1use std::default::Default;
6
7use embedder_traits::EmbedderMsg;
8use html5ever::{local_name, ns};
9use js::context::{JSContext, NoGC};
10use js::realm::CurrentRealm;
11use script_bindings::cell::DomRefCell;
12use servo_config::pref;
13use stylo_dom::ElementState;
14
15use crate::dom::RootedPromise;
16use crate::dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
17use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
18use crate::dom::bindings::error::Error;
19use crate::dom::bindings::inheritance::Castable;
20use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
21use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
22use crate::dom::document::document::Document;
23use crate::dom::element::element::Element;
24use crate::dom::event::event::{EventBubbles, EventCancelable, EventComposed};
25use crate::dom::event::eventtarget::EventTarget;
26use crate::dom::html::interactive::htmldialogelement::HTMLDialogElement;
27use crate::dom::node::NodeTraits;
28use crate::dom::promise::Promise;
29use crate::messaging::{CommonScriptMsg, MainThreadScriptMsg};
30use crate::runtime::script_runtime::ScriptThreadEventCategory;
31use crate::tasks::task::TaskOnce;
32use crate::tasks::task_source::TaskSourceName;
33
34#[derive(JSTraceable, MallocSizeOf)]
38#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
39pub(crate) struct DocumentOverlayHandler {
40 document: Dom<Document>,
42 fullscreen_element: MutNullableDom<Element>,
44 top_layer: DomRefCell<Vec<Dom<Element>>>,
46 pending_top_layer_removals: DomRefCell<Vec<Dom<Element>>>,
48 topmost_modal: MutNullableDom<Element>,
50 open_dialogs_list: DomRefCell<Vec<Dom<HTMLDialogElement>>>,
52 dialog_pointerdown_target: MutNullableDom<HTMLDialogElement>,
54}
55
56impl DocumentOverlayHandler {
57 pub(crate) fn new(document: &Document) -> Self {
58 Self {
59 document: Dom::from_ref(document),
60 fullscreen_element: MutNullableDom::new(None),
61 top_layer: Default::default(),
62 pending_top_layer_removals: Default::default(),
63 topmost_modal: Default::default(),
64 open_dialogs_list: Default::default(),
65 dialog_pointerdown_target: Default::default(),
66 }
67 }
68
69 pub(crate) fn fullscreen_element(&self) -> Option<DomRoot<Element>> {
70 self.fullscreen_element.get()
71 }
72
73 pub(crate) fn set_fullscreen_element(&self, element: Option<&Element>) {
74 self.fullscreen_element.set(element);
75 }
76
77 pub(crate) fn fully_exit_fullscreen(&self, cx: &mut JSContext) {
79 if self.fullscreen_element().is_none() {
82 return;
83 };
84
85 let _ = self.exit_fullscreen(cx);
90 }
91
92 pub(crate) fn enter_fullscreen(
94 &self,
95 cx: &mut CurrentRealm,
96 pending: &Element,
97 ) -> RootedPromise {
98 let document = pending.owner_document();
101
102 let promise = Promise::new_in_realm(cx);
105
106 if !document.is_fully_active() {
109 promise.reject_error(cx, Error::Type(c"Document is not fully active".to_owned()));
110 return promise;
111 }
112
113 let mut error = false;
116
117 {
120 match *pending.namespace() {
122 ns!(mathml) => {
123 if *pending.local_name() != local_name!("math") {
124 error = true;
125 }
126 },
127 ns!(svg) => {
128 if *pending.local_name() != local_name!("svg") {
129 error = true;
130 }
131 },
132 ns!(html) => (),
133 _ => error = true,
134 }
135
136 if pending.is::<HTMLDialogElement>() {
138 error = true;
139 }
140
141 if !pending.fullscreen_element_ready_check() {
143 error = true;
144 }
145
146 if !pending.owner_window().has_transient_activation() {
154 error = true;
155 }
156 }
157
158 if pref!(dom_fullscreen_test) {
159 info!("Tests don't really enter fullscreen.");
162 } else {
163 warn!("Fullscreen not supported yet");
166 }
167
168 if !error {
171 pending
172 .owner_window_unrooted(cx.no_gc())
173 .consume_user_activation();
174 }
175
176 if !error {
182 let event = EmbedderMsg::NotifyFullscreenStateChanged(document.webview_id(), true);
183 document.send_to_embedder(event);
184 }
185
186 let pipeline_id = self.document.window().pipeline_id();
189
190 let trusted_pending = Trusted::new(pending);
191 let trusted_pending_doc = Trusted::new(&*document);
192 let trusted_promise = TrustedPromise::from(&promise);
193 let handler = ElementPerformFullscreenEnter::new(
194 trusted_pending,
195 trusted_pending_doc,
196 trusted_promise,
197 error,
198 );
199 let script_msg = CommonScriptMsg::Task(
200 ScriptThreadEventCategory::EnterFullscreen,
201 handler,
202 Some(pipeline_id),
203 TaskSourceName::DOMManipulation,
204 );
205 let msg = MainThreadScriptMsg::Common(script_msg);
206 self.document
207 .window()
208 .main_thread_script_chan()
209 .send(msg)
210 .unwrap();
211
212 promise
213 }
214
215 pub(crate) fn exit_fullscreen(&self, cx: &mut JSContext) -> RootedPromise {
217 let document = &*self.document;
218
219 let mut realm = CurrentRealm::assert(cx);
222 let promise = Promise::new_in_realm(&mut realm);
223
224 if !document.is_fully_active() || self.fullscreen_element().is_none() {
227 promise.reject_error(
228 cx,
229 Error::Type(
230 c"No fullscreen element to exit or document is not fully active".to_owned(),
231 ),
232 );
233 return promise;
234 }
235
236 let element = self.fullscreen_element().unwrap();
239 let event = EmbedderMsg::NotifyFullscreenStateChanged(document.webview_id(), false);
243 document.send_to_embedder(event);
244
245 let trusted_element = Trusted::new(&*element);
248 let trusted_promise = TrustedPromise::from(&promise);
249 let handler = ElementPerformFullscreenExit::new(trusted_element, trusted_promise);
250 let pipeline_id = Some(self.document.window().pipeline_id());
251 let script_msg = CommonScriptMsg::Task(
252 ScriptThreadEventCategory::ExitFullscreen,
253 handler,
254 pipeline_id,
255 TaskSourceName::DOMManipulation,
256 );
257 let msg = MainThreadScriptMsg::Common(script_msg);
258 self.document
259 .window()
260 .main_thread_script_chan()
261 .send(msg)
262 .unwrap();
263
264 promise
265 }
266
267 pub(crate) fn get_allow_fullscreen(&self) -> bool {
269 match self.document.browsing_context() {
270 None => false,
272 Some(_) => {
273 if self.document.window().is_top_level() {
275 true
276 } else {
277 self.document
279 .window()
280 .GetFrameElement()
281 .is_some_and(|el| el.has_attribute(&local_name!("allowfullscreen")))
282 }
283 },
284 }
285 }
286
287 pub(crate) fn open_dialogs_list_contains(&self, dialog: &HTMLDialogElement) -> bool {
288 self.open_dialogs_list
289 .borrow()
290 .iter()
291 .any(|open_dialog| &**open_dialog == dialog)
292 }
293
294 pub(crate) fn add_to_open_dialogs_list(&self, dialog: &HTMLDialogElement, no_gc: &NoGC) {
295 self.open_dialogs_list
296 .safe_borrow_mut(no_gc)
297 .push(Dom::from_ref(dialog));
298 }
299
300 pub(crate) fn remove_from_open_dialogs_list(&self, dialog: &HTMLDialogElement, no_gc: &NoGC) {
301 self.open_dialogs_list
302 .safe_borrow_mut(no_gc)
303 .retain(|open| &**open != dialog);
304 }
305
306 pub(crate) fn topmost_open_dialog(&self) -> Option<DomRoot<HTMLDialogElement>> {
307 self.open_dialogs_list
308 .borrow()
309 .last()
310 .map(|dialog| dialog.as_rooted())
311 }
312
313 pub(crate) fn dialog_pointerdown_target(&self) -> Option<DomRoot<HTMLDialogElement>> {
314 self.dialog_pointerdown_target.get()
315 }
316
317 pub(crate) fn set_dialog_pointerdown_target(&self, dialog: Option<&HTMLDialogElement>) {
318 self.dialog_pointerdown_target.set(dialog);
319 }
320
321 pub(crate) fn top_layer_contains(&self, element: &Element) -> bool {
322 self.top_layer
323 .borrow()
324 .iter()
325 .any(|top_layer_element| &**top_layer_element == element)
326 }
327
328 fn pending_top_layer_removals_contains(&self, element: &Element) -> bool {
329 self.pending_top_layer_removals
330 .borrow()
331 .iter()
332 .any(|pending_element| &**pending_element == element)
333 }
334
335 pub(crate) fn is_in_the_top_layer(&self, element: &Element) -> bool {
337 self.top_layer_contains(element) && !self.pending_top_layer_removals_contains(element)
340 }
341
342 pub(crate) fn add_an_element_to_the_top_layer(&self, element: &Element, no_gc: &NoGC) {
344 if self.top_layer_contains(element) {
348 assert!(self.pending_top_layer_removals_contains(element));
351
352 self.top_layer
354 .safe_borrow_mut(no_gc)
355 .retain(|top_layer_element| &**top_layer_element != element);
356 self.pending_top_layer_removals
357 .safe_borrow_mut(no_gc)
358 .retain(|pending_element| &**pending_element != element);
359 }
360
361 self.top_layer
363 .safe_borrow_mut(no_gc)
364 .push(Dom::from_ref(element));
365
366 self.update_topmost_modal(no_gc);
370 }
371
372 pub(crate) fn request_an_element_to_be_removed_from_the_top_layer(
374 &self,
375 element: &Element,
376 no_gc: &NoGC,
377 ) {
378 if !self.top_layer_contains(element) || self.pending_top_layer_removals_contains(element) {
383 return;
384 }
385
386 self.pending_top_layer_removals
390 .safe_borrow_mut(no_gc)
391 .push(Dom::from_ref(element));
392
393 self.update_topmost_modal(no_gc);
394 }
395
396 pub(crate) fn remove_an_element_from_the_top_layer_immediately(
398 &self,
399 element: &Element,
400 no_gc: &NoGC,
401 ) {
402 self.top_layer
406 .safe_borrow_mut(no_gc)
407 .retain(|top_layer_element| &**top_layer_element != element);
408 self.pending_top_layer_removals
409 .safe_borrow_mut(no_gc)
410 .retain(|pending_element| &**pending_element != element);
411
412 self.update_topmost_modal(no_gc);
415 }
416
417 pub(crate) fn process_top_layer_removals(&self, cx: &mut JSContext) {
419 let pending_removals: Vec<_> = self
423 .pending_top_layer_removals
424 .borrow()
425 .iter()
426 .map(|element| DomRoot::from_ref(&**element))
427 .collect();
428 for element in pending_removals {
429 if !element.has_css_layout_box(cx) {
430 self.remove_an_element_from_the_top_layer_immediately(&element, cx)
431 }
432 }
433 }
434
435 pub fn update_topmost_modal(&self, no_gc: &NoGC) {
437 let new_topmost_modal = self
440 .top_layer
441 .borrow()
442 .iter()
443 .rev()
444 .find(|element| {
445 element.state().contains(ElementState::MODAL) &&
446 !self.pending_top_layer_removals_contains(element)
447 })
448 .map(|element| DomRoot::from_ref(&**element));
449 let old_topmost_modal = self.topmost_modal.get();
450
451 if let Some(old_topmost_modal) = old_topmost_modal {
452 old_topmost_modal.set_state(no_gc, ElementState::TOPMOST_MODAL, false);
453 }
454 if let Some(new_topmost_modal) = &new_topmost_modal {
455 new_topmost_modal.set_state(no_gc, ElementState::TOPMOST_MODAL, true);
456 }
457
458 self.topmost_modal.set(new_topmost_modal.as_deref());
459
460 if let Some(document_element) = self.document.GetDocumentElement() {
463 let is_inert = new_topmost_modal.is_some() ||
464 document_element.has_attribute(&local_name!("inert"));
465 document_element.set_state(no_gc, ElementState::INERT, is_inert);
466 }
467 }
468
469 pub(crate) fn is_blocked_by_a_modal_dialog(&self) -> bool {
471 self.topmost_modal.get().is_some()
472 }
473}
474
475struct ElementPerformFullscreenEnter {
476 element: Trusted<Element>,
477 document: Trusted<Document>,
478 promise: TrustedPromise,
479 error: bool,
480}
481
482impl ElementPerformFullscreenEnter {
483 fn new(
484 element: Trusted<Element>,
485 document: Trusted<Document>,
486 promise: TrustedPromise,
487 error: bool,
488 ) -> Box<ElementPerformFullscreenEnter> {
489 Box::new(ElementPerformFullscreenEnter {
490 element,
491 document,
492 promise,
493 error,
494 })
495 }
496}
497
498impl TaskOnce for ElementPerformFullscreenEnter {
499 fn run_once(self, cx: &mut js::context::JSContext) {
501 let element = self.element.root();
502 let promise = self.promise.root(cx);
503 let document = element.owner_document();
504
505 if self.document.root() != document ||
514 !element.fullscreen_element_ready_check() ||
515 self.error
516 {
517 document
519 .upcast::<EventTarget>()
520 .fire_event(cx, atom!("fullscreenerror"));
521 promise.reject_error(cx, Error::Type(c"fullscreen is not connected".to_owned()));
522 return;
523 }
524
525 element.set_fullscreen_state(cx.no_gc(), true);
528 document
529 .overlay_handler()
530 .set_fullscreen_element(Some(&element));
531 document.upcast::<EventTarget>().fire_event_with_params(
532 cx,
533 atom!("fullscreenchange"),
534 EventBubbles::Bubbles,
535 EventCancelable::NotCancelable,
536 EventComposed::Composed,
537 );
538
539 promise.resolve_native(cx, &());
542 }
543}
544
545struct ElementPerformFullscreenExit {
546 element: Trusted<Element>,
547 promise: TrustedPromise,
548}
549
550impl ElementPerformFullscreenExit {
551 fn new(
552 element: Trusted<Element>,
553 promise: TrustedPromise,
554 ) -> Box<ElementPerformFullscreenExit> {
555 Box::new(ElementPerformFullscreenExit { element, promise })
556 }
557}
558
559impl TaskOnce for ElementPerformFullscreenExit {
560 fn run_once(self, cx: &mut js::context::JSContext) {
562 let element = self.element.root();
563 let document = element.owner_document();
564 element.set_fullscreen_state(cx.no_gc(), false);
571 document.overlay_handler().set_fullscreen_element(None);
572 document.upcast::<EventTarget>().fire_event_with_params(
573 cx,
574 atom!("fullscreenchange"),
575 EventBubbles::Bubbles,
576 EventCancelable::NotCancelable,
577 EventComposed::Composed,
578 );
579
580 self.promise.root(cx).resolve_native(cx, &());
583 }
584}