Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Use WebRender to compute text index on click events

Browse source 
This is the second half of switching over to WebRender for hit testing.
Now that WebRender gives us the location of the hit tested point in the
display item, we can use that to calculate text index.
This commit is contained in:
Martin Robinson 2017-09-30 15:50:47 +02:00
parent ca08271345
commit 770b348091
11 changed files with 191 additions and 276 deletions
Download patch file Download diff file Expand all files Collapse all files

24
components/compositing/compositor.rs
View file

@ -702,20 +702,20 @@ impl<Window: WindowMethods> IOCompositor<Window> {
None => return, None => return,
}; };
let point = result.point_in_viewport.to_untyped(); let (button, event_type) = match mouse_window_event {
let node_address = Some(UntrustedNodeAddress(result.tag.0 as *const c_void)); MouseWindowEvent::Click(button, _) => (button, MouseEventType::Click),
let event_to_send = match mouse_window_event { MouseWindowEvent::MouseDown(button, _) => (button, MouseEventType::MouseDown),
MouseWindowEvent::Click(button, _) => { MouseWindowEvent::MouseUp(button, _) => (button, MouseEventType::MouseUp),
MouseButtonEvent(MouseEventType::Click, button, point, node_address)
}
MouseWindowEvent::MouseDown(button, _) => {
MouseButtonEvent(MouseEventType::MouseDown, button, point, node_address)
}
MouseWindowEvent::MouseUp(button, _) => {
MouseButtonEvent(MouseEventType::MouseUp, button, point, node_address)
}
}; };
let event_to_send = MouseButtonEvent(
event_type,
button,
result.point_in_viewport.to_untyped(),
Some(UntrustedNodeAddress(result.tag.0 as *const c_void)),
Some(result.point_relative_to_item.to_untyped()),
);
let pipeline_id = PipelineId::from_webrender(result.pipeline); let pipeline_id = PipelineId::from_webrender(result.pipeline);
let msg = ConstellationMsg::ForwardEvent(pipeline_id, event_to_send); let msg = ConstellationMsg::ForwardEvent(pipeline_id, event_to_send);
if let Err(e) = self.constellation_chan.send(msg) { if let Err(e) = self.constellation_chan.send(msg) {

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

@ -48,74 +48,6 @@ pub struct DisplayList {
pub list: Vec<DisplayItem>, pub list: Vec<DisplayItem>,
} }
struct ScrollOffsetLookup<'a> {
parents: &'a mut HashMap<ClipId, ClipId>,
calculated_total_offsets: ScrollOffsetMap,
raw_offsets: &'a ScrollOffsetMap,
}
impl<'a> ScrollOffsetLookup<'a> {
fn new(parents: &'a mut HashMap<ClipId, ClipId>,
raw_offsets: &'a ScrollOffsetMap)
-> ScrollOffsetLookup<'a> {
ScrollOffsetLookup {
parents: parents,
calculated_total_offsets: HashMap::new(),
raw_offsets: raw_offsets,
}
}
fn new_for_reference_frame(&mut self,
clip_id: ClipId,
transform: &Transform3D<f32>,
point: &mut Point2D<Au>)
-> Option<ScrollOffsetLookup> {
// If a transform function causes the current transformation matrix of an object
// to be non-invertible, the object and its content do not get displayed.
let inv_transform = match transform.inverse() {
Some(transform) => transform,
None => return None,
};
let scroll_offset = self.full_offset_for_clip_scroll_node(&clip_id);
*point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
point.y - Au::from_f32_px(scroll_offset.y));
let frac_point = inv_transform.transform_point2d(&Point2D::new(point.x.to_f32_px(),
point.y.to_f32_px()));
*point = Point2D::new(Au::from_f32_px(frac_point.x), Au::from_f32_px(frac_point.y));
let mut sublookup = ScrollOffsetLookup {
parents: &mut self.parents,
calculated_total_offsets: HashMap::new(),
raw_offsets: self.raw_offsets,
};
sublookup.calculated_total_offsets.insert(clip_id, Vector2D::zero());
Some(sublookup)
}
fn add_clip_scroll_node(&mut self, clip_scroll_node: &ClipScrollNode) {
self.parents.insert(clip_scroll_node.id, clip_scroll_node.parent_id);
}
fn full_offset_for_clip_scroll_node(&mut self, id: &ClipId) -> Vector2D<f32> {
if let Some(offset) = self.calculated_total_offsets.get(id) {
return *offset;
}
let parent_offset = if !id.is_root_scroll_node() {
let parent_id = *self.parents.get(id).unwrap();
self.full_offset_for_clip_scroll_node(&parent_id)
} else {
Vector2D::zero()
};
let offset = parent_offset +
self.raw_offsets.get(id).cloned().unwrap_or_else(Vector2D::zero);
self.calculated_total_offsets.insert(*id, offset);
offset
}
}
impl DisplayList { impl DisplayList {
/// Return the bounds of this display list based on the dimensions of the root /// Return the bounds of this display list based on the dimensions of the root
/// stacking context. /// stacking context.
@ -128,82 +60,23 @@ impl DisplayList {
} }
// Returns the text index within a node for the point of interest. // Returns the text index within a node for the point of interest.
pub fn text_index(&self, pub fn text_index(&self, node: OpaqueNode, point_in_item: &Point2D<Au>) -> Option<usize> {
node: OpaqueNode,
client_point: &Point2D<Au>,
scroll_offsets: &ScrollOffsetMap)
-> Option<usize> {
let mut result = Vec::new();
let mut traversal = DisplayListTraversal::new(self); let mut traversal = DisplayListTraversal::new(self);
self.text_index_contents(node,
&mut traversal,
client_point,
&mut ScrollOffsetLookup::new(&mut HashMap::new(), scroll_offsets),
&mut result);
result.pop()
}
fn text_index_contents<'a>(&self,
node: OpaqueNode,
traversal: &mut DisplayListTraversal<'a>,
point: &Point2D<Au>,
offset_lookup: &mut ScrollOffsetLookup,
result: &mut Vec<usize>) {
while let Some(item) = traversal.next() { while let Some(item) = traversal.next() {
match item { match item {
&DisplayItem::PushStackingContext(ref context_item) => {
self.text_index_stacking_context(&context_item.stacking_context,
item.scroll_node_id(),
node,
traversal,
point,
offset_lookup,
result);
}
&DisplayItem::DefineClipScrollNode(ref item) => {
offset_lookup.add_clip_scroll_node(&item.node);
}
&DisplayItem::PopStackingContext(_) => return,
&DisplayItem::Text(ref text) => { &DisplayItem::Text(ref text) => {
let base = item.base(); let base = item.base();
if base.metadata.node == node { if base.metadata.node == node {
let offset = *point - text.baseline_origin; let point = *point_in_item + item.base().bounds.origin.to_vector();
let index = text.text_run.range_index_of_advance(&text.range, offset.x); let offset = point - text.baseline_origin;
result.push(index); return Some(text.text_run.range_index_of_advance(&text.range, offset.x));
} }
}, },
_ => {}, _ => {},
} }
} }
}
fn text_index_stacking_context<'a>(&self, None
stacking_context: &StackingContext,
clip_id: ClipId,
node: OpaqueNode,
traversal: &mut DisplayListTraversal<'a>,
point: &Point2D<Au>,
offset_lookup: &mut ScrollOffsetLookup,
result: &mut Vec<usize>) {
let mut point = *point - stacking_context.bounds.origin.to_vector();
if stacking_context.scroll_policy == ScrollPolicy::Fixed {
let old_offset = offset_lookup.calculated_total_offsets.get(&clip_id).cloned();
offset_lookup.calculated_total_offsets.insert(clip_id, Vector2D::zero());
self.text_index_contents(node, traversal, &point, offset_lookup, result);
match old_offset {
Some(offset) => offset_lookup.calculated_total_offsets.insert(clip_id, offset),
None => offset_lookup.calculated_total_offsets.remove(&clip_id),
};
} else if let Some(transform) = stacking_context.transform {
if let Some(ref mut sublookup) =
offset_lookup.new_for_reference_frame(clip_id, &transform, &mut point) {
self.text_index_contents(node, traversal, &point, sublookup, result);
}
} else {
self.text_index_contents(node, traversal, &point, offset_lookup, result);
}
} }
pub fn print(&self) { pub fn print(&self) {

21
components/layout_thread/lib.rs
View file

@ -1358,18 +1358,19 @@ impl LayoutThread {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
rw_data.content_boxes_response = process_content_boxes_request(node, root_flow); rw_data.content_boxes_response = process_content_boxes_request(node, root_flow);
}, },
ReflowGoal::TextIndexQuery(node, mouse_x, mouse_y) => { ReflowGoal::TextIndexQuery(node, point_in_node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };
let opaque_node = node.opaque(); let opaque_node = node.opaque();
let client_point = Point2D::new(Au::from_px(mouse_x), let point_in_node = Point2D::new(
Au::from_px(mouse_y)); Au::from_f32_px(point_in_node.x),
rw_data.text_index_response = Au::from_f32_px(point_in_node.y)
TextIndexResponse(rw_data.display_list );
.as_ref() rw_data.text_index_response = TextIndexResponse(
.expect("Tried to hit test with no display list") rw_data.display_list
.text_index(opaque_node, .as_ref()
&client_point, .expect("Tried to hit test with no display list")
&rw_data.scroll_offsets)); .text_index(opaque_node, &point_in_node)
);
}, },
ReflowGoal::NodeGeometryQuery(node) => { ReflowGoal::NodeGeometryQuery(node) => {
let node = unsafe { ServoLayoutNode::new(&node) }; let node = unsafe { ServoLayoutNode::new(&node) };

1
components/script/dom/activation.rs
View file

@ -93,6 +93,7 @@ pub fn synthetic_click_activation(element: &Element,
alt_key, alt_key,
meta_key, meta_key,
0, 0,
None,
None); None);
let event = mouse.upcast::<Event>(); let event = mouse.upcast::<Event>();
if source == ActivationSource::FromClick { if source == ActivationSource::FromClick {

108
components/script/dom/document.rs
View file

@ -836,7 +836,8 @@ impl Document {
_button: MouseButton, _button: MouseButton,
client_point: Point2D<f32>, client_point: Point2D<f32>,
mouse_event_type: MouseEventType, mouse_event_type: MouseEventType,
node_address: Option<UntrustedNodeAddress> node_address: Option<UntrustedNodeAddress>,
point_in_node: Option<Point2D<f32>>
) { ) {
let mouse_event_type_string = match mouse_event_type { let mouse_event_type_string = match mouse_event_type {
MouseEventType::Click => "click".to_owned(), MouseEventType::Click => "click".to_owned(),
@ -871,22 +872,25 @@ impl Document {
let client_x = client_point.x as i32; let client_x = client_point.x as i32;
let client_y = client_point.y as i32; let client_y = client_point.y as i32;
let click_count = 1; let click_count = 1;
let event = MouseEvent::new(&self.window, let event = MouseEvent::new(
DOMString::from(mouse_event_type_string), &self.window,
EventBubbles::Bubbles, DOMString::from(mouse_event_type_string),
EventCancelable::Cancelable, EventBubbles::Bubbles,
Some(&self.window), EventCancelable::Cancelable,
click_count, Some(&self.window),
client_x, click_count,
client_y, client_x,
client_x, client_y,
client_y, // TODO: Get real screen coordinates? client_x,
false, client_y, // TODO: Get real screen coordinates?
false, false,
false, false,
false, false,
0i16, false,
None); 0i16,
None,
point_in_node,
);
let event = event.upcast::<Event>(); let event = event.upcast::<Event>();
// https://w3c.github.io/uievents/#trusted-events // https://w3c.github.io/uievents/#trusted-events
@ -943,22 +947,25 @@ impl Document {
let client_x = click_pos.x as i32; let client_x = click_pos.x as i32;
let client_y = click_pos.y as i32; let client_y = click_pos.y as i32;
let event = MouseEvent::new(&self.window, let event = MouseEvent::new(
DOMString::from("dblclick"), &self.window,
EventBubbles::Bubbles, DOMString::from("dblclick"),
EventCancelable::Cancelable, EventBubbles::Bubbles,
Some(&self.window), EventCancelable::Cancelable,
click_count, Some(&self.window),
client_x, click_count,
client_y, client_x,
client_x, client_y,
client_y, client_x,
false, client_y,
false, false,
false, false,
false, false,
0i16, false,
None); 0i16,
None,
None
);
event.upcast::<Event>().fire(target.upcast()); event.upcast::<Event>().fire(target.upcast());
// When a double click occurs, self.last_click_info is left as None so that a // When a double click occurs, self.last_click_info is left as None so that a
@ -1034,22 +1041,25 @@ impl Document {
let client_x = client_point.x.to_i32().unwrap_or(0); let client_x = client_point.x.to_i32().unwrap_or(0);
let client_y = client_point.y.to_i32().unwrap_or(0); let client_y = client_point.y.to_i32().unwrap_or(0);
let mouse_event = MouseEvent::new(&self.window, let mouse_event = MouseEvent::new(
DOMString::from(event_name), &self.window,
EventBubbles::Bubbles, DOMString::from(event_name),
EventCancelable::Cancelable, EventBubbles::Bubbles,
Some(&self.window), EventCancelable::Cancelable,
0i32, Some(&self.window),
client_x, 0i32,
client_y, client_x,
client_x, client_y,
client_y, client_x,
false, client_y,
false, false,
false, false,
false, false,
0i16, false,
None); 0i16,
None,
None
);
let event = mouse_event.upcast::<Event>(); let event = mouse_event.upcast::<Event>();
event.fire(target); event.fire(target);
} }

30
components/script/dom/htmlinputelement.rs
View file

@ -11,8 +11,6 @@ use dom::bindings::codegen::Bindings::FileListBinding::FileListMethods;
use dom::bindings::codegen::Bindings::HTMLInputElementBinding; use dom::bindings::codegen::Bindings::HTMLInputElementBinding;
use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods; use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
use dom::bindings::codegen::Bindings::KeyboardEventBinding::KeyboardEventMethods; use dom::bindings::codegen::Bindings::KeyboardEventBinding::KeyboardEventMethods;
use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use dom::bindings::error::{Error, ErrorResult}; use dom::bindings::error::{Error, ErrorResult};
use dom::bindings::inheritance::Castable; use dom::bindings::inheritance::Castable;
use dom::bindings::root::{Dom, DomRoot, LayoutDom, MutNullableDom, RootedReference}; use dom::bindings::root::{Dom, DomRoot, LayoutDom, MutNullableDom, RootedReference};
@ -1106,23 +1104,19 @@ impl VirtualMethods for HTMLInputElement {
// dispatch_key_event (document.rs) triggers a click event when releasing // dispatch_key_event (document.rs) triggers a click event when releasing
// the space key. There's no nice way to catch this so let's use this for // the space key. There's no nice way to catch this so let's use this for
// now. // now.
if !(mouse_event.ScreenX() == 0 && mouse_event.ScreenY() == 0 && if let Some(point_in_target) = mouse_event.point_in_target() {
mouse_event.GetRelatedTarget().is_none()) { let window = window_from_node(self);
let window = window_from_node(self); let TextIndexResponse(index) = window.text_index_query(
let translated_x = mouse_event.ClientX() + window.PageXOffset(); self.upcast::<Node>().to_trusted_node_address(),
let translated_y = mouse_event.ClientY() + window.PageYOffset(); point_in_target
let TextIndexResponse(index) = window.text_index_query( );
self.upcast::<Node>().to_trusted_node_address(), if let Some(i) = index {
translated_x, self.textinput.borrow_mut().set_edit_point_index(i as usize);
translated_y // trigger redraw
); self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
if let Some(i) = index { event.PreventDefault();
self.textinput.borrow_mut().set_edit_point_index(i as usize);
// trigger redraw
self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
event.PreventDefault();
}
} }
}
} }
} }
} else if event.type_() == atom!("keydown") && !event.DefaultPrevented() && } else if event.type_() == atom!("keydown") && !event.DefaultPrevented() &&

111
components/script/dom/mouseevent.rs
View file

@ -15,6 +15,7 @@ use dom::eventtarget::EventTarget;
use dom::uievent::UIEvent; use dom::uievent::UIEvent;
use dom::window::Window; use dom::window::Window;
use dom_struct::dom_struct; use dom_struct::dom_struct;
use euclid::Point2D;
use servo_config::prefs::PREFS; use servo_config::prefs::PREFS;
use std::cell::Cell; use std::cell::Cell;
use std::default::Default; use std::default::Default;
@ -32,6 +33,7 @@ pub struct MouseEvent {
meta_key: Cell<bool>, meta_key: Cell<bool>,
button: Cell<i16>, button: Cell<i16>,
related_target: MutNullableDom<EventTarget>, related_target: MutNullableDom<EventTarget>,
point_in_target: Cell<Option<Point2D<f32>>>
} }
impl MouseEvent { impl MouseEvent {
@ -48,6 +50,7 @@ impl MouseEvent {
meta_key: Cell::new(false), meta_key: Cell::new(false),
button: Cell::new(0), button: Cell::new(0),
related_target: Default::default(), related_target: Default::default(),
point_in_target: Cell::new(None),
} }
} }
@ -57,28 +60,34 @@ impl MouseEvent {
MouseEventBinding::Wrap) MouseEventBinding::Wrap)
} }
pub fn new(window: &Window, pub fn new(
type_: DOMString, window: &Window,
can_bubble: EventBubbles, type_: DOMString,
cancelable: EventCancelable, can_bubble: EventBubbles,
view: Option<&Window>, cancelable: EventCancelable,
detail: i32, view: Option<&Window>,
screen_x: i32, detail: i32,
screen_y: i32, screen_x: i32,
client_x: i32, screen_y: i32,
client_y: i32, client_x: i32,
ctrl_key: bool, client_y: i32,
alt_key: bool, ctrl_key: bool,
shift_key: bool, alt_key: bool,
meta_key: bool, shift_key: bool,
button: i16, meta_key: bool,
related_target: Option<&EventTarget>) -> DomRoot<MouseEvent> { button: i16,
related_target: Option<&EventTarget>,
point_in_target: Option<Point2D<f32>>
) -> DomRoot<MouseEvent> {
let ev = MouseEvent::new_uninitialized(window); let ev = MouseEvent::new_uninitialized(window);
ev.InitMouseEvent(type_, bool::from(can_bubble), bool::from(cancelable), ev.InitMouseEvent(
view, detail, type_, bool::from(can_bubble), bool::from(cancelable),
screen_x, screen_y, client_x, client_y, view, detail,
ctrl_key, alt_key, shift_key, meta_key, screen_x, screen_y, client_x, client_y,
button, related_target); ctrl_key, alt_key, shift_key, meta_key,
button, related_target,
);
ev.point_in_target.set(point_in_target);
ev ev
} }
@ -87,18 +96,24 @@ impl MouseEvent {
init: &MouseEventBinding::MouseEventInit) -> Fallible<DomRoot<MouseEvent>> { init: &MouseEventBinding::MouseEventInit) -> Fallible<DomRoot<MouseEvent>> {
let bubbles = EventBubbles::from(init.parent.parent.parent.bubbles); let bubbles = EventBubbles::from(init.parent.parent.parent.bubbles);
let cancelable = EventCancelable::from(init.parent.parent.parent.cancelable); let cancelable = EventCancelable::from(init.parent.parent.parent.cancelable);
let event = MouseEvent::new(window, let event = MouseEvent::new(
type_, window,
bubbles, type_,
cancelable, bubbles,
init.parent.parent.view.r(), cancelable,
init.parent.parent.detail, init.parent.parent.view.r(),
init.screenX, init.screenY, init.parent.parent.detail,
init.clientX, init.clientY, init.parent.ctrlKey, init.screenX, init.screenY,
init.parent.altKey, init.parent.shiftKey, init.parent.metaKey, init.clientX, init.clientY, init.parent.ctrlKey,
init.button, init.relatedTarget.r()); init.parent.altKey, init.parent.shiftKey, init.parent.metaKey,
init.button, init.relatedTarget.r(), None
);
Ok(event) Ok(event)
} }
pub fn point_in_target(&self) -> Option<Point2D<f32>> {
self.point_in_target.get()
}
} }
impl MouseEventMethods for MouseEvent { impl MouseEventMethods for MouseEvent {
@ -166,22 +181,24 @@ impl MouseEventMethods for MouseEvent {
} }
// https://w3c.github.io/uievents/#widl-MouseEvent-initMouseEvent // https://w3c.github.io/uievents/#widl-MouseEvent-initMouseEvent
fn InitMouseEvent(&self, fn InitMouseEvent(
type_arg: DOMString, &self,
can_bubble_arg: bool, type_arg: DOMString,
cancelable_arg: bool, can_bubble_arg: bool,
view_arg: Option<&Window>, cancelable_arg: bool,
detail_arg: i32, view_arg: Option<&Window>,
screen_x_arg: i32, detail_arg: i32,
screen_y_arg: i32, screen_x_arg: i32,
client_x_arg: i32, screen_y_arg: i32,
client_y_arg: i32, client_x_arg: i32,
ctrl_key_arg: bool, client_y_arg: i32,
alt_key_arg: bool, ctrl_key_arg: bool,
shift_key_arg: bool, alt_key_arg: bool,
meta_key_arg: bool, shift_key_arg: bool,
button_arg: i16, meta_key_arg: bool,
related_target_arg: Option<&EventTarget>) { button_arg: i16,
related_target_arg: Option<&EventTarget>,
) {
if self.upcast::<Event>().dispatching() { if self.upcast::<Event>().dispatching() {
return; return;
} }

8
components/script/dom/window.rs
View file

@ -1481,8 +1481,12 @@ impl Window {
self.layout_rpc.margin_style() self.layout_rpc.margin_style()
} }
pub fn text_index_query(&self, node: TrustedNodeAddress, mouse_x: i32, mouse_y: i32) -> TextIndexResponse { pub fn text_index_query(
if !self.reflow(ReflowGoal::TextIndexQuery(node, mouse_x, mouse_y), ReflowReason::Query) { &self,
node: TrustedNodeAddress,
point_in_node: Point2D<f32>
) -> TextIndexResponse {
if !self.reflow(ReflowGoal::TextIndexQuery(node, point_in_node), ReflowReason::Query) {
return TextIndexResponse(None); return TextIndexResponse(None);
} }
self.layout_rpc.text_index() self.layout_rpc.text_index()

17
components/script/script_thread.rs
View file

@ -2187,8 +2187,15 @@ impl ScriptThread {
self.handle_resize_event(pipeline_id, new_size, size_type); self.handle_resize_event(pipeline_id, new_size, size_type);
} }
MouseButtonEvent(event_type, button, point, node_address) => { MouseButtonEvent(event_type, button, point, node_address, point_in_node) => {
self.handle_mouse_event(pipeline_id, event_type, button, point, node_address); self.handle_mouse_event(
pipeline_id,
event_type,
button,
point,
node_address,
point_in_node
);
} }
MouseMoveEvent(point, node_address) => { MouseMoveEvent(point, node_address) => {
@ -2299,7 +2306,8 @@ impl ScriptThread {
mouse_event_type: MouseEventType, mouse_event_type: MouseEventType,
button: MouseButton, button: MouseButton,
point: Point2D<f32>, point: Point2D<f32>,
node_address: Option<UntrustedNodeAddress> node_address: Option<UntrustedNodeAddress>,
point_in_node: Option<Point2D<f32>>
) { ) {
let document = match { self.documents.borrow().find_document(pipeline_id) } { let document = match { self.documents.borrow().find_document(pipeline_id) } {
Some(document) => document, Some(document) => document,
@ -2310,7 +2318,8 @@ impl ScriptThread {
button, button,
point, point,
mouse_event_type, mouse_event_type,
node_address node_address,
point_in_node
); );
} }

2
components/script_layout_interface/message.rs
View file

@ -120,7 +120,7 @@ pub enum ReflowGoal {
ResolvedStyleQuery(TrustedNodeAddress, Option<PseudoElement>, PropertyId), ResolvedStyleQuery(TrustedNodeAddress, Option<PseudoElement>, PropertyId),
OffsetParentQuery(TrustedNodeAddress), OffsetParentQuery(TrustedNodeAddress),
MarginStyleQuery(TrustedNodeAddress), MarginStyleQuery(TrustedNodeAddress),
TextIndexQuery(TrustedNodeAddress, i32, i32), TextIndexQuery(TrustedNodeAddress, Point2D<f32>),
NodesFromPointQuery(Point2D<f32>, NodesFromPointQueryType), NodesFromPointQuery(Point2D<f32>, NodesFromPointQueryType),
} }

8
components/script_traits/lib.rs
View file

@ -436,7 +436,13 @@ pub enum CompositorEvent {
/// The window was resized. /// The window was resized.
ResizeEvent(WindowSizeData, WindowSizeType), ResizeEvent(WindowSizeData, WindowSizeType),
/// A mouse button state changed. /// A mouse button state changed.
MouseButtonEvent(MouseEventType, MouseButton, Point2D<f32>, Option<UntrustedNodeAddress>), MouseButtonEvent(
MouseEventType,
MouseButton,
Point2D<f32>,
Option<UntrustedNodeAddress>,
Option<Point2D<f32>>
),
/// The mouse was moved over a point (or was moved out of the recognizable region). /// The mouse was moved over a point (or was moved out of the recognizable region).
MouseMoveEvent(Option<Point2D<f32>>, Option<UntrustedNodeAddress>), MouseMoveEvent(Option<Point2D<f32>>, Option<UntrustedNodeAddress>),
/// A touch event was generated with a touch ID and location. /// A touch event was generated with a touch ID and location.