Screen

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

def additionalAttributes: MetaData

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]

def cancelButton: Elem

def clone(): AnyRef

def confirmScreen_?: Boolean

Is this screen a confirm screen?

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 }

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

override this method if there's a screen-specific thing to do on finish.

def finishButton: Elem

final def getClass(): java.lang.Class[_]

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

def hasUploadField: Boolean

def hashCode(): Int

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

final def isInstanceOf[T0]: Boolean

def isLastScreen: Boolean

def localSetup(): Unit

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 */ }

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: PairStringPromoter[T]): Field { ... /* 2 definitions in type refinement */ }

val myScreenNum: Int

final def ne(arg0: AnyRef): Boolean

def nextButton: Elem

def nextScreen: Box[Screen]

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 }

def postFinish(): Unit

override this method if there's a screen-specific thing to do on finish.

def prevButton: Elem

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

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

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

def screenBottom: Box[Elem]

def screenFields: List[BaseField]

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: PairStringPromoter[T]): Field { ... /* 2 definitions in type refinement */ }

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 }

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

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

def toLower: (String) ⇒ String

def toString(): String

def toUpper: (String) ⇒ String

def transitionIntoFrom(from: Box[Screen]): Unit

A notification that we are transitioning into this screen.

def transitionOutOfTo(to: Box[Screen]): Unit

A notification that we are transitioning out of this screen.

def trim: (String) ⇒ String

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

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

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

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

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

def _register(field: () ⇒ FieldContainer): Unit