Struct Bind

pub struct Bind<Key, T, R, W>
where
    Key: AttributeKey,
    T: FromEventTarget + AttributeValue + 'static,
    R: Get<Value = T> + Clone + 'static,
    W: Update<Value = T>,
{ /* private fields */ }

Two-way binding of an attribute and an event listener

Implementations

impl<Key, T, R, W> Bind<Key, T, R, W>

where Key: AttributeKey, T: FromEventTarget + AttributeValue + PartialEq + Sync + 'static, R: Get<Value = T> + Clone + Send + Sync + 'static, W: Update<Value = T> + Clone + 'static, Element: ChangeEvent + GetValue<T>,

pub fn attach(self, el: &Element) -> RemoveEventHandler<Element>

Attaches the event listener that updates the signal value to the element.

pub fn read_signal(&self, el: &Element) -> Signal<BoolOrT<T>>

Creates the signal to update the value of the attribute. This signal is different when using a "group" attribute

pub fn key(&self) -> &'static str

Returns the key of the attribute. If the key is "group" it returns "checked", otherwise the one which was provided originally.

Trait Implementations

impl<Key, T, R, W> Attribute for Bind<Key, T, R, W>

where Key: AttributeKey, T: FromEventTarget + AttributeValue + PartialEq + Sync + 'static, R: Get<Value = T> + Clone + Send + Sync + 'static, Signal<BoolOrT<T>>: IntoProperty, W: Update<Value = T> + Clone + Send + 'static, Element: ChangeEvent + GetValue<T>,

const MIN_LENGTH: usize = 0usize

The minimum length of this attribute in HTML.

type State = (<Signal<BoolOrT<T>> as IntoProperty>::State, (Element, Option<RemoveEventHandler<Element>>))

The state that should be retained between building and rebuilding.

type AsyncOutput = Bind<Key, T, R, W>

The type once all async data have loaded.

type Cloneable = Bind<Key, T, R, W>

An equivalent to this attribute that can be cloned to be shared across elements.

type CloneableOwned = Bind<Key, T, R, W>

An equivalent to this attribute that can be cloned to be shared across elements, and captures no references shorter than 'static.

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

fn to_html( self, _buf: &mut String, _class: &mut String, _style: &mut String, _inner_html: &mut String, )

Renders the attribute to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Bind<Key, T, R, W> as Attribute>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <Bind<Key, T, R, W> as Attribute>::State

Adds this attribute to the element during client-side rendering.

fn rebuild(self, state: &mut <Bind<Key, T, R, W> as Attribute>::State)

Applies a new value for the attribute.

fn into_cloneable(self) -> <Bind<Key, T, R, W> as Attribute>::Cloneable

Converts this attribute into an equivalent that can be cloned.

fn into_cloneable_owned( self, ) -> <Bind<Key, T, R, W> as Attribute>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <Bind<Key, T, R, W> as Attribute>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

impl<Key, T, R, W> Clone for Bind<Key, T, R, W>

where Key: AttributeKey, T: FromEventTarget + AttributeValue + 'static, R: Get<Value = T> + Clone + 'static, W: Update<Value = T> + Clone,

fn clone(&self) -> Bind<Key, T, R, W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Key, T, R, W> Debug for Bind<Key, T, R, W>

where Key: Debug + AttributeKey, T: Debug + FromEventTarget + AttributeValue + 'static, R: Debug + Get<Value = T> + Clone + 'static, W: Debug + Update<Value = T>,

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

Formats the value using the given formatter.

impl<Key, T, R, W> NextAttribute for Bind<Key, T, R, W>

where Key: AttributeKey, T: FromEventTarget + AttributeValue + PartialEq + Sync + 'static, R: Get<Value = T> + Clone + Send + Sync + 'static, Signal<BoolOrT<T>>: IntoProperty, W: Update<Value = T> + Clone + Send + 'static, Element: ChangeEvent + GetValue<T>,

type Output<NewAttr: Attribute> = (Bind<Key, T, R, W>, NewAttr)

The type of the new, combined attribute.

fn add_any_attr<NewAttr>( self, new_attr: NewAttr, ) -> <Bind<Key, T, R, W> as NextAttribute>::Output<NewAttr>

where NewAttr: Attribute,

Adds a new attribute.

impl<Key, T, R, W> ToTemplate for Bind<Key, T, R, W>

where Key: AttributeKey, T: FromEventTarget + AttributeValue + 'static, R: Get<Value = T> + Clone + 'static, W: Update<Value = T> + Clone,

fn to_template( _buf: &mut String, _class: &mut String, _style: &mut String, _inner_html: &mut String, _position: &mut Position, )

Renders a view type to a template. This does not take actual view data, but can be used for constructing part of an HTML <template> that corresponds to a view of a particular type.

const TEMPLATE: &'static str = ""

The HTML content of the static template.

const CLASS: &'static str = ""

The class attribute content known at compile time.

const STYLE: &'static str = ""

The style attribute content known at compile time.

const LEN: usize = _

The length of the template.