package properties

import "kaiju/markup/css/properties"

Variables

PropertyMap

map[string]Property{
    "accent-color":                AccentColor{},
    "align-content":               AlignContent{},
    "align-items":                 AlignItems{},
    "align-self":                  AlignSelf{},
    "all":                         All{},
    "animation":                   Animation{},
    "animation-delay":             AnimationDelay{},
    "animation-direction":         AnimationDirection{},
    "animation-duration":          AnimationDuration{},
    "animation-fill-mode":         AnimationFillMode{},
    "animation-iteration-count":   AnimationIterationCount{},
    "animation-name":              AnimationName{},
    "animation-play-state":        AnimationPlayState{},
    "animation-timing-function":   AnimationTimingFunction{},
    "aspect-ratio":                AspectRatio{},
    "backdrop-filter":             BackdropFilter{},
    "backface-visibility":         BackfaceVisibility{},
    "background":                  Background{},
    "background-attachment":       BackgroundAttachment{},
    "background-blend-mode":       BackgroundBlendMode{},
    "background-clip":             BackgroundClip{},
    "background-color":            BackgroundColor{},
    "background-image":            BackgroundImage{},
    "background-origin":           BackgroundOrigin{},
    "background-position":         BackgroundPosition{},
    "background-position-x":       BackgroundPositionX{},
    "background-position-y":       BackgroundPositionY{},
    "background-repeat":           BackgroundRepeat{},
    "background-size":             BackgroundSize{},
    "block-size":                  BlockSize{},
    "border":                      Border{},
    "border-block":                BorderBlock{},
    "border-block-color":          BorderBlockColor{},
    "border-block-end-color":      BorderBlockEndColor{},
    "border-block-end-style":      BorderBlockEndStyle{},
    "border-block-end-width":      BorderBlockEndWidth{},
    "border-block-start-color":    BorderBlockStartColor{},
    "border-block-start-style":    BorderBlockStartStyle{},
    "border-block-start-width":    BorderBlockStartWidth{},
    "border-block-style":          BorderBlockStyle{},
    "border-block-width":          BorderBlockWidth{},
    "border-bottom":               BorderBottom{},
    "border-bottom-color":         BorderBottomColor{},
    "border-bottom-left-radius":   BorderBottomLeftRadius{},
    "border-bottom-right-radius":  BorderBottomRightRadius{},
    "border-bottom-style":         BorderBottomStyle{},
    "border-bottom-width":         BorderBottomWidth{},
    "border-collapse":             BorderCollapse{},
    "border-color":                BorderColor{},
    "border-image":                BorderImage{},
    "border-image-outset":         BorderImageOutset{},
    "border-image-repeat":         BorderImageRepeat{},
    "border-image-slice":          BorderImageSlice{},
    "border-image-source":         BorderImageSource{},
    "border-image-width":          BorderImageWidth{},
    "border-inline":               BorderInline{},
    "border-inline-color":         BorderInlineColor{},
    "border-inline-end-color":     BorderInlineEndColor{},
    "border-inline-end-style":     BorderInlineEndStyle{},
    "border-inline-end-width":     BorderInlineEndWidth{},
    "border-inline-start-color":   BorderInlineStartColor{},
    "border-inline-start-style":   BorderInlineStartStyle{},
    "border-inline-start-width":   BorderInlineStartWidth{},
    "border-inline-style":         BorderInlineStyle{},
    "border-inline-width":         BorderInlineWidth{},
    "border-left":                 BorderLeft{},
    "border-left-color":           BorderLeftColor{},
    "border-left-style":           BorderLeftStyle{},
    "border-left-width":           BorderLeftWidth{},
    "border-radius":               BorderRadius{},
    "border-right":                BorderRight{},
    "border-right-color":          BorderRightColor{},
    "border-right-style":          BorderRightStyle{},
    "border-right-width":          BorderRightWidth{},
    "border-spacing":              BorderSpacing{},
    "border-style":                BorderStyle{},
    "border-top":                  BorderTop{},
    "border-top-color":            BorderTopColor{},
    "border-top-left-radius":      BorderTopLeftRadius{},
    "border-top-right-radius":     BorderTopRightRadius{},
    "border-top-style":            BorderTopStyle{},
    "border-top-width":            BorderTopWidth{},
    "border-width":                BorderWidth{},
    "bottom":                      Bottom{},
    "box-decoration-break":        BoxDecorationBreak{},
    "box-reflect":                 BoxReflect{},
    "box-shadow":                  BoxShadow{},
    "box-sizing":                  BoxSizing{},
    "break-after":                 BreakAfter{},
    "break-before":                BreakBefore{},
    "break-inside":                BreakInside{},
    "caption-side":                CaptionSide{},
    "caret-color":                 CaretColor{},
    "charset":                     Charset{},
    "clear":                       Clear{},
    "clip":                        Clip{},
    "color":                       Color{},
    "column-count":                ColumnCount{},
    "column-fill":                 ColumnFill{},
    "column-gap":                  ColumnGap{},
    "column-rule":                 ColumnRule{},
    "column-rule-color":           ColumnRuleColor{},
    "column-rule-style":           ColumnRuleStyle{},
    "column-rule-width":           ColumnRuleWidth{},
    "column-span":                 ColumnSpan{},
    "column-width":                ColumnWidth{},
    "columns":                     Columns{},
    "content":                     Content{},
    "counter-increment":           CounterIncrement{},
    "counter-reset":               CounterReset{},
    "cursor":                      Cursor{},
    "direction":                   Direction{},
    "display":                     Display{},
    "empty-cells":                 EmptyCells{},
    "filter":                      Filter{},
    "flex":                        Flex{},
    "flex-basis":                  FlexBasis{},
    "flex-direction":              FlexDirection{},
    "flex-flow":                   FlexFlow{},
    "flex-grow":                   FlexGrow{},
    "flex-shrink":                 FlexShrink{},
    "flex-wrap":                   FlexWrap{},
    "float":                       Float{},
    "font":                        Font{},
    "font-face":                   FontFace{},
    "font-family":                 FontFamily{},
    "font-feature-settings":       FontFeatureSettings{},
    "font-feature-values":         FontFeatureValues{},
    "font-kerning":                FontKerning{},
    "font-language-override":      FontLanguageOverride{},
    "font-size":                   FontSize{},
    "font-size-adjust":            FontSizeAdjust{},
    "font-stretch":                FontStretch{},
    "font-style":                  FontStyle{},
    "font-synthesis":              FontSynthesis{},
    "font-variant":                FontVariant{},
    "font-variant-alternates":     FontVariantAlternates{},
    "font-variant-caps":           FontVariantCaps{},
    "font-variant-east-asian":     FontVariantEastAsian{},
    "font-variant-ligatures":      FontVariantLigatures{},
    "font-variant-numeric":        FontVariantNumeric{},
    "font-variant-position":       FontVariantPosition{},
    "font-weight":                 FontWeight{},
    "gap":                         Gap{},
    "grid":                        Grid{},
    "grid-area":                   GridArea{},
    "grid-auto-columns":           GridAutoColumns{},
    "grid-auto-flow":              GridAutoFlow{},
    "grid-auto-rows":              GridAutoRows{},
    "grid-column":                 GridColumn{},
    "grid-column-end":             GridColumnEnd{},
    "grid-column-gap":             GridColumnGap{},
    "grid-column-start":           GridColumnStart{},
    "grid-gap":                    GridGap{},
    "grid-row":                    GridRow{},
    "grid-row-end":                GridRowEnd{},
    "grid-row-gap":                GridRowGap{},
    "grid-row-start":              GridRowStart{},
    "grid-template":               GridTemplate{},
    "grid-template-areas":         GridTemplateAreas{},
    "grid-template-columns":       GridTemplateColumns{},
    "grid-template-rows":          GridTemplateRows{},
    "hanging-punctuation":         HangingPunctuation{},
    "height":                      Height{},
    "hyphens":                     Hyphens{},
    "image-rendering":             ImageRendering{},
    "import":                      Import{},
    "inline-size":                 InlineSize{},
    "inset":                       Inset{},
    "inset-block":                 InsetBlock{},
    "inset-block-end":             InsetBlockEnd{},
    "inset-block-start":           InsetBlockStart{},
    "inset-inline":                InsetInline{},
    "inset-inline-end":            InsetInlineEnd{},
    "inset-inline-start":          InsetInlineStart{},
    "isolation":                   Isolation{},
    "justify-content":             JustifyContent{},
    "justify-items":               JustifyItems{},
    "justify-self":                JustifySelf{},
    "keyframes":                   Keyframes{},
    "left":                        Left{},
    "letter-spacing":              LetterSpacing{},
    "line-break":                  LineBreak{},
    "line-height":                 LineHeight{},
    "list-style":                  ListStyle{},
    "list-style-image":            ListStyleImage{},
    "list-style-position":         ListStylePosition{},
    "list-style-type":             ListStyleType{},
    "margin":                      Margin{},
    "margin-block":                MarginBlock{},
    "margin-block-end":            MarginBlockEnd{},
    "margin-block-start":          MarginBlockStart{},
    "margin-bottom":               MarginBottom{},
    "margin-inline":               MarginInline{},
    "margin-inline-end":           MarginInlineEnd{},
    "margin-inline-start":         MarginInlineStart{},
    "margin-left":                 MarginLeft{},
    "margin-right":                MarginRight{},
    "margin-top":                  MarginTop{},
    "mask":                        Mask{},
    "mask-clip":                   MaskClip{},
    "mask-composite":              MaskComposite{},
    "mask-image":                  MaskImage{},
    "mask-mode":                   MaskMode{},
    "mask-origin":                 MaskOrigin{},
    "mask-position":               MaskPosition{},
    "mask-repeat":                 MaskRepeat{},
    "mask-size":                   MaskSize{},
    "mask-type":                   MaskType{},
    "max-height":                  MaxHeight{},
    "max-width":                   MaxWidth{},
    "media":                       Media{},
    "max-block-size":              MaxBlockSize{},
    "max-inline-size":             MaxInlineSize{},
    "min-block-size":              MinBlockSize{},
    "min-inline-size":             MinInlineSize{},
    "min-height":                  MinHeight{},
    "min-width":                   MinWidth{},
    "mix-blend-mode":              MixBlendMode{},
    "object-fit":                  ObjectFit{},
    "object-position":             ObjectPosition{},
    "offset":                      Offset{},
    "offset-anchor":               OffsetAnchor{},
    "offset-distance":             OffsetDistance{},
    "offset-path":                 OffsetPath{},
    "offset-rotate":               OffsetRotate{},
    "opacity":                     Opacity{},
    "order":                       Order{},
    "orphans":                     Orphans{},
    "outline":                     Outline{},
    "outline-color":               OutlineColor{},
    "outline-offset":              OutlineOffset{},
    "outline-style":               OutlineStyle{},
    "outline-width":               OutlineWidth{},
    "overflow":                    Overflow{},
    "overflow-anchor":             OverflowAnchor{},
    "overflow-wrap":               OverflowWrap{},
    "overflow-x":                  OverflowX{},
    "overflow-y":                  OverflowY{},
    "overscroll-behavior":         OverscrollBehavior{},
    "overscroll-behavior-block":   OverscrollBehaviorBlock{},
    "overscroll-behavior-inline":  OverscrollBehaviorInline{},
    "overscroll-behavior-x":       OverscrollBehaviorX{},
    "overscroll-behavior-y":       OverscrollBehaviorY{},
    "padding":                     Padding{},
    "padding-block":               PaddingBlock{},
    "padding-block-end":           PaddingBlockEnd{},
    "padding-block-start":         PaddingBlockStart{},
    "padding-bottom":              PaddingBottom{},
    "padding-inline":              PaddingInline{},
    "padding-inline-end":          PaddingInlineEnd{},
    "padding-inline-start":        PaddingInlineStart{},
    "padding-left":                PaddingLeft{},
    "padding-right":               PaddingRight{},
    "padding-top":                 PaddingTop{},
    "page-break-after":            PageBreakAfter{},
    "page-break-before":           PageBreakBefore{},
    "page-break-inside":           PageBreakInside{},
    "paint-order":                 PaintOrder{},
    "perspective":                 Perspective{},
    "perspective-origin":          PerspectiveOrigin{},
    "place-content":               PlaceContent{},
    "place-items":                 PlaceItems{},
    "place-self":                  PlaceSelf{},
    "pointer-events":              PointerEvents{},
    "position":                    Position{},
    "quotes":                      Quotes{},
    "resize":                      Resize{},
    "right":                       Right{},
    "rotate":                      Rotate{},
    "row-gap":                     RowGap{},
    "scale":                       Scale{},
    "scroll-behavior":             ScrollBehavior{},
    "scroll-margin":               ScrollMargin{},
    "scroll-margin-block":         ScrollMarginBlock{},
    "scroll-margin-block-end":     ScrollMarginBlockEnd{},
    "scroll-margin-block-start":   ScrollMarginBlockStart{},
    "scroll-margin-bottom":        ScrollMarginBottom{},
    "scroll-margin-inline":        ScrollMarginInline{},
    "scroll-margin-inline-end":    ScrollMarginInlineEnd{},
    "scroll-margin-inline-start":  ScrollMarginInlineStart{},
    "scroll-margin-left":          ScrollMarginLeft{},
    "scroll-margin-right":         ScrollMarginRight{},
    "scroll-margin-top":           ScrollMarginTop{},
    "scroll-padding":              ScrollPadding{},
    "scroll-padding-block":        ScrollPaddingBlock{},
    "scroll-padding-block-end":    ScrollPaddingBlockEnd{},
    "scroll-padding-block-start":  ScrollPaddingBlockStart{},
    "scroll-padding-bottom":       ScrollPaddingBottom{},
    "scroll-padding-inline":       ScrollPaddingInline{},
    "scroll-padding-inline-end":   ScrollPaddingInlineEnd{},
    "scroll-padding-inline-start": ScrollPaddingInlineStart{},
    "scroll-padding-left":         ScrollPaddingLeft{},
    "scroll-padding-right":        ScrollPaddingRight{},
    "scroll-padding-top":          ScrollPaddingTop{},
    "scroll-snap-align":           ScrollSnapAlign{},
    "scroll-snap-stop":            ScrollSnapStop{},
    "scroll-snap-type":            ScrollSnapType{},
    "scrollbar-color":             ScrollbarColor{},
    "tab-size":                    TabSize{},
    "table-layout":                TableLayout{},
    "text-align":                  TextAlign{},
    "text-align-last":             TextAlignLast{},
    "text-combine-upright":        TextCombineUpright{},
    "text-decoration":             TextDecoration{},
    "text-decoration-color":       TextDecorationColor{},
    "text-decoration-line":        TextDecorationLine{},
    "text-decoration-style":       TextDecorationStyle{},
    "text-decoration-thickness":   TextDecorationThickness{},
    "text-emphasis":               TextEmphasis{},
    "text-indent":                 TextIndent{},
    "text-justify":                TextJustify{},
    "text-orientation":            TextOrientation{},
    "text-overflow":               TextOverflow{},
    "text-shadow":                 TextShadow{},
    "text-transform":              TextTransform{},
    "text-underline-position":     TextUnderlinePosition{},
    "top":                         Top{},
    "transform":                   Transform{},
    "transform-origin":            TransformOrigin{},
    "transform-style":             TransformStyle{},
    "transition":                  Transition{},
    "transition-delay":            TransitionDelay{},
    "transition-duration":         TransitionDuration{},
    "transition-property":         TransitionProperty{},
    "transition-timing-function":  TransitionTimingFunction{},
    "translate":                   Translate{},
    "unicode-bidi":                UnicodeBidi{},
    "user-select":                 UserSelect{},
    "vertical-align":              VerticalAlign{},
    "visibility":                  Visibility{},
    "white-space":                 WhiteSpace{},
    "widows":                      Widows{},
    "width":                       Width{},
    "word-break":                  WordBreak{},
    "word-spacing":                WordSpacing{},
    "word-wrap":                   WordWrap{},
    "writing-mode":                WritingMode{},
    "z-index":                     ZIndex{},
}

Types

AccentColor

struct

type AccentColor struct{}

Specifies an accent color for user-interface controls

AccentColor.Key

func (p AccentColor) Key() string

AccentColor.Process

func (p AccentColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AlignContent

struct

type AlignContent struct{}

Specifies the alignment between the lines inside a flexible container when the items do not use all available space

AlignContent.Key

func (p AlignContent) Key() string

AlignContent.Process

func (p AlignContent) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AlignItems

struct

type AlignItems struct{}

Specifies the alignment for items inside a flexible container

AlignItems.Key

func (p AlignItems) Key() string

AlignItems.Process

func (p AlignItems) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AlignSelf

struct

type AlignSelf struct{}

Specifies the alignment for selected items inside a flexible container

AlignSelf.Key

func (p AlignSelf) Key() string

AlignSelf.Process

func (p AlignSelf) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

All

struct

type All struct{}

Resets all properties (except unicode-bidi and direction)

All.Key

func (p All) Key() string

All.Process

func (p All) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Animation

struct

type Animation struct{}

A shorthand property for all the animation-* properties

Animation.Key

func (p Animation) Key() string

Animation.Process

func (p Animation) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationDelay

struct

type AnimationDelay struct{}

Specifies a delay for the start of an animation

AnimationDelay.Key

func (p AnimationDelay) Key() string

AnimationDelay.Process

func (p AnimationDelay) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationDirection

struct

type AnimationDirection struct{}

Specifies whether an animation should be played forwards, backwards or in alternate cycles

AnimationDirection.Key

func (p AnimationDirection) Key() string

AnimationDirection.Process

func (p AnimationDirection) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationDuration

struct

type AnimationDuration struct{}

Specifies how long an animation should take to complete one cycle

AnimationDuration.Key

func (p AnimationDuration) Key() string

AnimationDuration.Process

func (p AnimationDuration) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationFillMode

struct

type AnimationFillMode struct{}

Specifies a style for the element when the animation is not playing (before it starts, after it ends, or both)

AnimationFillMode.Key

func (p AnimationFillMode) Key() string

AnimationFillMode.Process

func (p AnimationFillMode) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationIterationCount

struct

type AnimationIterationCount struct{}

Specifies the number of times an animation should be played

AnimationIterationCount.Key

func (p AnimationIterationCount) Key() string

AnimationIterationCount.Process

func (p AnimationIterationCount) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationName

struct

type AnimationName struct{}

Specifies a name for the @keyframes animation

AnimationName.Key

func (p AnimationName) Key() string

AnimationName.Process

func (p AnimationName) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationPlayState

struct

type AnimationPlayState struct{}

Specifies whether the animation is running or paused

AnimationPlayState.Key

func (p AnimationPlayState) Key() string

AnimationPlayState.Process

func (p AnimationPlayState) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AnimationTimingFunction

struct

type AnimationTimingFunction struct{}

Specifies the speed curve of an animation

AnimationTimingFunction.Key

func (p AnimationTimingFunction) Key() string

AnimationTimingFunction.Process

func (p AnimationTimingFunction) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

AspectRatio

struct

type AspectRatio struct{}

Specifies preferred aspect ratio of an element

AspectRatio.Key

func (p AspectRatio) Key() string

AspectRatio.Process

func (p AspectRatio) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackdropFilter

struct

type BackdropFilter struct{}

Defines a graphical effect to the area behind an element

BackdropFilter.Key

func (p BackdropFilter) Key() string

BackdropFilter.Process

func (p BackdropFilter) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackfaceVisibility

struct

type BackfaceVisibility struct{}

Defines whether or not the back face of an element should be visible when facing the user

BackfaceVisibility.Key

func (p BackfaceVisibility) Key() string

BackfaceVisibility.Process

func (p BackfaceVisibility) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Background

struct

type Background struct{}

A shorthand property for all the background-* properties

Background.Key

func (p Background) Key() string

Background.Process

func (p Background) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundAttachment

struct

type BackgroundAttachment struct{}

Sets whether a background image scrolls with the rest of the page, or is fixed

BackgroundAttachment.Key

func (p BackgroundAttachment) Key() string

BackgroundAttachment.Process

func (p BackgroundAttachment) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundBlendMode

struct

type BackgroundBlendMode struct{}

Specifies the blending mode of each background layer (color/image)

BackgroundBlendMode.Key

func (p BackgroundBlendMode) Key() string

BackgroundBlendMode.Process

func (p BackgroundBlendMode) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundClip

struct

type BackgroundClip struct{}

Defines how far the background (color or image) should extend within an element

BackgroundClip.Key

func (p BackgroundClip) Key() string

BackgroundClip.Process

func (p BackgroundClip) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundColor

struct

type BackgroundColor struct{}

Specifies the background color of an element

BackgroundColor.Key

func (p BackgroundColor) Key() string

BackgroundColor.Process

func (p BackgroundColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundImage

struct

type BackgroundImage struct{}

Specifies one or more background images for an element

BackgroundImage.Key

func (p BackgroundImage) Key() string

BackgroundImage.Process

func (p BackgroundImage) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundOrigin

struct

type BackgroundOrigin struct{}

Specifies the origin position of a background image

BackgroundOrigin.Key

func (p BackgroundOrigin) Key() string

BackgroundOrigin.Process

func (p BackgroundOrigin) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundPosition

struct

type BackgroundPosition struct{}

Specifies the position of a background image

BackgroundPosition.Key

func (p BackgroundPosition) Key() string

BackgroundPosition.Process

func (p BackgroundPosition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundPositionX

struct

type BackgroundPositionX struct{}

Specifies the position of a background image on x-axis

BackgroundPositionX.Key

func (p BackgroundPositionX) Key() string

BackgroundPositionX.Process

func (p BackgroundPositionX) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundPositionY

struct

type BackgroundPositionY struct{}

Specifies the position of a background image on y-axis

BackgroundPositionY.Key

func (p BackgroundPositionY) Key() string

BackgroundPositionY.Process

func (p BackgroundPositionY) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundRepeat

struct

type BackgroundRepeat struct{}

Sets if/how a background image will be repeated

BackgroundRepeat.Key

func (p BackgroundRepeat) Key() string

BackgroundRepeat.Process

func (p BackgroundRepeat) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BackgroundSize

struct

type BackgroundSize struct{}

Specifies the size of the background images

BackgroundSize.Key

func (p BackgroundSize) Key() string

BackgroundSize.Process

func (p BackgroundSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BlockSize

struct

type BlockSize struct{}

Specifies the size of an element in block direction

BlockSize.Key

func (p BlockSize) Key() string

BlockSize.Process

func (p BlockSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Border

struct

type Border struct{}

A shorthand property for border-width, border-style and border-color

Border.Key

func (p Border) Key() string

Border.Process

func (p Border) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

border-width border-style border-color|initial|inherit

BorderBlock

struct

type BorderBlock struct{}

A shorthand property for border-block-width, border-block-style and border-block-color

BorderBlock.Key

func (p BorderBlock) Key() string

BorderBlock.Process

func (p BorderBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockColor

struct

type BorderBlockColor struct{}

Sets the color of the borders at start and end in the block direction

BorderBlockColor.Key

func (p BorderBlockColor) Key() string

BorderBlockColor.Process

func (p BorderBlockColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockEndColor

struct

type BorderBlockEndColor struct{}

Sets the color of the border at the end in the block direction

BorderBlockEndColor.Key

func (p BorderBlockEndColor) Key() string

BorderBlockEndColor.Process

func (p BorderBlockEndColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockEndStyle

struct

type BorderBlockEndStyle struct{}

Sets the style of the border at the end in the block direction

BorderBlockEndStyle.Key

func (p BorderBlockEndStyle) Key() string

BorderBlockEndStyle.Process

func (p BorderBlockEndStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockEndWidth

struct

type BorderBlockEndWidth struct{}

Sets the width of the border at the end in the block direction

BorderBlockEndWidth.Key

func (p BorderBlockEndWidth) Key() string

BorderBlockEndWidth.Process

func (p BorderBlockEndWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockStartColor

struct

type BorderBlockStartColor struct{}

Sets the color of the border at the start in the block direction

BorderBlockStartColor.Key

func (p BorderBlockStartColor) Key() string

BorderBlockStartColor.Process

func (p BorderBlockStartColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockStartStyle

struct

type BorderBlockStartStyle struct{}

Sets the style of the border at the start in the block direction

BorderBlockStartStyle.Key

func (p BorderBlockStartStyle) Key() string

BorderBlockStartStyle.Process

func (p BorderBlockStartStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockStartWidth

struct

type BorderBlockStartWidth struct{}

Sets the width of the border at the start in the block direction

BorderBlockStartWidth.Key

func (p BorderBlockStartWidth) Key() string

BorderBlockStartWidth.Process

func (p BorderBlockStartWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockStyle

struct

type BorderBlockStyle struct{}

Sets the style of the borders at start and end in the block direction

BorderBlockStyle.Key

func (p BorderBlockStyle) Key() string

BorderBlockStyle.Process

func (p BorderBlockStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBlockWidth

struct

type BorderBlockWidth struct{}

Sets the width of the borders at start and end in the block direction

BorderBlockWidth.Key

func (p BorderBlockWidth) Key() string

BorderBlockWidth.Process

func (p BorderBlockWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBottom

struct

type BorderBottom struct{}

A shorthand property for border-bottom-width, border-bottom-style and border-bottom-color

BorderBottom.Key

func (p BorderBottom) Key() string

BorderBottom.Process

func (p BorderBottom) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

border-width border-style border-color|initial|inherit

BorderBottomColor

struct

type BorderBottomColor struct{}

Sets the color of the bottom border

BorderBottomColor.Key

func (p BorderBottomColor) Key() string

BorderBottomColor.Process

func (p BorderBottomColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

color|transparent|initial|inherit

BorderBottomLeftRadius

struct

type BorderBottomLeftRadius struct{}

Defines the radius of the border of the bottom-left corner

BorderBottomLeftRadius.Key

func (p BorderBottomLeftRadius) Key() string

BorderBottomLeftRadius.Process

func (p BorderBottomLeftRadius) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBottomRightRadius

struct

type BorderBottomRightRadius struct{}

Defines the radius of the border of the bottom-right corner

BorderBottomRightRadius.Key

func (p BorderBottomRightRadius) Key() string

BorderBottomRightRadius.Process

func (p BorderBottomRightRadius) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBottomStyle

struct

type BorderBottomStyle struct{}

Sets the style of the bottom border

BorderBottomStyle.Key

func (p BorderBottomStyle) Key() string

BorderBottomStyle.Process

func (p BorderBottomStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderBottomWidth

struct

type BorderBottomWidth struct{}

Sets the width of the bottom border

BorderBottomWidth.Key

func (p BorderBottomWidth) Key() string

BorderBottomWidth.Process

func (p BorderBottomWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderCollapse

struct

type BorderCollapse struct{}

Sets whether table borders should collapse into a single border or be separated

BorderCollapse.Key

func (p BorderCollapse) Key() string

BorderCollapse.Process

func (p BorderCollapse) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderColor

struct

type BorderColor struct{}

Sets the color of the four borders

BorderColor.Key

func (p BorderColor) Key() string

BorderColor.Process

func (p BorderColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderImage

struct

type BorderImage struct{}

A shorthand property for all the border-image-* properties

BorderImage.Key

func (p BorderImage) Key() string

BorderImage.Process

func (p BorderImage) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderImageOutset

struct

type BorderImageOutset struct{}

Specifies the amount by which the border image area extends beyond the border box

BorderImageOutset.Key

func (p BorderImageOutset) Key() string

BorderImageOutset.Process

func (p BorderImageOutset) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderImageRepeat

struct

type BorderImageRepeat struct{}

Specifies whether the border image should be repeated, rounded or stretched

BorderImageRepeat.Key

func (p BorderImageRepeat) Key() string

BorderImageRepeat.Process

func (p BorderImageRepeat) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderImageSlice

struct

type BorderImageSlice struct{}

Specifies how to slice the border image

BorderImageSlice.Key

func (p BorderImageSlice) Key() string

BorderImageSlice.Process

func (p BorderImageSlice) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderImageSource

struct

type BorderImageSource struct{}

Specifies the path to the image to be used as a border

BorderImageSource.Key

func (p BorderImageSource) Key() string

BorderImageSource.Process

func (p BorderImageSource) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderImageWidth

struct

type BorderImageWidth struct{}

Specifies the width of the border image

BorderImageWidth.Key

func (p BorderImageWidth) Key() string

BorderImageWidth.Process

func (p BorderImageWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInline

struct

type BorderInline struct{}

A shorthand property for border-inline-width, border-inline-style and border-inline-color

BorderInline.Key

func (p BorderInline) Key() string

BorderInline.Process

func (p BorderInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineColor

struct

type BorderInlineColor struct{}

Sets the color of the borders at start and end in the inline direction

BorderInlineColor.Key

func (p BorderInlineColor) Key() string

BorderInlineColor.Process

func (p BorderInlineColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineEndColor

struct

type BorderInlineEndColor struct{}

Sets the color of the border at the end in the inline direction

BorderInlineEndColor.Key

func (p BorderInlineEndColor) Key() string

BorderInlineEndColor.Process

func (p BorderInlineEndColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineEndStyle

struct

type BorderInlineEndStyle struct{}

Sets the style of the border at the end in the inline direction

BorderInlineEndStyle.Key

func (p BorderInlineEndStyle) Key() string

BorderInlineEndStyle.Process

func (p BorderInlineEndStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineEndWidth

struct

type BorderInlineEndWidth struct{}

Sets the width of the border at the end in the inline direction

BorderInlineEndWidth.Key

func (p BorderInlineEndWidth) Key() string

BorderInlineEndWidth.Process

func (p BorderInlineEndWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineStartColor

struct

type BorderInlineStartColor struct{}

Sets the color of the border at the start in the inline direction

BorderInlineStartColor.Key

func (p BorderInlineStartColor) Key() string

BorderInlineStartColor.Process

func (p BorderInlineStartColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineStartStyle

struct

type BorderInlineStartStyle struct{}

Sets the style of the border at the start in the inline direction

BorderInlineStartStyle.Key

func (p BorderInlineStartStyle) Key() string

BorderInlineStartStyle.Process

func (p BorderInlineStartStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineStartWidth

struct

type BorderInlineStartWidth struct{}

Sets the width of the border at the start in the inline direction

BorderInlineStartWidth.Key

func (p BorderInlineStartWidth) Key() string

BorderInlineStartWidth.Process

func (p BorderInlineStartWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineStyle

struct

type BorderInlineStyle struct{}

Sets the style of the borders at start and end in the inline direction

BorderInlineStyle.Key

func (p BorderInlineStyle) Key() string

BorderInlineStyle.Process

func (p BorderInlineStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderInlineWidth

struct

type BorderInlineWidth struct{}

Sets the width of the borders at start and end in the inline direction

BorderInlineWidth.Key

func (p BorderInlineWidth) Key() string

BorderInlineWidth.Process

func (p BorderInlineWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderLeft

struct

type BorderLeft struct{}

A shorthand property for all the border-left-* properties

BorderLeft.Key

func (p BorderLeft) Key() string

BorderLeft.Process

func (p BorderLeft) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

border-width border-style border-color|initial|inherit

BorderLeftColor

struct

type BorderLeftColor struct{}

Sets the color of the left border

BorderLeftColor.Key

func (p BorderLeftColor) Key() string

BorderLeftColor.Process

func (p BorderLeftColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

color|transparent|initial|inherit

BorderLeftStyle

struct

type BorderLeftStyle struct{}

Sets the style of the left border

BorderLeftStyle.Key

func (p BorderLeftStyle) Key() string

BorderLeftStyle.Process

func (p BorderLeftStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderLeftWidth

struct

type BorderLeftWidth struct{}

Sets the width of the left border

BorderLeftWidth.Key

func (p BorderLeftWidth) Key() string

BorderLeftWidth.Process

func (p BorderLeftWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderRadius

struct

type BorderRadius struct{}

A shorthand property for the four border-*-radius properties

BorderRadius.Key

func (p BorderRadius) Key() string

BorderRadius.Process

func (p BorderRadius) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderRight

struct

type BorderRight struct{}

A shorthand property for all the border-right-* properties

BorderRight.Key

func (p BorderRight) Key() string

BorderRight.Process

func (p BorderRight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

border-width border-style border-color|initial|inherit

BorderRightColor

struct

type BorderRightColor struct{}

Sets the color of the right border

BorderRightColor.Key

func (p BorderRightColor) Key() string

BorderRightColor.Process

func (p BorderRightColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

color|transparent|initial|inherit

BorderRightStyle

struct

type BorderRightStyle struct{}

Sets the style of the right border

BorderRightStyle.Key

func (p BorderRightStyle) Key() string

BorderRightStyle.Process

func (p BorderRightStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderRightWidth

struct

type BorderRightWidth struct{}

Sets the width of the right border

BorderRightWidth.Key

func (p BorderRightWidth) Key() string

BorderRightWidth.Process

func (p BorderRightWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderSpacing

struct

type BorderSpacing struct{}

Sets the distance between the borders of adjacent cells

BorderSpacing.Key

func (p BorderSpacing) Key() string

BorderSpacing.Process

func (p BorderSpacing) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderStyle

struct

type BorderStyle struct{}

Sets the style of the four borders

BorderStyle.Key

func (p BorderStyle) Key() string

BorderStyle.Process

func (p BorderStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderTop

struct

type BorderTop struct{}

A shorthand property for border-top-width, border-top-style and border-top-color

BorderTop.Key

func (p BorderTop) Key() string

BorderTop.Process

func (p BorderTop) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

border-width border-style border-color|initial|inherit

BorderTopColor

struct

type BorderTopColor struct{}

Sets the color of the top border

BorderTopColor.Key

func (p BorderTopColor) Key() string

BorderTopColor.Process

func (p BorderTopColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

color|transparent|initial|inherit

BorderTopLeftRadius

struct

type BorderTopLeftRadius struct{}

Defines the radius of the border of the top-left corner

BorderTopLeftRadius.Key

func (p BorderTopLeftRadius) Key() string

BorderTopLeftRadius.Process

func (p BorderTopLeftRadius) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderTopRightRadius

struct

type BorderTopRightRadius struct{}

Defines the radius of the border of the top-right corner

BorderTopRightRadius.Key

func (p BorderTopRightRadius) Key() string

BorderTopRightRadius.Process

func (p BorderTopRightRadius) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderTopStyle

struct

type BorderTopStyle struct{}

Sets the style of the top border

BorderTopStyle.Key

func (p BorderTopStyle) Key() string

BorderTopStyle.Process

func (p BorderTopStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderTopWidth

struct

type BorderTopWidth struct{}

Sets the width of the top border

BorderTopWidth.Key

func (p BorderTopWidth) Key() string

BorderTopWidth.Process

func (p BorderTopWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BorderWidth

struct

type BorderWidth struct{}

Sets the width of the four borders

BorderWidth.Key

func (p BorderWidth) Key() string

BorderWidth.Process

func (p BorderWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Bottom

struct

type Bottom struct{}

Sets the elements position, from the bottom of its parent element

Bottom.Key

func (p Bottom) Key() string

Bottom.Process

func (p Bottom) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

auto|length|initial|inherit

BoxDecorationBreak

struct

type BoxDecorationBreak struct{}

Sets the behavior of the background and border of an element at page-break, or, for in-line elements, at line-break.

BoxDecorationBreak.Key

func (p BoxDecorationBreak) Key() string

BoxDecorationBreak.Process

func (p BoxDecorationBreak) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BoxReflect

struct

type BoxReflect struct{}

The box-reflect property is used to create a reflection of an element.

BoxReflect.Key

func (p BoxReflect) Key() string

BoxReflect.Process

func (p BoxReflect) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BoxShadow

struct

type BoxShadow struct{}

Attaches one or more shadows to an element

BoxShadow.Key

func (p BoxShadow) Key() string

BoxShadow.Process

func (p BoxShadow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BoxSizing

struct

type BoxSizing struct{}

Defines how the width and height of an element are calculated: should they include padding and borders, or not

BoxSizing.Key

func (p BoxSizing) Key() string

BoxSizing.Process

func (p BoxSizing) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BreakAfter

struct

type BreakAfter struct{}

Specifies whether or not a page-, column-, or region-break should occur after the specified element

BreakAfter.Key

func (p BreakAfter) Key() string

BreakAfter.Process

func (p BreakAfter) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BreakBefore

struct

type BreakBefore struct{}

Specifies whether or not a page-, column-, or region-break should occur before the specified element

BreakBefore.Key

func (p BreakBefore) Key() string

BreakBefore.Process

func (p BreakBefore) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

BreakInside

struct

type BreakInside struct{}

Specifies whether or not a page-, column-, or region-break should occur inside the specified element

BreakInside.Key

func (p BreakInside) Key() string

BreakInside.Process

func (p BreakInside) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

CaptionSide

struct

type CaptionSide struct{}

Specifies the placement of a table caption

CaptionSide.Key

func (p CaptionSide) Key() string

CaptionSide.Process

func (p CaptionSide) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

CaretColor

struct

type CaretColor struct{}

Specifies the color of the cursor (caret) in inputs, textareas, or any element that is editable

CaretColor.Key

func (p CaretColor) Key() string

CaretColor.Process

func (p CaretColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Charset

struct

type Charset struct{}

Specifies the character encoding used in the style sheet

Charset.Key

func (p Charset) Key() string

Charset.Process

func (p Charset) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Clear

struct

type Clear struct{}

Specifies what should happen with the element that is next to a floating element

Clear.Key

func (p Clear) Key() string

Clear.Process

func (p Clear) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Clip

struct

type Clip struct{}

Clips an absolutely positioned element

Clip.Key

func (p Clip) Key() string

Clip.Process

func (p Clip) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Color

struct

type Color struct{}

Sets the color of text

Color.Key

func (p Color) Key() string

Color.Process

func (p Color) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnCount

struct

type ColumnCount struct{}

Specifies the number of columns an element should be divided into

ColumnCount.Key

func (p ColumnCount) Key() string

ColumnCount.Process

func (p ColumnCount) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnFill

struct

type ColumnFill struct{}

Specifies how to fill columns, balanced or not

ColumnFill.Key

func (p ColumnFill) Key() string

ColumnFill.Process

func (p ColumnFill) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnGap

struct

type ColumnGap struct{}

Specifies the gap between the columns

ColumnGap.Key

func (p ColumnGap) Key() string

ColumnGap.Process

func (p ColumnGap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnRule

struct

type ColumnRule struct{}

A shorthand property for all the column-rule-* properties

ColumnRule.Key

func (p ColumnRule) Key() string

ColumnRule.Process

func (p ColumnRule) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnRuleColor

struct

type ColumnRuleColor struct{}

Specifies the color of the rule between columns

ColumnRuleColor.Key

func (p ColumnRuleColor) Key() string

ColumnRuleColor.Process

func (p ColumnRuleColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnRuleStyle

struct

type ColumnRuleStyle struct{}

Specifies the style of the rule between columns

ColumnRuleStyle.Key

func (p ColumnRuleStyle) Key() string

ColumnRuleStyle.Process

func (p ColumnRuleStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnRuleWidth

struct

type ColumnRuleWidth struct{}

Specifies the width of the rule between columns

ColumnRuleWidth.Key

func (p ColumnRuleWidth) Key() string

ColumnRuleWidth.Process

func (p ColumnRuleWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnSpan

struct

type ColumnSpan struct{}

Specifies how many columns an element should span across

ColumnSpan.Key

func (p ColumnSpan) Key() string

ColumnSpan.Process

func (p ColumnSpan) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ColumnWidth

struct

type ColumnWidth struct{}

Specifies the column width

ColumnWidth.Key

func (p ColumnWidth) Key() string

ColumnWidth.Process

func (p ColumnWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Columns

struct

type Columns struct{}

A shorthand property for column-width and column-count

Columns.Key

func (p Columns) Key() string

Columns.Process

func (p Columns) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Content

struct

type Content struct{}

Used with the :before and :after pseudo-elements, to insert generated content

Content.Key

func (p Content) Key() string

Content.Process

func (p Content) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

CounterIncrement

struct

type CounterIncrement struct{}

Increases or decreases the value of one or more CSS counters

CounterIncrement.Key

func (p CounterIncrement) Key() string

CounterIncrement.Process

func (p CounterIncrement) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

CounterReset

struct

type CounterReset struct{}

Creates or resets one or more CSS counters

CounterReset.Key

func (p CounterReset) Key() string

CounterReset.Process

func (p CounterReset) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Cursor

struct

type Cursor struct{}

Specifies the mouse cursor to be displayed when pointing over an element

Cursor.Key

func (p Cursor) Key() string

Cursor.Process

func (p Cursor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Direction

struct

type Direction struct{}

Specifies the text direction/writing direction

Direction.Key

func (p Direction) Key() string

Direction.Process

func (p Direction) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Display

struct

type Display struct{}

Specifies how a certain HTML element should be displayed

Display.Key

func (p Display) Key() string

Display.Process

func (p Display) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

EmptyCells

struct

type EmptyCells struct{}

Specifies whether or not to display borders and background on empty cells in a table

EmptyCells.Key

func (p EmptyCells) Key() string

EmptyCells.Process

func (p EmptyCells) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Filter

struct

type Filter struct{}

Defines effects (e.g. blurring or color shifting) on an element before the element is displayed

Filter.Key

func (p Filter) Key() string

Filter.Process

func (p Filter) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Flex

struct

type Flex struct{}

A shorthand property for the flex-grow, flex-shrink, and the flex-basis properties

Flex.Key

func (p Flex) Key() string

Flex.Process

func (p Flex) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FlexBasis

struct

type FlexBasis struct{}

Specifies the initial length of a flexible item

FlexBasis.Key

func (p FlexBasis) Key() string

FlexBasis.Process

func (p FlexBasis) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FlexDirection

struct

type FlexDirection struct{}

Specifies the direction of the flexible items

FlexDirection.Key

func (p FlexDirection) Key() string

FlexDirection.Process

func (p FlexDirection) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FlexFlow

struct

type FlexFlow struct{}

A shorthand property for the flex-direction and the flex-wrap properties

FlexFlow.Key

func (p FlexFlow) Key() string

FlexFlow.Process

func (p FlexFlow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FlexGrow

struct

type FlexGrow struct{}

Specifies how much the item will grow relative to the rest

FlexGrow.Key

func (p FlexGrow) Key() string

FlexGrow.Process

func (p FlexGrow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FlexShrink

struct

type FlexShrink struct{}

Specifies how the item will shrink relative to the rest

FlexShrink.Key

func (p FlexShrink) Key() string

FlexShrink.Process

func (p FlexShrink) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FlexWrap

struct

type FlexWrap struct{}

Specifies whether the flexible items should wrap or not

FlexWrap.Key

func (p FlexWrap) Key() string

FlexWrap.Process

func (p FlexWrap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Float

struct

type Float struct{}

Specifies whether an element should float to the left, right, or not at all

Float.Key

func (p Float) Key() string

Float.Process

func (p Float) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Font

struct

type Font struct{}

A shorthand property for the font-style, font-variant, font-weight, font-size/line-height, and the font-family properties

Font.Key

func (p Font) Key() string

Font.Process

func (p Font) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontFace

struct

type FontFace struct{}

A rule that allows websites to download and use fonts other than the "web-safe" fonts

FontFace.Key

func (p FontFace) Key() string

FontFace.Process

func (p FontFace) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontFamily

struct

type FontFamily struct{}

Specifies the font family for text

FontFamily.Key

func (p FontFamily) Key() string

FontFamily.Process

func (p FontFamily) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontFeatureSettings

struct

type FontFeatureSettings struct{}

Allows control over advanced typographic features in OpenType fonts

FontFeatureSettings.Key

func (p FontFeatureSettings) Key() string

FontFeatureSettings.Process

func (p FontFeatureSettings) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontFeatureValues

struct

type FontFeatureValues struct{}

Allows authors to use a common name in font-variant-alternate for feature activated differently in OpenType

FontFeatureValues.Key

func (p FontFeatureValues) Key() string

FontFeatureValues.Process

func (p FontFeatureValues) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontKerning

struct

type FontKerning struct{}

Controls the usage of the kerning information (how letters are spaced)

FontKerning.Key

func (p FontKerning) Key() string

FontKerning.Process

func (p FontKerning) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontLanguageOverride

struct

type FontLanguageOverride struct{}

Controls the usage of language-specific glyphs in a typeface

FontLanguageOverride.Key

func (p FontLanguageOverride) Key() string

FontLanguageOverride.Process

func (p FontLanguageOverride) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontSizeAdjust

struct

type FontSizeAdjust struct{}

Preserves the readability of text when font fallback occurs

FontSizeAdjust.Key

func (p FontSizeAdjust) Key() string

FontSizeAdjust.Process

func (p FontSizeAdjust) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontStretch

struct

type FontStretch struct{}

Selects a normal, condensed, or expanded face from a font family

FontStretch.Key

func (p FontStretch) Key() string

FontStretch.Process

func (p FontStretch) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontStyle

struct

type FontStyle struct{}

Specifies the font style for text

FontStyle.Key

func (p FontStyle) Key() string

FontStyle.Process

func (p FontStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

normal|italic|oblique|initial|inherit

FontSynthesis

struct

type FontSynthesis struct{}

Controls which missing typefaces (bold or italic) may be synthesized by the browser

FontSynthesis.Key

func (p FontSynthesis) Key() string

FontSynthesis.Process

func (p FontSynthesis) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariant

struct

type FontVariant struct{}

Specifies whether or not a text should be displayed in a small-caps font

FontVariant.Key

func (p FontVariant) Key() string

FontVariant.Process

func (p FontVariant) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariantAlternates

struct

type FontVariantAlternates struct{}

Controls the usage of alternate glyphs associated to alternative names defined in @font-feature-values

FontVariantAlternates.Key

func (p FontVariantAlternates) Key() string

FontVariantAlternates.Process

func (p FontVariantAlternates) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariantCaps

struct

type FontVariantCaps struct{}

Controls the usage of alternate glyphs for capital letters

FontVariantCaps.Key

func (p FontVariantCaps) Key() string

FontVariantCaps.Process

func (p FontVariantCaps) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariantEastAsian

struct

type FontVariantEastAsian struct{}

Controls the usage of alternate glyphs for East Asian scripts (e.g Japanese and Chinese)

FontVariantEastAsian.Key

func (p FontVariantEastAsian) Key() string

FontVariantEastAsian.Process

func (p FontVariantEastAsian) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariantLigatures

struct

type FontVariantLigatures struct{}

Controls which ligatures and contextual forms are used in textual content of the elements it applies to

FontVariantLigatures.Key

func (p FontVariantLigatures) Key() string

FontVariantLigatures.Process

func (p FontVariantLigatures) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariantNumeric

struct

type FontVariantNumeric struct{}

Controls the usage of alternate glyphs for numbers, fractions, and ordinal markers

FontVariantNumeric.Key

func (p FontVariantNumeric) Key() string

FontVariantNumeric.Process

func (p FontVariantNumeric) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontVariantPosition

struct

type FontVariantPosition struct{}

Controls the usage of alternate glyphs of smaller size positioned as superscript or subscript regarding the baseline of the font

FontVariantPosition.Key

func (p FontVariantPosition) Key() string

FontVariantPosition.Process

func (p FontVariantPosition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

FontWeight

struct

type FontWeight struct{}

Specifies the weight of a font

FontWeight.Key

func (p FontWeight) Key() string

FontWeight.Process

func (p FontWeight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Gap

struct

type Gap struct{}

A shorthand property for the row-gap and the column-gap properties

Gap.Key

func (p Gap) Key() string

Gap.Process

func (p Gap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Grid

struct

type Grid struct{}

A shorthand property for the grid-template-rows, grid-template-columns, grid-template-areas, grid-auto-rows, grid-auto-columns, and the grid-auto-flow properties

Grid.Key

func (p Grid) Key() string

Grid.Process

func (p Grid) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridArea

struct

type GridArea struct{}

Either specifies a name for the grid item, or this property is a shorthand property for the grid-row-start, grid-column-start, grid-row-end, and grid-column-end properties

GridArea.Key

func (p GridArea) Key() string

GridArea.Process

func (p GridArea) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridAutoColumns

struct

type GridAutoColumns struct{}

Specifies a default column size

GridAutoColumns.Key

func (p GridAutoColumns) Key() string

GridAutoColumns.Process

func (p GridAutoColumns) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridAutoFlow

struct

type GridAutoFlow struct{}

Specifies how auto-placed items are inserted in the grid

GridAutoFlow.Key

func (p GridAutoFlow) Key() string

GridAutoFlow.Process

func (p GridAutoFlow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridAutoRows

struct

type GridAutoRows struct{}

Specifies a default row size

GridAutoRows.Key

func (p GridAutoRows) Key() string

GridAutoRows.Process

func (p GridAutoRows) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridColumn

struct

type GridColumn struct{}

A shorthand property for the grid-column-start and the grid-column-end properties

GridColumn.Key

func (p GridColumn) Key() string

GridColumn.Process

func (p GridColumn) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridColumnEnd

struct

type GridColumnEnd struct{}

Specifies where to end the grid item

GridColumnEnd.Key

func (p GridColumnEnd) Key() string

GridColumnEnd.Process

func (p GridColumnEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridColumnGap

struct

type GridColumnGap struct{}

Specifies the size of the gap between columns

GridColumnGap.Key

func (p GridColumnGap) Key() string

GridColumnGap.Process

func (p GridColumnGap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridColumnStart

struct

type GridColumnStart struct{}

Specifies where to start the grid item

GridColumnStart.Key

func (p GridColumnStart) Key() string

GridColumnStart.Process

func (p GridColumnStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridGap

struct

type GridGap struct{}

A shorthand property for the grid-row-gap and grid-column-gap properties

GridGap.Key

func (p GridGap) Key() string

GridGap.Process

func (p GridGap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridRow

struct

type GridRow struct{}

A shorthand property for the grid-row-start and the grid-row-end properties

GridRow.Key

func (p GridRow) Key() string

GridRow.Process

func (p GridRow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridRowEnd

struct

type GridRowEnd struct{}

Specifies where to end the grid item

GridRowEnd.Key

func (p GridRowEnd) Key() string

GridRowEnd.Process

func (p GridRowEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridRowGap

struct

type GridRowGap struct{}

Specifies the size of the gap between rows

GridRowGap.Key

func (p GridRowGap) Key() string

GridRowGap.Process

func (p GridRowGap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridRowStart

struct

type GridRowStart struct{}

Specifies where to start the grid item

GridRowStart.Key

func (p GridRowStart) Key() string

GridRowStart.Process

func (p GridRowStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridTemplate

struct

type GridTemplate struct{}

A shorthand property for the grid-template-rows, grid-template-columns and grid-areas properties

GridTemplate.Key

func (p GridTemplate) Key() string

GridTemplate.Process

func (p GridTemplate) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridTemplateAreas

struct

type GridTemplateAreas struct{}

Specifies how to display columns and rows, using named grid items

GridTemplateAreas.Key

func (p GridTemplateAreas) Key() string

GridTemplateAreas.Process

func (p GridTemplateAreas) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridTemplateColumns

struct

type GridTemplateColumns struct{}

Specifies the size of the columns, and how many columns in a grid layout

GridTemplateColumns.Key

func (p GridTemplateColumns) Key() string

GridTemplateColumns.Process

func (p GridTemplateColumns) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

GridTemplateRows

struct

type GridTemplateRows struct{}

Specifies the size of the rows in a grid layout

GridTemplateRows.Key

func (p GridTemplateRows) Key() string

GridTemplateRows.Process

func (p GridTemplateRows) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

HangingPunctuation

struct

type HangingPunctuation struct{}

Specifies whether a punctuation character may be placed outside the line box

HangingPunctuation.Key

func (p HangingPunctuation) Key() string

HangingPunctuation.Process

func (p HangingPunctuation) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Height

struct

type Height struct{}

Sets the height of an element

Height.Key

func (p Height) Key() string

Height.Process

func (p Height) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Hyphens

struct

type Hyphens struct{}

Sets how to split words to improve the layout of paragraphs

Hyphens.Key

func (p Hyphens) Key() string

Hyphens.Process

func (p Hyphens) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ImageRendering

struct

type ImageRendering struct{}

Specifies the type of algorithm to use for image scaling

ImageRendering.Key

func (p ImageRendering) Key() string

ImageRendering.Process

func (p ImageRendering) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Import

struct

type Import struct{}

Allows you to import a style sheet into another style sheet

Import.Key

func (p Import) Key() string

Import.Process

func (p Import) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InlineSize

struct

type InlineSize struct{}

Specifies the size of an element in the inline direction

InlineSize.Key

func (p InlineSize) Key() string

InlineSize.Process

func (p InlineSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Inset

struct

type Inset struct{}

Specifies the distance between an element and the parent element

Inset.Key

func (p Inset) Key() string

Inset.Process

func (p Inset) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InsetBlock

struct

type InsetBlock struct{}

Specifies the distance between an element and the parent element in the block direction

InsetBlock.Key

func (p InsetBlock) Key() string

InsetBlock.Process

func (p InsetBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InsetBlockEnd

struct

type InsetBlockEnd struct{}

Specifies the distance between the end of an element and the parent element in the block direction

InsetBlockEnd.Key

func (p InsetBlockEnd) Key() string

InsetBlockEnd.Process

func (p InsetBlockEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InsetBlockStart

struct

type InsetBlockStart struct{}

Specifies the distance between the start of an element and the parent element in the block direction

InsetBlockStart.Key

func (p InsetBlockStart) Key() string

InsetBlockStart.Process

func (p InsetBlockStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InsetInline

struct

type InsetInline struct{}

Specifies the distance between an element and the parent element in the inline direction

InsetInline.Key

func (p InsetInline) Key() string

InsetInline.Process

func (p InsetInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InsetInlineEnd

struct

type InsetInlineEnd struct{}

Specifies the distance between the end of an element and the parent element in the inline direction

InsetInlineEnd.Key

func (p InsetInlineEnd) Key() string

InsetInlineEnd.Process

func (p InsetInlineEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

InsetInlineStart

struct

type InsetInlineStart struct{}

Specifies the distance between the start of an element and the parent element in the inline direction

InsetInlineStart.Key

func (p InsetInlineStart) Key() string

InsetInlineStart.Process

func (p InsetInlineStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Isolation

struct

type Isolation struct{}

Defines whether an element must create a new stacking content

Isolation.Key

func (p Isolation) Key() string

Isolation.Process

func (p Isolation) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

JustifyContent

struct

type JustifyContent struct{}

Specifies the alignment between the items inside a flexible container when the items do not use all available space

JustifyContent.Key

func (p JustifyContent) Key() string

JustifyContent.Process

func (p JustifyContent) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

JustifyItems

struct

type JustifyItems struct{}

Is set on the grid container. Specifies the alignment of grid items in the inline direction

JustifyItems.Key

func (p JustifyItems) Key() string

JustifyItems.Process

func (p JustifyItems) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

JustifySelf

struct

type JustifySelf struct{}

Is set on the grid item. Specifies the alignment of the grid item in the inline direction

JustifySelf.Key

func (p JustifySelf) Key() string

JustifySelf.Process

func (p JustifySelf) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Keyframes

struct

type Keyframes struct{}

Specifies the animation code

Keyframes.Key

func (p Keyframes) Key() string

Keyframes.Process

func (p Keyframes) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Left

struct

type Left struct{}

Specifies the left position of a positioned element

Left.Key

func (p Left) Key() string

Left.Process

func (p Left) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

auto|length|initial|inherit

LetterSpacing

struct

type LetterSpacing struct{}

Increases or decreases the space between characters in a text

LetterSpacing.Key

func (p LetterSpacing) Key() string

LetterSpacing.Process

func (p LetterSpacing) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

LineBreak

struct

type LineBreak struct{}

Specifies how/if to break lines

LineBreak.Key

func (p LineBreak) Key() string

LineBreak.Process

func (p LineBreak) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

LineHeight

struct

type LineHeight struct{}

Sets the line height

LineHeight.Key

func (p LineHeight) Key() string

LineHeight.Process

func (p LineHeight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ListStyle

struct

type ListStyle struct{}

Sets all the properties for a list in one declaration

ListStyle.Key

func (p ListStyle) Key() string

ListStyle.Process

func (p ListStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ListStyleImage

struct

type ListStyleImage struct{}

Specifies an image as the list-item marker

ListStyleImage.Key

func (p ListStyleImage) Key() string

ListStyleImage.Process

func (p ListStyleImage) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ListStylePosition

struct

type ListStylePosition struct{}

Specifies the position of the list-item markers (bullet points)

ListStylePosition.Key

func (p ListStylePosition) Key() string

ListStylePosition.Process

func (p ListStylePosition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ListStyleType

struct

type ListStyleType struct{}

Specifies the type of list-item marker

ListStyleType.Key

func (p ListStyleType) Key() string

ListStyleType.Process

func (p ListStyleType) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Margin

struct

type Margin struct{}

Sets all the margin properties in one declaration

Margin.Key

func (p Margin) Key() string

Margin.Process

func (p Margin) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginBlock

struct

type MarginBlock struct{}

Specifies the margin in the block direction

MarginBlock.Key

func (p MarginBlock) Key() string

MarginBlock.Process

func (p MarginBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginBlockEnd

struct

type MarginBlockEnd struct{}

Specifies the margin at the end in the block direction

MarginBlockEnd.Key

func (p MarginBlockEnd) Key() string

MarginBlockEnd.Process

func (p MarginBlockEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginBlockStart

struct

type MarginBlockStart struct{}

Specifies the margin at the start in the block direction

MarginBlockStart.Key

func (p MarginBlockStart) Key() string

MarginBlockStart.Process

func (p MarginBlockStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginBottom

struct

type MarginBottom struct{}

Sets the bottom margin of an element

MarginBottom.Key

func (p MarginBottom) Key() string

MarginBottom.Process

func (p MarginBottom) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|auto|initial|inherit

MarginInline

struct

type MarginInline struct{}

Specifies the margin in the inline direction

MarginInline.Key

func (p MarginInline) Key() string

MarginInline.Process

func (p MarginInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginInlineEnd

struct

type MarginInlineEnd struct{}

Specifies the margin at the end in the inline direction

MarginInlineEnd.Key

func (p MarginInlineEnd) Key() string

MarginInlineEnd.Process

func (p MarginInlineEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginInlineStart

struct

type MarginInlineStart struct{}

Specifies the margin at the start in the inline direction

MarginInlineStart.Key

func (p MarginInlineStart) Key() string

MarginInlineStart.Process

func (p MarginInlineStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MarginLeft

struct

type MarginLeft struct{}

Sets the left margin of an element

MarginLeft.Key

func (p MarginLeft) Key() string

MarginLeft.Process

func (p MarginLeft) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|auto|initial|inherit

MarginRight

struct

type MarginRight struct{}

Sets the right margin of an element

MarginRight.Key

func (p MarginRight) Key() string

MarginRight.Process

func (p MarginRight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|auto|initial|inherit

MarginTop

struct

type MarginTop struct{}

Sets the top margin of an element

MarginTop.Key

func (p MarginTop) Key() string

MarginTop.Process

func (p MarginTop) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|auto|initial|inherit

Mask

struct

type Mask struct{}

Hides parts of an element by masking or clipping an image at specific places

Mask.Key

func (p Mask) Key() string

Mask.Process

func (p Mask) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskClip

struct

type MaskClip struct{}

Specifies the mask area

MaskClip.Key

func (p MaskClip) Key() string

MaskClip.Process

func (p MaskClip) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskComposite

struct

type MaskComposite struct{}

Represents a compositing operation used on the current mask layer with the mask layers below it

MaskComposite.Key

func (p MaskComposite) Key() string

MaskComposite.Process

func (p MaskComposite) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskImage

struct

type MaskImage struct{}

Specifies an image to be used as a mask layer for an element

MaskImage.Key

func (p MaskImage) Key() string

MaskImage.Process

func (p MaskImage) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskMode

struct

type MaskMode struct{}

Specifies whether the mask layer image is treated as a luminance mask or as an alpha mask

MaskMode.Key

func (p MaskMode) Key() string

MaskMode.Process

func (p MaskMode) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskOrigin

struct

type MaskOrigin struct{}

Specifies the origin position (the mask position area) of a mask layer image

MaskOrigin.Key

func (p MaskOrigin) Key() string

MaskOrigin.Process

func (p MaskOrigin) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskPosition

struct

type MaskPosition struct{}

Sets the starting position of a mask layer image (relative to the mask position area)

MaskPosition.Key

func (p MaskPosition) Key() string

MaskPosition.Process

func (p MaskPosition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskRepeat

struct

type MaskRepeat struct{}

Specifies how the mask layer image is repeated

MaskRepeat.Key

func (p MaskRepeat) Key() string

MaskRepeat.Process

func (p MaskRepeat) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskSize

struct

type MaskSize struct{}

Specifies the size of a mask layer image

MaskSize.Key

func (p MaskSize) Key() string

MaskSize.Process

func (p MaskSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaskType

struct

type MaskType struct{}

Specifies whether an SVG element is treated as a luminance mask or as an alpha mask

MaskType.Key

func (p MaskType) Key() string

MaskType.Process

func (p MaskType) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaxBlockSize

struct

type MaxBlockSize struct{}

Sets the maximum size of an element in the block direction

MaxBlockSize.Key

func (p MaxBlockSize) Key() string

MaxBlockSize.Process

func (p MaxBlockSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaxHeight

struct

type MaxHeight struct{}

Sets the maximum height of an element

MaxHeight.Key

func (p MaxHeight) Key() string

MaxHeight.Process

func (p MaxHeight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaxInlineSize

struct

type MaxInlineSize struct{}

Sets the maximum size of an element in the inline direction

MaxInlineSize.Key

func (p MaxInlineSize) Key() string

MaxInlineSize.Process

func (p MaxInlineSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MaxWidth

struct

type MaxWidth struct{}

Sets the maximum width of an element

MaxWidth.Key

func (p MaxWidth) Key() string

MaxWidth.Process

func (p MaxWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Media

struct

type Media struct{}

Sets the style rules for different media types/devices/sizes

Media.Key

func (p Media) Key() string

Media.Process

func (p Media) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MinBlockSize

struct

type MinBlockSize struct{}

Sets the minimum size of an element in the block direction

MinBlockSize.Key

func (p MinBlockSize) Key() string

MinBlockSize.Process

func (p MinBlockSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MinHeight

struct

type MinHeight struct{}

Sets the minimum height of an element

MinHeight.Key

func (p MinHeight) Key() string

MinHeight.Process

func (p MinHeight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MinInlineSize

struct

type MinInlineSize struct{}

Sets the minimum size of an element in the inline direction

MinInlineSize.Key

func (p MinInlineSize) Key() string

MinInlineSize.Process

func (p MinInlineSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MinWidth

struct

type MinWidth struct{}

Sets the minimum width of an element

MinWidth.Key

func (p MinWidth) Key() string

MinWidth.Process

func (p MinWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

MixBlendMode

struct

type MixBlendMode struct{}

Specifies how an element's content should blend with its direct parent background

MixBlendMode.Key

func (p MixBlendMode) Key() string

MixBlendMode.Process

func (p MixBlendMode) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ObjectFit

struct

type ObjectFit struct{}

Specifies how the contents of a replaced element should be fitted to the box established by its used height and width

ObjectFit.Key

func (p ObjectFit) Key() string

ObjectFit.Process

func (p ObjectFit) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ObjectPosition

struct

type ObjectPosition struct{}

Specifies the alignment of the replaced element inside its box

ObjectPosition.Key

func (p ObjectPosition) Key() string

ObjectPosition.Process

func (p ObjectPosition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Offset

struct

type Offset struct{}

Is a shorthand, and specifies how to animate an element along a path

Offset.Key

func (p Offset) Key() string

Offset.Process

func (p Offset) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OffsetAnchor

struct

type OffsetAnchor struct{}

Specifies a point on an element that is fixed to the path it is animated along

OffsetAnchor.Key

func (p OffsetAnchor) Key() string

OffsetAnchor.Process

func (p OffsetAnchor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OffsetDistance

struct

type OffsetDistance struct{}

Specifies the position along a path where an animated element is placed

OffsetDistance.Key

func (p OffsetDistance) Key() string

OffsetDistance.Process

func (p OffsetDistance) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OffsetPath

struct

type OffsetPath struct{}

Specifies the path an element is animated along

OffsetPath.Key

func (p OffsetPath) Key() string

OffsetPath.Process

func (p OffsetPath) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OffsetRotate

struct

type OffsetRotate struct{}

Specifies rotation of an element as it is animated along a path

OffsetRotate.Key

func (p OffsetRotate) Key() string

OffsetRotate.Process

func (p OffsetRotate) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Opacity

struct

type Opacity struct{}

Sets the opacity level for an element

Opacity.Key

func (p Opacity) Key() string

Opacity.Process

func (p Opacity) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Order

struct

type Order struct{}

Sets the order of the flexible item, relative to the rest

Order.Key

func (p Order) Key() string

Order.Process

func (p Order) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Orphans

struct

type Orphans struct{}

Sets the minimum number of lines that must be left at the bottom of a page or column

Orphans.Key

func (p Orphans) Key() string

Orphans.Process

func (p Orphans) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Outline

struct

type Outline struct{}

A shorthand property for the outline-width, outline-style, and the outline-color properties

Outline.Key

func (p Outline) Key() string

Outline.Process

func (p Outline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OutlineColor

struct

type OutlineColor struct{}

Sets the color of an outline

OutlineColor.Key

func (p OutlineColor) Key() string

OutlineColor.Process

func (p OutlineColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OutlineOffset

struct

type OutlineOffset struct{}

Offsets an outline, and draws it beyond the border edge

OutlineOffset.Key

func (p OutlineOffset) Key() string

OutlineOffset.Process

func (p OutlineOffset) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OutlineStyle

struct

type OutlineStyle struct{}

Sets the style of an outline

OutlineStyle.Key

func (p OutlineStyle) Key() string

OutlineStyle.Process

func (p OutlineStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OutlineWidth

struct

type OutlineWidth struct{}

Sets the width of an outline

OutlineWidth.Key

func (p OutlineWidth) Key() string

OutlineWidth.Process

func (p OutlineWidth) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Overflow

struct

type Overflow struct{}

Specifies what happens if content overflows an element's box

Overflow.Key

func (p Overflow) Key() string

Overflow.Process

func (p Overflow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverflowAnchor

struct

type OverflowAnchor struct{}

Specifies whether or not content in viewable area in a scrollable contianer should be pushed down when new content is loaded above

OverflowAnchor.Key

func (p OverflowAnchor) Key() string

OverflowAnchor.Process

func (p OverflowAnchor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverflowWrap

struct

type OverflowWrap struct{}

Specifies whether or not the browser can break lines with long words, if they overflow the container

OverflowWrap.Key

func (p OverflowWrap) Key() string

OverflowWrap.Process

func (p OverflowWrap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverflowX

struct

type OverflowX struct{}

Specifies whether or not to clip the left/right edges of the content, if it overflows the element's content area

OverflowX.Key

func (p OverflowX) Key() string

OverflowX.Process

func (p OverflowX) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverflowY

struct

type OverflowY struct{}

Specifies whether or not to clip the top/bottom edges of the content, if it overflows the element's content area

OverflowY.Key

func (p OverflowY) Key() string

OverflowY.Process

func (p OverflowY) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverscrollBehavior

struct

type OverscrollBehavior struct{}

Specifies whether to have scroll chaining or overscroll affordance in x- and y-directions

OverscrollBehavior.Key

func (p OverscrollBehavior) Key() string

OverscrollBehavior.Process

func (p OverscrollBehavior) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverscrollBehaviorBlock

struct

type OverscrollBehaviorBlock struct{}

Specifies whether to have scroll chaining or overscroll affordance in the block direction

OverscrollBehaviorBlock.Key

func (p OverscrollBehaviorBlock) Key() string

OverscrollBehaviorBlock.Process

func (p OverscrollBehaviorBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverscrollBehaviorInline

struct

type OverscrollBehaviorInline struct{}

Specifies whether to have scroll chaining or overscroll affordance in the inline direction

OverscrollBehaviorInline.Key

func (p OverscrollBehaviorInline) Key() string

OverscrollBehaviorInline.Process

func (p OverscrollBehaviorInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverscrollBehaviorX

struct

type OverscrollBehaviorX struct{}

Specifies whether to have scroll chaining or overscroll affordance in x-direction

OverscrollBehaviorX.Key

func (p OverscrollBehaviorX) Key() string

OverscrollBehaviorX.Process

func (p OverscrollBehaviorX) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

OverscrollBehaviorY

struct

type OverscrollBehaviorY struct{}

Specifies whether to have scroll chaining or overscroll affordance in y-directions

OverscrollBehaviorY.Key

func (p OverscrollBehaviorY) Key() string

OverscrollBehaviorY.Process

func (p OverscrollBehaviorY) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Padding

struct

type Padding struct{}

A shorthand property for all the padding-* properties

Padding.Key

func (p Padding) Key() string

Padding.Process

func (p Padding) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|initial|inherit

PaddingBlock

struct

type PaddingBlock struct{}

Specifies the padding in the block direction

PaddingBlock.Key

func (p PaddingBlock) Key() string

PaddingBlock.Process

func (p PaddingBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaddingBlockEnd

struct

type PaddingBlockEnd struct{}

Specifies the padding at the end in the block direction

PaddingBlockEnd.Key

func (p PaddingBlockEnd) Key() string

PaddingBlockEnd.Process

func (p PaddingBlockEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaddingBlockStart

struct

type PaddingBlockStart struct{}

Specifies the padding at the start in the block direction

PaddingBlockStart.Key

func (p PaddingBlockStart) Key() string

PaddingBlockStart.Process

func (p PaddingBlockStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaddingBottom

struct

type PaddingBottom struct{}

Sets the bottom padding of an element

PaddingBottom.Key

func (p PaddingBottom) Key() string

PaddingBottom.Process

func (p PaddingBottom) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|initial|inherit

PaddingInline

struct

type PaddingInline struct{}

Specifies the padding in the inline direction

PaddingInline.Key

func (p PaddingInline) Key() string

PaddingInline.Process

func (p PaddingInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaddingInlineEnd

struct

type PaddingInlineEnd struct{}

Specifies the padding at the end in the inline direction

PaddingInlineEnd.Key

func (p PaddingInlineEnd) Key() string

PaddingInlineEnd.Process

func (p PaddingInlineEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaddingInlineStart

struct

type PaddingInlineStart struct{}

Specifies the padding at the start in the inline direction

PaddingInlineStart.Key

func (p PaddingInlineStart) Key() string

PaddingInlineStart.Process

func (p PaddingInlineStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaddingLeft

struct

type PaddingLeft struct{}

Sets the left padding of an element

PaddingLeft.Key

func (p PaddingLeft) Key() string

PaddingLeft.Process

func (p PaddingLeft) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|initial|inherit

PaddingRight

struct

type PaddingRight struct{}

Sets the right padding of an element

PaddingRight.Key

func (p PaddingRight) Key() string

PaddingRight.Process

func (p PaddingRight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|initial|inherit

PaddingTop

struct

type PaddingTop struct{}

Sets the top padding of an element

PaddingTop.Key

func (p PaddingTop) Key() string

PaddingTop.Process

func (p PaddingTop) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

length|initial|inherit

PageBreakAfter

struct

type PageBreakAfter struct{}

Sets the page-break behavior after an element

PageBreakAfter.Key

func (p PageBreakAfter) Key() string

PageBreakAfter.Process

func (p PageBreakAfter) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PageBreakBefore

struct

type PageBreakBefore struct{}

Sets the page-break behavior before an element

PageBreakBefore.Key

func (p PageBreakBefore) Key() string

PageBreakBefore.Process

func (p PageBreakBefore) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PageBreakInside

struct

type PageBreakInside struct{}

Sets the page-break behavior inside an element

PageBreakInside.Key

func (p PageBreakInside) Key() string

PageBreakInside.Process

func (p PageBreakInside) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PaintOrder

struct

type PaintOrder struct{}

Sets the order of how an SVG element or text is painted.

PaintOrder.Key

func (p PaintOrder) Key() string

PaintOrder.Process

func (p PaintOrder) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Perspective

struct

type Perspective struct{}

Gives a 3D-positioned element some perspective

Perspective.Key

func (p Perspective) Key() string

Perspective.Process

func (p Perspective) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PerspectiveOrigin

struct

type PerspectiveOrigin struct{}

Defines at which position the user is looking at the 3D-positioned element

PerspectiveOrigin.Key

func (p PerspectiveOrigin) Key() string

PerspectiveOrigin.Process

func (p PerspectiveOrigin) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PlaceContent

struct

type PlaceContent struct{}

Specifies align-content and justify-content property values for flexbox and grid layouts

PlaceContent.Key

func (p PlaceContent) Key() string

PlaceContent.Process

func (p PlaceContent) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PlaceItems

struct

type PlaceItems struct{}

Specifies align-items and justify-items property values for grid layouts

PlaceItems.Key

func (p PlaceItems) Key() string

PlaceItems.Process

func (p PlaceItems) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PlaceSelf

struct

type PlaceSelf struct{}

Specifies align-self and justify-self property values for grid layouts

PlaceSelf.Key

func (p PlaceSelf) Key() string

PlaceSelf.Process

func (p PlaceSelf) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

PointerEvents

struct

type PointerEvents struct{}

Defines whether or not an element reacts to pointer events

PointerEvents.Key

func (p PointerEvents) Key() string

PointerEvents.Process

func (p PointerEvents) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Position

struct

type Position struct{}

Specifies the type of positioning method used for an element (static, relative, absolute or fixed)

Position.Key

func (p Position) Key() string

Position.Process

func (p Position) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Property

interface

type Property interface {
    Key() string
    Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error
}

Quotes

struct

type Quotes struct{}

Sets the type of quotation marks for embedded quotations

Quotes.Key

func (p Quotes) Key() string

Quotes.Process

func (p Quotes) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Resize

struct

type Resize struct{}

Defines if (and how) an element is resizable by the user

Resize.Key

func (p Resize) Key() string

Resize.Process

func (p Resize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Right

struct

type Right struct{}

Specifies the right position of a positioned element

Right.Key

func (p Right) Key() string

Right.Process

func (p Right) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

auto|length|initial|inherit

Rotate

struct

type Rotate struct{}

Specifies the rotation of an element

Rotate.Key

func (p Rotate) Key() string

Rotate.Process

func (p Rotate) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

RowGap

struct

type RowGap struct{}

Specifies the gap between the grid rows

RowGap.Key

func (p RowGap) Key() string

RowGap.Process

func (p RowGap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Scale

struct

type Scale struct{}

Specifies the size of an element by scaling up or down

Scale.Key

func (p Scale) Key() string

Scale.Process

func (p Scale) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollBehavior

struct

type ScrollBehavior struct{}

Specifies whether to smoothly animate the scroll position in a scrollable box, instead of a straight jump

ScrollBehavior.Key

func (p ScrollBehavior) Key() string

ScrollBehavior.Process

func (p ScrollBehavior) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMargin

struct

type ScrollMargin struct{}

Specifies the margin between the snap position and the container

ScrollMargin.Key

func (p ScrollMargin) Key() string

ScrollMargin.Process

func (p ScrollMargin) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginBlock

struct

type ScrollMarginBlock struct{}

Specifies the margin between the snap position and the container in the block direction

ScrollMarginBlock.Key

func (p ScrollMarginBlock) Key() string

ScrollMarginBlock.Process

func (p ScrollMarginBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginBlockEnd

struct

type ScrollMarginBlockEnd struct{}

Specifies the end margin between the snap position and the container in the block direction

ScrollMarginBlockEnd.Key

func (p ScrollMarginBlockEnd) Key() string

ScrollMarginBlockEnd.Process

func (p ScrollMarginBlockEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginBlockStart

struct

type ScrollMarginBlockStart struct{}

Specifies the start margin between the snap position and the container in the block direction

ScrollMarginBlockStart.Key

func (p ScrollMarginBlockStart) Key() string

ScrollMarginBlockStart.Process

func (p ScrollMarginBlockStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginBottom

struct

type ScrollMarginBottom struct{}

Specifies the margin between the snap position on the bottom side and the container

ScrollMarginBottom.Key

func (p ScrollMarginBottom) Key() string

ScrollMarginBottom.Process

func (p ScrollMarginBottom) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginInline

struct

type ScrollMarginInline struct{}

Specifies the margin between the snap position and the container in the inline direction

ScrollMarginInline.Key

func (p ScrollMarginInline) Key() string

ScrollMarginInline.Process

func (p ScrollMarginInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginInlineEnd

struct

type ScrollMarginInlineEnd struct{}

Specifies the end margin between the snap position and the container in the inline direction

ScrollMarginInlineEnd.Key

func (p ScrollMarginInlineEnd) Key() string

ScrollMarginInlineEnd.Process

func (p ScrollMarginInlineEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginInlineStart

struct

type ScrollMarginInlineStart struct{}

Specifies the start margin between the snap position and the container in the inline direction

ScrollMarginInlineStart.Key

func (p ScrollMarginInlineStart) Key() string

ScrollMarginInlineStart.Process

func (p ScrollMarginInlineStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginLeft

struct

type ScrollMarginLeft struct{}

Specifies the margin between the snap position on the left side and the container

ScrollMarginLeft.Key

func (p ScrollMarginLeft) Key() string

ScrollMarginLeft.Process

func (p ScrollMarginLeft) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginRight

struct

type ScrollMarginRight struct{}

Specifies the margin between the snap position on the right side and the container

ScrollMarginRight.Key

func (p ScrollMarginRight) Key() string

ScrollMarginRight.Process

func (p ScrollMarginRight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollMarginTop

struct

type ScrollMarginTop struct{}

Specifies the margin between the snap position on the top side and the container

ScrollMarginTop.Key

func (p ScrollMarginTop) Key() string

ScrollMarginTop.Process

func (p ScrollMarginTop) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPadding

struct

type ScrollPadding struct{}

Specifies the distance from the container to the snap position on the child elements

ScrollPadding.Key

func (p ScrollPadding) Key() string

ScrollPadding.Process

func (p ScrollPadding) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingBlock

struct

type ScrollPaddingBlock struct{}

Specifies the distance in block direction from the container to the snap position on the child elements

ScrollPaddingBlock.Key

func (p ScrollPaddingBlock) Key() string

ScrollPaddingBlock.Process

func (p ScrollPaddingBlock) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingBlockEnd

struct

type ScrollPaddingBlockEnd struct{}

Specifies the distance in block direction from the end of the container to the snap position on the child elements

ScrollPaddingBlockEnd.Key

func (p ScrollPaddingBlockEnd) Key() string

ScrollPaddingBlockEnd.Process

func (p ScrollPaddingBlockEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingBlockStart

struct

type ScrollPaddingBlockStart struct{}

Specifies the distance in block direction from the start of the container to the snap position on the child elements

ScrollPaddingBlockStart.Key

func (p ScrollPaddingBlockStart) Key() string

ScrollPaddingBlockStart.Process

func (p ScrollPaddingBlockStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingBottom

struct

type ScrollPaddingBottom struct{}

Specifies the distance from the bottom of the container to the snap position on the child elements

ScrollPaddingBottom.Key

func (p ScrollPaddingBottom) Key() string

ScrollPaddingBottom.Process

func (p ScrollPaddingBottom) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingInline

struct

type ScrollPaddingInline struct{}

Specifies the distance in inline direction from the container to the snap position on the child elements

ScrollPaddingInline.Key

func (p ScrollPaddingInline) Key() string

ScrollPaddingInline.Process

func (p ScrollPaddingInline) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingInlineEnd

struct

type ScrollPaddingInlineEnd struct{}

Specifies the distance in inline direction from the end of the container to the snap position on the child elements

ScrollPaddingInlineEnd.Key

func (p ScrollPaddingInlineEnd) Key() string

ScrollPaddingInlineEnd.Process

func (p ScrollPaddingInlineEnd) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingInlineStart

struct

type ScrollPaddingInlineStart struct{}

Specifies the distance in inline direction from the start of the container to the snap position on the child elements

ScrollPaddingInlineStart.Key

func (p ScrollPaddingInlineStart) Key() string

ScrollPaddingInlineStart.Process

func (p ScrollPaddingInlineStart) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingLeft

struct

type ScrollPaddingLeft struct{}

Specifies the distance from the left side of the container to the snap position on the child elements

ScrollPaddingLeft.Key

func (p ScrollPaddingLeft) Key() string

ScrollPaddingLeft.Process

func (p ScrollPaddingLeft) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingRight

struct

type ScrollPaddingRight struct{}

Specifies the distance from the right side of the container to the snap position on the child elements

ScrollPaddingRight.Key

func (p ScrollPaddingRight) Key() string

ScrollPaddingRight.Process

func (p ScrollPaddingRight) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollPaddingTop

struct

type ScrollPaddingTop struct{}

Specifies the distance from the top of the container to the snap position on the child elements

ScrollPaddingTop.Key

func (p ScrollPaddingTop) Key() string

ScrollPaddingTop.Process

func (p ScrollPaddingTop) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollSnapAlign

struct

type ScrollSnapAlign struct{}

Specifies where to position elements when the user stops scrolling

ScrollSnapAlign.Key

func (p ScrollSnapAlign) Key() string

ScrollSnapAlign.Process

func (p ScrollSnapAlign) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollSnapStop

struct

type ScrollSnapStop struct{}

Specifies scroll behaviour after fast swipe on trackpad or touch screen

ScrollSnapStop.Key

func (p ScrollSnapStop) Key() string

ScrollSnapStop.Process

func (p ScrollSnapStop) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollSnapType

struct

type ScrollSnapType struct{}

Specifies how snap behaviour should be when scrolling

ScrollSnapType.Key

func (p ScrollSnapType) Key() string

ScrollSnapType.Process

func (p ScrollSnapType) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ScrollbarColor

struct

type ScrollbarColor struct{}

Specifies the color of the scrollbar of an element

ScrollbarColor.Key

func (p ScrollbarColor) Key() string

ScrollbarColor.Process

func (p ScrollbarColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TabSize

struct

type TabSize struct{}

Specifies the width of a tab character

TabSize.Key

func (p TabSize) Key() string

TabSize.Process

func (p TabSize) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TableLayout

struct

type TableLayout struct{}

Defines the algorithm used to lay out table cells, rows, and columns

TableLayout.Key

func (p TableLayout) Key() string

TableLayout.Process

func (p TableLayout) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextAlign

struct

type TextAlign struct{}

Specifies the horizontal alignment of text

TextAlign.Key

func (p TextAlign) Key() string

TextAlign.Process

func (p TextAlign) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextAlignLast

struct

type TextAlignLast struct{}

Describes how the last line of a block or a line right before a forced line break is aligned when text-align is "justify"

TextAlignLast.Key

func (p TextAlignLast) Key() string

TextAlignLast.Process

func (p TextAlignLast) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextCombineUpright

struct

type TextCombineUpright struct{}

Specifies the combination of multiple characters into the space of a single character

TextCombineUpright.Key

func (p TextCombineUpright) Key() string

TextCombineUpright.Process

func (p TextCombineUpright) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextDecoration

struct

type TextDecoration struct{}

Specifies the decoration added to text

TextDecoration.Key

func (p TextDecoration) Key() string

TextDecoration.Process

func (p TextDecoration) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextDecorationColor

struct

type TextDecorationColor struct{}

Specifies the color of the text-decoration

TextDecorationColor.Key

func (p TextDecorationColor) Key() string

TextDecorationColor.Process

func (p TextDecorationColor) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextDecorationLine

struct

type TextDecorationLine struct{}

Specifies the type of line in a text-decoration

TextDecorationLine.Key

func (p TextDecorationLine) Key() string

TextDecorationLine.Process

func (p TextDecorationLine) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextDecorationStyle

struct

type TextDecorationStyle struct{}

Specifies the style of the line in a text decoration

TextDecorationStyle.Key

func (p TextDecorationStyle) Key() string

TextDecorationStyle.Process

func (p TextDecorationStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextDecorationThickness

struct

type TextDecorationThickness struct{}

Specifies the thickness of the decoration line

TextDecorationThickness.Key

func (p TextDecorationThickness) Key() string

TextDecorationThickness.Process

func (p TextDecorationThickness) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextEmphasis

struct

type TextEmphasis struct{}

Applies emphasis marks to text

TextEmphasis.Key

func (p TextEmphasis) Key() string

TextEmphasis.Process

func (p TextEmphasis) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextIndent

struct

type TextIndent struct{}

Specifies the indentation of the first line in a text-block

TextIndent.Key

func (p TextIndent) Key() string

TextIndent.Process

func (p TextIndent) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextJustify

struct

type TextJustify struct{}

Specifies the justification method used when text-align is "justify"

TextJustify.Key

func (p TextJustify) Key() string

TextJustify.Process

func (p TextJustify) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextOrientation

struct

type TextOrientation struct{}

Defines the orientation of characters in a line

TextOrientation.Key

func (p TextOrientation) Key() string

TextOrientation.Process

func (p TextOrientation) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextOverflow

struct

type TextOverflow struct{}

Specifies what should happen when text overflows the containing element

TextOverflow.Key

func (p TextOverflow) Key() string

TextOverflow.Process

func (p TextOverflow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextShadow

struct

type TextShadow struct{}

Adds shadow to text

TextShadow.Key

func (p TextShadow) Key() string

TextShadow.Process

func (p TextShadow) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextTransform

struct

type TextTransform struct{}

Controls the capitalization of text

TextTransform.Key

func (p TextTransform) Key() string

TextTransform.Process

func (p TextTransform) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TextUnderlinePosition

struct

type TextUnderlinePosition struct{}

Specifies the position of the underline which is set using the text-decoration property

TextUnderlinePosition.Key

func (p TextUnderlinePosition) Key() string

TextUnderlinePosition.Process

func (p TextUnderlinePosition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Top

struct

type Top struct{}

Specifies the top position of a positioned element

Top.Key

func (p Top) Key() string

Top.Process

func (p Top) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

auto|length|initial|inherit

Transform

struct

type Transform struct{}

Applies a 2D or 3D transformation to an element

Transform.Key

func (p Transform) Key() string

Transform.Process

func (p Transform) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

none|transform-functions|initial|inherit

TransformOrigin

struct

type TransformOrigin struct{}

Allows you to change the position on transformed elements

TransformOrigin.Key

func (p TransformOrigin) Key() string

TransformOrigin.Process

func (p TransformOrigin) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TransformStyle

struct

type TransformStyle struct{}

Specifies how nested elements are rendered in 3D space

TransformStyle.Key

func (p TransformStyle) Key() string

TransformStyle.Process

func (p TransformStyle) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Transition

struct

type Transition struct{}

A shorthand property for all the transition-* properties

Transition.Key

func (p Transition) Key() string

Transition.Process

func (p Transition) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TransitionDelay

struct

type TransitionDelay struct{}

Specifies when the transition effect will start

TransitionDelay.Key

func (p TransitionDelay) Key() string

TransitionDelay.Process

func (p TransitionDelay) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TransitionDuration

struct

type TransitionDuration struct{}

Specifies how many seconds or milliseconds a transition effect takes to complete

TransitionDuration.Key

func (p TransitionDuration) Key() string

TransitionDuration.Process

func (p TransitionDuration) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TransitionProperty

struct

type TransitionProperty struct{}

Specifies the name of the CSS property the transition effect is for

TransitionProperty.Key

func (p TransitionProperty) Key() string

TransitionProperty.Process

func (p TransitionProperty) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

TransitionTimingFunction

struct

type TransitionTimingFunction struct{}

Specifies the speed curve of the transition effect

TransitionTimingFunction.Key

func (p TransitionTimingFunction) Key() string

TransitionTimingFunction.Process

func (p TransitionTimingFunction) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Translate

struct

type Translate struct{}

Specifies the position of an element

Translate.Key

func (p Translate) Key() string

Translate.Process

func (p Translate) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

UnicodeBidi

struct

type UnicodeBidi struct{}

Used together with the direction property to set or return whether the text should be overridden to support multiple languages in the same document

UnicodeBidi.Key

func (p UnicodeBidi) Key() string

UnicodeBidi.Process

func (p UnicodeBidi) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

UserSelect

struct

type UserSelect struct{}

Specifies whether the text of an element can be selected

UserSelect.Key

func (p UserSelect) Key() string

UserSelect.Process

func (p UserSelect) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

VerticalAlign

struct

type VerticalAlign struct{}

Sets the vertical alignment of an element

VerticalAlign.Key

func (p VerticalAlign) Key() string

VerticalAlign.Process

func (p VerticalAlign) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Visibility

struct

type Visibility struct{}

Specifies whether or not an element is visible

Visibility.Key

func (p Visibility) Key() string

Visibility.Process

func (p Visibility) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

visibility: visible|hidden|collapse|initial|inherit;

WhiteSpace

struct

type WhiteSpace struct{}

Specifies how white-space inside an element is handled

WhiteSpace.Key

func (p WhiteSpace) Key() string

WhiteSpace.Process

func (p WhiteSpace) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Widows

struct

type Widows struct{}

Sets the minimum number of lines that must be left at the top of a page or column

Widows.Key

func (p Widows) Key() string

Widows.Process

func (p Widows) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

Width

struct

type Width struct{}

Sets the width of an element

Width.Key

func (p Width) Key() string

Width.Process

func (p Width) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

WordBreak

struct

type WordBreak struct{}

Specifies how words should break when reaching the end of a line

WordBreak.Key

func (p WordBreak) Key() string

WordBreak.Process

func (p WordBreak) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

WordSpacing

struct

type WordSpacing struct{}

Increases or decreases the space between words in a text

WordSpacing.Key

func (p WordSpacing) Key() string

WordSpacing.Process

func (p WordSpacing) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

WordWrap

struct

type WordWrap struct{}

Allows long, unbreakable words to be broken and wrap to the next line

WordWrap.Key

func (p WordWrap) Key() string

WordWrap.Process

func (p WordWrap) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

WritingMode

struct

type WritingMode struct{}

Specifies whether lines of text are laid out horizontally or vertically

WritingMode.Key

func (p WritingMode) Key() string

WritingMode.Process

func (p WritingMode) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error

ZIndex

struct

type ZIndex struct{}

Sets the stack order of a positioned element

ZIndex.Key

func (p ZIndex) Key() string

ZIndex.Process

func (p ZIndex) Process(panel *ui.Panel, elm *document.Element, values []rules.PropertyValue, host *engine.Host) error