Textual

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): Widget.Input.Text[T] with T

def attachEnter(f: (String) ⇒ Unit): Widget.Input.Text[T] with T

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

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

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

lazy val attributes: Dict[String, String]

def autofocus(value: Boolean): T

def bind(ch: Channel[String]): Widget.Input.Text[T] with T

def bindEnter(ch: Channel[String]): Widget.Input.Text[T] with T

lazy val blur: Channel[Event]

lazy val change: Channel[Event]

lazy val className: Buffer[String]

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

def clear(value: Clear): T

lazy val click: Channel[MouseEvent]

def clone(): AnyRef

lazy val contextMenu: Channel[MouseEvent]

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

def css(cssTags: String*): T

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

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

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

def cursor(cursor: Cursor): T

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]): T

def enabled(value: Boolean): T

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]): T

def float(value: Floating): T

def focus(): T

final def getClass(): Class[_]

def hashCode(): Int

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

def height(height: Length): T

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

def hide(value: Boolean): T

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

def id(value: String): T

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

def invisible(value: Boolean): T

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[T] with T

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def overflow(value: Overflow): T

lazy val paste: Channel[DragEvent]

def placeholder(value: ReadChannel[String]): T

def placeholder(value: String): T

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]): T

def show(value: Boolean): T

lazy val style: CSSStyle

lazy val submit: Channel[Event]

def subscribe(ch: ReadChannel[String]): Widget.Input.Text[T] with T

def subscribeEnter(ch: ReadChannel[String]): Widget.Input.Text[T] with T

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

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

def tabIndex(value: Int): T

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

def title(value: String): T

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]): T

def visible(value: Boolean): T

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def width(width: Length): T