Trait dioxus_html::SvgAttributes

source · [−]
pub trait SvgAttributes {

Show 250 methods    fn prevent_default<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn accent_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn accumulate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn additive<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn alignment_baseline<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn alphabetic<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn amplitude<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn arabic_form<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ascent<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn attributeName<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn attributeType<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn azimuth<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseFrequency<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseline_shift<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseProfile<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bbox<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn begin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bias<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn by<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn calcMode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cap_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn class<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn clip<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clipPathUnits<'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<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_interpolation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_interpolation_filters<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_profile<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn contentScriptType<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn contentStyleType<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn crossorigin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cursor<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cx<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cy<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn d<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn decelerate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn descent<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn diffuseConstant<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn direction<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn divisor<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn dominant_baseline<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn dur<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dx<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dy<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn edgeMode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn elevation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn enable_background<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn end<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn exponent<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn fill<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fill_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn fill_rule<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn filter<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn filterRes<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn filterUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flood_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flood_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_family<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size_adjust<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_stretch<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_weight<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn format<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn from<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fr<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fx<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fy<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn g1<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn g2<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn glyph_name<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyph_orientation_horizontal<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyph_orientation_vertical<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyphRef<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn gradientTransform<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn gradientUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hanging<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn href<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn hreflang<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn horiz_adv_x<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn horiz_origin_x<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn id<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ideographic<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn image_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn _in<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn in2<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn intercept<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn k<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k1<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k2<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k3<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k4<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn kernelMatrix<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn kernelUnitLength<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn kerning<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn keyPoints<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn keySplines<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn keyTimes<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn lang<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn lengthAdjust<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn letter_spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn lighting_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn limitingConeAngle<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn local<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_end<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_mid<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_start<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn markerHeight<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn markerUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn markerWidth<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn maskContentUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn maskUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mathematical<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn max<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn media<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn method<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn min<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mode<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn name<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn numOctaves<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn operator<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn order<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn orient<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn orientation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn origin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overline_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overline_thickness<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn panose_1<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn paint_order<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn path<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pathLength<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn patternContentUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn patternTransform<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn patternUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ping<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pointer_events<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn points<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pointsAtX<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pointsAtY<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pointsAtZ<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn preserveAlpha<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn preserveAspectRatio<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn primitiveUnits<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn r<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn radius<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn referrerPolicy<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn refX<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn refY<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rel<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rendering_intent<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn repeatCount<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn repeatDur<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn requiredExtensions<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn requiredFeatures<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn restart<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn result<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn role<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rotate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn rx<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ry<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn scale<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn seed<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn shape_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn slope<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn specularConstant<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn specularExponent<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speed<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn spreadMethod<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn startOffset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stdDeviation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stemh<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stemv<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stitchTiles<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stop_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stop_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn strikethrough_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn strikethrough_thickness<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn string<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_dasharray<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_dashoffset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_linecap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_linejoin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_miterlimit<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn surfaceScale<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn systemLanguage<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn tabindex<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn tableValues<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn target<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn targetX<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn targetY<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_anchor<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn textLength<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn to<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn transform<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform_origin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn type<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn u1<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn u2<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn underline_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn underline_thickness<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode_bidi<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode_range<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn units_per_em<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_alphabetic<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_hanging<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_ideographic<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_mathematical<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn values<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vector_effect<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn version<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vert_adv_y<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vert_origin_x<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vert_origin_y<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn view_box<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn view_target<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn visibility<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn widths<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn word_spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn writing_mode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn x<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn x_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn x1<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn x2<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn xmlns<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn x_channel_selector<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn y<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn y1<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn y2<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn y_channel_selector<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn z<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn zoomAndPan<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

}

Provided Methods

Prevent the default action for this element.

For more information, see the MDN docs: https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault

Implementors