Struct DomBuilder

pub struct DomBuilder<A> { /* private fields */ }

Implementations

impl<A> DomBuilder<A>

where A: JsCast,

pub fn new_html(name: &str) -> Self

pub fn new_svg(name: &str) -> Self

impl<A> DomBuilder<A>

pub fn new(value: A) -> Self

pub fn global_event_with_options<T, F>( self, options: &EventOptions, listener: F, ) -> Self

where T: StaticEvent, F: FnMut(T) + 'static,

pub fn global_event<T, F>(self, listener: F) -> Self

where T: StaticEvent, F: FnMut(T) + 'static,

pub fn global_event_preventable<T, F>(self, listener: F) -> Self

where T: StaticEvent, F: FnMut(T) + 'static,

👎Deprecated since 0.5.21: Use global_event_with_options instead

pub fn future<F>(self, future: F) -> Self

where F: Future<Output = ()> + 'static,

pub fn apply<F>(self, f: F) -> Self

where F: FnOnce(Self) -> Self,

pub fn apply_if<F>(self, test: bool, f: F) -> Self

where F: FnOnce(Self) -> Self,

impl<A> DomBuilder<A>

where A: Clone,

pub fn with_element<B, F>(self, f: F) -> B

where F: FnOnce(Self, A) -> B,

👎Deprecated since 0.5.1: Use the with_node macro instead

pub fn before_inserted<F>(self, f: F) -> Self

where F: FnOnce(A),

👎Deprecated since 0.5.20: Use the with_node macro instead

impl<A> DomBuilder<A>

where A: Clone + 'static,

pub fn after_inserted<F>(self, f: F) -> Self

where F: FnOnce(A) + 'static,

pub fn after_removed<F>(self, f: F) -> Self

where F: FnOnce(A) + 'static,

impl<A> DomBuilder<A>

where A: Into<Node>,

pub fn into_dom(self) -> Dom

impl<A> DomBuilder<A>

where A: AsRef<JsValue>,

pub fn prop<B, C>(self, name: B, value: C) -> Self

where B: MultiStr, C: Into<JsValue>,

pub fn property<B, C>(self, name: B, value: C) -> Self

where B: MultiStr, C: Into<JsValue>,

The same as the prop method.

impl<A> DomBuilder<A>

where A: AsRef<JsValue>,

pub fn prop_signal<B, C, D>(self, name: B, value: D) -> Self

where B: MultiStr + 'static, C: Into<JsValue>, D: Signal<Item = C> + 'static,

pub fn property_signal<B, C, D>(self, name: B, value: D) -> Self

where B: MultiStr + 'static, C: Into<JsValue>, D: Signal<Item = C> + 'static,

The same as the prop_signal method.

impl<A> DomBuilder<A>

where A: AsRef<EventTarget>,

pub fn event_with_options<T, F>( self, options: &EventOptions, listener: F, ) -> Self

where T: StaticEvent, F: FnMut(T) + 'static,

pub fn event<T, F>(self, listener: F) -> Self

where T: StaticEvent, F: FnMut(T) + 'static,

pub fn event_preventable<T, F>(self, listener: F) -> Self

where T: StaticEvent, F: FnMut(T) + 'static,

👎Deprecated since 0.5.21: Use event_with_options instead

impl<A> DomBuilder<A>

where A: AsRef<Node>,

pub fn text(self, value: &str) -> Self

pub fn text_signal<B, C>(self, value: C) -> Self

where B: AsStr, C: Signal<Item = B> + 'static,

pub fn child<B: BorrowMut<Dom>>(self, child: B) -> Self

pub fn child_signal<B>(self, child: B) -> Self

where B: Signal<Item = Option<Dom>> + 'static,

pub fn children<B: BorrowMut<Dom>, C: IntoIterator<Item = B>>( self, children: C, ) -> Self

pub fn children_signal_vec<B>(self, children: B) -> Self

where B: SignalVec<Item = Dom> + 'static,

impl<A> DomBuilder<A>

where A: AsRef<Element>,

pub fn attr<B>(self, name: B, value: &str) -> Self

where B: MultiStr,

pub fn attribute<B>(self, name: B, value: &str) -> Self

where B: MultiStr,

The same as the attr method.

pub fn attr_ns<B>(self, namespace: &str, name: B, value: &str) -> Self

where B: MultiStr,

pub fn attribute_namespace<B>( self, namespace: &str, name: B, value: &str, ) -> Self

where B: MultiStr,

The same as the attr_ns method.

pub fn class<B>(self, name: B) -> Self

where B: MultiStr,

pub fn visible(self, value: bool) -> Self

impl<A> DomBuilder<A>

where A: AsRef<Element>,

pub fn attr_signal<B, C, D, E>(self, name: B, value: E) -> Self

where B: MultiStr + 'static, C: AsStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

pub fn attribute_signal<B, C, D, E>(self, name: B, value: E) -> Self

where B: MultiStr + 'static, C: AsStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

The same as the attr_signal method.

pub fn attr_ns_signal<B, C, D, E>( self, namespace: &str, name: B, value: E, ) -> Self

where B: MultiStr + 'static, C: AsStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

pub fn attribute_namespace_signal<B, C, D, E>( self, namespace: &str, name: B, value: E, ) -> Self

where B: MultiStr + 'static, C: AsStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

The same as the attr_ns_signal method.

pub fn class_signal<B, C>(self, name: B, value: C) -> Self

where B: MultiStr + 'static, C: Signal<Item = bool> + 'static,

pub fn visible_signal<B>(self, value: B) -> Self

where B: Signal<Item = bool> + 'static,

pub fn scroll_left_signal<B>(self, signal: B) -> Self

where B: Signal<Item = Option<i32>> + 'static,

pub fn scroll_top_signal<B>(self, signal: B) -> Self

where B: Signal<Item = Option<i32>> + 'static,

impl<A> DomBuilder<A>

where A: AsRef<HtmlElement>,

pub fn style<B, C>(self, name: B, value: C) -> Self

where B: MultiStr, C: MultiStr,

pub fn style_important<B, C>(self, name: B, value: C) -> Self

where B: MultiStr, C: MultiStr,

pub fn style_unchecked<B, C>(self, name: B, value: C) -> Self

where B: AsStr, C: AsStr,

impl<A> DomBuilder<A>

where A: AsRef<HtmlElement>,

pub fn style_signal<B, C, D, E>(self, name: B, value: E) -> Self

where B: MultiStr + 'static, C: MultiStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

pub fn style_important_signal<B, C, D, E>(self, name: B, value: E) -> Self

where B: MultiStr + 'static, C: MultiStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

pub fn style_unchecked_signal<B, C, D, E>(self, name: B, value: E) -> Self

where B: AsStr + 'static, C: AsStr, D: OptionStr<Output = C>, E: Signal<Item = D> + 'static,

pub fn focused(self, value: bool) -> Self

pub fn focused_signal<B>(self, value: B) -> Self

where B: Signal<Item = bool> + 'static,