Struct rsvg::node::CascadedValues

pub struct CascadedValues<'a> {
    inner: CascadedInner<'a>,
    pub context_stroke: Option<Rc<PaintSource>>,
    pub context_fill: Option<Rc<PaintSource>>,
}

Can obtain computed values from a node

In our tree of SVG elements (Node in our parlance), each node stores a ComputedValues that gets computed during the initial CSS cascade. However, sometimes nodes need to be rendered outside the normal hierarchy. For example, the <use> element can “instance” a subtree from elsewhere in the SVG; it causes the instanced subtree to re-cascade from the computed values for the <use> element.

You can then call the get() method on the resulting CascadedValues to get a &ComputedValues whose fields you can access.

Fields

inner: CascadedInner<'a>

context_stroke: Option<Rc<PaintSource>>

context_fill: Option<Rc<PaintSource>>

Implementations

impl<'a> CascadedValues<'a>

pub fn clone_with_node(&self, node: &'a Node<NodeData>) -> CascadedValues<'a>

Creates a CascadedValues that has the same cascading mode as &self

This is what nodes should normally use to draw their children from their draw() method. Nodes that need to override the cascade for their children can use new_from_values() instead.

pub fn new_from_node(node: &Node<NodeData>) -> CascadedValues<'_>

Creates a CascadedValues that will hold the node’s computed values

This is to be used only in the toplevel drawing function, or in elements like <marker> that don’t propagate their parent’s cascade to their children. All others should use new() to derive the cascade from an existing one.

pub fn new_from_values( node: &'a Node<NodeData>, values: &ComputedValues, fill: Option<Rc<PaintSource>>, stroke: Option<Rc<PaintSource>>, ) -> CascadedValues<'a>

Creates a CascadedValues that will override the node’s cascade with the specified values

This is for the <use> element, which draws the element which it references with the <use>’s own cascade, not with the element’s original cascade.

pub fn get(&'a self) -> &'a ComputedValues

Returns the cascaded ComputedValues.

Nodes should use this from their Draw::draw() implementation to get the ComputedValues from the CascadedValues that got passed to draw().