object SHtml extends SHtml
The SHtml object defines a suite of XHTML element generator methods to simplify the creation of markup, particularly with forms and AJAX.
- Alphabetic
- By Inheritance
- SHtml
- SHtml
- Loggable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
class
ApplicableElem
extends AnyRef
- Definition Classes
- SHtml
-
trait
AreaShape
extends AnyRef
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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
Holds a series of choices: HTML for input controls alongside some user defined value
- Definition Classes
- SHtml
-
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
Holds a form control as HTML along with some user defined value
- Definition Classes
- SHtml
-
case class
CirclePercentShape
(centerX: Int, centerY: Int, radiusPercent: Int) extends AreaShape with Product with Serializable
- Definition Classes
- SHtml
-
case class
CircleShape
(centerX: Int, centerY: Int, radius: Int) extends AreaShape with Product with Serializable
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
trait
PairStringPromoter
[T] extends (T) ⇒ String
Convert a T to a String for display in Select, MultiSelect, etc.
Convert a T to a String for display in Select, MultiSelect, etc.
- Definition Classes
- SHtml
-
case class
PolyShape
(polyCoords: (Int, Int)*) extends AreaShape with Product with Serializable
- Definition Classes
- SHtml
-
case class
RectShape
(left: Int, top: Int, right: Int, bottom: Int) extends AreaShape with Product with Serializable
- Definition Classes
- SHtml
-
final
case class
SelectableOption
[+T](value: T, label: String, attrs: ElemAttr*) extends Product with Serializable
- Definition Classes
- SHtml
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
-
def
a(body: NodeSeq, cmd: JsCmd, attrs: ElemAttr*): Elem
Create an anchor that will run a JavaScript command when clicked
Create an anchor that will run a JavaScript command when clicked
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
Create an anchor with a body and the function to be executed when the anchor is clicked
- Definition Classes
- SHtml
-
def
a(func: () ⇒ JsObj, jsonContext: JsonContext, body: NodeSeq, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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"))))
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
ajaxCheckbox(value: Boolean, jsFunc: Call, func: (Boolean) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxCheckbox(value: Boolean, func: (Boolean) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxCheckboxElem(settable: Settable { type ValueType = Boolean }, jsFunc: Call, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxCheckboxElem(settable: Settable { type ValueType = Boolean }, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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 })
- Definition Classes
- SHtml
-
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
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
def
ajaxInvoke(func: () ⇒ JsCmd): GUIDJsExp
- Definition Classes
- SHtml
-
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!"))
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
ajaxSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxSelect(opts: Seq[SelectableOption[String]], deflt: Box[String], func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
ajaxText(value: String, ignoreBlur: Boolean, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxText(value: String, ignoreBlur: Boolean, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxText(value: String, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxText(value: String, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxTextElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxTextarea(value: String, jsFunc: Call, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
ajaxTextarea(value: String, func: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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.
Defines a new checkbox set to { @code value } and running { @code func } when the checkbox is submitted.
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
checkboxElem(settable: Settable { type ValueType = Boolean }, attrs: ElemAttr*): NodeSeq
Defines a new checkbox for the Settable
Defines a new checkbox for the Settable
- Definition Classes
- SHtml
-
def
checkbox_*(value: Boolean, func: AFuncHolder, id: Box[String], attrs: ElemAttr*): NodeSeq
- Definition Classes
- SHtml
-
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 }.
- Definition Classes
- SHtml
-
def
checkbox_id(settable: Settable { type ValueType = Boolean }, id: Box[String], attrs: ElemAttr*): NodeSeq
Defines a new checkbox for the Settable
Defines a new checkbox for the Settable
- Definition Classes
- SHtml
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
implicit
def
elemToApplicable(e: Elem): ApplicableElem
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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>
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
hidden(func: () ⇒ Any, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
hidden_*(func: AFuncHolder, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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"))
- Definition Classes
- SHtml
-
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
Memoize the NodeSeq used in apply() and then call applyAgain() in an Ajax call and you don't have to explicitly capture the template
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
val
logger: Logger
- Attributes
- protected
- Definition Classes
- Loggable
- Annotations
- @transient()
-
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)
- Definition Classes
- SHtml
-
def
makeAjaxCall(in: JsExp): JsExp
Invokes the Ajax request
-
def
makeFormsAjax: (NodeSeq) ⇒ NodeSeq
Vend a function that will take all of the form elements and turns them into Ajax forms
Vend a function that will take all of the form elements and turns them into Ajax forms
- Definition Classes
- SHtml
-
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
Memoize the NodeSeq used in apply() and then call applyAgain() in an Ajax call and you don't have to explicitly capture the template
- Definition Classes
- SHtml
-
def
multiSelect(opts: Seq[SelectableOption[String]], deflt: Seq[String], func: (List[String]) ⇒ Any, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
multiSelect_*(opts: Seq[SelectableOption[String]], deflt: Seq[String], func: AFuncHolder, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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))
- Definition Classes
- SHtml
-
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())
- Definition Classes
- SHtml
-
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))
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
def
password(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
passwordElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
password_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
radio(opts: Seq[String], deflt: Box[String], func: (String) ⇒ Any, attrs: ElemAttr*): ChoiceHolder[String]
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
Generate a collection or radio box items from a sequence of things
- Definition Classes
- SHtml
-
def
radio_*(opts: Seq[String], deflt: Box[String], func: AFuncHolder, attrs: ElemAttr*): ChoiceHolder[String]
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
span(body: NodeSeq, cmd: JsCmd, attrs: ElemAttr*): Elem
Create a span that will run a JavaScript command when clicked
Create a span that will run a JavaScript command when clicked
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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.
Submits a form denominated by a formId and execute the func function after form fields functions are executed.
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
def
submit_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
swappable(shown: Elem, hidden: (String) ⇒ Elem): Elem
- Definition Classes
- SHtml
-
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.
- Definition Classes
- SHtml
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
text(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
textAjaxTest(value: String, func: (String) ⇒ Any, ajaxTest: Box[(String) ⇒ JsCmd], attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
textAjaxTest(value: String, func: (String) ⇒ Any, ajaxTest: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
textElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
Generate an input element for the Settable
Generate an input element for the Settable
- Definition Classes
- SHtml
-
def
text_*(value: String, func: AFuncHolder, ajaxTest: Box[(String) ⇒ JsCmd], attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
text_*(value: String, ignoreBlur: Boolean, func: AFuncHolder, ajaxTest: Box[(String) ⇒ JsCmd], attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
text_*(value: String, func: AFuncHolder, ajaxTest: (String) ⇒ JsCmd, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
text_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
textarea(value: String, func: (String) ⇒ Any, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
textareaElem(settable: Settable { type ValueType = String }, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
textarea_*(value: String, func: AFuncHolder, attrs: ElemAttr*): Elem
- Definition Classes
- SHtml
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
toggleKids(head: Elem, visible: Boolean, func: () ⇒ JsCmd, kids: Elem): NodeSeq
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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)
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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
- Definition Classes
- SHtml
-
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( ... )
-
object
ChoiceHolder
extends Serializable
- Definition Classes
- SHtml
-
object
ElemAttr
The companion object that has some very helpful conversion
The companion object that has some very helpful conversion
- Definition Classes
- SHtml
-
object
PairStringPromoter
A companion object that does implicit conversions
A companion object that does implicit conversions
- Definition Classes
- SHtml
-
object
SelectableOption
extends Serializable
- Definition Classes
- SHtml