mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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:
Dzmitry Malyshau 2019-02-15 17:39:40 +00:00
Родитель a39539982f
Коммит 1a4b75a034
7 изменённых файлов: 305 добавлений и 304 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

83
gfx/wr/webrender_api/src/api.rs
Просмотреть файл

@ -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};
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)
}

20
gfx/wr/webrender_api/src/display_item.rs
Просмотреть файл

@ -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;
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 {

436
gfx/wr/webrender_api/src/display_list.rs
Просмотреть файл

@ -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};
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) {

5
gfx/wr/webrender_api/src/font.rs
Просмотреть файл

@ -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};
use api::IdNamespace;
use color::ColorU;
use units::LayoutPoint;
#[cfg(not(target_os = "macos"))]

51
gfx/wr/webrender_api/src/gradient_builder.rs
Просмотреть файл

@ -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)
}

11
gfx/wr/webrender_api/src/image.rs
Просмотреть файл

@ -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;
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

3
gfx/wr/webrender_api/src/units.rs
Просмотреть файл

@ -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;
use image::DirtyRect;
/// Geometry in the coordinate system of the render target (screen or intermediate
/// surface) in physical pixels.