774 lines
25 KiB
Rust
774 lines
25 KiB
Rust
use std::{collections::HashMap, rc::Rc, sync::Arc};
|
|
|
|
use dioxus_core::{
|
|
events::{EventTrigger, VirtualEvent},
|
|
DomEdit, ElementId, ScopeId,
|
|
};
|
|
use fxhash::FxHashMap;
|
|
use wasm_bindgen::{closure::Closure, JsCast};
|
|
use web_sys::{
|
|
window, CssStyleDeclaration, Document, Element, Event, HtmlElement, HtmlInputElement,
|
|
HtmlOptionElement, Node, NodeList,
|
|
};
|
|
|
|
use crate::{nodeslab::NodeSlab, WebConfig};
|
|
|
|
pub struct WebsysDom {
|
|
stack: Stack,
|
|
|
|
/// A map from ElementID (index) to Node
|
|
nodes: NodeSlab,
|
|
|
|
document: Document,
|
|
|
|
root: Element,
|
|
|
|
sender_callback: Rc<dyn Fn(EventTrigger)>,
|
|
|
|
// map of listener types to number of those listeners
|
|
// This is roughly a delegater
|
|
// TODO: check how infero delegates its events - some are more performant
|
|
listeners: FxHashMap<&'static str, (usize, Closure<dyn FnMut(&Event)>)>,
|
|
|
|
// We need to make sure to add comments between text nodes
|
|
// We ensure that the text siblings are patched by preventing the browser from merging
|
|
// neighboring text nodes. Originally inspired by some of React's work from 2016.
|
|
// -> https://reactjs.org/blog/2016/04/07/react-v15.html#major-changes
|
|
// -> https://github.com/facebook/react/pull/5753
|
|
last_node_was_text: bool,
|
|
}
|
|
impl WebsysDom {
|
|
pub fn new(root: Element, cfg: WebConfig, sender_callback: Rc<dyn Fn(EventTrigger)>) -> Self {
|
|
let document = load_document();
|
|
|
|
let mut nodes = NodeSlab::new(2000);
|
|
let mut listeners = FxHashMap::default();
|
|
|
|
// re-hydrate the page - only supports one virtualdom per page
|
|
if cfg.hydrate {
|
|
// Load all the elements into the arena
|
|
let node_list: NodeList = document.query_selector_all("dio_el").unwrap();
|
|
let len = node_list.length() as usize;
|
|
|
|
for x in 0..len {
|
|
let node: Node = node_list.get(x as u32).unwrap();
|
|
let el: &Element = node.dyn_ref::<Element>().unwrap();
|
|
let id: String = el.get_attribute("dio_el").unwrap();
|
|
let id = id.parse::<usize>().unwrap();
|
|
nodes[id] = Some(node);
|
|
}
|
|
|
|
// Load all the event listeners into our listener register
|
|
// TODO
|
|
}
|
|
|
|
let mut stack = Stack::with_capacity(10);
|
|
let root_node = root.clone().dyn_into::<Node>().unwrap();
|
|
stack.push(root_node);
|
|
|
|
Self {
|
|
stack,
|
|
nodes,
|
|
listeners,
|
|
document,
|
|
sender_callback,
|
|
root,
|
|
last_node_was_text: false,
|
|
}
|
|
}
|
|
|
|
pub fn process_edits(&mut self, edits: &mut Vec<DomEdit>) {
|
|
for edit in edits.drain(..) {
|
|
log::info!("Handling edit: {:#?}", edit);
|
|
match edit {
|
|
DomEdit::PushRoot { id: root } => self.push(root),
|
|
DomEdit::PopRoot => self.pop(),
|
|
DomEdit::AppendChildren { many } => self.append_children(many),
|
|
DomEdit::ReplaceWith { n, m } => self.replace_with(n, m),
|
|
DomEdit::Remove => self.remove(),
|
|
DomEdit::RemoveAllChildren => self.remove_all_children(),
|
|
DomEdit::CreateTextNode { text, id } => self.create_text_node(text, id),
|
|
DomEdit::CreateElement { tag, id } => self.create_element(tag, None, id),
|
|
DomEdit::CreateElementNs { tag, id, ns } => self.create_element(tag, Some(ns), id),
|
|
DomEdit::CreatePlaceholder { id } => self.create_placeholder(id),
|
|
DomEdit::NewEventListener {
|
|
event_name: event,
|
|
scope,
|
|
mounted_node_id: node,
|
|
} => self.new_event_listener(event, scope, node),
|
|
|
|
DomEdit::RemoveEventListener { event } => todo!(),
|
|
DomEdit::SetText { text } => self.set_text(text),
|
|
DomEdit::SetAttribute { field, value, ns } => self.set_attribute(field, value, ns),
|
|
DomEdit::RemoveAttribute { name } => self.remove_attribute(name),
|
|
|
|
DomEdit::InsertAfter { n } => self.insert_after(n),
|
|
DomEdit::InsertBefore { n } => self.insert_before(n),
|
|
}
|
|
}
|
|
}
|
|
fn push(&mut self, root: u64) {
|
|
let key = root as usize;
|
|
let domnode = &self.nodes[key];
|
|
|
|
let real_node: Node = match domnode {
|
|
Some(n) => n.clone(),
|
|
None => todo!(),
|
|
};
|
|
|
|
self.stack.push(real_node);
|
|
}
|
|
// drop the node off the stack
|
|
fn pop(&mut self) {
|
|
self.stack.pop();
|
|
}
|
|
|
|
fn append_children(&mut self, many: u32) {
|
|
log::debug!("Called [`append_child`]");
|
|
|
|
let root: Node = self
|
|
.stack
|
|
.list
|
|
.get(self.stack.list.len() - (1 + many as usize))
|
|
.unwrap()
|
|
.clone();
|
|
|
|
for _ in 0..many {
|
|
let child = self.stack.pop();
|
|
|
|
if child.dyn_ref::<web_sys::Text>().is_some() {
|
|
if self.last_node_was_text {
|
|
let comment_node = self
|
|
.document
|
|
.create_comment("dioxus")
|
|
.dyn_into::<Node>()
|
|
.unwrap();
|
|
self.stack.top().append_child(&comment_node).unwrap();
|
|
}
|
|
self.last_node_was_text = true;
|
|
} else {
|
|
self.last_node_was_text = false;
|
|
}
|
|
|
|
root.append_child(&child).unwrap();
|
|
}
|
|
}
|
|
|
|
fn replace_with(&mut self, n: u32, m: u32) {
|
|
log::debug!("Called [`replace_with`]");
|
|
|
|
let mut new_nodes = vec![];
|
|
for _ in 0..m {
|
|
new_nodes.push(self.stack.pop());
|
|
}
|
|
|
|
let mut old_nodes = vec![];
|
|
for _ in 0..n {
|
|
old_nodes.push(self.stack.pop());
|
|
}
|
|
|
|
for node in &old_nodes[1..] {
|
|
node.dyn_ref::<Element>().unwrap().remove();
|
|
}
|
|
|
|
let old = old_nodes[0].clone();
|
|
let arr: js_sys::Array = new_nodes.iter().collect();
|
|
let el = old.dyn_into::<Element>().unwrap();
|
|
el.replace_with_with_node(&arr).unwrap();
|
|
// let arr = js_sys::Array::from();
|
|
|
|
// TODO: use different-sized replace withs
|
|
// if m == 1 {
|
|
// if old_node.has_type::<Element>() {
|
|
// old_node
|
|
// .dyn_ref::<Element>()
|
|
// .unwrap()
|
|
// .replace_with_with_node_1(&new_node)
|
|
// .unwrap();
|
|
// } else if old_node.has_type::<web_sys::CharacterData>() {
|
|
// old_node
|
|
// .dyn_ref::<web_sys::CharacterData>()
|
|
// .unwrap()
|
|
// .replace_with_with_node_1(&new_node)
|
|
// .unwrap();
|
|
// } else if old_node.has_type::<web_sys::DocumentType>() {
|
|
// old_node
|
|
// .dyn_ref::<web_sys::DocumentType>()
|
|
// .unwrap()
|
|
// .replace_with_with_node_1(&new_node)
|
|
// .unwrap();
|
|
// } else {
|
|
// panic!("Cannot replace node: {:?}", old_node);
|
|
// }
|
|
// }
|
|
|
|
// self.stack.push(new_node);
|
|
}
|
|
|
|
fn remove(&mut self) {
|
|
log::debug!("Called [`remove`]");
|
|
todo!()
|
|
}
|
|
|
|
fn remove_all_children(&mut self) {
|
|
log::debug!("Called [`remove_all_children`]");
|
|
todo!()
|
|
}
|
|
|
|
fn create_placeholder(&mut self, id: u64) {
|
|
self.create_element("pre", None, id);
|
|
self.set_attribute("hidden", "", None);
|
|
}
|
|
fn create_text_node(&mut self, text: &str, id: u64) {
|
|
// let nid = self.node_counter.next();
|
|
|
|
let textnode = self
|
|
.document
|
|
.create_text_node(text)
|
|
.dyn_into::<Node>()
|
|
.unwrap();
|
|
|
|
let id = id as usize;
|
|
self.stack.push(textnode.clone());
|
|
self.nodes[id] = Some(textnode);
|
|
}
|
|
|
|
fn create_element(&mut self, tag: &str, ns: Option<&'static str>, id: u64) {
|
|
let tag = wasm_bindgen::intern(tag);
|
|
let el = match ns {
|
|
Some(ns) => self
|
|
.document
|
|
.create_element_ns(Some(ns), tag)
|
|
.unwrap()
|
|
.dyn_into::<Node>()
|
|
.unwrap(),
|
|
None => self
|
|
.document
|
|
.create_element(tag)
|
|
.unwrap()
|
|
.dyn_into::<Node>()
|
|
.unwrap(),
|
|
};
|
|
let id = id as usize;
|
|
|
|
self.stack.push(el.clone());
|
|
self.nodes[id] = Some(el);
|
|
// let nid = self.node_counter.?next();
|
|
// let nid = self.nodes.insert(el).data().as_ffi();
|
|
// log::debug!("Called [`create_element`]: {}, {:?}", tag, nid);
|
|
// ElementId::new(nid)
|
|
}
|
|
|
|
fn new_event_listener(&mut self, event: &'static str, scope: ScopeId, real_id: u64) {
|
|
// let (_on, event) = event.split_at(2);
|
|
let event = wasm_bindgen::intern(event);
|
|
|
|
// attach the correct attributes to the element
|
|
// these will be used by accessing the event's target
|
|
// This ensures we only ever have one handler attached to the root, but decide
|
|
// dynamically when we want to call a listener.
|
|
|
|
let el = self.stack.top();
|
|
|
|
let el = el
|
|
.dyn_ref::<Element>()
|
|
.expect(&format!("not an element: {:?}", el));
|
|
|
|
// let scope_id = scope.data().as_ffi();
|
|
let scope_id = scope.0 as u64;
|
|
|
|
el.set_attribute(
|
|
&format!("dioxus-event-{}", event),
|
|
&format!("{}.{}", scope_id, real_id),
|
|
)
|
|
.unwrap();
|
|
|
|
el.set_attribute(&format!("dioxus-event"), &format!("{}", event))
|
|
.unwrap();
|
|
|
|
// Register the callback to decode
|
|
|
|
if let Some(entry) = self.listeners.get_mut(event) {
|
|
entry.0 += 1;
|
|
} else {
|
|
let trigger = self.sender_callback.clone();
|
|
|
|
let handler = Closure::wrap(Box::new(move |event: &web_sys::Event| {
|
|
// "Result" cannot be received from JS
|
|
// Instead, we just build and immediately execute a closure that returns result
|
|
match decode_trigger(event) {
|
|
Ok(synthetic_event) => trigger.as_ref()(synthetic_event),
|
|
Err(e) => log::error!("Error decoding Dioxus event attribute. {:#?}", e),
|
|
};
|
|
}) as Box<dyn FnMut(&Event)>);
|
|
|
|
self.root
|
|
.add_event_listener_with_callback(event, (&handler).as_ref().unchecked_ref())
|
|
.unwrap();
|
|
|
|
// Increment the listeners
|
|
self.listeners.insert(event.into(), (1, handler));
|
|
}
|
|
}
|
|
|
|
fn remove_event_listener(&mut self, event: &str) {
|
|
todo!()
|
|
}
|
|
|
|
fn set_text(&mut self, text: &str) {
|
|
self.stack.top().set_text_content(Some(text))
|
|
}
|
|
|
|
fn set_attribute(&mut self, name: &str, value: &str, ns: Option<&str>) {
|
|
if let Some(el) = self.stack.top().dyn_ref::<Element>() {
|
|
match ns {
|
|
// inline style support
|
|
Some("style") => {
|
|
let el = el.dyn_ref::<HtmlElement>().unwrap();
|
|
let style_dc: CssStyleDeclaration = el.style();
|
|
style_dc.set_property(name, value).unwrap();
|
|
}
|
|
_ => el.set_attribute(name, value).unwrap(),
|
|
}
|
|
match name {
|
|
"value" => {}
|
|
"checked" => {}
|
|
"selected" => {}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn remove_attribute(&mut self, name: &str) {
|
|
let node = self.stack.top();
|
|
if let Some(node) = node.dyn_ref::<web_sys::Element>() {
|
|
node.remove_attribute(name).unwrap();
|
|
}
|
|
if let Some(node) = node.dyn_ref::<HtmlInputElement>() {
|
|
// Some attributes are "volatile" and don't work through `removeAttribute`.
|
|
if name == "value" {
|
|
node.set_value("");
|
|
}
|
|
if name == "checked" {
|
|
node.set_checked(false);
|
|
}
|
|
}
|
|
|
|
if let Some(node) = node.dyn_ref::<HtmlOptionElement>() {
|
|
if name == "selected" {
|
|
node.set_selected(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn insert_after(&mut self, n: u32) {
|
|
let mut new_nodes = vec![];
|
|
for _ in 0..n {
|
|
new_nodes.push(self.stack.pop());
|
|
}
|
|
|
|
let after = self.stack.top().clone();
|
|
let arr: js_sys::Array = new_nodes.iter().collect();
|
|
|
|
let el = after.dyn_into::<Element>().unwrap();
|
|
el.after_with_node(&arr).unwrap();
|
|
// let mut old_nodes = vec![];
|
|
// for _ in 0..n {
|
|
// old_nodes.push(self.stack.pop());
|
|
// }
|
|
|
|
// let el = self.stack.top();
|
|
}
|
|
|
|
fn insert_before(&mut self, n: u32) {
|
|
let n = n as usize;
|
|
let root = self
|
|
.stack
|
|
.list
|
|
.get(self.stack.list.len() - n)
|
|
.unwrap()
|
|
.clone();
|
|
for _ in 0..n {
|
|
let el = self.stack.pop();
|
|
root.insert_before(&el, None).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct Stack {
|
|
pub list: Vec<Node>,
|
|
}
|
|
|
|
impl Stack {
|
|
#[inline]
|
|
pub fn with_capacity(cap: usize) -> Self {
|
|
Stack {
|
|
list: Vec::with_capacity(cap),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn push(&mut self, node: Node) {
|
|
self.list.push(node);
|
|
}
|
|
|
|
#[inline]
|
|
pub fn pop(&mut self) -> Node {
|
|
self.list.pop().unwrap()
|
|
}
|
|
|
|
#[inline]
|
|
pub fn clear(&mut self) {
|
|
self.list.clear();
|
|
}
|
|
|
|
pub fn top(&self) -> &Node {
|
|
match self.list.last() {
|
|
Some(a) => a,
|
|
None => panic!("Called 'top' of an empty stack, make sure to push the root first"),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn virtual_event_from_websys_event(event: &web_sys::Event) -> VirtualEvent {
|
|
use dioxus_core::events::on::*;
|
|
match event.type_().as_str() {
|
|
"copy" | "cut" | "paste" => {
|
|
struct WebsysClipboardEvent();
|
|
impl ClipboardEventInner for WebsysClipboardEvent {}
|
|
VirtualEvent::ClipboardEvent(ClipboardEvent(Rc::new(WebsysClipboardEvent())))
|
|
}
|
|
|
|
"compositionend" | "compositionstart" | "compositionupdate" => {
|
|
let evt: web_sys::CompositionEvent = event.clone().dyn_into().unwrap();
|
|
struct WebsysCompositionEvent(web_sys::CompositionEvent);
|
|
impl CompositionEventInner for WebsysCompositionEvent {
|
|
fn data(&self) -> String {
|
|
todo!()
|
|
}
|
|
}
|
|
VirtualEvent::CompositionEvent(CompositionEvent(Rc::new(WebsysCompositionEvent(evt))))
|
|
}
|
|
|
|
"keydown" | "keypress" | "keyup" => {
|
|
struct Event(web_sys::KeyboardEvent);
|
|
impl KeyboardEventInner for Event {
|
|
fn char_code(&self) -> u32 {
|
|
todo!()
|
|
}
|
|
fn key_code(&self) -> KeyCode {
|
|
todo!()
|
|
}
|
|
fn ctrl_key(&self) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn key(&self) -> String {
|
|
todo!()
|
|
}
|
|
|
|
fn locale(&self) -> String {
|
|
todo!()
|
|
}
|
|
|
|
fn location(&self) -> usize {
|
|
todo!()
|
|
}
|
|
|
|
fn meta_key(&self) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn repeat(&self) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn shift_key(&self) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn which(&self) -> usize {
|
|
todo!()
|
|
}
|
|
|
|
fn get_modifier_state(&self, key_code: usize) -> bool {
|
|
todo!()
|
|
}
|
|
}
|
|
let evt: web_sys::KeyboardEvent = event.clone().dyn_into().unwrap();
|
|
VirtualEvent::KeyboardEvent(KeyboardEvent(Rc::new(Event(evt))))
|
|
}
|
|
|
|
"focus" | "blur" => {
|
|
struct Event(web_sys::FocusEvent);
|
|
impl FocusEventInner for Event {}
|
|
let evt: web_sys::FocusEvent = event.clone().dyn_into().unwrap();
|
|
VirtualEvent::FocusEvent(FocusEvent(Rc::new(Event(evt))))
|
|
}
|
|
|
|
"change" => {
|
|
// struct Event(web_sys::Event);
|
|
// impl GenericEventInner for Event {
|
|
// fn bubbles(&self) -> bool {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn cancel_bubble(&self) {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn cancelable(&self) -> bool {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn composed(&self) -> bool {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn composed_path(&self) -> String {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn current_target(&self) {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn default_prevented(&self) -> bool {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn event_phase(&self) -> usize {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn is_trusted(&self) -> bool {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn prevent_default(&self) {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn stop_immediate_propagation(&self) {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn stop_propagation(&self) {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn target(&self) {
|
|
// todo!()
|
|
// }
|
|
|
|
// fn time_stamp(&self) -> usize {
|
|
// todo!()
|
|
// }
|
|
// }
|
|
// let evt: web_sys::Event = event.clone().dyn_into().expect("wrong error typ");
|
|
// VirtualEvent::Event(GenericEvent(Rc::new(Event(evt))))
|
|
todo!()
|
|
}
|
|
|
|
"input" | "invalid" | "reset" | "submit" => {
|
|
// is a special react events
|
|
let evt: web_sys::InputEvent = event.clone().dyn_into().expect("wrong event type");
|
|
let this: web_sys::EventTarget = evt.target().unwrap();
|
|
|
|
let value = (&this)
|
|
.dyn_ref()
|
|
.map(|input: &web_sys::HtmlInputElement| input.value())
|
|
.or_else(|| {
|
|
(&this)
|
|
.dyn_ref()
|
|
.map(|input: &web_sys::HtmlTextAreaElement| input.value())
|
|
})
|
|
.or_else(|| {
|
|
(&this)
|
|
.dyn_ref::<web_sys::HtmlElement>()
|
|
.unwrap()
|
|
.text_content()
|
|
})
|
|
.expect("only an InputElement or TextAreaElement or an element with contenteditable=true can have an oninput event listener");
|
|
|
|
todo!()
|
|
// VirtualEvent::FormEvent(FormEvent { value })
|
|
}
|
|
|
|
"click" | "contextmenu" | "doubleclick" | "drag" | "dragend" | "dragenter" | "dragexit"
|
|
| "dragleave" | "dragover" | "dragstart" | "drop" | "mousedown" | "mouseenter"
|
|
| "mouseleave" | "mousemove" | "mouseout" | "mouseover" | "mouseup" => {
|
|
let evt: web_sys::MouseEvent = event.clone().dyn_into().unwrap();
|
|
|
|
#[derive(Debug)]
|
|
pub struct CustomMouseEvent(web_sys::MouseEvent);
|
|
impl dioxus_core::events::on::MouseEventInner for CustomMouseEvent {
|
|
fn alt_key(&self) -> bool {
|
|
self.0.alt_key()
|
|
}
|
|
fn button(&self) -> i16 {
|
|
self.0.button()
|
|
}
|
|
fn buttons(&self) -> u16 {
|
|
self.0.buttons()
|
|
}
|
|
fn client_x(&self) -> i32 {
|
|
self.0.client_x()
|
|
}
|
|
fn client_y(&self) -> i32 {
|
|
self.0.client_y()
|
|
}
|
|
fn ctrl_key(&self) -> bool {
|
|
self.0.ctrl_key()
|
|
}
|
|
fn meta_key(&self) -> bool {
|
|
self.0.meta_key()
|
|
}
|
|
fn page_x(&self) -> i32 {
|
|
self.0.page_x()
|
|
}
|
|
fn page_y(&self) -> i32 {
|
|
self.0.page_y()
|
|
}
|
|
fn screen_x(&self) -> i32 {
|
|
self.0.screen_x()
|
|
}
|
|
fn screen_y(&self) -> i32 {
|
|
self.0.screen_y()
|
|
}
|
|
fn shift_key(&self) -> bool {
|
|
self.0.shift_key()
|
|
}
|
|
|
|
// yikes
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
|
|
fn get_modifier_state(&self, key_code: &str) -> bool {
|
|
self.0.get_modifier_state(key_code)
|
|
}
|
|
}
|
|
VirtualEvent::MouseEvent(MouseEvent(Rc::new(CustomMouseEvent(evt))))
|
|
}
|
|
|
|
"pointerdown" | "pointermove" | "pointerup" | "pointercancel" | "gotpointercapture"
|
|
| "lostpointercapture" | "pointerenter" | "pointerleave" | "pointerover" | "pointerout" => {
|
|
let evt: web_sys::PointerEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
|
|
"select" => {
|
|
// let evt: web_sys::SelectionEvent = event.clone().dyn_into().unwrap();
|
|
// not required to construct anything special beyond standard event stuff
|
|
todo!()
|
|
}
|
|
|
|
"touchcancel" | "touchend" | "touchmove" | "touchstart" => {
|
|
let evt: web_sys::TouchEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
|
|
"scroll" => {
|
|
// let evt: web_sys::UIEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
|
|
"wheel" => {
|
|
let evt: web_sys::WheelEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
"animationstart" | "animationend" | "animationiteration" => {
|
|
let evt: web_sys::AnimationEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
|
|
"transitionend" => {
|
|
let evt: web_sys::TransitionEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
|
|
"abort" | "canplay" | "canplaythrough" | "durationchange" | "emptied" | "encrypted"
|
|
| "ended" | "error" | "loadeddata" | "loadedmetadata" | "loadstart" | "pause" | "play"
|
|
| "playing" | "progress" | "ratechange" | "seeked" | "seeking" | "stalled" | "suspend"
|
|
| "timeupdate" | "volumechange" | "waiting" => {
|
|
// not required to construct anything special beyond standard event stuff
|
|
|
|
// let evt: web_sys::MediaEvent = event.clone().dyn_into().unwrap();
|
|
// let evt: web_sys::MediaEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
|
|
"toggle" => {
|
|
// not required to construct anything special beyond standard event stuff (target)
|
|
|
|
// let evt: web_sys::ToggleEvent = event.clone().dyn_into().unwrap();
|
|
todo!()
|
|
}
|
|
_ => {
|
|
todo!()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// This function decodes a websys event and produces an EventTrigger
|
|
/// With the websys implementation, we attach a unique key to the nodes
|
|
fn decode_trigger(event: &web_sys::Event) -> anyhow::Result<EventTrigger> {
|
|
log::debug!("Handling event!");
|
|
|
|
let target = event
|
|
.target()
|
|
.expect("missing target")
|
|
.dyn_into::<Element>()
|
|
.expect("not a valid element");
|
|
|
|
let typ = event.type_();
|
|
|
|
use anyhow::Context;
|
|
|
|
let attrs = target.attributes();
|
|
for x in 0..attrs.length() {
|
|
let attr = attrs.item(x).unwrap();
|
|
log::debug!("attrs include: {:#?}", attr);
|
|
}
|
|
|
|
// The error handling here is not very descriptive and needs to be replaced with a zero-cost error system
|
|
let val: String = target
|
|
.get_attribute(&format!("dioxus-event-{}", typ))
|
|
.context(format!("wrong format - received {:#?}", typ))?;
|
|
|
|
let mut fields = val.splitn(3, ".");
|
|
|
|
let gi_id = fields
|
|
.next()
|
|
.and_then(|f| f.parse::<u64>().ok())
|
|
.context("failed to parse gi id")?;
|
|
|
|
let real_id = fields
|
|
.next()
|
|
.and_then(|raw_id| raw_id.parse::<u64>().ok())
|
|
.context("failed to parse real id")?;
|
|
|
|
// Call the trigger
|
|
log::debug!("decoded scope_id: {}, node_id: {:#?}", gi_id, real_id);
|
|
|
|
let triggered_scope = gi_id;
|
|
// let triggered_scope: ScopeId = KeyData::from_ffi(gi_id).into();
|
|
log::debug!("Triggered scope is {:#?}", triggered_scope);
|
|
Ok(EventTrigger::new(
|
|
virtual_event_from_websys_event(event),
|
|
ScopeId(triggered_scope as usize),
|
|
Some(ElementId(real_id as usize)),
|
|
dioxus_core::events::EventPriority::High,
|
|
))
|
|
}
|
|
|
|
pub fn prepare_websys_dom() -> Element {
|
|
load_document().get_element_by_id("dioxusroot").unwrap()
|
|
}
|
|
|
|
pub fn load_document() -> Document {
|
|
web_sys::window()
|
|
.expect("should have access to the Window")
|
|
.document()
|
|
.expect("should have access to the Document")
|
|
}
|