CometListener

abstract def registerWith: SimpleActor[Any]

This controls which Actor to register with for updates.

abstract def render: RenderOut

It's the main method to override, to define what is rendered by the CometActor

def !(msg: Any): Unit

Send a message to the Actor.

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

Send a message to the Actor and wait for the actor to process the message and reply.

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

Send a message to the Actor and wait for up to timeout milliseconds for the actor to process the message and reply.

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

Send a message to the Actor and get an LAFuture that will contain the reply (if any) from the message

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

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

Send a message to the Actor and wait for up to timeout milliseconds for the actor to process the message and reply.

def !?(msg: Any): Any

Send a message to the Actor and wait for the actor to process the message and reply.

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

def answer(answer: Any): Unit

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

Prepends the handler to the Json Handlers.

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

You can wrap calls around the evaluation of the mailbox.

def aroundLoans: List[CommonLoanWrapper]

A list of LoanWrappers that will be executed around the evaluation of mailboxes

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

Convert a Seq[Node] (the superclass of NodeSeq) to a RenderOut.

final def asInstanceOf[T0]: T0

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

Ask another CometActor a question.

def attributes: Map[String, String]

def autoIncludeJsonCode: Boolean

Set this method to true to have the Json call code included in the Comet output

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

A helper for binding which uses the defaultHtml property and the default prefix.

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

A helper for binding which uses the defaultHtml property.

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: (CometListener.this)#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: (CometListener.this)#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: (CometListener.this)#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 buildSpan(time: Long, xml: NodeSeq): NodeSeq

Creates the span element acting as the real estate for comet rendering.

def cacheFixedRender: Boolean

By default, we do not cache the value of fixedRender.

def calcFixedRender: Box[NodeSeq]

Calculate fixedRender and capture the postpage javascript

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

Comet Actors live outside the HTTP request/response cycle.

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 clearWiringDependencies(): Unit

Clear the common dependencies for Wiring.

def clone(): AnyRef

def cometActorLocale: Locale

The locale for the session that created the CometActor

def cometListeners: List[ListenerId]

Return the list of ListenerIds of all long poll agents that are waiting for this CometActor to change its state.

def cometProcessingTimeout: Long

Override in sub-class to customise timeout for AJAX-requests to the comet-component for the specific comet

def cometProcessingTimeoutHandler(): JsCmd

This is to react to comet-requests timing out.

  override def cometTimeoutHandler(): JsCmd = {
    Alert("Timeout processing comet-request, timeout is: " + cometProcessingTimeout + "ms")
}

def cometRenderTimeout: Long

Override in sub-class to customise timeout for the render()-method for the specific comet

def cometRenderTimeoutHandler(): Box[NodeSeq]

This is to react to comet-actors timing out while initial rendering, calls to render().

  override def renderTimeoutHandler(): Box[NodeSeq] = {
    Full(<div>Comet {this.getClass} timed out, timeout is {cometRenderTimeout}ms</div>)
}

def composeFunction: PartialFunction[Any, Unit]

Compose the Message Handler function.

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 defaultHtml: NodeSeq

The template that was passed to this component during comet initializations

def defaultPrefix: Box[String]

def devMode: Boolean

Set to 'true' if we should run "render" on every page load

def dontCacheRendering: Boolean

Set this method to true if you want to avoid caching the rendering.

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

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 error(id: String, n: String): Unit

Similar with S.

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

Similar with S.

def error(n: NodeSeq): Unit

Similar with S.

def error(n: String): Unit

Similar with S.

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

def exceptionHandler: PartialFunction[Throwable, Unit]

By default, CometActor handles RedirectShortcutException, which is used to handle many types of redirects in Lift.

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

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.

def fixedRender: Box[NodeSeq]

A part of the CometActor's screen real estate that is not updated by default with reRender().

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]

Handle messages sent to this Actor before the

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

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

It's seriously suboptimal to override this method.

def insertMsgAtHeadOfQueue_!(msg: Any): Unit

This method inserts the message at the head of the mailbox.

final def isInstanceOf[T0]: Boolean

implicit def jsToXmlOrJsCmd(in: JsCmd): RenderOut

def jsonSend: JsonCall

The JavaScript call that you use to send the data to the server.

def jsonToIncludeInCode: JsCmd

The call that packages up the JSON and tosses it to the server.

def lifespan: Box[util.Helpers.TimeSpan]

The lifespan of this component.

def listenerTransition(): Unit

This method will be called when there's a change in the long poll listeners.

def localSetup(): Unit

This method will be called after the Actor has started.

def localShutdown(): Unit

This method will be called as part of the shut-down of the actor.

def lowPriority: PartialFunction[Any, Unit]

def manualWiringDependencyManagement: Boolean

By default, Lift deals with managing wiring dependencies.

def mediumPriority: PartialFunction[Any, Unit]

def messageHandler: PartialFunction[Any, Unit]

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

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

def name: Box[String]

The optional name of this CometActors

final def ne(arg0: AnyRef): Boolean

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

A helpful implicit conversion that takes a NodeSeq => NodeSeq (for example a CssSel) and converts it to a Box[NodeSeq] by applying the function to defaultHtml

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

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

Similar with S.

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

Similar with S.

def notice(n: NodeSeq): Unit

Similar with S.

def notice(n: String): Unit

Similar with S.

final def notify(): Unit

final def notifyAll(): Unit

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

Convert a NodeSeq => NodeSeq to a RenderOut.

def onJsonError: Box[JsCmd]

If there's actor-specific JSON behavior on failure to make the JSON call, include the JavaScript here.

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

def parentTag: Elem

def partialUpdate(cmd: ⇒ JsCmd): Unit

Perform a partial update of the comet component based on the JsCmd.

def poke(): Unit

Poke the CometActor and cause it to do a partial update Noop which will have the effect of causing the component to redisplay any Wiring elements on the component.

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

If the predicate cell changes, the Dependent will be notified

def reRender(): Unit

Cause the entire component to be reRendered and pushed out to any listeners.

def reRender(sendAll: Boolean): Unit

Cause the entire component to be reRendered and pushed out to any listeners.

def receiveJson: PartialFunction[JValue, JsCmd]

Override this method to deal with JSON sent from the browser via the sendJson function.

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

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

def reply(v: Any): Unit

The Actor should call this method with a reply to the message

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

How to report an error that occurs during message dispatch

def running: Boolean

Is the CometActor running?

def send(msg: Any): Unit

Send a message to the Actor.

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

Send a message to the Actor and get an LAFuture that will contain the reply (if any) from the message.

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

Send a message to the Actor and wait for up to timeout milliseconds for the actor to process the message and reply.

def sendAndGetReply(msg: Any): Any

Send a message to the Actor and wait for the actor to process the message and reply.

def sendInitialReq_?: Boolean

Is this CometActor going to capture the initial Req object? If yes, override this method and return true and override captureInitialReq to capture the Req.

def startQuestion(what: Any): Unit

implicit def strToCssBindPromoter(str: String): ToCssBindPromoter

promote a String to a ToCssBindPromotor

implicit def strToSuperArrowAssoc(in: String): (CometListener.this)#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 testTranslate(f: (Any) ⇒ Boolean)(v: Any): Boolean

def theSession: LiftSession

def theType: Box[String]

The optional type of this CometActor

def toString(): String

def unWatch: Unit

val uniqueId: String

def unregisterFromAllDependencies(): Unit

Remove from all dependencies

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

Similar with S.

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

Similar with S.

def warning(n: NodeSeq): Unit

Similar with S.

def warning(n: String): Unit

Similar with S.

def whoDoIDependOn: Seq[Cell[_]]

Get a list of all the cells this Dependency depends on

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.

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

The Cell notifies the Dependent of the dependency

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

The Cell notifies the Dependent of the removed dependency

object BindParamAssoc

transforms a Box into a Text node

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

Bind parameters to XML.

def shouldUpdate: PartialFunction[Any, Boolean]

Override this in order to selectively update listeners based on the given message.

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

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

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

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

def unregisterFromAllDepenencies(): Unit

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.