Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package wvlet.airframe.rx.html
/**
* SVG attribute definitions
*/
trait HtmlSvgAttrs {
import HtmlTags.*
// private def attr(name: String): HtmlAttributeOf = html.attr(name, Namespace.svg)
/**
* This attribute defines the distance from the origin to the top of accent characters, measured by a distance within
* the font coordinate system. If the attribute is not specified, the effect is as if the attribute were set to the
* value of the ascent attribute.
*
* Value
*
* MDN
*/
lazy val accentHeight = attr("accent-height")
/**
* This attribute controls whether or not the animation is cumulative. It is frequently useful for repeated
* animations to build upon the previous results, accumulating with each iteration. This attribute said to the
* animation if the value is added to the previous animated attribute's value on each iteration.
*
* Value none | sum
*
* MDN
*/
lazy val accumulate = attr("accumulate")
/**
* This attribute controls whether or not the animation is additive. It is frequently useful to define animation as
* an offset or delta to an attribute's value, rather than as absolute values. This attribute said to the animation
* if their values are added to the original animated attribute's value.
*
* Value replace | sum
*
* MDN
*/
lazy val additive = attr("additive")
/**
* The alignment-baseline attribute specifies how an object is aligned with respect to its parent. This property
* specifies which baseline of this element is to be aligned with the corresponding baseline of the parent. For
* example, this allows alphabetic baselines in Roman text to stay aligned across font size changes. It defaults to
* the baseline with the same name as the computed value of the alignment-baseline property. As a presentation
* attribute, it also can be used as a property directly inside a CSS stylesheet, see css alignment-baseline for
* further information.
*
* Value: auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge |
* ideographic | alphabetic | hanging | mathematical | inherit
*
* MDN
*/
lazy val alignmentBaseline = attr("alignment-baseline")
/**
* This attribute defines the maximum unaccented depth of the font within the font coordinate system. If the
* attribute is not specified, the effect is as if the attribute were set to the vert-origin-y value for the
* corresponding font.
*
* Value
*
* MDN
*/
lazy val ascent = attr("ascent")
/**
* This attribute indicates the name of the attribute in the parent element that is going to be changed during an
* animation.
*
* Value
*
* MDN
*/
lazy val attributeName = attr("attributeName")
/**
* This attribute specifies the namespace in which the target attribute and its associated values are defined.
*
* Value CSS | XML | auto
*
* MDN
*/
lazy val attributeType = attr("attributeType")
/**
* The azimuth attribute represent the direction angle for the light source on the XY plane (clockwise), in degrees
* from the x axis. If the attribute is not specified, then the effect is as if a value of 0 were specified.
*
* Value
*
* MDN
*/
lazy val azimuth = attr("azimuth")
/**
* The baseFrequency attribute represent The base frequencies parameter for the noise function of the
* primitive. If two s are provided, the first number represents a base frequency in the X direction and the
* second value represents a base frequency in the Y direction. If one number is provided, then that value is used
* for both X and Y. Negative values are forbidden. If the attribute is not specified, then the effect is as if a
* value of 0 were specified.
*
* Value
*
* MDN
*/
lazy val baseFrequency = attr("baseFrequency")
/**
* The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of
* the parent text content element. The shifted object might be a sub- or superscript. As a presentation attribute,
* it also can be used as a property directly inside a CSS stylesheet, see css baseline-shift for further
* information.
*
* Value auto | baseline | sup | sub | | | inherit
*
* MDN
*/
lazy val baselineShift = attr("baseline-shift")
/**
* This attribute defines when an animation should begin. The attribute value is a semicolon separated list of
* values. The interpretation of a list of start times is detailed in the SMIL specification in "Evaluation of begin
* and end time lists". Each individual value can be one of the following: , ,
* , , , or the keyword indefinite.
*
* Value
*
* MDN
*/
lazy val begin = attr("begin")
/**
* The bias attribute shifts the range of the filter. After applying the kernelMatrix of the
* element to the input image to yield a number and applied the divisor attribute, the bias attribute is added to
* each component. This allows representation of values that would otherwise be clamped to 0 or 1. If bias is not
* specified, then the effect is as if a value of 0 were specified.
*
* Value
*
* MDN
*/
lazy val bias = attr("bias")
/**
* This attribute specifies the interpolation mode for the animation. The default mode is linear, however if the
* attribute does not support linear interpolation (e.g. for strings), the calcMode attribute is ignored and discrete
* interpolation is used.
*
* Value discrete | linear | paced | spline
*
* MDN
*/
lazy val calcMode = attr("calcMode")
/**
* Assigns a class name or set of class names to an element. You may assign the same class name or names to any
* number of elements. If you specify multiple class names, they must be separated by whitespace characters. The
* class name of an element has two key roles: -As a style sheet selector, for use when an author wants to assign
* style information to a set of elements. -For general usage by the browser. The class can be used to style SVG
* content using CSS.
*
* Value
*
* MDN
*/
lazy val `class` = attr("class")
/**
* The clip attribute has the same parameter values as defined for the css clip property. Unitless values, which
* indicate current user coordinates, are permitted on the coordinate values on the . The value of auto
* defines a clipping path along the bounds of the viewport created by the given element. As a presentation
* attribute, it also can be used as a property directly inside a CSS stylesheet, see css clip for further
* information.
*
* Value auto | | inherit
*
* MDN
*/
lazy val clip = attr("clip")
/**
* The clip-path attribute bind the element is applied to with a given element As a presentation
* attribute, it also can be used as a property directly inside a CSS stylesheet
*
* Value | none | inherit
*
* MDN
*/
lazy val clipPath = attr("clip-path")
/**
* The clipPathUnits attribute defines the coordinate system for the contents of the element. the
* clipPathUnits attribute is not specified, then the effect is as if a value of userSpaceOnUse were specified. Note
* that values defined as a percentage inside the content of the are not affected by this attribute. It
* means that even if you set the value of maskContentUnits to objectBoundingBox, percentage values will be
* calculated as if the value of the attribute were userSpaceOnUse.
*
* Value userSpaceOnUse | objectBoundingBox
*
* MDN
*/
lazy val clipPathUnits = attr("clipPathUnits")
/**
* The clip-rule attribute only applies to graphics elements that are contained within a element. The
* clip-rule attribute basically works as the fill-rule attribute, except that it applies to definitions.
*
* Value nonezero | evenodd | inherit
*
* MDN
*/
lazy val clipRule = attr("clip-rule")
/**
* The color attribute is used to provide a potential indirect value (currentColor) for the fill, stroke, stop-color,
* flood-color and lighting-color attributes. As a presentation attribute, it also can be used as a property directly
* inside a CSS stylesheet, see css color for further information.
*
* Value | inherit
*
* MDN
*/
lazy val color = attr("color")
/**
* The color-interpolation attribute specifies the color space for gradient interpolations, color animations and
* alpha compositing.When a child element is blended into a background, the value of the color-interpolation
* attribute on the child determines the type of blending, not the value of the color-interpolation on the parent.
* For gradients which make use of the xlink:href attribute to reference another gradient, the gradient uses the
* color-interpolation attribute value from the gradient element which is directly referenced by the fill or stroke
* attribute. When animating colors, color interpolation is performed according to the value of the
* color-interpolation attribute on the element being animated. As a presentation attribute, it also can be used as a
* property directly inside a CSS stylesheet, see css color-interpolation for further information
*
* Value auto | sRGB | linearRGB | inherit
*
* MDN
*/
lazy val colorInterpolation = attr("color-interpolation")
/**
* The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
* effects. Note that color-interpolation-filters has a different initial value than color-interpolation.
* color-interpolation-filters has an initial value of linearRGB, whereas color-interpolation has an initial value of
* sRGB. Thus, in the default case, filter effects operations occur in the linearRGB color space, whereas all other
* color interpolations occur by default in the sRGB color space. As a presentation attribute, it also can be used as
* a property directly inside a CSS stylesheet, see css color-interpolation-filters for further information
*
* Value auto | sRGB | linearRGB | inherit
*
* MDN
*/
lazy val colorInterpolationFilters = attr("color-interpolation-filters")
/**
* The color-profile attribute is used to define which color profile a raster image included through the
* element should use. As a presentation attribute, it also can be used as a property directly inside a CSS
* stylesheet, see css color-profile for further information.
*
* Value auto | sRGB | | | inherit
*
* MDN
*/
lazy val colorProfile = attr("color-profile")
/**
* The color-rendering attribute provides a hint to the SVG user agent about how to optimize its color interpolation
* and compositing operations. color-rendering takes precedence over color-interpolation-filters. For example, assume
* color-rendering: optimizeSpeed and color-interpolation-filters: linearRGB. In this case, the SVG user agent should
* perform color operations in a way that optimizes performance, which might mean sacrificing the color interpolation
* precision as specified by color-interpolation-filters: linearRGB. As a presentation attribute, it also can be used
* as a property directly inside a CSS stylesheet, see css color-rendering for further information
*
* Value auto | optimizeSpeed | optimizeQuality | inherit
*
* MDN
*/
lazy val colorRendering = attr("color-rendering")
/**
* The contentScriptType attribute on the
