Trait dioxus::prelude::SvgAttributes[−][src]

pub trait SvgAttributes {

Show 249 methods    fn accent_height(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn accumulate(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn additive(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn alphabetic(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn amplitude(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn arabic_form(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn ascent(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn attributeName(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn attributeType(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn baseFrequency(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn baseProfile(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn bbox(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn begin(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn bias(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn by(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn calcMode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn cap_height(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn clipPathUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

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

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

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

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

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

    fn contentScriptType(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn contentStyleType(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn crossorigin(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn cy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn d(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn decelerate(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn descent(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn diffuseConstant(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn divisor(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn dur(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn dx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn dy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn edgeMode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

    fn end(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn exponent(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

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

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

    fn filterRes(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn filterUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

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

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

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

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

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

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

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

    fn format(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn from(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn fr(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn fx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn fy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn g1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn g2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn glyph_name(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn glyphRef(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn gradientTransform(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn gradientUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn hanging(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn href(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn hreflang(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn horiz_adv_x(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn horiz_origin_x(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn ideographic(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn _in(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn in2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn intercept(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn k(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn k1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn k2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn k3(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn k4(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn kernelMatrix(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn kernelUnitLength(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn keyPoints(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn keySplines(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn keyTimes(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn lengthAdjust(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn limitingConeAngle(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn local(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

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

    fn markerHeight(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn markerUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn markerWidth(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn maskContentUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn maskUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn mathematical(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn max(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn media(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn method(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn min(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn mode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn name(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn numOctaves(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn offset(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn operator(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn orient(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn orientation(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn origin(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn overline_position(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn overline_thickness(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn panose_1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn path(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn pathLength(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn patternContentUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn patternTransform(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn patternUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn ping(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn points(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn pointsAtX(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn pointsAtY(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn pointsAtZ(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn preserveAlpha(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn preserveAspectRatio(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn primitiveUnits(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn r(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn radius(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn referrerPolicy(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn refX(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn refY(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn rel(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn rendering_intent(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn repeatCount(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn repeatDur(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn requiredExtensions(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn requiredFeatures(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn restart(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn result(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn rotate(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn rx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn ry(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn scale(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn seed(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn slope(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn spacing(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn specularConstant(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn specularExponent(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn speed(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn spreadMethod(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn startOffset(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn stdDeviation(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn stemh(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn stemv(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn stitchTiles(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn strikethrough_position(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn strikethrough_thickness(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn string(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

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

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

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

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

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

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

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

    fn surfaceScale(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn systemLanguage(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

    fn tableValues(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn target(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn targetX(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn targetY(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

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

    fn textLength(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn to(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

    fn type(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn u1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn u2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn underline_position(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn underline_thickness(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn unicode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn unicode_range(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn units_per_em(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn v_alphabetic(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn v_hanging(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn v_ideographic(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn v_mathematical(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn values(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

    fn version(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn vert_adv_y(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn vert_origin_x(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn vert_origin_y(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn view_box(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn view_target(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

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

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

    fn widths(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

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

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

    fn x(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn x_height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn x1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn x2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn xmlns(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn x_channel_selector(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn y(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn y1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn y2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn y_channel_selector(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

    fn z(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }

    fn zoomAndPan(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

}

Provided methods

Implementations on Foreign Types

[src]

impl SvgAttributes for text

Implementors