Text

abstract val rendered: Input

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def append(widget: Widget[_]): Unit

Adds child widget

final def asInstanceOf[T0]: T0

def attach(f: (String) ⇒ Unit): Text[V] with V

def attachEnter(f: (String) ⇒ Unit): Text[V] with V

def attribute(key: String, value: ReadChannel[String]): V

def attribute(key: String, value: String): V

def attributeOpt(key: String, value: PartialChannel[String]): V

lazy val attributes: Dict[String, String]

def bind(ch: Channel[String]): Text[V] with V

def bindEnter(ch: Channel[String]): Text[V] with V

lazy val blur: Channel[Event]

lazy val change: Channel[Event]

lazy val className: Buffer[String]

def clear(value: ReadChannel[Clear]): V

def clear(value: Clear): V

lazy val click: Channel[MouseEvent]

def clone(): AnyRef

lazy val contextMenu: Channel[MouseEvent]

def css(tags: ReadChannel[Seq[String]]): V

def css(cssTags: String*): V

def cssState(state: ReadChannel[Boolean], cssTags: String*): V

def cssState(state: Boolean, cssTags: String*): V

def cursor(cursor: ReadChannel[Cursor]): V

def cursor(cursor: Cursor): V

lazy val doubleClick: Channel[MouseEvent]

lazy val drag: Channel[DragEvent]

lazy val dragEnd: Channel[DragEvent]

lazy val dragEnter: Channel[DragEvent]

lazy val dragLeave: Channel[DragEvent]

lazy val dragOver: Channel[DragEvent]

lazy val dragStart: Channel[DragEvent]

lazy val drop: Channel[DragEvent]

def enabled(value: ReadChannel[Boolean]): V

def enabled(value: Boolean): V

lazy val enterValue: StateChannel[String] with ChannelDefaultSize[String] { ... /* 2 definitions in type refinement */ }

Produce current value after enter was pressed.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def float(value: ReadChannel[Floating]): V

def float(value: Floating): V

def focus(): V

final def getClass(): Class[_]

def hashCode(): Int

def height(height: ReadChannel[Length]): V

def height(height: Length): V

def hide(value: ReadChannel[Boolean]): V

def hide(value: Boolean): V

def id(value: ReadChannel[String]): V

def id(value: String): V

def invisible(value: ReadChannel[Boolean]): V

def invisible(value: Boolean): V

final def isInstanceOf[T0]: Boolean

lazy val keyDown: Channel[KeyboardEvent]

lazy val keyPress: Channel[KeyboardEvent]

lazy val keyUp: Channel[KeyboardEvent]

lazy val mouseDown: Channel[MouseEvent]

lazy val mouseEnter: Channel[MouseEvent]

lazy val mouseLeave: Channel[MouseEvent]

lazy val mouseMove: Channel[MouseEvent]

lazy val mouseOut: Channel[MouseEvent]

lazy val mouseOver: Channel[MouseEvent]

lazy val mouseUp: Channel[MouseEvent]

final def ne(arg0: AnyRef): Boolean

lazy val nodeId: Opt[String]

final def notify(): Unit

final def notifyAll(): Unit

def onChange(f: (Event) ⇒ Unit): Widget[V] with V

def onClick(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onContextMenu(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onDoubleClick(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onDrag(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onDragEnd(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onDragEnter(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onDragLeave(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onDragOver(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onDragStart(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onDrop(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onKeyDown(f: (KeyboardEvent) ⇒ Unit): Widget[V] with V

def onKeyPress(f: (KeyboardEvent) ⇒ Unit): Widget[V] with V

def onKeyUp(f: (KeyboardEvent) ⇒ Unit): Widget[V] with V

def onMouseDown(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onMouseEnter(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onMouseLeave(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onMouseMove(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onMouseOut(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onMouseOver(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onMouseUp(f: (MouseEvent) ⇒ Unit): Widget[V] with V

def onPaste(f: (DragEvent) ⇒ Unit): Widget[V] with V

def onSubmit(f: (Event) ⇒ Unit): Widget[V] with V

def onTouchEnd(f: (TouchEvent) ⇒ Unit): Widget[V] with V

def onTouchMove(f: (TouchEvent) ⇒ Unit): Widget[V] with V

def onTouchStart(f: (TouchEvent) ⇒ Unit): Widget[V] with V

def overflow(value: ReadChannel[Overflow]): V

def overflow(value: Overflow): V

lazy val paste: Channel[DragEvent]

def relativeCoordinates: Coordinates

Coordinates relative to the padding box of offsetParent

def remove(widget: Widget[_]): Unit

Removes child widget

def render(parent: scalajs.dom.Node, offset: scalajs.dom.Node): Unit

def show(value: ReadChannel[Boolean]): V

def show(value: Boolean): V

lazy val style: CSSStyle

lazy val submit: Channel[Event]

def subscribe(ch: ReadChannel[String]): Text[V] with V

def subscribeEnter(ch: ReadChannel[String]): Text[V] with V

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

def tabIndex(value: ReadChannel[Int]): V

def tabIndex(value: Int): V

def title(value: ReadChannel[String]): V

def title(value: String): V

def toString(): String

lazy val touchEnd: Channel[TouchEvent]

lazy val touchMove: Channel[TouchEvent]

lazy val touchStart: Channel[TouchEvent]

lazy val value: StateChannel[String] with ChannelDefaultSize[String] { ... /* 2 definitions in type refinement */ }

Produce current value after every key press.

def visible(value: ReadChannel[Boolean]): V

def visible(value: Boolean): V

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def width(width: ReadChannel[Length]): V

def width(width: Length): V