Struct BaseDocument 

pub struct BaseDocument {
    pub net_provider: Arc<dyn NetProvider<Resource>>,
    pub navigation_provider: Arc<dyn NavigationProvider>,
    pub shell_provider: Arc<dyn ShellProvider>,
    pub html_parser_provider: Arc<dyn HtmlParserProvider>,
    /* private fields */
}

Fields

net_provider: Arc<dyn NetProvider<Resource>>

Network provider. Can be used to fetch assets.

navigation_provider: Arc<dyn NavigationProvider>

Navigation provider. Can be used to navigate to a new page (bubbles up the event on e.g. clicking a Link)

shell_provider: Arc<dyn ShellProvider>

Shell provider. Can be used to request a redraw or set the cursor icon

html_parser_provider: Arc<dyn HtmlParserProvider>

HTML parser provider. Used to parse HTML for setInnerHTML

Implementations

impl BaseDocument

pub fn new(config: DocumentConfig) -> Self

Create a new (empty) BaseDocument with the specified configuration

pub fn set_net_provider(&mut self, net_provider: SharedProvider<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: FnMut(DomEvent)>( &mut self, event: &mut DomEvent, dispatch_event: F, )

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

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_checkbox(el: &mut ElementData) -> bool

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>

impl BaseDocument

pub fn print_taffy_tree(&self)

pub fn debug_log_node(&self, node_id: usize)

impl BaseDocument

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

impl BaseDocument

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

Walk the whole tree, converting styles to layout

impl BaseDocument

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>>

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>>

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>>

impl BaseDocument

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

impl BaseDocument

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>

impl BaseDocument

pub fn build_accessibility_tree(&self) -> TreeUpdate

Trait Implementations

impl AsMut<BaseDocument> for BaseDocument

fn as_mut(&mut self) -> &mut BaseDocument

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<BaseDocument> for BaseDocument

fn as_ref(&self) -> &BaseDocument

Converts this type into a shared reference of the (usually inferred) input type.

impl CacheTree for BaseDocument

fn cache_get( &self, node_id: NodeId, known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>, run_mode: RunMode, ) -> Option<LayoutOutput>

Try to retrieve a cached result from the cache

fn cache_store( &mut self, node_id: NodeId, known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>, run_mode: RunMode, layout_output: LayoutOutput, )

Store a computed size in the cache

fn cache_clear(&mut self, node_id: NodeId)

Clear all cache entries for the node

impl LayoutBlockContainer for BaseDocument

type BlockContainerStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing the CSS Block container’s styles

type BlockItemStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing each CSS Block item’s styles

fn get_block_container_style( &self, node_id: NodeId, ) -> Self::BlockContainerStyle<'_>

Get the container’s styles

fn get_block_child_style( &self, child_node_id: NodeId, ) -> Self::BlockItemStyle<'_>

Get the child’s styles

impl LayoutFlexboxContainer for BaseDocument

type FlexboxContainerStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing the Flexbox container’s styles

type FlexboxItemStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing each Flexbox item’s styles

fn get_flexbox_container_style( &self, node_id: NodeId, ) -> Self::FlexboxContainerStyle<'_>

Get the container’s styles

fn get_flexbox_child_style( &self, child_node_id: NodeId, ) -> Self::FlexboxItemStyle<'_>

Get the child’s styles

impl LayoutGridContainer for BaseDocument

type GridContainerStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing the CSS Grid container’s styles

type GridItemStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing each CSS Grid item’s styles

fn get_grid_container_style( &self, node_id: NodeId, ) -> Self::GridContainerStyle<'_>

Get the container’s styles

fn get_grid_child_style(&self, child_node_id: NodeId) -> Self::GridItemStyle<'_>

Get the child’s styles

impl LayoutPartialTree for BaseDocument

type CoreContainerStyle<'a> = &'a Style<Atom<AtomStaticSet>> where Self: 'a

The style type representing the core container styles that all containers should have Used when laying out the root node of a tree

type CustomIdent = Atom<AtomStaticSet>

String type for representing “custom identifiers” (for example, named grid lines or areas) If you are unsure what to use here then consider Arc<str>.

fn get_core_container_style(&self, node_id: NodeId) -> &Style<Atom>

Get core style

fn set_unrounded_layout(&mut self, node_id: NodeId, layout: &Layout)

Set the node’s unrounded layout

fn resolve_calc_value(&self, calc_ptr: *const (), parent_size: f32) -> f32

Resolve calc value

fn compute_child_layout( &mut self, node_id: NodeId, inputs: LayoutInput, ) -> LayoutOutput

Compute the specified node’s size or full layout given the specified constraints

impl PrintTree for BaseDocument

fn get_debug_label(&self, node_id: NodeId) -> &'static str

Get a debug label for the node (typically the type of node: flexbox, grid, text, image, etc)

fn get_final_layout(&self, node_id: NodeId) -> Layout

Get a reference to the node’s final layout

impl RoundTree for BaseDocument

fn get_unrounded_layout(&self, node_id: NodeId) -> Layout

Get the node’s unrounded layout

fn set_final_layout(&mut self, node_id: NodeId, layout: &Layout)

Get a reference to the node’s final layout

impl TraversePartialTree for BaseDocument

type ChildIter<'a> = RefCellChildIter<'a>

Type representing an iterator of the children of a node

fn child_ids(&self, node_id: NodeId) -> Self::ChildIter<'_>

Get the list of children IDs for the given node

fn child_count(&self, node_id: NodeId) -> usize

Get the number of children for the given node

fn get_child_id(&self, node_id: NodeId, index: usize) -> NodeId

Get a specific child of a node, where the index represents the nth child

impl TraverseTree for BaseDocument