blitz-pdf 0.1.2 → 0.1.4

package/vendor/blitz-dom/src/events/driver.rs

@@ -0,0 +1,427 @@
+use crate::Document;
+use blitz_traits::events::{
+    BlitzPointerEvent, BlitzPointerId, DomEvent, DomEventData, EventState, Point, PointerCoords,
+    UiEvent,
+};
+use blitz_traits::node_id::NodeId;
+use std::collections::VecDeque;
+
+pub trait EventHandler {
+    fn handle_event(
+        &mut self,
+        chain: &[NodeId],
+        event: &mut DomEvent,
+        doc: &mut dyn Document,
+        event_state: &mut EventState,
+    );
+}
+
+pub struct NoopEventHandler;
+impl EventHandler for NoopEventHandler {
+    fn handle_event(
+        &mut self,
+        _chain: &[NodeId],
+        _event: &mut DomEvent,
+        _doc: &mut dyn Document,
+        _event_state: &mut EventState,
+    ) {
+        // Do nothing
+    }
+}
+
+pub struct EventDriver<'doc, Handler: EventHandler> {
+    doc: &'doc mut dyn Document,
+    handler: Handler,
+    queue: VecDeque<DomEvent>,
+}
+
+impl<'doc, Handler: EventHandler> EventDriver<'doc, Handler> {
+    pub fn new(doc: &'doc mut dyn Document, handler: Handler) -> Self {
+        EventDriver {
+            doc,
+            handler,
+            queue: VecDeque::with_capacity(4),
+        }
+    }
+
+    pub fn handle_pointer_move(&mut self, event: &BlitzPointerEvent) -> Option<NodeId> {
+        let mut doc = self.doc.inner_mut();
+
+        let prev_hover_node_id = doc.hover_node_id;
+        let changed = doc.set_hover_to(event.page_x(), event.page_y());
+        let hover_node_id = doc.hover_node_id;
+
+        drop(doc);
+
+        if !changed {
+            return prev_hover_node_id;
+        }
+
+        self.dispatch_hover_change(prev_hover_node_id, hover_node_id, event);
+
+        hover_node_id
+    }
+
+    /// End hover when the pointer leaves the document, dispatching out/leave
+    /// events to the previously hovered chain
+    pub fn handle_pointer_leave(&mut self, event: &BlitzPointerEvent) {
+        let mut doc = self.doc.inner_mut();
+        let prev_hover_node_id = doc.hover_node_id;
+        doc.clear_hover();
+        drop(doc);
+
+        self.dispatch_hover_change(prev_hover_node_id, None, event);
+    }
+
+    fn dispatch_hover_change(
+        &mut self,
+        prev_hover_node_id: Option<NodeId>,
+        hover_node_id: Option<NodeId>,
+        event: &BlitzPointerEvent,
+    ) {
+        let doc = self.doc.inner();
+        let mut old_chain = prev_hover_node_id
+            .map(|id| doc.node_chain(id))
+            .unwrap_or_default();
+        let mut new_chain = hover_node_id
+            .map(|id| doc.node_chain(id))
+            .unwrap_or_default();
+        old_chain.reverse();
+        new_chain.reverse();
+
+        // Find the difference in the node chain of the last hovered objected and the newest
+        let old_len = old_chain.len();
+        let new_len = new_chain.len();
+
+        let first_difference_index = old_chain
+            .iter()
+            .zip(&new_chain)
+            .position(|(old, new)| old != new)
+            .unwrap_or_else(|| old_len.min(new_len));
+
+        drop(doc);
+
+        let is_mouse = event.is_mouse();
+
+        if let Some(target) = prev_hover_node_id {
+            self.handle_dom_event(DomEvent::new(
+                target,
+                DomEventData::PointerOut(event.clone()),
+            ));
+            if is_mouse {
+                self.handle_dom_event(DomEvent::new(target, DomEventData::MouseOut(event.clone())));
+            }
+
+            // Send an mouseleave event to all old elements on the chain
+            for node_id in old_chain
+                .get(first_difference_index..)
+                .unwrap_or(&[])
+                .iter()
+            {
+                self.handle_dom_event(DomEvent::new(
+                    *node_id,
+                    DomEventData::PointerLeave(event.clone()),
+                ));
+                if is_mouse {
+                    self.handle_dom_event(DomEvent::new(
+                        *node_id,
+                        DomEventData::MouseLeave(event.clone()),
+                    ));
+                }
+            }
+        }
+
+        if let Some(target) = hover_node_id {
+            self.handle_dom_event(DomEvent::new(
+                target,
+                DomEventData::PointerOver(event.clone()),
+            ));
+
+            if is_mouse {
+                self.handle_dom_event(DomEvent::new(
+                    target,
+                    DomEventData::MouseOver(event.clone()),
+                ));
+            }
+
+            // Send an mouseenter event to all new elements on the chain
+            for node_id in new_chain
+                .get(first_difference_index..)
+                .unwrap_or(&[])
+                .iter()
+            {
+                self.handle_dom_event(DomEvent::new(
+                    *node_id,
+                    DomEventData::PointerEnter(event.clone()),
+                ));
+
+                if is_mouse {
+                    self.handle_dom_event(DomEvent::new(
+                        *node_id,
+                        DomEventData::MouseEnter(event.clone()),
+                    ));
+                }
+            }
+        }
+    }
+
+    pub fn handle_ui_event(&mut self, event: UiEvent) {
+        let doc = self.doc.inner();
+
+        // A non-hovering pointer (finger) ends hover once it is lifted or cancelled
+        let mut hover_end_event = None;
+        let mut hover_node_id = doc.hover_node_id;
+        let focussed_node_id = doc.focus_node_id;
+        let prev_hover = doc.hover_state();
+        drop(doc);
+
+        // A document the pointer has left has no say over the cursor
+        let is_leave = matches!(event, UiEvent::PointerLeave(_));
+
+        // Update document input state (hover, focus, active, etc)
+        match &event {
+            UiEvent::PointerMove(event) => {
+                hover_node_id = self.handle_pointer_move(event);
+            }
+            UiEvent::PointerDown(event) => {
+                hover_node_id = self.handle_pointer_move(event);
+                let mut doc = self.doc.inner_mut();
+                doc.active_node();
+                doc.set_mousedown_node_id(hover_node_id);
+            }
+            UiEvent::PointerUp(event) => {
+                hover_node_id = self.handle_pointer_move(event);
+                let mut doc = self.doc.inner_mut();
+                doc.unactive_node();
+
+                if event.is_primary && matches!(event.id, BlitzPointerId::Finger(_)) {
+                    hover_end_event = Some(event.clone());
+                }
+            }
+            UiEvent::PointerCancel(event) => {
+                hover_node_id = self.handle_pointer_move(event);
+                let mut doc = self.doc.inner_mut();
+                doc.unactive_node();
+
+                if event.is_primary && matches!(event.id, BlitzPointerId::Finger(_)) {
+                    hover_end_event = Some(event.clone());
+                }
+            }
+            UiEvent::PointerLeave(event) => {
+                self.handle_pointer_leave(event);
+                hover_node_id = None;
+            }
+            _ => {}
+        };
+
+        let target = match event {
+            UiEvent::PointerMove(_) => hover_node_id,
+            UiEvent::PointerUp(_) => hover_node_id,
+            UiEvent::PointerDown(_) => hover_node_id,
+            UiEvent::PointerCancel(_) => hover_node_id,
+            UiEvent::PointerLeave(_) => hover_node_id,
+            UiEvent::Wheel(_) => hover_node_id,
+            UiEvent::KeyUp(_) => focussed_node_id,
+            UiEvent::KeyDown(_) => focussed_node_id,
+            UiEvent::Ime(_) => focussed_node_id,
+            UiEvent::AppleStandardKeybinding(_) => focussed_node_id,
+        };
+        // Fall back to the root element. A document without a root element (e.g. an
+        // empty iframe sub-document) has no event target, so there is nothing to do.
+        let Some(target) = target.or_else(|| self.doc.inner().try_root_element().map(|el| el.id))
+        else {
+            return;
+        };
+
+        match event {
+            UiEvent::PointerMove(data) => {
+                self.handle_pointer_event(
+                    target,
+                    data,
+                    DomEventData::PointerMove,
+                    Some(DomEventData::MouseMove),
+                    DomEventData::TouchMove,
+                );
+            }
+            UiEvent::PointerUp(data) => {
+                self.handle_pointer_event(
+                    target,
+                    data,
+                    DomEventData::PointerUp,
+                    Some(DomEventData::MouseUp),
+                    DomEventData::TouchEnd,
+                );
+            }
+            UiEvent::PointerDown(data) => {
+                self.handle_pointer_event(
+                    target,
+                    data,
+                    DomEventData::PointerDown,
+                    Some(DomEventData::MouseDown),
+                    DomEventData::TouchStart,
+                );
+            }
+            UiEvent::PointerCancel(data) => {
+                // `pointercancel` has no mouse-compatibility event, but does
+                // generate a `touchcancel` for touch-like inputs.
+                self.handle_pointer_event(
+                    target,
+                    data,
+                    DomEventData::PointerCancel,
+                    None::<fn(BlitzPointerEvent) -> DomEventData>,
+                    DomEventData::TouchCancel,
+                );
+            }
+            // Out/leave events were dispatched by `handle_pointer_leave`
+            UiEvent::PointerLeave(_) => {}
+            UiEvent::Wheel(data) => {
+                self.handle_dom_event(DomEvent::new(target, DomEventData::Wheel(data)))
+            }
+            UiEvent::KeyUp(data) => {
+                self.handle_dom_event(DomEvent::new(target, DomEventData::KeyUp(data)))
+            }
+            UiEvent::KeyDown(data) => {
+                self.handle_dom_event(DomEvent::new(target, DomEventData::KeyDown(data)))
+            }
+            UiEvent::Ime(data) => {
+                self.handle_dom_event(DomEvent::new(target, DomEventData::Ime(data)))
+            }
+            UiEvent::AppleStandardKeybinding(data) => {
+                let mut dom_event =
+                    DomEvent::new(target, DomEventData::AppleStandardKeybinding(data));
+                self.run_default_action(&mut dom_event);
+                self.process_queue();
+            }
+        };
+
+        // Update document input state (hover, focus, active, etc)
+        if let Some(event) = hover_end_event {
+            self.handle_pointer_leave(&event);
+        }
+
+        // Update the cursor once the event (including any forwarding to a
+        // sub-document) has been fully handled
+        let doc = self.doc.inner();
+        if !is_leave && doc.hover_state() != prev_hover {
+            doc.update_cursor();
+        }
+    }
+
+    pub fn handle_dom_event(&mut self, event: DomEvent) {
+        self.queue.push_back(event);
+        self.process_queue();
+    }
+
+    fn handle_pointer_event(
+        &mut self,
+        target: NodeId,
+        data: BlitzPointerEvent,
+        make_ptr_data: impl FnOnce(BlitzPointerEvent) -> DomEventData,
+        make_mouse_data: Option<impl FnOnce(BlitzPointerEvent) -> DomEventData>,
+        make_touch_data: impl FnOnce(BlitzPointerEvent) -> DomEventData,
+    ) {
+        let mut ptr_event = DomEvent::new(target, make_ptr_data(data.clone()));
+        let mut event_state = EventState::default();
+        event_state = self.run_handler_event(&mut ptr_event, event_state);
+
+        // Generate the corresponding compatibility event (mouse events for the
+        // mouse, touch events for fingers and pen/stylus input) and expose it to
+        // script. The default action is always run on the pointer event so that
+        // the shell layer and default actions remain pointer-based.
+        //
+        // `pointercancel` has no mouse equivalent, so `make_mouse_data` is `None`
+        // in that case and no mouse event is generated.
+        if !event_state.is_cancelled() {
+            if data.is_mouse() {
+                if let Some(make_mouse_data) = make_mouse_data {
+                    let mut mouse_event = DomEvent::new(target, make_mouse_data(data));
+                    event_state = self.run_handler_event(&mut mouse_event, event_state);
+                }
+            } else if data.is_finger() || data.is_pen() {
+                let mut touch_event = DomEvent::new(target, make_touch_data(data));
+                event_state = self.run_handler_event(&mut touch_event, event_state);
+            }
+        }
+
+        if !event_state.is_cancelled() {
+            self.run_default_action(&mut ptr_event);
+        }
+        self.process_queue();
+    }
+
+    fn process_queue(&mut self) {
+        while let Some(mut event) = self.queue.pop_front() {
+            let event_state = self.run_handler_event(&mut event, EventState::default());
+            if !event_state.is_cancelled() {
+                self.run_default_action(&mut event);
+            }
+        }
+    }
+
+    fn adjust_element_coords(
+        &self,
+        target: NodeId,
+        coords: &PointerCoords,
+        element: &mut Point<f32>,
+    ) {
+        if let Some(rect) = self.doc.inner().get_client_bounding_rect(target) {
+            element.x = coords.client_x - rect.x as f32;
+            element.y = coords.client_y - rect.y as f32;
+        }
+    }
+
+    fn run_handler_event(
+        &mut self,
+        event: &mut DomEvent,
+        initial_event_state: EventState,
+    ) -> EventState {
+        let chain = if event.bubbles {
+            let doc = self.doc.inner();
+            doc.node_chain(event.target)
+        } else {
+            vec![event.target]
+        };
+
+        match &mut event.data {
+            DomEventData::PointerMove(data)
+            | DomEventData::PointerDown(data)
+            | DomEventData::PointerUp(data)
+            | DomEventData::PointerCancel(data)
+            | DomEventData::PointerEnter(data)
+            | DomEventData::PointerLeave(data)
+            | DomEventData::PointerOver(data)
+            | DomEventData::PointerOut(data)
+            | DomEventData::MouseMove(data)
+            | DomEventData::MouseDown(data)
+            | DomEventData::MouseUp(data)
+            | DomEventData::MouseEnter(data)
+            | DomEventData::MouseLeave(data)
+            | DomEventData::MouseOver(data)
+            | DomEventData::MouseOut(data)
+            | DomEventData::TouchStart(data)
+            | DomEventData::TouchEnd(data)
+            | DomEventData::TouchMove(data)
+            | DomEventData::TouchCancel(data)
+            | DomEventData::Click(data)
+            | DomEventData::ContextMenu(data)
+            | DomEventData::DoubleClick(data) => {
+                self.adjust_element_coords(event.target, &data.coords, &mut data.element)
+            }
+            DomEventData::Wheel(data) => {
+                self.adjust_element_coords(event.target, &data.coords, &mut data.element)
+            }
+            _ => {}
+        }
+
+        let mut event_state = initial_event_state;
+        self.handler
+            .handle_event(&chain, event, self.doc, &mut event_state);
+
+        event_state
+    }
+
+    fn run_default_action(&mut self, event: &mut DomEvent) {
+        let mut doc = self.doc.inner_mut();
+        doc.handle_dom_event(event, |new_evt| self.queue.push_back(new_evt));
+    }
+}

package/vendor/blitz-dom/src/events/focus.rs

@@ -0,0 +1,40 @@
+use blitz_traits::events::{BlitzFocusEvent, DomEvent, DomEventData};
+
+use crate::BaseDocument;
+
+pub(crate) fn generate_focus_events(
+    doc: &mut BaseDocument,
+    update_focus: &mut dyn FnMut(&mut BaseDocument),
+    dispatch_event: &mut dyn FnMut(DomEvent),
+) {
+    // Update focus, tracking which node was focussed before and after
+    let old_focus = doc.get_focussed_node_id();
+    update_focus(doc);
+    let new_focus = doc.get_focussed_node_id();
+
+    if old_focus == new_focus {
+        return;
+    }
+
+    if let Some(old_focus) = old_focus {
+        dispatch_event(DomEvent::new(
+            old_focus,
+            DomEventData::Blur(BlitzFocusEvent),
+        ));
+        dispatch_event(DomEvent::new(
+            old_focus,
+            DomEventData::FocusOut(BlitzFocusEvent),
+        ));
+    }
+
+    if let Some(new_focus) = new_focus {
+        dispatch_event(DomEvent::new(
+            new_focus,
+            DomEventData::Focus(BlitzFocusEvent),
+        ));
+        dispatch_event(DomEvent::new(
+            new_focus,
+            DomEventData::FocusIn(BlitzFocusEvent),
+        ));
+    }
+}

package/vendor/blitz-dom/src/events/ime.rs

@@ -0,0 +1,31 @@
+use blitz_traits::events::{BlitzImeEvent, DomEvent};
+
+use crate::BaseDocument;
+
+pub(crate) fn handle_ime_event<F: FnMut(DomEvent)>(
+    doc: &mut BaseDocument,
+    event: BlitzImeEvent,
+    dispatch_event: F,
+) {
+    if let Some(node_id) = doc.focus_node_id {
+        let node = &mut doc.nodes[node_id];
+        let text_input_data = node
+            .data
+            .downcast_element_mut()
+            .and_then(|el| el.text_input_data_mut());
+        if let Some(input_data) = text_input_data {
+            let generated_event = input_data.apply_ime_event(
+                &mut doc.font_ctx.lock().unwrap(),
+                &mut doc.layout_ctx,
+                event,
+            );
+
+            if let Some(generated_event) = generated_event {
+                doc.apply_generated_text_input_event(node_id, generated_event, dispatch_event);
+            }
+
+            #[cfg(feature = "tracing")]
+            tracing::debug!(node_id = ?node_id, "Sent ime event");
+        }
+    }
+}

package/vendor/blitz-dom/src/events/keyboard.rs

@@ -0,0 +1,174 @@
+use crate::events::focus::generate_focus_events;
+use crate::{BaseDocument, node::GeneratedTextInputEvent, util::ACTION_MOD};
+use blitz_traits::node_id::NodeId;
+use blitz_traits::{
+    SmolStr,
+    events::{BlitzInputEvent, BlitzKeyEvent, DomEvent, DomEventData},
+};
+use keyboard_types::{Key, Modifiers};
+use markup5ever::local_name;
+
+pub(super) enum KeyboardOrTextInputEvent {
+    KeyPress(BlitzKeyEvent),
+    AppleStandardKeyBinding(SmolStr),
+}
+
+pub(crate) fn handle_key_or_input_event<F: FnMut(DomEvent)>(
+    doc: &mut BaseDocument,
+    target: NodeId,
+    event: KeyboardOrTextInputEvent,
+    mut dispatch_event: F,
+) {
+    if let KeyboardOrTextInputEvent::KeyPress(event) = &event {
+        if event.key == Key::Tab {
+            let backwards = event.modifiers.contains(Modifiers::SHIFT);
+            let old_focus = doc.focus_node_id;
+            generate_focus_events(
+                doc,
+                &mut |doc| {
+                    if backwards {
+                        doc.focus_prev_node();
+                    } else {
+                        doc.focus_next_node();
+                    }
+                },
+                &mut dispatch_event,
+            );
+            if doc.focus_node_id != old_focus {
+                doc.shell_provider.request_redraw();
+            }
+            return;
+        }
+
+        // Handle copy (Ctrl+C/Cmd+C) for text selection when no text input is focused
+        if event.state.is_pressed() {
+            let action_mod = event.modifiers.contains(ACTION_MOD);
+            if action_mod {
+                if let Key::Character(c) = &event.key {
+                    if c.to_lowercase() == "c" {
+                        // Check if we have a text selection (and no focused text input)
+                        let has_focused_text_input = doc.focus_node_id.is_some_and(|id| {
+                            doc.get_node(id)
+                                .and_then(|n| n.element_data())
+                                .is_some_and(|e| e.text_input_data().is_some())
+                        });
+
+                        if !has_focused_text_input {
+                            if let Some(text) = doc.get_selected_text() {
+                                let _ = doc.shell_provider.set_clipboard_text(text);
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if let Some(node_id) = doc.focus_node_id {
+        if target != node_id {
+            return;
+        }
+
+        let node = &mut doc.nodes[node_id];
+        let Some(element_data) = node.element_data_mut() else {
+            return;
+        };
+
+        if let Some(input_data) = element_data.text_input_data_mut() {
+            let generated_event = match event {
+                KeyboardOrTextInputEvent::KeyPress(blitz_key_event) => input_data
+                    .apply_keypress_event(
+                        &mut doc.font_ctx.lock().unwrap(),
+                        &mut doc.layout_ctx,
+                        &*doc.shell_provider,
+                        blitz_key_event,
+                    ),
+                KeyboardOrTextInputEvent::AppleStandardKeyBinding(command) => input_data
+                    .apply_apple_standard_keybinding(
+                        &mut doc.font_ctx.lock().unwrap(),
+                        &mut doc.layout_ctx,
+                        &*doc.shell_provider,
+                        &command,
+                    ),
+            };
+
+            if let Some(generated_event) = generated_event {
+                doc.apply_generated_text_input_event(node_id, generated_event, dispatch_event);
+            }
+        }
+    }
+}
+
+impl BaseDocument {
+    pub(crate) fn apply_generated_text_input_event<F: FnMut(DomEvent)>(
+        &mut self,
+        node_id: NodeId,
+        event: GeneratedTextInputEvent,
+        mut dispatch_event: F,
+    ) {
+        let node = &mut self.nodes[node_id];
+        let element_data = node
+            .element_data_mut()
+            .expect("apply_generated_text_input_event called on a node that is not an element");
+        let input_data = element_data
+            .text_input_data_mut()
+            .expect("apply_generated_text_input_event called on a node that is not a text input");
+
+        match event {
+            GeneratedTextInputEvent::Input => {
+                let value = input_data.editor.raw_text().to_string();
+                dispatch_event(DomEvent::new(
+                    node_id,
+                    DomEventData::Input(BlitzInputEvent { value }),
+                ));
+                self.shell_provider.request_redraw();
+            }
+            GeneratedTextInputEvent::Select | GeneratedTextInputEvent::PreEditChange => {
+                self.shell_provider.request_redraw();
+            }
+            GeneratedTextInputEvent::Submit => {
+                // TODO: Generate submit event that can be handled by script
+                implicit_form_submission(self, node_id);
+            }
+        }
+    }
+}
+
+/// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#field-that-blocks-implicit-submission
+fn implicit_form_submission(doc: &BaseDocument, text_target: NodeId) {
+    let Some(form_owner_id) = doc.controls_to_form.get(&text_target) else {
+        return;
+    };
+    if doc
+        .controls_to_form
+        .iter()
+        .filter(|(_control_id, form_id)| *form_id == form_owner_id)
+        .filter_map(|(control_id, _)| doc.nodes[*control_id].element_data())
+        .filter(|element_data| {
+            element_data.attr(local_name!("type")).is_some_and(|t| {
+                matches!(
+                    t,
+                    "text"
+                        | "search"
+                        | "email"
+                        | "url"
+                        | "tel"
+                        | "password"
+                        | "date"
+                        | "month"
+                        | "week"
+                        | "time"
+                        | "datetime-local"
+                        | "number"
+                )
+            })
+        })
+        .count()
+        > 1
+    {
+        return;
+    }
+
+    doc.submit_form(*form_owner_id, *form_owner_id);
+}