1use base::id::{DomPointId, DomPointIndex};
6use constellation_traits::DomPoint;
7use dom_struct::dom_struct;
8use js::rust::HandleObject;
9use rustc_hash::FxHashMap;
10
11use crate::dom::bindings::codegen::Bindings::DOMPointBinding::{DOMPointInit, DOMPointMethods};
12use crate::dom::bindings::codegen::Bindings::DOMPointReadOnlyBinding::DOMPointReadOnlyMethods;
13use crate::dom::bindings::error::Fallible;
14use crate::dom::bindings::reflector::reflect_dom_object_with_proto;
15use crate::dom::bindings::root::DomRoot;
16use crate::dom::bindings::serializable::Serializable;
17use crate::dom::bindings::structuredclone::StructuredData;
18use crate::dom::dompointreadonly::{DOMPointReadOnly, DOMPointWriteMethods};
19use crate::dom::globalscope::GlobalScope;
20use crate::script_runtime::CanGc;
21
22#[dom_struct]
24pub(crate) struct DOMPoint {
25 point: DOMPointReadOnly,
26}
27
28#[allow(non_snake_case)]
29impl DOMPoint {
30 fn new_inherited(x: f64, y: f64, z: f64, w: f64) -> DOMPoint {
31 DOMPoint {
32 point: DOMPointReadOnly::new_inherited(x, y, z, w),
33 }
34 }
35
36 pub(crate) fn new(
37 global: &GlobalScope,
38 x: f64,
39 y: f64,
40 z: f64,
41 w: f64,
42 can_gc: CanGc,
43 ) -> DomRoot<DOMPoint> {
44 Self::new_with_proto(global, None, x, y, z, w, can_gc)
45 }
46
47 fn new_with_proto(
48 global: &GlobalScope,
49 proto: Option<HandleObject>,
50 x: f64,
51 y: f64,
52 z: f64,
53 w: f64,
54 can_gc: CanGc,
55 ) -> DomRoot<DOMPoint> {
56 reflect_dom_object_with_proto(
57 Box::new(DOMPoint::new_inherited(x, y, z, w)),
58 global,
59 proto,
60 can_gc,
61 )
62 }
63
64 pub(crate) fn new_from_init(
65 global: &GlobalScope,
66 p: &DOMPointInit,
67 can_gc: CanGc,
68 ) -> DomRoot<DOMPoint> {
69 DOMPoint::new(global, p.x, p.y, p.z, p.w, can_gc)
70 }
71}
72
73impl DOMPointMethods<crate::DomTypeHolder> for DOMPoint {
74 fn Constructor(
76 global: &GlobalScope,
77 proto: Option<HandleObject>,
78 can_gc: CanGc,
79 x: f64,
80 y: f64,
81 z: f64,
82 w: f64,
83 ) -> Fallible<DomRoot<DOMPoint>> {
84 Ok(DOMPoint::new_with_proto(global, proto, x, y, z, w, can_gc))
85 }
86
87 fn FromPoint(global: &GlobalScope, init: &DOMPointInit, can_gc: CanGc) -> DomRoot<Self> {
89 Self::new_from_init(global, init, can_gc)
90 }
91
92 fn X(&self) -> f64 {
94 self.point.X()
95 }
96
97 fn SetX(&self, value: f64) {
99 self.point.SetX(value);
100 }
101
102 fn Y(&self) -> f64 {
104 self.point.Y()
105 }
106
107 fn SetY(&self, value: f64) {
109 self.point.SetY(value);
110 }
111
112 fn Z(&self) -> f64 {
114 self.point.Z()
115 }
116
117 fn SetZ(&self, value: f64) {
119 self.point.SetZ(value);
120 }
121
122 fn W(&self) -> f64 {
124 self.point.W()
125 }
126
127 fn SetW(&self, value: f64) {
129 self.point.SetW(value);
130 }
131}
132
133impl Serializable for DOMPoint {
134 type Index = DomPointIndex;
135 type Data = DomPoint;
136
137 fn serialize(&self) -> Result<(DomPointId, Self::Data), ()> {
138 let serialized = DomPoint {
139 x: self.X(),
140 y: self.Y(),
141 z: self.Z(),
142 w: self.W(),
143 };
144 Ok((DomPointId::new(), serialized))
145 }
146
147 fn deserialize(
148 owner: &GlobalScope,
149 serialized: Self::Data,
150 can_gc: CanGc,
151 ) -> Result<DomRoot<Self>, ()>
152 where
153 Self: Sized,
154 {
155 Ok(Self::new(
156 owner,
157 serialized.x,
158 serialized.y,
159 serialized.z,
160 serialized.w,
161 can_gc,
162 ))
163 }
164
165 fn serialized_storage<'a>(
166 data: StructuredData<'a, '_>,
167 ) -> &'a mut Option<FxHashMap<DomPointId, Self::Data>> {
168 match data {
169 StructuredData::Reader(reader) => &mut reader.points,
170 StructuredData::Writer(writer) => &mut writer.points,
171 }
172 }
173}