中间件编程

开发平台：

JavaScript

pkg-forms-debug.js：源码内容

var r = s.getRangeAt(0);
r.selectNodeContents(this.getEditorBody());
r.collapse(true);
this.deferFocus();
}
try{
this.execCmd('useCSS', true);
this.execCmd('styleWithCSS', false);
}catch(e){}
}
this.fireEvent('activate', this);
},
// private
adjustFont: function(btn){
var adjust = btn.itemId == 'increasefontsize' ? 1 : -1;
var v = parseInt(this.doc.queryCommandValue('FontSize') || 2, 10);
if((Ext.isSafari && !Ext.isSafari2) || Ext.isChrome || Ext.isAir){
// Safari 3 values
// 1 = 10px, 2 = 13px, 3 = 16px, 4 = 18px, 5 = 24px, 6 = 32px
if(v <= 10){
v = 1 + adjust;
}else if(v <= 13){
v = 2 + adjust;
}else if(v <= 16){
v = 3 + adjust;
}else if(v <= 18){
v = 4 + adjust;
}else if(v <= 24){
v = 5 + adjust;
}else {
v = 6 + adjust;
}
v = v.constrain(1, 6);
}else{
if(Ext.isSafari){ // safari
adjust *= 2;
}
v = Math.max(1, v+adjust) + (Ext.isSafari ? 'px' : 0);
}
this.execCmd('FontSize', v);
},
// private
onEditorEvent : function(e){
this.updateToolbar();
},
/**
* Protected method that will not generally be called directly. It triggers
* a toolbar update by reading the markup state of the current selection in the editor.
*/
updateToolbar: function(){
if(!this.activated){
this.onFirstFocus();
return;
}
var btns = this.tb.items.map, doc = this.doc;
if(this.enableFont && !Ext.isSafari2){
var name = (this.doc.queryCommandValue('FontName')||this.defaultFont).toLowerCase();
if(name != this.fontSelect.dom.value){
this.fontSelect.dom.value = name;
}
}
if(this.enableFormat){
btns.bold.toggle(doc.queryCommandState('bold'));
btns.italic.toggle(doc.queryCommandState('italic'));
btns.underline.toggle(doc.queryCommandState('underline'));
}
if(this.enableAlignments){
btns.justifyleft.toggle(doc.queryCommandState('justifyleft'));
btns.justifycenter.toggle(doc.queryCommandState('justifycenter'));
btns.justifyright.toggle(doc.queryCommandState('justifyright'));
}
if(!Ext.isSafari2 && this.enableLists){
btns.insertorderedlist.toggle(doc.queryCommandState('insertorderedlist'));
btns.insertunorderedlist.toggle(doc.queryCommandState('insertunorderedlist'));
}
Ext.menu.MenuMgr.hideAll();
this.syncValue();
},
// private
relayBtnCmd : function(btn){
this.relayCmd(btn.itemId);
},
/**
* Executes a Midas editor command on the editor document and performs necessary focus and
* toolbar updates. This should only be called after the editor is initialized.
* @param {String} cmd The Midas command
* @param {String/Boolean} value (optional) The value to pass to the command (defaults to null)
*/
relayCmd : function(cmd, value){
(function(){
this.focus();
this.execCmd(cmd, value);
this.updateToolbar();
}).defer(10, this);
},
/**
* Executes a Midas editor command directly on the editor document.
* For visual commands, you should use {@link #relayCmd} instead.
* This should only be called after the editor is initialized.
* @param {String} cmd The Midas command
* @param {String/Boolean} value (optional) The value to pass to the command (defaults to null)
*/
execCmd : function(cmd, value){
this.doc.execCommand(cmd, false, value === undefined ? null : value);
this.syncValue();
},
// private
applyCommand : function(e){
if(e.ctrlKey){
var c = e.getCharCode(), cmd;
if(c > 0){
c = String.fromCharCode(c);
switch(c){
case 'b':
cmd = 'bold';
break;
case 'i':
cmd = 'italic';
break;
case 'u':
cmd = 'underline';
break;
}
if(cmd){
this.win.focus();
this.execCmd(cmd);
this.deferFocus();
e.preventDefault();
}
}
}
},
/**
* Inserts the passed text at the current cursor position. Note: the editor must be initialized and activated
* to insert text.
* @param {String} text
*/
insertAtCursor : function(text){
if(!this.activated){
return;
}
if(Ext.isIE){
this.win.focus();
var r = this.doc.selection.createRange();
if(r){
r.collapse(true);
r.pasteHTML(text);
this.syncValue();
this.deferFocus();
}
}else if(Ext.isGecko || Ext.isOpera){
this.win.focus();
this.execCmd('InsertHTML', text);
this.deferFocus();
}else if(Ext.isWebKit){
this.execCmd('InsertText', text);
this.deferFocus();
}
},
// private
fixKeys : function(){ // load time branching for fastest keydown performance
if(Ext.isIE){
return function(e){
var k = e.getKey(), r;
if(k == e.TAB){
e.stopEvent();
r = this.doc.selection.createRange();
if(r){
r.collapse(true);
r.pasteHTML('    ');
this.deferFocus();
}
}else if(k == e.ENTER){
r = this.doc.selection.createRange();
if(r){
var target = r.parentElement();
if(!target || target.tagName.toLowerCase() != 'li'){
e.stopEvent();
r.pasteHTML(' ');
r.collapse(false);
r.select();
}
}
}
};
}else if(Ext.isOpera){
return function(e){
var k = e.getKey();
if(k == e.TAB){
e.stopEvent();
this.win.focus();
this.execCmd('InsertHTML','    ');
this.deferFocus();
}
};
}else if(Ext.isWebKit){
return function(e){
var k = e.getKey();
if(k == e.TAB){
e.stopEvent();
this.execCmd('InsertText','t');
this.deferFocus();
}
};
}
}(),
/**
* Returns the editor's toolbar. This is only available after the editor has been rendered.
* @return {Ext.Toolbar}
*/
getToolbar : function(){
return this.tb;
},
/**
* Object collection of toolbar tooltips for the buttons in the editor. The key
* is the command id associated with that button and the value is a valid QuickTips object.
* For example:
<pre><code>
{
bold : {
title: 'Bold (Ctrl+B)',
text: 'Make the selected text bold.',
cls: 'x-html-editor-tip'
},
italic : {
title: 'Italic (Ctrl+I)',
text: 'Make the selected text italic.',
cls: 'x-html-editor-tip'
},
...
</code></pre>
* @type Object
*/
buttonTips : {
bold : {
title: 'Bold (Ctrl+B)',
text: 'Make the selected text bold.',
cls: 'x-html-editor-tip'
},
italic : {
title: 'Italic (Ctrl+I)',
text: 'Make the selected text italic.',
cls: 'x-html-editor-tip'
},
underline : {
title: 'Underline (Ctrl+U)',
text: 'Underline the selected text.',
cls: 'x-html-editor-tip'
},
increasefontsize : {
title: 'Grow Text',
text: 'Increase the font size.',
cls: 'x-html-editor-tip'
},
decreasefontsize : {
title: 'Shrink Text',
text: 'Decrease the font size.',
cls: 'x-html-editor-tip'
},
backcolor : {
title: 'Text Highlight Color',
text: 'Change the background color of the selected text.',
cls: 'x-html-editor-tip'
},
forecolor : {
title: 'Font Color',
text: 'Change the color of the selected text.',
cls: 'x-html-editor-tip'
},
justifyleft : {
title: 'Align Text Left',
text: 'Align text to the left.',
cls: 'x-html-editor-tip'
},
justifycenter : {
title: 'Center Text',
text: 'Center text in the editor.',
cls: 'x-html-editor-tip'
},
justifyright : {
title: 'Align Text Right',
text: 'Align text to the right.',
cls: 'x-html-editor-tip'
},
insertunorderedlist : {
title: 'Bullet List',
text: 'Start a bulleted list.',
cls: 'x-html-editor-tip'
},
insertorderedlist : {
title: 'Numbered List',
text: 'Start a numbered list.',
cls: 'x-html-editor-tip'
},
createlink : {
title: 'Hyperlink',
text: 'Make the selected text a hyperlink.',
cls: 'x-html-editor-tip'
},
sourceedit : {
title: 'Source Edit',
text: 'Switch to source editing mode.',
cls: 'x-html-editor-tip'
}
}
// hide stuff that is not compatible
/**
* @event blur
* @hide
*/
/**
* @event change
* @hide
*/
/**
* @event focus
* @hide
*/
/**
* @event specialkey
* @hide
*/
/**
* @cfg {String} fieldClass @hide
*/
/**
* @cfg {String} focusClass @hide
*/
/**
* @cfg {String} autoCreate @hide
*/
/**
* @cfg {String} inputType @hide
*/
/**
* @cfg {String} invalidClass @hide
*/
/**
* @cfg {String} invalidText @hide
*/
/**
* @cfg {String} msgFx @hide
*/
/**
* @cfg {String} validateOnBlur @hide
*/
/**
* @cfg {Boolean} allowDomMove @hide
*/
/**
* @cfg {String} applyTo @hide
*/
/**
* @cfg {String} autoHeight @hide
*/
/**
* @cfg {String} autoWidth @hide
*/
/**
* @cfg {String} cls @hide
*/
/**
* @cfg {String} disabled @hide
*/
/**
* @cfg {String} disabledClass @hide
*/
/**
* @cfg {String} msgTarget @hide
*/
/**
* @cfg {String} readOnly @hide
*/
/**
* @cfg {String} style @hide
*/
/**
* @cfg {String} validationDelay @hide
*/
/**
* @cfg {String} validationEvent @hide
*/
/**
* @cfg {String} tabIndex @hide
*/
/**
* @property disabled
* @hide
*/
/**
* @method applyToMarkup
* @hide
*/
/**
* @method disable
* @hide
*/
/**
* @method enable
* @hide
*/
/**
* @method validate
* @hide
*/
/**
* @event valid
* @hide
*/
/**
* @method setDisabled
* @hide
*/
/**
* @cfg keys
* @hide
*/
});
Ext.reg('htmleditor', Ext.form.HtmlEditor);/**
* @class Ext.form.TimeField
* @extends Ext.form.ComboBox
* Provides a time input field with a time dropdown and automatic time validation. Example usage:
* <pre><code>
new Ext.form.TimeField({
minValue: '9:00 AM',
maxValue: '6:00 PM',
increment: 30
});
</code></pre>
* @constructor
* Create a new TimeField
* @param {Object} config
* @xtype timefield
*/
Ext.form.TimeField = Ext.extend(Ext.form.ComboBox, {
/**
* @cfg {Date/String} minValue
* The minimum allowed time. Can be either a Javascript date object with a valid time value or a string
* time in a valid format -- see {@link #format} and {@link #altFormats} (defaults to null).
*/
minValue : null,
/**
* @cfg {Date/String} maxValue
* The maximum allowed time. Can be either a Javascript date object with a valid time value or a string
* time in a valid format -- see {@link #format} and {@link #altFormats} (defaults to null).
*/
maxValue : null,
/**
* @cfg {String} minText
* The error text to display when the date in the cell is before minValue (defaults to
* 'The time in this field must be equal to or after {0}').
*/
minText : "The time in this field must be equal to or after {0}",
/**
* @cfg {String} maxText
* The error text to display when the time is after maxValue (defaults to
* 'The time in this field must be equal to or before {0}').
*/
maxText : "The time in this field must be equal to or before {0}",
/**
* @cfg {String} invalidText
* The error text to display when the time in the field is invalid (defaults to
* '{value} is not a valid time').
*/
invalidText : "{0} is not a valid time",
/**
* @cfg {String} format
* The default time format string which can be overriden for localization support. The format must be
* valid according to {@link Date#parseDate} (defaults to 'g:i A', e.g., '3:15 PM'). For 24-hour time
* format try 'H:i' instead.
*/
format : "g:i A",
/**
* @cfg {String} altFormats
* Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined
* format (defaults to 'g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H').
*/
altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H",
/**
* @cfg {Number} increment
* The number of minutes between each time value in the list (defaults to 15).
*/
increment: 15,
// private override
mode: 'local',
// private override
triggerAction: 'all',
// private override
typeAhead: false,
// private - This is the date to use when generating time values in the absence of either minValue
// or maxValue. Using the current date causes DST issues on DST boundary dates, so this is an
// arbitrary "safe" date that can be any date aside from DST boundary dates.
initDate: '1/1/2008',
// private
initComponent : function(){
if(typeof this.minValue == "string"){
this.minValue = this.parseDate(this.minValue);
}
if(typeof this.maxValue == "string"){
this.maxValue = this.parseDate(this.maxValue);
}
if(!this.store){
var min = this.parseDate(this.minValue) || new Date(this.initDate).clearTime();
var max = this.parseDate(this.maxValue) || new Date(this.initDate).clearTime().add('mi', (24 * 60) - 1);
var times = [];
while(min <= max){
times.push(min.dateFormat(this.format));
min = min.add('mi', this.increment);
}
this.store = times;
}
Ext.form.TimeField.superclass.initComponent.call(this);
},
// inherited docs
getValue : function(){
var v = Ext.form.TimeField.superclass.getValue.call(this);
return this.formatDate(this.parseDate(v)) || '';
},
// inherited docs
setValue : function(value){
return Ext.form.TimeField.superclass.setValue.call(this, this.formatDate(this.parseDate(value)));
},
// private overrides
validateValue : Ext.form.DateField.prototype.validateValue,
parseDate : Ext.form.DateField.prototype.parseDate,
formatDate : Ext.form.DateField.prototype.formatDate,
// private
beforeBlur : function(){
var v = this.parseDate(this.getRawValue());
if(v){
this.setValue(v.dateFormat(this.format));
}
Ext.form.TimeField.superclass.beforeBlur.call(this);
}
/**
* @cfg {Boolean} grow @hide
*/
/**
* @cfg {Number} growMin @hide
*/
/**
* @cfg {Number} growMax @hide
*/
/**
* @hide
* @method autoSize
*/
});
Ext.reg('timefield', Ext.form.TimeField);/** * @class Ext.form.Label * @extends Ext.BoxComponent * Basic Label field. * @constructor * Creates a new Label * @param {Ext.Element/String/Object} config The configuration options. If an element is passed, it is set as the internal * element and its id used as the component id. If a string is passed, it is assumed to be the id of an existing element * and is used as the component id. Otherwise, it is assumed to be a standard config object and is applied to the component. * @xtype label */ Ext.form.Label = Ext.extend(Ext.BoxComponent, { /** * @cfg {String} text The plain text to display within the label (defaults to ''). If you need to include HTML * tags within the label's innerHTML, use the {@link #html} config instead. */ /** * @cfg {String} forId The id of the input element to which this label will be bound via the standard HTML 'for' * attribute. If not specified, the attribute will not be added to the label. */ /** * @cfg {String} html An HTML fragment that will be used as the label's innerHTML (defaults to ''). * Note that if {@link #text} is specified it will take precedence and this value will be ignored. */ // private onRender : function(ct, position){ if(!this.el){ this.el = document.createElement('label'); this.el.id = this.getId(); this.el.innerHTML = this.text ? Ext.util.Format.htmlEncode(this.text) : (this.html || ''); if(this.forId){ this.el.setAttribute('for', this.forId); } } Ext.form.Label.superclass.onRender.call(this, ct, position); }, /** * Updates the label's innerHTML with the specified string. * @param {String} text The new label text * @param {Boolean} encode (optional) False to skip HTML-encoding the text when rendering it * to the label (defaults to true which encodes the value). This might be useful if you want to include * tags in the label's innerHTML rather than rendering them as string literals per the default logic. * @return {Label} this */ setText : function(t, encode){ var e = encode === false; this[!e ? 'text' : 'html'] = t; delete this[e ? 'text' : 'html']; if(this.rendered){ this.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(t) : t; } return this; } }); Ext.reg('label', Ext.form.Label);/** * @class Ext.form.Action * The subclasses of this class provide actions to perform upon {@link Ext.form.BasicForm Form}s. * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when * the Form needs to perform an action such as submit or load. The Configuration options * listed for this class are set through the Form's action methods: {@link Ext.form.BasicForm#submit submit}, * {@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction} * The instance of Action which performed the action is passed to the success * and failure callbacks of the Form's action methods ({@link Ext.form.BasicForm#submit submit}, * {@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction}), * and to the {@link Ext.form.BasicForm#actioncomplete actioncomplete} and * {@link Ext.form.BasicForm#actionfailed actionfailed} event handlers. */ Ext.form.Action = function(form, options){ this.form = form; this.options = options || {}; }; /** * Failure type returned when client side validation of the Form fails * thus aborting a submit action. Client side validation is performed unless * {@link #clientValidation} is explicitly set to <tt>false</tt>. * @type {String} * @static */ Ext.form.Action.CLIENT_INVALID = 'client'; /** * Failure type returned when server side processing fails and the {@link #result}'s * <tt style="font-weight:bold">success</tt> property is set to <tt>false</tt>. * In the case of a form submission, field-specific error messages may be returned in the * {@link #result}'s <tt style="font-weight:bold">errors</tt> property. * @type {String} * @static */ Ext.form.Action.SERVER_INVALID = 'server'; /** * Failure type returned when a communication error happens when attempting * to send a request to the remote server. The {@link #response} may be examined to * provide further information. * @type {String} * @static */ Ext.form.Action.CONNECT_FAILURE = 'connect'; /** * Failure type returned when the response's <tt style="font-weight:bold">success</tt> * property is set to <tt>false</tt>, or no field values are returned in the response's * <tt style="font-weight:bold">data</tt> property. * @type {String} * @static */ Ext.form.Action.LOAD_FAILURE = 'load'; Ext.form.Action.prototype = { /** * @cfg {String} url The URL that the Action is to invoke. */ /** * @cfg {Boolean} reset When set to <tt>true</tt>, causes the Form to be * {@link Ext.form.BasicForm.reset reset} on Action success. If specified, this happens * before the {@link #success} callback is called and before the Form's * {@link Ext.form.BasicForm.actioncomplete actioncomplete} event fires. */ /** * @cfg {String} method The HTTP method to use to access the requested URL. Defaults to the * {@link Ext.form.BasicForm}'s method, or if that is not specified, the underlying DOM form's method. */ /** * @cfg {Mixed} params Extra parameter values to pass. These are added to the Form's * {@link Ext.form.BasicForm#baseParams} and passed to the specified URL along with the Form's * input fields. * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. */ /** * @cfg {Number} timeout The number of seconds to wait for a server response before * failing with the {@link #failureType} as {@link #Action.CONNECT_FAILURE}. If not specified, * defaults to the configured <tt>{@link Ext.form.BasicForm#timeout timeout}</tt> of the * {@link Ext.form.BasicForm form}. */ /** * @cfg {Function} success The function to call when a valid success return packet is recieved. * The function is passed the following parameters:<ul class="mdetail-params"> * <li>form : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li> * <li>action : Ext.form.Action<div class="sub-desc">The Action class. The {@link #result} * property of this object may be examined to perform custom postprocessing.</div></li> * </ul> */ /** * @cfg {Function} failure The function to call when a failure packet was recieved, or when an * error ocurred in the Ajax communication. * The function is passed the following parameters:<ul class="mdetail-params"> * <li>form : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li> * <li>action : Ext.form.Action<div class="sub-desc">The Action class. If an Ajax * error ocurred, the failure type will be in {@link #failureType}. The {@link #result} * property of this object may be examined to perform custom postprocessing.</div></li> * </ul> */ /** * @cfg {Object} scope The scope in which to call the callback functions (The <tt>this</tt> reference * for the callback functions). */ /** * @cfg {String} waitMsg The message to be displayed by a call to {@link Ext.MessageBox#wait} * during the time the action is being processed. */ /** * @cfg {String} waitTitle The title to be displayed by a call to {@link Ext.MessageBox#wait} * during the time the action is being processed. */ /** * The type of action this Action instance performs. * Currently only "submit" and "load" are supported. * @type {String} */ type : 'default', /** * The type of failure detected will be one of these: {@link #CLIENT_INVALID}, * {@link #SERVER_INVALID}, {@link #CONNECT_FAILURE}, or {@link #LOAD_FAILURE}. Usage: * <pre><code> var fp = new Ext.form.FormPanel({ ... buttons: [{ text: 'Save', formBind: true, handler: function(){ if(fp.getForm().isValid()){ fp.getForm().submit({ url: 'form-submit.php', waitMsg: 'Submitting your data...', success: function(form, action){ // server responded with success = true var result = action.{@link #result}; }, failure: function(form, action){ if (action.{@link #failureType} === Ext.form.Action.{@link #CONNECT_FAILURE}) { Ext.Msg.alert('Error', 'Status:'+action.{@link #response}.status+': '+ action.{@link #response}.statusText); } if (action.failureType === Ext.form.Action.{@link #SERVER_INVALID}){ // server responded with success = false Ext.Msg.alert('Invalid', action.{@link #result}.errormsg); } } }); } } },{ text: 'Reset', handler: function(){ fp.getForm().reset(); } }] * </code></pre> * @property failureType * @type {String} */ /** * The XMLHttpRequest object used to perform the action. * @property response * @type {Object} */ /** * The decoded response object containing a boolean <tt style="font-weight:bold">success</tt> property and * other, action-specific properties. * @property result * @type {Object} */ // interface method run : function(options){ }, // interface method success : function(response){ }, // interface method handleResponse : function(response){ }, // default connection failure failure : function(response){ this.response = response; this.failureType = Ext.form.Action.CONNECT_FAILURE; this.form.afterAction(this, false); }, // private // shared code among all Actions to validate that there was a response // with either responseText or responseXml processResponse : function(response){ this.response = response; if(!response.responseText && !response.responseXML){ return true; } this.result = this.handleResponse(response); return this.result; }, // utility functions used internally getUrl : function(appendParams){ var url = this.options.url || this.form.url || this.form.el.dom.action; if(appendParams){ var p = this.getParams(); if(p){ url = Ext.urlAppend(url, p); } } return url; }, // private getMethod : function(){ return (this.options.method || this.form.method || this.form.el.dom.method || 'POST').toUpperCase(); }, // private getParams : function(){ var bp = this.form.baseParams; var p = this.options.params; if(p){ if(typeof p == "object"){ p = Ext.urlEncode(Ext.applyIf(p, bp)); }else if(typeof p == 'string' && bp){ p += '&' + Ext.urlEncode(bp); } }else if(bp){ p = Ext.urlEncode(bp); } return p; }, // private createCallback : function(opts){ var opts = opts || {}; return { success: this.success, failure: this.failure, scope: this, timeout: (opts.timeout*1000) || (this.form.timeout*1000), upload: this.form.fileUpload ? this.success : undefined }; } }; /** * @class Ext.form.Action.Submit * @extends Ext.form.Action * A class which handles submission of data from {@link Ext.form.BasicForm Form}s * and processes the returned response. * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when * {@link Ext.form.BasicForm#submit submit}ting. * Response Packet Criteria * A response packet may contain: * <div class="mdetail-params"><ul> * <li><code>success</code> property : Boolean * <div class="sub-desc">The <code>success</code> property is required.</div></li> * <li><code>errors</code> property : Object * <div class="sub-desc"><div class="sub-desc">The <code>errors</code> property, * which is optional, contains error messages for invalid fields.</div></li> * </ul></div> * JSON Packets * By default, response packets are assumed to be JSON, so a typical response * packet may look like this:<pre><code> { success: false, errors: { clientCode: "Client not found", portOfLoading: "This field must not be null" } }</code></pre> * Other data may be placed into the response for processing by the {@link Ext.form.BasicForm}'s callback * or event handler methods. The object decoded from this JSON is available in the * {@link Ext.form.Action#result result} property. * Alternatively, if an {@link #errorReader} is specified as an {@link Ext.data.XmlReader XmlReader}:<pre><code> errorReader: new Ext.data.XmlReader({ record : 'field', success: '@success' }, [ 'id', 'msg' ] ) </code></pre> * then the results may be sent back in XML format:<pre><code> <?xml version="1.0" encoding="UTF-8"?> <message success="false"> <errors> <field> <id>clientCode</id> <msg><![CDATA[Code not found. This is a test validation message from the server ]]></msg> </field> <field> <id>portOfLoading</id> <msg><![CDATA[Port not found. This is a test validation message from the server ]]></msg> </field> </errors> </message> </code></pre> * Other elements may be placed into the response XML for processing by the {@link Ext.form.BasicForm}'s callback * or event handler methods. The XML document is available in the {@link #errorReader}'s {@link Ext.data.XmlReader#xmlData xmlData} property. */ Ext.form.Action.Submit = function(form, options){ Ext.form.Action.Submit.superclass.constructor.call(this, form, options); }; Ext.extend(Ext.form.Action.Submit, Ext.form.Action, { /** * @cfg {Ext.data.DataReader} errorReader Optional. JSON is interpreted with * no need for an errorReader. * A Reader which reads a single record from the returned data. The DataReader's * success property specifies how submission success is determined. The Record's * data provides the error messages to apply to any invalid form Fields. */ /** * @cfg {boolean} clientValidation Determines whether a Form's fields are validated * in a final call to {@link Ext.form.BasicForm#isValid isValid} prior to submission. * Pass <tt>false</tt> in the Form's submit options to prevent this. If not defined, pre-submission field validation * is performed. */ type : 'submit', // private run : function(){ var o = this.options; var method = this.getMethod(); var isGet = method == 'GET'; if(o.clientValidation === false || this.form.isValid()){ Ext.Ajax.request(Ext.apply(this.createCallback(o), { form:this.form.el.dom, url:this.getUrl(isGet), method: method, headers: o.headers, params:!isGet ? this.getParams() : null, isUpload: this.form.fileUpload })); }else if (o.clientValidation !== false){ // client validation failed this.failureType = Ext.form.Action.CLIENT_INVALID; this.form.afterAction(this, false); } }, // private success : function(response){ var result = this.processResponse(response); if(result === true || result.success){ this.form.afterAction(this, true); return; } if(result.errors){ this.form.markInvalid(result.errors); this.failureType = Ext.form.Action.SERVER_INVALID; } this.form.afterAction(this, false); }, // private handleResponse : function(response){ if(this.form.errorReader){ var rs = this.form.errorReader.read(response); var errors = []; if(rs.records){ for(var i = 0, len = rs.records.length; i < len; i++) { var r = rs.records[i]; errors[i] = r.data; } } if(errors.length < 1){ errors = null; } return { success : rs.success, errors : errors }; } return Ext.decode(response.responseText); } }); /** * @class Ext.form.Action.Load * @extends Ext.form.Action * A class which handles loading of data from a server into the Fields of an {@link Ext.form.BasicForm}. * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when * {@link Ext.form.BasicForm#load load}ing. * Response Packet Criteria * A response packet must contain: * <div class="mdetail-params"><ul> * <li><code>success</code> property : Boolean</li> * <li><code>data</code> property : Object</li> * <div class="sub-desc">The <code>data</code> property contains the values of Fields to load. * The individual value object for each Field is passed to the Field's * {@link Ext.form.Field#setValue setValue} method.</div></li> * </ul></div> * JSON Packets * By default, response packets are assumed to be JSON, so for the following form load call:<pre><code> var myFormPanel = new Ext.form.FormPanel({ title: 'Client and routing info', items: [{ fieldLabel: 'Client', name: 'clientName' }, { fieldLabel: 'Port of loading', name: 'portOfLoading' }, { fieldLabel: 'Port of discharge', name: 'portOfDischarge' }] }); myFormPanel.{@link Ext.form.FormPanel#getForm getForm}().{@link Ext.form.BasicForm#load load}({ url: '/getRoutingInfo.php', params: { consignmentRef: myConsignmentRef }, failure: function(form, action() { Ext.Msg.alert("Load failed", action.result.errorMessage); } }); </code></pre> * a success response packet may look like this:<pre><code> { success: true, data: { clientName: "Fred. Olsen Lines", portOfLoading: "FXT", portOfDischarge: "OSL" } }</code></pre> * while a failure response packet may look like this:<pre><code> { success: false, errorMessage: "Consignment reference not found" }</code></pre> * Other data may be placed into the response for processing the {@link Ext.form.BasicForm Form}'s * callback or event handler methods. The object decoded from this JSON is available in the * {@link Ext.form.Action#result result} property. */ Ext.form.Action.Load = function(form, options){ Ext.form.Action.Load.superclass.constructor.call(this, form, options); this.reader = this.form.reader; }; Ext.extend(Ext.form.Action.Load, Ext.form.Action, { // private type : 'load', // private run : function(){ Ext.Ajax.request(Ext.apply( this.createCallback(this.options), { method:this.getMethod(), url:this.getUrl(false), headers: this.options.headers, params:this.getParams() })); }, // private success : function(response){ var result = this.processResponse(response); if(result === true || !result.success || !result.data){ this.failureType = Ext.form.Action.LOAD_FAILURE; this.form.afterAction(this, false); return; } this.form.clearInvalid(); this.form.setValues(result.data); this.form.afterAction(this, true); }, // private handleResponse : function(response){ if(this.form.reader){ var rs = this.form.reader.read(response); var data = rs.records && rs.records[0] ? rs.records[0].data : null; return { success : rs.success, data : data }; } return Ext.decode(response.responseText); } }); /** * @class Ext.form.Action.DirectLoad * @extends Ext.form.Action.Load * Provides Ext.direct support for loading form data. This example illustrates usage * of Ext.Direct to load a submit a form through Ext.Direct. * <pre><code> var myFormPanel = new Ext.form.FormPanel({ // configs for FormPanel title: 'Basic Information', border: false, padding: 10, buttons:[{ text: 'Submit', handler: function(){ basicInfo.getForm().submit({ params: { uid: 5 } }); } }], // configs apply to child items defaults: {anchor: '100%'}, defaultType: 'textfield', items: [ // form fields go here ], // configs for BasicForm api: { load: Profile.getBasicInfo, // The server-side must mark the submit handler as a 'formHandler' submit: Profile.updateBasicInfo }, paramOrder: ['uid'] }); // load the form myFormPanel.getForm().load({ params: { uid: 5 } }); * </code></pre> */ Ext.form.Action.DirectLoad = Ext.extend(Ext.form.Action.Load, { constructor: function(form, opts) { Ext.form.Action.DirectLoad.superclass.constructor.call(this, form, opts); }, type: 'directload', run : function(){ var args = this.getParams(); args.push(this.success, this); this.form.api.load.apply(window, args); }, getParams: function() { var buf = [], o = {}; var bp = this.form.baseParams; var p = this.options.params; Ext.apply(o, p, bp); var paramOrder = this.form.paramOrder; if(paramOrder){ for(var i = 0, len = paramOrder.length; i < len; i++){ buf.push(o[paramOrder[i]]); } }else if(this.form.paramsAsHash){ buf.push(o); } return buf; }, // Direct actions have already been processed and therefore // we can directly set the result; Direct Actions do not have // a this.response property. processResponse: function(result) { this.result = result; return result; } }); /** * @class Ext.form.Action.DirectSubmit * @extends Ext.form.Action.Submit * Provides Ext.direct support for submitting form data. * See {@link Ext.form.Action.DirectLoad}. */ Ext.form.Action.DirectSubmit = Ext.extend(Ext.form.Action.Submit, { constructor: function(form, opts) { Ext.form.Action.DirectSubmit.superclass.constructor.call(this, form, opts); }, type: 'directsubmit', // override of Submit run : function(){ var o = this.options; if(o.clientValidation === false || this.form.isValid()){ // tag on any additional params to be posted in the // form scope this.success.params = this.getParams(); this.form.api.submit(this.form.el.dom, this.success, this); }else if (o.clientValidation !== false){ // client validation failed this.failureType = Ext.form.Action.CLIENT_INVALID; this.form.afterAction(this, false); } }, getParams: function() { var o = {}; var bp = this.form.baseParams; var p = this.options.params; Ext.apply(o, p, bp); return o; }, // Direct actions have already been processed and therefore // we can directly set the result; Direct Actions do not have // a this.response property. processResponse: function(result) { this.result = result; return result; } }); Ext.form.Action.ACTION_TYPES = { 'load' : Ext.form.Action.Load, 'submit' : Ext.form.Action.Submit, 'directload': Ext.form.Action.DirectLoad, 'directsubmit': Ext.form.Action.DirectSubmit }; /** * @class Ext.form.VTypes * This is a singleton object which contains a set of commonly used field validation functions. * The validations provided are basic and intended to be easily customizable and extended. * To add custom VTypes specify the <code>{@link Ext.form.TextField#vtype vtype}</code> validation * test function, and optionally specify any corresponding error text to display and any keystroke * filtering mask to apply. For example: * <pre><code> // custom Vtype for vtype:'time' var timeTest = /^([1-9]|1[0-9]):([0-5][0-9])(s[a|p]m)$/i; Ext.apply(Ext.form.VTypes, { // vtype validation function time: function(val, field) { return timeTest.test(val); }, // vtype Text property: The error text to display when the validation function returns false timeText: 'Not a valid time. Must be in the format "12:34 PM".', // vtype Mask property: The keystroke filter mask timeMask: /[ds:amp]/i }); * </code></pre> * Another example: * <pre><code> // custom Vtype for vtype:'IPAddress' Ext.apply(Ext.form.VTypes, { IPAddress: function(v) { return /^d{1,3}.d{1,3}.d{1,3}.d{1,3}$/.test(v); }, IPAddressText: 'Must be a numeric IP address', IPAddressMask: /[d.]/i }); * </code></pre> * @singleton */ Ext.form.VTypes = function(){ // closure these in so they are only created once. var alpha = /^[a-zA-Z_]+$/; var alphanum = /^[a-zA-Z0-9_]+$/; var email = /^(w+)([-+.][w]+)*@(w[-w]*.){1,5}([A-Za-z]){2,4}$/; var url = /(((https?)|(ftp))://([-w]+.)+w{2,3}(/[%-w]+(.w{2,})?)*(([w-.?\/+@&#;`~=%!]*)(.w{2,})?)*/?)/i; // All these messages and functions are configurable return { /** * The function used to validate email addresses. Note that this is a very basic validation -- complete * validation per the email RFC specifications is very complex and beyond the scope of this class, although * this function can be overridden if a more comprehensive validation scheme is desired. See the validation * section of the <a href="http://en.wikipedia.org/wiki/E-mail_address">Wikipedia article on email addresses</a> * for additional information. This implementation is intended to validate the following emails:<tt> * 'barney@example.de', 'barney.rubble@example.com', 'barney-rubble@example.coop', 'barney+rubble@example.com' * </tt>. * @param {String} value The email address * @return {Boolean} true if the RegExp test passed, and false if not. */ 'email' : function(v){ return email.test(v); }, /** * The error text to display when the email validation function returns false. Defaults to: * <tt>'This field should be an e-mail address in the format "user@example.com"'</tt> * @type String */ 'emailText' : 'This field should be an e-mail address in the format "user@example.com"', /** * The keystroke filter mask to be applied on email input. See the {@link #email} method for * information about more complex email validation. Defaults to: * <tt>/[a-z0-9_.-@]/i</tt> * @type RegExp */ 'emailMask' : /[a-z0-9_.-@]/i, /** * The function used to validate URLs * @param {String} value The URL * @return {Boolean} true if the RegExp test passed, and false if not. */ 'url' : function(v){ return url.test(v); }, /** * The error text to display when the url validation function returns false. Defaults to: * <tt>'This field should be a URL in the format "http:/'+'/www.example.com"'</tt> * @type String */ 'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"', /** * The function used to validate alpha values * @param {String} value The value * @return {Boolean} true if the RegExp test passed, and false if not. */ 'alpha' : function(v){ return alpha.test(v); }, /** * The error text to display when the alpha validation function returns false. Defaults to: * <tt>'This field should only contain letters and _'</tt> * @type String */ 'alphaText' : 'This field should only contain letters and _', /** * The keystroke filter mask to be applied on alpha input. Defaults to: * <tt>/[a-z_]/i</tt> * @type RegExp */ 'alphaMask' : /[a-z_]/i, /** * The function used to validate alphanumeric values * @param {String} value The value * @return {Boolean} true if the RegExp test passed, and false if not. */ 'alphanum' : function(v){ return alphanum.test(v); }, /** * The error text to display when the alphanumeric validation function returns false. Defaults to: * <tt>'This field should only contain letters, numbers and _'</tt> * @type String */ 'alphanumText' : 'This field should only contain letters, numbers and _', /** * The keystroke filter mask to be applied on alphanumeric input. Defaults to: * <tt>/[a-z0-9_]/i</tt> * @type RegExp */ 'alphanumMask' : /[a-z0-9_]/i }; }();