AbstractScreen

abstract def onConfirm_?: Boolean

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

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit object BoxMarkerObj extends BoxMarker

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

object Field

object FilterOrValidate

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

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

Add a FieldContainer to the Screen.

def additionalAttributes: MetaData

Any additional parameters that need to be put on the form (e.g., mime type)

final def asInstanceOf[T0]: T0

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 cancelButton: Elem

def clone(): AnyRef

object currentField extends ThreadGlobal[FieldIdentifier]

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

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]

Perform the injection for the given type.

final def isInstanceOf[T0]: Boolean

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 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

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 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 registerInjection[T](f: () ⇒ T)(implicit man: Manifest[T]): Unit

Register a function that will inject for the given Manifest

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

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 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

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 toLower: (String) ⇒ String

def toString(): String

def toUpper: (String) ⇒ String

def trim: (String) ⇒ String

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 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

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