Styles2

Type Members

class AutoStyle[V] extends Style[V]

A Style that takes any value of type T as a parameter and has an auto value
A Style that takes any value of type T as a parameter and has an auto value

Definition Classes
StylesMisc
class BorderRadius extends Style[String]

Definition Classes
StylesMisc
class BorderStyle extends (StylesMisc.this)#OutlineStyle

Definition Classes
StylesMisc
class BorderWidth extends Style[String]

Definition Classes
StylesMisc
trait MarginAuto extends Style[String]

Definition Classes
StylesMisc
class MaxLengthStyle extends Style[String]

Definition Classes
StylesMisc
class MinLengthStyle extends (StylesMisc.this)#AutoStyle[String]

Definition Classes
StylesMisc
class MultiImageStyle extends Style[String]

Definition Classes
StylesMisc
class MultiTimeStyle extends Style[String]

Definition Classes
StylesMisc
class NoneOpenStyle[V] extends Style[V]

A Style that takes any value of type T as a parameter and has an none value
A Style that takes any value of type T as a parameter and has an none value

Definition Classes
StylesMisc
class NormalOpenStyle[V] extends Style[V]

A Style that takes any value of type T as a parameter and has an normal value
A Style that takes any value of type T as a parameter and has an normal value

Definition Classes
StylesMisc
class OutlineStyle extends Style[String]

Definition Classes
StylesMisc
class Overflow extends Style[String]

Definition Classes
StylesMisc
class PageBreak extends Style[String]

Definition Classes
StylesMisc

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
lazy val animation: Style[String]

The animation CSS property is a shorthand property for animation-name, animation-duration, animation-timing-function, animation-delay, animation-iteration-count and animation-direction.
The animation CSS property is a shorthand property for animation-name, animation-duration, animation-timing-function, animation-delay, animation-iteration-count and animation-direction.
MDN
lazy val animationDelay: (Styles2.this)#MultiTimeStyle

The animation-delay CSS property specifies when the animation should start.
The animation-delay CSS property specifies when the animation should start. This lets the animation sequence begin some time after it's applied to an element.
A value of 0s, which is the default value of the property, indicates that the animation should begin as soon as it's applied. Otherwise, the value specifies an offset from the moment the animation is applied to the element; animation will begin that amount of time after being applied.
Specifying a negative value for the animation delay causes the animation to begin executing immediately. However, it will appear to have begun executing partway through its cycle. For example, if you specify -1s as the animation delay time, the animation will begin immediately but will start 1 second into the animation sequence.
If you specify a negative value for the animation delay, but the starting value is implicit, the starting value is taken from the moment the animation is applied to the element.
MDN
lazy val animationDirection: Style[String]

The animation-direction CSS property indicates whether the animation should play in reverse on alternate cycles.
The animation-direction CSS property indicates whether the animation should play in reverse on alternate cycles.
MDN
lazy val animationDuration: Style[String]

The animation-duration CSS property specifies the Length of time that an animation should take to complete one cycle.
The animation-duration CSS property specifies the Length of time that an animation should take to complete one cycle.
A value of 0s, which is the default value, indicates that no animation should occur.
MDN
lazy val animationFillMode: Style[String]

The animation-fill-mode CSS property specifies how a CSS animation should apply styles to its target before and after it is executing.
The animation-fill-mode CSS property specifies how a CSS animation should apply styles to its target before and after it is executing.
MDN
lazy val animationIterationCount: Style[Int]

The animation-iteration-count CSS property defines the number of times an animation cycle should be played before stopping.
The animation-iteration-count CSS property defines the number of times an animation cycle should be played before stopping.
MDN
lazy val animationName: Style[String]

The animation-name CSS property specifies a list of animations that should be applied to the selected element.
The animation-name CSS property specifies a list of animations that should be applied to the selected element. Each name indicates a @keyframes at-rule that defines the property values for the animation sequence.
MDN
lazy val animationPlayState: Style[String]

The animation-play-state CSS property determines whether an animation is running or paused.
The animation-play-state CSS property determines whether an animation is running or paused. You can query this property's value to determine whether or not the animation is currently running; in addition, you can set its value to pause and resume playback of an animation.
Resuming a paused animation will start the animation from where it left off at the time it was paused, rather than starting over from the beginning of the animation sequence.
MDN
lazy val animationTimingFunction: Style[String]

The CSS animation-timing-function property specifies how a CSS animation should progress over the duration of each cycle.
The CSS animation-timing-function property specifies how a CSS animation should progress over the duration of each cycle. The possible values are one or several <timing-function>.
For keyframed animations, the timing function applies between keyframes rather than over the entire animation. In other words, the timing function is applied at the start of the keyframe and at the end of the keyframe.
An animation timing function defined within a keyframe block applies to that keyframe; otherwise. If no timing function is specified for the keyframe, the timing function specified for the overall animation is used.
MDN
final def asInstanceOf[T0]: T0

Definition Classes
Any
object backfaceVisibility extends Style[String]

The CSS backface-visibility property determines whether or not the back face of the element is visible when facing the user.
The CSS backface-visibility property determines whether or not the back face of the element is visible when facing the user. The back face of an element always is a transparent background, letting, when visible, a mirror image of the front face be displayed.
MDN
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
lazy val columnCount: (Styles2.this)#AutoStyle[Int]

The column-count CSS property describes the number of columns of the element.
The column-count CSS property describes the number of columns of the element.
MDN
object columnFill extends Style[String]

The column-fill CSS property controls how contents are partitioned into columns.
The column-fill CSS property controls how contents are partitioned into columns. Contents are either balanced, which means that contents in all columns will have the same height or, when using auto, just take up the room the content needs.
MDN
lazy val columnGap: (Styles2.this)#NormalOpenStyle[String]

The column-gap CSS property sets the size of the gap between columns for elements which are specified to display as a multi-column element.
The column-gap CSS property sets the size of the gap between columns for elements which are specified to display as a multi-column element.
MDN
lazy val columnRule: Style[String]

In multi-column layouts, the column-rule CSS property specifies a straight line, or "rule", to be drawn between each column.
In multi-column layouts, the column-rule CSS property specifies a straight line, or "rule", to be drawn between each column. It is a convenient shorthand to avoid setting each of the individual column-rule-* properties separately : column-rule-width, column-rule-style and column-rule-color.
MDN
lazy val columnRuleColor: Style[String]

The column-rule-color CSS property lets you set the color of the rule drawn between columns in multi-column layouts.
The column-rule-color CSS property lets you set the color of the rule drawn between columns in multi-column layouts.
MDN
object columnRuleStyle extends (Styles2.this)#OutlineStyle

The column-rule-style CSS property lets you set the style of the rule drawn between columns in multi-column layouts.
The column-rule-style CSS property lets you set the style of the rule drawn between columns in multi-column layouts.
MDN
object columnRuleWidth extends Style[String]

The column-rule-width CSS property lets you set the width of the rule drawn between columns in multi-column layouts.
The column-rule-width CSS property lets you set the width of the rule drawn between columns in multi-column layouts.
MDN
object columnSpan extends Style[Int]

The column-span CSS property makes it possible for an element to span across all columns when its value is set to all.
The column-span CSS property makes it possible for an element to span across all columns when its value is set to all. An element that spans more than one column is called a spanning element.
MDN
lazy val columnWidth: (Styles2.this)#AutoStyle[Int]

The column-width CSS property suggests an optimal column width.
The column-width CSS property suggests an optimal column width. This is not a absolute value but a mere hint. Browser will adjust the width of the column around that suggested value, allowing to achieve scalable designs that fit different screen size. Especially in presence of the column-count CSS property which has precedence, to set an exact column width, all Length values must be specified. In horizontal text these are width, column-width, column-gap, and column-rule-width
MDN
object columns extends Style[String]

The columns CSS property is a shorthand property allowing to set both the column-width and the column-count properties at the same time.
The columns CSS property is a shorthand property allowing to set both the column-width and the column-count properties at the same time.
MDN
lazy val content: Style[String]

The content CSS property is used with the ::before and ::after pseudo-elements to generate content in an element.
The content CSS property is used with the ::before and ::after pseudo-elements to generate content in an element. Objects inserted using the content property are anonymous replaced elements.
MDN
lazy val counterIncrement: Style[String]

The counter-increment CSS property is used to increase the value of CSS Counters by a given value.
The counter-increment CSS property is used to increase the value of CSS Counters by a given value. The counter's value can be reset using the counter-reset CSS property.
MDN
lazy val counterReset: Style[String]

The counter-reset CSS property is used to reset CSS Counters to a given value.
The counter-reset CSS property is used to reset CSS Counters to a given value.
MDN
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
lazy val orphans: Style[Int]

The orphans CSS property refers to the minimum number of lines in a block container that must be left at the bottom of the page.
The orphans CSS property refers to the minimum number of lines in a block container that must be left at the bottom of the page. This property is normally used to control how page breaks occur.
MDN
lazy val pageBreakAfter: (Styles2.this)#PageBreak

The page-break-after CSS property adjusts page breaks after the current element.
The page-break-after CSS property adjusts page breaks after the current element.
MDN
lazy val pageBreakBefore: (Styles2.this)#PageBreak

The page-break-before CSS property adjusts page breaks before the current element.
The page-break-before CSS property adjusts page breaks before the current element.
This properties applies to block elements that generate a box. It won't apply on an empty div that won't generate a box.
MDN
lazy val pageBreakInside: (Styles2.this)#PageBreak

The page-break-inside CSS property adjusts page breaks inside the current element.
The page-break-inside CSS property adjusts page breaks inside the current element.
MDN
lazy val perspective: (Styles2.this)#NoneOpenStyle[String]

The perspective CSS property determines the distance between the z=0 plane and the user in order to give to the 3D-positioned element some perspective.
The perspective CSS property determines the distance between the z=0 plane and the user in order to give to the 3D-positioned element some perspective. Each 3D element with z>0 becomes larger; each 3D-element with z<0 becomes smaller. The strength of the effect is determined by the value of this property.
MDN
lazy val perspectiveOrigin: Style[String]

The perspective-origin CSS property determines the position the viewer is looking at.
The perspective-origin CSS property determines the position the viewer is looking at. It is used as the vanishing point by the perspective property.
MDN
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
lazy val transform: Style[String]

The CSS transform property lets you modify the coordinate space of the CSS visual formatting model.
The CSS transform property lets you modify the coordinate space of the CSS visual formatting model. Using it, elements can be translated, rotated, scaled, and skewed according to the values set.
If the property has a value different than none, a stacking context will be created. In that case the object will act as a containing block for position: fixed elements that it contains.
MDN
lazy val transformOrigin: Style[String]

The transform-origin CSS property lets you modify the origin for transformations of an element.
The transform-origin CSS property lets you modify the origin for transformations of an element. For example, the transform-origin of the rotate() function is the centre of rotation. (This property is applied by first translating the element by the negated value of the property, then applying the element's transform, then translating by the property value.)
Not explicitely set values are reset to their corresponding values.
MDN
object transformStyle extends Style[String]

The transform-style CSS property determines if the children of the element are positioned in the 3D-space or are flattened in the plane of the element.
The transform-style CSS property determines if the children of the element are positioned in the 3D-space or are flattened in the plane of the element.
MDN
object unicodeBidi extends Style[String]

The unicode-bidi CSS property together with the direction property relates to the handling of bidirectional text in a document.
The unicode-bidi CSS property together with the direction property relates to the handling of bidirectional text in a document. For example, if a block of text contains both left-to-right and right-to-left text then the user-agent uses a complex Unicode algorithm to decide how to display the text. This property overrides this algorithm and allows the developer to control the text embedding.
MDN
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val widows: Style[Int]

The widows CSS property defines how many minimum lines must be left on top of a new page, on a paged media.
The widows CSS property defines how many minimum lines must be left on top of a new page, on a paged media. In typography, a widow is the last line of a paragraph appearing alone at the top of a page. Setting the widows property allows to prevent widows to be left.
On a non-paged media, like screen, the widows CSS property has no effect.
MDN
object wordBreak extends Style[String]

The word-break CSS property specifies whether or not the browser should insert line breaks wherever the text would otherwise overflow its content box.
The word-break CSS property specifies whether or not the browser should insert line breaks wherever the text would otherwise overflow its content box.
MDN

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Doc: package styles

trait Styles2[StyleSetter] extends StylesMisc[StyleSetter]

Type Members

class AutoStyle[V] extends Style[V]

class BorderRadius extends Style[String]

class BorderStyle extends (StylesMisc.this)#OutlineStyle

class BorderWidth extends Style[String]

trait MarginAuto extends Style[String]

class MaxLengthStyle extends Style[String]

class MinLengthStyle extends (StylesMisc.this)#AutoStyle[String]

class MultiImageStyle extends Style[String]

class MultiTimeStyle extends Style[String]

class NoneOpenStyle[V] extends Style[V]

class NormalOpenStyle[V] extends Style[V]

class OutlineStyle extends Style[String]

class Overflow extends Style[String]

class PageBreak extends Style[String]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val animation: Style[String]

lazy val animationDelay: (Styles2.this)#MultiTimeStyle

lazy val animationDirection: Style[String]

lazy val animationDuration: Style[String]

lazy val animationFillMode: Style[String]

lazy val animationIterationCount: Style[Int]

lazy val animationName: Style[String]

lazy val animationPlayState: Style[String]

lazy val animationTimingFunction: Style[String]

final def asInstanceOf[T0]: T0

object backfaceVisibility extends Style[String]

def clone(): AnyRef

lazy val columnCount: (Styles2.this)#AutoStyle[Int]

object columnFill extends Style[String]

lazy val columnGap: (Styles2.this)#NormalOpenStyle[String]

lazy val columnRule: Style[String]

lazy val columnRuleColor: Style[String]

object columnRuleStyle extends (Styles2.this)#OutlineStyle

object columnRuleWidth extends Style[String]

object columnSpan extends Style[Int]

lazy val columnWidth: (Styles2.this)#AutoStyle[Int]

object columns extends Style[String]

lazy val content: Style[String]

lazy val counterIncrement: Style[String]

lazy val counterReset: Style[String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val orphans: Style[Int]

lazy val pageBreakAfter: (Styles2.this)#PageBreak

lazy val pageBreakBefore: (Styles2.this)#PageBreak

lazy val pageBreakInside: (Styles2.this)#PageBreak

lazy val perspective: (Styles2.this)#NoneOpenStyle[String]

lazy val perspectiveOrigin: Style[String]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

lazy val transform: Style[String]

lazy val transformOrigin: Style[String]

object transformStyle extends Style[String]

object unicodeBidi extends Style[String]

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

lazy val widows: Style[Int]

object wordBreak extends Style[String]

Deprecated Value Members

def finalize(): Unit

Inherited from StylesMisc[StyleSetter]

Inherited from AnyRef

Inherited from Any

Ungrouped