Clear Up
SharpKit Reference

Basic Class

Provides input field management, validation, submission, and form loading services for the collection of Field instances within a Ext.container.Container. It is recommended that you use a Ext.form.Panel as the form container, as that has logic to automatically hook up an instance of Ext.form.Basic (plus other conveniences related to field configuration.)

Form Actions

The Basic class delegates the handling of form loads and submits to instances of Ext.form.action.Action. See the various Action implementations for specific details of each one's functionality, as well as the documentation for doAction which details the configuration options that can be specified in each action call.

The default submit Action is Ext.form.action.Submit, which uses an Ajax request to submit the form's values to a configured URL. To enable normal browser submission of an Ext form, use the standardSubmit config option.

File uploads

File uploads are not performed using normal 'Ajax' techniques; see the description for hasUpload for details. If you're using file uploads you should read the method description.

Example usage:

  
    Ext.create('Ext.form.Panel', {
            title: 'Basic Form',
            renderTo: Ext.getBody(),
            bodyPadding: 5,
            width: 350,
            // Any configuration items here will be automatically passed along to
            // the Ext.form.Basic instance when it gets created.
            // The form will submit an AJAX request to this URL when submitted
            url: 'save-form.php',
            items: [{
            xtype: 'textfield',
            fieldLabel: 'Field',
            name: 'theField'
            }],
            buttons: [{
            text: 'Submit',
            handler: function() {
            // The getForm() method returns the Ext.form.Basic instance:
            var form = this.up('form').getForm();
            if (form.isValid()) {
            // Submit the Ajax request and handle the response
            form.submit({
            success: function(form, action) {
            Ext.Msg.alert('Success', action.result.message);
            },
            failure: function(form, action) {
            Ext.Msg.alert('Failed', action.result ? action.result.message : 'No response');
            }
            });
            }
            }
            }]
            });
            

Namespace: Ext.form

Base Types

System.Object

Base Interfaces

Constructors

Methods

Name Description
addEvents(object) Adds the specified events to the list of events which this Observable may fire.
addListener(object, Delegate, object, object) Appends an event handler to this object. For example:
myGridPanel.on("mouseover", this.onMouseOver, this);
            
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
            cellClick: this.onCellClick,
            mouseover: this.onMouseOver,
            mouseout: this.onMouseOut,
            scope: this // Important. Ensure "this" is correct during handler execution
            });
            
One can also specify options for each event handler separately:
myGridPanel.on({
            cellClick: {fn: this.onCellClick, scope: this, single: true},
            mouseover: {fn: panel.onMouseOver, scope: panel}
            });
            
Names of methods in a specified scope may also be used. Note that scope MUST be specified to use this option:
myGridPanel.on({
            cellClick: {fn: 'onCellClick', scope: this, single: true},
            mouseover: {fn: 'onMouseOver', scope: panel}
            });
            
addManagedListener(object, object, Delegate, object, object) Adds listeners to any Observable object (or Ext.Element) which are automatically removed when this Component is destroyed.
applyIfToFields(object) Calls Ext.applyIf for all field in this form with the passed object.
applyToFields(object) Calls Ext.apply for all fields in this form with the passed object.
checkDirty() Check whether the dirty state of the entire form has changed since it was last checked, and if so fire the dirtychange event. This is automatically invoked when an individual field's dirty state changes.
checkValidity() Check whether the validity of the entire form has changed since it was last checked, and if so fire the validitychange event. This is automatically invoked when an individual field's validity changes.
clearInvalid() Clears all invalid field messages in this form.
clearListeners() Removes all listeners for this object including the managed listeners
clearManagedListeners() Removes all managed listeners for this object.
continueFireEvent(JsString, object, object) Continue to fire event.
createRelayer(object, object) Creates an event handling function which refires the event from this object as the passed event name.
destroy() Destroys this object. Overrides: Ext.Base.destroy
doAction(object, object) Performs a predefined action (an implementation of Ext.form.action.Action) to perform application- specific processing.
enableBubble(object) Enables events fired by this Observable to bubble up an owner hierarchy by calling this.getBubbleTarget() if present. There is no implementation in the Observable base class. This is commonly used by Ext.Components to bubble events to owner Containers. See Ext.Component.getBubbleTarget. The default implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to access the required target more quickly. Example:
  Ext.override(Ext.form.field.Base, {
            //  Add functionality to Field's initComponent to enable the change event to bubble
            initComponent : Ext.Function.createSequence(Ext.form.field.Base.prototype.initComponent, function() {
            this.enableBubble('change');
            }),
            //  We know that we want Field's events to bubble directly to the FormPanel.
            getBubbleTarget : function() {
            if (!this.formPanel) {
            this.formPanel = this.findParentByType('form');
            }
            return this.formPanel;
            }
            });
            var myForm = new Ext.formPanel({
            title: 'User Details',
            items: [{
            ...
            }],
            listeners: {
            change: function() {
            // Title goes red if form has been modified.
            myForm.header.setStyle('color', 'red');
            }
            }
            });
            
findField(JsString) Find a specific Ext.form.field.Field in this form by id or name.
fireEvent(JsString, Object[]) Fires the specified event with the passed parameters (minus the event name, plus the options object passed to addListener). An event may be set to bubble up an Observable parent hierarchy (See Ext.Component.getBubbleTarget) by calling enableBubble.
getBubbleParent() Gets the bubbling parent for an Observable
getFields() Return all the Ext.form.field.Field components in the owner container.
getFieldValues(object) Retrieves the fields in the form as a set of key/value pairs, using their getModelData() method to collect the values. If multiple fields return values under the same name those values will be combined into an Array. This is similar to getValues except that this method collects type-specific data values (e.g. Date objects for date fields) while getValues returns only String values for submission.
getRecord() Returns the last Ext.data.Model instance that was loaded via loadRecord
getValues(object, object, object, object) Retrieves the fields in the form as a set of key/value pairs, using their getSubmitData() method to collect the values. If multiple fields return values under the same name those values will be combined into an Array. This is similar to getFieldValues except that this method collects only String values for submission, while getFieldValues collects type-specific data values (e.g. Date objects for date fields.)
hasInvalidField() Returns true if the form contains any invalid fields. No fields will be marked as invalid as a result of calling this; to trigger marking of fields use isValid instead.
hasListener(JsString) Checks to see if this object has any listeners for a specified event, or whether the event bubbles. The answer indicates whether the event needs firing or not.
hasUpload() Returns true if the form contains a file upload field. This is used to determine the method for submitting the form: File uploads are not performed using normal 'Ajax' techniques, that is they are not performed using XMLHttpRequests. Instead a hidden <form> element containing all the fields is created temporarily and submitted with its target set to refer to a dynamically generated, hidden <iframe> which is inserted into the document but removed after the return data has been gathered. The server response is parsed by the browser to create the document for the IFRAME. If the server is using JSON to send the return object, then the Content-Type header must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body. Characters which are significant to an HTML parser must be sent as HTML entities, so encode "<" as "&lt;", "&" as "&amp;" etc. The response text is retrieved from the document, and a fake XMLHttpRequest object is created containing a responseText property in order to conform to the requirements of event handlers and callbacks. Be aware that file upload packets are sent with the content type multipart/form and some server technologies (notably JEE) may require some custom processing in order to retrieve parameter names and parameter values from the packet content.
isDirty() Returns true if any fields in this form have changed from their original values. Note that if this BasicForm was configured with trackResetOnLoad then the Fields' original values are updated when the values are loaded by setValues or loadRecord.
isValid() Returns true if client-side validation on the form is successful. Any invalid fields will be marked as invalid. If you only want to determine overall form validity without marking anything, use hasInvalidField instead.
load(object) Shortcut to do a load action.
loadRecord(Model) Loads an Ext.data.Model into this form by calling setValues with the record data. See also trackResetOnLoad.
markInvalid(object) Mark fields in this form invalid in bulk.
mon(object, object, Delegate, object, object) Shorthand for addManagedListener. Adds listeners to any Observable object (or Ext.Element) which are automatically removed when this Component is destroyed.
mun(object, object, Delegate, object) Shorthand for removeManagedListener. Removes listeners that were added by the mon method.
on(object, Delegate, object, object) Shorthand for addListener. Appends an event handler to this object. For example:
myGridPanel.on("mouseover", this.onMouseOver, this);
            
The method also allows for a single argument to be passed which is a config object containing properties which specify multiple events. For example:
myGridPanel.on({
            cellClick: this.onCellClick,
            mouseover: this.onMouseOver,
            mouseout: this.onMouseOut,
            scope: this // Important. Ensure "this" is correct during handler execution
            });
            
One can also specify options for each event handler separately:
myGridPanel.on({
            cellClick: {fn: this.onCellClick, scope: this, single: true},
            mouseover: {fn: panel.onMouseOver, scope: panel}
            });
            
Names of methods in a specified scope may also be used. Note that scope MUST be specified to use this option:
myGridPanel.on({
            cellClick: {fn: 'onCellClick', scope: this, single: true},
            mouseover: {fn: 'onMouseOver', scope: panel}
            });
            
prepareClass(Delegate) Prepares a given class for observable instances. This method is called when a class derives from this class or uses this class as a mixin.
relayEvents(object, JsArray<T>, object) Relays selected events from the specified Observable as if the events were fired by this. For example if you are extending Grid, you might decide to forward some events from store. So you can do this inside your initComponent:
this.relayEvents(this.getStore(), ['load']);
            
The grid instance will then have an observable 'load' event which will be passed the parameters of the store's load event and any function fired with the grid's load event would have access to the grid using the this keyword.
removeListener(JsString, Delegate, object) Removes an event handler.
removeManagedListener(object, object, Delegate, object) Removes listeners that were added by the mon method.
removeManagedListenerItem(bool, object) Remove a single managed listener item
reset() Resets all fields in this form.
resumeEvents() Resumes firing events (see suspendEvents). If events were suspended using the queueSuspended parameter, then all events fired during event suspension will be sent to any listeners now.
setValues(object) Set values for fields in this form in bulk.
submit(object) Shortcut to do a submit action. This will use the AJAX submit action by default. If the standardSubmit config is enabled it will use a standard form element to submit, or if the api config is present it will use the Ext.direct.Direct submit action. The following code:
myFormPanel.getForm().submit({
            clientValidation: true,
            url: 'updateConsignment.php',
            params: {
            newStatus: 'delivered'
            },
            success: function(form, action) {
            Ext.Msg.alert('Success', action.result.msg);
            },
            failure: function(form, action) {
            switch (action.failureType) {
            case Ext.form.action.Action.CLIENT_INVALID:
            Ext.Msg.alert('Failure', 'Form fields may not be submitted with invalid values');
            break;
            case Ext.form.action.Action.CONNECT_FAILURE:
            Ext.Msg.alert('Failure', 'Ajax communication failed');
            break;
            case Ext.form.action.Action.SERVER_INVALID:
            Ext.Msg.alert('Failure', action.result.msg);
            }
            }
            });
            
would process the following server response for a successful submission:
{
            "success":true, // note this is Boolean, not string
            "msg":"Consignment updated"
            }
            
and the following server response for a failed submission:
{
            "success":false, // note this is Boolean, not string
            "msg":"You do not have permission to perform this operation"
            }
            
suspendEvents(bool) Suspends the firing of all events. (see resumeEvents)
un(JsString, Delegate, object) Shorthand for removeListener. Removes an event handler.
updateRecord(object) Persists the values in this form into the passed Ext.data.Model object in a beginEdit/endEdit block. If the record is not specified, it will attempt to update (if it exists) the record provided to loadRecord.

Fields

Name Description
api If specified, load and submit actions will be handled with DirectLoad and DirectSubmit. Methods which have been imported by Ext.direct.Manager can be specified here to load and submit forms. API methods may also be specified as strings. See Ext.data.proxy.Direct.directFn. Such as the following:
api: {
            load: App.ss.MyProfile.load,
            submit: App.ss.MyProfile.submit
            }
            
Load actions can use paramOrder or paramsAsHash to customize how the load method is invoked. Submit actions will always use a standard form submit. The formHandler configuration (see Ext.direct.RemotingProvider#action) must be set on the associated server-side method which has been imported by Ext.direct.Manager.
baseParams Parameters to pass with all requests. e.g. baseParams: {id: '123', foo: 'bar'}. Parameters are encoded as standard HTTP parameters using Ext.Object.toQueryString.
errorReader An Ext.data.DataReader (e.g. Ext.data.reader.Xml) to be used to read field error messages returned from 'submit' actions. This is optional as there is built-in support for processing JSON responses. The Records which provide messages for the invalid Fields must use the Field name (or id) as the Record ID, and must contain a field called 'msg' which contains the error message. The errorReader does not have to be a full-blown implementation of a Reader. It simply needs to implement a read(xhr) function which returns an Array of Records in an object with the following structure:
{
            records: recordArray
            }
            
listeners A config object containing one or more event handlers to be added to this object during initialization. This should be a valid listeners config object as specified in the addListener example for attaching multiple handlers at once. DOM events from Ext JS Components While some Ext JS Component classes export selected DOM events (e.g. "click", "mouseover" etc), this is usually only done when extra value can be added. For example the DataView's itemclick event passing the node clicked on. To access DOM events directly from a child element of a Component, we need to specify the element option to identify the Component property to add a DOM listener to:
new Ext.panel.Panel({
            width: 400,
            height: 200,
            dockedItems: [{
            xtype: 'toolbar'
            }],
            listeners: {
            click: {
            element: 'el', //bind to the underlying el property on the panel
            fn: function(){ console.log('click el'); }
            },
            dblclick: {
            element: 'body', //bind to the underlying body property on the panel
            fn: function(){ console.log('dblclick body'); }
            }
            }
            });
            
method The request method to use (GET or POST) for form actions if one isn't supplied in the action options.
paramOrder A list of params to be executed server side. Only used for the api load configuration. Specify the params in the order in which they must be executed on the server-side as either (1) an Array of String values, or (2) a String of params delimited by either whitespace, comma, or pipe. For example, any of the following would be acceptable:
paramOrder: ['param1','param2','param3']
            paramOrder: 'param1 param2 param3'
            paramOrder: 'param1,param2,param3'
            paramOrder: 'param1|param2|param'
            
paramsAsHash Only used for the api load configuration. If true, parameters will be sent as a single hash collection of named arguments. Providing a paramOrder nullifies this configuration. Defaults to: false
reader An Ext.data.DataReader (e.g. Ext.data.reader.Xml) to be used to read data when executing 'load' actions. This is optional as there is built-in support for processing JSON responses.
standardSubmit If set to true, a standard HTML form submit is used instead of a XHR (Ajax) style form submission. All of the field values, plus any additional params configured via baseParams and/or the options to submit, will be included in the values submitted in the form.
timeout Timeout for form actions in seconds. Defaults to: 30
trackResetOnLoad If set to true, reset() resets to the last loaded or setValues() data instead of when the form was first created. Defaults to: false
url The URL to use for form actions if one isn't supplied in the doAction options.
waitMsgTarget By default wait messages are displayed with Ext.MessageBox.wait. You can target a specific element by passing it or its id or mask the form itself by passing in true.
waitTitle The default title to show for the waiting message box Defaults to: "Please Wait..."

Properties

Name Description
className Defaults to: "Ext.Base"
configMap Defaults to: {}
eventsSuspended Initial suspended call count. Incremented when suspendEvents is called, decremented when resumeEvents is called. Defaults to: 0
hasListeners This object holds a key for any event that has a listener. The listener may be set directly on the instance, or on its class or a super class (via observe) or on the MVC EventBus. The values of this object are truthy (a non-zero number) and falsy (0 or undefined). They do not represent an exact count of listeners. The value for an event is truthy if the event must be fired and is falsy if there is no need to fire the event. The intended use of this property is to avoid the expense of fireEvent calls when there are no listeners. This can be particularly helpful when one would otherwise have to call fireEvent hundreds or thousands of times. It is used like this:
if (this.hasListeners.foo) {
           this.fireEvent('foo', this, arg1);
           }
            
initConfigList Defaults to: []
initConfigMap Defaults to: {}
isInstance Defaults to: true
isObservable true in this class to identify an object as an instantiated Observable, or subclass thereof. Defaults to: true
owner The container component to which this BasicForm is attached.
self Get the reference to the current class from which this object was instantiated. Unlike statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See statics for a detailed comparison
  Ext.define('My.Cat', {
            statics: {
            speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
            },
            constructor: function() {
            alert(this.self.speciesName); // dependent on 'this'
            },
            clone: function() {
            return new this.self();
            }
            });
            Ext.define('My.SnowLeopard', {
            extend: 'My.Cat',
            statics: {
            speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
            }
            });
            var cat = new My.Cat();                     // alerts 'Cat'
            var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'
            var clone = snowLeopard.clone();
            alert(Ext.getClassName(clone));             // alerts 'My.SnowLeopard'
            
© Copyright 2005-2011 SharpKit. All rights reserved.