use std::rc::Rc;
use app_units::Au;
use dom_struct::dom_struct;
use euclid::default::Rect;
use js::rust::HandleObject;
use crate::dom::bindings::callback::ExceptionHandling;
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::ResizeObserverBinding::{
ResizeObserverBoxOptions, ResizeObserverCallback, ResizeObserverMethods, ResizeObserverOptions,
};
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::reflector::{reflect_dom_object_with_proto, Reflector};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::domrectreadonly::DOMRectReadOnly;
use crate::dom::element::Element;
use crate::dom::node::{window_from_node, Node};
use crate::dom::resizeobserverentry::ResizeObserverEntry;
use crate::dom::resizeobserversize::{ResizeObserverSize, ResizeObserverSizeImpl};
use crate::dom::window::Window;
use crate::script_runtime::CanGc;
use crate::script_thread::ScriptThread;
#[derive(Debug, Default, PartialEq, PartialOrd)]
pub struct ResizeObservationDepth(usize);
impl ResizeObservationDepth {
pub fn max() -> ResizeObservationDepth {
ResizeObservationDepth(usize::MAX)
}
}
#[dom_struct]
pub struct ResizeObserver {
reflector_: Reflector,
#[ignore_malloc_size_of = "Rc are hard"]
callback: Rc<ResizeObserverCallback>,
observation_targets: DomRefCell<Vec<(ResizeObservation, Dom<Element>)>>,
}
impl ResizeObserver {
pub fn new_inherited(callback: Rc<ResizeObserverCallback>) -> ResizeObserver {
ResizeObserver {
reflector_: Reflector::new(),
callback,
observation_targets: Default::default(),
}
}
fn new(
window: &Window,
proto: Option<HandleObject>,
callback: Rc<ResizeObserverCallback>,
can_gc: CanGc,
) -> DomRoot<ResizeObserver> {
let observer = Box::new(ResizeObserver::new_inherited(callback));
reflect_dom_object_with_proto(observer, window, proto, can_gc)
}
#[allow(non_snake_case)]
pub fn Constructor(
window: &Window,
proto: Option<HandleObject>,
can_gc: CanGc,
callback: Rc<ResizeObserverCallback>,
) -> DomRoot<ResizeObserver> {
let rooted_observer = ResizeObserver::new(window, proto, callback, can_gc);
let document = window.Document();
document.add_resize_observer(&rooted_observer);
rooted_observer
}
pub fn gather_active_resize_observations_at_depth(
&self,
depth: &ResizeObservationDepth,
has_active: &mut bool,
) {
for (observation, target) in self.observation_targets.borrow_mut().iter_mut() {
observation.state = Default::default();
if let Some(size) = observation.is_active(target) {
let target_depth = calculate_depth_for_node(target);
if target_depth > *depth {
observation.state = ObservationState::Active(size);
*has_active = true;
} else {
observation.state = ObservationState::Skipped;
}
}
}
}
pub fn broadcast_active_resize_observations(
&self,
shallowest_target_depth: &mut ResizeObservationDepth,
) {
let mut entries: Vec<DomRoot<ResizeObserverEntry>> = Default::default();
for (observation, target) in self.observation_targets.borrow_mut().iter_mut() {
let ObservationState::Active(box_size) = observation.state else {
continue;
};
let width = box_size.width().to_f64_px();
let height = box_size.height().to_f64_px();
let size_impl = ResizeObserverSizeImpl::new(width, height);
let window = window_from_node(&**target);
let observer_size = ResizeObserverSize::new(&window, size_impl);
let content_rect = DOMRectReadOnly::new(
window.upcast(),
None,
box_size.origin.x.to_f64_px(),
box_size.origin.y.to_f64_px(),
width,
height,
CanGc::note(),
);
let entry = ResizeObserverEntry::new(
&window,
target,
&content_rect,
&[],
&[&*observer_size],
&[],
);
entries.push(entry);
observation.last_reported_sizes[0] = size_impl;
observation.state = ObservationState::Done;
let target_depth = calculate_depth_for_node(target);
if target_depth < *shallowest_target_depth {
*shallowest_target_depth = target_depth;
}
}
let _ = self
.callback
.Call_(self, entries, self, ExceptionHandling::Report);
}
pub fn has_skipped_resize_observations(&self) -> bool {
self.observation_targets
.borrow()
.iter()
.any(|(observation, _)| observation.state == ObservationState::Skipped)
}
}
impl ResizeObserverMethods for ResizeObserver {
fn Observe(&self, target: &Element, options: &ResizeObserverOptions) {
let is_present = self
.observation_targets
.borrow()
.iter()
.any(|(_obs, other)| &**other == target);
if is_present {
self.Unobserve(target);
}
let resize_observation = ResizeObservation::new(options.box_);
self.observation_targets
.borrow_mut()
.push((resize_observation, Dom::from_ref(target)));
ScriptThread::note_rendering_opportunity(window_from_node(target).pipeline_id());
}
fn Unobserve(&self, target: &Element) {
self.observation_targets
.borrow_mut()
.retain_mut(|(_obs, other)| !(&**other == target));
}
fn Disconnect(&self) {
self.observation_targets.borrow_mut().clear();
}
}
#[derive(Default, MallocSizeOf, PartialEq)]
enum ObservationState {
#[default]
Done,
Active(Rect<Au>),
Skipped,
}
#[derive(JSTraceable, MallocSizeOf)]
struct ResizeObservation {
observed_box: ResizeObserverBoxOptions,
last_reported_sizes: Vec<ResizeObserverSizeImpl>,
#[no_trace]
state: ObservationState,
}
impl ResizeObservation {
pub fn new(observed_box: ResizeObserverBoxOptions) -> ResizeObservation {
let size_impl = ResizeObserverSizeImpl::new(0.0, 0.0);
ResizeObservation {
observed_box,
last_reported_sizes: vec![size_impl],
state: Default::default(),
}
}
fn is_active(&self, target: &Element) -> Option<Rect<Au>> {
let last_reported_size = self.last_reported_sizes[0];
let box_size = calculate_box_size(target, &self.observed_box);
let is_active = box_size.width().to_f64_px() != last_reported_size.inline_size() ||
box_size.height().to_f64_px() != last_reported_size.block_size();
if is_active {
Some(box_size)
} else {
None
}
}
}
fn calculate_depth_for_node(target: &Element) -> ResizeObservationDepth {
let node = target.upcast::<Node>();
let depth = node.ancestors().count();
ResizeObservationDepth(depth)
}
fn calculate_box_size(target: &Element, observed_box: &ResizeObserverBoxOptions) -> Rect<Au> {
match observed_box {
ResizeObserverBoxOptions::Content_box => {
target
.upcast::<Node>()
.content_boxes()
.pop()
.unwrap_or_else(Rect::zero)
},
_ => Rect::zero(),
}
}