GlobalAttrs

implicit abstract def SeqFrag[A](xs: Seq[A])(implicit ev: (A) ⇒ Frag[Builder, FragT]): Frag[Builder, FragT]

Renders an Seq of FragT into a single FragT

implicit abstract def UnitFrag(u: Unit): Frag[Builder, FragT]

Lets you put Unit into a scalatags tree, as a no-op.

abstract def makeAbstractTypedTag[T <: Output](tag: String, void: Boolean, namespaceConfig: Namespace): ConcreteHtmlTag[T]

implicit abstract def stringAttrX: AttrValue[Builder, String]

implicit abstract def stringPixelStyleX: PixelStyleValue[Builder, String]

implicit abstract def stringStyleX: StyleValue[Builder, String]

abstract def tag(s: String, void: Boolean = false): TypedTag[Builder, Output, FragT]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def ArrayFrag[A](xs: Array[A])(implicit ev: (A) ⇒ Frag[Builder, FragT]): Frag[Builder, FragT]

Renders an Seq of FragT into a single FragT

implicit def ArrayNode[A](xs: Array[A])(implicit ev: (A) ⇒ Modifier[Builder]): SeqNode[A]

Allows you to modify a ConcreteHtmlTag by adding an Array containing other nest-able objects to its list of children.

implicit def OptionFrag[A](xs: Option[A])(implicit ev: (A) ⇒ Frag[Builder, FragT]): Frag[Builder, FragT]

Renders an Option of FragT into a single FragT

implicit def OptionNode[A](xs: Option[A])(implicit ev: (A) ⇒ Modifier[Builder]): SeqNode[A]

Allows you to modify a ConcreteHtmlTag by adding an Option containing other nest-able objects to its list of children.

lazy val accesskey: Attr

Specifies a shortcut key to activate/focus an element

final def asInstanceOf[T0]: T0

def attr(s: String, ns: Namespace = null, raw: Boolean = false): Attr

Constructs an Attr attribute object from a string; can be used inline:

div(
  attr("hello-world-special-attr") := "foo
)

val hello = attr("hello-world-special-attr")
div(
  hello := "foo
)

lazy val class: Attr

This attribute is a space-separated list of the classes of the element.

def clone(): AnyRef

lazy val cls: Attr

Shorthand for the class attribute

lazy val contenteditable: Attr

lazy val contextmenu: Attr

def css(s: String): Style

Constructs a CSS Style from a string, can be used inline

div(
  css("-moz-special-style") := "foo"
)

val mozSpecial := css("-moz-special-style")
div(
  mozSpecial := "foo"
)

def data(suffix: String): Attr

object data extends DataAttribute

This class of attributes, called custom data attributes, allows proprietary information to be exchanged between the HTML and its DOM representation that may be used by scripts.

lazy val dir: Attr

Specifies the text direction for the content in an element.

lazy val draggable: AttrPair[Builder, String]

A Boolean attribute that specifies whether an element is draggable or not

lazy val dropzone: Attr

Specifies whether the dragged data is copied, moved, or linked, when dropped

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def frag(frags: Frag[Builder, FragT]*): Frag[Builder, FragT]

final def getClass(): Class[_]

def hashCode(): Int

lazy val hidden: AttrPair[Builder, String]

Specifies that an element is not yet, or is no longer, relevant and consequently hidden from view of the user.

lazy val id: Attr

This attribute defines a unique identifier (ID) which must be unique in the whole document.

final def isInstanceOf[T0]: Boolean

lazy val lang: Attr

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.

def modifier(mods: Modifier[Builder]*): Modifier[Builder]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val spellcheck: AttrPair[Builder, String]

This enumerated attribute defines whether the element may be checked for spelling errors.

lazy val style: Attr

This attribute contains CSS styling declarations to be applied to the element.

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

lazy val tabindex: Attr

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.

lazy val title: Attr

This attribute contains a text representing advisory information related to the element it belongs too.

def toString(): String

lazy val translate: AttrPair[Builder, String]

Specifies whether the content of an element should be translated or not

final def wait(): Unit

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

final def wait(arg0: Long): Unit