SimpleNgModelBinder

def !(msg: Any): Unit

def !!(msg: Any): Box[Any]

def !!(msg: Any, timeout: Long): Box[Any]

def !<(msg: Any): LAFuture[Any]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def !?(timeout: Long, message: Any): Box[Any]

def !?(msg: Any): Any

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

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

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

def answer(answer: Any): Unit

def appendJsonHandler(h: PartialFunction[Any, JsCmd]): Unit

def around[R](f: ⇒ R): R

def aroundLoans: List[CommonLoanWrapper]

implicit def arrayToRenderOut(in: Seq[Node]): RenderOut

final def asInstanceOf[T0]: T0

def ask(who: LiftCometActor, what: Any)(answerWith: (Any) ⇒ Unit): Unit

def attributes: Map[String, String]

def autoIncludeJsonCode: Boolean

def bind(vals: (SimpleNgModelBinder.this)#BindParam*): NodeSeq

def bind(prefix: String, vals: (SimpleNgModelBinder.this)#BindParam*): NodeSeq

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

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

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

def bind(namespace: String, xml: NodeSeq, params: (SimpleNgModelBinder.this)#BindParam*): NodeSeq

val bindTo: String

The client $scope element to bind to

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

def buildCmd(root: Boolean, f: JsCmd): JsCmd

Sends any of our commands with all of the early-arrival retry mechanism packaged up

def buildSpan(time: Long, xml: NodeSeq): NodeSeq

def cacheFixedRender: Boolean

def calcFixedRender: Box[NodeSeq]

def captureInitialReq(initialReq: Box[Req]): Unit

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

def clearWiringDependencies(): Unit

val clientSendDelay: Int

Milliseconds for the client to delay sending updates, allowing them to batch into one request.

def clone(): AnyRef

def cometActorLocale: Locale

def cometListeners: List[ListenerId]

def cometProcessingTimeout: Long

def cometProcessingTimeoutHandler(): JsCmd

def cometRenderTimeout: Long

def cometRenderTimeoutHandler(): Box[NodeSeq]

def composeFunction: PartialFunction[Any, Unit]

implicit def cssSelectorToCssBindPromoter(sel: CssSelector): ToCssBindPromoter

def deepEnsureUniqueId(in: NodeSeq): NodeSeq

def defaultHtml: NodeSeq

def defaultPrefix: Box[String]

def devMode: Boolean

def dontCacheRendering: Boolean

implicit def elemToFull(in: Elem): Box[NodeSeq]

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(id: String, n: String): Unit

def error(id: String, n: NodeSeq): Unit

def error(n: NodeSeq): Unit

def error(n: String): Unit

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

def exceptionHandler: PartialFunction[Throwable, Unit]

def execTranslate(f: (Any) ⇒ Unit)(v: Any): Unit

def finalize(): Unit

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

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

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

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

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

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

def fixedRender: Box[NodeSeq]

Render a div for us to hook into

final def forwardMessageTo(msg: Any, forwardTo: TypedActor[Any, Any]): Unit

final def getClass(): Class[_]

def hasOuter: Boolean

def hashCode(): Int

def highPriority: PartialFunction[Any, Unit]

def highPriorityReceive: Box[PartialFunction[Any, Unit]]

val id: String

def initCometActor(theSession: LiftSession, theType: Box[String], name: Box[String], defaultHtml: NodeSeq, attributes: Map[String, String]): Unit

val initialValue: M

Initial value on session initialization

def insertMsgAtHeadOfQueue_!(msg: Any): Unit

final def isInstanceOf[T0]: Boolean

implicit def jsToXmlOrJsCmd(in: JsCmd): RenderOut

def jsonSend: JsonCall

def jsonToIncludeInCode: JsCmd

def lifespan: Box[liftweb.util.Helpers.TimeSpan]

def listenerTransition(): Unit

def localSetup(): Unit

def localShutdown(): Unit

val logger: Logger

def lowPriority: PartialFunction[Any, Unit]

def manualWiringDependencyManagement: Boolean

def mediumPriority: PartialFunction[Any, Unit]

def messageHandler: PartialFunction[Any, Unit]

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

def name: Box[String]

final def ne(arg0: AnyRef): Boolean

implicit def nodeSeqFuncToBoxNodeSeq(f: (NodeSeq) ⇒ NodeSeq): Box[NodeSeq]

implicit def nodeSeqToFull(in: NodeSeq): Box[NodeSeq]

val nodesToRender: NodeSeq

def notice(id: String, n: String): Unit

def notice(id: String, n: NodeSeq): Unit

def notice(n: NodeSeq): Unit

def notice(n: String): Unit

final def notify(): Unit

final def notifyAll(): Unit

implicit def nsToNsFuncToRenderOut(f: (NodeSeq) ⇒ NodeSeq): RenderOut

val onClientUpdate: (M) ⇒ M

Callback to execute on each update from the client

def onJsonError: Box[JsCmd]

implicit def pairToPair(in: (String, Any)): (String, NodeSeq)

def parentTag: Elem

def partialUpdate(cmd: ⇒ JsCmd): Unit

def poke(): Unit

def predicateChanged(which: Cell[_]): Unit

def reRender(): Unit

def reRender(sendAll: Boolean): Unit

def receiveJson: PartialFunction[JValue, JsCmd]

def render: RenderOut

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

def reply(v: Any): Unit

def reportError(msg: String, exception: Exception): Unit

object rootScope extends Scope

Your handle to the $rootScope object for your actor

def running: Boolean

val scope: (SimpleNgModelBinder.this)#Scope

Your handle to the $scope object for your actor

def send(msg: Any): Unit

def sendAndGetFuture(msg: Any): LAFuture[Any]

def sendAndGetReply(timeout: Long, msg: Any): Any

def sendAndGetReply(msg: Any): Any

def sendInitialReq_?: Boolean

def startQuestion(what: Any): Unit

implicit def strToCssBindPromoter(str: String): ToCssBindPromoter

implicit def strToSuperArrowAssoc(in: String): (SimpleNgModelBinder.this)#SuperArrowAssoc

def stringify(obj: AnyRef): String

def stripHead(in: NodeSeq): NodeSeq

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

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

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

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

def testTranslate(f: (Any) ⇒ Boolean)(v: Any): Boolean

def theSession: LiftSession

def theType: Box[String]

def toString(): String

def unWatch: Unit

val uniqueId: String

def unregisterFromAllDependencies(): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warning(id: String, n: String): Unit

def warning(id: String, n: NodeSeq): Unit

def warning(n: NodeSeq): Unit

def warning(n: String): Unit

def whoDoIDependOn: Seq[Cell[_]]

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

def youDependOnMe(who: Cell[_]): Unit

def youDontDependOnMe(who: Cell[_]): Unit

def defaultXml: NodeSeq

def handleJson(in: Any): JsCmd

lazy val jsonCall: JsonCall

lazy val jsonInCode: JsCmd

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

implicit def strToBPAssoc(in: String): (SimpleNgModelBinder.this)#BindParamAssoc

implicit def symToSAAssoc(in: Symbol): (SimpleNgModelBinder.this)#SuperArrowAssoc

def unregisterFromAllDepenencies(): Unit

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