mirror of
https://github.com/servo/servo.git
synced 2025-06-10 01:23:13 +00:00
This is the last big change necessary to create the `constellation_traits` crate. This moves the data structure for messages that originate from the `ScriptThread` and are sent to the `Contellation` to `constellation_traits`, effectively splitting `script_traits` in half. Before, `script_traits` was responsible for exposing the API of both the `ScriptThread` and the `Constellation` to the rest of Servo. - Data structures that are used by `ScriptToConstellationMsg` are moved to `constellation_traits`. The dependency graph looks a bit like this: `script_layout_interface` depends on `script_traits` depends on `constellation_traits` depends on `embedder_traits`. - Data structures that are used in the embedding layer (`UntrustedNodeAddress`, `CompositorHitTestResult`, `TouchEventResult` and `AnimationState`) are moved to embedder_traits, to avoid a dependency cycle between `webrender_traits` and `constellation_traits`. - Types dealing with MessagePorts and serialization are moved to `constellation_traits::message_port`. Testing: This is covered by existing tests as it just moves types around. Signed-off-by: Martin Robinson <mrobinson@igalia.com> Signed-off-by: Martin Robinson <mrobinson@igalia.com>
209 lines
5.6 KiB
Rust
209 lines
5.6 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
use std::cell::Cell;
|
|
use std::collections::HashMap;
|
|
use std::num::NonZeroU32;
|
|
|
|
use base::id::{DomPointId, DomPointIndex, PipelineNamespaceId};
|
|
use constellation_traits::DomPoint;
|
|
use dom_struct::dom_struct;
|
|
use js::rust::HandleObject;
|
|
|
|
use crate::dom::bindings::codegen::Bindings::DOMPointBinding::DOMPointInit;
|
|
use crate::dom::bindings::codegen::Bindings::DOMPointReadOnlyBinding::DOMPointReadOnlyMethods;
|
|
use crate::dom::bindings::error::Fallible;
|
|
use crate::dom::bindings::reflector::{Reflector, reflect_dom_object_with_proto};
|
|
use crate::dom::bindings::root::DomRoot;
|
|
use crate::dom::bindings::serializable::{IntoStorageKey, Serializable, StorageKey};
|
|
use crate::dom::bindings::structuredclone::{StructuredData, StructuredDataReader};
|
|
use crate::dom::globalscope::GlobalScope;
|
|
use crate::script_runtime::CanGc;
|
|
|
|
// http://dev.w3.org/fxtf/geometry/Overview.html#dompointreadonly
|
|
#[dom_struct]
|
|
pub(crate) struct DOMPointReadOnly {
|
|
reflector_: Reflector,
|
|
x: Cell<f64>,
|
|
y: Cell<f64>,
|
|
z: Cell<f64>,
|
|
w: Cell<f64>,
|
|
}
|
|
|
|
#[allow(non_snake_case)]
|
|
impl DOMPointReadOnly {
|
|
pub(crate) fn new_inherited(x: f64, y: f64, z: f64, w: f64) -> DOMPointReadOnly {
|
|
DOMPointReadOnly {
|
|
x: Cell::new(x),
|
|
y: Cell::new(y),
|
|
z: Cell::new(z),
|
|
w: Cell::new(w),
|
|
reflector_: Reflector::new(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn new(
|
|
global: &GlobalScope,
|
|
x: f64,
|
|
y: f64,
|
|
z: f64,
|
|
w: f64,
|
|
can_gc: CanGc,
|
|
) -> DomRoot<DOMPointReadOnly> {
|
|
Self::new_with_proto(global, None, x, y, z, w, can_gc)
|
|
}
|
|
|
|
fn new_with_proto(
|
|
global: &GlobalScope,
|
|
proto: Option<HandleObject>,
|
|
x: f64,
|
|
y: f64,
|
|
z: f64,
|
|
w: f64,
|
|
can_gc: CanGc,
|
|
) -> DomRoot<DOMPointReadOnly> {
|
|
reflect_dom_object_with_proto(
|
|
Box::new(DOMPointReadOnly::new_inherited(x, y, z, w)),
|
|
global,
|
|
proto,
|
|
can_gc,
|
|
)
|
|
}
|
|
}
|
|
|
|
#[allow(non_snake_case)]
|
|
impl DOMPointReadOnlyMethods<crate::DomTypeHolder> for DOMPointReadOnly {
|
|
// https://drafts.fxtf.org/geometry/#dom-dompoint-dompoint
|
|
fn Constructor(
|
|
global: &GlobalScope,
|
|
proto: Option<HandleObject>,
|
|
can_gc: CanGc,
|
|
x: f64,
|
|
y: f64,
|
|
z: f64,
|
|
w: f64,
|
|
) -> Fallible<DomRoot<DOMPointReadOnly>> {
|
|
Ok(DOMPointReadOnly::new_with_proto(
|
|
global, proto, x, y, z, w, can_gc,
|
|
))
|
|
}
|
|
|
|
// https://drafts.fxtf.org/geometry/#dom-dompointreadonly-frompoint
|
|
fn FromPoint(global: &GlobalScope, init: &DOMPointInit, can_gc: CanGc) -> DomRoot<Self> {
|
|
Self::new(global, init.x, init.y, init.z, init.w, can_gc)
|
|
}
|
|
|
|
// https://dev.w3.org/fxtf/geometry/Overview.html#dom-dompointreadonly-x
|
|
fn X(&self) -> f64 {
|
|
self.x.get()
|
|
}
|
|
|
|
// https://dev.w3.org/fxtf/geometry/Overview.html#dom-dompointreadonly-y
|
|
fn Y(&self) -> f64 {
|
|
self.y.get()
|
|
}
|
|
|
|
// https://dev.w3.org/fxtf/geometry/Overview.html#dom-dompointreadonly-z
|
|
fn Z(&self) -> f64 {
|
|
self.z.get()
|
|
}
|
|
|
|
// https://dev.w3.org/fxtf/geometry/Overview.html#dom-dompointreadonly-w
|
|
fn W(&self) -> f64 {
|
|
self.w.get()
|
|
}
|
|
}
|
|
|
|
#[allow(non_snake_case)]
|
|
pub(crate) trait DOMPointWriteMethods {
|
|
fn SetX(&self, value: f64);
|
|
fn SetY(&self, value: f64);
|
|
fn SetZ(&self, value: f64);
|
|
fn SetW(&self, value: f64);
|
|
}
|
|
|
|
impl DOMPointWriteMethods for DOMPointReadOnly {
|
|
fn SetX(&self, value: f64) {
|
|
self.x.set(value);
|
|
}
|
|
|
|
fn SetY(&self, value: f64) {
|
|
self.y.set(value);
|
|
}
|
|
|
|
fn SetZ(&self, value: f64) {
|
|
self.z.set(value);
|
|
}
|
|
|
|
fn SetW(&self, value: f64) {
|
|
self.w.set(value);
|
|
}
|
|
}
|
|
|
|
impl Serializable for DOMPointReadOnly {
|
|
type Id = DomPointId;
|
|
type Data = DomPoint;
|
|
|
|
fn serialize(&self) -> Result<(Self::Id, Self::Data), ()> {
|
|
let serialized = DomPoint {
|
|
x: self.x.get(),
|
|
y: self.y.get(),
|
|
z: self.z.get(),
|
|
w: self.w.get(),
|
|
};
|
|
Ok((DomPointId::new(), serialized))
|
|
}
|
|
|
|
fn deserialize(
|
|
owner: &GlobalScope,
|
|
serialized: Self::Data,
|
|
can_gc: CanGc,
|
|
) -> Result<DomRoot<Self>, ()>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
Ok(Self::new(
|
|
owner,
|
|
serialized.x,
|
|
serialized.y,
|
|
serialized.z,
|
|
serialized.w,
|
|
can_gc,
|
|
))
|
|
}
|
|
|
|
fn serialized_storage(data: StructuredData<'_>) -> &mut Option<HashMap<Self::Id, Self::Data>> {
|
|
match data {
|
|
StructuredData::Reader(r) => &mut r.points,
|
|
StructuredData::Writer(w) => &mut w.points,
|
|
}
|
|
}
|
|
|
|
fn deserialized_storage(
|
|
reader: &mut StructuredDataReader,
|
|
) -> &mut Option<HashMap<StorageKey, DomRoot<Self>>> {
|
|
&mut reader.points_read_only
|
|
}
|
|
}
|
|
|
|
impl From<StorageKey> for DomPointId {
|
|
fn from(storage_key: StorageKey) -> DomPointId {
|
|
let namespace_id = PipelineNamespaceId(storage_key.name_space);
|
|
let index = DomPointIndex(
|
|
NonZeroU32::new(storage_key.index).expect("Deserialized point index is zero"),
|
|
);
|
|
|
|
DomPointId {
|
|
namespace_id,
|
|
index,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl IntoStorageKey for DomPointId {
|
|
fn into_storage_key(self) -> StorageKey {
|
|
let DomPointIndex(index) = self.index;
|
|
StorageKey::new(self.namespace_id, index)
|
|
}
|
|
}
|