Alien-Web-ExtJS-V3
view release on metacpan or search on metacpan
share/ext-all-debug-w-comments.js view on Meta::CPAN
return {
/**
* Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
* @param {String} value The string to truncate
* @param {Number} length The maximum length to allow before truncating
* @param {Boolean} word True to try to find a common work break
* @return {String} The converted text
*/
ellipsis : function(value, len, word) {
if (value && value.length > len) {
if (word) {
var vs = value.substr(0, len - 2),
index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
if (index == -1 || index < (len - 15)) {
return value.substr(0, len - 3) + "...";
} else {
return vs.substr(0, index) + "...";
}
} else {
return value.substr(0, len - 3) + "...";
}
}
return value;
},
/**
* Checks a reference and converts it to empty string if it is undefined
* @param {Mixed} value Reference to check
* @return {Mixed} Empty string if converted, otherwise the original value
*/
undef : function(value) {
return value !== undefined ? value : "";
},
/**
* Checks a reference and converts it to the default value if it's empty
* @param {Mixed} value Reference to check
* @param {String} defaultValue The value to insert if it's undefined (defaults to "")
* @return {String}
*/
defaultValue : function(value, defaultValue) {
if (!defaultValue && defaultValue !== 0) {
defaultValue = '';
}
return value !== undefined && value !== '' ? value : defaultValue;
},
/**
* Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
* @param {String} value The string to encode
* @return {String} The encoded text
*/
htmlEncode : function(value) {
return !value ? value : String(value).replace(/&/g, "&").replace(/>/g, ">").replace(/</g, "<").replace(/"/g, """);
},
/**
* Convert certain characters (&, <, >, and ') from their HTML character equivalents.
* @param {String} value The string to decode
* @return {String} The decoded text
*/
htmlDecode : function(value) {
return !value ? value : String(value).replace(/>/g, ">").replace(/</g, "<").replace(/"/g, '"').replace(/&/g, "&");
},
/**
* Trims any whitespace from either side of a string
* @param {String} value The text to trim
* @return {String} The trimmed text
*/
trim : function(value) {
return String(value).replace(trimRe, "");
},
/**
* Returns a substring from within an original string
* @param {String} value The original text
* @param {Number} start The start index of the substring
* @param {Number} length The length of the substring
* @return {String} The substring
*/
substr : function(value, start, length) {
return String(value).substr(start, length);
},
/**
* Converts a string to all lower case letters
* @param {String} value The text to convert
* @return {String} The converted text
*/
lowercase : function(value) {
return String(value).toLowerCase();
},
/**
* Converts a string to all upper case letters
* @param {String} value The text to convert
* @return {String} The converted text
*/
uppercase : function(value) {
return String(value).toUpperCase();
},
/**
* Converts the first character only of a string to upper case
* @param {String} value The text to convert
* @return {String} The converted text
*/
capitalize : function(value) {
return !value ? value : value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();
},
// private
call : function(value, fn) {
if (arguments.length > 2) {
var args = Array.prototype.slice.call(arguments, 2);
args.unshift(value);
return eval(fn).apply(window, args);
} else {
return eval(fn).call(window, value);
share/ext-all-debug-w-comments.js view on Meta::CPAN
update : 'changed_update.php',
destroy : 'changed_destroy.php'
});
}
}
});
* </code></pre>
* </p>
*/
this.addEvents(
/**
* @event exception
* <p>Fires if an exception occurs in the Proxy during a remote request. This event is relayed
* through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
* so any Store instance may observe this event.</p>
* <p>In addition to being fired through the DataProxy instance that raised the event, this event is also fired
* through the Ext.data.DataProxy <i>class</i> to allow for centralized processing of exception events from <b>all</b>
* DataProxies by attaching a listener to the Ext.data.DataProxy class itself.</p>
* <p>This event can be fired for one of two reasons:</p>
* <div class="mdetail-params"><ul>
* <li>remote-request <b>failed</b> : <div class="sub-desc">
* The server did not return status === 200.
* </div></li>
* <li>remote-request <b>succeeded</b> : <div class="sub-desc">
* The remote-request succeeded but the reader could not read the response.
* This means the server returned data, but the configured Reader threw an
* error while reading the response. In this case, this event will be
* raised and the caught error will be passed along into this event.
* </div></li>
* </ul></div>
* <br><p>This event fires with two different contexts based upon the 2nd
* parameter <tt>type [remote|response]</tt>. The first four parameters
* are identical between the two contexts -- only the final two parameters
* differ.</p>
* @param {DataProxy} this The proxy that sent the request
* @param {String} type
* <p>The value of this parameter will be either <tt>'response'</tt> or <tt>'remote'</tt>.</p>
* <div class="mdetail-params"><ul>
* <li><b><tt>'response'</tt></b> : <div class="sub-desc">
* <p>An <b>invalid</b> response from the server was returned: either 404,
* 500 or the response meta-data does not match that defined in the DataReader
* (e.g.: root, idProperty, successProperty).</p>
* </div></li>
* <li><b><tt>'remote'</tt></b> : <div class="sub-desc">
* <p>A <b>valid</b> response was returned from the server having
* successProperty === false. This response might contain an error-message
* sent from the server. For example, the user may have failed
* authentication/authorization or a database validation error occurred.</p>
* </div></li>
* </ul></div>
* @param {String} action Name of the action (see {@link Ext.data.Api#actions}.
* @param {Object} options The options for the action that were specified in the {@link #request}.
* @param {Object} response
* <p>The value of this parameter depends on the value of the <code>type</code> parameter:</p>
* <div class="mdetail-params"><ul>
* <li><b><tt>'response'</tt></b> : <div class="sub-desc">
* <p>The raw browser response object (e.g.: XMLHttpRequest)</p>
* </div></li>
* <li><b><tt>'remote'</tt></b> : <div class="sub-desc">
* <p>The decoded response object sent from the server.</p>
* </div></li>
* </ul></div>
* @param {Mixed} arg
* <p>The type and value of this parameter depends on the value of the <code>type</code> parameter:</p>
* <div class="mdetail-params"><ul>
* <li><b><tt>'response'</tt></b> : Error<div class="sub-desc">
* <p>The JavaScript Error object caught if the configured Reader could not read the data.
* If the remote request returns success===false, this parameter will be null.</p>
* </div></li>
* <li><b><tt>'remote'</tt></b> : Record/Record[]<div class="sub-desc">
* <p>This parameter will only exist if the <tt>action</tt> was a <b>write</b> action
* (Ext.data.Api.actions.create|update|destroy).</p>
* </div></li>
* </ul></div>
*/
'exception',
/**
* @event beforeload
* Fires before a request to retrieve a data object.
* @param {DataProxy} this The proxy for the request
* @param {Object} params The params object passed to the {@link #request} function
*/
'beforeload',
/**
* @event load
* Fires before the load method's callback is called.
* @param {DataProxy} this The proxy for the request
* @param {Object} o The request transaction object
* @param {Object} options The callback's <tt>options</tt> property as passed to the {@link #request} function
*/
'load',
/**
* @event loadexception
* <p>This event is <b>deprecated</b>. The signature of the loadexception event
* varies depending on the proxy, use the catch-all {@link #exception} event instead.
* This event will fire in addition to the {@link #exception} event.</p>
* @param {misc} misc See {@link #exception}.
* @deprecated
*/
'loadexception',
/**
* @event beforewrite
* <p>Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy</p>
* <p>In addition to being fired through the DataProxy instance that raised the event, this event is also fired
* through the Ext.data.DataProxy <i>class</i> to allow for centralized processing of beforewrite events from <b>all</b>
* DataProxies by attaching a listener to the Ext.data.DataProxy class itself.</p>
* @param {DataProxy} this The proxy for the request
* @param {String} action [Ext.data.Api.actions.create|update|destroy]
* @param {Record/Record[]} rs The Record(s) to create|update|destroy.
* @param {Object} params The request <code>params</code> object. Edit <code>params</code> to add parameters to the request.
*/
'beforewrite',
/**
* @event write
* <p>Fires before the request-callback is called</p>
* <p>In addition to being fired through the DataProxy instance that raised the event, this event is also fired
* through the Ext.data.DataProxy <i>class</i> to allow for centralized processing of write events from <b>all</b>
* DataProxies by attaching a listener to the Ext.data.DataProxy class itself.</p>
* @param {DataProxy} this The proxy that sent the request
* @param {String} action [Ext.data.Api.actions.create|upate|destroy]
* @param {Object} data The data object extracted from the server-response
* @param {Object} response The decoded response from server
* @param {Record/Record[]} rs The Record(s) from Store
* @param {Object} options The callback's <tt>options</tt> property as passed to the {@link #request} function
*/
'write'
);
Ext.data.DataProxy.superclass.constructor.call(this);
// Prepare the proxy api. Ensures all API-actions are defined with the Object-form.
try {
Ext.data.Api.prepare(this);
} catch (e) {
if (e instanceof Ext.data.Api.Error) {
e.toConsole();
}
}
// relay each proxy's events onto Ext.data.DataProxy class for centralized Proxy-listening
Ext.data.DataProxy.relayEvents(this, ['beforewrite', 'write', 'exception']);
};
Ext.extend(Ext.data.DataProxy, Ext.util.Observable, {
/**
* @cfg {Boolean} restful
* <p>Defaults to <tt>false</tt>. Set to <tt>true</tt> to operate in a RESTful manner.</p>
* <br><p> Note: this parameter will automatically be set to <tt>true</tt> if the
* {@link Ext.data.Store} it is plugged into is set to <code>restful: true</code>. If the
* Store is RESTful, there is no need to set this option on the proxy.</p>
* <br><p>RESTful implementations enable the serverside framework to automatically route
* actions sent to one url based upon the HTTP method, for example:
* <pre><code>
store: new Ext.data.Store({
restful: true,
proxy: new Ext.data.HttpProxy({url:'/users'}); // all requests sent to /users
...
)}
* </code></pre>
* If there is no <code>{@link #api}</code> specified in the configuration of the proxy,
* all requests will be marshalled to a single RESTful url (/users) so the serverside
* framework can inspect the HTTP Method and act accordingly:
* <pre>
<u>Method</u> <u>url</u> <u>action</u>
POST /users create
GET /users read
PUT /users/23 update
DESTROY /users/23 delete
* </pre></p>
* <p>If set to <tt>true</tt>, a {@link Ext.data.Record#phantom non-phantom} record's
* {@link Ext.data.Record#id id} will be appended to the url. Some MVC (e.g., Ruby on Rails,
* Merb and Django) support segment based urls where the segments in the URL follow the
* Model-View-Controller approach:<pre><code>
* someSite.com/controller/action/id
* </code></pre>
* Where the segments in the url are typically:<div class="mdetail-params"><ul>
* <li>The first segment : represents the controller class that should be invoked.</li>
* <li>The second segment : represents the class function, or method, that should be called.</li>
* <li>The third segment : represents the ID (a variable typically passed to the method).</li>
* </ul></div></p>
* <br><p>Refer to <code>{@link Ext.data.DataProxy#api}</code> for additional information.</p>
*/
restful: false,
share/ext-all-debug-w-comments.js view on Meta::CPAN
autoOffset : function(x, y) {
x -= this.startPageX;
y -= this.startPageY;
this.setDelta(x, y);
}
});/**
* @class Ext.state.Provider
* Abstract base class for state provider implementations. This class provides methods
* for encoding and decoding <b>typed</b> variables including dates and defines the
* Provider interface.
*/
Ext.state.Provider = Ext.extend(Ext.util.Observable, {
constructor : function(){
/**
* @event statechange
* Fires when a state change occurs.
* @param {Provider} this This state provider
* @param {String} key The state key which was changed
* @param {String} value The encoded value for the state
*/
this.addEvents("statechange");
this.state = {};
Ext.state.Provider.superclass.constructor.call(this);
},
/**
* Returns the current value for a key
* @param {String} name The key name
* @param {Mixed} defaultValue A default value to return if the key's value is not found
* @return {Mixed} The state data
*/
get : function(name, defaultValue){
return typeof this.state[name] == "undefined" ?
defaultValue : this.state[name];
},
/**
* Clears a value from the state
* @param {String} name The key name
*/
clear : function(name){
delete this.state[name];
this.fireEvent("statechange", this, name, null);
},
/**
* Sets the value for a key
* @param {String} name The key name
* @param {Mixed} value The value to set
*/
set : function(name, value){
this.state[name] = value;
this.fireEvent("statechange", this, name, value);
},
/**
* Decodes a string previously encoded with {@link #encodeValue}.
* @param {String} value The value to decode
* @return {Mixed} The decoded value
*/
decodeValue : function(cookie){
/**
* a -> Array
* n -> Number
* d -> Date
* b -> Boolean
* s -> String
* o -> Object
* -> Empty (null)
*/
var re = /^(a|n|d|b|s|o|e)\:(.*)$/,
matches = re.exec(unescape(cookie)),
all,
type,
v,
kv;
if(!matches || !matches[1]){
return; // non state cookie
}
type = matches[1];
v = matches[2];
switch(type){
case 'e':
return null;
case 'n':
return parseFloat(v);
case 'd':
return new Date(Date.parse(v));
case 'b':
return (v == '1');
case 'a':
all = [];
if(v != ''){
Ext.each(v.split('^'), function(val){
all.push(this.decodeValue(val));
}, this);
}
return all;
case 'o':
all = {};
if(v != ''){
Ext.each(v.split('^'), function(val){
kv = val.split('=');
all[kv[0]] = this.decodeValue(kv[1]);
}, this);
}
return all;
default:
return v;
}
},
/**
* Encodes a value including type information. Decode with {@link #decodeValue}.
* @param {Mixed} value The value to encode
* @return {String} The encoded value
*/
encodeValue : function(v){
var enc,
share/ext-all-debug-w-comments.js view on Meta::CPAN
/**
* @cfg {Boolean} submitEmptyText If set to <tt>true</tt>, the emptyText value will be sent with the form
* when it is submitted. Defaults to <tt>true</tt>.
*/
/**
* 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;
},
decodeResponse: function(response) {
try {
return Ext.decode(response.responseText);
} catch(e) {
return false;
}
},
// 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
* <p>A class which handles submission of data from {@link Ext.form.BasicForm Form}s
* and processes the returned response.</p>
* <p>Instances of this class are only created by a {@link Ext.form.BasicForm Form} when
* {@link Ext.form.BasicForm#submit submit}ting.</p>
* <p><u><b>Response Packet Criteria</b></u></p>
* <p>A response packet may contain:
* <div class="mdetail-params"><ul>
* <li><b><code>success</code></b> property : Boolean
* <div class="sub-desc">The <code>success</code> property is required.</div></li>
* <li><b><code>errors</code></b> 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>
* <p><u><b>JSON Packets</b></u></p>
* <p>By default, response packets are assumed to be JSON, so a typical response
* packet may look like this:</p><pre><code>
{
success: false,
errors: {
clientCode: "Client not found",
portOfLoading: "This field must not be null"
}
}</code></pre>
* <p>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.</p>
* <p>Alternatively, if an {@link #errorReader} is specified as an {@link Ext.data.XmlReader XmlReader}:</p><pre><code>
errorReader: new Ext.data.XmlReader({
record : 'field',
success: '@success'
}, [
'id', 'msg'
]
)
</code></pre>
* <p>then the results may be sent back in XML format:</p><pre><code>
<?xml version="1.0" encoding="UTF-8"?>
<message success="false">
<errors>
<field>
<id>clientCode</id>
<msg><![CDATA[Code not found. <br /><i>This is a test validation message from the server </i>]]></msg>
</field>
<field>
<id>portOfLoading</id>
<msg><![CDATA[Port not found. <br /><i>This is a test validation message from the server </i>]]></msg>
</field>
</errors>
</message>
</code></pre>
* <p>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.</p>
*/
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 <p><b>Optional. JSON is interpreted with
* no need for an errorReader.</b></p>
* <p>A Reader which reads a single record from the returned data. The DataReader's
* <b>success</b> property specifies how submission success is determined. The Record's
* data provides the error messages to apply to any invalid form Fields.</p>
*/
/**
* @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,
method = this.getMethod(),
isGet = method == 'GET';
if(o.clientValidation === false || this.form.isValid()){
if (o.submitEmptyText === false) {
var fields = this.form.items,
emptyFields = [],
setupEmptyFields = function(f){
if (f.el.getValue() == f.emptyText) {
emptyFields.push(f);
share/ext-all-debug-w-comments.js view on Meta::CPAN
return this.decodeResponse(response);
}
});
/**
* @class Ext.form.Action.Load
* @extends Ext.form.Action
* <p>A class which handles loading of data from a server into the Fields of an {@link Ext.form.BasicForm}.</p>
* <p>Instances of this class are only created by a {@link Ext.form.BasicForm Form} when
* {@link Ext.form.BasicForm#load load}ing.</p>
* <p><u><b>Response Packet Criteria</b></u></p>
* <p>A response packet <b>must</b> contain:
* <div class="mdetail-params"><ul>
* <li><b><code>success</code></b> property : Boolean</li>
* <li><b><code>data</code></b> 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>
* <p><u><b>JSON Packets</b></u></p>
* <p>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 <b>success response</b> packet may look like this:</p><pre><code>
{
success: true,
data: {
clientName: "Fred. Olsen Lines",
portOfLoading: "FXT",
portOfDischarge: "OSL"
}
}</code></pre>
* while a <b>failure response</b> packet may look like this:</p><pre><code>
{
success: false,
errorMessage: "Consignment reference not found"
}</code></pre>
* <p>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.</p>
*/
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 this.decodeResponse(response);
}
});
/**
* @class Ext.form.Action.DirectLoad
* @extends Ext.form.Action.Load
* <p>Provides Ext.direct support for loading form data.</p>
* <p>This example illustrates usage of Ext.Direct to <b>load</b> a form through Ext.Direct.</p>
* <pre><code>
var myFormPanel = new Ext.form.FormPanel({
// configs for FormPanel
title: 'Basic Information',
( run in 0.483 second using v1.01-cache-2.11-cpan-3d66aa2751a )