Struct qmetaobject::scenegraph::SGNode

#[repr(C)]
pub struct SGNode<T> {
    pub raw: *mut c_void,
    // some fields omitted
}

A typed node in the scene graph

the SGNode owns a QSGNode* of a given type. The type information is given by T which is a Tag type (an empty enum)

Fields

raw: *mut c_void

Methods

impl<T> SGNode<T>

pub unsafe fn from_raw(raw: *mut c_void) -> Self

pub fn into_raw(self) -> *mut c_void

"leak" the QSGNode* pointer, so the caller must take ownership

pub fn reset(&mut self)

impl SGNode<ContainerNode>

pub fn update_dynamic<T: Any, Iter: ExactSizeIterator, F>(
    &mut self,
    iter: Iter,
    f: F
) where
    F: FnMut(<Iter as Iterator>::Item, SGNode<T>) -> SGNode<T>, 

Update the child nodes from an iterator.

When calling this function, all child nodes must be of the same type, but the amount of node must not be known at compile time.

The array must have the same size every time the function is called on the node. (panic otherwise). call reset() if you want to change the size.

// in the reimplementation of  QQuickItem::update_paint_node
fn update_paint_node(&mut self, mut node : SGNode<ContainerNode> ) -> SGNode<ContainerNode> {
   let items : &Vec<QRectF> = &self.items;
   node.update_dynamic(items.iter(),
       |i, mut n| -> SGNode<RectangleNode> { n.create(self); n.set_rect(*i); n });
   node
 }

pub fn update_static<A: 'static, T: UpdateNodeFnTuple<A>>(&mut self, info: T)

Update the child node: given a tuple of update function, runs it for every node

The argument is a tuple of update functions. The same node types must be used every time this function is called. (If reset() was not called in between) (Panic otherwise). Each node type can be different.

In this example, the node has two children node

// in the reimplementation of  QQuickItem::update_paint_node
fn update_paint_node(&mut self, mut node : SGNode<ContainerNode> ) -> SGNode<ContainerNode> {
     node.update_static((
         |mut n : SGNode<RectangleNode>| -> SGNode<RectangleNode> {
             n.create(self);
             n.set_rect(QRectF { x: 0., y: 0., width: 42., height: 42. });
             n
         },
         |mut n : SGNode<RectangleNode>| -> SGNode<RectangleNode> {
             n.create(self);
             n.set_rect(QRectF { x: 0., y: 0., width: 42., height: 42. });
             n
         }));
     node
 }

impl SGNode<RectangleNode>

pub fn set_color(&mut self, color: QColor)

pub fn set_rect(&mut self, rect: QRectF)

pub fn create(&mut self, item: &dyn QQuickItem)

impl SGNode<TransformNode>

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

pub fn create(&mut self)

pub fn update_sub_node<F: FnMut(SGNode<ContainerNode>) -> SGNode<ContainerNode>>(
    &mut self,
    f: F
)

Trait Implementations

impl<T> Drop for SGNode<T>

fn drop(&mut self)

Destroy the SGNode*