Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-24 15:50:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #3173 from mrobinson/typed-units-1

Browse source 
Start using more typed units in the compositor
This commit is contained in:
Josh Matthews 2014-09-02 15:14:37 -04:00
commit cb559efd4e
11 changed files with 60 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

17
src/components/compositing/compositor.rs
View file

@ -27,6 +27,7 @@ use geom::rect::Rect;
use geom::size::TypedSize2D;
use geom::scale_factor::ScaleFactor;
use gfx::render_task::{RenderChan, RenderMsg, RenderRequest, UnusedBufferMsg};
use layers::geometry::DevicePixel;
use layers::layers::{BufferRequest, Layer, LayerBufferSet};
use layers::rendergl;
use layers::rendergl::RenderContext;
@ -38,7 +39,7 @@ use servo_msg::compositor_msg::{LayerId, ReadyState, RenderState};
use servo_msg::constellation_msg::{ConstellationChan, ExitMsg, LoadUrlMsg, NavigateMsg};
use servo_msg::constellation_msg::{PipelineId, ResizedWindowMsg, WindowSizeData};
use servo_msg::constellation_msg;
use servo_util::geometry::{DevicePixel, PagePx, ScreenPx, ViewportPx};
use servo_util::geometry::{PagePx, ScreenPx, ViewportPx};
use servo_util::memory::MemoryProfilerChan;
use servo_util::opts::Opts;
use servo_util::time::{profile, TimeProfilerChan};
@ -506,7 +507,7 @@ impl IOCompositor {
events::move(root_layer.clone(),
pipeline_id,
layer_id,
fragment_point,
Point2D::from_untyped(&fragment_point),
window_size)
})
}
@ -522,6 +523,7 @@ impl IOCompositor {
new_rect_in_page_coordinates: Rect<f32>) {
let new_rect_in_layer_coordinates =
self.convert_page_rect_to_layer_coordinates(new_rect_in_page_coordinates);
let new_rect_in_layer_coordinates = Rect::from_untyped(&new_rect_in_layer_coordinates);
match self.find_layer_with_pipeline_and_layer_id(pipeline_id, layer_id) {
Some(ref layer) => *layer.bounds.borrow_mut() = new_rect_in_layer_coordinates,
@ -571,7 +573,7 @@ impl IOCompositor {
events::move(layer.clone(),
pipeline_id,
layer_id,
device_point,
Point2D::from_untyped(&device_point),
window_size))
}
Some(_) | None => {
@ -679,9 +681,9 @@ impl IOCompositor {
fn on_mouse_window_event_class(&self, mouse_window_event: MouseWindowEvent) {
let scale = self.device_pixels_per_page_px();
let point = match mouse_window_event {
MouseWindowClickEvent(_, p) => p / scale,
MouseWindowMouseDownEvent(_, p) => p / scale,
MouseWindowMouseUpEvent(_, p) => p / scale,
MouseWindowClickEvent(_, p) => p,
MouseWindowMouseDownEvent(_, p) => p,
MouseWindowMouseUpEvent(_, p) => p,
};
for layer in self.scene.root.iter() {
events::send_mouse_event(layer.clone(), mouse_window_event, point, scale);
@ -828,8 +830,7 @@ impl IOCompositor {
fn send_buffer_requests_for_all_layers(&mut self) {
let mut layers_and_requests = Vec::new();
self.scene.get_buffer_requests(&mut layers_and_requests,
Rect(Point2D(0f32, 0f32),
self.window_size.as_f32().to_untyped()));
Rect(TypedPoint2D(0f32, 0f32), self.window_size.as_f32()));
// Return unused tiles first, so that they can be reused by any new BufferRequests.
self.send_back_unused_buffers();

11
src/components/compositing/compositor_data.rs
View file

@ -9,13 +9,14 @@ use pipeline::CompositionPipeline;
use azure::azure_hl::Color;
use geom::point::TypedPoint2D;
use geom::size::{Size2D, TypedSize2D};
use geom::rect::Rect;
use gfx::render_task::UnusedBufferMsg;
use layers::geometry::DevicePixel;
use layers::layers::{Layer, LayerBufferSet};
use layers::platform::surface::NativeSurfaceMethods;
use servo_msg::compositor_msg::{Epoch, LayerId};
use servo_msg::compositor_msg::ScrollPolicy;
use servo_msg::constellation_msg::PipelineId;
use servo_util::geometry::DevicePixel;
use std::rc::Rc;
pub struct CompositorData {
@ -59,19 +60,21 @@ impl CompositorData {
background_color: layer_properties.background_color,
epoch: layer_properties.epoch,
};
Rc::new(Layer::new(layer_properties.rect, tile_size, new_compositor_data))
Rc::new(Layer::new(Rect::from_untyped(&layer_properties.rect),
tile_size, new_compositor_data))
}
pub fn update_layer(layer: Rc<Layer<CompositorData>>, layer_properties: LayerProperties) {
layer.extra_data.borrow_mut().epoch = layer_properties.epoch;
layer.extra_data.borrow_mut().background_color = layer_properties.background_color;
layer.resize(layer_properties.rect.size);
let size: TypedSize2D<DevicePixel, f32> = Size2D::from_untyped(&layer_properties.rect.size);
layer.resize(size);
layer.contents_changed();
// Call scroll for bounds checking if the page shrunk. Use (-1, -1) as the
// cursor position to make sure the scroll isn't propagated downwards.
let size: TypedSize2D<DevicePixel, f32> = Size2D::from_untyped(&layer.bounds.borrow().size);
events::handle_scroll_event(layer.clone(),
TypedPoint2D(0f32, 0f32),
TypedPoint2D(-1f32, -1f32),

62
src/components/compositing/events.rs
View file

@ -6,16 +6,17 @@ use compositor_data::{CompositorData, WantsScrollEvents};
use windowing::{MouseWindowEvent, MouseWindowClickEvent, MouseWindowMouseDownEvent};
use windowing::MouseWindowMouseUpEvent;
use geom::point::{Point2D, TypedPoint2D};
use geom::rect::{Rect, TypedRect};
use geom::length::Length;
use geom::point::TypedPoint2D;
use geom::scale_factor::ScaleFactor;
use geom::size::{Size2D, TypedSize2D};
use geom::size::TypedSize2D;
use layers::geometry::DevicePixel;
use layers::layers::Layer;
use script_traits::{ClickEvent, MouseDownEvent, MouseMoveEvent, MouseUpEvent, SendEventMsg};
use script_traits::{ScriptControlChan};
use servo_msg::compositor_msg::{FixedPosition, LayerId};
use servo_msg::constellation_msg::PipelineId;
use servo_util::geometry::{DevicePixel, PagePx};
use servo_util::geometry::PagePx;
use std::rc::Rc;
@ -55,36 +56,33 @@ pub fn handle_scroll_event(layer: Rc<Layer<CompositorData>>,
}
// Allow children to scroll.
let content_offset: TypedPoint2D<DevicePixel, f32> =
Point2D::from_untyped(&*layer.content_offset.borrow());
let content_offset = layer.content_offset.borrow().clone();
let cursor = cursor - content_offset;
for child in layer.children().iter() {
let rect: TypedRect<DevicePixel, f32> = Rect::from_untyped(&*child.bounds.borrow());
if rect.contains(&cursor) &&
let child_bounds = child.bounds.borrow();
if child_bounds.contains(&cursor) &&
handle_scroll_event(child.clone(),
delta,
cursor - rect.origin,
rect.size) {
cursor - child_bounds.origin,
child_bounds.size) {
return true
}
}
clamp_scroll_offset_and_scroll_layer(layer,
content_offset.to_untyped() + delta.to_untyped(),
window_size.to_untyped())
clamp_scroll_offset_and_scroll_layer(layer, content_offset + delta, window_size)
}
pub fn clamp_scroll_offset_and_scroll_layer(layer: Rc<Layer<CompositorData>>,
mut new_offset: Point2D<f32>,
window_size: Size2D<f32>)
mut new_offset: TypedPoint2D<DevicePixel, f32>,
window_size: TypedSize2D<DevicePixel, f32>)
-> bool {
let layer_size = layer.bounds.borrow().size;
let min_x = (window_size.width - layer_size.width).min(0.0);
new_offset.x = new_offset.x.clamp(&min_x, &0.0);
let min_x = (window_size.width - layer_size.width).get().min(0.0);
new_offset.x = Length(new_offset.x.get().clamp(&min_x, &0.0));
let min_y = (window_size.height - layer_size.height).min(0.0);
new_offset.y = new_offset.y.clamp(&min_y, &0.0);
let min_y = (window_size.height - layer_size.height).get().min(0.0);
new_offset.y = Length(new_offset.y.get().clamp(&min_y, &0.0));
if *layer.content_offset.borrow() == new_offset {
return false
@ -97,13 +95,15 @@ pub fn clamp_scroll_offset_and_scroll_layer(layer: Rc<Layer<CompositorData>>,
}
fn scroll_layer_and_all_child_layers(layer: Rc<Layer<CompositorData>>,
new_offset: Point2D<f32>)
new_offset: TypedPoint2D<DevicePixel, f32>)
-> bool {
let mut result = false;
// Only scroll this layer if it's not fixed-positioned.
if layer.extra_data.borrow().scroll_policy != FixedPosition {
*layer.transform.borrow_mut() = identity().translate(new_offset.x, new_offset.y, 0.0);
*layer.transform.borrow_mut() = identity().translate(new_offset.x.get(),
new_offset.y.get(),
0.0);
*layer.content_offset.borrow_mut() = new_offset;
result = true
}
@ -120,20 +120,22 @@ fn scroll_layer_and_all_child_layers(layer: Rc<Layer<CompositorData>>,
// page coordinates.
pub fn send_mouse_event(layer: Rc<Layer<CompositorData>>,
event: MouseWindowEvent,
cursor: TypedPoint2D<PagePx, f32>,
cursor: TypedPoint2D<DevicePixel, f32>,
device_pixels_per_page_px: ScaleFactor<PagePx, DevicePixel, f32>) {
let content_offset : TypedPoint2D<DevicePixel, f32> =
Point2D::from_untyped(&*layer.content_offset.borrow());
let cursor = cursor - (content_offset / device_pixels_per_page_px);
let cursor = cursor - *layer.content_offset.borrow();
for child in layer.children().iter() {
let rect: TypedRect<PagePx, f32> = Rect::from_untyped(&*child.bounds.borrow());
if rect.contains(&cursor) {
send_mouse_event(child.clone(), event, cursor - rect.origin, device_pixels_per_page_px);
let child_bounds = child.bounds.borrow();
if child_bounds.contains(&cursor) {
send_mouse_event(child.clone(),
event,
cursor - child_bounds.origin,
device_pixels_per_page_px);
return;
}
}
// This mouse event is mine!
let cursor = cursor / device_pixels_per_page_px;
let message = match event {
MouseWindowClickEvent(button, _) => ClickEvent(button, cursor.to_untyped()),
MouseWindowMouseDownEvent(button, _) => MouseDownEvent(button, cursor.to_untyped()),
@ -153,7 +155,7 @@ pub fn send_mouse_move_event(layer: Rc<Layer<CompositorData>>,
pub fn move(layer: Rc<Layer<CompositorData>>,
pipeline_id: PipelineId,
layer_id: LayerId,
origin: Point2D<f32>,
origin: TypedPoint2D<DevicePixel, f32>,
window_size: TypedSize2D<DevicePixel, f32>)
-> bool {
// Search children for the right layer to move.
@ -172,5 +174,5 @@ pub fn move(layer: Rc<Layer<CompositorData>>,
return false
}
clamp_scroll_offset_and_scroll_layer(layer, origin * -1.0, window_size.to_untyped())
clamp_scroll_offset_and_scroll_layer(layer, TypedPoint2D(0f32, 0f32) - origin, window_size)
}

3
src/components/compositing/platform/common/glfw_windowing.rs
View file

@ -22,9 +22,10 @@ use std::rc::Rc;
use geom::point::{Point2D, TypedPoint2D};
use geom::scale_factor::ScaleFactor;
use geom::size::TypedSize2D;
use layers::geometry::DevicePixel;
use servo_msg::compositor_msg::{IdleRenderState, RenderState, RenderingRenderState};
use servo_msg::compositor_msg::{FinishedLoading, Blank, Loading, PerformingLayout, ReadyState};
use servo_util::geometry::{ScreenPx, DevicePixel};
use servo_util::geometry::ScreenPx;
use glfw;
use glfw::Context;

3
src/components/compositing/platform/common/glut_windowing.rs
View file

@ -17,9 +17,10 @@ use std::rc::Rc;
use geom::point::{Point2D, TypedPoint2D};
use geom::scale_factor::ScaleFactor;
use geom::size::TypedSize2D;
use layers::geometry::DevicePixel;
use servo_msg::compositor_msg::{IdleRenderState, RenderState, RenderingRenderState};
use servo_msg::compositor_msg::{FinishedLoading, Blank, ReadyState};
use servo_util::geometry::{ScreenPx, DevicePixel};
use servo_util::geometry::ScreenPx;
use glut::glut::{ACTIVE_SHIFT, DOUBLE, WindowHeight};
use glut::glut::WindowWidth;

3
src/components/compositing/windowing.rs
View file

@ -7,8 +7,9 @@
use geom::point::TypedPoint2D;
use geom::scale_factor::ScaleFactor;
use geom::size::TypedSize2D;
use layers::geometry::DevicePixel;
use servo_msg::compositor_msg::{ReadyState, RenderState};
use servo_util::geometry::{ScreenPx, DevicePixel};
use servo_util::geometry::ScreenPx;
use std::rc::Rc;
pub enum MouseWindowEvent {

3
src/components/msg/constellation_msg.rs
View file

@ -8,8 +8,9 @@
use geom::rect::Rect;
use geom::size::TypedSize2D;
use geom::scale_factor::ScaleFactor;
use layers::geometry::DevicePixel;
use serialize::Encodable;
use servo_util::geometry::{DevicePixel, PagePx, ViewportPx};
use servo_util::geometry::{PagePx, ViewportPx};
use std::comm::{channel, Sender, Receiver};
use url::Url;

6
src/components/util/geometry.rs
View file

@ -13,12 +13,6 @@ use std::fmt;
// Units for use with geom::length and geom::scale_factor.
/// One hardware pixel.
///
/// This unit corresponds to the smallest addressable element of the display hardware.
#[deriving(Encodable)]
pub enum DevicePixel {}
/// A normalized "pixel" at the default resolution for the display.
///
/// Like the CSS "px" unit, the exact physical size of this unit may vary between devices, but it

3
src/components/util/opts.rs
View file

@ -5,11 +5,12 @@
//! Configuration options for a single run of the servo application. Created
//! from command line arguments.
use geometry::{DevicePixel, ScreenPx};
use geometry::ScreenPx;
use azure::azure_hl::{BackendType, CairoBackend, CoreGraphicsBackend};
use azure::azure_hl::{CoreGraphicsAcceleratedBackend, Direct2DBackend, SkiaBackend};
use geom::scale_factor::ScaleFactor;
use layers::geometry::DevicePixel;
use getopts;
use std::cmp;
use std::io;

1
src/components/util/util.rs
View file

@ -18,6 +18,7 @@ extern crate azure;
extern crate collections;
extern crate geom;
extern crate getopts;
extern crate layers;
extern crate libc;
extern crate native;
extern crate rand;

2
src/support/layers/rust-layers

@ -1 +1 @@
Subproject commit 5c167a7f739553dff01d3d6cba25e344058f77a1
Subproject commit c04029907be1f2242d48235d3b03608b905bbd9f