mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-17 23:35:34 +00:00
Bug 1527325 - Refactor webrender_api includes r=gw,nical
Differential Revision: https://phabricator.services.mozilla.com/D19499 --HG-- extra : moz-landing-system : lando
This commit is contained in:
parent
2c76682892
commit
78eba476ed
@ -13,12 +13,13 @@ use std::os::raw::c_void;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::u32;
|
||||
use {BuiltDisplayList, BuiltDisplayListDescriptor, ColorF, DeviceIntPoint, DeviceIntRect};
|
||||
use {DeviceIntSize, ExternalScrollId, FontInstanceKey, FontInstanceOptions};
|
||||
use {FontInstancePlatformOptions, FontKey, FontVariation, GlyphDimensions, GlyphIndex, ImageData};
|
||||
use {ImageDescriptor, ItemTag, LayoutPoint, LayoutSize, LayoutTransform, LayoutVector2D};
|
||||
use {BlobDirtyRect, ImageDirtyRect, ImageKey, BlobImageKey, BlobImageData};
|
||||
use {NativeFontHandle, WorldPoint};
|
||||
// local imports
|
||||
use {display_item as di, font};
|
||||
use color::ColorF;
|
||||
use display_list::{BuiltDisplayList, BuiltDisplayListDescriptor};
|
||||
use image::{BlobImageData, BlobImageKey, ImageData, ImageDescriptor, ImageKey};
|
||||
use units::*;
|
||||
|
||||
|
||||
pub type TileSize = u16;
|
||||
/// Documents are rendered in the ascending order of their associated layer values.
|
||||
@ -33,9 +34,9 @@ pub enum ResourceUpdate {
|
||||
DeleteImage(ImageKey),
|
||||
SetBlobImageVisibleArea(BlobImageKey, DeviceIntRect),
|
||||
AddFont(AddFont),
|
||||
DeleteFont(FontKey),
|
||||
DeleteFont(font::FontKey),
|
||||
AddFontInstance(AddFontInstance),
|
||||
DeleteFontInstance(FontInstanceKey),
|
||||
DeleteFontInstance(font::FontInstanceKey),
|
||||
}
|
||||
|
||||
/// A Transaction is a group of commands to apply atomically to a document.
|
||||
@ -224,7 +225,7 @@ impl Transaction {
|
||||
pub fn scroll_node_with_id(
|
||||
&mut self,
|
||||
origin: LayoutPoint,
|
||||
id: ExternalScrollId,
|
||||
id: di::ExternalScrollId,
|
||||
clamp: ScrollClamping,
|
||||
) {
|
||||
self.frame_ops.push(FrameMsg::ScrollNodeWithId(origin, id, clamp));
|
||||
@ -380,28 +381,28 @@ impl Transaction {
|
||||
self.resource_updates.push(ResourceUpdate::SetBlobImageVisibleArea(key, area))
|
||||
}
|
||||
|
||||
pub fn add_raw_font(&mut self, key: FontKey, bytes: Vec<u8>, index: u32) {
|
||||
pub fn add_raw_font(&mut self, key: font::FontKey, bytes: Vec<u8>, index: u32) {
|
||||
self.resource_updates
|
||||
.push(ResourceUpdate::AddFont(AddFont::Raw(key, bytes, index)));
|
||||
}
|
||||
|
||||
pub fn add_native_font(&mut self, key: FontKey, native_handle: NativeFontHandle) {
|
||||
pub fn add_native_font(&mut self, key: font::FontKey, native_handle: font::NativeFontHandle) {
|
||||
self.resource_updates
|
||||
.push(ResourceUpdate::AddFont(AddFont::Native(key, native_handle)));
|
||||
}
|
||||
|
||||
pub fn delete_font(&mut self, key: FontKey) {
|
||||
pub fn delete_font(&mut self, key: font::FontKey) {
|
||||
self.resource_updates.push(ResourceUpdate::DeleteFont(key));
|
||||
}
|
||||
|
||||
pub fn add_font_instance(
|
||||
&mut self,
|
||||
key: FontInstanceKey,
|
||||
font_key: FontKey,
|
||||
key: font::FontInstanceKey,
|
||||
font_key: font::FontKey,
|
||||
glyph_size: Au,
|
||||
options: Option<FontInstanceOptions>,
|
||||
platform_options: Option<FontInstancePlatformOptions>,
|
||||
variations: Vec<FontVariation>,
|
||||
options: Option<font::FontInstanceOptions>,
|
||||
platform_options: Option<font::FontInstancePlatformOptions>,
|
||||
variations: Vec<font::FontVariation>,
|
||||
) {
|
||||
self.resource_updates
|
||||
.push(ResourceUpdate::AddFontInstance(AddFontInstance {
|
||||
@ -414,7 +415,7 @@ impl Transaction {
|
||||
}));
|
||||
}
|
||||
|
||||
pub fn delete_font_instance(&mut self, key: FontInstanceKey) {
|
||||
pub fn delete_font_instance(&mut self, key: font::FontInstanceKey) {
|
||||
self.resource_updates.push(ResourceUpdate::DeleteFontInstance(key));
|
||||
}
|
||||
|
||||
@ -529,11 +530,11 @@ pub struct UpdateBlobImage {
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum AddFont {
|
||||
Raw(
|
||||
FontKey,
|
||||
font::FontKey,
|
||||
#[serde(with = "serde_bytes")] Vec<u8>,
|
||||
u32
|
||||
),
|
||||
Native(FontKey, NativeFontHandle),
|
||||
Native(font::FontKey, font::NativeFontHandle),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
|
||||
@ -542,7 +543,7 @@ pub struct HitTestItem {
|
||||
pub pipeline: PipelineId,
|
||||
|
||||
/// The tag of the hit display item.
|
||||
pub tag: ItemTag,
|
||||
pub tag: di::ItemTag,
|
||||
|
||||
/// The hit point in the coordinate space of the "viewport" of the display item. The
|
||||
/// viewport is the scroll node formed by the root reference frame of the display item's
|
||||
@ -569,12 +570,12 @@ bitflags! {
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct AddFontInstance {
|
||||
pub key: FontInstanceKey,
|
||||
pub font_key: FontKey,
|
||||
pub key: font::FontInstanceKey,
|
||||
pub font_key: font::FontKey,
|
||||
pub glyph_size: Au,
|
||||
pub options: Option<FontInstanceOptions>,
|
||||
pub platform_options: Option<FontInstancePlatformOptions>,
|
||||
pub variations: Vec<FontVariation>,
|
||||
pub options: Option<font::FontInstanceOptions>,
|
||||
pub platform_options: Option<font::FontInstancePlatformOptions>,
|
||||
pub variations: Vec<font::FontVariation>,
|
||||
}
|
||||
|
||||
// Frame messages affect building the scene.
|
||||
@ -608,7 +609,7 @@ pub enum FrameMsg {
|
||||
SetPan(DeviceIntPoint),
|
||||
EnableFrameOutput(PipelineId, bool),
|
||||
Scroll(ScrollLocation, WorldPoint),
|
||||
ScrollNodeWithId(LayoutPoint, ExternalScrollId, ScrollClamping),
|
||||
ScrollNodeWithId(LayoutPoint, di::ExternalScrollId, ScrollClamping),
|
||||
GetScrollNodeState(MsgSender<Vec<ScrollNodeState>>),
|
||||
UpdateDynamicProperties(DynamicProperties),
|
||||
AppendDynamicProperties(DynamicProperties),
|
||||
@ -715,12 +716,12 @@ pub enum ApiMsg {
|
||||
UpdateResources(Vec<ResourceUpdate>),
|
||||
/// Gets the glyph dimensions
|
||||
GetGlyphDimensions(
|
||||
FontInstanceKey,
|
||||
Vec<GlyphIndex>,
|
||||
MsgSender<Vec<Option<GlyphDimensions>>>,
|
||||
font::FontInstanceKey,
|
||||
Vec<font::GlyphIndex>,
|
||||
MsgSender<Vec<Option<font::GlyphDimensions>>>,
|
||||
),
|
||||
/// Gets the glyph indices from a string
|
||||
GetGlyphIndices(FontKey, String, MsgSender<Vec<Option<u32>>>),
|
||||
GetGlyphIndices(font::FontKey, String, MsgSender<Vec<Option<u32>>>),
|
||||
/// Adds a new document namespace.
|
||||
CloneApi(MsgSender<IdNamespace>),
|
||||
/// Adds a new document namespace.
|
||||
@ -1059,14 +1060,14 @@ impl RenderApi {
|
||||
self.api_sender.send(msg).unwrap();
|
||||
}
|
||||
|
||||
pub fn generate_font_key(&self) -> FontKey {
|
||||
pub fn generate_font_key(&self) -> font::FontKey {
|
||||
let new_id = self.next_unique_id();
|
||||
FontKey::new(self.namespace_id, new_id)
|
||||
font::FontKey::new(self.namespace_id, new_id)
|
||||
}
|
||||
|
||||
pub fn generate_font_instance_key(&self) -> FontInstanceKey {
|
||||
pub fn generate_font_instance_key(&self) -> font::FontInstanceKey {
|
||||
let new_id = self.next_unique_id();
|
||||
FontInstanceKey::new(self.namespace_id, new_id)
|
||||
font::FontInstanceKey::new(self.namespace_id, new_id)
|
||||
}
|
||||
|
||||
/// Gets the dimensions for the supplied glyph keys
|
||||
@ -1076,9 +1077,9 @@ impl RenderApi {
|
||||
/// This means that glyph dimensions e.g. for spaces (' ') will mostly be None.
|
||||
pub fn get_glyph_dimensions(
|
||||
&self,
|
||||
font: FontInstanceKey,
|
||||
glyph_indices: Vec<GlyphIndex>,
|
||||
) -> Vec<Option<GlyphDimensions>> {
|
||||
font: font::FontInstanceKey,
|
||||
glyph_indices: Vec<font::GlyphIndex>,
|
||||
) -> Vec<Option<font::GlyphDimensions>> {
|
||||
let (tx, rx) = channel::msg_channel().unwrap();
|
||||
let msg = ApiMsg::GetGlyphDimensions(font, glyph_indices, tx);
|
||||
self.api_sender.send(msg).unwrap();
|
||||
@ -1087,7 +1088,7 @@ impl RenderApi {
|
||||
|
||||
/// Gets the glyph indices for the supplied string. These
|
||||
/// can be used to construct GlyphKeys.
|
||||
pub fn get_glyph_indices(&self, font_key: FontKey, text: &str) -> Vec<Option<u32>> {
|
||||
pub fn get_glyph_indices(&self, font_key: font::FontKey, text: &str) -> Vec<Option<u32>> {
|
||||
let (tx, rx) = channel::msg_channel().unwrap();
|
||||
let msg = ApiMsg::GetGlyphIndices(font_key, text.to_string(), tx);
|
||||
self.api_sender.send(msg).unwrap();
|
||||
@ -1292,7 +1293,7 @@ impl Drop for RenderApi {
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct ScrollNodeState {
|
||||
pub id: ExternalScrollId,
|
||||
pub id: di::ExternalScrollId,
|
||||
pub scroll_offset: LayoutVector2D,
|
||||
}
|
||||
|
||||
@ -1312,7 +1313,7 @@ pub struct ZoomFactor(f32);
|
||||
|
||||
impl ZoomFactor {
|
||||
/// Construct a new zoom factor.
|
||||
pub fn new(scale: f32) -> ZoomFactor {
|
||||
pub fn new(scale: f32) -> Self {
|
||||
ZoomFactor(scale)
|
||||
}
|
||||
|
||||
|
@ -2,14 +2,14 @@
|
||||
* 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/. */
|
||||
|
||||
#[cfg(any(feature = "serialize", feature = "deserialize"))]
|
||||
use GlyphInstance;
|
||||
use euclid::{SideOffsets2D, TypedRect};
|
||||
use std::ops::Not;
|
||||
use {ColorF, FontInstanceKey, GlyphOptions, ImageKey, LayoutPixel, LayoutPoint};
|
||||
use {LayoutRect, LayoutSize, LayoutTransform, LayoutVector2D, PipelineId, PropertyBinding};
|
||||
use LayoutSideOffsets;
|
||||
use image::ColorDepth;
|
||||
// local imports
|
||||
use font;
|
||||
use api::{PipelineId, PropertyBinding};
|
||||
use color::ColorF;
|
||||
use image::{ColorDepth, ImageKey};
|
||||
use units::*;
|
||||
|
||||
// Maximum blur radius.
|
||||
// Taken from nsCSSRendering.cpp in Gecko.
|
||||
@ -143,7 +143,7 @@ pub enum CompletelySpecificDisplayItem {
|
||||
Rectangle(RectangleDisplayItem),
|
||||
ClearRectangle,
|
||||
Line(LineDisplayItem),
|
||||
Text(TextDisplayItem, Vec<GlyphInstance>),
|
||||
Text(TextDisplayItem, Vec<font::GlyphInstance>),
|
||||
Image(ImageDisplayItem),
|
||||
YuvImage(YuvImageDisplayItem),
|
||||
Border(BorderDisplayItem),
|
||||
@ -264,10 +264,10 @@ pub enum LineStyle {
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub struct TextDisplayItem {
|
||||
pub font_key: FontInstanceKey,
|
||||
pub font_key: font::FontInstanceKey,
|
||||
pub color: ColorF,
|
||||
pub glyph_options: Option<GlyphOptions>,
|
||||
} // IMPLICIT: glyphs: Vec<GlyphInstance>
|
||||
pub glyph_options: Option<font::GlyphOptions>,
|
||||
} // IMPLICIT: glyphs: Vec<font::GlyphInstance>
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
|
||||
pub struct NormalBorder {
|
||||
|
@ -14,19 +14,15 @@ use std::marker::PhantomData;
|
||||
use std::ops::Range;
|
||||
use std::{io, mem, ptr, slice};
|
||||
use time::precise_time_ns;
|
||||
use {AlphaType, BorderDetails, BorderDisplayItem, BorderRadius, BoxShadowClipMode, CacheMarkerDisplayItem};
|
||||
use {BoxShadowDisplayItem, ClipChainId, ClipChainItem, ClipDisplayItem, ClipId};
|
||||
use {ColorF, ComplexClipRegion, DisplayItem, ExtendMode, ExternalScrollId, FilterOp};
|
||||
use {FontInstanceKey, GlyphInstance, GlyphOptions, RasterSpace, Gradient, GradientBuilder};
|
||||
use {GradientDisplayItem, GradientStop, IframeDisplayItem, ImageDisplayItem, ImageKey, ImageMask};
|
||||
use {ImageRendering, LayoutPoint, LayoutPrimitiveInfo, LayoutRect, LayoutSideOffsets, LayoutSize};
|
||||
use {LayoutTransform, LayoutVector2D, LineDisplayItem, LineOrientation, LineStyle, MixBlendMode};
|
||||
use {PipelineId, PropertyBinding, ReferenceFrameDisplayListItem};
|
||||
use {PushStackingContextDisplayItem, RadialGradient, RadialGradientDisplayItem};
|
||||
use {RectangleDisplayItem, ReferenceFrame, ReferenceFrameKind, ScrollFrameDisplayItem, ScrollSensitivity};
|
||||
use {SerializedDisplayItem, Shadow, SpaceAndClipInfo, SpatialId, SpecificDisplayItem};
|
||||
use {StackingContext, StickyFrameDisplayItem, StickyOffsetBounds};
|
||||
use {TextDisplayItem, TransformStyle, YuvColorSpace, YuvData, YuvImageDisplayItem, ColorDepth};
|
||||
// local imports
|
||||
use display_item as di;
|
||||
use api::{PipelineId, PropertyBinding};
|
||||
use gradient_builder::GradientBuilder;
|
||||
use color::ColorF;
|
||||
use font::{FontInstanceKey, GlyphInstance, GlyphOptions};
|
||||
use image::{ColorDepth, ImageKey};
|
||||
use units::*;
|
||||
|
||||
|
||||
// We don't want to push a long text-run. If a text-run is too long, split it into several parts.
|
||||
// This needs to be set to (renderer::MAX_VERTEX_TEXTURE_WIDTH - VECS_PER_TEXT_RUN) * 2
|
||||
@ -95,12 +91,12 @@ pub struct BuiltDisplayListDescriptor {
|
||||
pub struct BuiltDisplayListIter<'a> {
|
||||
list: &'a BuiltDisplayList,
|
||||
data: &'a [u8],
|
||||
cur_item: DisplayItem,
|
||||
cur_stops: ItemRange<GradientStop>,
|
||||
cur_item: di::DisplayItem,
|
||||
cur_stops: ItemRange<di::GradientStop>,
|
||||
cur_glyphs: ItemRange<GlyphInstance>,
|
||||
cur_filters: ItemRange<FilterOp>,
|
||||
cur_clip_chain_items: ItemRange<ClipId>,
|
||||
cur_complex_clip: (ItemRange<ComplexClipRegion>, usize),
|
||||
cur_filters: ItemRange<di::FilterOp>,
|
||||
cur_clip_chain_items: ItemRange<di::ClipId>,
|
||||
cur_complex_clip: (ItemRange<di::ComplexClipRegion>, usize),
|
||||
peeking: Peek,
|
||||
}
|
||||
|
||||
@ -210,11 +206,11 @@ impl<'a> BuiltDisplayListIter<'a> {
|
||||
BuiltDisplayListIter {
|
||||
list,
|
||||
data,
|
||||
cur_item: DisplayItem {
|
||||
cur_item: di::DisplayItem {
|
||||
// Dummy data, will be overwritten by `next`
|
||||
item: SpecificDisplayItem::PopStackingContext,
|
||||
layout: LayoutPrimitiveInfo::new(LayoutRect::zero()),
|
||||
space_and_clip: SpaceAndClipInfo::root_scroll(PipelineId::dummy())
|
||||
item: di::SpecificDisplayItem::PopStackingContext,
|
||||
layout: di::LayoutPrimitiveInfo::new(LayoutRect::zero()),
|
||||
space_and_clip: di::SpaceAndClipInfo::root_scroll(PipelineId::dummy())
|
||||
},
|
||||
cur_stops: ItemRange::default(),
|
||||
cur_glyphs: ItemRange::default(),
|
||||
@ -278,16 +274,16 @@ impl<'a> BuiltDisplayListIter<'a> {
|
||||
|
||||
match self.cur_item.item {
|
||||
SetGradientStops => {
|
||||
self.cur_stops = skip_slice::<GradientStop>(self.list, &mut self.data).0;
|
||||
self.cur_stops = skip_slice::<di::GradientStop>(self.list, &mut self.data).0;
|
||||
}
|
||||
ClipChain(_) => {
|
||||
self.cur_clip_chain_items = skip_slice::<ClipId>(self.list, &mut self.data).0;
|
||||
self.cur_clip_chain_items = skip_slice::<di::ClipId>(self.list, &mut self.data).0;
|
||||
}
|
||||
Clip(_) | ScrollFrame(_) => {
|
||||
self.cur_complex_clip = self.skip_slice::<ComplexClipRegion>()
|
||||
self.cur_complex_clip = self.skip_slice::<di::ComplexClipRegion>()
|
||||
}
|
||||
Text(_) => self.cur_glyphs = self.skip_slice::<GlyphInstance>().0,
|
||||
PushStackingContext(_) => self.cur_filters = self.skip_slice::<FilterOp>().0,
|
||||
PushStackingContext(_) => self.cur_filters = self.skip_slice::<di::FilterOp>().0,
|
||||
_ => { /* do nothing */ }
|
||||
}
|
||||
|
||||
@ -304,9 +300,9 @@ impl<'a> BuiltDisplayListIter<'a> {
|
||||
|
||||
pub fn starting_stacking_context(
|
||||
&mut self,
|
||||
) -> Option<(StackingContext, LayoutRect, ItemRange<FilterOp>)> {
|
||||
) -> Option<(di::StackingContext, LayoutRect, ItemRange<di::FilterOp>)> {
|
||||
self.next().and_then(|item| match *item.item() {
|
||||
SpecificDisplayItem::PushStackingContext(ref specific_item) => Some((
|
||||
di::SpecificDisplayItem::PushStackingContext(ref specific_item) => Some((
|
||||
specific_item.stacking_context,
|
||||
item.rect(),
|
||||
item.filters(),
|
||||
@ -319,9 +315,9 @@ impl<'a> BuiltDisplayListIter<'a> {
|
||||
let mut depth = 0;
|
||||
while let Some(item) = self.next() {
|
||||
match *item.item() {
|
||||
SpecificDisplayItem::PushStackingContext(..) => depth += 1,
|
||||
SpecificDisplayItem::PopStackingContext if depth == 0 => return,
|
||||
SpecificDisplayItem::PopStackingContext => depth -= 1,
|
||||
di::SpecificDisplayItem::PushStackingContext(..) => depth += 1,
|
||||
di::SpecificDisplayItem::PopStackingContext if depth == 0 => return,
|
||||
di::SpecificDisplayItem::PopStackingContext => depth -= 1,
|
||||
_ => {}
|
||||
}
|
||||
debug_assert!(depth >= 0);
|
||||
@ -330,7 +326,7 @@ impl<'a> BuiltDisplayListIter<'a> {
|
||||
|
||||
pub fn current_stacking_context_empty(&mut self) -> bool {
|
||||
match self.peek() {
|
||||
Some(item) => *item.item() == SpecificDisplayItem::PopStackingContext,
|
||||
Some(item) => *item.item() == di::SpecificDisplayItem::PopStackingContext,
|
||||
None => true,
|
||||
}
|
||||
}
|
||||
@ -347,7 +343,7 @@ impl<'a> BuiltDisplayListIter<'a> {
|
||||
|
||||
// Some of these might just become ItemRanges
|
||||
impl<'a, 'b> DisplayItemRef<'a, 'b> {
|
||||
pub fn display_item(&self) -> &DisplayItem {
|
||||
pub fn display_item(&self) -> &di::DisplayItem {
|
||||
&self.iter.cur_item
|
||||
}
|
||||
|
||||
@ -355,9 +351,9 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
|
||||
self.iter.cur_item.layout.rect
|
||||
}
|
||||
|
||||
pub fn get_layout_primitive_info(&self, offset: &LayoutVector2D) -> LayoutPrimitiveInfo {
|
||||
pub fn get_layout_primitive_info(&self, offset: &LayoutVector2D) -> di::LayoutPrimitiveInfo {
|
||||
let layout = self.iter.cur_item.layout;
|
||||
LayoutPrimitiveInfo {
|
||||
di::LayoutPrimitiveInfo {
|
||||
rect: layout.rect.translate(offset),
|
||||
clip_rect: layout.clip_rect.translate(offset),
|
||||
is_backface_visible: layout.is_backface_visible,
|
||||
@ -369,19 +365,19 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
|
||||
&self.iter.cur_item.layout.clip_rect
|
||||
}
|
||||
|
||||
pub fn space_and_clip_info(&self) -> &SpaceAndClipInfo {
|
||||
pub fn space_and_clip_info(&self) -> &di::SpaceAndClipInfo {
|
||||
&self.iter.cur_item.space_and_clip
|
||||
}
|
||||
|
||||
pub fn item(&self) -> &SpecificDisplayItem {
|
||||
pub fn item(&self) -> &di::SpecificDisplayItem {
|
||||
&self.iter.cur_item.item
|
||||
}
|
||||
|
||||
pub fn complex_clip(&self) -> (ItemRange<ComplexClipRegion>, usize) {
|
||||
pub fn complex_clip(&self) -> (ItemRange<di::ComplexClipRegion>, usize) {
|
||||
self.iter.cur_complex_clip
|
||||
}
|
||||
|
||||
pub fn gradient_stops(&self) -> ItemRange<GradientStop> {
|
||||
pub fn gradient_stops(&self) -> ItemRange<di::GradientStop> {
|
||||
self.iter.cur_stops
|
||||
}
|
||||
|
||||
@ -389,11 +385,11 @@ impl<'a, 'b> DisplayItemRef<'a, 'b> {
|
||||
self.iter.cur_glyphs
|
||||
}
|
||||
|
||||
pub fn filters(&self) -> ItemRange<FilterOp> {
|
||||
pub fn filters(&self) -> ItemRange<di::FilterOp> {
|
||||
self.iter.cur_filters
|
||||
}
|
||||
|
||||
pub fn clip_chain_items(&self) -> ItemRange<ClipId> {
|
||||
pub fn clip_chain_items(&self) -> ItemRange<di::ClipId> {
|
||||
self.iter.cur_clip_chain_items
|
||||
}
|
||||
|
||||
@ -462,47 +458,47 @@ impl Serialize for BuiltDisplayList {
|
||||
let display_item = item.display_item();
|
||||
let serial_di = GenericDisplayItem {
|
||||
item: match display_item.item {
|
||||
SpecificDisplayItem::Clip(v) => Clip(
|
||||
di::SpecificDisplayItem::Clip(v) => Clip(
|
||||
v,
|
||||
item.iter.list.get(item.iter.cur_complex_clip.0).collect()
|
||||
),
|
||||
SpecificDisplayItem::ClipChain(v) => ClipChain(
|
||||
di::SpecificDisplayItem::ClipChain(v) => ClipChain(
|
||||
v,
|
||||
item.iter.list.get(item.iter.cur_clip_chain_items).collect(),
|
||||
),
|
||||
SpecificDisplayItem::ScrollFrame(v) => ScrollFrame(
|
||||
di::SpecificDisplayItem::ScrollFrame(v) => ScrollFrame(
|
||||
v,
|
||||
item.iter.list.get(item.iter.cur_complex_clip.0).collect()
|
||||
),
|
||||
SpecificDisplayItem::StickyFrame(v) => StickyFrame(v),
|
||||
SpecificDisplayItem::Rectangle(v) => Rectangle(v),
|
||||
SpecificDisplayItem::ClearRectangle => ClearRectangle,
|
||||
SpecificDisplayItem::Line(v) => Line(v),
|
||||
SpecificDisplayItem::Text(v) => Text(
|
||||
di::SpecificDisplayItem::StickyFrame(v) => StickyFrame(v),
|
||||
di::SpecificDisplayItem::Rectangle(v) => Rectangle(v),
|
||||
di::SpecificDisplayItem::ClearRectangle => ClearRectangle,
|
||||
di::SpecificDisplayItem::Line(v) => Line(v),
|
||||
di::SpecificDisplayItem::Text(v) => Text(
|
||||
v,
|
||||
item.iter.list.get(item.iter.cur_glyphs).collect()
|
||||
),
|
||||
SpecificDisplayItem::Image(v) => Image(v),
|
||||
SpecificDisplayItem::YuvImage(v) => YuvImage(v),
|
||||
SpecificDisplayItem::Border(v) => Border(v),
|
||||
SpecificDisplayItem::BoxShadow(v) => BoxShadow(v),
|
||||
SpecificDisplayItem::Gradient(v) => Gradient(v),
|
||||
SpecificDisplayItem::RadialGradient(v) => RadialGradient(v),
|
||||
SpecificDisplayItem::Iframe(v) => Iframe(v),
|
||||
SpecificDisplayItem::PushReferenceFrame(v) => PushReferenceFrame(v),
|
||||
SpecificDisplayItem::PopReferenceFrame => PopReferenceFrame,
|
||||
SpecificDisplayItem::PushStackingContext(v) => PushStackingContext(
|
||||
di::SpecificDisplayItem::Image(v) => Image(v),
|
||||
di::SpecificDisplayItem::YuvImage(v) => YuvImage(v),
|
||||
di::SpecificDisplayItem::Border(v) => Border(v),
|
||||
di::SpecificDisplayItem::BoxShadow(v) => BoxShadow(v),
|
||||
di::SpecificDisplayItem::Gradient(v) => Gradient(v),
|
||||
di::SpecificDisplayItem::RadialGradient(v) => RadialGradient(v),
|
||||
di::SpecificDisplayItem::Iframe(v) => Iframe(v),
|
||||
di::SpecificDisplayItem::PushReferenceFrame(v) => PushReferenceFrame(v),
|
||||
di::SpecificDisplayItem::PopReferenceFrame => PopReferenceFrame,
|
||||
di::SpecificDisplayItem::PushStackingContext(v) => PushStackingContext(
|
||||
v,
|
||||
item.iter.list.get(item.iter.cur_filters).collect()
|
||||
),
|
||||
SpecificDisplayItem::PopStackingContext => PopStackingContext,
|
||||
SpecificDisplayItem::SetGradientStops => SetGradientStops(
|
||||
di::SpecificDisplayItem::PopStackingContext => PopStackingContext,
|
||||
di::SpecificDisplayItem::SetGradientStops => SetGradientStops(
|
||||
item.iter.list.get(item.iter.cur_stops).collect()
|
||||
),
|
||||
SpecificDisplayItem::PushShadow(v) => PushShadow(v),
|
||||
SpecificDisplayItem::PopAllShadows => PopAllShadows,
|
||||
SpecificDisplayItem::PushCacheMarker(m) => PushCacheMarker(m),
|
||||
SpecificDisplayItem::PopCacheMarker => PopCacheMarker,
|
||||
di::SpecificDisplayItem::PushShadow(v) => PushShadow(v),
|
||||
di::SpecificDisplayItem::PopAllShadows => PopAllShadows,
|
||||
di::SpecificDisplayItem::PushCacheMarker(m) => PushCacheMarker(m),
|
||||
di::SpecificDisplayItem::PopCacheMarker => PopCacheMarker,
|
||||
},
|
||||
layout: display_item.layout,
|
||||
space_and_clip: display_item.space_and_clip,
|
||||
@ -534,63 +530,63 @@ impl<'de> Deserialize<'de> for BuiltDisplayList {
|
||||
let mut total_clip_nodes = FIRST_CLIP_NODE_INDEX;
|
||||
let mut total_spatial_nodes = FIRST_SPATIAL_NODE_INDEX;
|
||||
for complete in list {
|
||||
let item = DisplayItem {
|
||||
let item = di::DisplayItem {
|
||||
item: match complete.item {
|
||||
Clip(specific_item, complex_clips) => {
|
||||
total_clip_nodes += 1;
|
||||
DisplayListBuilder::push_iter_impl(&mut temp, complex_clips);
|
||||
SpecificDisplayItem::Clip(specific_item)
|
||||
di::SpecificDisplayItem::Clip(specific_item)
|
||||
},
|
||||
ClipChain(specific_item, clip_chain_ids) => {
|
||||
DisplayListBuilder::push_iter_impl(&mut temp, clip_chain_ids);
|
||||
SpecificDisplayItem::ClipChain(specific_item)
|
||||
di::SpecificDisplayItem::ClipChain(specific_item)
|
||||
}
|
||||
ScrollFrame(specific_item, complex_clips) => {
|
||||
total_spatial_nodes += 1;
|
||||
total_clip_nodes += 1;
|
||||
DisplayListBuilder::push_iter_impl(&mut temp, complex_clips);
|
||||
SpecificDisplayItem::ScrollFrame(specific_item)
|
||||
di::SpecificDisplayItem::ScrollFrame(specific_item)
|
||||
}
|
||||
StickyFrame(specific_item) => {
|
||||
total_spatial_nodes += 1;
|
||||
SpecificDisplayItem::StickyFrame(specific_item)
|
||||
di::SpecificDisplayItem::StickyFrame(specific_item)
|
||||
}
|
||||
Rectangle(specific_item) => SpecificDisplayItem::Rectangle(specific_item),
|
||||
ClearRectangle => SpecificDisplayItem::ClearRectangle,
|
||||
Line(specific_item) => SpecificDisplayItem::Line(specific_item),
|
||||
Rectangle(specific_item) => di::SpecificDisplayItem::Rectangle(specific_item),
|
||||
ClearRectangle => di::SpecificDisplayItem::ClearRectangle,
|
||||
Line(specific_item) => di::SpecificDisplayItem::Line(specific_item),
|
||||
Text(specific_item, glyphs) => {
|
||||
DisplayListBuilder::push_iter_impl(&mut temp, glyphs);
|
||||
SpecificDisplayItem::Text(specific_item)
|
||||
di::SpecificDisplayItem::Text(specific_item)
|
||||
},
|
||||
Image(specific_item) => SpecificDisplayItem::Image(specific_item),
|
||||
YuvImage(specific_item) => SpecificDisplayItem::YuvImage(specific_item),
|
||||
Border(specific_item) => SpecificDisplayItem::Border(specific_item),
|
||||
BoxShadow(specific_item) => SpecificDisplayItem::BoxShadow(specific_item),
|
||||
Gradient(specific_item) => SpecificDisplayItem::Gradient(specific_item),
|
||||
Image(specific_item) => di::SpecificDisplayItem::Image(specific_item),
|
||||
YuvImage(specific_item) => di::SpecificDisplayItem::YuvImage(specific_item),
|
||||
Border(specific_item) => di::SpecificDisplayItem::Border(specific_item),
|
||||
BoxShadow(specific_item) => di::SpecificDisplayItem::BoxShadow(specific_item),
|
||||
Gradient(specific_item) => di::SpecificDisplayItem::Gradient(specific_item),
|
||||
RadialGradient(specific_item) =>
|
||||
SpecificDisplayItem::RadialGradient(specific_item),
|
||||
di::SpecificDisplayItem::RadialGradient(specific_item),
|
||||
Iframe(specific_item) => {
|
||||
total_clip_nodes += 1;
|
||||
SpecificDisplayItem::Iframe(specific_item)
|
||||
di::SpecificDisplayItem::Iframe(specific_item)
|
||||
}
|
||||
PushReferenceFrame(v) => {
|
||||
total_spatial_nodes += 1;
|
||||
SpecificDisplayItem::PushReferenceFrame(v)
|
||||
di::SpecificDisplayItem::PushReferenceFrame(v)
|
||||
}
|
||||
PopReferenceFrame => SpecificDisplayItem::PopReferenceFrame,
|
||||
PopReferenceFrame => di::SpecificDisplayItem::PopReferenceFrame,
|
||||
PushStackingContext(specific_item, filters) => {
|
||||
DisplayListBuilder::push_iter_impl(&mut temp, filters);
|
||||
SpecificDisplayItem::PushStackingContext(specific_item)
|
||||
di::SpecificDisplayItem::PushStackingContext(specific_item)
|
||||
},
|
||||
PopStackingContext => SpecificDisplayItem::PopStackingContext,
|
||||
PopStackingContext => di::SpecificDisplayItem::PopStackingContext,
|
||||
SetGradientStops(stops) => {
|
||||
DisplayListBuilder::push_iter_impl(&mut temp, stops);
|
||||
SpecificDisplayItem::SetGradientStops
|
||||
di::SpecificDisplayItem::SetGradientStops
|
||||
},
|
||||
PushShadow(specific_item) => SpecificDisplayItem::PushShadow(specific_item),
|
||||
PopAllShadows => SpecificDisplayItem::PopAllShadows,
|
||||
PushCacheMarker(marker) => SpecificDisplayItem::PushCacheMarker(marker),
|
||||
PopCacheMarker => SpecificDisplayItem::PopCacheMarker,
|
||||
PushShadow(specific_item) => di::SpecificDisplayItem::PushShadow(specific_item),
|
||||
PopAllShadows => di::SpecificDisplayItem::PopAllShadows,
|
||||
PushCacheMarker(marker) => di::SpecificDisplayItem::PushCacheMarker(marker),
|
||||
PopCacheMarker => di::SpecificDisplayItem::PopCacheMarker,
|
||||
},
|
||||
layout: complete.layout,
|
||||
space_and_clip: complete.space_and_clip,
|
||||
@ -964,13 +960,13 @@ impl DisplayListBuilder {
|
||||
#[inline]
|
||||
pub fn push_item(
|
||||
&mut self,
|
||||
item: &SpecificDisplayItem,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
item: &di::SpecificDisplayItem,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
) {
|
||||
serialize_fast(
|
||||
&mut self.data,
|
||||
SerializedDisplayItem {
|
||||
di::SerializedDisplayItem {
|
||||
item,
|
||||
layout,
|
||||
space_and_clip,
|
||||
@ -979,12 +975,12 @@ impl DisplayListBuilder {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn push_new_empty_item(&mut self, item: &SpecificDisplayItem) {
|
||||
fn push_new_empty_item(&mut self, item: &di::SpecificDisplayItem) {
|
||||
let pipeline_id = self.pipeline_id;
|
||||
self.push_item(
|
||||
item,
|
||||
&LayoutPrimitiveInfo::new(LayoutRect::zero()),
|
||||
&SpaceAndClipInfo::root_scroll(pipeline_id),
|
||||
&di::LayoutPrimitiveInfo::new(LayoutRect::zero()),
|
||||
&di::SpaceAndClipInfo::root_scroll(pipeline_id),
|
||||
)
|
||||
}
|
||||
|
||||
@ -1035,32 +1031,32 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn push_rect(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
color: ColorF,
|
||||
) {
|
||||
let item = SpecificDisplayItem::Rectangle(RectangleDisplayItem { color });
|
||||
let item = di::SpecificDisplayItem::Rectangle(di::RectangleDisplayItem { color });
|
||||
self.push_item(&item, layout, space_and_clip);
|
||||
}
|
||||
|
||||
pub fn push_clear_rect(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
) {
|
||||
self.push_item(&SpecificDisplayItem::ClearRectangle, layout, space_and_clip);
|
||||
self.push_item(&di::SpecificDisplayItem::ClearRectangle, layout, space_and_clip);
|
||||
}
|
||||
|
||||
pub fn push_line(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
wavy_line_thickness: f32,
|
||||
orientation: LineOrientation,
|
||||
orientation: di::LineOrientation,
|
||||
color: &ColorF,
|
||||
style: LineStyle,
|
||||
style: di::LineStyle,
|
||||
) {
|
||||
let item = SpecificDisplayItem::Line(LineDisplayItem {
|
||||
let item = di::SpecificDisplayItem::Line(di::LineDisplayItem {
|
||||
wavy_line_thickness,
|
||||
orientation,
|
||||
color: *color,
|
||||
@ -1072,16 +1068,16 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn push_image(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
stretch_size: LayoutSize,
|
||||
tile_spacing: LayoutSize,
|
||||
image_rendering: ImageRendering,
|
||||
alpha_type: AlphaType,
|
||||
image_rendering: di::ImageRendering,
|
||||
alpha_type: di::AlphaType,
|
||||
key: ImageKey,
|
||||
color: ColorF,
|
||||
) {
|
||||
let item = SpecificDisplayItem::Image(ImageDisplayItem {
|
||||
let item = di::SpecificDisplayItem::Image(di::ImageDisplayItem {
|
||||
image_key: key,
|
||||
stretch_size,
|
||||
tile_spacing,
|
||||
@ -1096,14 +1092,14 @@ impl DisplayListBuilder {
|
||||
/// Push a yuv image. All planar data in yuv image should use the same buffer type.
|
||||
pub fn push_yuv_image(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
yuv_data: YuvData,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
yuv_data: di::YuvData,
|
||||
color_depth: ColorDepth,
|
||||
color_space: YuvColorSpace,
|
||||
image_rendering: ImageRendering,
|
||||
color_space: di::YuvColorSpace,
|
||||
image_rendering: di::ImageRendering,
|
||||
) {
|
||||
let item = SpecificDisplayItem::YuvImage(YuvImageDisplayItem {
|
||||
let item = di::SpecificDisplayItem::YuvImage(di::YuvImageDisplayItem {
|
||||
yuv_data,
|
||||
color_depth,
|
||||
color_space,
|
||||
@ -1114,14 +1110,14 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn push_text(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
glyphs: &[GlyphInstance],
|
||||
font_key: FontInstanceKey,
|
||||
color: ColorF,
|
||||
glyph_options: Option<GlyphOptions>,
|
||||
) {
|
||||
let item = SpecificDisplayItem::Text(TextDisplayItem {
|
||||
let item = di::SpecificDisplayItem::Text(di::TextDisplayItem {
|
||||
color,
|
||||
font_key,
|
||||
glyph_options,
|
||||
@ -1139,9 +1135,9 @@ impl DisplayListBuilder {
|
||||
&mut self,
|
||||
start_point: LayoutPoint,
|
||||
end_point: LayoutPoint,
|
||||
stops: Vec<GradientStop>,
|
||||
extend_mode: ExtendMode,
|
||||
) -> Gradient {
|
||||
stops: Vec<di::GradientStop>,
|
||||
extend_mode: di::ExtendMode,
|
||||
) -> di::Gradient {
|
||||
let mut builder = GradientBuilder::with_stops(stops);
|
||||
let gradient = builder.gradient(start_point, end_point, extend_mode);
|
||||
self.push_stops(builder.stops());
|
||||
@ -1154,9 +1150,9 @@ impl DisplayListBuilder {
|
||||
&mut self,
|
||||
center: LayoutPoint,
|
||||
radius: LayoutSize,
|
||||
stops: Vec<GradientStop>,
|
||||
extend_mode: ExtendMode,
|
||||
) -> RadialGradient {
|
||||
stops: Vec<di::GradientStop>,
|
||||
extend_mode: di::ExtendMode,
|
||||
) -> di::RadialGradient {
|
||||
let mut builder = GradientBuilder::with_stops(stops);
|
||||
let gradient = builder.radial_gradient(center, radius, extend_mode);
|
||||
self.push_stops(builder.stops());
|
||||
@ -1165,29 +1161,29 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn push_border(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
widths: LayoutSideOffsets,
|
||||
details: BorderDetails,
|
||||
details: di::BorderDetails,
|
||||
) {
|
||||
let item = SpecificDisplayItem::Border(BorderDisplayItem { details, widths });
|
||||
let item = di::SpecificDisplayItem::Border(di::BorderDisplayItem { details, widths });
|
||||
|
||||
self.push_item(&item, layout, space_and_clip);
|
||||
}
|
||||
|
||||
pub fn push_box_shadow(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
box_bounds: LayoutRect,
|
||||
offset: LayoutVector2D,
|
||||
color: ColorF,
|
||||
blur_radius: f32,
|
||||
spread_radius: f32,
|
||||
border_radius: BorderRadius,
|
||||
clip_mode: BoxShadowClipMode,
|
||||
border_radius: di::BorderRadius,
|
||||
clip_mode: di::BoxShadowClipMode,
|
||||
) {
|
||||
let item = SpecificDisplayItem::BoxShadow(BoxShadowDisplayItem {
|
||||
let item = di::SpecificDisplayItem::BoxShadow(di::BoxShadowDisplayItem {
|
||||
box_bounds,
|
||||
offset,
|
||||
color,
|
||||
@ -1216,13 +1212,13 @@ impl DisplayListBuilder {
|
||||
/// The gradient is only visible within the local clip.
|
||||
pub fn push_gradient(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
gradient: Gradient,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
gradient: di::Gradient,
|
||||
tile_size: LayoutSize,
|
||||
tile_spacing: LayoutSize,
|
||||
) {
|
||||
let item = SpecificDisplayItem::Gradient(GradientDisplayItem {
|
||||
let item = di::SpecificDisplayItem::Gradient(di::GradientDisplayItem {
|
||||
gradient,
|
||||
tile_size,
|
||||
tile_spacing,
|
||||
@ -1236,13 +1232,13 @@ impl DisplayListBuilder {
|
||||
/// See [`push_gradient`](#method.push_gradient) for explanation.
|
||||
pub fn push_radial_gradient(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
gradient: RadialGradient,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
gradient: di::RadialGradient,
|
||||
tile_size: LayoutSize,
|
||||
tile_spacing: LayoutSize,
|
||||
) {
|
||||
let item = SpecificDisplayItem::RadialGradient(RadialGradientDisplayItem {
|
||||
let item = di::SpecificDisplayItem::RadialGradient(di::RadialGradientDisplayItem {
|
||||
gradient,
|
||||
tile_size,
|
||||
tile_spacing,
|
||||
@ -1254,15 +1250,15 @@ impl DisplayListBuilder {
|
||||
pub fn push_reference_frame(
|
||||
&mut self,
|
||||
rect: &LayoutRect,
|
||||
parent: SpatialId,
|
||||
transform_style: TransformStyle,
|
||||
parent: di::SpatialId,
|
||||
transform_style: di::TransformStyle,
|
||||
transform: PropertyBinding<LayoutTransform>,
|
||||
kind: ReferenceFrameKind,
|
||||
) -> SpatialId {
|
||||
kind: di::ReferenceFrameKind,
|
||||
) -> di::SpatialId {
|
||||
let id = self.generate_spatial_index();
|
||||
|
||||
let item = SpecificDisplayItem::PushReferenceFrame(ReferenceFrameDisplayListItem {
|
||||
reference_frame: ReferenceFrame {
|
||||
let item = di::SpecificDisplayItem::PushReferenceFrame(di::ReferenceFrameDisplayListItem {
|
||||
reference_frame: di::ReferenceFrame {
|
||||
transform_style,
|
||||
transform,
|
||||
kind,
|
||||
@ -1270,16 +1266,16 @@ impl DisplayListBuilder {
|
||||
},
|
||||
});
|
||||
|
||||
let layout = LayoutPrimitiveInfo::new(*rect);
|
||||
self.push_item(&item, &layout, &SpaceAndClipInfo {
|
||||
let layout = di::LayoutPrimitiveInfo::new(*rect);
|
||||
self.push_item(&item, &layout, &di::SpaceAndClipInfo {
|
||||
spatial_id: parent,
|
||||
clip_id: ClipId::invalid(),
|
||||
clip_id: di::ClipId::invalid(),
|
||||
});
|
||||
id
|
||||
}
|
||||
|
||||
pub fn push_cache_marker(&mut self) {
|
||||
self.push_new_empty_item(&SpecificDisplayItem::PushCacheMarker(CacheMarkerDisplayItem {
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::PushCacheMarker(di::CacheMarkerDisplayItem {
|
||||
// The display item itself is empty for now while we experiment with
|
||||
// the API. In future it may contain extra information, such as details
|
||||
// on whether the surface is known to be opaque and/or a background color
|
||||
@ -1288,26 +1284,26 @@ impl DisplayListBuilder {
|
||||
}
|
||||
|
||||
pub fn pop_cache_marker(&mut self) {
|
||||
self.push_new_empty_item(&SpecificDisplayItem::PopCacheMarker);
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::PopCacheMarker);
|
||||
}
|
||||
|
||||
pub fn pop_reference_frame(&mut self) {
|
||||
self.push_new_empty_item(&SpecificDisplayItem::PopReferenceFrame);
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::PopReferenceFrame);
|
||||
}
|
||||
|
||||
pub fn push_stacking_context(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
spatial_id: SpatialId,
|
||||
clip_id: Option<ClipId>,
|
||||
transform_style: TransformStyle,
|
||||
mix_blend_mode: MixBlendMode,
|
||||
filters: &[FilterOp],
|
||||
raster_space: RasterSpace,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
spatial_id: di::SpatialId,
|
||||
clip_id: Option<di::ClipId>,
|
||||
transform_style: di::TransformStyle,
|
||||
mix_blend_mode: di::MixBlendMode,
|
||||
filters: &[di::FilterOp],
|
||||
raster_space: di::RasterSpace,
|
||||
cache_tiles: bool,
|
||||
) {
|
||||
let item = SpecificDisplayItem::PushStackingContext(PushStackingContextDisplayItem {
|
||||
stacking_context: StackingContext {
|
||||
let item = di::SpecificDisplayItem::PushStackingContext(di::PushStackingContextDisplayItem {
|
||||
stacking_context: di::StackingContext {
|
||||
transform_style,
|
||||
mix_blend_mode,
|
||||
clip_id,
|
||||
@ -1316,9 +1312,9 @@ impl DisplayListBuilder {
|
||||
},
|
||||
});
|
||||
|
||||
self.push_item(&item, layout, &SpaceAndClipInfo {
|
||||
self.push_item(&item, layout, &di::SpaceAndClipInfo {
|
||||
spatial_id,
|
||||
clip_id: ClipId::invalid(),
|
||||
clip_id: di::ClipId::invalid(),
|
||||
});
|
||||
self.push_iter(filters);
|
||||
}
|
||||
@ -1326,8 +1322,8 @@ impl DisplayListBuilder {
|
||||
/// Helper for examples/ code.
|
||||
pub fn push_simple_stacking_context(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
spatial_id: SpatialId,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
spatial_id: di::SpatialId,
|
||||
) {
|
||||
self.push_simple_stacking_context_with_filters(layout, spatial_id, &[]);
|
||||
}
|
||||
@ -1335,66 +1331,66 @@ impl DisplayListBuilder {
|
||||
/// Helper for examples/ code.
|
||||
pub fn push_simple_stacking_context_with_filters(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
spatial_id: SpatialId,
|
||||
filters: &[FilterOp],
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
spatial_id: di::SpatialId,
|
||||
filters: &[di::FilterOp],
|
||||
) {
|
||||
self.push_stacking_context(
|
||||
layout,
|
||||
spatial_id,
|
||||
None,
|
||||
TransformStyle::Flat,
|
||||
MixBlendMode::Normal,
|
||||
di::TransformStyle::Flat,
|
||||
di::MixBlendMode::Normal,
|
||||
filters,
|
||||
RasterSpace::Screen,
|
||||
di::RasterSpace::Screen,
|
||||
/* cache_tiles = */ false,
|
||||
);
|
||||
}
|
||||
|
||||
pub fn pop_stacking_context(&mut self) {
|
||||
self.push_new_empty_item(&SpecificDisplayItem::PopStackingContext);
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::PopStackingContext);
|
||||
}
|
||||
|
||||
pub fn push_stops(&mut self, stops: &[GradientStop]) {
|
||||
pub fn push_stops(&mut self, stops: &[di::GradientStop]) {
|
||||
if stops.is_empty() {
|
||||
return;
|
||||
}
|
||||
self.push_new_empty_item(&SpecificDisplayItem::SetGradientStops);
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::SetGradientStops);
|
||||
self.push_iter(stops);
|
||||
}
|
||||
|
||||
fn generate_clip_index(&mut self) -> ClipId {
|
||||
fn generate_clip_index(&mut self) -> di::ClipId {
|
||||
self.next_clip_index += 1;
|
||||
ClipId::Clip(self.next_clip_index - 1, self.pipeline_id)
|
||||
di::ClipId::Clip(self.next_clip_index - 1, self.pipeline_id)
|
||||
}
|
||||
|
||||
fn generate_spatial_index(&mut self) -> SpatialId {
|
||||
fn generate_spatial_index(&mut self) -> di::SpatialId {
|
||||
self.next_spatial_index += 1;
|
||||
SpatialId::new(self.next_spatial_index - 1, self.pipeline_id)
|
||||
di::SpatialId::new(self.next_spatial_index - 1, self.pipeline_id)
|
||||
}
|
||||
|
||||
fn generate_clip_chain_id(&mut self) -> ClipChainId {
|
||||
fn generate_clip_chain_id(&mut self) -> di::ClipChainId {
|
||||
self.next_clip_chain_id += 1;
|
||||
ClipChainId(self.next_clip_chain_id - 1, self.pipeline_id)
|
||||
di::ClipChainId(self.next_clip_chain_id - 1, self.pipeline_id)
|
||||
}
|
||||
|
||||
pub fn define_scroll_frame<I>(
|
||||
&mut self,
|
||||
parent_space_and_clip: &SpaceAndClipInfo,
|
||||
external_id: Option<ExternalScrollId>,
|
||||
parent_space_and_clip: &di::SpaceAndClipInfo,
|
||||
external_id: Option<di::ExternalScrollId>,
|
||||
content_rect: LayoutRect,
|
||||
clip_rect: LayoutRect,
|
||||
complex_clips: I,
|
||||
image_mask: Option<ImageMask>,
|
||||
scroll_sensitivity: ScrollSensitivity,
|
||||
) -> SpaceAndClipInfo
|
||||
image_mask: Option<di::ImageMask>,
|
||||
scroll_sensitivity: di::ScrollSensitivity,
|
||||
) -> di::SpaceAndClipInfo
|
||||
where
|
||||
I: IntoIterator<Item = ComplexClipRegion>,
|
||||
I: IntoIterator<Item = di::ComplexClipRegion>,
|
||||
I::IntoIter: ExactSizeIterator + Clone,
|
||||
{
|
||||
let clip_id = self.generate_clip_index();
|
||||
let scroll_frame_id = self.generate_spatial_index();
|
||||
let item = SpecificDisplayItem::ScrollFrame(ScrollFrameDisplayItem {
|
||||
let item = di::SpecificDisplayItem::ScrollFrame(di::ScrollFrameDisplayItem {
|
||||
clip_id,
|
||||
scroll_frame_id,
|
||||
external_id,
|
||||
@ -1404,12 +1400,12 @@ impl DisplayListBuilder {
|
||||
|
||||
self.push_item(
|
||||
&item,
|
||||
&LayoutPrimitiveInfo::with_clip_rect(content_rect, clip_rect),
|
||||
&di::LayoutPrimitiveInfo::with_clip_rect(content_rect, clip_rect),
|
||||
parent_space_and_clip,
|
||||
);
|
||||
self.push_iter(complex_clips);
|
||||
|
||||
SpaceAndClipInfo {
|
||||
di::SpaceAndClipInfo {
|
||||
spatial_id: scroll_frame_id,
|
||||
clip_id,
|
||||
}
|
||||
@ -1417,39 +1413,39 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn define_clip_chain<I>(
|
||||
&mut self,
|
||||
parent: Option<ClipChainId>,
|
||||
parent: Option<di::ClipChainId>,
|
||||
clips: I,
|
||||
) -> ClipChainId
|
||||
) -> di::ClipChainId
|
||||
where
|
||||
I: IntoIterator<Item = ClipId>,
|
||||
I: IntoIterator<Item = di::ClipId>,
|
||||
I::IntoIter: ExactSizeIterator + Clone,
|
||||
{
|
||||
let id = self.generate_clip_chain_id();
|
||||
self.push_new_empty_item(&SpecificDisplayItem::ClipChain(ClipChainItem { id, parent }));
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::ClipChain(di::ClipChainItem { id, parent }));
|
||||
self.push_iter(clips);
|
||||
id
|
||||
}
|
||||
|
||||
pub fn define_clip<I>(
|
||||
&mut self,
|
||||
parent_space_and_clip: &SpaceAndClipInfo,
|
||||
parent_space_and_clip: &di::SpaceAndClipInfo,
|
||||
clip_rect: LayoutRect,
|
||||
complex_clips: I,
|
||||
image_mask: Option<ImageMask>,
|
||||
) -> ClipId
|
||||
image_mask: Option<di::ImageMask>,
|
||||
) -> di::ClipId
|
||||
where
|
||||
I: IntoIterator<Item = ComplexClipRegion>,
|
||||
I: IntoIterator<Item = di::ComplexClipRegion>,
|
||||
I::IntoIter: ExactSizeIterator + Clone,
|
||||
{
|
||||
let id = self.generate_clip_index();
|
||||
let item = SpecificDisplayItem::Clip(ClipDisplayItem {
|
||||
let item = di::SpecificDisplayItem::Clip(di::ClipDisplayItem {
|
||||
id,
|
||||
image_mask,
|
||||
});
|
||||
|
||||
self.push_item(
|
||||
&item,
|
||||
&LayoutPrimitiveInfo::new(clip_rect),
|
||||
&di::LayoutPrimitiveInfo::new(clip_rect),
|
||||
parent_space_and_clip,
|
||||
);
|
||||
self.push_iter(complex_clips);
|
||||
@ -1458,15 +1454,15 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn define_sticky_frame(
|
||||
&mut self,
|
||||
parent_spatial_id: SpatialId,
|
||||
parent_spatial_id: di::SpatialId,
|
||||
frame_rect: LayoutRect,
|
||||
margins: SideOffsets2D<Option<f32>>,
|
||||
vertical_offset_bounds: StickyOffsetBounds,
|
||||
horizontal_offset_bounds: StickyOffsetBounds,
|
||||
vertical_offset_bounds: di::StickyOffsetBounds,
|
||||
horizontal_offset_bounds: di::StickyOffsetBounds,
|
||||
previously_applied_offset: LayoutVector2D,
|
||||
) -> SpatialId {
|
||||
) -> di::SpatialId {
|
||||
let id = self.generate_spatial_index();
|
||||
let item = SpecificDisplayItem::StickyFrame(StickyFrameDisplayItem {
|
||||
let item = di::SpecificDisplayItem::StickyFrame(di::StickyFrameDisplayItem {
|
||||
id,
|
||||
margins,
|
||||
vertical_offset_bounds,
|
||||
@ -1476,10 +1472,10 @@ impl DisplayListBuilder {
|
||||
|
||||
self.push_item(
|
||||
&item,
|
||||
&LayoutPrimitiveInfo::new(frame_rect),
|
||||
&SpaceAndClipInfo {
|
||||
&di::LayoutPrimitiveInfo::new(frame_rect),
|
||||
&di::SpaceAndClipInfo {
|
||||
spatial_id: parent_spatial_id,
|
||||
clip_id: ClipId::invalid(),
|
||||
clip_id: di::ClipId::invalid(),
|
||||
},
|
||||
);
|
||||
id
|
||||
@ -1487,12 +1483,12 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn push_iframe(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
pipeline_id: PipelineId,
|
||||
ignore_missing_pipeline: bool
|
||||
) {
|
||||
let item = SpecificDisplayItem::Iframe(IframeDisplayItem {
|
||||
let item = di::SpecificDisplayItem::Iframe(di::IframeDisplayItem {
|
||||
pipeline_id,
|
||||
ignore_missing_pipeline,
|
||||
});
|
||||
@ -1501,15 +1497,15 @@ impl DisplayListBuilder {
|
||||
|
||||
pub fn push_shadow(
|
||||
&mut self,
|
||||
layout: &LayoutPrimitiveInfo,
|
||||
space_and_clip: &SpaceAndClipInfo,
|
||||
shadow: Shadow,
|
||||
layout: &di::LayoutPrimitiveInfo,
|
||||
space_and_clip: &di::SpaceAndClipInfo,
|
||||
shadow: di::Shadow,
|
||||
) {
|
||||
self.push_item(&SpecificDisplayItem::PushShadow(shadow), layout, space_and_clip);
|
||||
self.push_item(&di::SpecificDisplayItem::PushShadow(shadow), layout, space_and_clip);
|
||||
}
|
||||
|
||||
pub fn pop_all_shadows(&mut self) {
|
||||
self.push_new_empty_item(&SpecificDisplayItem::PopAllShadows);
|
||||
self.push_new_empty_item(&di::SpecificDisplayItem::PopAllShadows);
|
||||
}
|
||||
|
||||
pub fn finalize(self) -> (PipelineId, LayoutSize, BuiltDisplayList) {
|
||||
|
@ -16,7 +16,10 @@ use std::hash::{Hash, Hasher};
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use {ColorU, IdNamespace, LayoutPoint};
|
||||
// local imports
|
||||
use api::IdNamespace;
|
||||
use color::ColorU;
|
||||
use units::LayoutPoint;
|
||||
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
|
@ -2,41 +2,42 @@
|
||||
* 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/. */
|
||||
|
||||
use {ExtendMode, Gradient, GradientStop, LayoutPoint, LayoutSize, RadialGradient};
|
||||
use display_item as di;
|
||||
use units::*;
|
||||
|
||||
|
||||
/// Construct a gradient to be used in display lists.
|
||||
///
|
||||
/// Each gradient needs at least two stops.
|
||||
pub struct GradientBuilder {
|
||||
stops: Vec<GradientStop>,
|
||||
stops: Vec<di::GradientStop>,
|
||||
}
|
||||
|
||||
impl GradientBuilder {
|
||||
/// Create a new gradient builder.
|
||||
pub fn new() -> GradientBuilder {
|
||||
pub fn new() -> Self {
|
||||
GradientBuilder {
|
||||
stops: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a gradient builder with a list of stops.
|
||||
pub fn with_stops(stops: Vec<GradientStop>) -> GradientBuilder {
|
||||
pub fn with_stops(stops: Vec<di::GradientStop>) -> GradientBuilder {
|
||||
GradientBuilder { stops }
|
||||
}
|
||||
|
||||
/// Push an additional stop for the gradient.
|
||||
pub fn push(&mut self, stop: GradientStop) {
|
||||
pub fn push(&mut self, stop: di::GradientStop) {
|
||||
self.stops.push(stop);
|
||||
}
|
||||
|
||||
/// Get a reference to the list of stops.
|
||||
pub fn stops(&self) -> &[GradientStop] {
|
||||
pub fn stops(&self) -> &[di::GradientStop] {
|
||||
self.stops.as_ref()
|
||||
}
|
||||
|
||||
/// Return the gradient stops vector.
|
||||
pub fn into_stops(self) -> Vec<GradientStop> {
|
||||
pub fn into_stops(self) -> Vec<di::GradientStop> {
|
||||
self.stops
|
||||
}
|
||||
|
||||
@ -45,12 +46,12 @@ impl GradientBuilder {
|
||||
&mut self,
|
||||
start_point: LayoutPoint,
|
||||
end_point: LayoutPoint,
|
||||
extend_mode: ExtendMode,
|
||||
) -> Gradient {
|
||||
extend_mode: di::ExtendMode,
|
||||
) -> di::Gradient {
|
||||
let (start_offset, end_offset) = self.normalize(extend_mode);
|
||||
let start_to_end = end_point - start_point;
|
||||
|
||||
Gradient {
|
||||
di::Gradient {
|
||||
start_point: start_point + start_to_end * start_offset,
|
||||
end_point: start_point + start_to_end * end_offset,
|
||||
extend_mode,
|
||||
@ -65,8 +66,8 @@ impl GradientBuilder {
|
||||
&mut self,
|
||||
center: LayoutPoint,
|
||||
radius: LayoutSize,
|
||||
extend_mode: ExtendMode,
|
||||
) -> RadialGradient {
|
||||
extend_mode: di::ExtendMode,
|
||||
) -> di::RadialGradient {
|
||||
if radius.width <= 0.0 || radius.height <= 0.0 {
|
||||
// The shader cannot handle a non positive radius. So
|
||||
// reuse the stops vector and construct an equivalent
|
||||
@ -74,10 +75,10 @@ impl GradientBuilder {
|
||||
let last_color = self.stops.last().unwrap().color;
|
||||
|
||||
self.stops.clear();
|
||||
self.stops.push(GradientStop { offset: 0.0, color: last_color, });
|
||||
self.stops.push(GradientStop { offset: 1.0, color: last_color, });
|
||||
self.stops.push(di::GradientStop { offset: 0.0, color: last_color, });
|
||||
self.stops.push(di::GradientStop { offset: 1.0, color: last_color, });
|
||||
|
||||
return RadialGradient {
|
||||
return di::RadialGradient {
|
||||
center,
|
||||
radius: LayoutSize::new(1.0, 1.0),
|
||||
start_offset: 0.0,
|
||||
@ -89,7 +90,7 @@ impl GradientBuilder {
|
||||
let (start_offset, end_offset) =
|
||||
self.normalize(extend_mode);
|
||||
|
||||
RadialGradient {
|
||||
di::RadialGradient {
|
||||
center,
|
||||
radius,
|
||||
start_offset,
|
||||
@ -105,7 +106,7 @@ impl GradientBuilder {
|
||||
/// of the gradient line to where stop[0] and the end of the gradient line
|
||||
/// to stop[n-1]. this function adjusts the stops in place, and returns
|
||||
/// the amount to adjust the gradient line start and stop.
|
||||
fn normalize(&mut self, extend_mode: ExtendMode) -> (f32, f32) {
|
||||
fn normalize(&mut self, extend_mode: di::ExtendMode) -> (f32, f32) {
|
||||
let stops = &mut self.stops;
|
||||
assert!(stops.len() >= 2);
|
||||
|
||||
@ -129,26 +130,26 @@ impl GradientBuilder {
|
||||
stops.clear();
|
||||
|
||||
match extend_mode {
|
||||
ExtendMode::Clamp => {
|
||||
di::ExtendMode::Clamp => {
|
||||
// This gradient is two colors split at the offset of the stops,
|
||||
// so create a gradient with two colors split at 0.5 and adjust
|
||||
// the gradient line so 0.5 is at the offset of the stops
|
||||
stops.push(GradientStop { color: first.color, offset: 0.0, });
|
||||
stops.push(GradientStop { color: first.color, offset: 0.5, });
|
||||
stops.push(GradientStop { color: last.color, offset: 0.5, });
|
||||
stops.push(GradientStop { color: last.color, offset: 1.0, });
|
||||
stops.push(di::GradientStop { color: first.color, offset: 0.0, });
|
||||
stops.push(di::GradientStop { color: first.color, offset: 0.5, });
|
||||
stops.push(di::GradientStop { color: last.color, offset: 0.5, });
|
||||
stops.push(di::GradientStop { color: last.color, offset: 1.0, });
|
||||
|
||||
let offset = last.offset;
|
||||
|
||||
(offset - 0.5, offset + 0.5)
|
||||
}
|
||||
ExtendMode::Repeat => {
|
||||
di::ExtendMode::Repeat => {
|
||||
// A repeating gradient with stops that are all in the same
|
||||
// position should just display the last color. I believe the
|
||||
// spec says that it should be the average color of the gradient,
|
||||
// but this matches what Gecko and Blink does
|
||||
stops.push(GradientStop { color: last.color, offset: 0.0, });
|
||||
stops.push(GradientStop { color: last.color, offset: 1.0, });
|
||||
stops.push(di::GradientStop { color: last.color, offset: 0.0, });
|
||||
stops.push(di::GradientStop { color: last.color, offset: 1.0, });
|
||||
|
||||
(0.0, 1.0)
|
||||
}
|
||||
|
@ -4,14 +4,13 @@
|
||||
|
||||
#![deny(missing_docs)]
|
||||
|
||||
extern crate serde_bytes;
|
||||
|
||||
use font::{FontInstanceKey, FontInstanceData, FontKey, FontTemplate};
|
||||
use std::sync::Arc;
|
||||
use {DeviceIntPoint, DeviceIntRect, DeviceIntSize, LayoutIntRect};
|
||||
use {BlobDirtyRect, IdNamespace, TileOffset, TileSize};
|
||||
use euclid::{size2, TypedRect, num::Zero};
|
||||
use std::ops::{Add, Sub};
|
||||
use std::sync::Arc;
|
||||
// local imports
|
||||
use api::{IdNamespace, TileSize};
|
||||
use font::{FontInstanceKey, FontInstanceData, FontKey, FontTemplate};
|
||||
use units::*;
|
||||
|
||||
/// An opaque identifier describing an image registered with WebRender.
|
||||
/// This is used as a handle to reference images, and is used as the
|
||||
|
@ -16,7 +16,8 @@ use app_units::Au;
|
||||
use euclid::{Length, TypedRect, TypedScale, TypedSize2D, TypedTransform3D, TypedTranslation2D};
|
||||
use euclid::{TypedPoint2D, TypedPoint3D, TypedVector2D, TypedVector3D, TypedSideOffsets2D};
|
||||
use euclid::HomogeneousVector;
|
||||
use DirtyRect;
|
||||
// local imports
|
||||
use image::DirtyRect;
|
||||
|
||||
/// Geometry in the coordinate system of the render target (screen or intermediate
|
||||
/// surface) in physical pixels.
|
||||
|
Loading…
Reference in New Issue
Block a user