Struct mogwai::component::GizmoComponent

pub struct GizmoComponent<T: Component> {
    pub trns: Transmitter<T::ModelMsg>,
    pub recv: Receiver<T::ViewMsg>,
    // some fields omitted
}

A component and all of its pieces.

TODO: Think about renaming Gizmo to Dom and GizmoComponent to Gizmo. I think people will use this GizmoComponent more often.

Fields

trns: Transmitter<T::ModelMsg>

recv: Receiver<T::ViewMsg>

Methods

impl<T> GizmoComponent<T> where
    T: Component + 'static,
    T::ViewMsg: Clone,
    T::DomNode: AsRef<Node> + Clone, 

pub fn new(init: T) -> GizmoComponent<T>

pub fn dom_ref(&self) -> &T::DomNode

A reference to the DomNode.

pub fn gizmo_ref(&self) -> &Gizmo<T::DomNode>

A reference to the Gizmo.

pub fn rx_from(self, rx: Receiver<T::ModelMsg>) -> GizmoComponent<T>

Send model messages into this component from a Receiver<T::ModelMsg>. This is helpful for sending messages to this component from a parent component.

pub fn tx_into(self, tx: &Transmitter<T::ViewMsg>) -> GizmoComponent<T>

Send view messages from this component into a Transmitter<T::ViewMsg>. This is helpful for sending messages to this component from a parent component.

pub fn run_init(self, msgs: Vec<T::ModelMsg>) -> Result<(), JsValue>

Run and initialize the component with a list of messages. This is equivalent to calling run and update with each message.

pub fn run(self) -> Result<(), JsValue>

Run this component forever

pub fn update(&mut self, msg: &T::ModelMsg)

Update the component with the given message. This how a parent component communicates down to its child components.

pub fn with_state<F, N>(&self, f: F) -> N where
    F: Fn(&T) -> N, 

Access the component's underlying state.

Methods from Deref<Target = Gizmo<T::DomNode>>

Trait Implementations

impl<T: Component> Deref for GizmoComponent<T>

type Target = Gizmo<T::DomNode>

The resulting type after dereferencing.

fn deref(&self) -> &Gizmo<T::DomNode>

Dereferences the value.

impl<T> SubGizmo for GizmoComponent<T> where
    T: Component,
    T::DomNode: AsRef<Node>, 

fn into_sub_gizmo(self) -> Result<Gizmo<Node>, Node>

Attempts to turn the Gizmo into a child gizmo who's inner element is a Node, if possible. Otherwise this will return a Node.