CssBoundLiftScreen

abstract def finish(): Unit

abstract def formName: String

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object AjaxOnDone extends ScreenVar[JsCmd]

What to do when the Screen is done.

object Ajax_? extends ScreenVar[Boolean]

implicit object BoxMarkerObj extends BoxMarker

A little hack because => BaseField and => Box[BaseField] have the same method signature

object CancelId extends TransientRequestVar[String]

object Field

object FilterOrValidate

object FormGUID extends ScreenVar[String]

A unique GUID for the form.

object LocalAction extends TransientRequestVar[String]

object LocalActionRef extends RequestVar[String]

object LocalActions extends ScreenVar[AtomicReference[Map[String, () ⇒ JsCmd]]]

object NextId extends ScreenVar[String]

object NotOnConfirmScreen extends FilterOrValidate[Nothing] with Product with Serializable

Override the screen default for fields appearing on the confirm screen and force this field not to appear on the confirm screen

object NothingOtherValueInitializer extends OtherValueInitializer[Nothing] with Product with Serializable

object OnConfirmScreen extends FilterOrValidate[Nothing] with Product with Serializable

Override the screen default for fields appearing on the confirm screen and force this field to appear on the confirm screen

object PrevId extends TransientRequestVar[Box[String]]

object PrevSnapshot extends TransientRequestVar[Box[ScreenSnapshot]]

object Referer extends ScreenVar[String]

object SavedDefaultXml extends ScreenVar[NodeSeq]

object _defaultXml extends TransientRequestVar[NodeSeq]

Holds the template passed via the snippet for the duration of the request

def addFields(fields: () ⇒ FieldContainer): Unit

Add a FieldContainer to the Screen.

def addName(name: String): Unit

def additionalAttributes: MetaData

Any additional parameters that need to be put on the form (e.

def additionalFormBindings: Box[CssSel]

def ajaxForms_?: Boolean

Are the forms Ajax or regular HTTP/HTML.

def allTemplate: NodeSeq

def allTemplateNodeSeq: NodeSeq

def allTemplatePath: List[String]

final def asInstanceOf[T0]: T0

def bindLocalAction(selector: String, func: () ⇒ JsCmd): CssSel

implicit def boxOfScreen[T <: AbstractScreen](in: T): Box[T]

implicit def boxStrToListFieldError(msg: Box[String]): List[FieldError]

implicit def boxXmlToListFieldError(msg: Box[NodeSeq]): List[FieldError]

def builder[T](name: ⇒ String, default: ⇒ T, stuff: FilterOrValidate[T]*)(implicit man: Manifest[T]): FieldBuilder[T]

Create a FieldBuilder so you can add help screens, validations and filters.

def calcAjax: Boolean

Calculate if this Screen/Wizard should be ajax

def calcAjaxOnDone: JsCmd

What should be done at the end of an Ajax session.

def calcReferer: String

Calculate the referer (the page to go back to on finish).

def cancelButton: Elem

def clone(): AnyRef

def createSnapshot: ScreenSnapshot

lazy val cssClassBinding: CssClassBinding

object currentField extends ThreadGlobal[FieldIdentifier]

def defaultFieldNodeSeq: NodeSeq

def defaultToAjax_?: Boolean

Should all instances of this Wizard or Screen default to Ajax when not explicitly set

def defaultXml: NodeSeq

the NodeSeq passed as a parameter when the snippet was invoked

def dispatch: PartialFunction[String, (NodeSeq) ⇒ NodeSeq]

def doFinish(): JsCmd

implicit def elemInABox(in: Elem): Box[Elem]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def field[T](name: ⇒ String, default: ⇒ T, stuff: FilterOrValidate[T]*)(implicit man: Manifest[T]): Field { type ValueType = T }

Create a field with a name, default value, and

def field[T](underlying: ⇒ Box[BaseField { type ValueType = T }], stuff: FilterOrValidate[T]*)(implicit man: Manifest[T], marker: BoxMarker): Field { type ValueType = T }

def field[T](underlying: ⇒ BaseField { type ValueType = T }, stuff: FilterOrValidate[T]*)(implicit man: Manifest[T]): Field { type ValueType = T }

def finalize(): Unit

def finishButton: Elem

def formAttrs: MetaData

What additional attributes should be put on

final def getClass(): Class[_]

def grabParams(in: Seq[FilterOrValidate[_]]): List[SHtml.ElemAttr]

Grabs the FormFieldId and FormParam parameters

def hasUploadField: Boolean

def hashCode(): Int

implicit def inject[T](implicit man: Manifest[T]): Box[T]

final def isInstanceOf[T0]: Boolean

def labelSuffix: NodeSeq

def link(to: String, func: () ⇒ Any, body: NodeSeq, attrs: SHtml.ElemAttr*): Elem

create an anchor tag around a body

def localSetup(): Unit

Override this method to do any setup of this screen

val logger: Logger

def makeField[T, OV](theName: ⇒ String, defaultValue: ⇒ T, theToForm: (Field { ... /* 2 definitions in type refinement */ }) ⇒ Box[NodeSeq], otherValue: OtherValueInitializer[OV], stuff: FilterOrValidate[T]*): Field { ... /* 2 definitions in type refinement */ }

Create a field that's added to the Screen

def mapLocalAction[T](func: () ⇒ JsCmd)(f: (String) ⇒ T): T

def maxVal[T](len: ⇒ T, msg: ⇒ String)(implicit f: (T) ⇒ Number): (T) ⇒ List[FieldError]

def minVal[T](len: ⇒ T, msg: ⇒ String)(implicit f: (T) ⇒ Number): (T) ⇒ List[FieldError]

def multiselect[T](name: ⇒ String, default: ⇒ Seq[T], choices: ⇒ Seq[T], stuff: FilterOrValidate[Seq[T]]*)(implicit f: SHtml.PairStringPromoter[T]): Field { ... /* 2 definitions in type refinement */ }

Create a multi select HTML element

def names: Set[String]

final def ne(arg0: AnyRef): Boolean

def notNull: (String) ⇒ String

def noticeTypeToAttr(screen: AbstractScreen): Box[(Value) ⇒ MetaData]

final def notify(): Unit

final def notifyAll(): Unit

def onConfirm_?: Boolean

By default, are all the fields on this screen on the confirm screen?

def password(name: ⇒ String, defaultValue: ⇒ String, stuff: FilterOrValidate[String]*): Field { type ValueType = String }

Create a password field

def radio(name: ⇒ String, default: ⇒ String, choices: ⇒ Seq[String], stuff: FilterOrValidate[String]*): Field { ... /* 2 definitions in type refinement */ }

Create a radio HTML element

def redirectBack(): JsCmd

def redirectTo(where: String): Nothing

Redirect to another page, but make sure this StatefulSnippet is registered on that page so the state continues on the new page

def registerInjection[T](f: () ⇒ T)(implicit man: Manifest[T]): Unit

def registerThisSnippet(): Unit

def removeRegExChars(regEx: String): (String) ⇒ String

def renderAll(currentScreenNumber: Box[NodeSeq], screenCount: Box[NodeSeq], wizardTop: Box[Elem], screenTop: Box[Elem], fields: List[ScreenFieldInfo], prev: Box[Elem], cancel: Box[Elem], next: Box[Elem], finish: Box[Elem], screenBottom: Box[Elem], wizardBottom: Box[Elem], nextId: (String, () ⇒ JsCmd), prevId: Box[(String, () ⇒ JsCmd)], cancelId: (String, () ⇒ JsCmd), theScreen: AbstractScreen, ajax_?: Boolean): NodeSeq

def renderFormCmd: JsCmd

def renderHtml(): NodeSeq

def renderWithErrors(errors: List[FieldError]): Unit

def replayForm: JsCmd

def savedDefaultXml: NodeSeq

def screenBottom: Box[Elem]

def screenFields: List[BaseField]

A list of fields in this screen

def screenName: String

The name of the screen.

def screenNameAsHtml: NodeSeq

def screenTitle: NodeSeq

def screenTop: Box[Elem]

def screenValidate: List[FieldError]

def seeOther(where: String): Nothing

See Other to another page, but make sure this StatefulSnippet is registered on that page so the state continues on the new page

def select[T](name: ⇒ String, default: ⇒ T, choices: ⇒ Seq[T], stuff: FilterOrValidate[T]*)(implicit f: SHtml.PairStringPromoter[T]): Field { ... /* 2 definitions in type refinement */ }

Create a select HTML element

def setLocalAction(s: String): Unit

implicit def strToListFieldError(msg: String): List[FieldError]

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

def text(name: ⇒ String, defaultValue: ⇒ String, stuff: FilterOrValidate[String]*): Field { type ValueType = String }

Create a text field

def textarea(name: ⇒ String, defaultValue: ⇒ String, rows: Int, cols: Int, stuff: FilterOrValidate[String]*): Field { type ValueType = String }

Create a textarea field

def textarea(name: ⇒ String, defaultValue: ⇒ String, stuff: FilterOrValidate[String]*): Field { type ValueType = String }

Create a textarea field with 80 columns and 5 rows

def toForm: NodeSeq

def toLower: (String) ⇒ String

def toString(): String

def toUpper: (String) ⇒ String

def trim: (String) ⇒ String

def unregisterThisSnippet(): Unit

def valMaxLen(len: ⇒ Int, msg: ⇒ String): (String) ⇒ List[FieldError]

A validation helper.

def valMinLen(len: ⇒ Int, msg: ⇒ String): (String) ⇒ List[FieldError]

A validation helper.

def valRegex(pat: ⇒ Pattern, msg: ⇒ String): (String) ⇒ List[FieldError]

Make sure the field matches a regular expression

def validate: List[FieldError]

def validations: List[() ⇒ List[FieldError]]

def vendAVar[T](dflt: ⇒ T): NonCleanAnyVar[T]

def vendForm[T](implicit man: Manifest[T]): Box[(T, (T) ⇒ Any) ⇒ NodeSeq]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wrapInDiv(in: NodeSeq): Elem

implicit def xmlToListFieldError(msg: NodeSeq): List[FieldError]