trait SvgTags extends generic.SvgTags[Builder, String, String] with TagFactory
- Alphabetic
- By Inheritance
- SvgTags
- TagFactory
- SvgTags
- Util
- LowPriUtil
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
implicit
class
SeqNode
[A] extends Modifier[Builder]
Allows you to modify a ConcreteHtmlTag by adding a Seq containing other nest-able objects to its list of children.
Allows you to modify a ConcreteHtmlTag by adding a Seq containing other nest-able objects to its list of children.
- Definition Classes
- Util
-
abstract
type
ConcreteHtmlTag[T <: String] <: TypedTag[Builder, T, String]
- Definition Classes
- Util
Abstract Value Members
-
implicit abstract
def
SeqFrag[A](xs: Seq[A])(implicit ev: (A) ⇒ generic.Frag[Builder, String]): generic.Frag[Builder, String]
Renders an Seq of FragT into a single FragT
Renders an Seq of FragT into a single FragT
- Definition Classes
- LowPriUtil
-
implicit abstract
def
UnitFrag(u: Unit): generic.Frag[Builder, String]
Lets you put Unit into a scalatags tree, as a no-op.
Lets you put Unit into a scalatags tree, as a no-op.
- Definition Classes
- LowPriUtil
-
abstract
def
makeAbstractTypedTag[T <: String](tag: String, void: Boolean, namespaceConfig: Namespace): ConcreteHtmlTag[T]
- Definition Classes
- Util
-
implicit abstract
def
stringAttrX: AttrValue[Builder, String]
- Attributes
- protected[this]
- Definition Classes
- Util
-
implicit abstract
def
stringPixelStyleX: PixelStyleValue[Builder, String]
- Attributes
- protected[this]
- Definition Classes
- Util
-
implicit abstract
def
stringStyleX: StyleValue[Builder, String]
- Attributes
- protected[this]
- Definition Classes
- Util
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
implicit
def
ArrayFrag[A](xs: Array[A])(implicit ev: (A) ⇒ generic.Frag[Builder, String]): generic.Frag[Builder, String]
Renders an Seq of FragT into a single FragT
Renders an Seq of FragT into a single FragT
- Definition Classes
- LowPriUtil
-
implicit
def
ArrayNode[A](xs: Array[A])(implicit ev: (A) ⇒ Modifier[Builder]): SeqNode[A]
Allows you to modify a ConcreteHtmlTag by adding an Array containing other nest-able objects to its list of children.
Allows you to modify a ConcreteHtmlTag by adding an Array containing other nest-able objects to its list of children.
- Definition Classes
- Util
-
implicit
def
OptionFrag[A](xs: Option[A])(implicit ev: (A) ⇒ generic.Frag[Builder, String]): generic.Frag[Builder, String]
Renders an Option of FragT into a single FragT
Renders an Option of FragT into a single FragT
- Definition Classes
- LowPriUtil
-
implicit
def
OptionNode[A](xs: Option[A])(implicit ev: (A) ⇒ Modifier[Builder]): SeqNode[A]
Allows you to modify a ConcreteHtmlTag by adding an Option containing other nest-able objects to its list of children.
Allows you to modify a ConcreteHtmlTag by adding an Option containing other nest-able objects to its list of children.
- Definition Classes
- Util
-
lazy val
altGlyph: ConcreteHtmlTag[String]
The altGlyph element allows sophisticated selection of the glyphs used to render its child character data.
-
lazy val
altGlyphDef: ConcreteHtmlTag[String]
The altGlyphDef element defines a substitution representation for glyphs.
-
lazy val
altGlyphItem: ConcreteHtmlTag[String]
The altGlyphItem element provides a set of candidates for glyph substitution by the altGlyph element.
-
lazy val
animate: ConcreteHtmlTag[String]
The animate element is put inside a shape element and defines how an attribute of an element changes over the animation
-
lazy val
animateMotion: ConcreteHtmlTag[String]
The animateMotion element causes a referenced element to move along a motion path.
-
lazy val
animateTransform: ConcreteHtmlTag[String]
The animateTransform element animates a transformation attribute on a target element, thereby allowing animations to control translation, scaling, rotation and/or skewing.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
attr(s: String, ns: Namespace = null, raw: Boolean = false): Attr
Constructs an Attr attribute object from a string; can be used inline:
-
lazy val
circle: ConcreteHtmlTag[String]
The circle element is an SVG basic shape, used to create circles based on a center point and a radius.
-
lazy val
clipPath: ConcreteHtmlTag[String]
The clipping path restricts the region to which paint can be applied.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
lazy val
color-profile: ConcreteHtmlTag[String]
The element allows describing the color profile used for the image.
-
def
css(s: String): Style
Constructs a CSS Style from a string, can be used inline
-
lazy val
cursor: ConcreteHtmlTag[String]
The cursor element can be used to define a platform-independent custom cursor.
The cursor element can be used to define a platform-independent custom cursor. A recommended approach for defining a platform-independent custom cursor is to create a PNG image and define a cursor element that references the PNG image and identifies the exact position within the image which is the pointer position (i.e., the hot spot).
MDN
-
lazy val
defs: ConcreteHtmlTag[String]
SVG allows graphical objects to be defined for later reuse.
SVG allows graphical objects to be defined for later reuse. It is recommended that, wherever possible, referenced elements be defined inside of a defs element. Defining these elements inside of a defs element promotes understandability of the SVG content and thus promotes accessibility. Graphical elements defined in a defs will not be directly rendered. You can use a use element to render those elements wherever you want on the viewport.
MDN
-
lazy val
desc: ConcreteHtmlTag[String]
Each container element or graphics element in an SVG drawing can supply a desc description string where the description is text-only.
Each container element or graphics element in an SVG drawing can supply a desc description string where the description is text-only. When the current SVG document fragment is rendered as SVG on visual media, desc elements are not rendered as part of the graphics. Alternate presentations are possible, both visual and aural, which display the desc element but do not display path elements or other graphics elements. The desc element generally improve accessibility of SVG documents
MDN
-
lazy val
ellipse: ConcreteHtmlTag[String]
The ellipse element is an SVG basic shape, used to create ellipses based on a center coordinate, and both their x and y radius.
The ellipse element is an SVG basic shape, used to create ellipses based on a center coordinate, and both their x and y radius.
Ellipses are unable to specify the exact orientation of the ellipse (if, for example, you wanted to draw an ellipse titled at a 45 degree angle), but can be rotated by using the transform attribute.
MDN
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
lazy val
feBlend: ConcreteHtmlTag[String]
The feBlend filter composes two objects together ruled by a certain blending mode.
-
lazy val
feColorMatrix: ConcreteHtmlTag[String]
This filter changes colors based on a transformation matrix.
-
lazy val
feComponentTransfer: ConcreteHtmlTag[String]
The color of each pixel is modified by changing each channel (R, G, B, and A) to the result of what the children feFuncR, feFuncB, feFuncG, and feFuncA return.
-
lazy val
feComposite: ConcreteHtmlTag[String]
This filter primitive performs the combination of two input images pixel-wise in image space using one of the Porter-Duff compositing operations: over, in, atop, out, xor.
This filter primitive performs the combination of two input images pixel-wise in image space using one of the Porter-Duff compositing operations: over, in, atop, out, xor. Additionally, a component-wise arithmetic operation (with the result clamped between [0..1]) can be applied.
MDN
-
lazy val
feConvolveMatrix: ConcreteHtmlTag[String]
the feConvolveMatrix element applies a matrix convolution filter effect.
the feConvolveMatrix element applies a matrix convolution filter effect. A convolution combines pixels in the input image with neighboring pixels to produce a resulting image. A wide variety of imaging operations can be achieved through convolutions, including blurring, edge detection, sharpening, embossing and beveling.
MDN
-
lazy val
feDiffuseLighting: ConcreteHtmlTag[String]
This filter primitive lights an image using the alpha channel as a bump map.
-
lazy val
feDisplacementMap: ConcreteHtmlTag[String]
This filter primitive uses the pixels values from the image from in2 to spatially displace the image from in.
-
lazy val
feDistantLighting: ConcreteHtmlTag[String]
This filter primitive define a distant light source that can be used within a lighting filter primitive: feDiffuseLighting or feSpecularLighting.
-
lazy val
feFlood: ConcreteHtmlTag[String]
The filter fills the filter subregion with the color and opacity defined by flood-color and flood-opacity.
-
lazy val
feFuncA: ConcreteHtmlTag[String]
This filter primitive defines the transfer function for the alpha component of the input graphic of its parent feComponentTransfer element.
-
lazy val
feFuncB: ConcreteHtmlTag[String]
This filter primitive defines the transfer function for the blue component of the input graphic of its parent feComponentTransfer element.
-
lazy val
feFuncG: ConcreteHtmlTag[String]
This filter primitive defines the transfer function for the green component of the input graphic of its parent feComponentTransfer element.
-
lazy val
feFuncR: ConcreteHtmlTag[String]
This filter primitive defines the transfer function for the red component of the input graphic of its parent feComponentTransfer element.
-
lazy val
feGaussianBlur: ConcreteHtmlTag[String]
The filter blurs the input image by the amount specified in stdDeviation, which defines the bell-curve.
-
lazy val
feImage: ConcreteHtmlTag[String]
The feImage filter fetches image data from an external source and provides the pixel data as output (meaning, if the external source is an SVG image, it is rasterize).
-
lazy val
feMerge: ConcreteHtmlTag[String]
The feMerge filter allows filter effects to be applied concurrently instead of sequentially.
-
lazy val
feMergeNode: ConcreteHtmlTag[String]
The feMergeNode takes the result of another filter to be processed by its parent feMerge.
-
lazy val
feMorphology: ConcreteHtmlTag[String]
This filter is used to erode or dilate the input image.
-
lazy val
feOffset: ConcreteHtmlTag[String]
The input image as a whole is offset by the values specified in the dx and dy attributes.
- lazy val fePointLight: ConcreteHtmlTag[String]
-
lazy val
feSpecularLighting: ConcreteHtmlTag[String]
This filter primitive lights a source graphic using the alpha channel as a bump map.
This filter primitive lights a source graphic using the alpha channel as a bump map. The resulting image is an RGBA image based on the light color. The lighting calculation follows the standard specular component of the Phong lighting model. The resulting image depends on the light color, light position and surface geometry of the input bump map. The result of the lighting calculation is added. The filter primitive assumes that the viewer is at infinity in the z direction.
MDN
- lazy val feSpotlight: ConcreteHtmlTag[String]
-
lazy val
feTile: ConcreteHtmlTag[String]
An input image is tiled and the result used to fill a target.
-
lazy val
feTurbulance: ConcreteHtmlTag[String]
This filter primitive creates an image using the Perlin turbulence function.
-
lazy val
filter: ConcreteHtmlTag[String]
The filter element serves as container for atomic filter operations.
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
lazy val
font: ConcreteHtmlTag[String]
The font element defines a font to be used for text layout.
-
lazy val
font-face: ConcreteHtmlTag[String]
The font-face element corresponds to the CSS @font-face declaration.
-
lazy val
font-face-format: ConcreteHtmlTag[String]
The font-face-format element describes the type of font referenced by its parent font-face-uri.
-
lazy val
font-face-name: ConcreteHtmlTag[String]
The font-face-name element points to a locally installed copy of this font, identified by its name.
-
lazy val
font-face-src: ConcreteHtmlTag[String]
The font-face-src element corresponds to the src property in CSS @font-face descriptions.
-
lazy val
font-face-uri: ConcreteHtmlTag[String]
The font-face-uri element points to a remote definition of the current font.
-
lazy val
foreignObject: ConcreteHtmlTag[String]
The foreignObject element allows for inclusion of a foreign XML namespace which has its graphical content drawn by a different user agent.
-
def
frag(frags: generic.Frag[Builder, String]*): generic.Frag[Builder, String]
- Definition Classes
- Util
-
lazy val
g: ConcreteHtmlTag[String]
The g element is a container used to group objects.
The g element is a container used to group objects. Transformations applied to the g element are performed on all of its child elements. Attributes applied are inherited by child elements. In addition, it can be used to define complex objects that can later be referenced with the use element.
MDN
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
lazy val
glyph: ConcreteHtmlTag[String]
A glyph defines a single glyph in an SVG font.
-
lazy val
glyphRef: ConcreteHtmlTag[String]
The glyphRef element provides a single possible glyph to the referencing altGlyph substitution.
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
lazy val
hkern: ConcreteHtmlTag[String]
The horizontal distance between two glyphs can be fine-tweaked with an hkern Element.
-
lazy val
image: ConcreteHtmlTag[String]
The SVG Image Element (image) allows a raster image into be included in an SVG document.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
lazy val
line: ConcreteHtmlTag[String]
The line element is an SVG basic shape, used to create a line connecting two points.
-
lazy val
linearGradient: ConcreteHtmlTag[String]
linearGradient lets authors define linear gradients to fill or stroke graphical elements.
-
lazy val
marker: ConcreteHtmlTag[String]
The marker element defines the graphics that is to be used for drawing arrowheads or polymarkers on a given path, line, polyline or polygon element.
-
lazy val
mask: ConcreteHtmlTag[String]
In SVG, you can specify that any other graphics object or g element can be used as an alpha mask for compositing the current object into the background.
-
lazy val
metadata: ConcreteHtmlTag[String]
Metadata is structured data about data.
-
lazy val
missing-glyph: ConcreteHtmlTag[String]
The missing-glyph's content is rendered, if for a given character the font doesn't define an appropriate glyph.
-
def
modifier(mods: Modifier[Builder]*): Modifier[Builder]
- Definition Classes
- Util
-
lazy val
mpath: ConcreteHtmlTag[String]
the mpath sub-element for the animateMotion element provides the ability to reference an external path element as the definition of a motion path.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
lazy val
path: ConcreteHtmlTag[String]
The path element is the generic element to define a shape.
-
lazy val
pattern: ConcreteHtmlTag[String]
A pattern is used to fill or stroke an object using a pre-defined graphic object which can be replicated ("tiled") at fixed intervals in x and y to cover the areas to be painted.
A pattern is used to fill or stroke an object using a pre-defined graphic object which can be replicated ("tiled") at fixed intervals in x and y to cover the areas to be painted. Patterns are defined using the pattern element and then referenced by properties fill and stroke on a given graphics element to indicate that the given element shall be filled or stroked with the referenced pattern.
MDN
-
lazy val
polygon: ConcreteHtmlTag[String]
The polygon element defines a closed shape consisting of a set of connected straight line segments.
-
lazy val
polyline: ConcreteHtmlTag[String]
The polyline element is an SVG basic shape, used to create a series of straight lines connecting several points.
-
lazy val
radialGradient: ConcreteHtmlTag[String]
radialGradient lets authors define radial gradients to fill or stroke graphical elements.
-
lazy val
rect: ConcreteHtmlTag[String]
The rect element is an SVG basic shape, used to create rectangles based on the position of a corner and their width and height.
-
lazy val
set: ConcreteHtmlTag[String]
The set element provides a simple means of just setting the value of an attribute for a specified duration.
The set element provides a simple means of just setting the value of an attribute for a specified duration. It supports all attribute types, including those that cannot reasonably be interpolated, such as string and boolean values. The set element is non-additive. The additive and accumulate attributes are not allowed, and will be ignored if specified.
MDN
-
lazy val
stop: ConcreteHtmlTag[String]
The ramp of colors to use on a gradient is defined by the stop elements that are child elements to either the lineargradient element or the radialGradient element.
-
lazy val
svg: ConcreteHtmlTag[String]
When it is not the root element, the svg element can be used to nest a standalone SVG fragment inside the current document (which can be an HTML document).
-
lazy val
switch: ConcreteHtmlTag[String]
The switch element evaluates the requiredFeatures, requiredExtensions and systemLanguage attributes on its direct child elements in order, and then processes and renders the first child for which these attributes evaluate to true.
The switch element evaluates the requiredFeatures, requiredExtensions and systemLanguage attributes on its direct child elements in order, and then processes and renders the first child for which these attributes evaluate to true. All others will be bypassed and therefore not rendered. If the child element is a container element such as a g, then the entire subtree is either processed/rendered or bypassed/not rendered.
MDN
-
lazy val
symbol: ConcreteHtmlTag[String]
The symbol element is used to define graphical template objects which can be instantiated by a use element.
The symbol element is used to define graphical template objects which can be instantiated by a use element. The use of symbol elements for graphics that are used multiple times in the same document adds structure and semantics. Documents that are rich in structure may be rendered graphically, as speech, or as braille, and thus promote accessibility. note that a symbol element itself is not rendered. Only instances of a symbol element (i.e., a reference to a symbol by a use element) are rendered.
MDN
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tag(s: String, void: Boolean = false): ConcreteHtmlTag[String]
- Definition Classes
- TagFactory → Util
-
lazy val
text: ConcreteHtmlTag[String]
The text element defines a graphics element consisting of text.
-
lazy val
textPath: ConcreteHtmlTag[String]
In addition to text drawn in a straight line, SVG also includes the ability to place text along the shape of a path element.
In addition to text drawn in a straight line, SVG also includes the ability to place text along the shape of a path element. To specify that a block of text is to be rendered along the shape of a path, include the given text within a textPath element which includes an xlink:href attribute with a reference to a path element.
MDN
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
lazy val
tref: ConcreteHtmlTag[String]
The textual content for a text can be either character data directly embedded within the text element or the character data content of a referenced element, where the referencing is specified with a tref element.
-
lazy val
tspan: ConcreteHtmlTag[String]
Within a text element, text and font properties and the current text position can be adjusted with absolute or relative coordinate values by including a tspan element.
-
lazy val
use: ConcreteHtmlTag[String]
The use element takes nodes from within the SVG document, and duplicates them somewhere else.
The use element takes nodes from within the SVG document, and duplicates them somewhere else. The effect is the same as if the nodes were deeply cloned into a non-exposed DOM, and then pasted where the use element is, much like anonymous content and XBL. Since the cloned nodes are not exposed, care must be taken when using CSS to style a use element and its hidden descendants. CSS attributes are not guaranteed to be inherited by the hidden, cloned DOM unless you explicitly request it using CSS inheritance.
MDN
-
lazy val
view: ConcreteHtmlTag[String]
A view is a defined way to view the image, like a zoom level or a detail view.
-
lazy val
vkern: ConcreteHtmlTag[String]
The vertical distance between two glyphs in top-to-bottom fonts can be fine-tweaked with an vkern Element.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )