1use std::cell::Cell;
6
7use dom_struct::dom_struct;
8use embedder_traits::MouseButton;
9use euclid::Point2D;
10use js::context::JSContext;
11use js::rust::HandleObject;
12use keyboard_types::Modifiers;
13use script_bindings::cell::DomRefCell;
14use script_bindings::domstring::TracedDOMString;
15use script_bindings::reflector::reflect_dom_object_with_proto;
16use script_bindings::root::DomSlice;
17use script_traits::MouseButtons;
18use style::Atom;
19use style_traits::CSSPixel;
20
21use crate::dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
22use crate::dom::bindings::codegen::Bindings::PointerEventBinding::{
23 PointerEventInit, PointerEventMethods,
24};
25use crate::dom::bindings::num::Finite;
26use crate::dom::bindings::root::{Dom, DomRoot};
27use crate::dom::bindings::str::DOMString;
28use crate::dom::event::{EventBubbles, EventCancelable};
29use crate::dom::eventtarget::EventTarget;
30use crate::dom::mouseevent::MouseEvent;
31use crate::dom::window::Window;
32
33#[derive(Clone, Copy, MallocSizeOf, PartialEq)]
35pub(crate) enum PointerId {
36 NonPointerDevice = -1,
37 Mouse,
38}
39
40#[dom_struct]
41pub(crate) struct PointerEvent {
42 mouseevent: MouseEvent,
43 pointer_id: Cell<i32>,
44 width: Cell<i32>,
45 height: Cell<i32>,
46 pressure: Cell<f32>,
47 tangential_pressure: Cell<f32>,
48 tilt_x: Cell<i32>,
49 tilt_y: Cell<i32>,
50 twist: Cell<i32>,
51 altitude_angle: Cell<f64>,
52 azimuth_angle: Cell<f64>,
53 pointer_type: DomRefCell<TracedDOMString>,
54 is_primary: Cell<bool>,
55 coalesced_events: DomRefCell<Vec<Dom<PointerEvent>>>,
56 predicted_events: DomRefCell<Vec<Dom<PointerEvent>>>,
57}
58
59impl PointerEvent {
60 fn new_inherited() -> PointerEvent {
61 PointerEvent {
62 mouseevent: MouseEvent::new_inherited(),
63 pointer_id: Cell::new(0),
64 width: Cell::new(0),
65 height: Cell::new(0),
66 pressure: Cell::new(0.),
67 tangential_pressure: Cell::new(0.),
68 tilt_x: Cell::new(0),
69 tilt_y: Cell::new(0),
70 twist: Cell::new(0),
71 altitude_angle: Cell::new(0.),
72 azimuth_angle: Cell::new(0.),
73 pointer_type: DomRefCell::new(DOMString::new().traced()),
74 is_primary: Cell::new(false),
75 coalesced_events: DomRefCell::new(Vec::new()),
76 predicted_events: DomRefCell::new(Vec::new()),
77 }
78 }
79
80 fn new_uninitialized_with_proto(
81 cx: &mut JSContext,
82 window: &Window,
83 proto: Option<HandleObject>,
84 ) -> DomRoot<PointerEvent> {
85 reflect_dom_object_with_proto(cx, Box::new(PointerEvent::new_inherited()), window, proto)
86 }
87
88 #[expect(clippy::too_many_arguments)]
89 pub(crate) fn new(
90 cx: &mut JSContext,
91 window: &Window,
92 event_type: Atom,
93 can_bubble: EventBubbles,
94 cancelable: EventCancelable,
95 view: Option<&Window>,
96 detail: i32,
97 screen_point: Point2D<i32, CSSPixel>,
98 client_point: Point2D<i32, CSSPixel>,
99 page_point: Point2D<i32, CSSPixel>,
100 modifiers: Modifiers,
101 button: MouseButton,
102 buttons: MouseButtons,
103 related_target: Option<&EventTarget>,
104 point_in_target: Option<Point2D<f32, CSSPixel>>,
105 pointer_id: i32,
106 width: i32,
107 height: i32,
108 pressure: f32,
109 tangential_pressure: f32,
110 tilt_x: i32,
111 tilt_y: i32,
112 twist: i32,
113 altitude_angle: f64,
114 azimuth_angle: f64,
115 pointer_type: DOMString,
116 is_primary: bool,
117 coalesced_events: &[&PointerEvent],
118 predicted_events: &[&PointerEvent],
119 ) -> DomRoot<PointerEvent> {
120 Self::new_with_proto(
121 cx,
122 window,
123 None,
124 event_type,
125 can_bubble,
126 cancelable,
127 view,
128 detail,
129 screen_point,
130 client_point,
131 page_point,
132 modifiers,
133 button,
134 buttons,
135 related_target,
136 point_in_target,
137 pointer_id,
138 width,
139 height,
140 pressure,
141 tangential_pressure,
142 tilt_x,
143 tilt_y,
144 twist,
145 altitude_angle,
146 azimuth_angle,
147 pointer_type,
148 is_primary,
149 coalesced_events,
150 predicted_events,
151 )
152 }
153
154 #[expect(clippy::too_many_arguments)]
155 fn new_with_proto(
156 cx: &mut JSContext,
157 window: &Window,
158 proto: Option<HandleObject>,
159 event_type: Atom,
160 can_bubble: EventBubbles,
161 cancelable: EventCancelable,
162 view: Option<&Window>,
163 detail: i32,
164 screen_point: Point2D<i32, CSSPixel>,
165 client_point: Point2D<i32, CSSPixel>,
166 page_point: Point2D<i32, CSSPixel>,
167 modifiers: Modifiers,
168 button: MouseButton,
169 buttons: MouseButtons,
170 related_target: Option<&EventTarget>,
171 point_in_target: Option<Point2D<f32, CSSPixel>>,
172 pointer_id: i32,
173 width: i32,
174 height: i32,
175 pressure: f32,
176 tangential_pressure: f32,
177 tilt_x: i32,
178 tilt_y: i32,
179 twist: i32,
180 altitude_angle: f64,
181 azimuth_angle: f64,
182 pointer_type: DOMString,
183 is_primary: bool,
184 coalesced_events: &[&PointerEvent],
185 predicted_events: &[&PointerEvent],
186 ) -> DomRoot<PointerEvent> {
187 let ev = PointerEvent::new_uninitialized_with_proto(cx, window, proto);
188 ev.mouseevent.initialize_mouse_event(
189 event_type,
190 can_bubble,
191 cancelable,
192 view,
193 detail,
194 screen_point,
195 client_point,
196 page_point,
197 modifiers,
198 button,
199 buttons,
200 related_target,
201 point_in_target,
202 );
203 ev.pointer_id.set(pointer_id);
204 ev.width.set(width);
205 ev.height.set(height);
206 ev.pressure.set(pressure);
207 ev.tangential_pressure.set(tangential_pressure);
208 ev.tilt_x.set(tilt_x);
209 ev.tilt_y.set(tilt_y);
210 ev.twist.set(twist);
211 ev.altitude_angle.set(altitude_angle);
212 ev.azimuth_angle.set(azimuth_angle);
213 *ev.pointer_type.safe_borrow_mut(cx.no_gc()) = pointer_type.traced();
214 ev.is_primary.set(is_primary);
215 *ev.coalesced_events.safe_borrow_mut(cx.no_gc()) = coalesced_events
216 .iter()
217 .map(|&event| Dom::from_ref(event))
218 .collect();
219 *ev.predicted_events.safe_borrow_mut(cx.no_gc()) = predicted_events
220 .iter()
221 .map(|&event| Dom::from_ref(event))
222 .collect();
223 ev
224 }
225}
226
227impl PointerEventMethods<crate::DomTypeHolder> for PointerEvent {
228 fn Constructor(
230 cx: &mut JSContext,
231 window: &Window,
232 proto: Option<HandleObject>,
233 event_type: DOMString,
234 init: &PointerEventInit,
235 ) -> DomRoot<PointerEvent> {
236 let bubbles = EventBubbles::from(init.parent.parent.parent.parent.bubbles);
237 let cancelable = EventCancelable::from(init.parent.parent.parent.parent.cancelable);
238 let scroll_offset = window.scroll_offset(cx);
239 let page_point = Point2D::new(
240 scroll_offset.x as i32 + init.parent.clientX,
241 scroll_offset.y as i32 + init.parent.clientY,
242 );
243 PointerEvent::new_with_proto(
244 cx,
245 window,
246 proto,
247 event_type.into(),
248 bubbles,
249 cancelable,
250 init.parent.parent.parent.view.as_deref(),
251 init.parent.parent.parent.detail,
252 Point2D::new(init.parent.screenX, init.parent.screenY),
253 Point2D::new(init.parent.clientX, init.parent.clientY),
254 page_point,
255 init.parent.parent.modifiers(),
256 init.parent.button.into(),
257 MouseButtons::from_bits_retain(init.parent.buttons),
258 init.parent.relatedTarget.as_deref(),
259 None,
260 init.pointerId,
261 init.width,
262 init.height,
263 *init.pressure,
264 *init.tangentialPressure,
265 init.tiltX.unwrap_or_default(),
266 init.tiltY.unwrap_or_default(),
267 init.twist,
268 *init.altitudeAngle.unwrap_or_default(),
269 *init.azimuthAngle.unwrap_or_default(),
270 init.pointerType.clone(),
271 init.isPrimary,
272 init.coalescedEvents.as_ref_slice(),
273 init.predictedEvents.as_ref_slice(),
274 )
275 }
276
277 fn PointerId(&self) -> i32 {
279 self.pointer_id.get()
280 }
281
282 fn Width(&self) -> i32 {
284 self.width.get()
285 }
286
287 fn Height(&self) -> i32 {
289 self.height.get()
290 }
291
292 fn Pressure(&self) -> Finite<f32> {
294 Finite::wrap(self.pressure.get())
295 }
296
297 fn TangentialPressure(&self) -> Finite<f32> {
299 Finite::wrap(self.tangential_pressure.get())
300 }
301
302 fn TiltX(&self) -> i32 {
304 self.tilt_x.get()
305 }
306
307 fn TiltY(&self) -> i32 {
309 self.tilt_y.get()
310 }
311
312 fn Twist(&self) -> i32 {
314 self.twist.get()
315 }
316
317 fn AltitudeAngle(&self) -> Finite<f64> {
319 Finite::wrap(self.altitude_angle.get())
320 }
321
322 fn AzimuthAngle(&self) -> Finite<f64> {
324 Finite::wrap(self.azimuth_angle.get())
325 }
326
327 fn PointerType(&self) -> DOMString {
329 self.pointer_type.borrow().clone().root()
330 }
331
332 fn IsPrimary(&self) -> bool {
334 self.is_primary.get()
335 }
336
337 fn GetCoalescedEvents(&self) -> Vec<DomRoot<PointerEvent>> {
339 self.coalesced_events
340 .borrow()
341 .iter()
342 .map(|event| event.as_rooted())
343 .collect()
344 }
345
346 fn GetPredictedEvents(&self) -> Vec<DomRoot<PointerEvent>> {
348 self.predicted_events
349 .borrow()
350 .iter()
351 .map(|event| event.as_rooted())
352 .collect()
353 }
354
355 fn IsTrusted(&self) -> bool {
357 self.mouseevent.IsTrusted()
358 }
359}