DataLoc

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

lazy val _foundStatelessCalc: (Box[CalcStateless], Box[CalcParamStateless[T]])

The cached Loc params

lazy val _frozenStateless: Boolean

A lazy val used to track statelessness for non-dev mode.

def _testAccess: Either[Boolean, Box[() ⇒ LiftResponse]]

object accessTestRes extends RequestVar[Either[Boolean, Box[() ⇒ LiftResponse]]]

def allParams: List[AnyLocParam]

def appendQueryParameters(in: String, what: Box[T]): String

def appendQueryParams(what: T)(nodeSeq: NodeSeq): NodeSeq

final def asInstanceOf[T0]: T0

def breadCrumbs: List[Loc[_]]

def buildKidMenuItems(kids: Seq[Menu]): List[MenuItem]

def buildMenu: CompleteMenu

lazy val cacheCssClassForMenuItem: Box[() ⇒ String]

By default, this lazy val looks for the MenuCssClass LocParam and uses it.

def calcDefaultHref: String

Calculate HREF to this item using currentValue

def calcHidden(kids: List[MenuItem]): Boolean

def calcHref(in: T): String

Given a value calculate the HREF to this item

lazy val calcSnippets: SnippetTest

The snippets provided by LocParams

def calcStateless(): Boolean

The method to calculate if this Loc is stateless.

def calcTemplate: Box[NodeSeq]

This method can be overridden to provide a template for this Loc

def childValues: List[T]

def clone(): AnyRef

def createDefaultLink: Option[NodeSeq]

def createLink(in: T): Option[NodeSeq]

def cssClassForMenuItem: Box[String]

When the menu item is displayed, what CSS class do we add to the node?

def currentValue: Box[T]

The current value of the cell: overrideValue or requestValue.

def defaultRequestValue: Box[T]

Override this if the default request value should be something other than Empty

val defaultValue: Box[T]

def doesMatch_?(req: Req): Boolean

def earlyResponse: Box[LiftResponse]

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

def findStatelessCalc: (Box[CalcStateless], Box[CalcParamStateless[T]])

Find the stateless calculation Loc params

def foundStatelessCalc: (Box[CalcStateless], Box[CalcParamStateless[T]])

final def getClass(): Class[_]

def hidden: Boolean

def hideIfNoKids_?: Boolean

def inGroup_?(group: String): Boolean

def init(): Unit

final def isInstanceOf[T0]: Boolean

val link: Link[T]

def linkText: Box[NodeSeq]

The title of the location given the current value associated with this Loc

def linkText(in: T): NodeSeq

The link text to be displayed for a value of type T

def menu: Menu

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def overrideValue: Box[T]

def paramTemplate: Box[NodeSeq]

The first Loc.

lazy val paramTitle: Box[(T) ⇒ NodeSeq]

The first Loc.

def paramValue: Box[T]

The value of the Loc based on params (either Loc.

val params: List[LocParam[T]]

def placeHolder_?: Boolean

def queryParameters(what: Box[T]): List[(String, String)]

Calculate the Query parameters

def reqCalcStateless(): Boolean

run the stateless calculation

object requestValue extends RequestVar[Box[T]]

def rewrite: LocRewrite

def rewritePF: Box[RewritePF]

def siteMap: SiteMap

def snippet(name: String): Box[(NodeSeq) ⇒ NodeSeq]

Look up a snippet by name, taking into account the current Loc value.

def snippets: SnippetTest

The snippets defined by the Loc class itself, as opposed to those provided by its LocParams.

def stateless_?: Boolean

Is the Loc marked as Stateless (this will force rendering of the page into stateless mode)

def supplementalKidMenuItems: List[MenuItem]

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

def template: Box[NodeSeq]

The template assocaited with this Loc, if any.

def testAccess: Either[Boolean, Box[() ⇒ LiftResponse]]

val text: LinkText[T]

def title: NodeSeq

The title of the location given the current value associated with this Loc.

def title(in: T): NodeSeq

The title to be displayed for the value associated with this Loc.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val xparams: LocParam[T]*

final def supplimentalKidMenuItems: List[MenuItem]