code stringlengths 1 2.08M | language stringclasses 1
value |
|---|---|
/**
* @author Ed Spencer
* @class Ext.data.XmlStore
* @extends Ext.data.Store
* @private
* @ignore
* <p>Small helper class to make creating {@link Ext.data.Store}s from XML data easier.
* A XmlStore will be automatically configured with a {@link Ext.data.XmlReader}.</p>
* <p>A store configuration would be somet... | JavaScript |
/**
* @class Ext.data.JsonPStore
* @extends Ext.data.Store
* @ignore
* @private
* <p><b>NOTE:</b> This class is in need of migration to the new API.</p>
* <p>Small helper class to make creating {@link Ext.data.Store}s from different domain JSON data easier.
* A JsonPStore will be automatically configured with a ... | JavaScript |
/**
* @author Aaron Conran
* @class Ext.data.TreeStore
* @extends Ext.data.AbstractStore
*
* <p>A store class that allows the representation of hierarchical data.</p>
* @constructor
* @param {Object} config Optional config object
*/
Ext.data.TreeStore = Ext.extend(Ext.data.AbstractStore, {
/**
* @cfg {... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.JsonStore
* @extends Ext.data.Store
* @ignore
*
* <p>Small helper class to make creating {@link Ext.data.Store}s from JSON data easier.
* A JsonStore will be automatically configured with a {@link Ext.data.JsonReader}.</p>
*
* <p>A store configuration would be somet... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.AbstractStore
* @extends Ext.util.Observable
*
* <p>AbstractStore is a superclass of {@link Ext.data.Store} and {@link Ext.data.TreeStore}. It's never used directly,
* but offers a set of methods used by both of those subclasses.</p>
*
* <p>We've left it here in the d... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ArrayStore
* @extends Ext.data.Store
* @ignore
*
* <p>Small helper class to make creating {@link Ext.data.Store}s from Array data easier.
* An ArrayStore will be automatically configured with a {@link Ext.data.ArrayReader}.</p>
*
* <p>A store configuration would be ... | JavaScript |
/**
* @class Ext.data.Tree
* @extends Ext.util.Observable
* Represents a tree data structure and bubbles all the events for its nodes. The nodes
* in the tree have most standard DOM functionality.
* @constructor
* @param {Node} root (optional) The root node
*/
Ext.data.Tree = Ext.extend(Ext.util.Observable, {
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ProxyMgr
* @extends Ext.AbstractManager
* @singleton
* @ignore
*/
Ext.data.ProxyMgr = new Ext.AbstractManager({
create: function(config) {
if (config == undefined || typeof config == 'string') {
config = {
type: config
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.RestProxy
* @extends Ext.data.AjaxProxy
*
* <p>RestProxy is a specialization of the {@link Ext.data.AjaxProxy AjaxProxy} which simply maps the four actions
* (create, read, update and destroy) to RESTful HTTP verbs. For example, let's set up a {@link Ext.data.Model Mod... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.SessionStorageProxy
* @extends Ext.data.WebStorageProxy
*
* <p>Proxy which uses HTML5 session storage as its data storage/retrieval mechanism.
* If this proxy is used in a browser where session storage is not supported, the constructor will throw an error.
* A session ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.MemoryProxy
* @extends Ext.data.ClientProxy
*
* <p>In-memory proxy. This proxy simply uses a local variable for data storage/retrieval, so its contents are lost on
* every page refresh.</p>
*
* <p>Usually this Proxy isn't used directly, serving instead as a helper to... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ClientProxy
* @extends Ext.data.Proxy
*
* <p>Base class for any client-side storage. Used as a superclass for {@link Ext.data.MemoryProxy Memory} and
* {@link Ext.data.WebStorageProxy Web Storage} proxies. Do not use directly, use one of the subclasses instead.</p>
*/... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.AjaxProxy
* @extends Ext.data.ServerProxy
*
* <p>AjaxProxy is one of the most widely-used ways of getting data into your application. It uses AJAX requests to
* load data from the server, usually to be placed into a {@link Ext.data.Store Store}. Let's take a look at a ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.LocalStorageProxy
* @extends Ext.data.WebStorageProxy
*
* <p>The LocalStorageProxy uses the new HTML5 localStorage API to save {@link Ext.data.Model Model} data locally on
* the client browser. HTML5 localStorage is a key-value store (e.g. cannot save complex objects li... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.WebStorageProxy
* @extends Ext.data.ClientProxy
*
* <p>WebStorageProxy is simply a superclass for the {@link Ext.data.LocalStorageProxy localStorage} and
* {@link Ext.data.SessionStorageProxy sessionStorage} proxies. It uses the new HTML5 key/value client-side storage ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Proxy
* @extends Ext.util.Observable
*
* <p>Proxies are used by {@link Ext.data.Store Stores} to handle the loading and saving of {@link Ext.data.Model Model} data.
* Usually developers will not need to create or interact with proxies directly.</p>
* <p><u>Types of Pro... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ServerProxy
* @extends Ext.data.Proxy
*
* <p>ServerProxy is a superclass of {@link Ext.data.ScriptTagProxy ScriptTagProxy} and {@link Ext.data.AjaxProxy AjaxProxy},
* and would not usually be used directly.</p>
*
* <p>ServerProxy should ideally be named HttpProxy as ... | JavaScript |
Ext.apply(Ext, {
/**
* Returns the current document body as an {@link Ext.Element}.
* @ignore
* @member Ext
* @return Ext.Element The document body
*/
getHead : function() {
var head;
return function() {
if (head == undefined) {
head ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Store
* @extends Ext.data.AbstractStore
*
* <p>The Store class encapsulates a client side cache of {@link Ext.data.Model Model} objects. Stores load
* data via a {@link Ext.data.Proxy Proxy}, and also provide functions for {@link #sort sorting},
* {@link #filter filteri... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.PolymorphicAssociation
* @extends Ext.data.Association
* @ignore
*/
Ext.data.PolymorphicAssociation = Ext.extend(Ext.data.Association, {
constructor: function(config) {
Ext.data.PolymorphicAssociation.superclass.constructor.call(this, config);
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Writer
* @extends Object
*
* <p>Base Writer class used by most subclasses of {@link Ext.data.ServerProxy}. This class is
* responsible for taking a set of {@link Ext.data.Operation} objects and a {@link Ext.data.Request}
* object and modifying that request based on the... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.XmlWriter
* @extends Ext.data.Writer
*
* <p>Writer that outputs model data in XML format</p>
*/
Ext.data.XmlWriter = Ext.extend(Ext.data.Writer, {
/**
* @cfg {String} documentRoot The name of the root element of the document. Defaults to <tt>'xmlData'</tt>.
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.JsonWriter
* @extends Ext.data.Writer
*
* <p>Writer that outputs model data in JSON format</p>
*/
Ext.data.JsonWriter = Ext.extend(Ext.data.Writer, {
/**
* @cfg {String} root The key under which the records in this Writer will be placed. Defaults to 'records'.
... | JavaScript |
/**
* @class Ext.data.Types
* @ignore
* <p>This is s static class containing the system-supplied data types which may be given to a {@link Ext.data.Field Field}.<p/>
* <p>The properties in this class are used as type indicators in the {@link Ext.data.Field Field} class, so to
* test whether a Field is of a certain... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Errors
* @extends Ext.util.MixedCollection
*
* <p>Wraps a collection of validation error responses and provides convenient functions for
* accessing and errors for specific fields.</p>
*
* <p>Usually this class does not need to be instantiated directly - instances ar... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Field
* @extends Object
*
* <p>Fields are used to define what a Model is. They aren't instantiated directly - instead, {@link Ext#regModel}
* creates a Field instance for each field configured in a {@link Ext.data.Model Model}. For example, we might set up a
* model l... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Association
* @extends Object
*
* <p>Associations enable you to express relationships between different {@link Ext.data.Model Models}. Let's say we're
* writing an ecommerce system where Users can make Orders - there's a relationship between these Models that we can
* ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.WriterMgr
* @extends Ext.AbstractManager
* @ignore
*
* <p>Keeps track of all of the registered {@link Ext.data.Writer Writers}</p>
*/
Ext.data.WriterMgr = new Ext.AbstractManager({
}); | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Request
* @extends Object
*
* <p>Simple class that represents a Request that will be made by any {@link Ext.data.ServerProxy} subclass.
* All this class does is standardize the representation of a Request as used by any ServerProxy subclass,
* it does not contain any a... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Batch
* @extends Ext.util.Observable
*
* <p>Provides a mechanism to run one or more {@link Ext.data.Operation operations} in a given order. Fires the 'operationcomplete' event
* after the completion of each Operation, and the 'complete' event when all Operations have be... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.ModelMgr
* @extends Ext.AbstractManager
* @singleton
*
* <p>Creates and manages the current set of models</p>
*/
Ext.ModelMgr = new Ext.AbstractManager({
typeName: 'mtype',
/**
* The string type of the default Model Proxy. Defaults to 'ajax'
* @proper... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.HasManyAssociation
* @extends Ext.data.Association
*
* <p>Represents a one-to-many relationship between two models. Usually created indirectly via a model definition:</p>
*
<pre><code>
Ext.regModel('Product', {
fields: [
{name: 'id', type: 'int'},
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ReaderMgr
* @extends Ext.AbstractManager
* @singleton
* @ignore
*
* <p>Maintains the set of all registered {@link Ext.data.Reader Reader} types.</p>
*/
Ext.data.ReaderMgr = new Ext.AbstractManager({
typeName: 'rtype'
}); | JavaScript |
/**
* @class Ext.StoreMgr
* @extends Ext.util.MixedCollection
* The default global group of stores.
* @singleton
* TODO: Make this an AbstractMgr
*/
Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), {
/**
* @cfg {Object} listeners @hide
*/
/**
* Registers one or more Stores with the... | JavaScript |
/**
* @class Ext.data.SortTypes
* @ignore
* @singleton
* Defines the default sorting (casting?) comparison functions used when sorting data.
*/
Ext.data.SortTypes = {
/**
* Default sort that does nothing
* @param {Mixed} s The value being converted
* @return {Mixed} The comparison value
*/
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.validations
* @extends Object
*
* <p>This singleton contains a set of validation functions that can be used to validate any type
* of data. They are most often used in {@link Ext.data.Model Models}, where they are automatically
* set up and executed.</p>
*/
Ext.data.v... | JavaScript |
/**
* @class Ext.data.Node
* @extends Ext.util.Observable
* @cfg {Boolean} leaf true if this node is a leaf and does not have children
* @cfg {String} id The id for this node. If one is not specified, one is generated.
* @constructor
* @param {Object} attributes The attributes/config for the node
*/
Ext.data.Nod... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ResultSet
* @extends Object
*
* <p>Simple wrapper class that represents a set of records returned by a Proxy.</p>
*
* @constructor
* Creates the new ResultSet
*/
Ext.data.ResultSet = Ext.extend(Object, {
/**
* @cfg {Boolean} loaded
* True if the record... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.BelongsToAssociation
* @extends Ext.data.Association
*
* <p>Represents a many to one association with another model. The owner model is expected to have
* a foreign key which references the primary key of the associated model:</p>
*
<pre><code>
var Category = Ext.regM... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.XmlReader
* @extends Ext.data.Reader
*
*
* <p>The XML Reader is used by a Proxy to read a server response that is sent back in XML format. This usually
* happens as a result of loading a Store - for example we might create something like this:</p>
*
<pre><code>
Ext.... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Reader
* @extends Object
*
* <p>Readers are used to interpret data to be loaded into a {@link Ext.data.Model Model} instance or a {@link Ext.data.Store Store}
* - usually in response to an AJAX request. This is normally handled transparently by passing some configuratio... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.JsonReader
* @extends Ext.data.Reader
*
* <p>The JSON Reader is used by a Proxy to read a server response that is sent back in JSON format. This usually
* happens as a result of loading a Store - for example we might create something like this:</p>
*
<pre><code>
Ext.r... | JavaScript |
Ext.data.TreeReader = Ext.extend(Ext.data.JsonReader, {
extractData : function(root, returnRecords) {
var records = Ext.data.TreeReader.superclass.extractData.call(this, root, returnRecords),
ln = records.length,
i = 0,
record;
if (returnRecords) {
f... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.ArrayReader
* @extends Ext.data.JsonReader
*
* <p>Data reader class to create an Array of {@link Ext.data.Model} objects from an Array.
* Each element of that Array represents a row of data fields. The
* fields are pulled into a Record object using as a subscript, the ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Operation
* @extends Object
*
* <p>Represents a single read or write operation performed by a {@link Ext.data.Proxy Proxy}.
* Operation objects are used to enable communication between Stores and Proxies. Application
* developers should rarely need to interact with Ope... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Model
* @extends Ext.util.Stateful
*
* <p>A Model represents some object that your application manages. For example, one might define a Model for Users, Products,
* Cars, or any other real-world object that we want to model in the system. Models are registered via the {... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.util.Dispatcher
* @extends Ext.util.Observable
*
* <p>The Dispatcher class is used to send requests through to a controller action. Usually, only a single Dispatcher
* is required on the page, and by default a single instance is already created - {@link Ext.Dispatcher}. See ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.Controller
* @extends Ext.util.Observable
*
* @constructor
*/
Ext.Controller = Ext.extend(Ext.util.Observable, {
constructor: function(config) {
this.addEvents(
/**
* @event instance-created
* Fired when a new model instance ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.util.Route
* @extends Object
* @ignore
* <p>Represents a mapping between a url and a controller/action pair. May also contain additional params</p>
*/
Ext.util.Route = Ext.extend(Object, {
/**
* @cfg {String} url The url string to match. Required.
*/
co... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.util.Router
* @extends Ext.util.Observable
*
* <p>See {@link Ext.Router}.</p>
*/
Ext.util.Router = Ext.extend(Ext.util.Observable, {
constructor: function(config) {
config = config || {};
Ext.apply(this, config, {
defaults: {
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.Interaction
* @extends Ext.util.Observable
*
* <p>Interactions are very simple objects that represent an action performed by specific {@link Ext.Controller}
* action. The must consist of the {@link #controller} and {@link #action} to be called, but can contain any other
* ... | JavaScript |
/**
* @class Ext.ApplicationManager
* @extends Ext.AbstractManager
* @singleton
* @ignore
*/
Ext.ApplicationManager = new Ext.AbstractManager({
register: function(name, options) {
if (Ext.isObject(name)) {
options = name;
} else {
options.name = name;
}
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.ControllerManager
* @extends Ext.AbstractManager
* @singleton
*
* <p>Keeps track of all of the registered controllers. This should very rarely need to be used by developers. This
* is simply an {@link Ext.AbstractManager AbstractManager} with a custom {@link #register} fun... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.Application
* @extends Ext.util.Observable
*
* <p>Represents a Sencha Application. Most Applications consist of at least the application's name and a launch
* function:</p>
*
<pre><code>
new Ext.Application({
name: 'MyApp',
launch: function() {
this.viewport... | JavaScript |
/**
* @class Ext.PluginMgr
* @extends Ext.AbstractManager
* <p>Provides a registry of available Plugin <i>classes</i> indexed by a mnemonic code known as the Plugin's ptype.
* The <code>{@link Ext.Component#xtype xtype}</code> provides a way to avoid instantiating child Components
* when creating a full, nested co... | JavaScript |
/**
* @class Ext.Element
*/
Ext.applyIf(Ext.Element, {
unitRe: /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i,
camelRe: /(-[a-z])/gi,
opacityRe: /alpha\(opacity=(.*)\)/i,
propertyCache: {},
defaultUnit : "px",
borders: {l: 'border-left-width', r: 'border-right-width', t: 'border-top-width', b: 'border-... | JavaScript |
/**
* @class Ext.Element
*/
Ext.Element.addMethods({
/**
* Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)
* @param {String} selector The simple selector to test
* @param {Number/Mixed} maxDepth (optional) The max depth... | JavaScript |
/**
* @class Ext.Element
*/
Ext.Element.addMethods({
/**
* Appends the passed element(s) to this element
* @param {String/HTMLElement/Array/Element/CompositeElement} el
* @return {Ext.Element} this
*/
appendChild : function(el) {
return Ext.get(el).appendTo(this);
},
/**
... | JavaScript |
/**
* @class Array
*/
Ext.applyIf(Array.prototype, {
/**
* Checks whether or not the specified object exists in the array.
* @param {Object} o The object to check for
* @param {Number} from (Optional) The index at which to begin the search
* @return {Number} The index of o in the array (or -1 ... | JavaScript |
/**
* @class Ext.EventManager
* Registers event handlers that want to receive a normalized EventObject instead of the standard browser event and provides
* several useful events directly.
* See {@link Ext.EventObject} for more details on normalized event objects.
* @singleton
*/
Ext.EventManager = {
optionsRe... | JavaScript |
/**
* @class Ext
* Ext core utilities and functions.
* @singleton
*/
if (typeof Ext === "undefined") {
Ext = {};
}
/**
* Copies all the properties of config to obj.
* @param {Object} object The receiver of the properties
* @param {Object} config The source of the properties
* @param {Object} defaults A dif... | JavaScript |
/**
* @class Ext.lib.Panel
* @extends Ext.Container
* Shared Panel class
*/
Ext.lib.Panel = Ext.extend(Ext.Container, {
/**
* @cfg {String} baseCls
* The base CSS class to apply to this panel's element (defaults to <code>'x-panel'</code>).
*/
baseCls : 'x-panel',
/**
* @cfg {Number/... | JavaScript |
/**
* @class Ext.lib.Component
* @extends Ext.util.Observable
* Shared Component class
*/
Ext.lib.Component = Ext.extend(Ext.util.Observable, {
isComponent: true,
/**
* @cfg {Mixed} renderTpl
* <p>An {@link Ext.XTemplate XTemplate} used to create the internal structure inside this Component's
... | JavaScript |
/**
* @class Ext.util.Format
* Reusable data formatting functions
* @singleton
*/
Ext.util.Format = {
defaultDateFormat: 'm/d/Y',
escapeRe: /('|\\)/g,
trimRe: /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x... | JavaScript |
/**
* @class Ext.util.Point
* @extends Object
*
* Represents a 2D point with x and y properties, useful for comparison and instantiation
* from an event:
* <pre><code>
* var point = Ext.util.Point.fromEvent(e);
* </code></pre>
*/
Ext.util.Point = Ext.extend(Object, {
constructor: function(x, y) {
... | JavaScript |
/**
* @class Ext.util.GeoLocation
* @extends Ext.util.Observable
*
* Provides a cross browser class for retrieving location information.<br/>
* <br/>
* Based on the <a href="http://dev.w3.org/geo/api/spec-source.html">Geolocation API Specification</a>.<br/>
* If the browser does not implement that specification ... | JavaScript |
/**
* @class Ext.util.DelayedTask
* <p> The DelayedTask class provides a convenient way to "buffer" the execution of a method,
* performing setTimeout where a new timeout cancels the old timeout. When called, the
* task will wait the specified time period before executing. If durng that time period,
* the task is ... | JavaScript |
/**
* @class Ext.util.Sorter
* @extends Object
* Represents a single sorter that can be applied to a Store
*/
Ext.util.Sorter = Ext.extend(Object, {
/**
* @cfg {String} property The property to sort by. Required unless {@link #sorter} is provided
*/
/**
* @cfg {Function} sorterFn A speci... | JavaScript |
/**
* @class Ext.util.Observable
* Base class that provides a common interface for publishing events. Subclasses are expected to
* to have a property "events" with all the events defined, and, optionally, a property "listeners"
* with configured listeners defined.<br>
* For example:
* <pre><code>
Employee = Ext.e... | JavaScript |
/**
* @class Ext.util.Filter
* @extends Object
* <p>Represents a filter that can be applied to a {@link Ext.data.MixedCollection MixedCollection}. Can either simply
* filter on a property/value pair or pass in a filter function with custom logic. Filters are always used in the context
* of MixedCollections, though... | JavaScript |
/**
* @class Ext.Template
* <p>Represents an HTML fragment template. Templates may be {@link #compile precompiled}
* for greater performance.</p>
* An instance of this class may be created by passing to the constructor either
* a single argument, or multiple arguments:
* <div class="mdetail-params"><ul>
* <li><b... | JavaScript |
/**
* @class Ext.util.Stateful
* @extends Ext.util.Observable
* Represents any object whose data can be saved by a {@link Ext.data.Proxy Proxy}. Ext.Model
* and Ext.View both inherit from this class as both can save state (Models save field state,
* Views save configuration)
*/
Ext.util.Stateful = Ext.extend(Ext... | JavaScript |
/**
* @class Ext.util.Numbers
* @singleton
*/
Ext.util.Numbers = {
// detect toFixed implementation bug in IE
toFixedBroken: (0.9).toFixed() != 1,
/**
* Checks whether or not the current number is within a desired range. If the number is already within the
* range it is returned, ot... | JavaScript |
/**
* @class Ext.util.Region
* @extends Object
*
* Represents a rectangular region and provides a number of utility methods
* to compare regions.
*/
Ext.util.Region = Ext.extend(Object, {
/**
* @constructor
* @param {Number} top Top
* @param {Number} right Right
* @param {Number} bottom Bo... | JavaScript |
/**
* @class Ext.util.MixedCollection
* @extends Ext.util.Observable
* A Collection class that maintains both numeric indexes and keys and exposes events.
* @constructor
* @param {Boolean} allowFunctions Specify <tt>true</tt> if the {@link #addAll}
* function should add function references to the collection. Defa... | JavaScript |
/**
* @class Ext.util.HashMap
* @extends Ext.util.Observable
* <p>A simple unordered dictionary implementation to store key/value pairs.</p>
*
* @cfg {Function} keyFn A function that is used to retrieve a default key for a passed object.
* A default is provided that returns the <b>id</b> property on the object. ... | JavaScript |
/**
* @class Ext.XTemplate
* @extends Ext.Template
* <p>A template class that supports advanced functionality like:<div class="mdetail-params"><ul>
* <li>Autofilling arrays using templates and sub-templates</li>
* <li>Conditional processing with basic comparison operators</li>
* <li>Basic math function support</l... | JavaScript |
/**
* @class Ext.AbstractManager
* @extends Object
* @ignore
* Base Manager class - extended by ComponentMgr and PluginMgr
*/
Ext.AbstractManager = Ext.extend(Object, {
typeName: 'type',
constructor: function(config) {
Ext.apply(this, config || {});
/**
* Contains all of the item... | JavaScript |
/**
* @class Ext.util.Functions
* @singleton
*/
Ext.util.Functions = {
/**
* Creates an interceptor function. The passed function is called before the original one. If it returns false,
* the original one is not called. The resulting function returns the results of the original function.
* The pas... | JavaScript |
/**
* @class Ext.util.Date
* @singleton
*/
Ext.util.Date = {
/**
* Returns the number of milliseconds between two dates
* @param {Date} dateA
* @param {Date} dateB (optional) Defaults to now
* @return {Number} The diff in milliseconds
*/
getElapsed: function(dateA, dateB) {
... | JavaScript |
/**
* @class Ext.LoadMask
* A simple utility class for generically masking elements while loading data. If the {@link #store}
* config option is specified, the masking will be automatically synchronized with the store's loading
* process and the mask element will be cached for reuse.
* <p>Example usage:</p>
*<pr... | JavaScript |
Ext.util.Offset = Ext.extend(Object, {
constructor: function(x, y) {
this.x = (x != null && !isNaN(x)) ? x : 0;
this.y = (y != null && !isNaN(y)) ? y : 0;
return this;
},
copy: function() {
return new Ext.util.Offset(this.x, this.y);
},
copyFrom: function(p) {
... | JavaScript |
/**
* @class Ext.util.Sortable
* @extends Ext.util.Observable
* @constructor
* @param {Mixed} el
* @param {Object} config
*/
Ext.util.Sortable = Ext.extend(Ext.util.Observable, {
baseCls: 'x-sortable',
/**
* @cfg {String} direction
* Possible values: 'vertical', 'horizontal'
* Defaults to ... | JavaScript |
// This class is still experimental, docs will be added at a later time
Ext.util.EventSimulator = Ext.extend(Object, {
supportedEvents: {
touch: ['touchstart', 'touchmove', 'touchend', 'gesturestart', 'gesturechange', 'gestureend'],
mouse: ['mousedown', 'mousemove', 'mouseup', 'click']
},
... | JavaScript |
/*
http://www.JSON.org/json2.js
2010-03-20
Public Domain.
NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
See http://www.JSON.org/js.html
This code should be minified before deployment.
See http://javascript.crockford.com/jsmin.html
USE YOUR OWN COPY. IT IS EXTREMELY UNWISE... | JavaScript |
/**
* @class Ext.util.JSONP
*
* Provides functionality to make cross-domain requests with JSONP (JSON with Padding).
* http://en.wikipedia.org/wiki/JSON#JSONP
* <p>
* <b>Note that if you are retrieving data from a page that is in a domain that is NOT the same as the originating domain
* of the running page, you ... | JavaScript |
(function(){
Ext.ScrollManager = new Ext.AbstractManager();
/**
* @class Ext.util.ScrollView
* @extends Ext.util.Observable
*
* A wrapper class around {@link Ext.util.Scroller Ext.util.Scroller} and {@link Ext.util.Scroller.Indicator Ext.util.Scroller.Indicator}
* that listens to scroll events and control the sc... | JavaScript |
/**
* @class Ext.util.Draggable
* @extends Ext.util.Observable
* A core util class to bring Draggable behavior to any DOM element, acts as a base class for Scroller and Sortable
* @constructor
* @param {Mixed} el The element you want to make draggable.
* @param {Object} config The configuration object for this Dr... | JavaScript |
/**
* @class Date
*
* The date parsing and formatting syntax contains a subset of
* <a href="http://www.php.net/date">PHP's date() function</a>, and the formats that are
* supported will provide results equivalent to their PHP versions.
*
* The following is a list of all currently supported formats:
* <pre>
For... | JavaScript |
/**
* @class Ext.util.Droppable
* @extends Ext.util.Observable
*
* @constructor
*/
Ext.util.Droppable = Ext.extend(Ext.util.Observable, {
baseCls: 'x-droppable',
/**
* @cfg {String} activeCls
* The CSS added to a Droppable when a Draggable in the same group is being
* dragged. Defaults to '... | JavaScript |
/**
* @class Ext.util.TapRepeater
* @extends Ext.util.Observable
*
* A wrapper class which can be applied to any element. Fires a "tap" event while
* touching the device. The interval between firings may be specified in the config but
* defaults to 20 milliseconds.
*
* @constructor
* @param {Mixed} el The elem... | JavaScript |
// This class is still experimental, docs will be added at a later time
Ext.util.EventRecorder = Ext.extend(Ext.util.Observable, {
eventCollection: null,
currentEventSetName: null,
constructor: function() {
this.addEvents(
'replaystart',
'beforecalculatetarget',
... | JavaScript |
/**
* @class Ext
* Ext core utilities and functions.
* @singleton
*/
if (typeof Ext === "undefined") {
Ext = {};
}
/**
* Copies all the properties of config to obj.
* @param {Object} object The receiver of the properties
* @param {Object} config The source of the properties
* @param {Object} defaults A dif... | JavaScript |
describe("Ext.data.Connection", function() {
var proto = Ext.data.Connection.prototype,
conn, makeConn, makeRequest;
beforeEach(function() {
makeConn = function(config) {
return conn = new Ext.data.Connection(config || {});
};
makeRequest = function(conf... | JavaScript |
describe("Ext.IndexBar", function() {
var indexBar, e;
beforeEach(function() {
indexBar = new Ext.IndexBar({
renderTo: Ext.getBody()
});
});
afterEach(function() {
indexBar.destroy();
});
it("should have a componentCls", function() {
exp... | JavaScript |
describe("Ext.Sheet", function() {
var sheet;
beforeEach(function() {
sheet = new Ext.Sheet({
renderTo: Ext.getBody()
});
});
afterEach(function() {
sheet.destroy();
});
it("should have a componentCls", function() {
expect(sheet.componen... | JavaScript |
describe("Ext.Container", function() {
var container;
beforeEach(function() {
container = new Ext.Container({
renderTo: Ext.getBody()
});
});
afterEach(function() {
container.destroy();
});
it("should have no cardSwitchAnimation by default", fun... | JavaScript |
describe("Ext.Audio", function() {
var audio;
beforeEach(function() {
audio = new Ext.Audio({
url : 'test.mp3'
});
});
afterEach(function() {
audio.destroy();
});
it("should have a componentCls", function() {
expect(audio.componentCl... | JavaScript |
describe("Ext.Map", function() {
var map;
beforeEach(function() {
map = new Ext.Map();
});
afterEach(function() {
map.destroy();
});
it("should have a baseCls", function() {
expect(map.baseCls).toEqual('x-map');
});
it("should not useCurrentLoc... | JavaScript |
xdescribe("Ext.ProgressBar", function() {
var pb;
beforeEach(function() {
pb = new Ext.ProgressBar({
renderTo: Ext.getBody()
});
});
afterEach(function() {
pb.destroy();
});
it("should have a default value of 0", function() {
expect(pb.v... | JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.