Struct ServoLayoutNode

#[repr(transparent)]
pub struct ServoLayoutNode<'dom> {
    pub(super) node: LayoutDom<'dom, Node>,
}

A wrapper around a LayoutDom<Node> which provides a safe interface that can be used during layout. This implements the LayoutNode trait as well as several style and selectors traits for use during layout. This version should only be used on a single thread. If you need to use nodes across threads use ServoThreadSafeLayoutNode.

Fields

node: LayoutDom<'dom, Node>

The wrapped private DOM node.

Implementations

impl<'dom> ServoLayoutNode<'dom>

pub(super) fn from_layout_js(n: LayoutDom<'dom, Node>) -> Self

pub unsafe fn new(address: &TrustedNodeAddress) -> Self

Create a new ServoLayoutNode for this given TrustedNodeAddress.

Safety

The address pointed to by address should point to a valid node in memory.

pub(super) fn script_type_id(&self) -> NodeTypeId

pub(crate) fn get_jsmanaged(self) -> LayoutDom<'dom, Node>

Returns the interior of this node as a LayoutDom.

pub(crate) fn assigned_slot(self) -> Option<ServoLayoutElement<'dom>>

Trait Implementations

impl<'dom> Clone for ServoLayoutNode<'dom>

fn clone(&self) -> ServoLayoutNode<'dom>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ServoLayoutNode<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'dom> LayoutNode<'dom> for ServoLayoutNode<'dom>

type ConcreteThreadSafeLayoutNode = ServoThreadSafeLayoutNode<'dom>

fn to_threadsafe(&self) -> Self::ConcreteThreadSafeLayoutNode

fn type_id(&self) -> LayoutNodeType

Returns the type ID of this node.

unsafe fn initialize_style_and_layout_data<RequestedLayoutDataType: LayoutDataTrait>( &self, )

Initialize this node with empty style and opaque layout data.

fn initialize_layout_data<RequestedLayoutDataType: LayoutDataTrait>(&self)

Initialize this node with empty opaque layout data.

fn is_connected(&self) -> bool

Returns whether the node is connected.

fn style_data(&self) -> Option<&'dom StyleData>

Get the StyleData for this node. Returns None if the node is unstyled.

fn layout_data(&self) -> Option<&'dom GenericLayoutData>

Get the layout data of this node, attempting to downcast it to the desired type. Returns None if there is no layout data or it isn’t of the desired type.

fn rev_children(self) -> LayoutIterator<ReverseChildrenIterator<Self>>

fn traverse_preorder(self) -> TreeIterator<Self>

impl NodeInfo for ServoLayoutNode<'_>

fn is_element(&self) -> bool

Whether this node is an element.

fn is_text_node(&self) -> bool

Whether this node is a text node.

impl<'dom> PartialEq for ServoLayoutNode<'dom>

fn eq(&self, other: &ServoLayoutNode<'dom>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'dom> TNode for ServoLayoutNode<'dom>

type ConcreteDocument = ServoLayoutDocument<'dom>

The concrete TDocument type.

type ConcreteElement = ServoLayoutElement<'dom>

The concrete TElement type.

type ConcreteShadowRoot = ServoShadowRoot<'dom>

The concrete TShadowRoot type.

fn parent_node(&self) -> Option<Self>

Get this node’s parent node.

fn first_child(&self) -> Option<Self>

Get this node’s first child.

fn last_child(&self) -> Option<Self>

Get this node’s last child.

fn prev_sibling(&self) -> Option<Self>

Get this node’s previous sibling.

fn next_sibling(&self) -> Option<Self>

Get this node’s next sibling.

fn owner_doc(&self) -> Self::ConcreteDocument

Get the owner document of this node.

fn traversal_parent(&self) -> Option<ServoLayoutElement<'dom>>

Get this node’s parent element from the perspective of a restyle traversal.

fn opaque(&self) -> OpaqueNode

Converts self into an OpaqueNode.

fn debug_id(self) -> usize

A debug id, only useful, mm… for debugging.

fn as_element(&self) -> Option<ServoLayoutElement<'dom>>

Get this node as an element, if it’s one.

fn as_document(&self) -> Option<ServoLayoutDocument<'dom>>

Get this node as a document, if it’s one.

fn as_shadow_root(&self) -> Option<ServoShadowRoot<'dom>>

Get this node as a ShadowRoot, if it’s one.

fn is_in_document(&self) -> bool

Returns whether the node is attached to a document.

fn dom_children(&self) -> DomChildren<Self>

Iterate over the DOM children of a node.

fn dom_descendants(&self) -> DomDescendants<Self>

Iterate over the DOM children of a node, in preorder.

fn next_in_preorder(&self, scoped_to: Self) -> Option<Self>

Returns the next node after this one, in a pre-order tree-traversal of the subtree rooted at scoped_to.

fn depth(&self) -> usize

Returns the depth of this node in the DOM.

fn parent_element(&self) -> Option<Self::ConcreteElement>

Get this node’s parent element if present.

fn parent_element_or_host(&self) -> Option<Self::ConcreteElement>

Get this node’s parent element, or shadow host if it’s a shadow root.

impl<'dom> Copy for ServoLayoutNode<'dom>

impl Send for ServoLayoutNode<'_>

Those are supposed to be sound, but they aren’t because the entire system between script and layout so far has been designed to work around their absence. Switching the entire thing to the inert crate infra will help.

FIXME(mrobinson): These are required because Layout 2020 sends non-threadsafe nodes to different threads. This should be adressed in a comprehensive way.

impl<'dom> StructuralPartialEq for ServoLayoutNode<'dom>

impl Sync for ServoLayoutNode<'_>