Bindings

Type Members

implicit final class InlineStyleOps[T] extends AnyRef

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 val CheckButtons: inputs.CheckButtons.type
final val Checkbox: inputs.Checkbox.type
final val FileInput: inputs.FileInput.type
final val NumberInput: inputs.NumberInput.type
final val PasswordInput: inputs.PasswordInput.type
final val RadioButtons: inputs.RadioButtons.type
final val RangeInput: inputs.RangeInput.type
final val Select: inputs.Select.type
final val TextArea: inputs.TextArea.type
final val TextInput: inputs.TextInput.type
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bind[T](property: properties.single.ReadableProperty[T]): Binding

Use it to bind value of property into DOM structure.
Use it to bind value of property into DOM structure. Value of the property will be rendered as text node. (Using .toString method.) If property value is null, empty text node will be added.
property
Property to bind.
returns
property binding.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def emptyStringNode(): Node

Creates empty text node, which is useful as placeholder.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def produce[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]], customElementsReplace: ReplaceMethod)(builder: (Seq[T]) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change. Notice that on every property change, whole element representing property will be rendered again.
property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
builder
Element builder which will be used to create HTML element. Seq passed to the builder can not be null.
returns
property binding.
def produce[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]])(builder: (Seq[T]) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change. Notice that on every property change, whole element representing property will be rendered again.
property
Property to bind.
builder
Element builder which will be used to create HTML element. Seq passed to the builder cannot be null.
returns
property binding.
def produce[T](property: properties.single.ReadableProperty[T], customElementsReplace: ReplaceMethod, checkNull: Boolean)(builder: (T) ⇒ Seq[Node]): Binding

Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change. If property value is null, empty text node will be added as placeholder.
property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
checkNull
if it is true, then null value of property will result in rendering empty text node. if it is false, then null value has to be handled by builder.
builder
Element builder which will be used to create HTML element.
returns
property binding.
def produce[T](property: properties.single.ReadableProperty[T], checkNull: Boolean = true)(builder: (T) ⇒ Seq[Node]): Binding

Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change. If property value is null, empty text node will be added as placeholder.
property
Property to bind.
checkNull
if it is true, then null value of property will result in rendering empty text node. if it is false, then null value has to be handled by builder.
builder
Element builder which will be used to create HTML element.
returns
property binding.
def produceWithNested[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]], customElementsReplace: ReplaceMethod)(builder: (Seq[T], NestedInterceptor) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change. Notice that on every property change, whole element representing property will be rendered again.

The builder takes nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
builder
Element builder which will be used to create HTML element. Seq passed to the builder can not be null.
returns
property binding.
def produceWithNested[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]])(builder: (Seq[T], NestedInterceptor) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind sequence property into DOM structure, given builder will be used to generate DOM element on every value change. Notice that on every property change, whole element representing property will be rendered again.

The builder takes nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

property
Property to bind.
builder
Element builder which will be used to create HTML element. Seq passed to the builder can not be null.
returns
property binding.
def produceWithNested[T](property: properties.single.ReadableProperty[T], customElementsReplace: ReplaceMethod, checkNull: Boolean)(builder: (T, NestedInterceptor) ⇒ Seq[Node]): Binding

Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change. If property value is null, empty text node will be added as placeholder.

The builder takes nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

For example:
```
produceWithNested(property) { case (data, nested) =>
  div(data, nested(produce(anotherProperty) { innerData => span(innerData).render })).render
}
```
property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
checkNull
if it is true, then null value of property will result in rendering empty text node. if it is false, then null value has to be handled by builder.
builder
Element builder which will be used to create HTML element.
returns
property binding.
def produceWithNested[T](property: properties.single.ReadableProperty[T], checkNull: Boolean = true)(builder: (T, NestedInterceptor) ⇒ Seq[Node]): Binding

Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change.
Use it to bind property into DOM structure, given builder will be used to generate DOM element on every value change. If property value is null, empty text node will be added as placeholder.

The builder takes nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

For example:
```
produceWithNested(property) { case (data, nested) =>
  div(data, nested(produce(anotherProperty) { innerData => span(innerData).render })).render
}
```
property
Property to bind.
checkNull
if it is true, then null value of property will result in rendering empty text node. if it is false, then null value has to be handled by builder.
builder
Element builder which will be used to create HTML element.
returns
property binding.
def queuedNode(component: ⇒ Seq[Node], timeout: Int = 0): Modifier[Element]

Renders component with provided timeout.
Renders component with provided timeout. It's useful to render heavy components after displaying the main view.
def repeat[T, E <: properties.single.ReadableProperty[T]](property: properties.seq.ReadableSeqProperty[T, E], customElementsReplace: ReplaceMethod = ..., customElementsInsert: InsertMethod = DOMManipulator.DefaultElementInsert)(builder: (E) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure.
Use it to bind sequence property into DOM structure. This method cares about adding new elements which appears in sequence and also removes those which were removed. You only need to provide builder which is used to create HTML element for each sequence member.
Note: This will handle only structure changes, if you want to handle concrete subproperties changes, you should use another binding method inside builder.
property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
customElementsInsert
takes root element, ref node and new children. It should return true, if it does not insert elements in DOM. Is such a case the default implementation will insert the elements. Otherwise you have to insert elements in DOM manually.
builder
Builder which is used for every element.
returns
property binding.
def repeatWithIndex[T, E <: properties.single.ReadableProperty[T]](property: properties.seq.ReadableSeqProperty[T, E], customElementsReplace: ReplaceMethod = ..., customElementsInsert: InsertMethod = DOMManipulator.DefaultElementInsert)(builder: (E, properties.single.ReadableProperty[Int], NestedInterceptor) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure.
Use it to bind sequence property into DOM structure. This method cares about adding new elements which appears in sequence and also removes those which were removed. You only need to provide builder which is used to create HTML element for each sequence member. This modifier provides also property with element index in sequence.
Note: This will handle only structure changes, if you want to handle concrete subproperties changes, you should use another binding method inside builder.

The builder takes nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
customElementsInsert
takes root element, ref node and new children. It should return true, if it does not insert elements in DOM. Is such a case the default implementation will insert the elements. Otherwise you have to insert elements in DOM manually.
builder
Builder which is used for every element.
returns
property binding.
def repeatWithNested[T, E <: properties.single.ReadableProperty[T]](property: properties.seq.ReadableSeqProperty[T, E], customElementsReplace: ReplaceMethod = ..., customElementsInsert: InsertMethod = DOMManipulator.DefaultElementInsert)(builder: (E, NestedInterceptor) ⇒ Seq[Node]): Binding

Use it to bind sequence property into DOM structure.
Use it to bind sequence property into DOM structure. This method cares about adding new elements which appears in sequence and also removes those which were removed. You only need to provide builder which is used to create HTML element for each sequence member.
Note: This will handle only structure changes, if you want to handle concrete subproperties changes, you should use another binding method inside builder.

The builder takes nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

property
Property to bind.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
customElementsInsert
takes root element, ref node and new children. It should return true, if it does not insert elements in DOM. Is such a case the default implementation will insert the elements. Otherwise you have to insert elements in DOM manually.
builder
Builder which is used for every element.
returns
property binding.
implicit def seqFromElement(el: Element): Seq[Element]
implicit def seqFromNode(el: Node): Seq[Node]
implicit def seqNodeFromOpt[T](el: Opt[T])(implicit ev: (T) ⇒ Modifier[Element]): Modifier[Element]
def showIf(property: properties.single.ReadableProperty[Boolean], customElementsReplace: ReplaceMethod)(elements: ⇒ Seq[Node]): Binding

Shows provided DOM elements only if property value is true.
Shows provided DOM elements only if property value is true.
property
Property to check.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
elements
Elements to show if property value is true.
returns
property binding.
def showIf(property: properties.single.ReadableProperty[Boolean])(elements: ⇒ Seq[Node]): Binding

Shows provided DOM elements only if property value is true.
Shows provided DOM elements only if property value is true.
property
Property to check.
elements
Elements to show if property value is true.
returns
property binding.
def showIfElse(property: properties.single.ReadableProperty[Boolean], customElementsReplace: ReplaceMethod)(elements: ⇒ Seq[Node], elseElements: ⇒ Seq[Node]): Binding

Switches provided DOM elements depending on property value.
Switches provided DOM elements depending on property value.
property
Property to check.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
elements
Elements to show if property value is true.
elseElements
Elements to show if property value is false.
returns
property binding.
def showIfElse(property: properties.single.ReadableProperty[Boolean])(elements: ⇒ Seq[Node], elseElements: ⇒ Seq[Node]): Binding

Switches provided DOM elements depending on property value.
Switches provided DOM elements depending on property value.
property
Property to check.
elements
Elements to show if property value is true.
elseElements
Elements to show if property value is false.
returns
property binding.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
implicit def toAttrOps(attr: Attr): AttrOps
implicit def toAttrPairOps(attr: AttrPair[Element, _]): AttrPairOps
implicit def toPropertyOps[T](property: properties.single.ReadableProperty[T]): PropertyOps[T]
def toString(): String

Definition Classes
AnyRef → Any
def valid[A](property: properties.single.ReadableProperty[A])(completeBuilder: (properties.ValidationResult) ⇒ Seq[Node], progressBuilder: (Future[properties.ValidationResult]) ⇒ Seq[Node] = null, errorBuilder: (Throwable) ⇒ Seq[Node] = null): Binding

Use in order to add validation logic over property.
Use in order to add validation logic over property. As this modifier listens on property validation results, user is able to customize what HTML elements should be shown.
property
Property to bind.
completeBuilder
Builder which is called when validation process is completed. It will give an access to validation results.
progressBuilder
Builder which is called when validation process is started. It will also give you an access to future of validation results.
errorBuilder
Builder which is called, when validation process fails.
returns
property binding.
def validWithNested[A](property: properties.single.ReadableProperty[A])(completeBuilder: (properties.ValidationResult, NestedInterceptor) ⇒ Seq[Node], progressBuilder: (Future[properties.ValidationResult], NestedInterceptor) ⇒ Seq[Node] = null, errorBuilder: (Throwable, NestedInterceptor) ⇒ Seq[Node] = null, customElementsReplace: ReplaceMethod = ...): Binding

Use in order to add validation logic over property.
Use in order to add validation logic over property. As this modifier listens on property validation results, user is able to customize what HTML elements should be shown.

The builders take nested bindings interceptor - it should be used if you want to create another binding inside this builder. This prevents memory leaks by killing nested bindings on property change.

property
Property to bind.
completeBuilder
Builder which is called when validation process is completed. It will give an access to validation results.
progressBuilder
Builder which is called when validation process is started. It will also give you an access to future of validation results.
errorBuilder
Builder which is called, when validation process fails.
customElementsReplace
takes root element, old children and new children. It should return true, if it did not replace elements in DOM. Is such a case the default implementation will replace the elements. Otherwise you have to replace elements in DOM manually.
returns
property binding.
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 wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: object Bindings | package bindings

trait Bindings extends AnyRef

Type Members

implicit final class InlineStyleOps[T] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val CheckButtons: inputs.CheckButtons.type

final val Checkbox: inputs.Checkbox.type

final val FileInput: inputs.FileInput.type

final val NumberInput: inputs.NumberInput.type

final val PasswordInput: inputs.PasswordInput.type

final val RadioButtons: inputs.RadioButtons.type

final val RangeInput: inputs.RangeInput.type

final val Select: inputs.Select.type

final val TextArea: inputs.TextArea.type

final val TextInput: inputs.TextInput.type

final def asInstanceOf[T0]: T0

def bind[T](property: properties.single.ReadableProperty[T]): Binding

def clone(): AnyRef

def emptyStringNode(): Node

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def produce[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]], customElementsReplace: ReplaceMethod)(builder: (Seq[T]) ⇒ Seq[Node]): Binding

def produce[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]])(builder: (Seq[T]) ⇒ Seq[Node]): Binding

def produce[T](property: properties.single.ReadableProperty[T], customElementsReplace: ReplaceMethod, checkNull: Boolean)(builder: (T) ⇒ Seq[Node]): Binding

def produce[T](property: properties.single.ReadableProperty[T], checkNull: Boolean = true)(builder: (T) ⇒ Seq[Node]): Binding

def produceWithNested[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]], customElementsReplace: ReplaceMethod)(builder: (Seq[T], NestedInterceptor) ⇒ Seq[Node]): Binding

def produceWithNested[T](property: properties.seq.ReadableSeqProperty[T, _ <: properties.single.ReadableProperty[T]])(builder: (Seq[T], NestedInterceptor) ⇒ Seq[Node]): Binding

def produceWithNested[T](property: properties.single.ReadableProperty[T], customElementsReplace: ReplaceMethod, checkNull: Boolean)(builder: (T, NestedInterceptor) ⇒ Seq[Node]): Binding

def produceWithNested[T](property: properties.single.ReadableProperty[T], checkNull: Boolean = true)(builder: (T, NestedInterceptor) ⇒ Seq[Node]): Binding

def queuedNode(component: ⇒ Seq[Node], timeout: Int = 0): Modifier[Element]

def repeat[T, E <: properties.single.ReadableProperty[T]](property: properties.seq.ReadableSeqProperty[T, E], customElementsReplace: ReplaceMethod = ..., customElementsInsert: InsertMethod = DOMManipulator.DefaultElementInsert)(builder: (E) ⇒ Seq[Node]): Binding

def repeatWithNested[T, E <: properties.single.ReadableProperty[T]](property: properties.seq.ReadableSeqProperty[T, E], customElementsReplace: ReplaceMethod = ..., customElementsInsert: InsertMethod = DOMManipulator.DefaultElementInsert)(builder: (E, NestedInterceptor) ⇒ Seq[Node]): Binding

implicit def seqFromElement(el: Element): Seq[Element]

implicit def seqFromNode(el: Node): Seq[Node]

implicit def seqNodeFromOpt[T](el: Opt[T])(implicit ev: (T) ⇒ Modifier[Element]): Modifier[Element]

def showIf(property: properties.single.ReadableProperty[Boolean], customElementsReplace: ReplaceMethod)(elements: ⇒ Seq[Node]): Binding

def showIf(property: properties.single.ReadableProperty[Boolean])(elements: ⇒ Seq[Node]): Binding

def showIfElse(property: properties.single.ReadableProperty[Boolean], customElementsReplace: ReplaceMethod)(elements: ⇒ Seq[Node], elseElements: ⇒ Seq[Node]): Binding

def showIfElse(property: properties.single.ReadableProperty[Boolean])(elements: ⇒ Seq[Node], elseElements: ⇒ Seq[Node]): Binding

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

implicit def toAttrOps(attr: Attr): AttrOps

implicit def toAttrPairOps(attr: AttrPair[Element, _]): AttrPairOps

implicit def toPropertyOps[T](property: properties.single.ReadableProperty[T]): PropertyOps[T]

def toString(): String

def valid[A](property: properties.single.ReadableProperty[A])(completeBuilder: (properties.ValidationResult) ⇒ Seq[Node], progressBuilder: (Future[properties.ValidationResult]) ⇒ Seq[Node] = null, errorBuilder: (Throwable) ⇒ Seq[Node] = null): Binding

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

final def wait(arg0: Long): Unit

final def wait(): Unit

Deprecated Value Members

def finalize(): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped