IdentifiableTag

abstract def outputString: String

abstract def xmlLabel: String

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var _attributes: ListMap[String, PropertyAttribute[_]]

def addAttribute(attribute: PropertyAttribute[_]): Unit

def after(): Unit

Invoked immediately after writing this markup out.

def applyAttribute(a: Attribute): Unit

final def asInstanceOf[T0]: T0

def attribute[T](name: String, create: Boolean = false)(implicit persister: ValuePersistence[T], manifest: Manifest[T]): Option[PropertyAttribute[T]]

def attributeFromXML(a: Attribute): Boolean

def attributes: Map[String, PropertyAttribute[_]]

def before(): Unit

Invoked immediately before writing this markup out.

implicit val booleanPersistence: BooleanPersistence.type

def byId[T <: Tag](id: String)(implicit manifest: Manifest[T]): Option[T]

def byTag[T <: Tag](implicit manifest: Manifest[T]): Stream[T]

def byType[T](implicit manifest: Manifest[T]): Stream[T]

def checkInit(): Unit

Iterate over everything

def clone(): AnyRef

def connected[Ancestor](f: (Ancestor) ⇒ Unit)(implicit manifest: Manifest[Ancestor]): Unit

def data(name: String, value: String): Unit

def data(name: String): Option[String]

def dataAttribute(name: String): PropertyAttribute[String]

Gets or creates a data attribute (data-<name>) and returns the property attribute.

def dataAttributes: List[PropertyAttribute[_]]

def dataWrapper[T](name: String, initial: T, prop: Option[Property[T]] = None)(converter: (T) ⇒ String)(implicit parent: Listenable = null, manifest: Manifest[T]): Property[T]

Creates a type-safe wrapper around a data attribute by name.

def debug(message: ⇒ Any): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(message: ⇒ Any, t: Throwable): Unit

def error(message: ⇒ Any): Unit

val eventReceived: EventReceivedProcessor

def finalize(): Unit

def getAttribute(name: String): Option[PropertyAttribute[_]]

def getById[T <: Tag](id: String)(implicit manifest: Manifest[T]): T

final def getClass(): Class[_]

def handle[E <: BrowserEvent](f: (E) ⇒ Unit, condition: (E) ⇒ Boolean = (e: E) => true, intercept: Intercept = Intercept.Stop)(implicit manifest: Manifest[E]): Unit

Convenience method to inject support for received ClientEvents of a specific type.

def hashCode(): Int

var hierarchicalParent: Any

val id: PropertyAttribute[String]

def identity: String

Gets the id value and sets it to a unique value if it's null.

def info(message: ⇒ Any): Unit

def initialize(): Unit

def initialized: Boolean

true if this Markup has been initialized.

final def isInstanceOf[T0]: Boolean

def listen[Event, Response, Result](name: String, priority: Priority, modes: ListenMode*)(f: (Event) ⇒ Response)(implicit eventManifest: Manifest[Event]): FunctionalListener[Event, Response]

val listeners: Listeners

def log(level: Level, message: ⇒ Any): Unit

def logger: Logger

def loggerName: String

lazy val name: PropertyAttribute[String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onAfterRender(f: ⇒ Unit): Unit

Invokes the function before rendering of this markup.

def onBeforeRender(f: ⇒ Unit): Unit

Invokes the function before rendering of this markup.

def onInit(f: ⇒ Unit): Unit

Invokes the supplied function upon init or immediately if this Markup has already been initialized.

def parent: Any

def read(content: Content): Unit

def removeFromParent(): Boolean

def render: Boolean

lazy val renderTag: PropertyAttribute[Boolean]

def renderable: Boolean

Recursively walks up the DOM validating the 'render' state on its parents returning true only if all parents have the 'render' value set to true.

def rendered: Boolean

true if this Markup has been rendered.

def replaceWith[T <: XMLContent](content: T): T

def root[T](implicit manifest: Manifest[T]): Option[T]

implicit val stringPersistence: StringPersistence.type

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

lazy val tagCreated: StandardHierarchyEventProcessor[TagCreated]

implicit val thisListenable: Listenable

implicit val thisTag: Tag

def toString(): String

def trace(message: ⇒ Any): Unit

def unsupportedAttribute(name: String, value: String): Unit

def up(attribute: ⇒ PropertyAttribute[Boolean], value: Boolean): Unit

def up(attribute: ⇒ PropertyAttribute[Char], value: Character): Unit

def up(attribute: ⇒ PropertyAttribute[Int], value: Integer): Unit

def up(attribute: ⇒ PropertyAttribute[Double], value: Double): Unit

def up[T](attribute: ⇒ PropertyAttribute[T], value: T): Unit

Updates attribute with value if it's not null.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(message: ⇒ Any, t: Throwable): Unit

def warn(message: ⇒ Any): Unit

def write(writer: HTMLWriter): Unit

def writeAttribute(writer: HTMLWriter, attribute: XMLAttribute): Unit

def writeChild(writer: HTMLWriter, child: XMLContent): Unit

final def writeChildren(writer: HTMLWriter, children: Seq[XMLContent]): Unit

def writeExtra(writer: HTMLWriter): Unit

def writeTag(writer: HTMLWriter): Unit

def xmlAttributes: Iterable[PropertyAttribute[_]]

def xmlChildren: Seq[XMLContent]

def xmlExpanded: Boolean

True if tag should never be self-closing even if there are no children.