Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-13 09:25:32 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update euclid to 0.10.1

Browse source
This commit is contained in:
Anthony Ramine 2016-08-19 17:13:23 +02:00
parent 8a75810eba
commit 51768844ed
37 changed files with 281 additions and 280 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/gfx/Cargo.toml
View file

@ -14,7 +14,7 @@ path = "lib.rs"
app_units = "0.3"
azure = {git = "https://github.com/servo/rust-azure", features = ["plugins"]}
bitflags = "0.7"
euclid = "0.9"
euclid = "0.10.1"
fnv = "1.0"
gfx_traits = {path = "../gfx_traits"}
harfbuzz-sys = "0.1"

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

@ -21,7 +21,7 @@ use euclid::approxeq::ApproxEq;
use euclid::num::{One, Zero};
use euclid::rect::TypedRect;
use euclid::side_offsets::SideOffsets2D;
use euclid::{Matrix2D, Matrix4D, Point2D, Rect, Size2D};
use euclid::{Matrix4D, Point2D, Rect, Size2D};
use fnv::FnvHasher;
use gfx_traits::print_tree::PrintTree;
use gfx_traits::{LayerId, ScrollPolicy, StackingContextId};
@ -339,10 +339,7 @@ impl DisplayList {
transform: &Matrix4D<f32>,
index: usize) {
let old_transform = paint_context.draw_target.get_transform();
paint_context.draw_target.set_transform(
&Matrix2D::new(transform.m11, transform.m12,
transform.m21, transform.m22,
transform.m41, transform.m42));
paint_context.draw_target.set_transform(&transform.to_2d());
let item = &self.list[index];
item.draw_into_context(paint_context);
@ -459,9 +456,11 @@ impl DisplayList {
Point2D::new(origin.x.to_nearest_pixel(pixels_per_px.get()),
origin.y.to_nearest_pixel(pixels_per_px.get()));
let transform = transform.translate(pixel_snapped_origin.x as AzFloat,
pixel_snapped_origin.y as AzFloat,
0.0).mul(&stacking_context.transform);
let transform = transform
.pre_translated(pixel_snapped_origin.x as AzFloat,
pixel_snapped_origin.y as AzFloat,
0.0)
.pre_mul(&stacking_context.transform);
if transform.is_identity_or_simple_translation() {
let pixel_snapped_origin = Point2D::new(Au::from_f32_px(pixel_snapped_origin.x),
@ -477,6 +476,18 @@ impl DisplayList {
}
};
let transformed_transform =
match transformed_tile_rect(paint_context.screen_rect, &transform) {
Some(transformed) => transformed,
None => {
// https://drafts.csswg.org/css-transforms/#transform-function-lists
// If a transform function causes the current transformation matrix (CTM)
// of an object to be non-invertible, the object and its content do not
// get displayed.
return;
},
};
{
let mut paint_subcontext = PaintContext {
draw_target: draw_target.clone(),
@ -490,10 +501,7 @@ impl DisplayList {
};
// Set up our clip rect and transform.
paint_subcontext.draw_target.set_transform(
&Matrix2D::new(transform.m11, transform.m12,
transform.m21, transform.m22,
transform.m41, transform.m42));
paint_subcontext.draw_target.set_transform(&transform.to_2d());
paint_subcontext.push_clip_if_applicable();
self.draw_stacking_context_contents(
@ -502,7 +510,7 @@ impl DisplayList {
&mut paint_subcontext,
&transform,
&subpixel_offset,
Some(transformed_tile_rect(paint_context.screen_rect, &transform)));
Some(transformed_transform));
paint_subcontext.remove_transient_clip_if_applicable();
paint_subcontext.pop_clip_if_applicable();
@ -535,17 +543,20 @@ impl DisplayList {
}
}
fn transformed_tile_rect(tile_rect: TypedRect<usize, ScreenPx>, transform: &Matrix4D<f32>) -> Rect<Au> {
fn transformed_tile_rect(tile_rect: TypedRect<usize, ScreenPx>,
transform: &Matrix4D<f32>)
-> Option<Rect<Au>> {
// Invert the current transform, then use this to back transform
// the tile rect (placed at the origin) into the space of this
// stacking context.
let inverse_transform = transform.invert();
let inverse_transform_2d = Matrix2D::new(inverse_transform.m11, inverse_transform.m12,
inverse_transform.m21, inverse_transform.m22,
inverse_transform.m41, inverse_transform.m42);
let tile_size = Size2D::new(tile_rect.as_f32().size.width, tile_rect.as_f32().size.height);
let inverse_transform = match transform.inverse() {
Some(inverse) => inverse,
None => return None,
};
let inverse_transform_2d = inverse_transform.to_2d();
let tile_size = Size2D::new(tile_rect.to_f32().size.width, tile_rect.to_f32().size.height);
let tile_rect = Rect::new(Point2D::zero(), tile_size).to_untyped();
geometry::f32_rect_to_au_rect(inverse_transform_2d.transform_rect(&tile_rect))
Some(geometry::f32_rect_to_au_rect(inverse_transform_2d.transform_rect(&tile_rect)))
}
@ -699,11 +710,9 @@ impl StackingContext {
let origin_x = self.bounds.origin.x.to_f32_px();
let origin_y = self.bounds.origin.y.to_f32_px();
let transform = Matrix4D::identity().translate(origin_x, origin_y, 0.0)
.mul(&self.transform);
let transform_2d = Matrix2D::new(transform.m11, transform.m12,
transform.m21, transform.m22,
transform.m41, transform.m42);
let transform = Matrix4D::identity().pre_translated(origin_x, origin_y, 0.0)
.pre_mul(&self.transform);
let transform_2d = transform.to_2d();
let overflow = geometry::au_rect_to_f32_rect(self.overflow);
let overflow = transform_2d.transform_rect(&overflow);
@ -726,7 +735,7 @@ impl StackingContext {
// Convert the point into stacking context local transform space.
let mut point = if self.context_type == StackingContextType::Real {
let point = *effective_point - self.bounds.origin;
let inv_transform = self.transform.invert();
let inv_transform = self.transform.inverse().unwrap();
let frac_point = inv_transform.transform_point(&Point2D::new(point.x.to_f32_px(),
point.y.to_f32_px()));
Point2D::new(Au::from_f32_px(frac_point.x), Au::from_f32_px(frac_point.y))

29
components/gfx/paint_context.rs
View file

@ -127,7 +127,7 @@ impl<'a> PaintContext<'a> {
}
pub fn screen_pixels_per_px(&self) -> ScaleFactor<f32, PagePx, ScreenPx> {
ScaleFactor::new(self.screen_rect.as_f32().size.width / self.page_rect.size.width)
ScaleFactor::new(self.screen_rect.to_f32().size.width / self.page_rect.size.width)
}
pub fn draw_target(&self) -> &DrawTarget {
@ -242,7 +242,7 @@ impl<'a> PaintContext<'a> {
//
// Annoyingly, surface patterns in Azure/Skia are relative to the top left of the *canvas*,
// not the rectangle we're drawing to. So we need to translate it explicitly.
let matrix = Matrix2D::identity().translate(dest_rect.origin.x, dest_rect.origin.y);
let matrix = Matrix2D::identity().pre_translated(dest_rect.origin.x, dest_rect.origin.y);
let stretch_size = stretch_size.to_nearest_azure_size(scale);
if source_rect.size == stretch_size {
let pattern = SurfacePattern::new(azure_surface.azure_source_surface,
@ -1358,17 +1358,15 @@ impl<'a> PaintContext<'a> {
SidewaysLeft => {
let x = origin.x.to_f32_px();
let y = origin.y.to_f32_px();
self.draw_target.set_transform(&draw_target_transform.mul(&Matrix2D::new(0., -1.,
1., 0.,
x, y)));
self.draw_target.set_transform(
&draw_target_transform.pre_mul(&Matrix2D::row_major(0., -1., 1., 0., x, y)));
Point2D::zero()
}
SidewaysRight => {
let x = origin.x.to_f32_px();
let y = origin.y.to_f32_px();
self.draw_target.set_transform(&draw_target_transform.mul(&Matrix2D::new(0., 1.,
-1., 0.,
x, y)));
self.draw_target.set_transform(
&draw_target_transform.pre_mul(&Matrix2D::row_major(0., 1., -1., 0., x, y)));
Point2D::zero()
}
};
@ -1450,9 +1448,10 @@ impl<'a> PaintContext<'a> {
Size2D::new(size.width as AzFloat,
size.height as AzFloat));
let temporary_draw_target_bounds = old_transform.transform_rect(&inflated_size);
matrix = Matrix2D::identity().translate(
-temporary_draw_target_bounds.origin.x as AzFloat,
-temporary_draw_target_bounds.origin.y as AzFloat).mul(&old_transform);
matrix = Matrix2D::identity()
.pre_translated(-temporary_draw_target_bounds.origin.x as AzFloat,
-temporary_draw_target_bounds.origin.y as AzFloat)
.pre_mul(&old_transform);
}
let temporary_draw_target =
@ -1978,10 +1977,10 @@ impl TemporaryDrawTarget {
let temporary_draw_target =
main_draw_target.create_similar_draw_target(&temporary_draw_target_size,
main_draw_target.get_format());
let matrix =
Matrix2D::identity().translate(-temporary_draw_target_bounds.origin.x as AzFloat,
-temporary_draw_target_bounds.origin.y as AzFloat)
.mul(&draw_target_transform);
let matrix = Matrix2D::identity()
.pre_translated(-temporary_draw_target_bounds.origin.x as AzFloat,
-temporary_draw_target_bounds.origin.y as AzFloat)
.pre_mul(&draw_target_transform);
temporary_draw_target.set_transform(&matrix);
TemporaryDrawTarget {
draw_target: temporary_draw_target,

16
components/gfx/paint_thread.rs
View file

@ -77,8 +77,8 @@ impl PaintLayer {
Size2D::new(bounds.size.width.to_nearest_px() as f32,
bounds.size.height.to_nearest_px() as f32));
let transform = transform.mul(&stacking_context.transform);
let perspective = perspective.mul(&stacking_context.perspective);
let transform = transform.pre_mul(&stacking_context.transform);
let perspective = perspective.pre_mul(&stacking_context.perspective);
let establishes_3d_context = stacking_context.establishes_3d_context;
let scrolls_overflow_area = stacking_context.scrolls_overflow_area;
@ -244,8 +244,8 @@ impl LayerCreator {
self.process_stacking_context_items(stacking_context,
traversal,
&(stacking_context.bounds.origin + *parent_origin),
&transform.mul(&stacking_context.transform),
&perspective.mul(&stacking_context.perspective));
&transform.pre_mul(&stacking_context.transform),
&perspective.pre_mul(&stacking_context.perspective));
}
fn process_stacking_context_items<'a>(&mut self,
@ -694,11 +694,11 @@ impl WorkerThread {
// Apply the translation to paint the tile we want.
let matrix = Matrix4D::identity();
let matrix = matrix.scale(scale as AzFloat, scale as AzFloat, 1.0);
let matrix = matrix.pre_scaled(scale as AzFloat, scale as AzFloat, 1.0);
let tile_bounds = tile.page_rect.translate(&paint_layer.display_list_origin);
let matrix = matrix.translate(-tile_bounds.origin.x as AzFloat,
-tile_bounds.origin.y as AzFloat,
0.0);
let matrix = matrix.pre_translated(-tile_bounds.origin.x as AzFloat,
-tile_bounds.origin.y as AzFloat,
0.0);
// Clear the buffer.
paint_context.clear();