code stringlengths 1 2.08M | language stringclasses 1
value |
|---|---|
/**
* @private
*/
Ext.define('Ext.fx.animation.WipeOut', {
extend: 'Ext.fx.animation.Wipe',
config: {
// @hide
out: true
}
}); | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.animation.Flip', {
extend: 'Ext.fx.animation.Abstract',
alias: 'animation.flip',
config: {
easing: 'ease-in',
/**
* @cfg {String} direction The direction of which the slide animates
* @accessor
*/
direction: 'right'... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.animation.Pop', {
extend: 'Ext.fx.animation.Abstract',
alias: ['animation.pop', 'animation.popIn'],
alternateClassName: 'Ext.fx.animation.PopIn',
config: {
/**
* @cfg {Boolean} out True if you want to make this animation pop out, instead of pop ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.animation.Wipe', {
extend: 'Ext.fx.Animation',
alternateClassName: 'Ext.fx.animation.WipeIn',
config: {
/**
* Valid values are 'ease', 'linear', ease-in', 'ease-out', 'ease-in-out',
* or a cubic-bezier curve as defined by CSS.
*/
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.animation.FadeOut', {
extend: 'Ext.fx.animation.Fade',
alias: 'animation.fadeOut',
config: {
// @hide
out: true,
before: {}
}
});
| JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.animation.Abstract', {
extend: 'Ext.Evented',
isAnimation: true,
requires: [
'Ext.fx.State'
],
config: {
name: '',
element: null,
/**
* @cfg
* Before configuration.
*/
before: null,
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.animation.Cube', {
extend: 'Ext.fx.animation.Abstract',
alias: 'animation.cube',
config: {
/**
* @cfg
* @inheritdoc
*/
before: {
// 'transform-style': 'preserve-3d'
},
after: {},
/**
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.State', {
isAnimatable: {
'background-color' : true,
'background-image' : true,
'background-position': true,
'border-bottom-color': true,
'border-bottom-width': true,
'border-color' : true,
'border-left-color' ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.Easing', {
requires: ['Ext.fx.easing.Linear'],
constructor: function(easing) {
return Ext.factory(easing, Ext.fx.easing.Linear, null, 'easing');
}
});
| JavaScript |
/**
* @author Jacky Nguyen <jacky@sencha.com>
* @private
*/
Ext.define('Ext.fx.runner.CssTransition', {
extend: 'Ext.fx.runner.Css',
requires: ['Ext.AnimationQueue'],
listenersAttached: false,
constructor: function() {
this.runningAnimationsData = {};
return this.callParent(argumen... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.runner.Css', {
extend: 'Ext.Evented',
requires: [
'Ext.fx.Animation'
],
prefixedProperties: {
'transform' : true,
'transform-origin' : true,
'perspective' : true,
'transform-style' ... | JavaScript |
/**
* @author Jacky Nguyen <jacky@sencha.com>
* @private
*/
Ext.define('Ext.fx.runner.CssAnimation', {
extend: 'Ext.fx.runner.Css',
constructor: function() {
this.runningAnimationsMap = {};
this.elementEndStates = {};
this.animationElementMap = {};
this.keyframesRulesCache... | JavaScript |
/**
* @class Ext.fx.Runner
* @private
*/
Ext.define('Ext.fx.Runner', {
requires: [
'Ext.fx.runner.CssTransition'
// 'Ext.fx.runner.CssAnimation'
],
constructor: function() {
return new Ext.fx.runner.CssTransition();
}
});
| JavaScript |
/**
* @private
*
* This easing is typically used for {@link Ext.scroll.Scroller}. It's a combination of
* {@link Ext.fx.easing.Momentum} and {@link Ext.fx.easing.Bounce}, which emulates deceleration when the animated element
* is still within its boundary, then bouncing back (snapping) when it's out-of-bound.
*/
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.easing.EaseIn', {
extend: 'Ext.fx.easing.Linear',
alias: 'easing.ease-in',
config: {
exponent: 4,
duration: 1500
},
getValue: function() {
var deltaTime = Ext.Date.now() - this.getStartTime(),
duration = this.getDuration()... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.easing.Momentum', {
extend: 'Ext.fx.easing.Abstract',
config: {
acceleration: 30,
friction: 0,
startVelocity: 0
},
alpha: 0,
updateFriction: function(friction) {
var theta = Math.log(1 - (friction / 10));
this.theta ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.easing.EaseOut', {
extend: 'Ext.fx.easing.Linear',
alias: 'easing.ease-out',
config: {
exponent: 4,
duration: 1500
},
getValue: function() {
var deltaTime = Ext.Date.now() - this.getStartTime(),
duration = this.getDuration... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.easing.Linear', {
extend: 'Ext.fx.easing.Abstract',
alias: 'easing.linear',
config: {
duration: 0,
endValue: 0
},
updateStartValue: function(startValue) {
this.distance = this.getEndValue() - startValue;
},
updateEndValue: f... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.easing.Abstract', {
config: {
startTime: 0,
startValue: 0
},
isEasing: true,
isEnded: false,
constructor: function(config) {
this.initConfig(config);
return this;
},
applyStartTime: function(startTime) {
if ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.fx.easing.Bounce', {
extend: 'Ext.fx.easing.Abstract',
config: {
springTension: 0.3,
acceleration: 30,
startVelocity: 0
},
getValue: function() {
var deltaTime = Ext.Date.now() - this.getStartTime(),
theta = (deltaTime / ... | JavaScript |
/**
* @private
* @author Jacky Nguyen <jacky@sencha.com>
*/
Ext.define('Ext.fx.Animation', {
requires: [
'Ext.fx.animation.Slide',
'Ext.fx.animation.SlideOut',
'Ext.fx.animation.Fade',
'Ext.fx.animation.FadeOut',
'Ext.fx.animation.Flip',
'Ext.fx.animation.Pop',
... | JavaScript |
Ext.data.SyncStore = Ext.extend(Object, {
constructor: function(config) {
Ext.data.utilities.check('SyncStore', 'constructor', 'config', config, ['database_name','localStorageProxy']);
this.local= config.localStorageProxy;
this.readConfig('index',function(data) {
this.index= data||{};
},this);
},
cr... | JavaScript |
Ext.data.SyncProxy = Ext.extend(Ext.data.Proxy, {
definition: undefined,
csv: undefined,
generator: undefined,
model: undefined,
store: undefined,
idProperty: undefined,
idDefaultProperty: undefined,
// JCM constructor should not be async, delay until first operation
constructor: function(config,callback,s... | JavaScript |
Ext.regModel("Sencha.Protocol.Model", { // JCM not actually used...
fields: [
{name: "id"}
]
});
Ext.data.SyncStorageProxy = Ext.extend(Ext.data.Proxy, {
constructor: function(config) {
//
Ext.data.utilities.check('SyncStorageProxy', 'constructor', 'config', config, ['id','url','key']);
//
... | JavaScript |
// this model is used to extend the user's own model.
// it adds the replication state.
Ext.data.SyncModel= {
STATE: '_state',
TOMBSTONE: '_ts',
OID: '_oid',
REF: '_ref',
MODEL: '_model',
state: undefined,
createReplStorageModel: function(modelName) { // create the storage model, based on the user model
... | JavaScript |
Ext.data.CSV = Ext.extend(Ext.data.Config, {
v: undefined, // array of change stamps
constructor: function(config,callback,scope) {
var changed= false;
if (config) {
config.config_id= 'csv';
Ext.data.CSV.superclass.constructor.call(this, config);
if (config.v) {
this.v= [];
this.do_add(config.... | JavaScript |
// JCM this 'class' could help with batching updates to be sent to the server
Ext.data.Updates = Ext.extend(Object, {
updates: undefined,
constructor: function(x) {
//
// sort the updates into change stamp order,
// as they have to be transmitted this way
//
this.updates= x||[];
this.updates.forEach(... | JavaScript |
Ext.data.Config = Ext.extend(Object, {
config_id: undefined,
write_fn: undefined,
_id: undefined,
constructor: function(config) {
this.config_id= config.config_id;
this.write_fn= config.write_fn;
this._id= config._id;
},
set: function(data) {
this._id= data._id;
},
to_s: function(indent) {
ret... | JavaScript |
Ext.data.UUIDGenerator= {
generate: function() { // totally random uuid
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);
});
}
}; | JavaScript |
Ext.data.DatabaseDefinition = Ext.extend(Ext.data.Config, {
key: undefined, // the developer's api key
database_name: undefined,
generation: undefined, // of the database
system_name: undefined, // this system
system_names: {}, // other systems
replica_number: undefined,
idProperty: undefined,
idPropertyDefau... | JavaScript |
Ext.data.Clock = Ext.extend(Object, {
constructor: function() {
this.epoch= new Date(2011,0,1);
},
now: function() {
return this.ms_to_s(new Date().getTime()-this.epoch);
},
ms_to_s: function(ms) {
return Math.floor(ms/1000);
}
}); | JavaScript |
Ext.data.Protocol = Ext.extend(Object, {
constructor: function(config) {
this.remote = config.remoteStorageProxy;
this.remote.on('exception',function(proxy,request,operation){
console.log('EXCEPTION'); // JCM should handle this properly...
console.log(request);
console.log(operation);
});
},
... | JavaScript |
Ext.data.array= {
select: function(a,fn,scope) {
var r= [];
if (a) {
a.forEach(function(i) {
if (i!==undefined && fn.call(scope||i,i)) { r.push(i) }
})
}
return r;
},
index: function(a,fn,scope) {
if (a) {
var j, l= a.length;
for(var i= 0;i<l;i++) {
j= a[i];
if(fn.call(scope||j... | JavaScript |
Ext.data.CS = Ext.extend(Object, { // Change Stamp
r: 0, // replica_number
t: 0, // time, in seconds since the epoch
s: 0, // sequence number
constructor: function(config) {
this.set(config);
},
set: function(x) {
if (typeof x === 'string' || x instanceof String) {
this.from_s(x)
} else if (typeof x... | JavaScript |
Ext.data.CSGenerator = Ext.extend(Ext.data.Config, {
r: undefined, // replica_number
t: undefined, // time, in seconds since epoch
s: undefined, // sequence number
clock: undefined,
local_offset: undefined,
global_offset: undefined,
constructor: function(config,callback,scope) {
Ext.apply(this, config);
... | JavaScript |
Ext.data.utilities= {
delegate: function(from_instance, to_instance, methods) {
if (to_instance===undefined) { throw "Error - Tried to delegate '"+methods+"' to undefined instance."; }
methods.forEach(function(method){
var to_method= to_instance[method];
if (to_method===undefined) { throw "Error - Tried to... | JavaScript |
Ext.define('Ext.table.Table', {
extend: 'Ext.Container',
requires: ['Ext.table.Row'],
xtype: 'table',
config: {
baseCls: 'x-table',
defaultType: 'tablerow'
},
cachedConfig: {
fixedLayout: false
},
fixedLayoutCls: 'x-table-fixed',
updateFixedLayout: funct... | JavaScript |
Ext.define('Ext.table.Cell', {
extend: 'Ext.Container',
xtype: 'tablecell',
config: {
baseCls: 'x-table-cell'
},
getElementConfig: function() {
var config = this.callParent();
config.children.length = 0;
return config;
}
});
| JavaScript |
Ext.define('Ext.table.Row', {
extend: 'Ext.table.Cell',
xtype: 'tablerow',
config: {
baseCls: 'x-table-row',
defaultType: 'tablecell'
}
});
| JavaScript |
/**
* @aside guide floating_components
*
* Panels are most useful as Overlays - containers that float over your application. They contain extra styling such
* that when you {@link #showBy} another component, the container will appear in a rounded black box with a 'tip'
* pointing to a reference component.
*
* If... | JavaScript |
/**
* SegmentedButton is a container for a group of {@link Ext.Button}s. Generally a SegmentedButton would be
* a child of a {@link Ext.Toolbar} and would be used to switch between different views.
*
* ## Example usage:
*
* @example
* var segmentedButton = Ext.create('Ext.SegmentedButton', {
* a... | JavaScript |
/**
* A simple class used to mask any {@link Ext.Container}.
*
* This should rarely be used directly, instead look at the {@link Ext.Container#masked} configuration.
*
* ## Example
*
* @example miniphone
* Ext.Viewport.add({
* masked: {
* xtype: 'loadmask'
* }
* });
*... | JavaScript |
(function(clsPrefix) {
/**
* Most of the visual classes you interact with in Sencha Touch are Components. Every Component in Sencha Touch is a
* subclass of Ext.Component, which means they can all:
*
* * Render themselves onto the page using a template
* * Show and hide themselves at any time
* * Center themselv... | JavaScript |
/**
* Ext.Direct aims to streamline communication between the client and server by providing a single interface that
* reduces the amount of common code typically required to validate data and handle returned data packets (reading data,
* error conditions, etc).
*
* The Ext.direct namespace includes several classe... | JavaScript |
/**
* Supporting Class for Ext.Direct (not intended to be used directly).
*/
Ext.define('Ext.direct.Transaction', {
alias: 'direct.transaction',
alternateClassName: 'Ext.Direct.Transaction',
statics: {
TRANSACTION_ID: 0
},
config: {
id: undefined,
provider: null,
... | JavaScript |
/**
* @class Ext.direct.RemotingEvent
* An event that is fired when data is received from a
* {@link Ext.direct.RemotingProvider}. Contains a method to the
* related transaction for the direct request, see {@link #getTransaction}
*/
Ext.define('Ext.direct.RemotingEvent', {
extend: 'Ext.direct.Event',
alia... | JavaScript |
/**
* Small utility class used internally to represent a Direct method.
* @class Ext.direct.RemotingMethod
* @private
*/
Ext.define('Ext.direct.RemotingMethod', {
config: {
name: null,
params: null,
formHandler: null,
len: null,
ordered: true
},
constructor: func... | JavaScript |
/**
* @class Ext.direct.ExceptionEvent
* An event that is fired when an exception is received from a {@link Ext.direct.RemotingProvider}
*/
Ext.define('Ext.direct.ExceptionEvent', {
extend: 'Ext.direct.RemotingEvent',
alias: 'direct.exception',
config: {
status: false,
name: 'exception... | JavaScript |
/**
* Ext.direct.Provider is an abstract class meant to be extended.
*
* For example Ext JS implements the following subclasses:
*
* Provider
* |
* +---{@link Ext.direct.JsonProvider JsonProvider}
* |
* +---{@link Ext.direct.PollingProvider PollingProvider}
* |
* +... | JavaScript |
/**
* @class Ext.direct.JsonProvider
*
* A base provider for communicating using JSON. This is an abstract class
* and should not be instanced directly.
* @abstract
*/
Ext.define('Ext.direct.JsonProvider', {
extend: 'Ext.direct.Provider',
alias: 'direct.jsonprovider',
uses: ['Ext.direct.ExceptionEv... | JavaScript |
/**
* @class Ext.direct.Event
* A base class for all Ext.direct events. An event is
* created after some kind of interaction with the server.
* The event class is essentially just a data structure
* to hold a Direct response.
*/
Ext.define('Ext.direct.Event', {
alias: 'direct.event',
requires: ['Ext.dire... | JavaScript |
/**
* @class Ext.direct.RemotingProvider
*
* The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to
* server side methods on the client (a remote procedure call (RPC) type of
* connection where the client can initiate a procedure on the server).
*
* This allows for code to be organized in a f... | JavaScript |
/**
* @private
*
* Provides a registry of all Components (instances of {@link Ext.Component} or any subclass
* thereof) on a page so that they can be easily accessed by {@link Ext.Component component}
* {@link Ext.Component#getId id} (see {@link #get}, or the convenience method {@link Ext#getCmp Ext.getCmp}).
*
... | JavaScript |
/**
*
*/
Ext.define('Ext.util.PaintMonitor', {
requires: [
'Ext.util.paintmonitor.CssAnimation',
'Ext.util.paintmonitor.OverflowChange'
],
constructor: function(config) {
if (Ext.browser.is.Firefox || (Ext.browser.is.WebKit && Ext.browser.engineVersion.gtEq('536') && !Ext.os.is.Bl... | JavaScript |
/**
* @private
*
* Scroll position implementation
*/
Ext.define('Ext.util.translatable.ScrollPosition', {
extend: 'Ext.util.translatable.Dom',
type: 'scrollposition',
config: {
useWrapper: true
},
getWrapper: function() {
var wrapper = this.wrapper,
element = this.... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.translatable.Dom', {
extend: 'Ext.util.translatable.Abstract',
config: {
element: null
},
applyElement: function(element) {
if (!element) {
return;
}
return Ext.get(element);
},
updateElement: function() {
... | JavaScript |
/**
* @class Ext.util.translatable.CssPosition
* @private
*/
Ext.define('Ext.util.translatable.CssPosition', {
extend: 'Ext.util.translatable.Dom',
doTranslate: function(x, y) {
var domStyle = this.getElement().dom.style;
if (typeof x == 'number') {
domStyle.left = x + 'px';
... | JavaScript |
/**
* @private
*
* The abstract class. Sub-classes are expected, at the very least, to implement translation logics inside
* the 'translate' method
*/
Ext.define('Ext.util.translatable.Abstract', {
extend: 'Ext.Evented',
requires: ['Ext.fx.easing.Linear'],
config: {
useWrapper: null,
... | JavaScript |
/**
* @private
*
* CSS Transform implementation
*/
Ext.define('Ext.util.translatable.CssTransform', {
extend: 'Ext.util.translatable.Dom',
doTranslate: function(x, y) {
if (!this.isDestroyed) {
this.getElement().translate(x, y);
}
},
destroy: function() {
var el... | JavaScript |
/**
* @docauthor Tommy Maintz <tommy@sencha.com>
*
* A mixin which allows a data component to be sorted. This is used by e.g. {@link Ext.data.Store} and {@link Ext.data.TreeStore}.
*
* __Note:__ This mixin is mainly for internal library use and most users should not need to use it directly. It
* is more likely yo... | JavaScript |
/**
* Provides a cross browser class for retrieving location information.
*
* Based on the [Geolocation API Specification](http://dev.w3.org/geo/api/spec-source.html)
*
* When instantiated, by default this class immediately begins tracking location information,
* firing a {@link #locationupdate} event when new lo... | JavaScript |
/**
* Reusable data formatting functions
*/
Ext.define('Ext.util.Format', {
requires: [
'Ext.DateExtras'
],
singleton: true,
/**
* The global default date format.
*/
defaultDateFormat: 'm/d/Y',
escapeRe: /('|\\)/g,
trimRe: /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2... | JavaScript |
/**
* Represents a 2D point with x and y properties, useful for comparison and instantiation
* from an event:
*
* var point = Ext.util.Point.fromEvent(e);
*/
Ext.define('Ext.util.Point', {
radianToDegreeConstant: 180 / Math.PI,
statics: {
/**
* Returns a new instance of {@link Ext.ut... | JavaScript |
/**
* The utility class to abstract different implementations to have the best performance when applying 2D translation
* on any DOM element.
*
* @private
*/
Ext.define('Ext.util.Translatable', {
requires: [
'Ext.util.translatable.CssTransform',
'Ext.util.translatable.ScrollPosition',
'... | JavaScript |
/**
*
*/
Ext.define('Ext.util.SizeMonitor', {
requires: [
'Ext.util.sizemonitor.Default',
'Ext.util.sizemonitor.Scroll',
'Ext.util.sizemonitor.OverflowChange'
],
constructor: function(config) {
var namespace = Ext.util.sizemonitor;
if (Ext.browser.is.Firefox) {
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.paintmonitor.OverflowChange', {
extend: 'Ext.util.paintmonitor.Abstract',
eventName: Ext.browser.is.Firefox ? 'overflow' : 'overflowchanged',
monitorClass: 'overflowchange',
onElementPainted: function(e) {
this.getCallback().apply(this.getScope(), thi... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.paintmonitor.Abstract', {
config: {
element: null,
callback: Ext.emptyFn,
scope: null,
args: []
},
eventName: '',
monitorClass: '',
constructor: function(config) {
this.onElementPainted = Ext.Function.bind(this.o... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.paintmonitor.CssAnimation', {
extend: 'Ext.util.paintmonitor.Abstract',
eventName: Ext.browser.is.WebKit ? 'webkitAnimationEnd' : 'animationend',
monitorClass: 'cssanimation',
onElementPainted: function(e) {
if (e.animationName === 'x-paint-monitor-he... | JavaScript |
/**
* 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 during that time period,
* the task is called again, the original call ... | JavaScript |
/**
* Represents a single sorter that can be used as part of the sorters configuration in Ext.mixin.Sortable.
*
* A common place for Sorters to be used are {@link Ext.data.Store Stores}. For example:
*
* @example miniphone
* var store = Ext.create('Ext.data.Store', {
* fields: ['firstName', 'lastN... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.TranslatableGroup', {
extend: 'Ext.util.translatable.Abstract',
config: {
items: [],
activeIndex: 0,
itemLength: {
x: 0,
y: 0
}
},
applyItems: function(items) {
return Ext.Array.from(items);
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.Collection', {
/**
* @cfg {Object[]} filters
* Array of {@link Ext.util.Filter Filters} for this collection.
*/
/**
* @cfg {Object[]} sorters
* Array of {@link Ext.util.Sorter Sorters} for this collection.
*/
config: {
autoFilt... | 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 |
/**
* Represents a filter that can be applied to a {@link Ext.util.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 {@link Ext.data.Store Store}s frequently create... | JavaScript |
/**
*
*/
Ext.define('Ext.util.Wrapper', {
mixins: ['Ext.mixin.Bindable'],
constructor: function(elementConfig, wrappedElement) {
var element = this.link('element', Ext.Element.create(elementConfig));
if (wrappedElement) {
element.insertBefore(wrappedElement);
this.wra... | JavaScript |
/**
* General purpose inflector class that {@link #pluralize pluralizes}, {@link #singularize singularizes} and
* {@link #ordinalize ordinalizes} words. Sample usage:
*
* // turning singular words into plurals
* Ext.util.Inflector.pluralize('word'); // 'words'
* Ext.util.Inflector.pluralize('person')... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.AbstractMixedCollection', {
requires: ['Ext.util.Filter'],
mixins: {
observable: 'Ext.mixin.Observable'
},
/**
* @event clear
* Fires when the collection is cleared.
*/
/**
* @event add
* Fires when an item is added to the ... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.sizemonitor.OverflowChange', {
extend: 'Ext.util.sizemonitor.Abstract',
constructor: function(config) {
this.onExpand = Ext.Function.bind(this.onExpand, this);
this.onShrink = Ext.Function.bind(this.onShrink, this);
this.callSuper(arguments);
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.sizemonitor.Default', {
extend: 'Ext.util.sizemonitor.Abstract',
updateElement: function(element) {},
bindListeners: function(bind) {
var element = this.getElement().dom;
if (!element) {
return;
}
if (bind) {
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.sizemonitor.Scroll', {
extend: 'Ext.util.sizemonitor.Abstract',
getElementConfig: function() {
return {
reference: 'detectorsContainer',
classList: ['x-size-monitors', 'scroll'],
children: [
{
... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.sizemonitor.Abstract', {
mixins: ['Ext.mixin.Templatable'],
requires: [
'Ext.TaskQueue'
],
config: {
element: null,
callback: Ext.emptyFn,
scope: null,
args: []
},
width: 0,
height: 0,
contentWidth:... | JavaScript |
/**
* Represents a rectangular region and provides a number of utility methods
* to compare regions.
*/
Ext.define('Ext.util.Region', {
requires: ['Ext.util.Offset'],
statics: {
/**
* @static
* Retrieves an Ext.util.Region for a particular element.
* @param {String/HTMLEl... | JavaScript |
/**
* A core util class to bring Draggable behavior to any DOM element
*/
Ext.define('Ext.util.Draggable', {
isDraggable: true,
mixins: [
'Ext.mixin.Observable'
],
requires: [
'Ext.util.Translatable'
],
/**
* @event dragstart
* @preventable initDragStart
* Fir... | JavaScript |
/**
* Represents a collection of a set of key and value pairs. Each key in the MixedCollection must be unique, the same key
* cannot exist twice. This collection is ordered, items in the collection can be accessed by index or via the key.
* Newly added items are added to the end of the collection. This class is simi... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.Grouper', {
/* Begin Definitions */
extend: 'Ext.util.Sorter',
isGrouper: true,
config: {
/**
* @cfg {Function} groupFn This function will be called for each item in the collection to
* determine the group to which it belongs.
... | JavaScript |
/**
* Represents a collection of a set of key and value pairs. Each key in the HashMap must be unique, the same
* key cannot exist twice. Access to items is provided via the key only. Sample usage:
*
* var map = Ext.create('Ext.util.HashMap');
* map.add('key1', 1);
* map.add('key2', 2);
* map.add... | JavaScript |
/**
* @class Ext.util.LineSegment
*
* Utility class that represents a line segment, constructed by two {@link Ext.util.Point}
*/
Ext.define('Ext.util.LineSegment', {
requires: ['Ext.util.Point'],
/**
* Creates new LineSegment out of two points.
* @param {Ext.util.Point} point1
* @param {Ext.... | JavaScript |
/**
*
*/
Ext.define('Ext.util.Droppable', {
mixins: {
observable: 'Ext.mixin.Observable'
},
config: {
/**
* The base CSS class to apply to this component's element.
* This will also be prepended to other elements within this component.
*/
baseCls: Ext.ba... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.TranslatableList', {
extend: 'Ext.util.translatable.Abstract',
config: {
items: []
},
applyItems: function(items) {
return Ext.Array.from(items);
},
doTranslate: function(x, y) {
var items = this.getItems(),
offset =... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.PositionMap', {
config: {
minimumHeight: 50
},
constructor: function(config) {
this.map = [];
this.adjustments = {};
this.offset = 0;
this.initConfig(config);
},
populate: function(count, offset) {
var map = ... | JavaScript |
/**
*
* @private
* A utility class to disable input fields in WP7,8 because they stay still clickable even if they are under other elements.
*/
Ext.define('Ext.util.InputBlocker', {
blockInputs: function () {
if (Ext.browser.is.ie) {
Ext.select('.x-field-text .x-field-input:not(.x-item-disab... | JavaScript |
/**
* 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.
*/
Ext.define('Ext.util.TapRepeater', {
requires: ['Ext.DateExtras'],
mixins: {
observable: 'Ext... | JavaScript |
/**
* @private
*/
Ext.define('Ext.util.Offset', {
/* Begin Definitions */
statics: {
fromObject: function(obj) {
return new this(obj.x, obj.y);
}
},
/* End Definitions */
constructor: function(x, y) {
this.x = (x != null && !isNaN(x)) ? x : 0;
this.y... | JavaScript |
/**
* @class Ext.chart.MarkerHolder
* @extends Ext.mixin.Mixin
*
* Mixin that provides the functionality to place markers.
*/
Ext.define("Ext.chart.MarkerHolder", {
extend: 'Ext.mixin.Mixin',
mixinConfig: {
id: 'markerHolder',
hooks: {
constructor: 'constructor',
pr... | JavaScript |
/**
* @class Ext.chart.PolarChart
* @extends Ext.chart.AbstractChart
*
* Creates a chart that uses polar coordinates.
*/
Ext.define('Ext.chart.PolarChart', {
requires: [
'Ext.chart.grid.CircularGrid',
'Ext.chart.grid.RadialGrid'
],
extend: 'Ext.chart.AbstractChart',
xtype: 'polar... | JavaScript |
/**
* @class Ext.chart.SpaceFillingChart
* @extends Ext.chart.AbstractChart
*
* Creates a chart that fills the entire area of the chart.
* e.g. Gauge, Treemap
*/
Ext.define('Ext.chart.SpaceFillingChart', {
extend: 'Ext.chart.AbstractChart',
xtype: 'spacefilling',
config: {
},
performLayou... | JavaScript |
/**
* @class Ext.chart.axis.Time
* @extends Ext.chart.axis.Numeric
*
* A type of axis whose units are measured in time values. Use this axis
* for listing dates that you will want to group or dynamically change.
* If you just want to display dates as categories then use the
* Category class for axis instead.
*
... | JavaScript |
/**
* @class Ext.chart.axis.Axis
*
* Defines axis for charts.
*
* Using the current model, the type of axis can be easily extended. By default, Sencha Touch provides three different
* type of axis:
*
* * **Numeric**: the data attached with this axes are considered to be numeric and continuous.
* * **Time**: ... | JavaScript |
/**
* @class Ext.chart.axis.Category
* @extends Ext.chart.axis.Axis
*
* A type of axis that displays items in categories. This axis is generally used to
* display categorical information like names of items, month names, quarters, etc.
* but no quantitative values. For that other type of information {@link Ext.ch... | JavaScript |
/**
* @class Ext.chart.axis.Numeric
* @extends Ext.chart.axis.Axis
*
* An axis to handle numeric values. This axis is used for quantitative data as
* opposed to the category axis. You can set minimum and maximum values to the
* axis so that the values are bound to that. If no values are set, then the
* scale wil... | JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.