BindHelpers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object AttrBindParam

BindParam that binds a given value into a new attribute.

object BooleanBindParam extends Serializable

object BoxBindParam extends Serializable

object FuncAttrBindParam

BindParam using a function to calculate its value.

object FuncAttrBoxBindParam

BindParam that computes an optional new attribute value based on the current attribute value.

object FuncAttrOptionBindParam

BindParam that computes an optional new attribute value based on the current attribute value.

object FuncBindParam extends Serializable

object IntBindParam extends Serializable

object LongBindParam extends Serializable

object OptionBindParam extends Serializable

object SymbolBindParam extends Serializable

object TheBindParam extends Serializable

object TheBindableBindParam extends Serializable

object TheStrBindParam extends Serializable

def addAttributes(in: NodeSeq, attributes: MetaData): NodeSeq

takes a NodeSeq and applies all the attributes to all the Elems at the top level of the NodeSeq.

def addCssClass(cssClass: String, elem: Elem): Elem

Adds a css class to the existing class tag of an Elem or create the class attribute

def addCssClass(cssClass: Box[String], elem: Elem): Elem

Adds a css class to the existing class tag of an Elem or create the class attribute

final def asInstanceOf[T0]: T0

def bind(vals: Map[String, NodeSeq], xml: NodeSeq): NodeSeq

Replace the content of lift:bind nodes with the corresponding nodes found in a map, according to the value of the "name" attribute.

  bind(Map("a" ->
= ), change this) must ==/(
=  =
)

def bind(namespace: String, nodeFailureXform: Box[(NodeSeq) ⇒ NodeSeq], paramFailureXform: Box[(PrefixedAttribute) ⇒ MetaData], preserveScope: Boolean, xml: NodeSeq, params: BindParam*): NodeSeq

Bind a set of values to parameters and attributes in a block of XML with defined transforms for unbound elements within the specified namespace.

  bind("user",
       Full(xhtml: NodeSeq => Text("Default Value")),
       Empty,
       replace thisreplace with default,
       "hello" ->
= )

=  =
Default Value

def bind(namespace: String, nodeFailureXform: Box[(NodeSeq) ⇒ NodeSeq], paramFailureXform: Box[(PrefixedAttribute) ⇒ MetaData], xml: NodeSeq, params: BindParam*): NodeSeq

Bind a set of values to parameters and attributes in a block of XML with defined transforms for unbound elements within the specified namespace.

  bind("user",
       Full(xhtml: NodeSeq => Text("Default Value")),
       Empty,
       replace thisreplace with default,
       "hello" ->
= )

=  =
Default Value

def bind(namespace: String, xml: NodeSeq, params: BindParam*): NodeSeq

Bind a set of values to parameters and attributes in a block of XML.

  bind("user", replace this, "hello" ->
= )

=  =

def bindlist(listvals: List[Map[String, NodeSeq]], xml: NodeSeq): Box[NodeSeq]

Bind a list of name/xml maps to a block of XML containing lift:bind nodes (see the bind(Map, NodeSeq) function)

def chooseTemplate(prefix: String, tag: String, xhtml: NodeSeq): NodeSeq

Finds and returns one of many templates from the children based upon the namespace and tag name: for example, for prefix "choose" and tag name "stuff" this would return the contents of the first tag <choose:stuff> ... </choose:stuff> in the specified NodeSeq.

def clone(): AnyRef

implicit def cssSelectorToCssBindPromoter(sel: CssSelector): ToCssBindPromoter

promote a String to a ToCssBindPromotor

def deepEnsureUniqueId(in: NodeSeq): NodeSeq

For a list of NodeSeq, ensure that the the id of the root Elems are unique.

def ensureId(ns: NodeSeq, id: String): NodeSeq

Ensure that the first Element has the specified ID

def ensureUniqueId(in: Seq[NodeSeq]): Seq[NodeSeq]

For a list of NodeSeq, ensure that the the id of the root Elems are unique.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorDiv(body: NodeSeq): Box[NodeSeq]

def finalize(): Unit

def findBox[T](nodes: Seq[Node])(f: (Elem) ⇒ Box[T]): Box[T]

Given a NodeSeq and a function that returns a Box[T], return the first value found in which the function evaluates to Full

def findId(ns: NodeSeq): Box[String]

Finds the first Element in the NodeSeq (or any children) that has an ID attribute

def findId(nodes: Seq[Node], id: String): Option[Elem]

Given an id value, find the Elem with the specified id

def findNode(in: Elem, nodes: NodeSeq): Box[Elem]

Finds and returns the first node in the specified NodeSeq and its children with the same label and prefix as the specified element.

def findOption[T](nodes: Seq[Node])(f: (Elem) ⇒ Option[T]): Option[T]

Given a NodeSeq and a function that returns an Option[T], return the first value found in which the function evaluates to Some

def findOrCreateId(f: (String) ⇒ (NodeSeq) ⇒ NodeSeq): (NodeSeq) ⇒ NodeSeq

Find the first Elem in the NodeSeq.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mixinAttributes(out: Elem)(in: NodeSeq): NodeSeq

Takes attributes from the first node of 'in' (if any) and mixes them into 'out'.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def replaceIdNode(in: NodeSeq, id: String, replacement: NodeSeq): NodeSeq

Replace the element with the id that matches with the replacement nodeseq.

implicit def strToCssBindPromoter(str: String): ToCssBindPromoter

promote a String to a ToCssBindPromotor

implicit def strToSuperArrowAssoc(in: String): SuperArrowAssoc

def stripHead(in: NodeSeq): NodeSeq

Remove all the <head> tags, just leaving the child tags

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

def template(xhtml: NodeSeq, prefix: String, tag1: String, tag2: String, tag3: String): Box[(NodeSeq, NodeSeq, NodeSeq)]

Find three of many templates from the children

def template(xhtml: NodeSeq, prefix: String, tag1: String, tag2: String): Box[(NodeSeq, NodeSeq)]

Find two of many templates from the children

def template(xhtml: NodeSeq, prefix: String, tag: String): Box[NodeSeq]

Similar to chooseTemplate, this returns the contents of the element in a Full Box if found or an Empty Box otherwise.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xmlParam(in: NodeSeq, param: String): Box[String]

Finds the named attribute in specified XML element and returns a Full Box containing the value of the attribute if found.

object BindParamAssoc

transforms a Box into a Text node

def processBind(around: NodeSeq, atWhat: Map[String, NodeSeq]): NodeSeq

Bind parameters to XML.

implicit def strToBPAssoc(in: String): BindParamAssoc

transforms a String to a BindParamAssoc object which can be associated to a BindParam object using the --> operator.

implicit def symToSAAssoc(in: Symbol): SuperArrowAssoc

transforms a Symbol to a SuperArrowAssoc object which can be associated to a BindParam object using the -> operator.

def xbind(namespace: String, xml: NodeSeq)(transform: PartialFunction[String, (NodeSeq) ⇒ NodeSeq]): NodeSeq

Experimental extension to bind which passes in an additional "parameter" from the XHTML to the transform function, which can be used to format the returned NodeSeq.