Demonthos
67a6fa9eb8
* work on seperating tree struture from realdom * intial update to new mutations * handle height * update to taffy 0.2 * add as_varient functions to OwnedAttributeValue * make get node parent mut optionally return a parent * work on upward pass * add more code for parrellel passes * make resolve passes public * more work on parallel passes * fix deadlock and add more tests * move height into the tree instead of the realdom * make passes exicute in parallel instead of executing invidual passes in parellel * fix some warnings * add up dependant test * clean up examples * work on intigrating state with passes * update to new mutations * work on implementing macro * make the macro compile * more progress on macro * mark cloned nodes as dirty * update persistant_iterator utility * fix mask generation * update tui with new mutations * more progress updating tui * some basic tui examples working * don't push template nodes onto the stack * update hover example * update benchmark * update more examples * fix root node layout * ignore out of bounds renders * update color picker example * update all events example * update remaining examples * update tests * tests passing * move persistant iterator test * update examples * fix gaps in layout * fix formatting * fix memory leak
120 lines
2.9 KiB
Rust
120 lines
2.9 KiB
Rust
use crate::{state::State, tree::NodeId};
|
|
use dioxus_core::ElementId;
|
|
use rustc_hash::{FxHashMap, FxHashSet};
|
|
|
|
/// The node is stored client side and stores only basic data about the node.
|
|
#[derive(Debug, Clone)]
|
|
pub struct Node<S: State> {
|
|
/// The transformed state of the node.
|
|
pub state: S,
|
|
/// The raw data for the node
|
|
pub node_data: NodeData,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct NodeData {
|
|
/// The id of the node
|
|
pub node_id: NodeId,
|
|
/// The id of the node in the vdom.
|
|
pub element_id: Option<ElementId>,
|
|
/// Additional inforation specific to the node type
|
|
pub node_type: NodeType,
|
|
}
|
|
|
|
/// A type of node with data specific to the node type. The types are a subset of the [VNode] types.
|
|
#[derive(Debug, Clone)]
|
|
pub enum NodeType {
|
|
Text {
|
|
text: String,
|
|
},
|
|
Element {
|
|
tag: String,
|
|
namespace: Option<String>,
|
|
attributes: FxHashMap<OwnedAttributeDiscription, OwnedAttributeValue>,
|
|
listeners: FxHashSet<String>,
|
|
},
|
|
Placeholder,
|
|
}
|
|
|
|
impl<S: State> Node<S> {
|
|
pub(crate) fn new(node_type: NodeType) -> Self {
|
|
Node {
|
|
state: S::default(),
|
|
node_data: NodeData {
|
|
element_id: None,
|
|
node_type,
|
|
node_id: NodeId(0),
|
|
},
|
|
}
|
|
}
|
|
|
|
/// get the mounted id of the node
|
|
pub fn mounted_id(&self) -> Option<ElementId> {
|
|
self.node_data.element_id
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
|
|
pub struct OwnedAttributeDiscription {
|
|
pub name: String,
|
|
pub namespace: Option<String>,
|
|
pub volatile: bool,
|
|
}
|
|
|
|
/// An attribute on a DOM node, such as `id="my-thing"` or
|
|
/// `href="https://example.com"`.
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct OwnedAttributeView<'a> {
|
|
/// The discription of the attribute.
|
|
pub attribute: &'a OwnedAttributeDiscription,
|
|
|
|
/// The value of the attribute.
|
|
pub value: &'a OwnedAttributeValue,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum OwnedAttributeValue {
|
|
Text(String),
|
|
Float(f32),
|
|
Int(i32),
|
|
Bool(bool),
|
|
None,
|
|
}
|
|
|
|
impl OwnedAttributeValue {
|
|
pub fn as_text(&self) -> Option<&str> {
|
|
match self {
|
|
OwnedAttributeValue::Text(text) => Some(text),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn as_float(&self) -> Option<f32> {
|
|
match self {
|
|
OwnedAttributeValue::Float(float) => Some(*float),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn as_int(&self) -> Option<i32> {
|
|
match self {
|
|
OwnedAttributeValue::Int(int) => Some(*int),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn as_bool(&self) -> Option<bool> {
|
|
match self {
|
|
OwnedAttributeValue::Bool(bool) => Some(*bool),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn as_none(&self) -> Option<()> {
|
|
match self {
|
|
OwnedAttributeValue::None => Some(()),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|