code stringlengths 1 2.08M | language stringclasses 1
value |
|---|---|
/**
* @class Ext.carousel.Carousel
* @author Jacky Nguyen <jacky@sencha.com>
*
* Carousels, like [tabs](#!/guide/tabs), are a great way to allow the user to swipe through multiple full-screen pages.
* A Carousel shows only one of its pages at a time but allows you to swipe through with your finger.
*
* Carousels... | JavaScript |
/**
* {@link Ext.Audio} is a simple class which provides a container for the [HTML5 Audio element](http://developer.mozilla.org/en-US/docs/Using_HTML5_audio_and_video).
*
* ## Recommended File Types/Compression:
* * Uncompressed WAV and AIF audio
* * MP3 audio
* * AAC-LC
* * HE-AAC audio
*
* ## Notes
* On And... | JavaScript |
/**
* This class compiles the XTemplate syntax into a function object. The function is used
* like so:
*
* function (out, values, parent, xindex, xcount) {
* // out is the output array to store results
* // values, parent, xindex and xcount have their historical meaning
* }
*
* @pri... | JavaScript |
/**
* A mixin which allows a data component to be sorted
* @ignore
*/
Ext.define('Ext.Sortable', {
mixins: {
observable: 'Ext.mixin.Observable'
},
requires: ['Ext.util.Draggable'],
config: {
/**
* @cfg
* @inheritdoc
*/
baseCls: Ext.baseCSSPrefix + ... | JavaScript |
/**
* {@link Ext.TitleBar}'s are most commonly used as a docked item within an {@link Ext.Container}.
*
* The main difference between a {@link Ext.TitleBar} and an {@link Ext.Toolbar} is that
* the {@link #title} configuration is **always** centered horizontally in a {@link Ext.TitleBar} between
* any items aligne... | JavaScript |
/**
* Wraps a Google Map in an Ext.Component using the [Google Maps API](http://code.google.com/apis/maps/documentation/v3/introduction.html).
*
* To use this component you must include an additional JavaScript file from Google:
*
* <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=... | JavaScript |
/**
* @aside video list
* @aside guide list
*
* IndexBar is a component used to display a list of data (primarily an alphabet) which can then be used to quickly
* navigate through a list (see {@link Ext.List}) of data. When a user taps on an item in the {@link Ext.IndexBar},
* it will fire the {@link #index} even... | JavaScript |
/**
* @aside guide list
* @aside video list
*
* List is a custom styled DataView which allows Grouping, Indexing, Icons, and a Disclosure. See the
* [Guide](#!/guide/list) and [Video](#!/video/list) for more.
*
* @example miniphone preview
* Ext.create('Ext.List', {
* fullscreen: true,
* ... | JavaScript |
/**
* @aside guide dataview
*
* DataView makes it easy to create lots of components dynamically, usually based off a {@link Ext.data.Store Store}.
* It's great for rendering lots of data from your server backend or any other data source and is what powers
* components like {@link Ext.List}.
*
* Use DataView when... | JavaScript |
/**
* @private - To be made a sample
*/
Ext.define('Ext.dataview.ListItemHeader', {
extend: 'Ext.Component',
xtype : 'listitemheader',
config: {
/**
* @cfg
* @inheritdoc
*/
baseCls: Ext.baseCSSPrefix + 'list-header',
docked: 'top'
}
}); | JavaScript |
/**
* @private
*/
Ext.define('Ext.dataview.element.Container', {
extend: 'Ext.Component',
/**
* @event itemtouchstart
* Fires whenever an item is touched
* @param {Ext.dataview.element.Container} this
* @param {Ext.dom.Element} item The item touched
* @param {Number} index The index ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.dataview.element.List', {
extend: 'Ext.dataview.element.Container',
updateBaseCls: function(newBaseCls) {
var me = this;
me.itemClsShortCache = newBaseCls + '-item';
me.headerClsShortCache = newBaseCls + '-header';
me.headerClsCache = '.' + m... | JavaScript |
/**
* A DataItem is a container for {@link Ext.dataview.DataView} with useComponents: true. It ties together
* {@link Ext.data.Model records} to its contained Components via a {@link #dataMap dataMap} configuration.
*
* For example, lets say you have a `text` configuration which, when applied, gets turned into an i... | JavaScript |
/**
* @private
*/
Ext.define('Ext.dataview.component.Container', {
extend: 'Ext.Container',
requires: [
'Ext.dataview.component.DataItem'
],
/**
* @event itemtouchstart
* Fires whenever an item is touched
* @param {Ext.dataview.component.Container} this
* @param {Ext.data... | JavaScript |
/**
* A SimpleListItem is a simplified list item that is used by {@link Ext.dataview.List} when
* useSimpleItems is set to true. It supports disclosure icons and headers and generates the
* slimmest markup possible to achieve this. It doesn't support container functionality like adding
* or docking items. If you r... | JavaScript |
/**
* A ListItem is a container for {@link Ext.dataview.List} with
* useSimpleItems: false.
*
* ListItem configures and updates the {@link Ext.data.Model records} for
* the sub-component items in a list.
*
* Overwrite the `updateRecord()` method to set a sub-component's value.
* Sencha Touch calls `up... | JavaScript |
/**
* NestedList provides a miller column interface to navigate between nested sets
* and provide a clean interface with limited screen real-estate.
*
* @example miniphone preview
* var data = {
* text: 'Groceries',
* items: [{
* text: 'Drinks',
* items: [{
... | JavaScript |
/**
* @private
* This is the abstract class for {@link Ext.Component}.
*
* This should never be overridden.
*/
Ext.define('Ext.AbstractComponent', {
extend: 'Ext.Evented',
onClassExtended: function(Class, members) {
if (!members.hasOwnProperty('cachedConfig')) {
return;
}
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.behavior.Translatable', {
extend: 'Ext.behavior.Behavior',
requires: [
'Ext.util.Translatable'
],
setConfig: function(config) {
var translatable = this.translatable,
component = this.component;
if (config) {
if (!tra... | JavaScript |
/**
* @private
*/
Ext.define('Ext.behavior.Scrollable', {
extend: 'Ext.behavior.Behavior',
requires: [
'Ext.scroll.View'
],
constructor: function() {
this.listeners = {
painted: 'onComponentPainted',
scope: this
};
this.callParent(arguments);... | JavaScript |
/**
* @private
*/
Ext.define('Ext.behavior.Draggable', {
extend: 'Ext.behavior.Behavior',
requires: [
'Ext.util.Draggable'
],
setConfig: function(config) {
var draggable = this.draggable,
component = this.component;
if (config) {
if (!draggable) {
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.behavior.Behavior', {
constructor: function(component) {
this.component = component;
component.on('destroy', 'onComponentDestroy', this);
},
onComponentDestroy: Ext.emptyFn
});
| JavaScript |
/**
* This component is used in {@link Ext.navigation.View} to control animations in the toolbar. You should never need to
* interact with the component directly, unless you are subclassing it.
* @private
* @author Robert Dougan <rob@sencha.com>
*/
Ext.define('Ext.navigation.Bar', {
extend: 'Ext.TitleBar',
... | JavaScript |
/**
* @author Robert Dougan <rob@sencha.com>
*
* NavigationView is basically a {@link Ext.Container} with a {@link Ext.layout.Card card} layout, so only one view
* can be visible at a time. However, NavigationView also adds extra functionality on top of this to allow
* you to `push` and `pop` views at any time. Wh... | JavaScript |
/**
* @aside guide forms
*
* The Url field creates an HTML5 url input and is usually created inside a form. Because it creates an HTML url input
* field, most browsers will show a specialized virtual keyboard for web address input. Aside from that, the url field
* is just a normal text field. Here's an example of ... | JavaScript |
Ext.define('Ext.field.DatePickerNative', {
extend: 'Ext.field.DatePicker',
alternateClassName: 'Ext.form.DatePickerNative',
xtype: 'datepickernativefield',
initialize: function() {
this.callParent();
},
onFocus: function(e) {
var me = this;
if (!(navigator.plugins &&... | JavaScript |
/**
* @aside guide forms
*
* Creates an HTML textarea field on the page. This is useful whenever you need the user to enter large amounts of text
* (i.e. more than a few words). Typically, text entry on mobile devices is not a pleasant experience for the user so
* it's good to limit your use of text areas to only ... | JavaScript |
/**
* @aside guide forms
*
* This is a specialized field which shows a {@link Ext.picker.Date} when tapped. If it has a predefined value,
* or a value is selected in the {@link Ext.picker.Date}, it will be displayed like a normal {@link Ext.field.Text}
* (but not selectable/changable).
*
* Ext.create('Ext.fi... | JavaScript |
/**
* @private
*/
Ext.define('Ext.field.Input', {
extend: 'Ext.Component',
xtype : 'input',
/**
* @event clearicontap
* Fires whenever the clear icon is tapped.
* @param {Ext.field.Input} this
* @param {Ext.EventObject} e The event object
*/
/**
* @event masktap
* ... | JavaScript |
/**
* @aside guide forms
*
* Hidden fields allow you to easily inject additional data into a {@link Ext.form.Panel form} without displaying
* additional fields on the screen. This is often useful for sending dynamic or previously collected data back to the
* server in the same request as the normal form submission... | JavaScript |
/**
* @aside guide forms
*
* The Password field creates a password input and is usually created inside a form. Because it creates a password
* field, when the user enters text it will show up as stars. Aside from that, the password field is just a normal text
* field. Here's an example of how to use it in a form:
... | JavaScript |
/**
* @aside guide forms
*
* The radio field is an enhanced version of the native browser radio controls and is a good way of allowing your user
* to choose one option out of a selection of several (for example, choosing a favorite color):
*
* @example
* var form = Ext.create('Ext.form.Panel', {
* ... | JavaScript |
/**
* @aside guide forms
*
* Field is the base class for all form fields used in Sencha Touch. It provides a lot of shared functionality to all
* field subclasses (for example labels, simple validation, {@link #clearIcon clearing} and tab index management), but
* is rarely used directly. Instead, it is much more c... | JavaScript |
/**
* @aside guide forms
*
* The slider is a way to allow the user to select a value from a given numerical range. You might use it for choosing
* a percentage, combine two of them to get min and max values, or use three of them to specify the hex values for a
* color. Each slider contains a single 'thumb' that ca... | JavaScript |
/**
* @private
*/
Ext.define('Ext.field.File', {
extend: 'Ext.field.Input',
xtype : 'file',
cachedConfig: {
type: 'file'
},
// @private
getTemplate: function() {
var items = [
{
reference: 'input',
tag: this.tag,
typ... | JavaScript |
/**
* @aside guide forms
*
* The Email field creates an HTML5 email input and is usually created inside a form. Because it creates an HTML email
* input field, most browsers will show a specialized virtual keyboard for email address input. Aside from that, the
* email field is just a normal text field. Here's an e... | JavaScript |
/**
* @aside guide forms
*
* The Number field creates an HTML5 number input and is usually created inside a form. Because it creates an HTML
* number input field, most browsers will show a specialized virtual keyboard for entering numbers. The Number field
* only accepts numerical input and also provides additiona... | JavaScript |
/**
* @aside guide forms
*
* Specialized {@link Ext.field.Slider} with a single thumb which only supports two {@link #value values}.
*
* ## Examples
*
* @example miniphone preview
* Ext.Viewport.add({
* xtype: 'togglefield',
* name: 'awesome',
* label: 'Are you awesome?',
* ... | JavaScript |
/**
* @aside guide forms
*
* The text field is the basis for most of the input fields in Sencha Touch. It provides a baseline of shared
* functionality such as input validation, standard events, state management and look and feel. Typically we create
* text fields inside a form, like this:
*
* @example
* ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.field.TextAreaInput', {
extend: 'Ext.field.Input',
xtype : 'textareainput',
tag: 'textarea'
});
| JavaScript |
/**
* @aside guide forms
*
* Simple Select field wrapper. Example usage:
*
* @example
* Ext.create('Ext.form.Panel', {
* fullscreen: true,
* items: [
* {
* xtype: 'fieldset',
* title: 'Select',
* items: [
* ... | JavaScript |
/**
* @aside guide forms
*
* The Search field creates an HTML5 search input and is usually created inside a form. Because it creates an HTML
* search input type, the visual styling of this input is slightly different to normal text input controls (the corners
* are rounded), though the virtual keyboard displayed b... | JavaScript |
/**
* @aside guide forms
*
* Wraps an HTML5 number field. Example usage:
*
* @example miniphone
* var spinner = Ext.create('Ext.field.Spinner', {
* label: 'Spinner Field',
* minValue: 0,
* maxValue: 100,
* increment: 2,
* cycle: true
* });
* Ext.Viewp... | JavaScript |
/**
* @aside guide forms
*
* The checkbox field is an enhanced version of the native browser checkbox and is great for enabling your user to
* choose one or more items from a set (for example choosing toppings for a pizza order). It works like any other
* {@link Ext.field.Field field} and is usually found in the c... | JavaScript |
/**
The {@link Ext.Spacer} component is generally used to put space between items in {@link Ext.Toolbar} components.
## Examples
By default the {@link #flex} configuration is set to 1:
@example miniphone preview
Ext.create('Ext.Container', {
fullscreen: true,
items: [
{
... | JavaScript |
/**
* This class parses the XTemplate syntax and calls abstract methods to process the parts.
* @private
*/
Ext.define('Ext.XTemplateParser', {
constructor: function (config) {
Ext.apply(this, config);
},
/**
* @property {Number} level The 'for' loop context level. This is adjusted up by on... | JavaScript |
/**
* @author Ed Spencer
* @aside guide stores
*
* 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 Proxy}, and also provide functions for {@link #sort sorting},
* {@link #filter filtering} and querying the {@link Ext.da... | JavaScript |
/**
* @author Ed Spencer
*
* The ModelManager keeps track of all {@link Ext.data.Model} types defined in your application.
*
* ## Creating Model Instances
*
* Model instances can be created by using the {@link Ext.ClassManager#create Ext.create} method. Ext.create replaces
* the deprecated {@link #create Ext... | JavaScript |
/**
* @class Ext.data.Types
*
* This is a static class containing the system-supplied data types which may be given to a {@link Ext.data.Field Field}.
*
* 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 type, compare ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Errors
* @extends Ext.util.Collection
*
* Wraps a collection of validation error responses and provides convenient functions for
* accessing and errors for specific fields.
*
* Usually this class does not need to be instantiated directly - instances are instead created... | JavaScript |
/**
* @author Tommy Maintz
*
* This class generates UUID's according to RFC 4122. This class has a default id property.
* This means that a single instance is shared unless the id property is overridden. Thus,
* two {@link Ext.data.Model} instances configured like the following share one generator:
*
* Ext.d... | JavaScript |
/**
* @author Tommy Maintz
*
* This class is the simple default id generator for Model instances.
*
* An example of a configured simple generator would be:
*
* Ext.define('MyApp.data.MyModel', {
* extend: 'Ext.data.Model',
* config: {
* identifier: {
* type: 's... | JavaScript |
/**
* @author Tommy Maintz
*
* This class is a sequential id generator. A simple use of this class would be like so:
*
* Ext.define('MyApp.data.MyModel', {
* extend: 'Ext.data.Model',
* config: {
* identifier: 'sequential'
* }
* });
* // assign id's of 1, 2, 3,... | JavaScript |
/**
* @aside guide ajax
* @singleton
*
* This class is used to create JsonP requests. JsonP is a mechanism that allows for making requests for data cross
* domain. More information is available [here](http://en.wikipedia.org/wiki/JSONP).
*
* ## Example
*
* @example preview
* Ext.Viewport.add({
* ... | JavaScript |
/**
* @author Ed Spencer
* @aside guide models
*
* Fields are used to define what a Model is. They aren't instantiated directly - instead, when we create a class that
* extends {@link Ext.data.Model}, it will automatically create a Field instance for each field configured in a {@link
* Ext.data.Model Model}. For ... | JavaScript |
/**
* @author Ed Spencer
*
* Simple class that represents a Request that will be made by any {@link Ext.data.proxy.Server} subclass.
* All this class does is standardize the representation of a Request as used by any ServerProxy subclass,
* it does not contain any actual logic or perform the request itself.
*/
Ex... | JavaScript |
/**
* @author Ed Spencer
*
* Base Writer class used by most subclasses of {@link Ext.data.proxy.Server}. 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 Operations.
*
* For example a Ext.data.writer... | JavaScript |
/**
* This class is used to write {@link Ext.data.Model} data to the server in a JSON format.
* The {@link #allowSingle} configuration can be set to false to force the records to always be
* encoded in an array, even if there is only a single record being sent.
*/
Ext.define('Ext.data.writer.Json', {
extend: 'E... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.writer.Xml
*
* This class is used to write {@link Ext.data.Model} data to the server in an XML format.
* The {@link #documentRoot} property is used to specify the root element in the XML document.
* The {@link #record} option is used to specify the element name for each ... | JavaScript |
/**
* @aside guide stores
*
* Small helper class to create an {@link Ext.data.Store} configured with an {@link Ext.data.proxy.Direct}
* and {@link Ext.data.reader.Json} to make interacting with an {@link Ext.direct.Manager} server-side
* {@link Ext.direct.Provider Provider} easier. To create a different proxy/read... | JavaScript |
/**
* @class Ext.data.NodeInterface
* This class is meant to be used as a set of methods that are applied to the prototype of a
* Record to decorate it with a Node API. This means that models used in conjunction with a tree
* will have all of the tree related methods available on the model. In general this class wi... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Batch
*
* 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 been successfully executed. Fires an `... | JavaScript |
/**
* @private
*/
Ext.define('Ext.data.NodeStore', {
extend: 'Ext.data.Store',
alias: 'store.node',
requires: ['Ext.data.NodeInterface'],
config: {
/**
* @cfg {Ext.data.Model} node The Record you want to bind this Store to. Note that
* this record will be decorated with the ... | JavaScript |
/**
* @author Ed Spencer
*
* Readers are used to interpret data to be loaded into a {@link Ext.data.Model Model} instance or a {@link
* Ext.data.Store Store} - often in response to an AJAX request. In general there is usually no need to create
* a Reader instance directly, since a Reader is almost always used toge... | JavaScript |
/**
* 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:
*
* Ext.define('User', {
* extend: 'Ext.data.Model',
* config: {
* fields: ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.reader.Array
*
* 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 `mapping` property
* of the field ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.reader.Xml
* @extends Ext.data.reader.Reader
*
* 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:
*
* Ext.define('Us... | JavaScript |
/**
* @aside guide stores
*
* The TreeStore is a store implementation that allows for nested data.
*
* It provides convenience methods for loading nodes, as well as the ability to use
* the hierarchical tree structure combined with a store. This class also relays many events from
* the Tree for convenience.
*
... | JavaScript |
/**
* @aside guide proxies
*
* This class is used to send requests to the server using {@link Ext.direct.Manager Ext.Direct}. When a
* request is made, the transport mechanism is handed off to the appropriate
* {@link Ext.direct.RemotingProvider Provider} to complete the call.
*
* # Specifying the function
*
*... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* In-memory proxy. This proxy simply uses a local variable for data storage/retrieval, so its contents are lost on
* every page refresh.
*
* Usually this Proxy isn't used directly, serving instead as a helper to a {@link Ext.data.Store Store} where a reader
* is... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* 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 storage proxy requires a
* unique ID which is used as a ke... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* 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 like JSON), so
* LocalStorageProxy automatically serial... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* The JsonP proxy is useful when you need to load data from a domain other than the one your application is running on. If
* your application is running on http://domainA.com it cannot use {@link Ext.data.proxy.Ajax Ajax} to load its data
* from http://domainB.com... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* The Rest proxy is a specialization of the {@link Ext.data.proxy.Ajax 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 Model}
* with an inline Rest proxy:
... | JavaScript |
/**
* SQL proxy.
*/
Ext.define('Ext.data.proxy.Sql', {
alias: 'proxy.sql',
extend: 'Ext.data.proxy.Client',
alternateClassName: 'Ext.data.proxy.SQL',
isSQLProxy: true,
config: {
/**
* @cfg {Object} reader
* @hide
*/
reader: null,
/**
* ... | JavaScript |
/**
* @author Ed Spencer
*
* WebStorageProxy is simply a superclass for the {@link Ext.data.proxy.LocalStorage LocalStorage} proxy. It uses the
* new HTML5 key/value client-side storage objects to save {@link Ext.data.Model model instances} for offline use.
* @private
*/
Ext.define('Ext.data.proxy.WebStorage', {
... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* 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 typical setup. Here we're going to set u... | JavaScript |
/**
* @author Ed Spencer
*
* Base class for any client-side storage. Used as a superclass for {@link Ext.data.proxy.Memory Memory} and
* {@link Ext.data.proxy.WebStorage Web Storage} proxies. Do not use directly, use one of the subclasses instead.
* @private
*/
Ext.define('Ext.data.proxy.Client', {
extend: 'E... | JavaScript |
/**
* @author Ed Spencer
*
* ServerProxy is a superclass of {@link Ext.data.proxy.JsonP JsonPProxy} and {@link Ext.data.proxy.Ajax AjaxProxy}, and
* would not usually be used directly.
* @private
*/
Ext.define('Ext.data.proxy.Server', {
extend: 'Ext.data.proxy.Proxy',
alias : 'proxy.server',
alternate... | JavaScript |
/**
* @author Ed Spencer
* @aside guide proxies
*
* 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.
*
* # Types of Proxy
*
* There are two main types of Proxy... | JavaScript |
/**
* @class Ext.data.SortTypes
* This class defines a series of static methods that are used on a
* {@link Ext.data.Field} for performing sorting. The methods cast the
* underlying values into a data type that is appropriate for sorting on
* that particular field. If a {@link Ext.data.Field#type} is specified,
... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.JsonStore
* @extends Ext.data.Store
* @private
*
* 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.reader.Json}.
*
* A store configuration would be something like:... | JavaScript |
/**
* The Connection class encapsulates a connection to the page's originating domain, allowing requests to be made either
* to a configured URL, or to a URL specified at request time.
*
* Requests made by this class are asynchronous, and will return immediately. No data from the server will be available
* to the ... | JavaScript |
/**
* @author Ed Spencer
* @aside guide models
*
* 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.
*/
Ext.define('Ext.data.Validations', {
alterna... | JavaScript |
/**
* @author Ed Spencer
*
* Simple wrapper class that represents a set of records returned by a Proxy.
*/
Ext.define('Ext.data.ResultSet', {
config: {
/**
* @cfg {Boolean} loaded
* True if the records have already been loaded. This is only meaningful when dealing with
* SQL-b... | JavaScript |
/**
* @author Ed Spencer
* @aside guide models
*
* 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:
*
* Ext.define('Category', {
* extend: 'Ext.data.Model',
* config: {
* ... | JavaScript |
/**
* @aside guide models
*
* Represents a one-to-many relationship between two models. Usually created indirectly via a model definition:
*
* Ext.define('Product', {
* extend: 'Ext.data.Model',
* config: {
* fields: [
* {name: 'id', type: 'int'},
* ... | JavaScript |
/**
* @author Ed Spencer
* @aside guide models
*
* 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
* express like this:
*
* Ex... | JavaScript |
/**
* @aside guide models
*
* Represents a one 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:
*
* Ext.define('Person', {
* extend: 'Ext.data.Model',
* config: {
* fields: [
* ... | JavaScript |
/**
* @author Ed Spencer
* @aside guide stores
*
* 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.reader.Array}.
*
* A store configuration would be something like:
*
* var store = Ext.create('Ext.da... | JavaScript |
/**
* @docauthor Evan Trimboli <evan@sencha.com>
* @aside guide stores
*
* Contains a collection of all stores that are created that have an identifier. An identifier can be assigned by
* setting the {@link Ext.data.Store#storeId storeId} property. When a store is in the StoreManager, it can be
* referred to via ... | JavaScript |
/**
* @author Ed Spencer
* @class Ext.data.Error
*
* This is used when validating a record. The validate method will return an {@link Ext.data.Errors} collection
* containing Ext.data.Error instances. Each error has a field and a message.
*
* Usually this class does not need to be instantiated directly - instanc... | JavaScript |
/**
* @author Ed Spencer
*
* Represents a single read or write operation performed by a {@link Ext.data.proxy.Proxy Proxy}. Operation objects are
* used to enable communication between Stores and Proxies. Application developers should rarely need to interact with
* Operation objects directly.
*
* Note that when ... | JavaScript |
/**
* @author Ed Spencer
* @aside guide models
*
* 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
* {@link Ext.data.ModelManager model... | JavaScript |
/**
* Provides a base class for audio/visual controls. Should not be used directly.
*
* Please see the {@link Ext.Audio} and {@link Ext.Video} classes for more information.
* @private
*/
Ext.define('Ext.Media', {
extend: 'Ext.Component',
xtype: 'media',
/**
* @event play
* Fires whenever the... | JavaScript |
/**
* A simple class to display a button in Sencha Touch.
*
* There are various different styles of Button you can create by using the {@link #icon},
* {@link #iconCls}, {@link #iconAlign}, {@link #ui}, and {@link #text}
* configurations.
*
* ## Simple Button
*
* Here is a Button in it's simplest form:
*
* ... | JavaScript |
/**
* Used in the {@link Ext.tab.Bar} component. This shouldn't be used directly, instead use
* {@link Ext.tab.Bar} or {@link Ext.tab.Panel}.
* @private
*/
Ext.define('Ext.tab.Tab', {
extend: 'Ext.Button',
xtype: 'tab',
alternateClassName: 'Ext.Tab',
// @private
isTab: true,
config: {
... | JavaScript |
/**
* Ext.tab.Bar is used internally by {@link Ext.tab.Panel} to create the bar of tabs that appears at the top of the tab
* panel. It's unusual to use it directly, instead see the {@link Ext.tab.Panel tab panel docs} for usage instructions.
*
* Used in the {@link Ext.tab.Panel} component to display {@link Ext.tab.... | JavaScript |
/**
* @aside guide tabs
* @aside video tabs-toolbars
* @aside example tabs
* @aside example tabs-bottom
*
* Tab Panels are a great way to allow the user to switch between several pages that are all full screen. Each
* Component in the Tab Panel gets its own Tab, which shows the Component when tapped on. Tabs can... | JavaScript |
/**
* @author Ed Spencer
*
* @aside guide controllers
* @aside guide apps_intro
* @aside guide history_support
* @aside video mvc-part-1
* @aside video mvc-part-2
*
* Controllers are responsible for responding to events that occur within your app. If your app contains a Logout
* {@link Ext.Button button} that... | JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.