Struct dioxus_html::h2

source · [−]

pub struct h2;

Expand description

Build a <h2> element.

About

The HTML <h2> element is found within the <body> tag.
Headings can range from <h1> to <h6>.
The most important heading is <h1> and the least important heading is <h6>.
The <h2> heading is the second heading in the document.
The <h2> heading is usually a large bolded font.

Usage

html!(<h2> A header element </h2>)
rsx!(h2 { "A header element" })
LazyNodes::new(|f| f.el(h2).children([f.text("A header element")]).finish())

Trait Implementations

source

impl DioxusElement for h2

source

const TAG_NAME: &'static str

The tag name of the element.

source

const NAME_SPACE: Option<&'static str>

The namespace of the element.

source

fn tag_name(&self) -> &'static str

The tag name of the element.

source

fn namespace(&self) -> Option<&'static str>

The namespace of the element.

source

impl GlobalAttributes for h2

source

fn prevent_default<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

Prevent the default action for this element. Read more

source

fn accesskey<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn class<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

The HTML class attribute is used to specify a class for an HTML element. Read more

source

fn contenteditable<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn data<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn dir<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn draggable<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn spellcheck<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn style<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn tabindex<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn title<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn translate<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn role<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn dangerous_inner_html<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

dangerous_inner_html is Dioxus’s replacement for using innerHTML in the browser DOM. In general, setting HTML from code is risky because it’s easy to inadvertently expose your users to a cross-site scripting (XSS) attack. So, you can set HTML directly from Dioxus, but you have to type out dangerous_inner_html to remind yourself that it’s dangerous Read more

source

fn align_content<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn align_items<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn align_self<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn alignment_adjust<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn alignment_baseline<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn all<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn alt<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn animation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_delay<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_direction<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_duration<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_fill_mode<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_iteration_count<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_name<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_play_state<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn animation_timing_function<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn azimuth<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn backface_visibility<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_attachment<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_clip<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_image<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_origin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_repeat<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_size<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn background_blend_mode<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn baseline_shift<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn bleed<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn bookmark_label<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn bookmark_level<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn bookmark_state<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn border_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_bottom<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_bottom_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_bottom_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_bottom_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_left<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_left_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_left_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_left_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_right<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_right_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_right_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_right_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_top<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_top_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_top_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_top_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_collapse<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_image<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_image_outset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_image_repeat<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_image_slice<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_image_source<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_image_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_radius<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_bottom_left_radius<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_bottom_right_radius<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_top_left_radius<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_top_right_radius<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn border_spacing<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn bottom<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn box_decoration_break<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn box_shadow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn box_sizing<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn box_snap<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn break_after<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn break_before<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn break_inside<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn buffered_rendering<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn caption_side<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn clear<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn clear_side<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn clip<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn clip_path<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn clip_rule<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn color<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn color_adjust<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn color_correction<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn color_interpolation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn color_interpolation_filters<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn color_profile<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn color_rendering<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_fill<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_gap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_rule<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_rule_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_rule_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_rule_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_span<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn columns<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn column_count<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn column_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn contain<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn content<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn counter_increment<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn counter_reset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn counter_set<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn cue<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn cue_after<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn cue_before<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn cursor<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn direction<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn display<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn display_inside<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn display_outside<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn display_extras<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn display_box<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn dominant_baseline<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn elevation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn empty_cells<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn enable_background<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn fill<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn fill_opacity<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn fill_rule<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn filter<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn float<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn float_defer_column<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn float_defer_page<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn float_offset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn float_wrap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flow_into<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flow_from<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flex<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn flex_basis<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flex_grow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flex_shrink<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flex_flow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flex_direction<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flex_wrap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flood_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn flood_opacity<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn font_family<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_size<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_stretch<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_weight<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_feature_settings<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_kerning<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_language_override<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_size_adjust<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_synthesis<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant_alternates<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant_caps<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant_east_asian<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant_ligatures<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant_numeric<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn font_variant_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn footnote_policy<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn glyph_orientation_horizontal<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn glyph_orientation_vertical<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn grid_auto_flow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_auto_columns<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_auto_rows<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_template<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_template_areas<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_template_columns<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_template_rows<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_area<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_column<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_column_start<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_column_end<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_row<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn grid_row_start<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn grid_row_end<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn hanging_punctuation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn height<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn hyphenate_character<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn hyphenate_limit_chars<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn hyphenate_limit_last<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn hyphenate_limit_lines<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn hyphenate_limit_zone<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn hyphens<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn icon<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn image_orientation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn image_resolution<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn image_rendering<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn ime<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn ime_align<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn ime_mode<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn ime_offset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn ime_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn initial_letters<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn inline_box_align<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn isolation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn justify_content<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn justify_items<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn justify_self<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn kerning<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn left<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn letter_spacing<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn lighting_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn line_box_contain<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn line_break<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn line_grid<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn line_height<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn line_slack<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn line_snap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn list_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn list_style_image<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn list_style_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn list_style_type<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn margin<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn margin_bottom<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn margin_left<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn margin_right<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn margin_top<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn marker_end<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_mid<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_pattern<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_segment<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_start<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_knockout_left<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_knockout_right<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marker_side<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marks<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn marquee_direction<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marquee_play_count<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marquee_speed<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn marquee_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn mask_image<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_repeat<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_clip<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_origin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_size<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_box<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn mask_box_outset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_box_repeat<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_box_slice<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_box_source<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_box_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mask_type<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn max_height<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn max_lines<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn max_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn min_height<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn min_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn mix_blend_mode<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn nav_down<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn nav_index<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn nav_left<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn nav_right<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn nav_up<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn object_fit<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn object_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn offset_after<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn offset_before<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn offset_end<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn offset_start<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn opacity<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn order<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn orphans<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn outline<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn outline_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn outline_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn outline_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn outline_offset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn overflow<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn overflow_x<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn overflow_y<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn overflow_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn overflow_wrap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn padding<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn padding_bottom<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn padding_left<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn padding_right<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn padding_top<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn page<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn page_break_after<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn page_break_before<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn page_break_inside<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn paint_order<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn pause<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn pause_after<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn pause_before<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn perspective<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn perspective_origin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn pitch<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn pitch_range<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn play_during<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn pointer_events<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn position<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn quotes<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn region_fragment<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn resize<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn rest<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn rest_after<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn rest_before<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn richness<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn right<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn ruby_align<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn ruby_merge<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn ruby_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn scroll_behavior<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn scroll_snap_coordinate<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn scroll_snap_destination<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn scroll_snap_points_x<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn scroll_snap_points_y<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn scroll_snap_type<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn shape_image_threshold<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn shape_inside<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn shape_margin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn shape_outside<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn shape_padding<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn shape_rendering<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn size<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn speak<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn speak_as<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn speak_header<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn speak_numeral<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn speak_punctuation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn speech_rate<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stop_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stop_opacity<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stress<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn string_set<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn stroke_dasharray<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke_dashoffset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke_linecap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke_linejoin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke_miterlimit<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke_opacity<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn stroke_width<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn tab_size<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn table_layout<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_align<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_align_all<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_align_last<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_anchor<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_combine_upright<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_decoration<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_decoration_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_decoration_line<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_decoration_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_decoration_skip<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_emphasis<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_emphasis_color<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_emphasis_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_emphasis_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_emphasis_skip<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_height<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_indent<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_justify<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_orientation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_overflow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_rendering<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_shadow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_size_adjust<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_space_collapse<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_spacing<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_transform<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_underline_position<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn text_wrap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn top<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn touch_action<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transform<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transform_box<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transform_origin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transform_style<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transition<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transition_delay<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transition_duration<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn transition_property<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn unicode_bidi<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn vector_effect<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn vertical_align<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn visibility<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_balance<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_duration<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_family<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_pitch<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_range<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_rate<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_stress<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn voice_volumn<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn volume<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn white_space<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn widows<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn width<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn will_change<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn word_break<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn word_spacing<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn word_wrap<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn wrap_flow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn wrap_through<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn writing_mode<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn gap<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn list_styler_type<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn row_gap<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn transition_timing_function<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn user_select<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn webkit_user_select<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn z_index<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

source

fn aria_current<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_details<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_disabled<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_hidden<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_invalid<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_keyshortcuts<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_label<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_roledescription<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_autocomplete<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_checked<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_expanded<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_haspopup<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_level<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_modal<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_multiline<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_multiselectable<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_orientation<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_placeholder<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_pressed<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_readonly<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_required<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_selected<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_sort<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_valuemax<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_valuemin<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_valuenow<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_valuetext<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_atomic<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_busy<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_live<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_relevant<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_dropeffect<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_grabbed<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_activedescendant<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_colcount<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_colindex<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_colspan<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_controls<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_describedby<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_errormessage<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_flowto<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_labelledby<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_owns<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_posinset<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_rowcount<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_rowindex<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_rowspan<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn aria_setsize<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

Auto Trait Implementations

impl RefUnwindSafe for h2

impl Send for h2

impl Sync for h2

impl Unpin for h2

impl UnwindSafe for h2

Blanket Implementations

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T, U> TryFrom<U> for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

Struct dioxus_html::h2

Trait Implementations

impl DioxusElement for h2

const TAG_NAME: &'static str

const NAME_SPACE: Option<&'static str>

fn tag_name(&self) -> &'static str

fn namespace(&self) -> Option<&'static str>

impl GlobalAttributes for h2

fn prevent_default<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn accesskey<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn class<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn contenteditable<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn data<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn dir<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn draggable<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn hidden<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn id<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn lang<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn spellcheck<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn style<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn tabindex<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn title<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn translate<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn role<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn dangerous_inner_html<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn align_content<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn align_items<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn align_self<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn alignment_adjust<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn alignment_baseline<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn all<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn alt<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_delay<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_direction<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_duration<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_fill_mode<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_iteration_count<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_name<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_play_state<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn animation_timing_function<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn azimuth<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn backface_visibility<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_attachment<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_clip<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_color<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_image<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_origin<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_position<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_repeat<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_size<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn background_blend_mode<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn baseline_shift<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn bleed<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn bookmark_label<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn bookmark_level<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn bookmark_state<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_color<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_style<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_width<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_bottom<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_bottom_color<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_bottom_style<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_bottom_width<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_left<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_left_color<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_left_style<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_left_width<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_right<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_right_color<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_right_style<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_right_width<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_top<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_top_color<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_top_style<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_top_width<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_collapse<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn border_image<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn prevent_default<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn accesskey<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn contenteditable<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn draggable<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn spellcheck<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn translate<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn dangerous_inner_html<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn align_content<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn align_items<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn align_self<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn alignment_adjust<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn alignment_baseline<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_delay<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_direction<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_duration<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_fill_mode<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_iteration_count<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_name<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_play_state<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn animation_timing_function<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn backface_visibility<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_attachment<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_clip<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_color<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_image<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_origin<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_position<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_repeat<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_size<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn background_blend_mode<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn baseline_shift<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn bookmark_label<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn bookmark_level<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn bookmark_state<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_color<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_style<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_width<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_bottom<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_bottom_color<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_bottom_style<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_bottom_width<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_left<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_left_color<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_left_style<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_left_width<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_right<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_right_color<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_right_style<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_right_width<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_top<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_top_color<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_top_style<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_top_width<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_collapse<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_image<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_image_outset<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_image_repeat<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_image_slice<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_image_source<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_image_width<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_radius<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_bottom_left_radius<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_bottom_right_radius<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_top_left_radius<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_top_right_radius<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn border_spacing<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn box_decoration_break<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn box_shadow<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn box_sizing<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn break_after<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn break_before<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn break_inside<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn buffered_rendering<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn caption_side<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn clear_side<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn clip_path<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn clip_rule<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>

fn color_adjust<'a>(
&self,
cx: NodeFactory<'a>,
val: Arguments<'_>
) -> Attribute<'a>