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

Rename ScrollRoot to ClipScrollNode

Browse source 
ScrollRoot is an ever increasingly inaccurate name for this thing and
WebRender consistently uses ClipScrollNode nowadays. Stick with the
WebRender terminology to be consistent.
This commit is contained in:
Martin Robinson 2017-08-30 20:37:11 +02:00
parent ee46bc57ed
commit cedc7ebc53
4 changed files with 128 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

52
components/gfx/display_list/mod.rs
View file

@ -77,7 +77,7 @@ impl<'a> ScrollOffsetLookup<'a> {
None => return None,
};
let scroll_offset = self.full_offset_for_scroll_root(&clip_id);
let scroll_offset = self.full_offset_for_clip_scroll_node(&clip_id);
*point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
point.y - Au::from_f32_px(scroll_offset.y));
let frac_point = inv_transform.transform_point2d(&Point2D::new(point.x.to_f32_px(),
@ -93,18 +93,18 @@ impl<'a> ScrollOffsetLookup<'a> {
Some(sublookup)
}
fn add_scroll_root(&mut self, scroll_root: &ScrollRoot) {
self.parents.insert(scroll_root.id, scroll_root.parent_id);
fn add_clip_scroll_node(&mut self, clip_scroll_node: &ClipScrollNode) {
self.parents.insert(clip_scroll_node.id, clip_scroll_node.parent_id);
}
fn full_offset_for_scroll_root(&mut self, id: &ClipId) -> Vector2D<f32> {
fn full_offset_for_clip_scroll_node(&mut self, id: &ClipId) -> Vector2D<f32> {
if let Some(offset) = self.calculated_total_offsets.get(id) {
return *offset;
}
let parent_offset = if !id.is_root_scroll_node() {
let parent_id = *self.parents.get(id).unwrap();
self.full_offset_for_scroll_root(&parent_id)
self.full_offset_for_clip_scroll_node(&parent_id)
} else {
Vector2D::zero()
};
@ -160,8 +160,8 @@ impl DisplayList {
offset_lookup,
result);
}
&DisplayItem::DefineClip(ref item) => {
offset_lookup.add_scroll_root(&item.scroll_root);
&DisplayItem::DefineClipScrollNode(ref item) => {
offset_lookup.add_clip_scroll_node(&item.node);
}
&DisplayItem::PopStackingContext(_) => return,
&DisplayItem::Text(ref text) => {
@ -237,8 +237,8 @@ impl DisplayList {
result);
}
&DisplayItem::PopStackingContext(_) => return,
&DisplayItem::DefineClip(ref item) => {
offset_lookup.add_scroll_root(&item.scroll_root);
&DisplayItem::DefineClipScrollNode(ref item) => {
offset_lookup.add_clip_scroll_node(&item.node);
}
_ => {
if let Some(meta) = item.hit_test(*point, offset_lookup) {
@ -558,20 +558,20 @@ impl fmt::Debug for StackingContext {
}
#[derive(Clone, Debug, Deserialize, HeapSizeOf, Serialize)]
pub enum ScrollRootType {
pub enum ClipScrollNodeType {
ScrollFrame(ScrollSensitivity),
StickyFrame(StickyFrameInfo),
Clip,
}
/// Defines a stacking context.
/// Defines a clip scroll node.
#[derive(Clone, Debug, Deserialize, HeapSizeOf, Serialize)]
pub struct ScrollRoot {
pub struct ClipScrollNode {
/// The WebRender clip id of this scroll root based on the source of this clip
/// and information about the fragment.
pub id: ClipId,
/// The unique ID of the parent of this ScrollRoot.
/// The unique ID of the parent of this ClipScrollNode.
pub parent_id: ClipId,
/// The position of this scroll root's frame in the parent stacking context.
@ -580,15 +580,15 @@ pub struct ScrollRoot {
/// The rect of the contents that can be scrolled inside of the scroll root.
pub content_rect: Rect<Au>,
/// The type of this ScrollRoot.
pub root_type: ScrollRootType
/// The type of this ClipScrollNode.
pub node_type: ClipScrollNodeType,
}
impl ScrollRoot {
impl ClipScrollNode {
pub fn to_define_item(&self, pipeline_id: PipelineId) -> DisplayItem {
DisplayItem::DefineClip(box DefineClipItem {
DisplayItem::DefineClipScrollNode(box DefineClipScrollNodeItem {
base: BaseDisplayItem::empty(pipeline_id),
scroll_root: self.clone(),
node: self.clone(),
})
}
}
@ -610,7 +610,7 @@ pub enum DisplayItem {
Iframe(Box<IframeDisplayItem>),
PushStackingContext(Box<PushStackingContextItem>),
PopStackingContext(Box<PopStackingContextItem>),
DefineClip(Box<DefineClipItem>),
DefineClipScrollNode(Box<DefineClipScrollNodeItem>),
}
/// Information common to all display items.
@ -1215,12 +1215,12 @@ pub struct PopStackingContextItem {
/// Starts a group of items inside a particular scroll root.
#[derive(Clone, Deserialize, HeapSizeOf, Serialize)]
pub struct DefineClipItem {
pub struct DefineClipScrollNodeItem {
/// Fields common to all display items.
pub base: BaseDisplayItem,
/// The scroll root that this item starts.
pub scroll_root: ScrollRoot,
pub node: ClipScrollNode,
}
/// How a box shadow should be clipped.
@ -1252,7 +1252,7 @@ impl DisplayItem {
DisplayItem::Iframe(ref iframe) => &iframe.base,
DisplayItem::PushStackingContext(ref stacking_context) => &stacking_context.base,
DisplayItem::PopStackingContext(ref item) => &item.base,
DisplayItem::DefineClip(ref item) => &item.base,
DisplayItem::DefineClipScrollNode(ref item) => &item.base,
}
}
@ -1292,7 +1292,7 @@ impl DisplayItem {
// test elements with `border-radius`, for example.
let base_item = self.base();
let scroll_offset = offset_lookup.full_offset_for_scroll_root(&self.scroll_node_id());
let scroll_offset = offset_lookup.full_offset_for_clip_scroll_node(&self.scroll_node_id());
let point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
point.y - Au::from_f32_px(scroll_offset.y));
@ -1349,8 +1349,8 @@ impl fmt::Debug for DisplayItem {
return write!(f, "PopStackingContext({:?}", item.stacking_context_id);
}
if let DisplayItem::DefineClip(ref item) = *self {
return write!(f, "DefineClip({:?}", item.scroll_root);
if let DisplayItem::DefineClipScrollNode(ref item) = *self {
return write!(f, "DefineClipScrollNode({:?}", item.node);
}
write!(f, "{} @ {:?} {:?}",
@ -1377,7 +1377,7 @@ impl fmt::Debug for DisplayItem {
DisplayItem::Iframe(_) => "Iframe".to_owned(),
DisplayItem::PushStackingContext(_) |
DisplayItem::PopStackingContext(_) |
DisplayItem::DefineClip(_) => "".to_owned(),
DisplayItem::DefineClipScrollNode(_) => "".to_owned(),
},
self.bounds(),
self.base().local_clip

2
components/layout/block.rs
View file

@ -1680,7 +1680,7 @@ impl BlockFlow {
}
}
pub fn overflow_style_may_require_scroll_root(&self) -> bool {
pub fn overflow_style_may_require_clip_scroll_node(&self) -> bool {
match (self.fragment.style().get_box().overflow_x,
self.fragment.style().get_box().overflow_y) {
(overflow_x::T::auto, _) | (overflow_x::T::scroll, _) | (overflow_x::T::hidden, _) |

143
components/layout/display_list_builder.rs
View file

@ -18,19 +18,19 @@ use euclid::{Point2D, Rect, SideOffsets2D, Size2D, Transform3D, TypedSize2D};
use euclid::Vector2D;
use flex::FlexFlow;
use flow::{BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED};
use fnv::FnvHashMap;
use flow_ref::FlowRef;
use fnv::FnvHashMap;
use fragment::{CanvasFragmentSource, CoordinateSystem, Fragment, ImageFragmentInfo, ScannedTextFragmentInfo};
use fragment::{SpecificFragmentInfo, TruncatedFragmentInfo};
use gfx::display_list;
use gfx::display_list::{BLUR_INFLATION_FACTOR, BaseDisplayItem, BorderDetails, BorderDisplayItem};
use gfx::display_list::{BorderRadii, BoxShadowClipMode, BoxShadowDisplayItem, ClippingRegion};
use gfx::display_list::{DisplayItem, DisplayItemMetadata, DisplayList, DisplayListSection};
use gfx::display_list::{GradientDisplayItem, IframeDisplayItem, ImageBorder, ImageDisplayItem};
use gfx::display_list::{LineDisplayItem, NormalBorder, OpaqueNode, PushTextShadowDisplayItem};
use gfx::display_list::{PopTextShadowDisplayItem, RadialGradientDisplayItem, ScrollRoot};
use gfx::display_list::{ScrollRootType, SolidColorDisplayItem, StackingContext, StackingContextType};
use gfx::display_list::{TextDisplayItem, TextOrientation, WebRenderImageInfo};
use gfx::display_list::{BorderRadii, BoxShadowClipMode, BoxShadowDisplayItem, ClipScrollNode};
use gfx::display_list::{ClipScrollNodeType, ClippingRegion, DisplayItem, DisplayItemMetadata};
use gfx::display_list::{DisplayList, DisplayListSection, GradientDisplayItem, IframeDisplayItem};
use gfx::display_list::{ImageBorder, ImageDisplayItem, LineDisplayItem, NormalBorder, OpaqueNode};
use gfx::display_list::{PopTextShadowDisplayItem, PushTextShadowDisplayItem};
use gfx::display_list::{RadialGradientDisplayItem, SolidColorDisplayItem, StackingContext};
use gfx::display_list::{StackingContextType, TextDisplayItem, TextOrientation, WebRenderImageInfo};
use gfx_traits::{combine_id_with_fragment_type, FragmentType, StackingContextId};
use inline::{FIRST_FRAGMENT_OF_ELEMENT, InlineFlow, LAST_FRAGMENT_OF_ELEMENT};
use ipc_channel::ipc;
@ -143,14 +143,14 @@ fn get_cyclic<T>(arr: &[T], index: usize) -> &T {
#[derive(Debug)]
struct StackingContextInfo {
children: Vec<StackingContext>,
scroll_roots: Vec<ScrollRoot>,
clip_scroll_nodes: Vec<ClipScrollNode>,
}
impl StackingContextInfo {
fn new() -> StackingContextInfo {
StackingContextInfo {
children: Vec::new(),
scroll_roots: Vec::new(),
clip_scroll_nodes: Vec::new(),
}
}
@ -166,11 +166,11 @@ pub struct StackingContextCollectionState {
/// The root of the StackingContext tree.
pub root_stacking_context: StackingContext,
/// StackingContext and ScrollRoot children for each StackingContext.
/// StackingContext and ClipScrollNode children for each StackingContext.
stacking_context_info: FnvHashMap<StackingContextId, StackingContextInfo>,
/// A map establishing the parent child relationship of every ScrollRoot.
pub scroll_root_parents: FnvHashMap<ClipId, ClipId>,
/// A map establishing the parent child relationship of every ClipScrollNode.
pub clip_scroll_node_parents: FnvHashMap<ClipId, ClipId>,
/// The current stacking context id, used to keep track of state when building.
/// recursively building and processing the display list.
@ -207,7 +207,7 @@ impl StackingContextCollectionState {
pipeline_id: pipeline_id,
root_stacking_context: StackingContext::root(pipeline_id),
stacking_context_info: FnvHashMap::default(),
scroll_root_parents: FnvHashMap::default(),
clip_scroll_node_parents: FnvHashMap::default(),
current_stacking_context_id: StackingContextId::root(),
current_real_stacking_context_id: StackingContextId::root(),
current_clip_and_scroll_info: root_clip_info,
@ -227,20 +227,20 @@ impl StackingContextCollectionState {
info.children.push(stacking_context);
}
fn has_scroll_root(&mut self, id: ClipId) -> bool {
self.scroll_root_parents.contains_key(&id)
fn has_clip_scroll_node(&mut self, id: ClipId) -> bool {
self.clip_scroll_node_parents.contains_key(&id)
}
fn add_scroll_root(&mut self, scroll_root: ScrollRoot) {
fn add_clip_scroll_node(&mut self, clip_scroll_node: ClipScrollNode) {
// We want the scroll root to be defined before any possible item that could use it,
// so we make sure that it is added to the beginning of the parent "real" (non-pseudo)
// stacking context. This ensures that item reordering will not result in an item using
// the scroll root before it is defined.
self.scroll_root_parents.insert(scroll_root.id, scroll_root.parent_id);
self.clip_scroll_node_parents.insert(clip_scroll_node.id, clip_scroll_node.parent_id);
let info = self.stacking_context_info
.entry(self.current_real_stacking_context_id)
.or_insert(StackingContextInfo::new());
info.scroll_roots.push(scroll_root);
info.clip_scroll_nodes.push(clip_scroll_node);
}
}
@ -251,18 +251,18 @@ pub struct DisplayListBuildState<'a> {
/// The root of the StackingContext tree.
pub root_stacking_context: StackingContext,
/// StackingContext and ScrollRoot children for each StackingContext.
/// StackingContext and ClipScrollNode children for each StackingContext.
stacking_context_info: FnvHashMap<StackingContextId, StackingContextInfo>,
/// A map establishing the parent child relationship of every ScrollRoot.
pub scroll_root_parents: FnvHashMap<ClipId, ClipId>,
/// A map establishing the parent child relationship of every ClipScrollNode.
pub clip_scroll_node_parents: FnvHashMap<ClipId, ClipId>,
/// The items in this display list.
pub items: FnvHashMap<StackingContextId, Vec<DisplayItem>>,
/// Whether or not we are processing an element that establishes a scroll root, used
/// to determine what ScrollRoot to place backgrounds and borders into.
pub processing_scroll_root_element: bool,
/// Whether or not we are processing an element that establishes scrolling overflow. Used
/// to determine what ClipScrollNode to place backgrounds and borders into.
pub processing_scrolling_overflow_element: bool,
/// The current stacking context id, used to keep track of state when building.
/// recursively building and processing the display list.
@ -287,8 +287,8 @@ impl<'a> DisplayListBuildState<'a> {
root_stacking_context: state.root_stacking_context,
items: FnvHashMap::default(),
stacking_context_info: state.stacking_context_info,
scroll_root_parents: state.scroll_root_parents,
processing_scroll_root_element: false,
clip_scroll_node_parents: state.clip_scroll_node_parents,
processing_scrolling_overflow_element: false,
current_stacking_context_id: StackingContextId::root(),
current_clip_and_scroll_info: root_clip_info,
iframe_sizes: Vec::new(),
@ -300,19 +300,19 @@ impl<'a> DisplayListBuildState<'a> {
items.push(display_item);
}
fn parent_scroll_root_id(&self, scroll_root_id: ClipId) -> ClipId {
if scroll_root_id.is_root_scroll_node() {
return scroll_root_id;
fn parent_clip_scroll_node_id(&self, clip_scroll_node_id: ClipId) -> ClipId {
if clip_scroll_node_id.is_root_scroll_node() {
return clip_scroll_node_id;
}
debug_assert!(self.scroll_root_parents.contains_key(&scroll_root_id));
*self.scroll_root_parents.get(&scroll_root_id).unwrap()
debug_assert!(self.clip_scroll_node_parents.contains_key(&clip_scroll_node_id));
*self.clip_scroll_node_parents.get(&clip_scroll_node_id).unwrap()
}
fn is_background_or_border_of_scroll_root(&self, section: DisplayListSection) -> bool {
fn is_background_or_border_of_clip_scroll_node(&self, section: DisplayListSection) -> bool {
(section == DisplayListSection::BackgroundAndBorders ||
section == DisplayListSection::BlockBackgroundsAndBorders) &&
self.processing_scroll_root_element
self.processing_scrolling_overflow_element
}
fn create_base_display_item(&self,
@ -322,8 +322,8 @@ impl<'a> DisplayListBuildState<'a> {
cursor: Option<Cursor>,
section: DisplayListSection)
-> BaseDisplayItem {
let clip_and_scroll_info = if self.is_background_or_border_of_scroll_root(section) {
ClipAndScrollInfo::simple(self.parent_scroll_root_id(self.current_clip_and_scroll_info.scroll_node_id))
let clip_and_scroll_info = if self.is_background_or_border_of_clip_scroll_node(section) {
ClipAndScrollInfo::simple(self.parent_clip_scroll_node_id(self.current_clip_and_scroll_info.scroll_node_id))
} else {
self.current_clip_and_scroll_info
};
@ -365,12 +365,12 @@ impl<'a> DisplayListBuildState<'a> {
let pipeline_id = self.layout_context.id;
if stacking_context.context_type != StackingContextType::Real {
list.extend(info.scroll_roots.into_iter().map(|root| root.to_define_item(pipeline_id)));
list.extend(info.clip_scroll_nodes.into_iter().map(|root| root.to_define_item(pipeline_id)));
self.to_display_list_for_items(list, child_items, info.children);
} else {
let (push_item, pop_item) = stacking_context.to_display_list_items(pipeline_id);
list.push(push_item);
list.extend(info.scroll_roots.into_iter().map(|root| root.to_define_item(pipeline_id)));
list.extend(info.clip_scroll_nodes.into_iter().map(|root| root.to_define_item(pipeline_id)));
self.to_display_list_for_items(list, child_items, info.children);
list.push(pop_item);
}
@ -2330,13 +2330,13 @@ pub trait BlockFlowDisplayListBuilding {
stacking_context_type: BlockStackingContextType,
can_establish_containing_block: EstablishContainingBlock)
-> ClipAndScrollInfo;
fn setup_scroll_root_for_position(&mut self,
fn setup_clip_scroll_node_for_position(&mut self,
state: &mut StackingContextCollectionState,
border_box: &Rect<Au>);
fn setup_scroll_root_for_overflow(&mut self,
fn setup_clip_scroll_node_for_overflow(&mut self,
state: &mut StackingContextCollectionState,
border_box: &Rect<Au>);
fn setup_scroll_root_for_css_clip(&mut self,
fn setup_clip_scroll_node_for_css_clip(&mut self,
state: &mut StackingContextCollectionState,
preserved_state: &mut SavedStackingContextCollectionState,
stacking_relative_border_box: &Rect<Au>);
@ -2566,9 +2566,9 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
self.transform_clip_to_coordinate_space(state, preserved_state);
}
self.setup_scroll_root_for_position(state, &stacking_relative_border_box);
self.setup_scroll_root_for_overflow(state, &stacking_relative_border_box);
self.setup_scroll_root_for_css_clip(state, preserved_state, &stacking_relative_border_box);
self.setup_clip_scroll_node_for_position(state, &stacking_relative_border_box);
self.setup_clip_scroll_node_for_overflow(state, &stacking_relative_border_box);
self.setup_clip_scroll_node_for_css_clip(state, preserved_state, &stacking_relative_border_box);
self.base.clip = state.clip_stack.last().cloned().unwrap_or_else(max_rect);
// We keep track of our position so that any stickily positioned elements can
@ -2592,7 +2592,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
containing_clip_and_scroll_info
}
fn setup_scroll_root_for_position(&mut self,
fn setup_clip_scroll_node_for_position(&mut self,
state: &mut StackingContextCollectionState,
border_box: &Rect<Au>) {
if self.positioning() != position::T::sticky {
@ -2640,28 +2640,28 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
to_sticky_info(sticky_position.left,
to_max_offset(constraint_rect.max_x(), border_box_in_parent.max_x())));
let new_scroll_root_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
let new_clip_scroll_node_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
state.pipeline_id.to_webrender());
let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id;
state.add_scroll_root(
ScrollRoot {
id: new_scroll_root_id,
state.add_clip_scroll_node(
ClipScrollNode {
id: new_clip_scroll_node_id,
parent_id: parent_id,
clip: ClippingRegion::from_rect(border_box),
content_rect: Rect::zero(),
root_type: ScrollRootType::StickyFrame(sticky_frame_info),
node_type: ClipScrollNodeType::StickyFrame(sticky_frame_info),
},
);
let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_scroll_root_id);
let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_clip_scroll_node_id);
self.base.clip_and_scroll_info = Some(new_clip_and_scroll_info);
state.current_clip_and_scroll_info = new_clip_and_scroll_info;
}
fn setup_scroll_root_for_overflow(&mut self,
fn setup_clip_scroll_node_for_overflow(&mut self,
state: &mut StackingContextCollectionState,
border_box: &Rect<Au>) {
if !self.overflow_style_may_require_scroll_root() {
if !self.overflow_style_may_require_clip_scroll_node() {
return;
}
@ -2681,9 +2681,9 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
// If we already have a scroll root for this flow, just return. This can happen
// when fragments map to more than one flow, such as in the case of table
// wrappers. We just accept the first scroll root in that case.
let new_scroll_root_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
let new_clip_scroll_node_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
state.pipeline_id.to_webrender());
if state.has_scroll_root(new_scroll_root_id) {
if state.has_clip_scroll_node(new_clip_scroll_node_id) {
return;
}
@ -2705,24 +2705,24 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
let content_size = Size2D::new(content_size.x, content_size.y);
let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id;
state.add_scroll_root(
ScrollRoot {
id: new_scroll_root_id,
state.add_clip_scroll_node(
ClipScrollNode {
id: new_clip_scroll_node_id,
parent_id: parent_id,
clip: clip,
content_rect: Rect::new(content_box.origin, content_size),
root_type: ScrollRootType::ScrollFrame(sensitivity),
node_type: ClipScrollNodeType::ScrollFrame(sensitivity),
},
);
let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_scroll_root_id);
let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_clip_scroll_node_id);
self.base.clip_and_scroll_info = Some(new_clip_and_scroll_info);
state.current_clip_and_scroll_info = new_clip_and_scroll_info;
}
/// Adds a scroll root for a block to take the `clip` property into account
/// per CSS 2.1 § 11.1.2.
fn setup_scroll_root_for_css_clip(&mut self,
fn setup_clip_scroll_node_for_css_clip(&mut self,
state: &mut StackingContextCollectionState,
preserved_state: &mut SavedStackingContextCollectionState,
stacking_relative_border_box: &Rect<Au>) {
@ -2750,14 +2750,14 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
// We use the node id to create scroll roots for overflow properties, so we
// use the fragment address to do the same for CSS clipping.
// TODO(mrobinson): This should be more resilient while maintaining the space
// efficiency of ScrollRootId.
let new_scroll_root_id = ClipId::new(self.fragment.unique_id(IdType::CSSClip),
// efficiency of ClipScrollNode.
let new_clip_scroll_node_id = ClipId::new(self.fragment.unique_id(IdType::CSSClip),
state.pipeline_id.to_webrender());
// If we already have a scroll root for this flow, just return. This can happen
// when fragments map to more than one flow, such as in the case of table
// wrappers. We just accept the first scroll root in that case.
if state.has_scroll_root(new_scroll_root_id) {
if state.has_clip_scroll_node(new_clip_scroll_node_id) {
return;
}
@ -2765,17 +2765,18 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
preserved_state.push_clip(state, &clip_rect, self.positioning());
let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id;
state.add_scroll_root(
ScrollRoot {
id: new_scroll_root_id,
state.add_clip_scroll_node(
ClipScrollNode {
id: new_clip_scroll_node_id,
parent_id: parent_id,
clip: ClippingRegion::from_rect(&clip_rect),
content_rect: Rect::zero(), // content_rect isn't important for clips.
root_type: ScrollRootType::Clip,
node_type: ClipScrollNodeType::Clip,
},
);
let new_clip_and_scroll_info = ClipAndScrollInfo::new(new_scroll_root_id, new_scroll_root_id);
let new_clip_and_scroll_info = ClipAndScrollInfo::new(new_clip_scroll_node_id,
new_clip_scroll_node_id);
self.base.clip_and_scroll_info = Some(new_clip_and_scroll_info);
state.current_clip_and_scroll_info = new_clip_and_scroll_info;
}
@ -2850,7 +2851,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
DisplayListSection::BlockBackgroundsAndBorders
};
state.processing_scroll_root_element = self.has_scrolling_overflow();
state.processing_scrolling_overflow_element = self.has_scrolling_overflow();
// Add the box that starts the block context.
self.fragment
@ -2868,7 +2869,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
self.base.build_display_items_for_debugging_tint(state, self.fragment.node);
state.processing_scroll_root_element = false;
state.processing_scrolling_overflow_element = false;
}
}

28
components/layout/webrender_helpers.rs
View file

@ -9,8 +9,8 @@
use app_units::Au;
use euclid::{Point2D, Vector2D, Rect, SideOffsets2D, Size2D};
use gfx::display_list::{BorderDetails, BorderRadii, BoxShadowClipMode, ClippingRegion};
use gfx::display_list::{DisplayItem, DisplayList, DisplayListTraversal, ScrollRootType};
use gfx::display_list::{BorderDetails, BorderRadii, BoxShadowClipMode, ClipScrollNodeType};
use gfx::display_list::{ClippingRegion, DisplayItem, DisplayList, DisplayListTraversal};
use gfx::display_list::StackingContextType;
use msg::constellation_msg::PipelineId;
use style::computed_values::{image_rendering, mix_blend_mode, transform_style};
@ -488,27 +488,27 @@ impl WebRenderDisplayItemConverter for DisplayItem {
stacking_context.filters.to_filter_ops());
}
DisplayItem::PopStackingContext(_) => builder.pop_stacking_context(),
DisplayItem::DefineClip(ref item) => {
builder.push_clip_id(item.scroll_root.parent_id);
DisplayItem::DefineClipScrollNode(ref item) => {
builder.push_clip_id(item.node.parent_id);
let our_id = item.scroll_root.id;
let item_rect = item.scroll_root.clip.main.to_rectf();
let webrender_id = match item.scroll_root.root_type {
ScrollRootType::Clip => {
let our_id = item.node.id;
let item_rect = item.node.clip.main.to_rectf();
let webrender_id = match item.node.node_type {
ClipScrollNodeType::Clip => {
builder.define_clip(Some(our_id),
item_rect,
item.scroll_root.clip.get_complex_clips(),
item.node.clip.get_complex_clips(),
None)
}
ScrollRootType::ScrollFrame(scroll_sensitivity) => {
ClipScrollNodeType::ScrollFrame(scroll_sensitivity) => {
builder.define_scroll_frame(Some(our_id),
item.scroll_root.content_rect.to_rectf(),
item.scroll_root.clip.main.to_rectf(),
item.scroll_root.clip.get_complex_clips(),
item.node.content_rect.to_rectf(),
item.node.clip.main.to_rectf(),
item.node.clip.get_complex_clips(),
None,
scroll_sensitivity)
}
ScrollRootType::StickyFrame(sticky_frame_info) => {
ClipScrollNodeType::StickyFrame(sticky_frame_info) => {
builder.define_sticky_frame(Some(our_id), item_rect, sticky_frame_info)
}
};