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

Revert unnecessary changes

Browse source
This commit is contained in:
Utsav Oza 2020-05-30 18:46:18 +05:30
parent 43051c7bf3
commit 5493424d9a
1 changed files with 34 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

68
components/canvas/canvas_data.rs
View file

@ -371,7 +371,7 @@ pub enum Filter {
pub struct CanvasData<'a> { pub struct CanvasData<'a> {
backend: Box<dyn Backend>, backend: Box<dyn Backend>,
draw_target: Box<dyn GenericDrawTarget>, drawtarget: Box<dyn GenericDrawTarget>,
path_state: Option<PathState>, path_state: Option<PathState>,
state: CanvasPaintState<'a>, state: CanvasPaintState<'a>,
saved_states: Vec<CanvasPaintState<'a>>, saved_states: Vec<CanvasPaintState<'a>>,
@ -399,7 +399,7 @@ impl<'a> CanvasData<'a> {
let draw_target = backend.create_drawtarget(size); let draw_target = backend.create_drawtarget(size);
CanvasData { CanvasData {
backend, backend,
draw_target, drawtarget: draw_target,
path_state: None, path_state: None,
state: CanvasPaintState::new(antialias), state: CanvasPaintState::new(antialias),
saved_states: vec![], saved_states: vec![],
@ -449,7 +449,7 @@ impl<'a> CanvasData<'a> {
// TODO(pylbrecht) pass another closure for raqote // TODO(pylbrecht) pass another closure for raqote
self.draw_with_shadow(&rect, writer); self.draw_with_shadow(&rect, writer);
} else { } else {
writer(&mut *self.draw_target); writer(&mut *self.drawtarget);
} }
} }
@ -460,8 +460,8 @@ impl<'a> CanvasData<'a> {
pub fn restore_context_state(&mut self) { pub fn restore_context_state(&mut self) {
if let Some(state) = self.saved_states.pop() { if let Some(state) = self.saved_states.pop() {
let _ = mem::replace(&mut self.state, state); let _ = mem::replace(&mut self.state, state);
self.draw_target.set_transform(&self.state.transform); self.drawtarget.set_transform(&self.state.transform);
self.draw_target.pop_clip(); self.drawtarget.pop_clip();
} }
} }
@ -481,7 +481,7 @@ impl<'a> CanvasData<'a> {
}) })
.collect(); .collect();
self.draw_target.fill_text( self.drawtarget.fill_text(
text, text,
x, x,
y, y,
@ -541,7 +541,7 @@ impl<'a> CanvasData<'a> {
); );
}); });
} else { } else {
self.draw_target.fill_rect( self.drawtarget.fill_rect(
&draw_rect, &draw_rect,
self.state.fill_style.clone(), self.state.fill_style.clone(),
Some(&self.state.draw_options), Some(&self.state.draw_options),
@ -550,7 +550,7 @@ impl<'a> CanvasData<'a> {
} }
pub fn clear_rect(&mut self, rect: &Rect<f32>) { pub fn clear_rect(&mut self, rect: &Rect<f32>) {
self.draw_target.clear_rect(rect); self.drawtarget.clear_rect(rect);
} }
pub fn stroke_rect(&mut self, rect: &Rect<f32>) { pub fn stroke_rect(&mut self, rect: &Rect<f32>) {
@ -570,7 +570,7 @@ impl<'a> CanvasData<'a> {
} else if rect.size.width == 0. || rect.size.height == 0. { } else if rect.size.width == 0. || rect.size.height == 0. {
let mut stroke_opts = self.state.stroke_opts.clone(); let mut stroke_opts = self.state.stroke_opts.clone();
stroke_opts.set_line_cap(LineCapStyle::Butt); stroke_opts.set_line_cap(LineCapStyle::Butt);
self.draw_target.stroke_line( self.drawtarget.stroke_line(
rect.origin, rect.origin,
rect.bottom_right(), rect.bottom_right(),
self.state.stroke_style.clone(), self.state.stroke_style.clone(),
@ -578,7 +578,7 @@ impl<'a> CanvasData<'a> {
&self.state.draw_options, &self.state.draw_options,
); );
} else { } else {
self.draw_target.stroke_rect( self.drawtarget.stroke_rect(
rect, rect,
self.state.stroke_style.clone(), self.state.stroke_style.clone(),
&self.state.stroke_opts, &self.state.stroke_opts,
@ -600,7 +600,7 @@ impl<'a> CanvasData<'a> {
// If there's no record of any path yet, create a new builder in user-space. // If there's no record of any path yet, create a new builder in user-space.
if self.path_state.is_none() { if self.path_state.is_none() {
self.path_state = Some(PathState::UserSpacePathBuilder( self.path_state = Some(PathState::UserSpacePathBuilder(
self.draw_target.create_path_builder(), self.drawtarget.create_path_builder(),
None, None,
)); ));
} }
@ -635,7 +635,7 @@ impl<'a> CanvasData<'a> {
let new_state = match *self.path_state.as_mut().unwrap() { let new_state = match *self.path_state.as_mut().unwrap() {
PathState::DeviceSpacePathBuilder(ref mut builder) => { PathState::DeviceSpacePathBuilder(ref mut builder) => {
let path = builder.finish(); let path = builder.finish();
let inverse = match self.draw_target.get_transform().inverse() { let inverse = match self.drawtarget.get_transform().inverse() {
Some(m) => m, Some(m) => m,
None => { None => {
warn!("Couldn't invert canvas transformation."); warn!("Couldn't invert canvas transformation.");
@ -667,7 +667,7 @@ impl<'a> CanvasData<'a> {
} }
self.ensure_path(); self.ensure_path();
self.draw_target.fill( self.drawtarget.fill(
&self.path().clone(), &self.path().clone(),
self.state.fill_style.clone(), self.state.fill_style.clone(),
&self.state.draw_options, &self.state.draw_options,
@ -680,7 +680,7 @@ impl<'a> CanvasData<'a> {
} }
self.ensure_path(); self.ensure_path();
self.draw_target.stroke( self.drawtarget.stroke(
&self.path().clone(), &self.path().clone(),
self.state.stroke_style.clone(), self.state.stroke_style.clone(),
&self.state.stroke_opts, &self.state.stroke_opts,
@ -691,7 +691,7 @@ impl<'a> CanvasData<'a> {
pub fn clip(&mut self) { pub fn clip(&mut self) {
self.ensure_path(); self.ensure_path();
let path = self.path().clone(); let path = self.path().clone();
self.draw_target.push_clip(&path); self.drawtarget.push_clip(&path);
} }
pub fn is_point_in_path( pub fn is_point_in_path(
@ -704,7 +704,7 @@ impl<'a> CanvasData<'a> {
self.ensure_path(); self.ensure_path();
let result = match self.path_state.as_ref() { let result = match self.path_state.as_ref() {
Some(PathState::UserSpacePath(ref path, ref transform)) => { Some(PathState::UserSpacePath(ref path, ref transform)) => {
let target_transform = self.draw_target.get_transform(); let target_transform = self.drawtarget.get_transform();
let path_transform = transform.as_ref().unwrap_or(&target_transform); let path_transform = transform.as_ref().unwrap_or(&target_transform);
path.contains_point(x, y, path_transform) path.contains_point(x, y, path_transform)
}, },
@ -724,7 +724,7 @@ impl<'a> CanvasData<'a> {
fn path_builder(&mut self) -> PathBuilderRef { fn path_builder(&mut self) -> PathBuilderRef {
if self.path_state.is_none() { if self.path_state.is_none() {
self.path_state = Some(PathState::UserSpacePathBuilder( self.path_state = Some(PathState::UserSpacePathBuilder(
self.draw_target.create_path_builder(), self.drawtarget.create_path_builder(),
None, None,
)); ));
} }
@ -766,7 +766,7 @@ impl<'a> CanvasData<'a> {
PathState::DeviceSpacePathBuilder(ref mut builder) => { PathState::DeviceSpacePathBuilder(ref mut builder) => {
return PathBuilderRef { return PathBuilderRef {
builder, builder,
transform: self.draw_target.get_transform(), transform: self.drawtarget.get_transform(),
}; };
}, },
_ => unreachable!(), _ => unreachable!(),
@ -780,7 +780,7 @@ impl<'a> CanvasData<'a> {
}, },
PathState::DeviceSpacePathBuilder(ref mut builder) => PathBuilderRef { PathState::DeviceSpacePathBuilder(ref mut builder) => PathBuilderRef {
builder, builder,
transform: self.draw_target.get_transform(), transform: self.drawtarget.get_transform(),
}, },
PathState::UserSpacePathBuilder(..) | PathState::UserSpacePath(..) => unreachable!(), PathState::UserSpacePathBuilder(..) | PathState::UserSpacePath(..) => unreachable!(),
} }
@ -910,12 +910,12 @@ impl<'a> CanvasData<'a> {
pub fn set_fill_style(&mut self, style: FillOrStrokeStyle) { pub fn set_fill_style(&mut self, style: FillOrStrokeStyle) {
self.backend self.backend
.set_fill_style(style, &mut self.state, &*self.draw_target); .set_fill_style(style, &mut self.state, &*self.drawtarget);
} }
pub fn set_stroke_style(&mut self, style: FillOrStrokeStyle) { pub fn set_stroke_style(&mut self, style: FillOrStrokeStyle) {
self.backend self.backend
.set_stroke_style(style, &mut self.state, &*self.draw_target); .set_stroke_style(style, &mut self.state, &*self.drawtarget);
} }
pub fn set_line_width(&mut self, width: f32) { pub fn set_line_width(&mut self, width: f32) {
@ -935,7 +935,7 @@ impl<'a> CanvasData<'a> {
} }
pub fn get_transform(&self) -> Transform2D<f32> { pub fn get_transform(&self) -> Transform2D<f32> {
self.draw_target.get_transform() self.drawtarget.get_transform()
} }
pub fn set_transform(&mut self, transform: &Transform2D<f32>) { pub fn set_transform(&mut self, transform: &Transform2D<f32>) {
@ -946,12 +946,12 @@ impl<'a> CanvasData<'a> {
Some(PathState::UserSpacePathBuilder(_, ref mut transform)) | Some(PathState::UserSpacePathBuilder(_, ref mut transform)) |
Some(PathState::UserSpacePath(_, ref mut transform)) => { Some(PathState::UserSpacePath(_, ref mut transform)) => {
if transform.is_none() { if transform.is_none() {
*transform = Some(self.draw_target.get_transform()); *transform = Some(self.drawtarget.get_transform());
} }
}, },
} }
self.state.transform = transform.clone(); self.state.transform = transform.clone();
self.draw_target.set_transform(transform) self.drawtarget.set_transform(transform)
} }
pub fn set_global_alpha(&mut self, alpha: f32) { pub fn set_global_alpha(&mut self, alpha: f32) {
@ -963,7 +963,7 @@ impl<'a> CanvasData<'a> {
} }
pub fn recreate(&mut self, size: Size2D<u64>) { pub fn recreate(&mut self, size: Size2D<u64>) {
self.draw_target = self self.drawtarget = self
.backend .backend
.create_drawtarget(Size2D::new(size.width, size.height)); .create_drawtarget(Size2D::new(size.width, size.height));
self.state = self.backend.recreate_paint_state(&self.state); self.state = self.backend.recreate_paint_state(&self.state);
@ -982,7 +982,7 @@ impl<'a> CanvasData<'a> {
} }
pub fn send_pixels(&mut self, chan: IpcSender<IpcSharedMemory>) { pub fn send_pixels(&mut self, chan: IpcSender<IpcSharedMemory>) {
self.draw_target.snapshot_data(&|bytes| { self.drawtarget.snapshot_data(&|bytes| {
let data = IpcSharedMemory::from_bytes(bytes); let data = IpcSharedMemory::from_bytes(bytes);
chan.send(data).unwrap(); chan.send(data).unwrap();
vec![] vec![]
@ -990,7 +990,7 @@ impl<'a> CanvasData<'a> {
} }
pub fn send_data(&mut self, chan: IpcSender<CanvasImageData>) { pub fn send_data(&mut self, chan: IpcSender<CanvasImageData>) {
let size = self.draw_target.get_size(); let size = self.drawtarget.get_size();
let descriptor = webrender_api::ImageDescriptor { let descriptor = webrender_api::ImageDescriptor {
size: webrender_api::units::DeviceIntSize::new(size.width, size.height), size: webrender_api::units::DeviceIntSize::new(size.width, size.height),
@ -999,7 +999,7 @@ impl<'a> CanvasData<'a> {
offset: 0, offset: 0,
flags: webrender_api::ImageDescriptorFlags::empty(), flags: webrender_api::ImageDescriptorFlags::empty(),
}; };
let data = self.draw_target.snapshot_data_owned(); let data = self.drawtarget.snapshot_data_owned();
let data = webrender_api::ImageData::Raw(Arc::new(data)); let data = webrender_api::ImageData::Raw(Arc::new(data));
let mut updates = vec![]; let mut updates = vec![];
@ -1037,14 +1037,14 @@ impl<'a> CanvasData<'a> {
assert_eq!(rect.size.area() as usize, imagedata.len() / 4); assert_eq!(rect.size.area() as usize, imagedata.len() / 4);
pixels::rgba8_byte_swap_and_premultiply_inplace(&mut imagedata); pixels::rgba8_byte_swap_and_premultiply_inplace(&mut imagedata);
let source_surface = self let source_surface = self
.draw_target .drawtarget
.create_source_surface_from_data( .create_source_surface_from_data(
&imagedata, &imagedata,
rect.size.to_i32(), rect.size.to_i32(),
rect.size.width as i32 * 4, rect.size.width as i32 * 4,
) )
.unwrap(); .unwrap();
self.draw_target.copy_surface( self.drawtarget.copy_surface(
source_surface, source_surface,
Rect::from_size(rect.size.to_i32()), Rect::from_size(rect.size.to_i32()),
rect.origin.to_i32(), rect.origin.to_i32(),
@ -1076,12 +1076,12 @@ impl<'a> CanvasData<'a> {
} }
fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> Box<dyn GenericDrawTarget> { fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> Box<dyn GenericDrawTarget> {
let mut draw_target = self.draw_target.create_similar_draw_target( let mut draw_target = self.drawtarget.create_similar_draw_target(
&Size2D::new( &Size2D::new(
source_rect.size.width as i32, source_rect.size.width as i32,
source_rect.size.height as i32, source_rect.size.height as i32,
), ),
self.draw_target.get_format(), self.drawtarget.get_format(),
); );
let matrix = Transform2D::identity() let matrix = Transform2D::identity()
.pre_translate(-source_rect.origin.to_vector().cast::<f32>()) .pre_translate(-source_rect.origin.to_vector().cast::<f32>())
@ -1097,7 +1097,7 @@ impl<'a> CanvasData<'a> {
let shadow_src_rect = self.state.transform.transform_rect(rect); let shadow_src_rect = self.state.transform.transform_rect(rect);
let mut new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect); let mut new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect);
draw_shadow_source(&mut *new_draw_target); draw_shadow_source(&mut *new_draw_target);
self.draw_target.draw_surface_with_shadow( self.drawtarget.draw_surface_with_shadow(
new_draw_target.snapshot(), new_draw_target.snapshot(),
&Point2D::new( &Point2D::new(
shadow_src_rect.origin.x as f32, shadow_src_rect.origin.x as f32,
@ -1126,7 +1126,7 @@ impl<'a> CanvasData<'a> {
return vec![]; return vec![];
} }
self.draw_target.snapshot_data(&|bytes| { self.drawtarget.snapshot_data(&|bytes| {
pixels::rgba8_get_rect(bytes, canvas_size, read_rect).into_owned() pixels::rgba8_get_rect(bytes, canvas_size, read_rect).into_owned()
}) })
} }