SHtml

Type Members

class ApplicableElem extends AnyRef
trait AreaShape extends AnyRef
final case class BasicElemAttr(name: String, value: String) extends ElemAttr with Product with Serializable

Any old attribute.
Any old attribute. You should not explicitly construct one of these, but rather use "name" -> "value" and let the implicit conversion take care of making a BasicElemAttr.
final case class ChoiceHolder[T](items: Seq[ChoiceItem[T]]) extends Product with Serializable

Holds a series of choices: HTML for input controls alongside some user defined value
final case class ChoiceItem[T](key: T, xhtml: NodeSeq) extends Product with Serializable

Holds a form control as HTML along with some user defined value
case class CirclePercentShape(centerX: Int, centerY: Int, radiusPercent: Int) extends AreaShape with Product with Serializable
case class CircleShape(centerX: Int, centerY: Int, radius: Int) extends AreaShape with Product with Serializable
trait ElemAttr extends (Elem) ⇒ Elem

An attribute that can be applied to an element.
An attribute that can be applied to an element. Typically, this will be a key-value pair, but there is a class of HTML5 attributes that should be similated in JavaScript.
trait PairStringPromoter[T] extends (T) ⇒ String

Convert a T to a String for display in Select, MultiSelect, etc.
case class PolyShape(polyCoords: (Int, Int)*) extends AreaShape with Product with Serializable
case class RectShape(left: Int, top: Int, right: Int, bottom: Int) extends AreaShape with Product with Serializable
final case class SelectableOption[+T](value: T, label: String, attrs: ElemAttr*) extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object ChoiceHolder extends Serializable
object ElemAttr

The companion object that has some very helpful conversion
object PairStringPromoter

A companion object that does implicit conversions
object SelectableOption extends Serializable
def a(body: NodeSeq, cmd: JsCmd, attrs: ElemAttr*): Elem

Create an anchor that will run a JavaScript command when clicked
def a(jsFunc: Call, body: NodeSeq, attrs: ElemAttr*)(func: ⇒ JsCmd): Elem

Create an anchor with a body and the function to be executed when the anchor is clicked
Create an anchor with a body and the function to be executed when the anchor is clicked
jsFunc
-- the user function that will be executed. This function will receive as last parameter the function that will actually do the ajax call. Hence the user function can decide when to make the ajax request.
body
- the NodeSeq to wrap in the anchor tag
attrs
- the anchor node attributes
def a(body: NodeSeq, attrs: ElemAttr*)(func: ⇒ JsCmd): Elem

Create an anchor with a body and the function to be executed when the anchor is clicked
def a(func: () ⇒ JsObj, jsonContext: JsonContext, body: NodeSeq, attrs: ElemAttr*): Elem
def a(jsFunc: Call, func: () ⇒ JsCmd, body: NodeSeq, attrs: ElemAttr*): Elem

Create an anchor tag around a body which will do an AJAX call and invoke the function
Create an anchor tag around a body which will do an AJAX call and invoke the function
jsFunc
-- the user function that will be executed. This function will receive as last parameter the function that will actually do the ajax call. Hence the user function can decide when to make the ajax request.
func
- the function to invoke when the link is clicked
body
- the NodeSeq to wrap in the anchor tag
attrs
- the anchor node attributes
def a(func: () ⇒ JsCmd, body: NodeSeq, attrs: ElemAttr*): Elem

Create an anchor tag around a body which will do an AJAX call and invoke the function
Create an anchor tag around a body which will do an AJAX call and invoke the function
func
- the function to invoke when the link is clicked
body
- the NodeSeq to wrap in the anchor tag
attrs
- the anchor node attributes
def ajaxButton(text: String, jsFunc: Call, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

Create an Ajax button that when pressed, executes the function
Create an Ajax button that when pressed, executes the function
text
-- the name/text of the button
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
returns
a button to put on your page
def ajaxButton(text: String, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

Create an Ajax button that when pressed, executes the function
Create an Ajax button that when pressed, executes the function
text
-- the name/text of the button
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
returns
a button to put on your page
def ajaxButton(text: NodeSeq, jsFunc: Call, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

Create an Ajax button that when pressed, executes the function
Create an Ajax button that when pressed, executes the function
text
-- the name/text of the button
jsFunc
-- the user function that will be executed. This function will receive as last parameter the function that will actually do the ajax call. Hence the user function can decide when to make the ajax request.
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
returns
a button to put on your pagejsFunc.params ++ List(AnonFunc(makeAjaxCall(Str(name+"=true"))))
def ajaxButton(text: NodeSeq, jsExp: JsExp, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

Create an Ajax button that when pressed, executes the function
Create an Ajax button that when pressed, executes the function
text
-- the name/text of the button
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
attrs
-- the list of node attributes
returns
a button to put on your page
def ajaxButton(text: NodeSeq, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

Create an Ajax button.
Create an Ajax button. When it's pressed, the function is executed
text
-- the name/text of the button
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
attrs
-- the list of node attributes
returns
a button to put on your page
def ajaxCall(jsCalcValue: JsExp, jsContext: JsContext, func: (String) ⇒ JsCmd): GUIDJsExp

Build a JavaScript function that will perform an AJAX call based on a value calculated in JavaScript
Build a JavaScript function that will perform an AJAX call based on a value calculated in JavaScript
jsCalcValue
the JavaScript that will be executed on the client to calculate the value to be sent to the server
jsContext
the context instance that defines JavaScript to be executed on call success or failure
func
the function to call when the data is sent
returns
the function ID and JavaScript that makes the call
def ajaxCall(jsCalcValue: JsExp, func: (String) ⇒ JsCmd): GUIDJsExp

Build a JavaScript function that will perform an AJAX call based on a value calculated in JavaScript
Build a JavaScript function that will perform an AJAX call based on a value calculated in JavaScript
jsCalcValue
the JavaScript that will be executed on the client to calculate the value to be sent to the server
func
the function to call when the data is sent
returns
the function ID and JavaScript that makes the call
def ajaxCheckbox(value: Boolean, jsFunc: Call, func: (Boolean) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxCheckbox(value: Boolean, func: (Boolean) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxCheckboxElem(settable: Settable { type ValueType = Boolean }, jsFunc: Call, attrs: ElemAttr*): Elem
def ajaxCheckboxElem(settable: Settable { type ValueType = Boolean }, attrs: ElemAttr*): Elem
def ajaxEditable(displayContents: ⇒ NodeSeq, editForm: ⇒ NodeSeq, onSubmit: () ⇒ JsCmd): NodeSeq

This method generates an AJAX editable field.
This method generates an AJAX editable field.
Normally, the displayContents will be shown, with an "Edit" button. If the "Edit" button is clicked, the field will be replaced with the edit form, along with an "OK" and "Cancel" button. If the OK button is pressed, the form fields are submitted and the onSubmit function is called, and then the displayContents are re-run to get a new display. If cancel is pressed then the original displayContents are re-shown.
Note that the editForm NodeSeq is wrapped inside of an ajaxForm, so it can be comprised of normal (non-AJAX) SHtml form elements. For example:
```
ajaxEditable(Test("Click me"),
             SHtml.text("Edit me", s => println("Edited with " +s)),
             () => { println("submitted"); Noop })
```
def ajaxEditableSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], f: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission with an additional selection that transforms select into an ajaxText allowing the user to add a new select option
def ajaxForm(body: NodeSeq, onSubmit: JsCmd, postSubmit: JsCmd): Elem

Takes a form and wraps it so that it will be submitted via AJAX.
Takes a form and wraps it so that it will be submitted via AJAX. This also takes a parameter for script code that will be executed after the form has been submitted.
body
The form body. This should not include the <form> tag.
postSubmit
Code that should be executed after a successful submission
def ajaxForm(body: NodeSeq, onSubmit: JsCmd): Elem

Takes a form and wraps it so that it will be submitted via AJAX.
Takes a form and wraps it so that it will be submitted via AJAX.
body
The form body. This should not include the <form> tag.
onSubmit
JavaScript code to execute on the client prior to submission
def ajaxForm(body: NodeSeq): Elem

Takes a form and wraps it so that it will be submitted via AJAX.
Takes a form and wraps it so that it will be submitted via AJAX.
body
The form body. This should not include the <form> tag.
def ajaxInvoke(func: () ⇒ JsCmd): GUIDJsExp
def ajaxOnSubmit(func: () ⇒ JsCmd): (NodeSeq) ⇒ NodeSeq

Add appropriate attributes to an input type="submit" or button element to make it submit an ajaxForm correctly and return a JsCmd to the client.
Add appropriate attributes to an input type="submit" or button element to make it submit an ajaxForm correctly and return a JsCmd to the client. Note that the key difference between this and ajaxSubmit is that ajaxSubmit returns a complete input type="submit" element, while ajaxOnSubmit applies the right attributes to any input type="submit" *or* button element.
Example:
```
"type=submit" #> ajaxOnSubmit(() => Alert("Done!"))
```
def ajaxRadio[T](opts: Seq[T], deflt: Box[T], ajaxFunc: (T) ⇒ JsCmd, attrs: ElemAttr*): ChoiceHolder[T]

Make a set of Ajax radio buttons.
Make a set of Ajax radio buttons. When the buttons are pressed, the function is called
opts
-- The possible values. These are not revealed to the browser
deflt
-- the default button
ajaxFunc
-- the function to invoke when the button is pressed
def ajaxSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxSelectElem[T](options: Seq[T], default: Box[T], jsFunc: Call, attrs: ElemAttr*)(onSubmit: (T) ⇒ JsCmd)(implicit f: PairStringPromoter[T]): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def ajaxSelectElem[T](options: Seq[T], default: Box[T], attrs: ElemAttr*)(onSubmit: (T) ⇒ JsCmd)(implicit f: PairStringPromoter[T]): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def ajaxSelectObj[T](options: Seq[SelectableOption[T]], default: Box[T], jsFunc: Call, onSubmit: (T) ⇒ JsCmd, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def ajaxSelectObj[T](options: Seq[SelectableOption[T]], default: Box[T], onSubmit: (T) ⇒ JsCmd, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def ajaxSubmit(value: String, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

Constructs an Ajax submit button that can be used inside ajax forms.
Constructs an Ajax submit button that can be used inside ajax forms. Multiple buttons can be used in the same form.
value
- the button text
func
- the ajax function to be called
attrs
- button attributes
def ajaxText(value: String, ignoreBlur: Boolean, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxText(value: String, ignoreBlur: Boolean, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxText(value: String, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxText(value: String, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxTextElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
def ajaxTextarea(value: String, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxTextarea(value: String, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def ajaxUntrustedSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], jsFunc: Call, func: (String) ⇒ JsCmd, attrs: (String, String)*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission.
Create a select box based on the list with a default value and the function to be executed on form submission. No check is made to see if the resulting value was in the original list. For use with DHTML form updating.
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
jsFunc
-- user provided function
func
-- the function to execute on form submission
attrs
-- select box attributes
def ajaxUntrustedSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ JsCmd, attrs: (String, String)*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission.
Create a select box based on the list with a default value and the function to be executed on form submission. No check is made to see if the resulting value was in the original list. For use with DHTML form updating.
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
func
-- the function to execute on form submission
attrs
-- select box attributes
def area(shape: AreaShape, func: () ⇒ JsCmd, alt: String, attrs: ElemAttr*): Elem

Generate an Area tag
Generate an Area tag
shape
- the shape of the area (RectShape, CircleShape, CirclePercentShape, PolyShape)
func
- The server side function to execute when the area is clicked on.
alt
- the contents of the alt attribute
attrs
- the balance of the attributes for the tag
def area(shape: AreaShape, jsCmd: JsCmd, alt: String, attrs: ElemAttr*): Elem

Generate an Area tag
Generate an Area tag
shape
- the shape of the area (RectShape, CircleShape, CirclePercentShape, PolyShape)
jsCmd
- the JavaScript to execute on the client when the area is clicked
alt
- the contents of the alt attribute
attrs
- the balance of the attributes for the tag
def area(shape: AreaShape, alt: String, attrs: ElemAttr*): Elem

Generate an Area tag
Generate an Area tag
shape
- the shape of the area (RectShape, CircleShape, CirclePercentShape, PolyShape)
alt
- the contents of the alt attribute
attrs
- the balance of the attributes for the tag
final def asInstanceOf[T0]: T0

Definition Classes
Any
def button(strOrNodeSeq: StringOrNodeSeq, func: () ⇒ Any, attrs: ElemAttr*): Elem

Create an HTML button with strOrNodeSeq as the body.
Create an HTML button with strOrNodeSeq as the body. The button will be type submit.
strOrNodeSeq
-- the String or NodeSeq (either will work just fine) to put into the body of the button
func
-- the function to execute when the form containing the button is posted
attrs
-- the attributes to append to the button
returns
a button HTML Element b
def checkbox(value: Boolean, func: (Boolean) ⇒ Any, attrs: ElemAttr*): NodeSeq

Defines a new checkbox set to { @code value } and running { @code func } when the checkbox is submitted.
def checkbox[T](possible: Seq[T], actual: Seq[T], func: (Seq[T]) ⇒ Any, attrs: ElemAttr*): ChoiceHolder[T]

Generate a ChoiceHolder of possible checkbox type inputs that calls back to the given function when the form is submitted.
Generate a ChoiceHolder of possible checkbox type inputs that calls back to the given function when the form is submitted.
possible
complete sequence of possible values, each a separate checkbox when rendered
actual
values to be preselected
func
function to receive all values corresponding to the checked boxes
attrs
sequence of attributes to apply to each checkbox input element
returns
ChoiceHolder containing the checkboxes and values in order
def checkboxElem(settable: Settable { type ValueType = Boolean }, attrs: ElemAttr*): NodeSeq

Defines a new checkbox for the Settable
def checkbox_*(value: Boolean, func: AFuncHolder, id: Box[String], attrs: ElemAttr*): NodeSeq
def checkbox_id(value: Boolean, func: (Boolean) ⇒ Any, id: Box[String], attrs: ElemAttr*): NodeSeq

Defines a new checkbox set to { @code value } and running { @code func } when the checkbox is submitted.
Defines a new checkbox set to { @code value } and running { @code func } when the checkbox is submitted. Has an id of { @code id }.
def checkbox_id(settable: Settable { type ValueType = Boolean }, id: Box[String], attrs: ElemAttr*): NodeSeq

Defines a new checkbox for the Settable
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def elemToApplicable(e: Elem): ApplicableElem
def email(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem

Generate an email input element for the Settable.
Generate an email input element for the Settable. At some point there will be graceful fallback for non-HTML5 browsers. FIXME
def email(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem

Generate an input field with type email.
Generate an input field with type email. At some point, there will be graceful fallback for non-HTML5 browsers. FIXME
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fajaxCall[T](jsCalcValue: JsExp, func: (String) ⇒ JsCmd)(f: (String, JsExp) ⇒ T): T
def fileUpload(func: (FileParamHolder) ⇒ Any, attrs: ElemAttr*): Elem

Defines a form element for a file upload that will call the specified function when the file is uploaded if the file size is greater than zero.
Defines a form element for a file upload that will call the specified function when the file is uploaded if the file size is greater than zero. Note that in order to use the fileUpload element you need to specify the multipart attribute on your snippet tag:
```
<lift:Some.snippet form="POST" multipart="true">
...
</lift:Some.snippet>
```
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def hidden(func: (String) ⇒ Any, defaultlValue: String, attrs: ElemAttr*): Elem
def hidden(func: () ⇒ Any, attrs: ElemAttr*): Elem
def hidden_*(func: AFuncHolder, attrs: ElemAttr*): Elem
def hrefFunc(func: () ⇒ Any): (NodeSeq) ⇒ NodeSeq

If you want to update the href of an <a> tag, this method returns a function that mutates the href by adding a function that will be executed when the link is clicked: "#my_link" #> SHtml.hrefFunc(() => println("howdy"))
If you want to update the href of an <a> tag, this method returns a function that mutates the href by adding a function that will be executed when the link is clicked: "#my_link" #> SHtml.hrefFunc(() => println("howdy"))
def idMemoize(f: (IdMemoizeTransform) ⇒ NodeSeqFuncOrSeqNodeSeqFunc): IdMemoizeTransform

Memoize the NodeSeq used in apply() and then call applyAgain() in an Ajax call and you don't have to explicitly capture the template
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def jsonButton(text: NodeSeq, jsExp: JsExp, func: (JValue) ⇒ JsCmd, ajaxContext: JsonContext, attrs: ElemAttr*)(implicit dummy: AvoidTypeErasureIssues1): Elem

Create an Ajax button that when pressed, submits an Ajax request and expects back a JSON construct which will be passed to the success function
Create an Ajax button that when pressed, submits an Ajax request and expects back a JSON construct which will be passed to the success function
text
-- the name/text of the button
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
ajaxContext
-- defines the callback functions and the JSON response type
attrs
-- the list of node attributes
returns
a button to put on your page
def jsonButton(text: NodeSeq, func: () ⇒ JsObj, ajaxContext: JsonContext, attrs: ElemAttr*): Elem

Create an Ajax button that when pressed, submits an Ajax request and expects back a JSON construct which will be passed to the success function
Create an Ajax button that when pressed, submits an Ajax request and expects back a JSON construct which will be passed to the success function
text
-- the name/text of the button
func
-- the function to execute when the button is pushed. Return Noop if nothing changes on the browser.
ajaxContext
-- defines the callback functions and the JSON response type
attrs
-- the list of node attributes
returns
a button to put on your page
def jsonCall(jsCalcValue: JsExp, jsonContext: JsonContext, func: (JValue) ⇒ JValue): GUIDJsExp

Build a JavaScript function that will perform a JSON call based on a value calculated in JavaScript.
Build a JavaScript function that will perform a JSON call based on a value calculated in JavaScript.
The JSON generated by func will be returned to the client and passed as argument to the javascript function specified in jsonContext.success
jsCalcValue
the JavaScript to calculate the value to be sent to the server
jsonContext
the context instance that defines JavaScript to be executed on call success or failure
func
the function to call when the JSON data is sent. The returned JSON is sent back to the client
returns
the function ID and JavaScript that makes the call
def jsonCall(jsCalcValue: JsExp, jsContext: JsContext, func: (JValue) ⇒ JsCmd): GUIDJsExp

Build a JavaScript function that will perform a JSON call based on a value calculated in JavaScript.
Build a JavaScript function that will perform a JSON call based on a value calculated in JavaScript. This method uses the Lift-JSON package rather than the old, slow, not-typed JSONParser. This is the preferred way to do client to server JSON calls.
jsCalcValue
the JavaScript to calculate the value to be sent to the server
jsContext
the context instance that defines JavaScript to be executed on call success or failure
func
the function to call when the data is sent
returns
the function ID and JavaScript that makes the call
def jsonCall(jsCalcValue: JsExp, func: (JValue) ⇒ JsCmd): GUIDJsExp

Build a JavaScript function that will perform a JSON call based on a value calculated in JavaScript.
Build a JavaScript function that will perform a JSON call based on a value calculated in JavaScript. This method uses the Lift-JSON package rather than the old, slow, not-typed JSONParser. This is the preferred way to do client to server JSON calls.
jsCalcValue
the JavaScript to calculate the value to be sent to the server
func
the function to call when the data is sent
returns
the function ID and JavaScript that makes the call
def jsonText(value: String, cmd: String, json: JsonCall, attrs: ElemAttr*): Elem

Create a JSON text widget that makes a JSON call on blur or "return".
Create a JSON text widget that makes a JSON call on blur or "return".
value
- the initial value of the text field
cmd
- the json command name
json
- the JsonCall returned from S.createJsonFunc
returns
a text field
def jsonText(value: String, json: (JsExp) ⇒ JsCmd, attrs: ElemAttr*): Elem

This function does not really submit a JSON request to the server.
This function does not really submit a JSON request to the server. Instead, json is a function that allows you to build a more complex JsCmd based on the JsExp JE.JsRaw("this.value"). This function is called by the overloaded version of jsonText.
value
- the initial value of the text field
json
- takes a JsExp which describes how to recover the value of the text field and returns a JsExp containing the thing to execute on blur/return
returns
a text field
def jsonText(value: String, ignoreBlur: Boolean, json: (JsExp) ⇒ JsCmd, attrs: ElemAttr*): Elem

This function does not really submit a JSON request to the server.
This function does not really submit a JSON request to the server. Instead, json is a function that allows you to build a more complex JsCmd based on the JsExp JE.JsRaw("this.value"). This function is called by the overloaded version of jsonText.
value
- the initial value of the text field
ignoreBlur
- ignore the onblur event and only do the event if the enter key is pressed
json
- takes a JsExp which describes how to recover the value of the text field and returns a JsExp containing the thing to execute on blur/return
returns
a text field
def jsonTextarea(value: String, cmd: String, json: JsonCall, attrs: ElemAttr*): Elem

Create a JSON text area widget that makes a JSON call on blur
Create a JSON text area widget that makes a JSON call on blur
value
- the initial value of the text field
cmd
- the json command name
json
- the JsonCall returned from S.createJsonFunc
returns
a text field
def jsonTextarea(value: String, json: (JsExp) ⇒ JsCmd, attrs: ElemAttr*): Elem

This function does not really submit a JSON request to the server.
This function does not really submit a JSON request to the server. Instead, json is a function that allows you to build a more complex JsCmd based on the JsExp JE.JsRaw("this.value"). This function is called by the overloaded version of jsonTextarea.
value
- the initial value of the text area field
json
- takes a JsExp which describes how to recover the value of the text area field and returns a JsExp containing the thing to execute on blur
returns
a text area field
def link(to: String, func: () ⇒ Any, body: NodeSeq, attrs: ElemAttr*): Elem

create an anchor tag around a body
create an anchor tag around a body
to
the target
func
the function to invoke when the link is clicked
body
the NodeSeq to wrap in the anchor tag
attrs
the (optional) attributes for the HTML element
val logger: Logger

Attributes
protected
Definition Classes
Loggable
def makeAjaxCall(in: JsExp, context: AjaxContext): JsExp

Invokes the Ajax request
Invokes the Ajax request
in
the JsExp that returns the request data
context
defines the response callback functions and the response type (JavaScript or JSON)
def makeAjaxCall(in: JsExp): JsExp

Invokes the Ajax request
Invokes the Ajax request
in
the JsExp that returns the request data
def makeFormsAjax: (NodeSeq) ⇒ NodeSeq

Vend a function that will take all of the form elements and turns them into Ajax forms
def memoize(f: ⇒ (NodeSeq) ⇒ NodeSeq): MemoizeTransform

Memoize the NodeSeq used in apply() and then call applyAgain() in an Ajax call and you don't have to explicitly capture the template
def multiSelect(opts: Seq[SelectableOption[String]], deflt: Seq[String], func: (List[String]) ⇒ Any, attrs: ElemAttr*): Elem
def multiSelectElem[T](options: Seq[T], default: Seq[T], attrs: ElemAttr*)(onSubmit: (List[T]) ⇒ Any)(implicit f: PairStringPromoter[T]): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def multiSelectObj[T](options: Seq[SelectableOption[T]], default: Seq[T], onSubmit: (List[T]) ⇒ Any, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def multiSelect_*(opts: Seq[SelectableOption[String]], deflt: Seq[String], func: AFuncHolder, attrs: ElemAttr*): Elem
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def number(settable: Settable { type ValueType = Double }, min: Double, max: Double, step: Double, attrs: ElemAttr*): Elem

Generate a number input element for the Settable.
Generate a number input element for the Settable. It allows for Double if your step is for example: 0.1 At some point there will be graceful fallback for non-HTML5 browsers. FIXME
def number(value: Double, func: (Double) ⇒ Any, min: Double, max: Double, step: Double, attrs: ElemAttr*): Elem

Generate an input field with type number.
Generate an input field with type number. It allows for Double if your step is for example: 0.1 At some point, there will be graceful fallback for non-HTML5 browsers. FIXME
def number(settable: Settable { type ValueType = Int }, min: Int, max: Int, attrs: ElemAttr*): Elem

Generate a number input element for the Settable.
Generate a number input element for the Settable. At some point there will be graceful fallback for non-HTML5 browsers. FIXME
def number(value: Int, func: (Int) ⇒ Any, min: Int, max: Int, attrs: ElemAttr*): Elem

Generate an input field with type number.
Generate an input field with type number. At some point, there will be graceful fallback for non-HTML5 browsers. FIXME
def onEvent(func: (String) ⇒ JsCmd): GUIDJsExp

Create something that's bindable to an event attribute and when the event happens, the command will fire: "input [onblur]" #> SHtml.onEvent(s => Alert("Thanks: "+s))
Create something that's bindable to an event attribute and when the event happens, the command will fire: "input [onblur]" #> SHtml.onEvent(s => Alert("Thanks: "+s))
def onEventIf(question: String, fn: (String) ⇒ JsCmd): GUIDJsExp

Create something that's bindable to an event attribute and guarded by a confirm dialog.
Create something that's bindable to an event attribute and guarded by a confirm dialog. The fn passed in will only execute if the user clicks the "OK" button in the confirm dialog. Useful for things like delete buttons that you want a confirmation on.
".deleteBtn [onclick]" #> SHtml.onEventIf("Are you sure you want to do that?", s => deleteUser())
def onEvents(event: String, events: String*)(func: (String) ⇒ JsCmd): (NodeSeq) ⇒ NodeSeq

Specify the events (e.g., onblur, onchange, etc.) and the function to execute on those events.
Specify the events (e.g., onblur, onchange, etc.) and the function to execute on those events. Returns a NodeSeq => NodeSeq that will add the events to all the Elements ":text" #> SHtml.onEvents("onchange", "onblur")(s => Alert("yikes "+s))
def onSubmit(func: (String) ⇒ Any): (NodeSeq) ⇒ NodeSeq

Execute the String function when the form is submitted.
Execute the String function when the form is submitted. This method returns a function that can be applied to form fields (input, button, textarea, select) and the function is executed when the form containing the field is submitted.
def onSubmitBoolean(func: (Boolean) ⇒ Any): (NodeSeq) ⇒ NodeSeq

Execute the Boolean function when the form is submitted.
Execute the Boolean function when the form is submitted. This method returns a function that can be applied to form fields (input, button, textarea, select) and the function is executed when the form containing the field is submitted.
def onSubmitImpl(func: AFuncHolder): (NodeSeq) ⇒ NodeSeq

Execute the function when the form is submitted.
Execute the function when the form is submitted. This method returns a function that can be applied to form fields (input, button, textarea, select) and the function is executed when the form containing the field is submitted.
def onSubmitList(func: (List[String]) ⇒ Any): (NodeSeq) ⇒ NodeSeq

Execute the List[String] function when the form is submitted.
Execute the List[String] function when the form is submitted. This method returns a function that can be applied to form fields (input, button, textarea, select) and the function is executed when the form containing the field is submitted.
def onSubmitUnit(func: () ⇒ Any): (NodeSeq) ⇒ NodeSeq

Execute the function when the form is submitted.
Execute the function when the form is submitted. This method returns a function that can be applied to form fields (input, button, textarea, select) and the function is executed when the form containing the field is submitted.
def password(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem
def passwordElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
def password_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
def radio(opts: Seq[String], deflt: Box[String], func: (String) ⇒ Any, attrs: ElemAttr*): ChoiceHolder[String]
def radioCssSel[T](initialValue: Box[T], onSubmit: (Box[T]) ⇒ Any)(cssSelToValue: (String, T)*): CssSel

Generate a CSS transform that will bind to a template containing radio buttons without overwriting the radio buttons in the template with entirely new elements.
Generate a CSS transform that will bind to a template containing radio buttons without overwriting the radio buttons in the template with entirely new elements.
This is a change in technique from the normal radio handlers in that it doesn't involve the creation of a new element or injection of hidden elements. That means that labels designed to target a partiular radio by ID and CSS styles that target elements following radios using the + CSS selector won't stop working once a form is bound by Lift.
As an example, given the following template:
```
<input type="radio" id="all-emails">
<label for="all-emails">All emails.</label>

<input type="radio" id="some-emails">
<label for="some-emails">Some emails.</label>
```
You might invoke this function like so:
```
def render = {
  SHtml.radioCssSel[String](Empty, submitHandler) (
    "#all-emails" -> "All emails",
    "#some-emails" -> "Some emails"
  )
}

val submitHandler:Box[String] => Unit = { box =>
  println("We got a box!! "+box)
}
```
initialValue
initial value or Empty if no initial value
onSubmit
function to execute on form submission
cssSelToValue
mapping between CSS selectors of radio input nodes and values assigned to them
def radioElem[T](opts: Seq[T], deflt: Box[T], attrs: ElemAttr*)(onSubmit: (Box[T]) ⇒ Any): ChoiceHolder[T]

Generate a collection or radio box items from a sequence of things
def radio_*(opts: Seq[String], deflt: Box[String], func: AFuncHolder, attrs: ElemAttr*): ChoiceHolder[String]
def range(settable: Settable { type ValueType = Int }, min: Int, max: Int, attrs: ElemAttr*): Elem

Generate a range input element for the Settable.
Generate a range input element for the Settable. At some point there will be graceful fallback for non-HTML5 browsers. FIXME
def range(value: Int, func: (Int) ⇒ Any, min: Int, max: Int, attrs: ElemAttr*): Elem

Generate an input field with type range.
Generate an input field with type range. At some point, there will be graceful fallback for non-HTML5 browsers. FIXME
def select(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ Any, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
opts
-- the options. A list of value and text pairs (value, text to display)
deflt
-- the default value (or Empty if no default value)
func
-- the function to execute on form submission
def selectElem[T](options: Seq[T], settable: LiftValue[T], attrs: ElemAttr*)(implicit f: PairStringPromoter[T]): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of values
attrs
-- the attributes to append to the resulting Elem, these may be name-value pairs (static attributes) or special HTML5 ElemAtts
f
-- the function that converts a T to a Display String.
def selectElem[T](options: Seq[T], default: Box[T], attrs: ElemAttr*)(onSubmit: (T) ⇒ Any)(implicit f: PairStringPromoter[T]): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of values
default
-- the default value (or Empty if no default value)
attrs
-- the attributes to append to the resulting Elem, these may be name-value pairs (static attributes) or special HTML5 ElemAtts
onSubmit
-- the function to execute on form submission
f
-- the function that converts a T to a Display String.
def selectObj[T](options: Seq[SelectableOption[T]], default: Box[T], onSubmit: (T) ⇒ Any, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
options
-- a list of value and text pairs (value, text to display)
default
-- the default value (or Empty if no default value)
onSubmit
-- the function to execute on form submission
def select_*(opts: Seq[SelectableOption[String]], deflt: Box[String], func: AFuncHolder, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission
Create a select box based on the list with a default value and the function to be executed on form submission
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
func
-- the function to execute on form submission
def span(body: NodeSeq, cmd: JsCmd, attrs: ElemAttr*): Elem

Create a span that will run a JavaScript command when clicked
def submit(value: String, func: () ⇒ Any, attrs: ElemAttr*): Elem

Generates a form submission button.
Generates a form submission button.
value
The label for the button
func
The function that will be executed on form submission
attrs
Optional XHTML element attributes that will be applied to the button
def submitAjaxForm(formId: String, postSubmit: Call): JsCmd

Having a regular form, this method can be used to send the serialized content of the form.
Having a regular form, this method can be used to send the serialized content of the form.
formId
- the id of the form
postSubmit
- the function that needs to be called after a successfull request
def submitAjaxForm(formId: String, func: () ⇒ JsCmd): JsCmd

Submits a form denominated by a formId and execute the func function after form fields functions are executed.
def submitAjaxForm(formId: String): JsCmd

Having a regular form, this method can be used to send the serialized content of the form.
Having a regular form, this method can be used to send the serialized content of the form.
formId
- the id of the form
def submitButton(func: () ⇒ Any, attrs: ElemAttr*): Elem

Generates a form submission button with a default label.
Generates a form submission button with a default label.
func
The function that will be executed on form submission
attrs
Optional XHTML element attributes that will be applied to the button
def submit_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
def swappable(shown: Elem, hidden: (String) ⇒ Elem): Elem
def swappable(shown: Elem, hidden: Elem): Elem

Build a swappable visual element.
Build a swappable visual element. If the shown element is clicked on, it turns into the hidden element and when the hidden element blurs, it swaps into the shown element.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def text(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem
def textAjaxTest(value: String, func: (String) ⇒ Any, ajaxTest: Box[(String) ⇒ JsCmd], attrs: ElemAttr*): Elem
def textAjaxTest(value: String, func: (String) ⇒ Any, ajaxTest: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def textElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem

Generate an input element for the Settable
def text_*(value: String, func: AFuncHolder, ajaxTest: Box[(String) ⇒ JsCmd], attrs: ElemAttr*): Elem
def text_*(value: String, ignoreBlur: Boolean, func: AFuncHolder, ajaxTest: Box[(String) ⇒ JsCmd], attrs: ElemAttr*): Elem
def text_*(value: String, func: AFuncHolder, ajaxTest: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
def text_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
def textarea(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem
def textareaElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
def textarea_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
def toString(): String

Definition Classes
AnyRef → Any
def toggleKids(head: Elem, visible: Boolean, func: () ⇒ JsCmd, kids: Elem): NodeSeq
def untrustedMultiSelect(opts: Seq[SelectableOption[String]], deflt: Seq[String], func: (List[String]) ⇒ Any, attrs: ElemAttr*): NodeSeq

Create a multiple select box based on the list with a default value and the function to be executed on form submission.
Create a multiple select box based on the list with a default value and the function to be executed on form submission. No check is made to see if the resulting value was in the original list. For use with DHTML form updating.
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
func
-- the function to execute on form submission
def untrustedMultiSelect_*(opts: Seq[SelectableOption[String]], deflt: Seq[String], lf: AFuncHolder, attrs: ElemAttr*): NodeSeq

Create a multiple select box based on the list with a default value and the function to be executed on form submission.
Create a multiple select box based on the list with a default value and the function to be executed on form submission. No check is made to see if the resulting value was in the original list. For use with DHTML form updating.
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
def untrustedSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ Any, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission.
Create a select box based on the list with a default value and the function to be executed on form submission. No check is made to see if the resulting value was in the original list. For use with DHTML form updating.
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
func
-- the function to execute on form submission
def untrustedSelect_*(opts: Seq[SelectableOption[String]], deflt: Box[String], func: AFuncHolder, attrs: ElemAttr*): Elem

Create a select box based on the list with a default value and the function to be executed on form submission.
Create a select box based on the list with a default value and the function to be executed on form submission. No check is made to see if the resulting value was in the original list. For use with DHTML form updating.
opts
-- the options. A list of value and text pairs
deflt
-- the default value (or Empty if no default value)
func
-- the function to execute on form submission
def url(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem

Generate a url input element for the Settable.
Generate a url input element for the Settable. At some point there will be graceful fallback for non-HTML5 browsers. FIXME
def url(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem

Generate an input field with type url.
Generate an input field with type url. At some point, there will be graceful fallback for non-HTML5 browsers. FIXME
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object SHtml | package http

trait SHtml extends Loggable

Type Members

class ApplicableElem extends AnyRef

trait AreaShape extends AnyRef

final case class BasicElemAttr(name: String, value: String) extends ElemAttr with Product with Serializable

final case class ChoiceHolder[T](items: Seq[ChoiceItem[T]]) extends Product with Serializable

final case class ChoiceItem[T](key: T, xhtml: NodeSeq) extends Product with Serializable

case class CirclePercentShape(centerX: Int, centerY: Int, radiusPercent: Int) extends AreaShape with Product with Serializable

case class CircleShape(centerX: Int, centerY: Int, radius: Int) extends AreaShape with Product with Serializable

trait ElemAttr extends (Elem) ⇒ Elem

trait PairStringPromoter[T] extends (T) ⇒ String

case class PolyShape(polyCoords: (Int, Int)*) extends AreaShape with Product with Serializable

case class RectShape(left: Int, top: Int, right: Int, bottom: Int) extends AreaShape with Product with Serializable

final case class SelectableOption[+T](value: T, label: String, attrs: ElemAttr*) extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object ChoiceHolder extends Serializable

object ElemAttr

object PairStringPromoter

object SelectableOption extends Serializable

def a(body: NodeSeq, cmd: JsCmd, attrs: ElemAttr*): Elem

def a(jsFunc: Call, body: NodeSeq, attrs: ElemAttr*)(func: ⇒ JsCmd): Elem

def a(body: NodeSeq, attrs: ElemAttr*)(func: ⇒ JsCmd): Elem

def a(func: () ⇒ JsObj, jsonContext: JsonContext, body: NodeSeq, attrs: ElemAttr*): Elem

def a(jsFunc: Call, func: () ⇒ JsCmd, body: NodeSeq, attrs: ElemAttr*): Elem

def a(func: () ⇒ JsCmd, body: NodeSeq, attrs: ElemAttr*): Elem

def ajaxButton(text: String, jsFunc: Call, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxButton(text: String, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxButton(text: NodeSeq, jsFunc: Call, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxButton(text: NodeSeq, jsExp: JsExp, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxButton(text: NodeSeq, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxCall(jsCalcValue: JsExp, jsContext: JsContext, func: (String) ⇒ JsCmd): GUIDJsExp

def ajaxCall(jsCalcValue: JsExp, func: (String) ⇒ JsCmd): GUIDJsExp

def ajaxCheckbox(value: Boolean, jsFunc: Call, func: (Boolean) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxCheckbox(value: Boolean, func: (Boolean) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxCheckboxElem(settable: Settable { type ValueType = Boolean }, jsFunc: Call, attrs: ElemAttr*): Elem

def ajaxCheckboxElem(settable: Settable { type ValueType = Boolean }, attrs: ElemAttr*): Elem

def ajaxEditable(displayContents: ⇒ NodeSeq, editForm: ⇒ NodeSeq, onSubmit: () ⇒ JsCmd): NodeSeq

def ajaxEditableSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], f: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxForm(body: NodeSeq, onSubmit: JsCmd, postSubmit: JsCmd): Elem

def ajaxForm(body: NodeSeq, onSubmit: JsCmd): Elem

def ajaxForm(body: NodeSeq): Elem

def ajaxInvoke(func: () ⇒ JsCmd): GUIDJsExp

def ajaxOnSubmit(func: () ⇒ JsCmd): (NodeSeq) ⇒ NodeSeq

def ajaxRadio[T](opts: Seq[T], deflt: Box[T], ajaxFunc: (T) ⇒ JsCmd, attrs: ElemAttr*): ChoiceHolder[T]

def ajaxSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxSelectElem[T](options: Seq[T], default: Box[T], jsFunc: Call, attrs: ElemAttr*)(onSubmit: (T) ⇒ JsCmd)(implicit f: PairStringPromoter[T]): Elem

def ajaxSelectElem[T](options: Seq[T], default: Box[T], attrs: ElemAttr*)(onSubmit: (T) ⇒ JsCmd)(implicit f: PairStringPromoter[T]): Elem

def ajaxSelectObj[T](options: Seq[SelectableOption[T]], default: Box[T], jsFunc: Call, onSubmit: (T) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxSelectObj[T](options: Seq[SelectableOption[T]], default: Box[T], onSubmit: (T) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxSubmit(value: String, func: () ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxText(value: String, ignoreBlur: Boolean, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxText(value: String, ignoreBlur: Boolean, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxText(value: String, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxText(value: String, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxTextElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem

def ajaxTextarea(value: String, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxTextarea(value: String, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem

def ajaxUntrustedSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], jsFunc: Call, func: (String) ⇒ JsCmd, attrs: (String, String)*): Elem

def ajaxUntrustedSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ JsCmd, attrs: (String, String)*): Elem

def area(shape: AreaShape, func: () ⇒ JsCmd, alt: String, attrs: ElemAttr*): Elem

def area(shape: AreaShape, jsCmd: JsCmd, alt: String, attrs: ElemAttr*): Elem

def area(shape: AreaShape, alt: String, attrs: ElemAttr*): Elem

final def asInstanceOf[T0]: T0

def button(strOrNodeSeq: StringOrNodeSeq, func: () ⇒ Any, attrs: ElemAttr*): Elem

def checkbox(value: Boolean, func: (Boolean) ⇒ Any, attrs: ElemAttr*): NodeSeq

def checkbox[T](possible: Seq[T], actual: Seq[T], func: (Seq[T]) ⇒ Any, attrs: ElemAttr*): ChoiceHolder[T]

def checkboxElem(settable: Settable { type ValueType = Boolean }, attrs: ElemAttr*): NodeSeq

def checkbox_*(value: Boolean, func: AFuncHolder, id: Box[String], attrs: ElemAttr*): NodeSeq

def checkbox_id(value: Boolean, func: (Boolean) ⇒ Any, id: Box[String], attrs: ElemAttr*): NodeSeq

def checkbox_id(settable: Settable { type ValueType = Boolean }, id: Box[String], attrs: ElemAttr*): NodeSeq

def clone(): AnyRef

implicit def elemToApplicable(e: Elem): ApplicableElem

def email(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem

def email(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem

def checkbox_(value: Boolean, func: AFuncHolder, id: Box[String], attrs: ElemAttr): NodeSeq

def hidden_(func: AFuncHolder, attrs: ElemAttr): Elem

def multiSelect_(opts: Seq[SelectableOption[String]], deflt: Seq[String], func: AFuncHolder, attrs: ElemAttr): Elem

def password_(value: String, func: AFuncHolder, attrs: ElemAttr): Elem

def radio_(opts: Seq[String], deflt: Box[String], func: AFuncHolder, attrs: ElemAttr): ChoiceHolder[String]

def select_(opts: Seq[SelectableOption[String]], deflt: Box[String], func: AFuncHolder, attrs: ElemAttr): Elem

def submit_(value: String, func: AFuncHolder, attrs: ElemAttr): Elem