Struct DioxusDocument 

pub struct DioxusDocument {
    pub inner: BaseDocument,
    pub vdom: VirtualDom,
    pub vdom_state: DioxusState,
    /* private fields */
}

Integrates BaseDocument from blitz-dom with VirtualDom from dioxus-core

Example

use blitz_traits::shell::{Viewport, ColorScheme};
use dioxus_native_dom::{DioxusDocument, DocumentConfig};
use dioxus::prelude::*;

// Example Dioxus app
fn app() -> Element {
    rsx! {
        div { "Hello, world!" }
    }
}

fn main() {
   let vdom = VirtualDom::new(app);
   let mut doc = DioxusDocument::new(vdom, DocumentConfig {
        viewport: Some(Viewport::new(800, 600, 1.0, ColorScheme::Light)),
        ..Default::default()
   });
   doc.initial_build();
}

You can just push events into the DioxusDocument with doc.handle_ui_event(..) and then flush the changes with doc.poll(..)

Fields

inner: BaseDocument

vdom: VirtualDom

vdom_state: DioxusState

Implementations

impl DioxusDocument

pub fn new(vdom: VirtualDom, config: DocumentConfig) -> DioxusDocument

Create a new DioxusDocument from a VirtualDom.

pub fn initial_build(&mut self)

Run an initial build of the Dioxus vdom

Methods from Deref<Target = BaseDocument>

pub fn set_net_provider(&mut self, net_provider: Arc<dyn NetProvider<Resource>>)

Set the Document’s networking provider

pub fn set_navigation_provider( &mut self, navigation_provider: Arc<dyn NavigationProvider>, )

Set the Document’s navigation provider

pub fn set_shell_provider(&mut self, shell_provider: Arc<dyn ShellProvider>)

Set the Document’s shell provider

pub fn set_html_parser_provider( &mut self, html_parser_provider: Arc<dyn HtmlParserProvider>, )

Set the Document’s html parser provider

pub fn set_base_url(&mut self, url: &str)

Set base url for resolving linked resources (stylesheets, images, fonts, etc)

pub fn guard(&self) -> &SharedRwLock

pub fn tree(&self) -> &Slab<Node>

pub fn id(&self) -> usize

pub fn get_node(&self, node_id: usize) -> Option<&Node>

pub fn get_node_mut(&mut self, node_id: usize) -> Option<&mut Node>

pub fn get_focussed_node_id(&self) -> Option<usize>

pub fn mutate<'doc>(&'doc mut self) -> DocumentMutator<'doc>

pub fn handle_dom_event<F>(&mut self, event: &mut DomEvent, dispatch_event: F)

where F: FnMut(DomEvent),

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

pub fn label_bound_input_element(&self, label_node_id: usize) -> Option<&Node>

Find the label’s bound input elements: the element id referenced by the “for” attribute of a given label element or the first input element which is nested in the label Note that although there should only be one bound element, we return all possibilities instead of just the first in order to allow the caller to decide which one is correct

pub fn toggle_radio(&mut self, radio_set_name: String, target_radio_id: usize)

pub fn set_style_property(&mut self, node_id: usize, name: &str, value: &str)

pub fn remove_style_property(&mut self, node_id: usize, name: &str)

pub fn root_node(&self) -> &Node

pub fn root_node_mut(&mut self) -> &mut Node

pub fn try_root_element(&self) -> Option<&Node>

pub fn root_element(&self) -> &Node

pub fn create_node(&mut self, node_data: NodeData) -> usize

pub fn has_changes(&self) -> bool

Whether the document has been mutated

pub fn create_text_node(&mut self, text: &str) -> usize

pub fn deep_clone_node(&mut self, node_id: usize) -> usize

pub fn print_tree(&self)

pub fn print_subtree(&self, node_id: usize)

pub fn reload_resource_by_href(&mut self, href_to_reload: &str)

pub fn process_style_element(&mut self, target_id: usize)

pub fn remove_user_agent_stylesheet(&mut self, contents: &str)

pub fn add_user_agent_stylesheet(&mut self, css: &str)

pub fn make_stylesheet( &self, css: impl AsRef<str>, origin: Origin, ) -> DocumentStyleSheet

pub fn upsert_stylesheet_for_node(&mut self, node_id: usize)

pub fn add_stylesheet_for_node( &mut self, stylesheet: DocumentStyleSheet, node_id: usize, )

pub fn load_resource(&mut self, resource: Resource)

pub fn snapshot_node(&mut self, node_id: usize)

pub fn snapshot_node_and(&mut self, node_id: usize, cb: impl FnOnce(&mut Node))

pub fn resolve(&mut self, current_time_for_animations: f64)

Restyle the tree and then relayout it

pub fn hit(&self, x: f32, y: f32) -> Option<HitResult>

pub fn focus_next_node(&mut self) -> Option<usize>

pub fn clear_focus(&mut self)

Clear the focussed node

pub fn set_mousedown_node_id(&mut self, node_id: Option<usize>)

pub fn set_focus_to(&mut self, focus_node_id: usize) -> bool

pub fn active_node(&mut self) -> bool

pub fn unactive_node(&mut self) -> bool

pub fn set_hover_to(&mut self, x: f32, y: f32) -> bool

pub fn get_hover_node_id(&self) -> Option<usize>

pub fn set_viewport(&mut self, viewport: Viewport)

pub fn viewport(&self) -> &Viewport

pub fn viewport_mut(&mut self) -> ViewportMut<'_>

pub fn zoom_by(&mut self, increment: f32)

pub fn zoom_to(&mut self, zoom: f32)

pub fn get_viewport(&self) -> Viewport

pub fn devtools(&self) -> &DevtoolSettings

pub fn devtools_mut(&mut self) -> &mut DevtoolSettings

pub fn is_animating(&self) -> bool

pub fn set_stylist_device(&mut self, device: Device)

Update the device and reset the stylist to process the new size

pub fn stylist_device(&mut self) -> &Device

pub fn resolve_layout_children(&mut self)

Ensure that the layout_children field is populated for all nodes

pub fn resolve_deferred_tasks(&mut self)

pub fn resolve_layout(&mut self)

Walk the nodes now that they’re properly styled and transfer their styles to the taffy style system

TODO: update taffy to use an associated type instead of slab key TODO: update taffy to support traited styles so we don’t even need to rely on taffy for storage

pub fn get_cursor(&self) -> Option<CursorIcon>

pub fn scroll_node_by(&mut self, node_id: usize, x: f64, y: f64)

pub fn scroll_node_by_has_changed( &mut self, node_id: usize, x: f64, y: f64, ) -> bool

Scroll a node by given x and y Will bubble scrolling up to parent node once it can no longer scroll further If we’re already at the root node, bubbles scrolling up to the viewport

pub fn scroll_viewport_by(&mut self, x: f64, y: f64)

pub fn scroll_viewport_by_has_changed(&mut self, x: f64, y: f64) -> bool

Scroll the viewport by the given values

pub fn viewport_scroll(&self) -> Point<f64>

pub fn set_viewport_scroll(&mut self, scroll: Point<f64>)

pub fn find_title_node(&self) -> Option<&Node>

pub fn print_taffy_tree(&self)

pub fn debug_log_node(&self, node_id: usize)

pub fn reset_form_owner(&mut self, node_id: usize)

Resets the form owner for a given node by either using an explicit form attribute or finding the nearest ancestor form element

Arguments

• node_id - The ID of the node whose form owner needs to be reset

https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#reset-the-form-owner

pub fn submit_form(&self, node_id: usize, submitter_id: usize)

Submits a form with the given form node ID and submitter node ID

Arguments

• node_id - The ID of the form node to submit
• submitter_id - The ID of the node that triggered the submission

https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#form-submission-algorithm

pub fn flush_styles_to_layout(&mut self, node_id: usize)

Walk the whole tree, converting styles to layout

pub fn get_element_by_id(&self, id: &str) -> Option<usize>

Find the node with the specified id attribute (if one exists)

pub fn query_selector<'input>( &self, selector: &'input str, ) -> Result<Option<usize>, ParseError<'input, StyleParseErrorKind<'input>>>

Find the first node that matches the selector specified as a string Returns:

• Err(_) if parsing the selector fails
• Ok(None) if nothing matches
• Ok(Some(node_id)) with the first node ID that matches if one is found

pub fn query_selector_raw( &self, selector_list: &SelectorList<SelectorImpl>, ) -> Option<usize>

Find the first node that matches the selector(s) specified in selector_list

pub fn query_selector_all<'input>( &self, selector: &'input str, ) -> Result<SmallVec<[usize; 32]>, ParseError<'input, StyleParseErrorKind<'input>>>

Find all nodes that match the selector specified as a string Returns:

• Err(_) if parsing the selector fails
• Ok(SmallVec<usize>) with all matching nodes otherwise

pub fn query_selector_all_raw( &self, selector_list: &SelectorList<SelectorImpl>, ) -> SmallVec<[usize; 32]>

Find all nodes that match the selector(s) specified in selector_list

pub fn try_parse_selector_list<'input>( &self, input: &'input str, ) -> Result<SelectorList<SelectorImpl>, ParseError<'input, StyleParseErrorKind<'input>>>

pub fn resolve_stylist(&mut self, now: f64)

pub fn node_chain(&self, node_id: usize) -> Vec<usize>

Collect the nodes into a chain by traversing upwards

pub fn visit<F>(&self, visit: F)

where F: FnMut(usize, &Node),

pub fn non_anon_ancestor_if_anon(&self, node_id: usize) -> usize

If the node is non-anonymous then returns the node’s id Else find’s the first non-anonymous ancester of the node

pub fn iter_children_mut( &mut self, node_id: usize, cb: impl FnMut(usize, &mut BaseDocument), )

pub fn iter_subtree_mut( &mut self, node_id: usize, cb: impl FnMut(usize, &mut BaseDocument), )

pub fn iter_children_and_pseudos_mut( &mut self, node_id: usize, cb: impl FnMut(usize, &mut BaseDocument), )

pub fn next_node( &self, start: &Node, filter: impl FnMut(&Node) -> bool, ) -> Option<usize>

pub fn node_layout_ancestors(&self, node_id: usize) -> Vec<usize>

pub fn maybe_node_layout_ancestors(&self, node_id: Option<usize>) -> Vec<usize>

pub fn build_accessibility_tree(&self) -> TreeUpdate

Trait Implementations

impl Deref for DioxusDocument

type Target = BaseDocument

The resulting type after dereferencing.

fn deref(&self) -> &BaseDocument

Dereferences the value.

impl DerefMut for DioxusDocument

fn deref_mut(&mut self) -> &mut <DioxusDocument as Deref>::Target

Mutably dereferences the value.

impl Document for DioxusDocument

fn id(&self) -> usize

Get the Document’s id

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

fn poll(&mut self, cx: Option<Context<'_>>) -> bool

Poll any pending async operations, and flush changes to the underlying BaseDocument

fn handle_ui_event(&mut self, event: UiEvent)

Update the Document in response to a UiEvent (click, keypress, etc)

impl From<DioxusDocument> for BaseDocument

fn from(doc: DioxusDocument) -> BaseDocument

Converts to this type from the input type.