Skip to main content

script/dom/event/
pointerevent.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use 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/// <https://w3c.github.io/pointerevents/#dom-pointerevent-pointerid>
34#[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    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-constructor>
229    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    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-pointerid>
278    fn PointerId(&self) -> i32 {
279        self.pointer_id.get()
280    }
281
282    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-width>
283    fn Width(&self) -> i32 {
284        self.width.get()
285    }
286
287    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-height>
288    fn Height(&self) -> i32 {
289        self.height.get()
290    }
291
292    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-pressure>
293    fn Pressure(&self) -> Finite<f32> {
294        Finite::wrap(self.pressure.get())
295    }
296
297    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-tangentialpressure>
298    fn TangentialPressure(&self) -> Finite<f32> {
299        Finite::wrap(self.tangential_pressure.get())
300    }
301
302    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-tiltx>
303    fn TiltX(&self) -> i32 {
304        self.tilt_x.get()
305    }
306
307    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-tilty>
308    fn TiltY(&self) -> i32 {
309        self.tilt_y.get()
310    }
311
312    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-twist>
313    fn Twist(&self) -> i32 {
314        self.twist.get()
315    }
316
317    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-altitudeangle>
318    fn AltitudeAngle(&self) -> Finite<f64> {
319        Finite::wrap(self.altitude_angle.get())
320    }
321
322    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-azimuthangle>
323    fn AzimuthAngle(&self) -> Finite<f64> {
324        Finite::wrap(self.azimuth_angle.get())
325    }
326
327    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-pointertype>
328    fn PointerType(&self) -> DOMString {
329        self.pointer_type.borrow().clone().root()
330    }
331
332    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-isprimary>
333    fn IsPrimary(&self) -> bool {
334        self.is_primary.get()
335    }
336
337    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-getcoalescedevents>
338    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    /// <https://w3c.github.io/pointerevents/#dom-pointerevent-getpredictedevents>
347    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    /// <https://dom.spec.whatwg.org/#dom-event-istrusted>
356    fn IsTrusted(&self) -> bool {
357        self.mouseevent.IsTrusted()
358    }
359}