HtmlAttrs

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def accept: Attr[Any]

If the value of the type attribute is file, this attribute indicates the types of files that the server accepts; otherwise it is ignored.
final def acceptCharset: Attr[Any]
final def accessKey: Attr[Any]
final def action: Attr[Any]

The URI of a program that processes the information submitted via the form.
The URI of a program that processes the information submitted via the form. This value can be overridden by a formaction attribute on a button or input element.
final def allowFullScreen: Attr[Boolean]
final def allowTransparency: Attr[Boolean]
final def alt: Attr[String]

This attribute defines the alternative text describing the image.
This attribute defines the alternative text describing the image. Users will see this displayed if the image URL is wrong, the image is not in one of the supported formats, or until the image is downloaded.
object aria

ARIA is a set of special accessibility attributes which can be added to any markup, but is especially suited to HTML.
ARIA is a set of special accessibility attributes which can be added to any markup, but is especially suited to HTML. The role attribute defines what the general type of object is (such as an article, alert, or slider). Additional ARIA attributes provide other useful properties, such as a description for a form or the current value of a progressbar.
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def async: Attr[Boolean]
final def autoCapitalize: Attr[Any]
object autoComplete extends Generic[Any]

This attribute indicates whether the value of the control can be automatically completed by the browser.
This attribute indicates whether the value of the control can be automatically completed by the browser. This attribute is ignored if the value of the type attribute is hidden, checkbox, radio, file, or a button type (button, submit, reset, image).
Possible values are "off" and "on"
final def autoCorrect: Attr[Boolean]
final def autoFocus: Attr[Boolean]

This Boolean attribute lets you specify that a form control should have input focus when the page loads, unless the user overrides it, for example by typing in a different control.
This Boolean attribute lets you specify that a form control should have input focus when the page loads, unless the user overrides it, for example by typing in a different control. Only one form element in a document can have the autoFocus attribute, which is a Boolean. It cannot be applied if the type attribute is set to hidden (that is, you cannot automatically set focus to a hidden control).
final def autoPlay: Attr[Boolean]
final def autoSave: Attr[Boolean]
final def capture: Attr[Any]

The capture attribute allows authors to declaratively request use of a media capture mechanism, such as a camera or microphone, from within a file upload control, for capturing media on the spot.
final def cellPadding: Attr[Any]
final def cellSpacing: Attr[Any]
final def challenge: Attr[Any]

<keygen>: A challenge string that is submitted along with the public key.
final def charset: Attr[String]

Declares the character encoding of the page or script.
Declares the character encoding of the page or script. Used on meta and script elements.
final def checked: Attr[Boolean]

When the value of the type attribute is radio or checkbox, the presence of this Boolean attribute indicates that the control is selected by default; otherwise it is ignored.
final def citeAttr: Attr[Any]
final def class: Attr[String]
final def classID: Attr[Any]
final def className: Attr[String]
final def classSet(ps: (String, Boolean)*): TagMod
final def classSet1(a: String, ps: (String, Boolean)*): TagMod
final def classSet1M(a: String, ps: Map[String, Boolean]): TagMod
final def classSetM(ps: Map[String, Boolean]): TagMod
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def cls: Attr[String]
final def colSpan: Attr[Int]
final def cols: Attr[Any]

The visible width of the text control, in average character widths.
The visible width of the text control, in average character widths. If it is specified, it must be a positive integer. If it is not specified, the default value is 20 (HTML5).
final def contentAttr: Attr[Any]

This attribute gives the value associated with the http-equiv or name attribute, depending of the context.
final def contentEditable: Attr[Any]
final def contextMenu: Attr[Any]
final def controls: Attr[Boolean]
final def coords: Attr[Any]
final def crossOrigin: Attr[Any]
final def dangerouslySetInnerHtml: Attr[InnerHtmlAttr]
final def dateTime: Attr[Any]
final def default: Attr[Boolean]
final def defaultValue: Attr[Any]
final def defer: Attr[Boolean]
final def dir: Attr[Any]
final def disabled: Attr[Boolean]

This Boolean attribute indicates that the form control is not available for interaction.
This Boolean attribute indicates that the form control is not available for interaction. In particular, the click event will not be dispatched on disabled controls. Also, a disabled control's value isn't submitted with the form.
This attribute is ignored if the value of the type attribute is hidden.
final def download: Attr[Any]
final def draggable: Attr[Boolean]
final def encType: Attr[Any]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def for: Attr[Any]

Describes elements which belongs to this one.
Describes elements which belongs to this one. Used on labels and output elements.
final def formAction: Attr[Any]
final def formEncType: Attr[Any]
final def formId: Attr[Any]

Allows association of an input to a non-ancestoral form.
final def formMethod: Attr[Any]
final def formNoValidate: Attr[Boolean]
final def formTarget: Attr[Any]
final def frameBorder: Attr[Any]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def headers: Attr[Any]
final def hidden: Attr[Boolean]
final def high: Attr[Any]

For use in <meter> tags.
For use in <meter> tags.

See also
https://css-tricks.com/html5-meter-element/
final def href: Attr[String]

This is the single required attribute for anchors defining a hypertext source link.
This is the single required attribute for anchors defining a hypertext source link. It indicates the link target, either a URL or a URL fragment. A URL fragment is a name preceded by a hash mark (#), which specifies an internal target location (an ID) within the current document. URLs are not restricted to Web (HTTP)-based documents. URLs might use any protocol supported by the browser. For example, file, ftp, and mailto work in most user agents.
final def hrefLang: Attr[Any]
final def htmlFor: Attr[Any]
final def httpEquiv: Attr[Any]

This enumerated attribute defines the pragma that can alter servers and user-agents behavior.
This enumerated attribute defines the pragma that can alter servers and user-agents behavior. The value of the pragma is defined using the content attribute and can be one of the following:
- content-language - content-type - default-style - refresh - set-cookie
final def icon: Attr[Any]
final def id: Attr[Any]

This attribute defines a unique identifier (ID) which must be unique in the whole document.
This attribute defines a unique identifier (ID) which must be unique in the whole document. Its purpose is to identify the element when linking (using a fragment identifier), scripting, or styling (with CSS).
final def inputMode: Attr[Any]

The inputmode attribute tells the browser on devices with dynamic keyboards which keyboard to display.
The inputmode attribute tells the browser on devices with dynamic keyboards which keyboard to display. The inputmode attribute applies to the text, search and password input types as well as <textarea>.
final def integrity: Attr[Any]

http://www.w3.org/TR/2015/CR-SRI-20151112/#the-integrity-attribute
final def is: Attr[Any]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def itemProp: Attr[Any]
final def itemScope: Attr[Boolean]
final def itemType: Attr[Any]
final val key: Key.type

React key
final def keyParams: Attr[Any]

For use in <keygen>
final def keyType: Attr[Any]

<keygen>: Specifies the type of key generated.
final def kind: Attr[Any]
final def lang: Attr[String]

This attribute participates in defining the language of the element, the language that non-editable elements are written in or the language that editable elements should be written in.
This attribute participates in defining the language of the element, the language that non-editable elements are written in or the language that editable elements should be written in. The tag contains one single entry value in the format defines in the Tags for Identifying Languages (BCP47) IETF document. If the tag content is the empty string the language is set to unknown; if the tag content is not valid, regarding to BCP47, it is set to invalid.
final def list: Attr[Any]
final def loop: Attr[Boolean]
final def low: Attr[Any]

For use in <meter> tags.
For use in <meter> tags.

See also
https://css-tricks.com/html5-meter-element/
final def manifest: Attr[Any]
final def marginHeight: Attr[Any]
final def marginWidth: Attr[Any]
final def max: Attr[Any]

For use in <meter> tags.
For use in <meter> tags.

See also
https://css-tricks.com/html5-meter-element/
final def maxLength: Attr[Any]
final def media: Attr[Any]

This attribute specifies the media which the linked resource applies to.
This attribute specifies the media which the linked resource applies to. Its value must be a media query. This attribute is mainly useful when linking to external stylesheets by allowing the user agent to pick the best adapted one for the device it runs on.

See also
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-media
final def mediaGroup: Attr[Any]
final def method: Attr[Any]

The HTTP method that the browser uses to submit the form.
The HTTP method that the browser uses to submit the form. Possible values are:
- post: Corresponds to the HTTP POST method ; form data are included in the body of the form and sent to the server.
- get: Corresponds to the HTTP GET method; form data are appended to the action attribute URI with a '?' as a separator, and the resulting URI is sent to the server. Use this method when the form has no side-effects and contains only ASCII characters.
This value can be overridden by a formmethod attribute on a button or input element.
final def min: Attr[Any]

For use in <meter> tags.
For use in <meter> tags.

See also
https://css-tricks.com/html5-meter-element/
final def minLength: Attr[Any]
final def multiple: Attr[Boolean]
final def muted: Attr[Boolean]
final def name: Attr[String]

On form elements (input etc.): Name of the element.
On form elements (input etc.): Name of the element. For example used by the server to identify the fields in form submits.
On the meta tag: This attribute defines the name of a document-level metadata. This document-level metadata name is associated with a value, contained by the content attribute.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def noModule: Attr[Boolean]
final def noValidate: Attr[Boolean]
final def nonce: Attr[Any]

For <script> and <style>elements.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def on: Attr[Any]

'on' attribute for amp tags.
'on' attribute for amp tags.
The on attribute is used to install event handlers on elements. The events that are supported depend on the element.
The value for the syntax is a simple domain specific language of the form:
```
eventName:targetId[.methodName[(arg1=value, arg2=value)]]
```
See also
https://www.ampproject.org/docs/reference/spec#on
final def onAbort: Event[SyntheticEvent]
final def onAbortCapture: Event[SyntheticEvent]
final def onAnimationEnd: Event[SyntheticAnimationEvent]
final def onAnimationEndCapture: Event[SyntheticAnimationEvent]
final def onAnimationIteration: Event[SyntheticAnimationEvent]
final def onAnimationIterationCapture: Event[SyntheticAnimationEvent]
final def onAnimationStart: Event[SyntheticAnimationEvent]
final def onAnimationStartCapture: Event[SyntheticAnimationEvent]
final def onAuxClick: Event[SyntheticMouseEvent]
final def onAuxClickCapture: Event[Nothing]
final def onBeforeInput: Event[SyntheticEvent]
final def onBlur: Event[SyntheticFocusEvent]

The blur event is raised when an element loses focus.
final def onBlurCapture: Event[SyntheticFocusEvent]
final def onCanPlay: Event[SyntheticEvent]
final def onCanPlayCapture: Event[SyntheticEvent]
final def onCanPlayThrough: Event[SyntheticEvent]
final val onChange: Event[SyntheticEvent]

The change event is fired for input, select, and textarea elements when a change to the element's value is committed by the user.
final val onClick: Event[SyntheticMouseEvent]

The click event is raised when the user clicks on an element.
The click event is raised when the user clicks on an element. The click event will occur after the mousedown and mouseup events.
final val onClickCapture: Event[SyntheticMouseEvent]
final def onCompositionEnd: Event[SyntheticCompositionEvent]
final def onCompositionStart: Event[SyntheticCompositionEvent]
final def onCompositionUpdate: Event[SyntheticCompositionEvent]
final def onContextMenu: Event[SyntheticMouseEvent]
final def onContextMenuCapture: Event[SyntheticMouseEvent]
final def onCopy: Event[SyntheticClipboardEvent]
final def onCopyCapture: Event[SyntheticClipboardEvent]
final def onCut: Event[SyntheticClipboardEvent]
final def onCutCapture: Event[SyntheticClipboardEvent]
final def onDblClick: Event[SyntheticMouseEvent]

React alias for onDoubleClick
final def onDoubleClick: Event[SyntheticMouseEvent]

The dblclick event is fired when a pointing device button (usually a mouse button) is clicked twice on a single element.
final def onDoubleClickCapture: Event[SyntheticMouseEvent]
final def onDrag: Event[SyntheticDragEvent]
final def onDragCapture: Event[SyntheticDragEvent]
final def onDragEnd: Event[SyntheticDragEvent]
final def onDragEndCapture: Event[SyntheticDragEvent]
final def onDragEnter: Event[SyntheticDragEvent]
final def onDragEnterCapture: Event[SyntheticDragEvent]
final def onDragExit: Event[SyntheticDragEvent]
final def onDragExitCapture: Event[SyntheticDragEvent]
final def onDragLeave: Event[SyntheticDragEvent]
final def onDragLeaveCapture: Event[SyntheticDragEvent]
final def onDragOver: Event[SyntheticDragEvent]
final def onDragOverCapture: Event[SyntheticDragEvent]
final def onDragStart: Event[SyntheticDragEvent]
final def onDragStartCapture: Event[SyntheticDragEvent]
final def onDrop: Event[SyntheticDragEvent]
final def onDropCapture: Event[SyntheticDragEvent]
final def onDurationChange: Event[SyntheticEvent]
final def onDurationChangeCapture: Event[SyntheticEvent]
final def onEmptied: Event[SyntheticEvent]
final def onEmptiedCapture: Event[SyntheticEvent]
final def onEncrypted: Event[SyntheticEvent]
final def onEncryptedCapture: Event[SyntheticEvent]
final def onEnded: Event[SyntheticEvent]
final def onEndedCapture: Event[SyntheticEvent]
final def onError: Event[SyntheticEvent]

Type: script code
Type: script code
This event is sent to an image element when an error occurs loading the image.
https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XUL/image#a-onerror
final def onErrorCapture: Event[SyntheticEvent]
final def onFocus: Event[SyntheticFocusEvent]

The focus event is raised when the user sets focus on the given element.
final def onFocusCapture: Event[SyntheticFocusEvent]
final def onGotPointerCapture: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named gotpointercapture when an element receives pointer capture.
A user agent MUST fire a pointer event named gotpointercapture when an element receives pointer capture. This event is fired at the element that is receiving pointer capture. Subsequent events for that pointer will be fired at this element.

Since
1.3.0 / React 16.4.0
final def onInput: Event[SyntheticEvent]
final def onInputCapture: Event[SyntheticEvent]
final def onInvalid: Event[SyntheticEvent]
final def onInvalidCapture: Event[SyntheticEvent]
final def onKeyDown: Event[SyntheticKeyboardEvent]

The keydown event is raised when the user presses a keyboard key.
final def onKeyDownCapture: Event[SyntheticKeyboardEvent]
final def onKeyPress: Event[SyntheticKeyboardEvent]

The keypress event should be raised when the user presses a key on the keyboard.
The keypress event should be raised when the user presses a key on the keyboard. However, not all browsers fire keypress events for certain keys.
Webkit-based browsers (Google Chrome and Safari, for example) do not fire keypress events on the arrow keys. Firefox does not fire keypress events on modifier keys like SHIFT.
final def onKeyPressCapture: Event[SyntheticKeyboardEvent]
final def onKeyUp: Event[SyntheticKeyboardEvent]

The keyup event is raised when the user releases a key that's been pressed.
final def onKeyUpCapture: Event[SyntheticKeyboardEvent]
final def onLoad: Event[SyntheticEvent]

The load event fires at the end of the document loading process.
The load event fires at the end of the document loading process. At this point, all of the objects in the document are in the DOM, and all the images and sub-frames have finished loading.
final def onLoadCapture: Event[SyntheticEvent]
final def onLoadStart: Event[SyntheticEvent]
final def onLoadStartCapture: Event[SyntheticEvent]
final def onLoadedData: Event[SyntheticEvent]
final def onLoadedDataCapture: Event[SyntheticEvent]
final def onLoadedMetadata: Event[SyntheticEvent]
final def onLoadedMetadataCapture: Event[SyntheticEvent]
final def onLostPointerCapture: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named lostpointercapture after pointer capture is released for a pointer.
A user agent MUST fire a pointer event named lostpointercapture after pointer capture is released for a pointer. This event MUST be fired prior to any subsequent events for the pointer after capture was released. This event is fired at the element from which pointer capture was removed. Subsequent events for the pointer follow normal hit testing mechanisms (out of scope for this specification) for determining the event target.

Since
1.3.0 / React 16.4.0
final def onMouseDown: Event[SyntheticMouseEvent]

The mousedown event is raised when the user presses the mouse button.
final def onMouseDownCapture: Event[SyntheticMouseEvent]
final def onMouseEnter: Event[SyntheticMouseEvent]

The mouseenter event is fired when a pointing device (usually a mouse) is moved over the element that has the listener attached.
final def onMouseLeave: Event[SyntheticMouseEvent]

The mouseleave event is fired when a pointing device (usually a mouse) is moved off the element that has the listener attached.
final def onMouseMove: Event[SyntheticMouseEvent]

The mousemove event is raised when the user moves the mouse.
final def onMouseMoveCapture: Event[SyntheticMouseEvent]
final def onMouseOut: Event[SyntheticMouseEvent]

The mouseout event is raised when the mouse leaves an element (e.g, when the mouse moves off of an image in the web page, the mouseout event is raised for that image element).
final def onMouseOutCapture: Event[SyntheticMouseEvent]
final def onMouseOver: Event[SyntheticMouseEvent]

The mouseover event is raised when the user moves the mouse over a particular element.
final def onMouseOverCapture: Event[SyntheticMouseEvent]
final def onMouseUp: Event[SyntheticMouseEvent]

The mouseup event is raised when the user releases the mouse button.
final def onMouseUpCapture: Event[SyntheticMouseEvent]
final def onPaste: Event[SyntheticClipboardEvent]
final def onPasteCapture: Event[SyntheticClipboardEvent]
final def onPause: Event[SyntheticEvent]
final def onPauseCapture: Event[SyntheticEvent]
final def onPlay: Event[SyntheticEvent]
final def onPlayCapture: Event[SyntheticEvent]
final def onPlaying: Event[SyntheticEvent]
final def onPlayingCapture: Event[SyntheticEvent]
final def onPointerCancel: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointercancel in the following circumstances:
A user agent MUST fire a pointer event named pointercancel in the following circumstances:
- The user agent has determined that a pointer is unlikely to continue to produce events (for example, because of a hardware event).
- After having fired the pointerdown event, if the pointer is subsequently used to manipulate the page viewport (e.g. panning or zooming). NOTE: User agents can trigger panning or zooming through multiple pointer types (such as touch and pen), and therefore the start of a pan or zoom action may result in the cancellation of various pointers, including pointers with different pointer types.
- Immediately before drag operation starts [HTML], for the pointer that caused the drag operation. NOTE: If the start of the drag operation is prevented through any means (e.g. through calling preventDefault on the dragstart event) there will be no pointercancel event.
After firing the pointercancel event, a user agent MUST also fire a pointer event named pointerout followed by firing a pointer event named pointerleave.
NOTE: This section is non-normative. Examples of scenarios in which a user agent might determine that a pointer is unlikely to continue to produce events include:
- A device's screen orientation is changed while a pointer is active.
- The user inputs a greater number of simultaneous pointers than is supported by the device.
- The user agent interprets the input as accidental (for example, the hardware supports palm rejection).
- The user agent interprets the input as a pan or zoom gesture. Methods for changing the device's screen orientation, recognizing accidental input, or using a pointer to manipulate the viewport (e.g. panning or zooming) are out of scope for this specification.
Since
1.3.0 / React 16.4.0
final def onPointerDown: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointerdown when a pointer enters the active buttons state.
A user agent MUST fire a pointer event named pointerdown when a pointer enters the active buttons state. For mouse, this is when the device transitions from no buttons depressed to at least one button depressed. For touch, this is when physical contact is made with the digitizer. For pen, this is when the pen either makes physical contact with the digitizer without any button depressed, or transitions from no buttons depressed to at least one button depressed while hovering.
NOTE: For mouse (or other multi-button pointer devices), this means pointerdown and pointerup are not fired for all of the same circumstances as mousedown and mouseup. See chorded buttons for more information.
For input devices that do not support hover, a user agent MUST also fire a pointer event named pointerover followed by a pointer event named pointerenter prior to dispatching the pointerdown event.
NOTE: Authors can prevent the firing of certain compatibility mouse events by canceling the pointerdown event (if the isPrimary property is true). This sets the PREVENT MOUSE EVENT flag on the pointer. Note, however, that this does not prevent the mouseover, mouseenter, mouseout, or mouseleave events from firing.

Since
1.3.0 / React 16.4.0
final def onPointerEnter: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointerenter when a pointing device is moved into the hit test boundaries of an element or one of its descendants, including as a result of a pointerdown event from a device that does not support hover (see pointerdown).
A user agent MUST fire a pointer event named pointerenter when a pointing device is moved into the hit test boundaries of an element or one of its descendants, including as a result of a pointerdown event from a device that does not support hover (see pointerdown). Note that setPointerCapture or releasePointerCapture might have changed the hit test target and while a pointer is captured it is considered to be always inside the boundaries of the capturing element for the purpose of firing boundary events. This event type is similar to pointerover, but differs in that it does not bubble.

Since
1.3.0 / React 16.4.0
final def onPointerLeave: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointerleave when a pointing device is moved out of the hit test boundaries of an element and all of its descendants, including as a result of a pointerup and pointercancel events from a device that does not support hover (see pointerup and pointercancel).
A user agent MUST fire a pointer event named pointerleave when a pointing device is moved out of the hit test boundaries of an element and all of its descendants, including as a result of a pointerup and pointercancel events from a device that does not support hover (see pointerup and pointercancel). Note that setPointerCapture or releasePointerCapture might have changed the hit test target and while a pointer is captured it is considered to be always inside the boundaries of the capturing element for the purpose of firing boundary events. User agents MUST also fire a pointer event named pointerleave when a pen stylus leaves hover range detectable by the digitizer. This event type is similar to pointerout, but differs in that it does not bubble and that it MUST not be fired until the pointing device has left the boundaries of the element and the boundaries of all of its descendants.
NOTE: There are similarities between this event type, the mouseleave event described in [UIEVENTS], and the CSS :hover pseudo-class described in [CSS21]. See also the pointerenter event.

Since
1.3.0 / React 16.4.0
final def onPointerMove: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointermove when a pointer changes coordinates.
A user agent MUST fire a pointer event named pointermove when a pointer changes coordinates. Additionally, when a pointer changes button state, pressure, tangential pressure, tilt, twist, or contact geometry (e.g. width and height) and the circumstances produce no other pointer events defined in this specification then a user agent MUST fire a pointer event named pointermove.

Since
1.3.0 / React 16.4.0
final def onPointerOut: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointerout when any of the following occurs:
A user agent MUST fire a pointer event named pointerout when any of the following occurs:
- A pointing device is moved out of the hit test boundaries of an element. Note that setPointerCapture or releasePointerCapture might have changed the hit test target and while a pointer is captured it is considered to be always inside the boundaries of the capturing element for the purpose of firing boundary events.
- After firing the pointerup event for a device that does not support hover (see pointerup).
- After firing the pointercancel event (see pointercancel).
- When a pen stylus leaves the hover range detectable by the digitizer.
Since
1.3.0 / React 16.4.0
final def onPointerOver: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointerover when a pointing device is moved into the hit test boundaries of an element.
A user agent MUST fire a pointer event named pointerover when a pointing device is moved into the hit test boundaries of an element. Note that setPointerCapture or releasePointerCapture might have changed the hit test target and while a pointer is captured it is considered to be always inside the boundaries of the capturing element for the purpose of firing boundary events. A user agent MUST also fire this event prior to firing a pointerdown event for devices that do not support hover (see pointerdown).

Since
1.3.0 / React 16.4.0
final def onPointerUp: Event[SyntheticPointerEvent]

A user agent MUST fire a pointer event named pointerup when a pointer leaves the active buttons state.
A user agent MUST fire a pointer event named pointerup when a pointer leaves the active buttons state. For mouse, this is when the device transitions from at least one button depressed to no buttons depressed. For touch, this is when physical contact is removed from the digitizer. For pen, this is when the pen is removed from the physical contact with the digitizer while no button is depressed, or transitions from at least one button depressed to no buttons depressed while hovering.
For input devices that do not support hover, a user agent MUST also fire a pointer event named pointerout followed by a pointer event named pointerleave after dispatching the pointerup event.
NOTE: For mouse (or other multi-button pointer devices), this means pointerdown and pointerup are not fired for all of the same circumstances as mousedown and mouseup. See chorded buttons for more information.

Since
1.3.0 / React 16.4.0
final def onProgress: Event[SyntheticEvent]
final def onProgressCapture: Event[SyntheticEvent]
final def onRateChange: Event[SyntheticEvent]
final def onRateChangeCapture: Event[SyntheticEvent]
final def onReset: Event[SyntheticEvent]

The reset event is fired when a form is reset.
final def onResetCapture: Event[SyntheticEvent]
final def onScroll: Event[SyntheticUIEvent]

Specifies the function to be called when the window is scrolled.
final def onScrollCapture: Event[SyntheticUIEvent]
final def onSeeked: Event[SyntheticEvent]
final def onSeekedCapture: Event[SyntheticEvent]
final def onSeeking: Event[SyntheticEvent]
final def onSeekingCapture: Event[SyntheticEvent]
final def onSelect: Event[SyntheticEvent]

The select event only fires when text inside a text input or textarea is selected.
The select event only fires when text inside a text input or textarea is selected. The event is fired after the text has been selected.
final def onStalled: Event[SyntheticEvent]
final def onStalledCapture: Event[SyntheticEvent]
final def onSubmit: Event[SyntheticEvent]

The submit event is raised when the user clicks a submit button in a form ().
The submit event is raised when the user clicks a submit button in a form ().
final def onSubmitCapture: Event[SyntheticEvent]
final def onSuspend: Event[SyntheticEvent]
final def onSuspendCapture: Event[SyntheticEvent]
final def onTimeUpdate: Event[SyntheticEvent]
final def onTimeUpdateCapture: Event[SyntheticEvent]
final def onTouchCancel: Event[SyntheticTouchEvent]

Event indicating that the touch point has been canceled or disrupted.
Event indicating that the touch point has been canceled or disrupted.
For example, when popup menu is shown.
final def onTouchCancelCapture: Event[SyntheticTouchEvent]
final def onTouchEnd: Event[SyntheticTouchEvent]

Event indicating that the touch point does not exist any more.
Event indicating that the touch point does not exist any more.
For example, whn you release your finger.
final def onTouchEndCapture: Event[SyntheticTouchEvent]
final def onTouchMove: Event[SyntheticTouchEvent]

Event indicating that the touch point has moved along the plane.
final def onTouchMoveCapture: Event[SyntheticTouchEvent]
final def onTouchStart: Event[SyntheticTouchEvent]

Event indicating that the user has touched the plane.
final def onTouchStartCapture: Event[SyntheticTouchEvent]
final def onTransitionEnd: Event[SyntheticTransitionEvent]
final def onTransitionEndCapture: Event[SyntheticTransitionEvent]
final def onVolumeChange: Event[SyntheticEvent]
final def onVolumeChangeCapture: Event[SyntheticEvent]
final def onWaiting: Event[SyntheticEvent]
final def onWaitingCapture: Event[SyntheticEvent]
final def onWheel: Event[SyntheticWheelEvent]
final def onWheelCapture: Event[SyntheticWheelEvent]
final def open: Attr[Boolean]
final def optimum: Attr[Any]

For use in <meter> tags.
For use in <meter> tags.

See also
https://css-tricks.com/html5-meter-element/
final def placeholder: Attr[Any]

A hint to the user of what can be entered in the control.
A hint to the user of what can be entered in the control. The placeholder text must not contain carriage returns or line-feeds. This attribute applies when the value of the type attribute is text, search, tel, url or email; otherwise it is ignored.
final def playsInline: Attr[Boolean]
final def poster: Attr[Any]
final def preload: Attr[Any]
final def profile: Attr[Any]
final def radioGroup: Attr[String]
final def readOnly: Attr[Boolean]

This Boolean attribute indicates that the user cannot modify the value of the control.
This Boolean attribute indicates that the user cannot modify the value of the control. This attribute is ignored if the value of the type attribute is hidden, range, color, checkbox, radio, file, or a button type.
final def rel: Attr[Any]

This attribute names a relationship of the linked document to the current document.
This attribute names a relationship of the linked document to the current document. The attribute must be a space-separated list of the link types values. The most common use of this attribute is to specify a link to an external style sheet: the rel attribute is set to stylesheet, and the href attribute is set to the URL of an external style sheet to format the page.
final def required: Attr[Boolean]

This attribute specifies that the user must fill in a value before submitting a form.
This attribute specifies that the user must fill in a value before submitting a form. It cannot be used when the type attribute is hidden, image, or a button type (submit, reset, or button). The :optional and :required CSS pseudo-classes will be applied to the field as appropriate.
final def results: Attr[Any]
final def reversed: Attr[Boolean]

For <ol> elements.
final def role: Attr[String]

The attribute describes the role(s) the current element plays in the context of the document.
The attribute describes the role(s) the current element plays in the context of the document. This can be used, for example, by applications and assistive technologies to determine the purpose of an element. This could allow a user to make informed decisions on which actions may be taken on an element and activate the selected action in a device independent way. It could also be used as a mechanism for annotating portions of a document in a domain specific way (e.g., a legal term taxonomy). Although the role attribute may be used to add semantics to an element, authors should use elements with inherent semantics, such as p, rather than layering semantics on semantically neutral elements, such as div role="paragraph".

See also
http://www.w3.org/TR/role-attribute/#s_role_module_attributes
final def rowSpan: Attr[Int]
final def rows: Attr[Int]

The number of visible text lines for the control.
final def sandbox: Attr[Any]
final def scope: Attr[Any]
final def scoped: Attr[Boolean]

For use in <style> tags.
For use in <style> tags.
If this attribute is present, then the style applies only to its parent element. If absent, the style applies to the whole document.
final def scrolling: Attr[Any]
final def seamless: Attr[Boolean]
final def security: Attr[Any]
final def selected: Attr[Boolean]
final def shape: Attr[Any]
final def size: Attr[Int]

The initial size of the control.
The initial size of the control. This value is in pixels unless the value of the type attribute is text or password, in which case, it is an integer number of characters. Starting in HTML5, this attribute applies only when the type attribute is set to text, search, tel, url, email, or password; otherwise it is ignored. In addition, the size must be greater than zero. If you don't specify a size, a default value of 20 is used.
final def sizes: Attr[Any]
final def spellCheck: Attr[Any]

This enumerated attribute defines whether the element may be checked for spelling errors.
final val src: Attr[String]

If the value of the type attribute is image, this attribute specifies a URI for the location of an image to display on the graphical submit button; otherwise it is ignored.
final def srcDoc: Attr[Any]
final def srcLang: Attr[Any]
final def srcSet: Attr[Any]
final def step: Attr[Any]
final def style: Attr[Object]

This attribute contains CSS styling declarations to be applied to the element.
This attribute contains CSS styling declarations to be applied to the element. Note that it is recommended for styles to be defined in a separate file or files. This attribute and the style element have mainly the purpose of allowing for quick styling, for example for testing purposes.
final def summaryAttr: Attr[Any]

The value is actually just summary.
The value is actually just summary. This is named summaryAttr in Scala to avoid a conflict with the <summary> tag in all.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def tabIndex: Attr[Int]

This integer attribute indicates if the element can take input focus (is focusable), if it should participate to sequential keyboard navigation, and if so, at what position.
This integer attribute indicates if the element can take input focus (is focusable), if it should participate to sequential keyboard navigation, and if so, at what position. It can takes several values:
- a negative value means that the element should be focusable, but should not be reachable via sequential keyboard navigation; - 0 means that the element should be focusable and reachable via sequential keyboard navigation, but its relative order is defined by the platform convention; - a positive value which means should be focusable and reachable via sequential keyboard navigation; its relative order is defined by the value of the attribute: the sequential follow the increasing number of the tabIndex. If several elements share the same tabIndex, their relative order follows their relative position in the document).
An element with a 0 value, an invalid value, or no tabIndex value should be placed after elements with a positive tabIndex in the sequential keyboard navigation order.
object target extends Generic[String]

A name or keyword indicating where to display the response that is received after submitting the form.
A name or keyword indicating where to display the response that is received after submitting the form. In HTML 4, this is the name of, or a keyword for, a frame. In HTML5, it is a name of, or keyword for, a browsing context (for example, tab, window, or inline frame). The following keywords have special meanings:
- _self: Load the response into the same HTML 4 frame (or HTML5 browsing context) as the current one. This value is the default if the attribute is not specified. - _blank: Load the response into a new unnamed HTML 4 window or HTML5 browsing context. - _parent: Load the response into the HTML 4 frameset parent of the current frame or HTML5 parent browsing context of the current one. If there is no parent, this option behaves the same way as _self. - _top: HTML 4: Load the response into the full, original window, canceling all other frames. HTML5: Load the response into the top-level browsing context (that is, the browsing context that is an ancestor of the current one, and has no parent). If there is no parent, this option behaves the same way as _self. - iframename: The response is displayed in a named iframe.
final val title: Attr[String]

This attribute contains a text representing advisory information related to the element it belongs too.
This attribute contains a text representing advisory information related to the element it belongs too. Such information can typically, but not necessarily, be presented to the user as a tooltip.
def toString(): String

Definition Classes
AnyRef → Any
final def tpe: Attr[Any]

Shorthand for the type attribute
final val type: Attr[Any]

This attribute is used to define the type of the content linked to.
This attribute is used to define the type of the content linked to. The value of the attribute should be a MIME type such as text/html, text/css, and so on. The common use of this attribute is to define the type of style sheet linked and the most common current value is text/css, which indicates a Cascading Style Sheet format. You can use tpe as an alias for this attribute so you don't have to backtick-escape this attribute.
final def unselectable: Attr[Any]

IE-specific property to prevent user selection
final def untypedRef: Attr.Ref.type
final def useMap: Attr[Any]
final val value: Attr[Any]

The initial value of the control.
The initial value of the control. This attribute is optional except when the value of the type attribute is radio or checkbox.
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wmode: Attr[Any]
object wrap extends Generic[Any]

<textarea>: Indicates whether the text should be wrapped.
final def xmlns: Attr[Any]

Related Docs: object HtmlAttrs | package vdom

trait HtmlAttrs extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def accept: Attr[Any]

final def acceptCharset: Attr[Any]

final def accessKey: Attr[Any]

final def action: Attr[Any]

final def allowFullScreen: Attr[Boolean]

final def allowTransparency: Attr[Boolean]

final def alt: Attr[String]

object aria

final def asInstanceOf[T0]: T0

final def async: Attr[Boolean]

final def autoCapitalize: Attr[Any]

object autoComplete extends Generic[Any]

final def autoCorrect: Attr[Boolean]

final def autoFocus: Attr[Boolean]

final def autoPlay: Attr[Boolean]

final def autoSave: Attr[Boolean]

final def capture: Attr[Any]

final def cellPadding: Attr[Any]

final def cellSpacing: Attr[Any]

final def challenge: Attr[Any]

final def charset: Attr[String]

final def checked: Attr[Boolean]

final def citeAttr: Attr[Any]

final def class: Attr[String]

final def classID: Attr[Any]

final def className: Attr[String]

final def classSet(ps: (String, Boolean)*): TagMod

final def classSet1(a: String, ps: (String, Boolean)*): TagMod

final def classSet1M(a: String, ps: Map[String, Boolean]): TagMod

final def classSetM(ps: Map[String, Boolean]): TagMod

def clone(): AnyRef

final def cls: Attr[String]

final def colSpan: Attr[Int]

final def cols: Attr[Any]

final def contentAttr: Attr[Any]

final def contentEditable: Attr[Any]

final def contextMenu: Attr[Any]

final def controls: Attr[Boolean]

final def coords: Attr[Any]

final def crossOrigin: Attr[Any]

final def dangerouslySetInnerHtml: Attr[InnerHtmlAttr]

final def dateTime: Attr[Any]

final def default: Attr[Boolean]

final def defaultValue: Attr[Any]

final def defer: Attr[Boolean]

final def dir: Attr[Any]

final def disabled: Attr[Boolean]

final def download: Attr[Any]

final def draggable: Attr[Boolean]

final def encType: Attr[Any]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def for: Attr[Any]

final def formAction: Attr[Any]

final def formEncType: Attr[Any]

final def formId: Attr[Any]

final def formMethod: Attr[Any]

final def formNoValidate: Attr[Boolean]

final def formTarget: Attr[Any]

final def frameBorder: Attr[Any]

final def getClass(): Class[_]

def hashCode(): Int

final def headers: Attr[Any]

final def hidden: Attr[Boolean]

final def high: Attr[Any]

final def href: Attr[String]

final def hrefLang: Attr[Any]

final def htmlFor: Attr[Any]

final def httpEquiv: Attr[Any]

final def icon: Attr[Any]

final def id: Attr[Any]

final def inputMode: Attr[Any]