Extends one class to create a subclass and optionally overrides members with the passed literal. This method - * also adds the function "override()" to the subclass that can be used to override members of the class.
- * For example, to create a subclass of Ext GridPanel: - *
-MyGridPanel = Ext.extend(Ext.grid.GridPanel, {
- constructor: function(config) {
-
-// Create configuration for this Grid.
- var store = new Ext.data.Store({...});
- var colModel = new Ext.grid.ColumnModel({...});
-
-// Create a new config object containing our computed properties
-// *plus* whatever was in the config parameter.
- config = Ext.apply({
- store: store,
- colModel: colModel
- }, config);
-
- MyGridPanel.superclass.constructor.call(this, config);
-
-// Your postprocessing here
- },
-
- yourMethod: function() {
- // etc.
- }
-});
-This function also supports a 3-argument call in which the subclass's constructor is - * passed as an argument. In this form, the parameters are as follows:
- *subclass : Function superclass : Function overrides : Object A literal with members which are copied into the subclass's - * prototype, and are therefore shared between all instances of the new class.
- *This may contain a special member named constructor. This is used - * to define the constructor of the new class, and is returned. If this property is - * not specified, a constructor is generated and returned which just calls the - * superclass's constructor passing on its parameters.
- *It is essential that you call the superclass constructor in any provided constructor. See example code.
- * @return {Function} The subclass constructor from theoverrides parameter, or a generated one if not provided.
- */
- extend : function(){
- // inline overrides
- var io = function(o){
- for(var m in o){
- this[m] = o[m];
- }
- };
- var oc = Object.prototype.constructor;
-
- return function(sb, sp, overrides){
- if(typeof sp == 'object'){
- overrides = sp;
- sp = sb;
- sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};
- }
- var F = function(){},
- sbp,
- spp = sp.prototype;
-
- F.prototype = spp;
- sbp = sb.prototype = new F();
- sbp.constructor=sb;
- sb.superclass=spp;
- if(spp.constructor == oc){
- spp.constructor=sp;
- }
- sb.override = function(o){
- Ext.override(sb, o);
- };
- sbp.superclass = sbp.supr = (function(){
- return spp;
- });
- sbp.override = io;
- Ext.override(sb, overrides);
- sb.extend = function(o){return Ext.extend(sb, o);};
- return sb;
- };
- }(),
-
- /**
- * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
- * Usage:
-Ext.override(MyClass, {
- newMethod1: function(){
- // etc.
- },
- newMethod2: function(foo){
- // etc.
- }
-});
-
-Ext.namespace('Company', 'Company.data');
-Ext.namespace('Company.data'); // equivalent and preferable to above syntax
-Company.Widget = function() { ... }
-Company.data.CustomStore = function(config) { ... }
-
-Ext.urlDecode("foo=1&bar=2"); // returns {foo: "1", bar: "2"}
-Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", false); // returns {foo: "1", bar: ["2", "3", "4"]}
-index. This function is called with
- * the following arguments:
- * item : Mixed
- * index
- * in the passed arrayindex : Number
- * allItems : Array
- * array passed as the first
- * argument to Ext.each.this reference) in which the specified function is executed.
- * Defaults to the item at the current index
- * within the passed array.
- * @return See description for the fn parameter.
- */
- each : function(array, fn, scope){
- if(Ext.isEmpty(array, true)){
- return;
- }
- if(!Ext.isIterable(array) || Ext.isPrimitive(array)){
- array = [array];
- }
- for(var i = 0, len = array.length; i < len; i++){
- if(fn.call(scope || array[i], array[i], i, array) === false){
- return i;
- };
- }
- },
-
- /**
- * Iterates either the elements in an array, or each of the properties in an object.
- * Note: If you are only iterating arrays, it is better to call {@link #each}.
- * @param {Object/Array} object The object or array to be iterated
- * @param {Function} fn The function to be called for each iteration.
- * The iteration will stop if the supplied function returns false, or
- * all array elements / object properties have been covered. The signature
- * varies depending on the type of object being interated:
- * this reference) in which the specified function is executed. Defaults to
- * the object being iterated.
- */
- iterate : function(obj, fn, scope){
- if(Ext.isEmpty(obj)){
- return;
- }
- if(Ext.isIterable(obj)){
- Ext.each(obj, fn, scope);
- return;
- }else if(typeof obj == 'object'){
- for(var prop in obj){
- if(obj.hasOwnProperty(prop)){
- if(fn.call(scope || obj, prop, obj[prop], obj) === false){
- return;
- };
- }
- }
- }
- },
-
- /**
- * Return the dom node for the passed String (id), dom node, or Ext.Element.
- * Optional 'strict' flag is needed for IE since it can return 'name' and
- * 'id' elements by using getElementById.
- * Here are some examples:
- *
-// gets dom node based on id
-var elDom = Ext.getDom('elId');
-// gets dom node based on the dom node
-var elDom1 = Ext.getDom(elDom);
-
-// If we don't know if we are working with an
-// Ext.Element or a dom node use Ext.getDom
-function(el){
- var dom = Ext.getDom(el);
- // do something with the dom node
-}
- * Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
- * All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is
- * true, then DOM event listeners are also removed from all child nodes. The body node
- * will be ignored if passed in.
Returns true if the passed value is empty.
- *The value is deemed to be empty if it is
-Ext.namespace('Company', 'Company.data');
-Ext.namespace('Company.data'); // equivalent and preferable to above syntax
-Company.Widget = function() { ... }
-Company.data.CustomStore = function(config) { ... }
-
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
-
-sayHi('Fred'); // alerts "Hi, Fred"
-
-// create a new function that validates input without
-// directly modifying the original function:
-var sayHiToFriend = sayHi.createInterceptor(function(name){
- return name == 'Brian';
-});
-
-sayHiToFriend('Fred'); // no alert
-sayHiToFriend('Brian'); // alerts "Hi, Brian"
-this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- */
- createInterceptor : function(fcn, scope){
- var method = this;
- return !Ext.isFunction(fcn) ?
- this :
- function() {
- var me = this,
- args = arguments;
- fcn.target = me;
- fcn.method = method;
- return (fcn.apply(scope || me || window, args) !== false) ?
- method.apply(me || window, args) :
- null;
- };
- },
-
- /**
- * Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
- * Call directly on any function. Example: myFunction.createCallback(arg1, arg2)
- * Will create a function that is bound to those 2 args. If a specific scope is required in the
- * callback, use {@link #createDelegate} instead. The function returned by createCallback always
- * executes in the window scope.
- * This method is required when you want to pass arguments to a callback function. If no arguments - * are needed, you can simply pass a reference to the function as a callback (e.g., callback: myFn). - * However, if you tried to pass a function with arguments (e.g., callback: myFn(arg1, arg2)) the function - * would simply execute immediately when the code is parsed. Example usage: - *
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
-
-// clicking the button alerts "Hi, Fred"
-new Ext.Button({
- text: 'Say Hi',
- renderTo: Ext.getBody(),
- handler: sayHi.createCallback('Fred')
-});
-this.myFunction.createDelegate(this, [arg1, arg2])
- * Will create a function that is automatically scoped to obj so that the this variable inside the
- * callback points to obj. Example usage:
- *
-var sayHi = function(name){
- // Note this use of "this.text" here. This function expects to
- // execute within a scope that contains a text property. In this
- // example, the "this" variable is pointing to the btn object that
- // was passed in createDelegate below.
- alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
-}
-
-var btn = new Ext.Button({
- text: 'Say Hi',
- renderTo: Ext.getBody()
-});
-
-// This callback will execute in the scope of the
-// button instance. Clicking the button alerts
-// "Hi, Fred. You clicked the "Say Hi" button."
-btn.on('click', sayHi.createDelegate(btn, ['Fred']));
-this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Function} The new function
- */
- createDelegate : function(obj, args, appendArgs){
- var method = this;
- return function() {
- var callArgs = args || arguments;
- if (appendArgs === true){
- callArgs = Array.prototype.slice.call(arguments, 0);
- callArgs = callArgs.concat(args);
- }else if (Ext.isNumber(appendArgs)){
- callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first
- var applyArgs = [appendArgs, 0].concat(args); // create method call params
- Array.prototype.splice.apply(callArgs, applyArgs); // splice them in
- }
- return method.apply(obj || window, callArgs);
- };
- },
-
- /**
- * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
- *
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
-
-// executes immediately:
-sayHi('Fred');
-
-// executes after 2 seconds:
-sayHi.defer(2000, this, ['Fred']);
-
-// this syntax is sometimes useful for deferring
-// execution of an anonymous function:
-(function(){
- alert('Anonymous');
-}).defer(100);
-this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Number} The timeout id that can be used with clearTimeout
- */
- defer : function(millis, obj, args, appendArgs){
- var fn = this.createDelegate(obj, args, appendArgs);
- if(millis > 0){
- return setTimeout(fn, millis);
- }
- fn();
- return 0;
- }
-});
-
-/**
- * @class String
- * These functions are available on every String object.
- */
-Ext.applyIf(String, {
- /**
- * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens. Each
- * token must be unique, and must increment in the format {0}, {1}, etc. Example usage:
- *
-var cls = 'my-class', text = 'Some text';
-var s = String.format('<div class="{0}">{1}</div>', cls, text);
-// s now contains the string: '<div class="my-class">Some text</div>'
- *