Checks whether or not the specified object exists in the array.The object to check forRemoves the specified object from the array. If the object is not found nothing happens.The object to removeThe date parsing and format syntax is 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.
Following is the list of all currently supported formats:
<pre>Sample date:
'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'
Format Output Description
------ ---------- --------------------------------------------------------------
d 10 Day of the month, 2 digits with leading zeros
D Wed A textual representation of a day, three letters
j 10 Day of the month without leading zeros
l Wednesday A full textual representation of the day of the week
S th English ordinal day of month suffix, 2 chars (use with j)
w 3 Numeric representation of the day of the week
z 9 The julian date, or day of the year (0-365)
W 01 ISO-8601 2-digit week number of year, weeks starting on Monday (00-52)
F January A full textual representation of the month
m 01 Numeric representation of a month, with leading zeros
M Jan Month name abbreviation, three letters
n 1 Numeric representation of a month, without leading zeros
t 31 Number of days in the given month
L 0 Whether it's a leap year (1 if it is a leap year, else 0)
Y 2007 A full numeric representation of a year, 4 digits
y 07 A two digit representation of a year
a pm Lowercase Ante meridiem and Post meridiem
A PM Uppercase Ante meridiem and Post meridiem
g 3 12-hour format of an hour without leading zeros
G 15 24-hour format of an hour without leading zeros
h 03 12-hour format of an hour with leading zeros
H 15 24-hour format of an hour with leading zeros
i 05 Minutes with leading zeros
s 01 Seconds, with leading zeros
O -0600 Difference to Greenwich time (GMT) in hours
T CST Timezone setting of the machine running the code
Z -21600 Timezone offset in seconds (negative if west of UTC, positive if east)</pre>
Example usage (note that you must escape format specifiers with '\\' to render them as character literals):
<pre><code>var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
document.write(dt.format('Y-m-d')); //2007-01-10
document.write(dt.format('F j, Y, g:i a')); //January 10, 2007, 3:05 pm
document.write(dt.format('l, \\t\\he dS of F Y h:i:s A')); //Wednesday, the 10th of January 2007 03:05:01 PM</code></pre>
Here are some standard date/time patterns that you might find helpful. They
are not part of the source of Date.js, but to use them you can simply copy this
block of code into any script that is included after Date.js and they will also become
globally available on the Date object. Feel free to add or remove patterns as needed in your code.
<pre><code>Date.patterns = {
ISO8601Long:"Y-m-d H:i:s",
ISO8601Short:"Y-m-d",
ShortDate: "n/j/Y",
LongDate: "l, F d, Y",
FullDateTime: "l, F d, Y g:i:s A",
MonthDay: "F d",
ShortTime: "g:i A",
LongTime: "g:i:s A",
SortableDateTime: "Y-m-d\\TH:i:s",
UniversalSortableDateTime: "Y-m-d H:i:sO",
YearMonth: "F, Y"
};</code></pre>
Example usage:
<pre><code>var dt = new Date();
document.write(dt.format(Date.patterns.ShortDate));</code></pre><static> An array of textual month names.
Override these values for international dates, for example...
Date.monthNames = ['JanInYourLang', 'FebInYourLang', ...];<static> An array of textual day names.
Override these values for international dates, for example...
Date.dayNames = ['SundayInYourLang', 'MondayInYourLang', ...];<static> Date interval constant<static> Date interval constant<static> Date interval constant<static> Date interval constant<static> Date interval constant<static> Date interval constant<static> Date interval constantFormats a date given the supplied format stringThe format string<static> Parses the passed string using the specified format. Note that this function expects dates in normal calendar
format, meaning that months are 1-based (1 = January) and not zero-based like in JavaScript dates. Any part of
the date format that is not specified will default to the current date value for that part. Time parts can also
be specified, but default to 0. Keep in mind that the input date string must precisely match the specified format
string or the parse operation will fail.
Example Usage:
<pre><code>//dt = Fri May 25 2007 (current date)
var dt = new Date();
//dt = Thu May 25 2006 (today's month/day in 2006)
dt = Date.parseDate("2006", "Y");
//dt = Sun Jan 15 2006 (all date parts specified)
dt = Date.parseDate("2006-01-15", "Y-m-d");
//dt = Sun Jan 15 2006 15:20:01 GMT-0600 (CST)
dt = Date.parseDate("2006-01-15 3:20:01 PM", "Y-m-d h:i:s A" );</code></pre>The unparsed date as a stringThe format the date is inGet the timezone abbreviation of the current date (equivalent to the format specifier 'T').Get the offset from GMT of the current date (equivalent to the format specifier 'O').Get the numeric day number of the year, adjusted for leap year.Get the string representation of the numeric week number of the year
(equivalent to the format specifier 'W').Whether or not the current date is in a leap year.Get the first day of the current month, adjusted for leap year. The returned value
is the numeric day index within the week (0-6) which can be used in conjunction with
the <a ext:cls="Date" ext:member="monthNames" href="output/Date.html#monthNames">monthNames</a> array to retrieve the textual day name.
Example:
<pre><code>var dt = new Date('1/10/2007');
document.write(Date.dayNames[dt.getFirstDayOfMonth()]); //output: 'Monday'</code></pre>Get the last day of the current month, adjusted for leap year. The returned value
is the numeric day index within the week (0-6) which can be used in conjunction with
the <a ext:cls="Date" ext:member="monthNames" href="output/Date.html#monthNames">monthNames</a> array to retrieve the textual day name.
Example:
<pre><code>var dt = new Date('1/10/2007');
document.write(Date.dayNames[dt.getLastDayOfMonth()]); //output: 'Wednesday'</code></pre>Get the first date of this date's monthGet the last date of this date's monthGet the number of days in the current month, adjusted for leap year.Get the English ordinal suffix of the current day (equivalent to the format specifier 'S').Creates and returns a new Date instance with the exact same date value as the called instance.
Dates are copied and passed by reference, so if a copied date variable is modified later, the original
variable will also be changed. When the intention is to create a new variable that will not
modify the original instance, you should create a clone.
Example of correctly cloning a date:
<pre><code>//wrong way:
var orig = new Date('10/1/2006');
var copy = orig;
copy.setDate(5);
document.write(orig); //returns 'Thu Oct 05 2006'!
//correct way:
var orig = new Date('10/1/2006');
var copy = orig.clone();
copy.setDate(5);
document.write(orig); //returns 'Thu Oct 01 2006'</code></pre>Clears any time information from this datetrue to create a clone of this date, clear the time and return itProvides a convenient method of performing basic date arithmetic. This method
does not modify the Date instance being called - it creates and returns
a new Date instance containing the resulting date value.
Examples:
<pre><code>//Basic usage:
var dt = new Date('10/29/2006').add(Date.DAY, 5);
document.write(dt); //returns 'Fri Oct 06 2006 00:00:00'
//Negative values will subtract correctly:
var dt2 = new Date('10/1/2006').add(Date.DAY, -5);
document.write(dt2); //returns 'Tue Sep 26 2006 00:00:00'
//You can even chain several calls together in one line!
var dt3 = new Date('10/1/2006').add(Date.DAY, 5).add(Date.HOUR, 8).add(Date.MINUTE, -30);
document.write(dt3); //returns 'Fri Oct 06 2006 07:30:00'</code></pre>A valid date interval enum valueThe amount to add to the current dateReturns the number of milliseconds between this date and date(optional) Defaults to nowExt core utilities and functions.<br><br><i>This class is a singleton and cannot be created directly.</i>True if the browser is in strict modeTrue if the page is running over SSLTrue when the document is fully initialized and ready for actionTrue to automatically uncache orphaned Ext.Elements periodically (defaults to true)True to automatically purge event listeners after uncaching an element (defaults to false).
Note: this only happens if enableGarbageCollector is true.URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent
the IE insecure content warning (defaults to javascript:false).URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images. (Defaults to
"http://extjs.com/s.gif" and you should change this to a URL on your server).A reusable empty functionBy default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,
you may want to set this to true.Copies all the properties of config to obj if they don't already exist.The receiver of the propertiesThe source of the propertiesApplies event listeners to elements by selectors when the document is ready.
The event name is specified with an @ suffix.
<pre><code>Ext.addBehaviors({
// add a listener for click on all anchors in element with id foo
'#foo a@click' : function(e, t){
// do something
},
// add the same listener to multiple selectors (separated by comma BEFORE the @)
'#foo a, #bar span.some-class@mouseover' : function(){
// do something
}
});</code></pre>The list of behaviors to applyGenerates unique ids. If the element already has an id, it is unchanged(optional) The element to generate an id for(optional) Id prefix (defaults "ext-gen")Extends one class with another class and optionally overrides members with the passed literal. This class
also adds the function "override()" to the class that can be used to override
members on an instance.The class inheriting the functionalityThe class being extended(optional) A literal with membersAdds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
Usage:<pre><code>Ext.override(MyClass, {
newMethod1: function(){
// etc.
},
newMethod2: function(foo){
// etc.
}
});</code></pre>The class to overrideThe list of functions to add to origClass. This should be specified as an object literal
containing one or more methods.Creates namespaces to be used for scoping variables and classes so that they are not global. Usage:
<pre><code>Ext.namespace('Company', 'Company.data');
Company.Widget = function() { ... }
Company.data.CustomStore = function(config) { ... }</code></pre>Takes an object and converts it to an encoded URL. e.g. Ext.urlEncode({foo: 1, bar: 2}); would return "foo=1&bar=2". Optionally, property values can be arrays, instead of keys and the resulting string that's returned will contain a name/value pair for each array value.Takes an encoded URL and and converts it to an object. e.g. Ext.urlDecode("foo=1&bar=2"); would return {foo: 1, bar: 2} or Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", true); would return {foo: 1, bar: [2, 3, 4]}.(optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).Iterates an array calling the passed function with each item, stopping if your function returns false. If the
passed array is not really an array, your function is called once with it.
The supplied function is called with (Object item, Number index, Array allItems).Escapes the passed string for use in a regular expressionReturn the dom node for the passed string (id), dom node, or Ext.ElementReturns the current HTML document object as an <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a>.Returns the current document body as an <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a>.Shorthand for <a ext:cls="Ext.ComponentMgr" ext:member="get" href="output/Ext.ComponentMgr.html#get">Ext.ComponentMgr.get</a>Utility method for validating that a value is numeric, returning the specified default value if it is not.Should be a number, but any type will be handled appropriatelyThe value to return if the original value is non-numericAttempts to destroy any objects passed to it by removing all event listeners, removing them from the
DOM (if applicable) and calling their destroy functions (if available). This method is primarily
intended for arguments of type <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a> and <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a>, but any subclass of
<a ext:cls="Ext.util.Observable" href="output/Ext.util.Observable.html">Ext.util.Observable</a> can be passed in. Any number of elements and/or components can be
passed into this function in a single call as separate arguments.An <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a> or <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a> to destroyarg2etc...Returns the type of object that is passed in. If the object passed in is null or undefined it
return false otherwise it returns one of the following values:<ul>
<li><b>string</b>: If the object passed is a string</li>
<li><b>number</b>: If the object passed is a number</li>
<li><b>boolean</b>: If the object passed is a boolean value</li>
<li><b>function</b>: If the object passed is a function reference</li>
<li><b>object</b>: If the object passed is an object</li>
<li><b>array</b>: If the object passed is an array</li>
<li><b>regexp</b>: If the object passed is a regular expression</li>
<li><b>element</b>: If the object passed is a DOM Element</li>
<li><b>nodelist</b>: If the object passed is a DOM NodeList</li>
<li><b>textnode</b>: If the object passed is a DOM text node and contains something other than whitespace</li>
<li><b>whitespace</b>: If the object passed is a DOM text node and contains only whitespace</li>Returns true if the passed value is null, undefined or an empty string (optional).The value to test(optional) Pass true if an empty string is not considered emptySelects elements based on the passed CSS selector to enable working on them as 1.The CSS selector or an array of elements(optional) true to create a unique Ext.Element for each element (defaults to a shared flyweight object)(optional) The root element of the query or id of the rootSelects an array of DOM nodes by CSS/XPath selector. Shorthand of <a ext:cls="Ext.DomQuery" ext:member="select" href="output/Ext.DomQuery.html#select">Ext.DomQuery.select</a>The selector/xpath query(optional) The start of the query (defaults to document).Static method to retrieve Element objects. Uses simple caching to consistently return the same object.
Automatically fixes if an object was recreated with the same id via AJAX or DOM.
Shorthand of <a ext:cls="Ext.Element" ext:member="get" href="output/Ext.Element.html#get">Ext.Element.get</a>The id of the node, a DOM Node or an existing Element.<static> Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
the dom node can be overwritten by other code.
Shorthand of <a ext:cls="Ext.Element" ext:member="fly" href="output/Ext.Element.html#fly">Ext.Element.fly</a>The dom node or id(optional) Allows for creation of named reusable flyweights to
prevent conflicts (e.g. internally Ext uses "_internal")Fires when the document is ready (before onload and before images are loaded). Shorthand of <a ext:cls="Ext.EventManager" ext:member="onDocumentReady" href="output/Ext.EventManager.html#onDocumentReady">Ext.EventManager.onDocumentReady</a>.The method the event invokesAn object that becomes the scope of the handlerIf true, the obj passed in becomes
the execution scope of the listener
Copies all the properties of config to obj.The receiver of the propertiesThe source of the propertiesA different object that will also be applied for default valuesShorthand for <a ext:cls="Ext.util.JSON" ext:member="encode" href="output/Ext.util.JSON.html#encode">Ext.util.JSON.encode</a>Shorthand for <a ext:cls="Ext.util.JSON" ext:member="decode" href="output/Ext.util.JSON.html#decode">Ext.util.JSON.decode</a><p>An Action is a piece of reusable functionality that can be abstracted out of any particular component so that it
can be usefully shared among multiple components. Actions let you share handlers, configuration options and UI
updates across any components that support the Action interface (primarily <a ext:cls="Ext.Toolbar" href="output/Ext.Toolbar.html">Ext.Toolbar</a>, <a ext:cls="Ext.Button" href="output/Ext.Button.html">Ext.Button</a>
and <a ext:cls="Ext.menu.Menu" href="output/Ext.menu.Menu.html">Ext.menu.Menu</a> components).</p>
<p>Aside from supporting the config object interface, any component that needs to use Actions must also support
the following method list, as these will be called as needed by the Action class: setText(string), setIconCls(string),
setDisabled(boolean), setVisible(boolean) and setHandler(function).</p>
Example usage:<br>
<pre><code>// Define the shared action. Each component below will have the same
// display text and icon, and will display the same message on click.
var action = new Ext.Action({
text: 'Do something',
handler: function(){
Ext.Msg.alert('Click', 'You did something.');
},
iconCls: 'do-something'
});
var panel = new Ext.Panel({
title: 'Actions',
width:500,
height:300,
tbar: [
// Add the action directly to a toolbar as a menu button
action, {
text: 'Action Menu',
// Add the action to a menu as a text item
menu: [action]
}
],
items: [
// Add the action to the panel body as a standard button
new Ext.Button(action)
],
renderTo: Ext.getBody()
});
// Change the text for all components using the action
action.setText('Something else');</code></pre>The configuration optionsReturns true if the components using this action are currently disabled, else returns false. Read-only.Returns true if the components using this action are currently hidden, else returns false. Read-only.Sets the text to be displayed by all components using this action.The text to displayGets the text currently displayed by all components using this action.Sets the icon CSS class for all components using this action. The class should supply
a background image that will be used as the icon image.The CSS class supplying the icon imageGets the icon CSS class currently used by all components using this action.Sets the disabled state of all components using this action. Shortcut method
for <a ext:cls="Ext.Action" ext:member="enable" href="output/Ext.Action.html#enable">enable</a> and <a ext:cls="Ext.Action" ext:member="disable" href="output/Ext.Action.html#disable">disable</a>.True to disable the component, false to enable itEnables all components using this action.Disables all components using this action.Sets the hidden state of all components using this action. Shortcut method
for <a ext:cls="Ext.Action" ext:member="hide" href="output/Ext.Action.html#hide">hide</a> and <a ext:cls="Ext.Action" ext:member="show" href="output/Ext.Action.html#show">show</a>.True to hide the component, false to show itShows all components using this action.Hides all components using this action.Sets the function that will be called by each component using this action when its primary event is triggered.The function that will be invoked by the action's components. The function
will be called with no arguments.The scope in which the function will executeExecutes the specified function once for each component currently tied to this action. The function passed
in should accept a single argument that will be an object that supports the basic Action config/method interface.The function to execute for each componentThe scope in which the function will executeGlobal Ajax request class. Provides a simple way to make Ajax requests with maximum flexibility. Example usage:
<pre><code>// Basic request
Ext.Ajax.request({
url: 'foo.php',
success: someFn,
failure: otherFn,
headers: {
'my-header': 'foo'
},
params: { foo: 'bar' }
});
// Simple ajax form submission
Ext.Ajax.request({
form: 'some-form',
params: 'foo=bar'
});
// Default headers to pass in every request
Ext.Ajax.defaultHeaders = {
'Powered-By': 'Ext'
};
// Global Ajax events can be handled on every request!
Ext.Ajax.on('beforerequest', this.showSpinner, this);</code></pre><br><br><i>This class is a singleton and cannot be created directly.</i>
True to add a unique cache-buster param to GET requests. (defaults to true)
The default URL to be used for requests to the server. (defaults to undefined)
An object containing properties which are used as
extra parameters to each request made by this object. (defaults to undefined)
An object containing request headers which are added to each request made by this object. (defaults to undefined)
The default HTTP method to be used for requests. (defaults to undefined; if not set but parms are present will use POST, otherwise GET)
The timeout in milliseconds to be used for requests. (defaults to 30000)
Whether a new request should abort any pending requests. (defaults to false)Serialize the passed form into a url encoded stringBase class for any visual <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a> that uses a box container. BoxComponent provides automatic box
model adjustments for sizing and positioning and will work correctly withnin the Component rendering model. All
container classes should subclass BoxComponent so that they will work consistently when nested within other Ext
layout containers.The configuration options.Sets the width and height of the component. This method fires the resize event. This method can accept
either width and height as separate numeric arguments, or you can pass a size object like {width:10, height:20}.The new width to set, or a size object in the format {width, height}The new height to set (not required if a size object is passed as the first arg)Sets the width of the component. This method fires the resize event.The new width to setSets the height of the component. This method fires the resize event.The new height to setGets the current size of the component's underlying element.Gets the current XY position of the component's underlying element.(optional) If true the element's left and top are returned instead of page XY (defaults to false)Gets the current box measurements of the component's underlying element.(optional) If true the element's left and top are returned instead of page XY (defaults to false)Sets the current box measurements of the component's underlying element.An object in the format {x, y, width, height}Sets the left and top of the component. To set the page XY position instead, use <a ext:cls="Ext.BoxComponent" ext:member="setPagePosition" href="output/Ext.BoxComponent.html#setPagePosition">setPagePosition</a>.
This method fires the move event.The new leftThe new topSets the page XY position of the component. To set the left and top instead, use <a ext:cls="Ext.BoxComponent" ext:member="setPosition" href="output/Ext.BoxComponent.html#setPosition">setPosition</a>.
This method fires the move event.The new x positionThe new y positionForce the component's size to recalculate based on the underlying element's current height and width.Simple Button classCreate a new buttonThe config objectRead-only. True if this button is hiddenRead-only. True if this button is disabledRead-only. True if this button is pressed (only if enableToggle = true)Assigns this button's click handlerThe function to call when the button is clicked(optional) Scope for the function passed inSets this button's textThe button textGets the text for this buttonIf a state it passed, it becomes the pressed state otherwise the current state is toggled.(optional) Force a particular stateFocus the buttonShow this button's menu (if it has one)Hide this button's menu (if it has one)Returns true if the button has a menu and it is visibleSimple color palette class for choosing colors. The palette can be rendered to any container.<br />
Here's an example of typical usage:
<pre><code>var cp = new Ext.ColorPalette({value:'993300'}); // initial selected color
cp.render('my-div');
cp.on('select', function(palette, selColor){
// do something with selColor
});</code></pre>Create a new ColorPaletteThe config object<p>An array of 6-digit color hex code strings (without the # symbol). This array can contain any number
of colors, and each hex code should be unique. The width of the palette is controlled via CSS by adjusting
the width property of the 'x-color-palette' class (or assigning a custom class), so you can balance the number
of colors with the width setting until the box is symmetrical.</p>
<p>You can override individual colors if needed:</p>
<pre><code>var cp = new Ext.ColorPalette();
cp.colors[0] = "FF0000"; // change the first box to red</code></pre>
Or you can provide a custom array of your own for complete control:
<pre><code>var cp = new Ext.ColorPalette();
cp.colors = ["000000", "993300", "333300"];</code></pre>Selects the specified color in the palette (fires the select event)A valid 6-digit color hex code (# will be stripped if included)<p>Base class for all Ext components. All subclasses of Component can automatically participate in the standard
Ext component lifecycle of creation, rendering and destruction. They also have automatic support for basic hide/show
and enable/disable behavior. Component allows any subclass to be lazy-rendered into any <a ext:cls="Ext.Container" href="output/Ext.Container.html">Ext.Container</a> and
to be automatically registered with the <a ext:cls="Ext.ComponentMgr" href="output/Ext.ComponentMgr.html">Ext.ComponentMgr</a> so that it can be referenced at any time via
<a ext:cls="Ext" ext:member="getCmp" href="output/Ext.html#getCmp">Ext.getCmp</a>. All visual widgets that require rendering into a layout should subclass Component (or
<a ext:cls="Ext.BoxComponent" href="output/Ext.BoxComponent.html">Ext.BoxComponent</a> if managed box model handling is required).</p>
<p>Every component has a specific xtype, which is its Ext-specific type name, along with methods for checking the
xtype like <a ext:cls="Ext.Component" ext:member="getXType" href="output/Ext.Component.html#getXType">getXType</a> and <a ext:cls="Ext.Component" ext:member="isXType" href="output/Ext.Component.html#isXType">isXType</a>. This is the list of all valid xtypes:</p>
<pre>xtype Class
------------- ------------------
box Ext.BoxComponent
button Ext.Button
colorpalette Ext.ColorPalette
component Ext.Component
container Ext.Container
cycle Ext.CycleButton
dataview Ext.DataView
datepicker Ext.DatePicker
editor Ext.Editor
editorgrid Ext.grid.EditorGridPanel
grid Ext.grid.GridPanel
paging Ext.PagingToolbar
panel Ext.Panel
progress Ext.ProgressBar
splitbutton Ext.SplitButton
tabpanel Ext.TabPanel
treepanel Ext.tree.TreePanel
viewport Ext.ViewPort
window Ext.Window
Toolbar components
---------------------------------------
toolbar Ext.Toolbar
tbitem Ext.Toolbar.Item
tbseparator Ext.Toolbar.Separator
tbspacer Ext.Toolbar.Spacer
tbfill Ext.Toolbar.Fill
tbtext Ext.Toolbar.TextItem
tbbutton Ext.Toolbar.Button
tbsplit Ext.Toolbar.SplitButton
Form components
---------------------------------------
checkbox Ext.form.Checkbox
combo Ext.form.ComboBox
datefield Ext.form.DateField
field Ext.form.Field
fieldset Ext.form.FieldSet
form Ext.FormPanel
hidden Ext.form.Hidden
htmleditor Ext.form.HtmlEditor
numberfield Ext.form.NumberField
radio Ext.form.Radio
textarea Ext.form.TextArea
textfield Ext.form.TextField
timefield Ext.form.TimeField
trigger Ext.form.TriggerField</pre>The configuration options. If an element is passed, it is set as the internal
element and its id used as the component id. If a string is passed, it is assumed to be the id of an existing element
and is used as the component id. Otherwise, it is assumed to be a standard config object and is applied to the component.The component's owner <a ext:cls="Ext.Container" href="output/Ext.Container.html">Ext.Container</a> (defaults to undefined, and is set automatically when
the component is added to a container). Read-only.
True if this component is hidden. Read-only.True if this component is disabled. Read-only.True if this component has been rendered. Read-only.If this is a lazy rendering component, render it to its container element.(optional) The element this component should be rendered into. If it is being
applied to existing markup, this should be left off.(optional) The element ID or DOM node index within the container <b>before</b>
which this component will be inserted (defaults to appending to the end of the container)Apply this component to existing markup that is valid. With this function, no call to render() is required.Adds a CSS class to the component's underlying element.The CSS class name to addRemoves a CSS class from the component's underlying element.The CSS class name to removeDestroys this component by purging any event listeners, removing the component's element from the DOM,
removing the component from its <a ext:cls="Ext.Container" href="output/Ext.Container.html">Ext.Container</a> (if applicable) and unregistering it from
<a ext:cls="Ext.ComponentMgr" href="output/Ext.ComponentMgr.html">Ext.ComponentMgr</a>. Destruction is generally handled automatically by the framework and this method
should usually not need to be called directly.Returns the underlying <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a>.Returns the id of this component.Try to focus this component.(optional) If applicable, true to also select the text in this componentDisable this component.Enable this component.Convenience function for setting disabled/enabled by boolean.Show this component.Hide this component.Convenience function to hide or show this component by boolean.True to show, false to hideReturns true if this component is visible.Clone the current component using the original config values passed into this instance by default.A new config containing any properties to override in the cloned version.
An id property can be passed on this object, otherwise one will be generated to avoid duplicates.Gets the xtype for this component as registered with <a ext:cls="Ext.ComponentMgr" href="output/Ext.ComponentMgr.html">Ext.ComponentMgr</a>. For a list of all
available xtypes, see the <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a> header. Example usage:
<pre><code>var t = new Ext.form.TextField();
alert(t.getXType()); // alerts 'textfield'</code></pre>Tests whether or not this component is of a specific xtype. This can test whether this component is descended
from the xtype (default) or whether it is directly of the xtype specified (shallow = true). For a list of all
available xtypes, see the <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a> header. Example usage:
<pre><code>var t = new Ext.form.TextField();
var isText = t.isXType('textfield'); // true
var isBoxSubclass = t.isXType('box'); // true, descended from BoxComponent
var isBoxInstance = t.isXType('box', true); // false, not a direct BoxComponent instance</code></pre>The xtype to check for this component(optional) False to check whether this component is descended from the xtype (this is
the default), or true to check whether this component is directly of the specified xtype.Returns this component's xtype hierarchy as a slash-delimited string. For a list of all
available xtypes, see the <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a> header. Example usage:
<pre><code>
var t = new Ext.form.TextField();
alert(t.getXTypes()); // alerts 'component/box/field/textfield'</pre></code><p>Provides a common registry of all components (specifically subclasses of <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a>) on a page so
that they can be easily accessed by component id (see <a ext:cls="Ext.getCmp" href="output/Ext.getCmp.html">Ext.getCmp</a>).</p>
<p>Every component class also gets registered in ComponentMgr by its 'xtype' property, which is its Ext-specific
type name (e.g., Ext.form.TextField's xtype is 'textfield'). This allows you to check the xtype of specific
object instances (see <a ext:cls="Ext.Component" ext:member="getXType" href="output/Ext.Component.html#getXType">Ext.Component.getXType</a> and <a ext:cls="Ext.Component" ext:member="isXType" href="output/Ext.Component.html#isXType">Ext.Component.isXType</a>). For a list of all
available xtypes, see <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a>.</p><br><br><i>This class is a singleton and cannot be created directly.</i>The MixedCollection used internally for the component cache. An example usage may be subscribing to
events on the MixedCollection to monitor addition or removal. Read-only.Registers a component.The componentUnregisters a component.The componentReturns a component by idThe component idRegisters a function that will be called when a specified component is added to ComponentMgrThe component idThe callback functionThe scope of the callbackStandard composite class. Creates a Ext.Element for every element in the collection.
<br><br>
<b>NOTE: Although they are not listed, this class supports all of the set/update methods of Ext.Element. All Ext.Element
actions will be performed on all the elements in this collection.</b>
<br><br>
All methods return <i>this</i> and can be chained.
<pre><code>var els = Ext.select("#some-el div.some-class", true);
// or select directly from an existing element
var el = Ext.get('some-el');
el.select('div.some-class', true);
els.setWidth(100); // all elements become 100 width
els.hide(true); // all elements fade out and hide
// or
els.setWidth(100).hide(true);</code></pre>Clears this composite and adds the elements returned by the passed selector.A string CSS selector, an array of elements or an elementFilters this composite to only elements that match the passed selector.A string CSS selectorAdds elements to this composite.A string CSS selector, an array of elements or an elementCalls the passed function passing (el, this, index) for each element in this composite.The function to call(optional) The <i>this</i> object (defaults to the element)Returns the Element object at the specified indexReturns the first ElementReturns the last ElementReturns the number of elements in this compositeReturns true if this composite contains the passed elementReturns true if this composite contains the passed elementRemoves the specified element(s).The id of an element, the Element itself, the index of the element in this composite
or an array of any of those.(optional) True to also remove the element from the documentReplaces the specified element with the passed element.The id of an element, the Element itself, the index of the element in this composite
to replace.The id of an element or the Element itself.(Optional) True to remove and replace the element in the document too.Removes all elements.Flyweight composite class. Reuses the same Ext.Element for element operations.
<pre><code>var els = Ext.select("#some-el div.some-class");
// or select directly from an existing element
var el = Ext.get('some-el');
el.select('div.some-class');
els.setWidth(100); // all elements become 100 width
els.hide(true); // all elements fade out and hide
// or
els.setWidth(100).hide(true);</code></pre><br><br>
<b>NOTE: Although they are not listed, this class supports all of the set/update methods of Ext.Element. All Ext.Element
actions will be performed on all the elements in this collection.</b>Returns a flyweight Element of the dom element object at the specified indexCalls the passed function passing (el, this, index) for each element in this composite. <b>The element
passed is the flyweight (shared) Ext.Element instance, so if you require a
a reference to the dom node, use el.dom.</b>The function to call(optional) The <i>this</i> object (defaults to the element)Base class for any <a ext:cls="Ext.BoxComponent" href="output/Ext.BoxComponent.html">Ext.BoxComponent</a> that can contain other components. Containers handle the basic
behavior of containing items, namely adding, inserting and removing them. The specific layout logic required
to visually render contained items is delegated to any one of the different <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">layout</a> classes available.
This class is intended to be extended and should generally not need to be created directly via the new keyword.The collection of components in this container as a <a ext:cls="Ext.util.MixedCollection" href="output/Ext.util.MixedCollection.html">Ext.util.MixedCollection</a>Adds a component to this container. Fires the beforeadd event before adding, then fires the add event
after the component has been added.The component to addInserts a component into this container at a specified index. Fires the beforeadd event before inserting,
then fires the add event after the component has been inserted.The index at which the component will be inserted into the container's items collectionThe component to addRemoves a component from this container. Fires the beforeremove event before removing, then fires
the remove event after the component has been removed.The component reference or id to remove(optional) True to automatically invoke the component's <a ext:cls="Ext.Component" ext:member="destroy" href="output/Ext.Component.html#destroy">Ext.Component.destroy</a> functionGets a direct child component by idForce this container's layout to be recalculated. Generally this is handled automatically by the container,
and should be used with care as it can be intensive with complex layouts since all nested containers'
doLayout methods are also called recursively.Returns the layout currently in use by the container. If the container does not currently have a layout
set, a default <a ext:cls="Ext.layout.ContainerLayout" href="output/Ext.layout.ContainerLayout.html">Ext.layout.ContainerLayout</a> will be created and set as the container's layout.Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (<i>this</i>) of
function call will be the scope provided or the current component. The arguments to the function
will be the args provided or the current component. If the function returns false at any point,
the bubble is stopped.The function to call(optional) The scope of the function (defaults to current node)(optional) The args to call the function with (default to passing the current component)Cascades down the component/container heirarchy from this component (called first), calling the specified function with
each component. The scope (<i>this</i>) of
function call will be the scope provided or the current component. The arguments to the function
will be the args provided or the current component. If the function returns false at any point,
the cascade is stopped on that branch.The function to call(optional) The scope of the function (defaults to current component)(optional) The args to call the function with (defaults to passing the current component)Find a component under this container at any level by idFind a component under this container at any level by xtype or classThe xtype string for a component, or the class of the component directlyFind a component under this container at any level by propertyFind a component under this container at any level by a custom function. If the passed function returns
true, the component will be included in the results. The passed function is called with the arguments (component, this container).A specialized SplitButton that contains a menu of <a ext:cls="Ext.menu.CheckItem" href="output/Ext.menu.CheckItem.html">Ext.menu.CheckItem</a> elements. The button automatically
cycles through each menu item on click, raising the button's <a ext:cls="Ext.CycleButton" ext:member="change" href="output/Ext.CycleButton.html#change">change</a> event (or calling the button's
<a ext:cls="Ext.CycleButton" ext:member="changeHandler" href="output/Ext.CycleButton.html#changeHandler">changeHandler</a> function, if supplied) for the active menu item. Clicking on the arrow section of the
button displays the dropdown menu just like a normal SplitButton. Example usage:
<pre><code>var btn = new Ext.CycleButton({
showText: true,
prependText: 'View as ',
items: [{
text:'text only',
iconCls:'view-text',
checked:true
},{
text:'HTML',
iconCls:'view-html'
}],
changeHandler:function(btn, item){
Ext.Msg.alert('Change View', item.text);
}
});</code></pre>Create a new split buttonThe config objectSets the button's active menu item.The item to activateTrue to prevent the button's change event from firing (defaults to false)Gets the currently active menu item.This is normally called internally on button click, but can be called externally to advance the button's
active item programmatically to the next one in the menu. If the current item is the last one in the menu
the active item will be set to the first item in the menu.A mechanism for displaying data using custom layout templates and formatting. A DataView is bound to an <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>
so that as the data in the store changes the view is automatically updated to reflect the changes. The view also
provides built-in behavior for many common events that can occur for its contained items including click, doubleclick,
mouseover, mouseout, etc. as well as a built-in selection model. <b>In order to use these features, an itemSelector config must be provided
for the DataView to determine what nodes it will be working with. </b>
<p>The example below binds a DataView to a <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> and renders it into an <a ext:cls="Ext.Panel" href="output/Ext.Panel.html">Ext.Panel</a>.</p>
<pre><code>var store = new Ext.data.JsonStore({
url: 'get-images.php',
root: 'images',
fields: [
'name', 'url',
{name:'size', type: 'float'},
{name:'lastmod', type:'date', dateFormat:'timestamp'}
]
});
store.load();
var tpl = new Ext.XTemplate(
'<tpl for=".">',
'<div class="thumb-wrap" id="{name}">',
'<div class="thumb"><img src="{url}" title="{name}"></div>',
'<span class="x-editable">{shortName}</span></div>',
'</tpl>',
'<div class="x-clear"></div>'
);
var panel = new Ext.Panel({
id:'images-view',
frame:true,
width:535,
autoHeight:true,
collapsible:true,
layout:'fit',
title:'Simple DataView',
items: new Ext.DataView({
store: store,
tpl: tpl,
autoHeight:true,
multiSelect: true,
overClass:'x-view-over',
itemSelector:'div.thumb-wrap',
emptyText: 'No images to display'
})
});
panel.render(document.body);</code></pre>Create a new DataViewThe config objectRefreshes the view by reloading the data from the store and re-rendering the template.Function that can be overridden to provide custom formatting for the data that is sent to the template for each node.The raw data (array of colData for a data model bound view or
a JSON object for an Updater bound view).Refreshes an individual node's data from the store.The item's data index in the storeChanges the data store bound to this view and refreshes it.The store to bind to this viewReturns the template node the passed child belongs to, or null if it doesn't belong to one.Gets the number of selected nodes.Gets the currently selected nodes.Gets the indexes of the selected nodes.Gets an array of the selected recordsGets an array of the records from an array of nodesThe nodes to evaluateGets a record from a nodeThe node to evaluateClears all selections.(optional) True to skip firing of the selectionchange eventReturns true if the passed node is selected, else false.The node or node index to checkDeselects a node.The node to deselectSelects a set of nodes.An HTMLElement template node, index of a template node,
id of a template node or an array of any of those to select(optional) true to keep existing selections(optional) true to skip firing of the selectionchange ventSelects a range of nodes. All nodes between start and end are selected.The index of the first node in the rangeThe index of the last node in the range(optional) True to retain existing selectionsGets a template node.An HTMLElement template node, index of a template node or the id of a template nodeGets a range nodes.The index of the first node in the rangeThe index of the last node in the rangeFinds the index of the passed node.An HTMLElement template node, index of a template node or the id of a template nodeSimple date picker class.Create a new DatePickerThe config objectSets the value of the date fieldThe date to setGets the current selected value of the date fieldUtility class for working with DOM and/or Templates. It transparently supports using HTML fragments or DOM.<br>
This is an example, where an unordered list with 5 children items is appended to an existing element with id 'my-div':<br>
<pre><code>var list = dh.append('my-div', {
tag: 'ul', cls: 'my-list', children: [
{tag: 'li', id: 'item0', html: 'List Item 0'},
{tag: 'li', id: 'item1', html: 'List Item 1'},
{tag: 'li', id: 'item2', html: 'List Item 2'},
{tag: 'li', id: 'item3', html: 'List Item 3'},
{tag: 'li', id: 'item4', html: 'List Item 4'}
]
});</code></pre>
For more information and examples, see <a href="http://www.jackslocum.com/blog/2006/10/06/domhelper-create-elements-using-dom-html-fragments-or-templates/">the original blog post</a>.<br><br><i>This class is a singleton and cannot be created directly.</i>True to force the use of DOM instead of html fragmentsReturns the markup for the passed Element(s) config.The DOM object spec (and children)Applies a style specification to an element.The element to apply styles toA style specification string eg "width:100px", or object in the form {width:"100px"}, or
a function which returns such a specification.Inserts an HTML fragment into the DOM.Where to insert the html in relation to el - beforeBegin, afterBegin, beforeEnd, afterEnd.The context elementThe HTML fragmenetCreates new DOM element(s) and inserts them before el.The context elementThe DOM object spec (and children) or raw HTML blob(optional) true to return a Ext.ElementCreates new DOM element(s) and inserts them after el.The context elementThe DOM object spec (and children)(optional) true to return a Ext.ElementCreates new DOM element(s) and inserts them as the first child of el.The context elementThe DOM object spec (and children) or raw HTML blob(optional) true to return a Ext.ElementCreates new DOM element(s) and appends them to el.The context elementThe DOM object spec (and children) or raw HTML blob(optional) true to return a Ext.ElementCreates new DOM element(s) and overwrites the contents of el with them.The context elementThe DOM object spec (and children) or raw HTML blob(optional) true to return a Ext.ElementCreates a new Ext.Template from the DOM object spec.The DOM object spec (and children)*
Provides high performance selector/xpath processing by compiling queries into reusable functions. New pseudo classes and matchers can be plugged. It works on HTML and XML documents (if a content node is passed in).
<p>
DomQuery supports most of the <a href="http://www.w3.org/TR/2005/WD-css3-selectors-20051215/#selectors">CSS3 selectors spec</a>, along with some custom selectors and basic XPath.</p>
<p>
All selectors, attribute filters and pseudos below can be combined infinitely in any order. For example "div.foo:nth-child(odd)[@foo=bar].bar:first" would be a perfectly valid selector. Node filters are processed in the order in which they appear, which allows you to optimize your queries for your document structure.
</p>
<h4>Element Selectors:</h4>
<ul class="list">
<li> <b>*</b> any element</li>
<li> <b>E</b> an element with the tag E</li>
<li> <b>E F</b> All descendent elements of E that have the tag F</li>
<li> <b>E > F</b> or <b>E/F</b> all direct children elements of E that have the tag F</li>
<li> <b>E + F</b> all elements with the tag F that are immediately preceded by an element with the tag E</li>
<li> <b>E ~ F</b> all elements with the tag F that are preceded by a sibling element with the tag E</li>
</ul>
<h4>Attribute Selectors:</h4>
<p>The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.</p>
<ul class="list">
<li> <b>E[foo]</b> has an attribute "foo"</li>
<li> <b>E[foo=bar]</b> has an attribute "foo" that equals "bar"</li>
<li> <b>E[foo^=bar]</b> has an attribute "foo" that starts with "bar"</li>
<li> <b>E[foo$=bar]</b> has an attribute "foo" that ends with "bar"</li>
<li> <b>E[foo*=bar]</b> has an attribute "foo" that contains the substring "bar"</li>
<li> <b>E[foo%=2]</b> has an attribute "foo" that is evenly divisible by 2</li>
<li> <b>E[foo!=bar]</b> has an attribute "foo" that does not equal "bar"</li>
</ul>
<h4>Pseudo Classes:</h4>
<ul class="list">
<li> <b>E:first-child</b> E is the first child of its parent</li>
<li> <b>E:last-child</b> E is the last child of its parent</li>
<li> <b>E:nth-child(<i>n</i>)</b> E is the <i>n</i>th child of its parent (1 based as per the spec)</li>
<li> <b>E:nth-child(odd)</b> E is an odd child of its parent</li>
<li> <b>E:nth-child(even)</b> E is an even child of its parent</li>
<li> <b>E:only-child</b> E is the only child of its parent</li>
<li> <b>E:checked</b> E is an element that is has a checked attribute that is true (e.g. a radio or checkbox) </li>
<li> <b>E:first</b> the first E in the resultset</li>
<li> <b>E:last</b> the last E in the resultset</li>
<li> <b>E:nth(<i>n</i>)</b> the <i>n</i>th E in the resultset (1 based)</li>
<li> <b>E:odd</b> shortcut for :nth-child(odd)</li>
<li> <b>E:even</b> shortcut for :nth-child(even)</li>
<li> <b>E:contains(foo)</b> E's innerHTML contains the substring "foo"</li>
<li> <b>E:nodeValue(foo)</b> E contains a textNode with a nodeValue that equals "foo"</li>
<li> <b>E:not(S)</b> an E element that does not match simple selector S</li>
<li> <b>E:has(S)</b> an E element that has a descendent that matches simple selector S</li>
<li> <b>E:next(S)</b> an E element whose next sibling matches simple selector S</li>
<li> <b>E:prev(S)</b> an E element whose previous sibling matches simple selector S</li>
</ul>
<h4>CSS Value Selectors:</h4>
<ul class="list">
<li> <b>E{display=none}</b> css value "display" that equals "none"</li>
<li> <b>E{display^=none}</b> css value "display" that starts with "none"</li>
<li> <b>E{display$=none}</b> css value "display" that ends with "none"</li>
<li> <b>E{display*=none}</b> css value "display" that contains the substring "none"</li>
<li> <b>E{display%=2}</b> css value "display" that is evenly divisible by 2</li>
<li> <b>E{display!=none}</b> css value "display" that does not equal "none"</li>
</ul><br><br><i>This class is a singleton and cannot be created directly.</i>Collection of matching regular expressions and code snippets.Collection of operator comparison functions. The default operators are =, !=, ^=, $=, *=, %=, |= and ~=.
New operators can be added as long as the match the format <i>c</i>= where <i>c</i> is any character other than space, > <.Collection of "pseudo class" processors. Each processor is passed the current nodeset (array)
and the argument (if any) supplied in the selector.Compiles a selector/xpath query into a reusable function. The returned function
takes one parameter "root" (optional), which is the context node from where the query should start.The selector/xpath query(optional) Either "select" (the default) or "simple" for a simple selector matchSelects a group of elements.The selector/xpath query (can be a comma separated list of selectors)(optional) The start of the query (defaults to document).Selects a single element.The selector/xpath query(optional) The start of the query (defaults to document).Selects the value of a node, optionally replacing null with the defaultValue.The selector/xpath query(optional) The start of the query (defaults to document).Selects the value of a node, parsing integers and floats.The selector/xpath query(optional) The start of the query (defaults to document).Returns true if the passed element(s) match the passed simple selector (e.g. div.some-class or span:first-child)An element id, element or array of elementsThe simple selector to testFilters an array of elements to only include matches of a simple selector (e.g. div.some-class or span:first-child)An array of elements to filterThe simple selector to testIf true, it returns the elements that DON'T match
the selector instead of the ones that matchA base editor field that handles displaying/hiding on demand and has some built-in sizing and event handling logic.Create a new EditorThe Field object (or descendant)The config objectStarts the editing process and shows the editor.The element to edit(optional) A value to initialize the editor with. If a value is not provided, it defaults
to the innerHTML of el.Sets the height and width of this editor.The new widthThe new heightRealigns the editor to the bound field based on the current alignment config value.Ends the editing process, persists the changed value to the underlying field, and hides the editor.Override the default behavior and keep the editor visible after edit (defaults to false)Cancels the editing process and hides the editor without persisting any changes. The field value will be
reverted to the original starting value.Override the default behavior and keep the editor visible after
cancel (defaults to false)Sets the data value of the editorAny valid value supported by the underlying fieldGets the data value of the editorRepresents an Element in the DOM.<br><br>
Usage:<br>
<pre><code>var el = Ext.get("my-div");
// or with getEl
var el = getEl("my-div");
// or with a DOM element
var el = Ext.get(myDivElement);</code></pre>
Using Ext.get() or getEl() instead of calling the constructor directly ensures you get the same object
each call instead of constructing a new one.<br><br>
<b>Animations</b><br />
Many of the functions for manipulating an element have an optional "animate" parameter. The animate parameter
should either be a boolean (true) or an object literal with animation options. Note that the supported Element animation
options are a subset of the <a ext:cls="Ext.Fx" href="output/Ext.Fx.html">Ext.Fx</a> animation options specific to Fx effects. The Element animation options are:
<pre>Option Default Description
--------- -------- ---------------------------------------------
duration .35 The duration of the animation in seconds
easing easeOut The easing method
callback none A function to execute when the anim completes
scope this The scope (this) of the callback function</pre>
Also, the Anim object being used for the animation will be set on your options object as "anim", which allows you to stop or
manipulate the animation. Here's an example:
<pre><code>var el = Ext.get("my-div");
// no animation
el.setWidth(100);
// default animation
el.setWidth(100, true);
// animation with some options set
el.setWidth(100, {
duration: 1,
callback: this.foo,
scope: this
});
// using the "anim" property to get the Anim object
var opt = {
duration: 1,
callback: this.foo,
scope: this
};
el.setWidth(100, opt);
...
if(opt.anim.isAnimated()){
opt.anim.stop();
}</code></pre>
<b> Composite (Collections of) Elements</b><br />
For working with collections of Elements, see <a ext:cls="Ext.CompositeElement" href="output/Ext.CompositeElement.html">Ext.CompositeElement</a>Create a new Element directly.(optional) By default the constructor checks to see if there is already an instance of this element in the cache and if there is it returns the same instance. This will skip that check (useful for extending this class).The DOM elementThe DOM element IDThe element's default display mode (defaults to "")The default unit to append to CSS values where a unit isn't provided (defaults to px).<static> Visibility mode constant - Use visibility to hide element<static> Visibility mode constant - Use display to hide elementSets the element's visibility mode. When setVisible() is called it
will use this to determine whether to set the visibility or the display property.or Element.DISPLAYConvenience method for setVisibilityMode(Element.DISPLAY)(optional) What to set display to when visibleLooks 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)The simple selector to test(optional) The max depth to
search as a number or element (defaults to 10 || document.body)(optional) True to return a Ext.Element object instead of DOM nodeLooks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)The simple selector to test(optional) The max depth to
search as a number or element (defaults to 10 || document.body)(optional) True to return a Ext.Element object instead of DOM nodeWalks up the dom looking for a parent node that matches the passed simple selector (e.g. div.some-class or span:first-child).
This is a shortcut for findParentNode() that always returns an Ext.Element.The simple selector to test(optional) The max depth to
search as a number or element (defaults to 10 || document.body)Returns true if this element matches the passed simple selector (e.g. div.some-class or span:first-child)The simple selector to testPerform animation on this element.The animation control args(optional) How long the animation lasts in seconds (defaults to .35)(optional) Function to call when animation completes(optional) Easing method to use (defaults to 'easeOut')(optional) 'run' is the default. Can also be 'color', 'motion', or 'scroll'Removes worthless text nodes(optional) By default the element
keeps track if it has been cleaned already so
you can call this over and over. However, if you update the element and
need to force a reclean, you can pass true.Scrolls this element into view within the passed container.(optional) The container element to scroll (defaults to document.body)(optional) False to disable horizontal scroll (defaults to true)Measures the element's content height and updates height to match. Note: this function uses setTimeout so
the new height may not be available immediately.(optional) Animate the transition (defaults to false)(optional) Length of the animation in seconds (defaults to .35)(optional) Function to call when animation completes(optional) Easing method to use (defaults to easeOut)Returns true if this element is an ancestor of the passed elementThe element to checkChecks whether the element is currently visible using both visibility and display properties.(optional) True to walk the dom and see if parent elements are hidden (defaults to false)Creates a <a ext:cls="Ext.CompositeElement" href="output/Ext.CompositeElement.html">Ext.CompositeElement</a> for child nodes based on the passed CSS selector (the selector should not contain an id).The CSS selector(optional) True to create a unique Ext.Element for each child (defaults to false, which creates a single shared flyweight object)Selects child nodes based on the passed CSS selector (the selector should not contain an id).The CSS selectorSelects a single child at any depth below this element based on the passed CSS selector (the selector should not contain an id).The CSS selector(optional) True to return the DOM node instead of Ext.Element (defaults to false)Selects a single *direct* child based on the passed CSS selector (the selector should not contain an id).The CSS selector(optional) True to return the DOM node instead of Ext.Element (defaults to false)Initializes a <a ext:cls="Ext.dd.DD" href="output/Ext.dd.DD.html">Ext.dd.DD</a> drag drop object for this element.The group the DD object is member ofThe DD config objectAn object containing methods to override/implement on the DD objectInitializes a <a ext:cls="Ext.dd.DDProxy" href="output/Ext.dd.DDProxy.html">Ext.dd.DDProxy</a> object for this element.The group the DDProxy object is member ofThe DDProxy config objectAn object containing methods to override/implement on the DDProxy objectInitializes a <a ext:cls="Ext.dd.DDTarget" href="output/Ext.dd.DDTarget.html">Ext.dd.DDTarget</a> object for this element.The group the DDTarget object is member ofThe DDTarget config objectAn object containing methods to override/implement on the DDTarget objectSets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use
the display property to hide the element, otherwise it uses visibility. The default is to hide and show using the visibility property.Whether the element is visible(optional) True for the default animation, or a standard Element animation config objectReturns true if display is not "none"Toggles the element's visibility or display, depending on visibility mode.(optional) True for the default animation, or a standard Element animation config objectSets the CSS display property. Uses originalDisplay if the specified value is a boolean true.Boolean value to display the element using its default display, or a string to set the display directlyTries to focus the element. Any exceptions are caught and ignored.Tries to blur the element. Any exceptions are caught and ignored.Adds one or more CSS classes to the element. Duplicate classes are automatically filtered out.The CSS class to add, or an array of classesAdds one or more CSS classes to this element and removes the same class(es) from all siblings.The CSS class to add, or an array of classesRemoves one or more CSS classes from the element.The CSS class to remove, or an array of classesToggles the specified CSS class on this element (removes it if it already exists, otherwise adds it).The CSS class to toggleChecks if the specified CSS class exists on this element's DOM node.The CSS class to check forReplaces a CSS class on the element with another. If the old name does not exist, the new name will simply be added.The CSS class to replaceThe replacement CSS classReturns an object with properties matching the styles requested.
For example, el.getStyles('color', 'font-size', 'width') might return
{'color': '#FFFFFF', 'font-size': '13px', 'width': '100px'}.A style nameA style nameNormalizes currentStyle and computedStyle.The style property whose value is returned.Wrapper for setting style properties, also takes single object parameter of multiple styles.The style property to be set, or an object of multiple styles.(optional) The value to apply to the given property, or null if an object was passed.More flexible version of <a ext:cls="Ext.Element" ext:member="setStyle" href="output/Ext.Element.html#setStyle">setStyle</a> for setting style properties.A style specification string, e.g. "width:100px", or object in the form {width:"100px"}, or
a function which returns such a specification.Gets the current X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).Gets the current Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).Gets the current position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).Returns the offsets of this element from the passed element. Both element must be part of the DOM tree and not have display:none to have page coordinates.The element to get the offsets from.Sets the X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).X position of the element(optional) True for the default animation, or a standard Element animation config objectSets the Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).Y position of the element(optional) True for the default animation, or a standard Element animation config objectSets the element's left position directly using CSS style (instead of <a ext:cls="Ext.Element" ext:member="setX" href="output/Ext.Element.html#setX">setX</a>).The left CSS property valueSets the element's top position directly using CSS style (instead of <a ext:cls="Ext.Element" ext:member="setY" href="output/Ext.Element.html#setY">setY</a>).The top CSS property valueSets the element's CSS right style.The right CSS property valueSets the element's CSS bottom style.The bottom CSS property valueSets the position of the element in page coordinates, regardless of how the element is positioned.
The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).Contains X & Y [x, y] values for new position (coordinates are page-based)(optional) True for the default animation, or a standard Element animation config objectSets the position of the element in page coordinates, regardless of how the element is positioned.
The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).X value for new position (coordinates are page-based)Y value for new position (coordinates are page-based)(optional) True for the default animation, or a standard Element animation config objectSets the position of the element in page coordinates, regardless of how the element is positioned.
The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).X value for new position (coordinates are page-based)Y value for new position (coordinates are page-based)(optional) True for the default animation, or a standard Element animation config objectReturns the region of the given element.
The element must be part of the DOM tree to have a region (display:none or elements not appended return false).Returns the offset height of the element(optional) true to get the height minus borders and paddingReturns the offset width of the element(optional) true to get the width minus borders and paddingReturns either the offsetHeight or the height of this element based on CSS height adjusted by padding or borders
when needed to simulate offsetHeight when offsets aren't available. This may not work on display:none elements
if a height has not been set using CSS.Returns either the offsetWidth or the width of this element based on CSS width adjusted by padding or borders
when needed to simulate offsetWidth when offsets aren't available. This may not work on display:none elements
if a width has not been set using CSS.Returns the size of the element.(optional) true to get the width/size minus borders and paddingReturns the width and height of the viewport.Returns the value of the "value" attributetrue to parse the value as a numberSet the width of the elementThe new width(optional) true for the default animation or a standard Element animation config objectSet the height of the elementThe new height(optional) true for the default animation or a standard Element animation config objectSet the size of the element. If animation is true, both width an height will be animated concurrently.The new widthThe new height(optional) true for the default animation or a standard Element animation config objectSets the element's position and size in one shot. If animation is true then width, height, x and y will be animated concurrently.X value for new position (coordinates are page-based)Y value for new position (coordinates are page-based)The new widthThe new height(optional) true for the default animation or a standard Element animation config objectSets the element's position and size the the specified region. If animation is true then width, height, x and y will be animated concurrently.The region to fill(optional) true for the default animation or a standard Element animation config objectAppends an event handler to this element. The shorthand version <a ext:cls="Ext.Element" ext:member="on" href="output/Ext.Element.html#on">on</a> is equivalent.The type of event to handleThe handler function the event invokes(optional) The scope (this element) of the handler function(optional) An object containing handler configuration properties.
This may contain any of the following properties:<ul>
<li>scope {Object} : The scope in which to execute the handler function. The handler function's "this" context.</li>
<li>delegate {String} : A simple selector to filter the target or look for a descendant of the target</li>
<li>stopEvent {Boolean} : True to stop the event. That is stop propagation, and prevent the default action.</li>
<li>preventDefault {Boolean} : True to prevent the default action</li>
<li>stopPropagation {Boolean} : True to prevent event propagation</li>
<li>normalized {Boolean} : False to pass a browser event to the handler function instead of an Ext.EventObject</li>
<li>delay {Number} : The number of milliseconds to delay the invocation of the handler after te event fires.</li>
<li>single {Boolean} : True to add a handler to handle just the next firing of the event, and then remove itself.</li>
<li>buffer {Number} : Causes the handler to be scheduled to run in an <a ext:cls="Ext.util.DelayedTask" href="output/Ext.util.DelayedTask.html">Ext.util.DelayedTask</a> delayed
by the specified number of milliseconds. If the event fires again within that time, the original
handler is <em>not</em> invoked, but the new handler is scheduled in its place.</li>
</ul><br>
<p>
<b>Combining Options</b><br>
In the following examples, the shorthand form <a ext:cls="Ext.Element" ext:member="on" href="output/Ext.Element.html#on">on</a> is used rather than the more verbose
addListener. The two are equivalent. Using the options argument, it is possible to combine different
types of listeners:<br>
<br>
A normalized, delayed, one-time listener that auto stops the event and passes a custom argument (forumId)<div style="margin: 5px 20px 20px;">
Code:<pre><code>el.on('click', this.onClick, this, {
single: true,
delay: 100,
stopEvent : true,
forumId: 4
});</code></pre>
<p>
<b>Attaching multiple handlers in 1 call</b><br>
The method also allows for a single argument to be passed which is a config object containing properties
which specify multiple handlers.
<p>
Code:<pre><code>el.on({
'click' : {
fn: this.onClick
scope: this,
delay: 100
},
'mouseover' : {
fn: this.onMouseOver
scope: this
},
'mouseout' : {
fn: this.onMouseOut
scope: this
}
});</code></pre>
<p>
Or a shorthand syntax:<br>
Code:<pre><code>el.on({
'click' : this.onClick,
'mouseover' : this.onMouseOver,
'mouseout' : this.onMouseOut
scope: this
});</code></pre>Removes an event handler from this element. The shorthand version <a ext:cls="Ext.Element" ext:member="un" href="output/Ext.Element.html#un">un</a> is equivalent. Example:
<pre><code>el.removeListener('click', this.handlerFn);
// or
el.un('click', this.handlerFn);</code></pre>the type of event to removethe method the event invokesRemoves all previous added listeners from this elementCreate an event handler on this element such that when the event fires and is handled by this element,
it will be relayed to another object (i.e., fired again as if it originated from that object instead).The type of event to relayAny object that extends <a ext:cls="Ext.util.Observable" href="output/Ext.util.Observable.html">Ext.util.Observable</a> that will provide the context
for firing the relayed eventSet the opacity of the elementThe new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc(optional) true for the default animation or a standard Element animation config objectGets the left X coordinateTrue to get the local css position instead of page coordinateGets the right X coordinate of the element (element X position + element width)True to get the local css position instead of page coordinateGets the top Y coordinateTrue to get the local css position instead of page coordinateGets the bottom Y coordinate of the element (element Y position + element height)True to get the local css position instead of page coordinateInitializes positioning on this element. If a desired position is not passed, it will make the
the element positioned relative IF it is not already positioned.(optional) Positioning to use "relative", "absolute" or "fixed"(optional) The zIndex to apply(optional) Set the page X position(optional) Set the page Y positionClear positioning back to the default when the document was loaded(optional) The value to use for the left,right,top,bottom, defaults to '' (empty string). You could use 'auto'.Gets an object with all CSS positioning properties. Useful along with setPostioning to get
snapshot before performing an update and then restoring the element.Gets the width of the border(s) for the specified side(s)Can be t, l, r, b or any combination of those to add multiple values. For example,
passing lr would get the border (l)eft width + the border (r)ight width.Gets the width of the padding(s) for the specified side(s)Can be t, l, r, b or any combination of those to add multiple values. For example,
passing lr would get the padding (l)eft + the padding (r)ight.Set positioning with an object returned by getPositioning().Quick set left and top adding default unitsThe left CSS property valueThe top CSS property valueMove this element relative to its current position.Possible values are: "l","left" - "r","right" - "t","top","up" - "b","bottom","down".How far to move the element in pixels(optional) true for the default animation or a standard Element animation config objectStore the current overflow setting and clip overflow on the element - use <a ext:cls="Ext.Element" ext:member="unclip" href="output/Ext.Element.html#unclip">unclip</a> to removeReturn clipping (overflow) to original clipping before clip() was calledGets the x,y coordinates specified by the anchor position on the element.(optional) The specified anchor position (defaults to "c"). See <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">alignTo</a> for details on supported anchor positions.(optional) An object containing the size to use for calculating anchor position
{width: (target width), height: (target height)} (defaults to the element's current size)(optional) True to get the local (element top/left-relative) anchor position instead of page coordinatesGets the x,y coordinates to align this element with another element. See <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">alignTo</a> for more info on the
supported position values.The element to align to.The position to align to.(optional) Offset the positioning by [x, y]Aligns this element with another element relative to the specified anchor points. If the other element is the
document it aligns it to the viewport.
The position parameter is optional, and can be specified in any one of the following formats:
<ul>
<li><b>Blank</b>: Defaults to aligning the element's top-left corner to the target's bottom-left corner ("tl-bl").</li>
<li><b>One anchor (deprecated)</b>: The passed anchor position is used as the target element's anchor point.
The element being aligned will position its top-left corner (tl) to that point. <i>This method has been
deprecated in favor of the newer two anchor syntax below</i>.</li>
<li><b>Two anchors</b>: If two values from the table below are passed separated by a dash, the first value is used as the
element's anchor point, and the second value is used as the target's anchor point.</li>
</ul>
In addition to the anchor points, the position parameter also supports the "?" character. If "?" is passed at the end of
the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to
the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than
that specified in order to enforce the viewport constraints.
Following are all of the supported anchor positions:
<pre>Value Description
----- -----------------------------
tl The top left corner (default)
t The center of the top edge
tr The top right corner
l The center of the left edge
c In the center of the element
r The center of the right edge
bl The bottom left corner
b The center of the bottom edge
br The bottom right corner</pre>
Example Usage:
<pre><code>// align el to other-el using the default positioning ("tl-bl", non-constrained)
el.alignTo("other-el");
// align the top left corner of el with the top right corner of other-el (constrained to viewport)
el.alignTo("other-el", "tr?");
// align the bottom right corner of el with the center left edge of other-el
el.alignTo("other-el", "br-l?");
// align the center of el with the bottom left corner of other-el and
// adjust the x position by -6 pixels (and the y position by 0)
el.alignTo("other-el", "c-bl", [-6, 0]);</code></pre>The element to align to.The position to align to.(optional) Offset the positioning by [x, y](optional) true for the default animation or a standard Element animation config objectAnchors an element to another element and realigns it when the window is resized.The element to align to.The position to align to.(optional) Offset the positioning by [x, y](optional) True for the default animation or a standard Element animation config object(optional) True to monitor body scroll and reposition. If this parameter
is a number, it is used as the buffer delay (defaults to 50ms).The function to call after the animation finishesClears any opacity settings from this element. Required in some cases for IE.Hide this element - Uses display mode to determine whether to use "display" or "visibility". See <a ext:cls="Ext.Element" ext:member="setVisible" href="output/Ext.Element.html#setVisible">setVisible</a>.(optional) true for the default animation or a standard Element animation config objectShow this element - Uses display mode to determine whether to use "display" or "visibility". See <a ext:cls="Ext.Element" ext:member="setVisible" href="output/Ext.Element.html#setVisible">setVisible</a>.(optional) true for the default animation or a standard Element animation config objectUpdate the innerHTML of this element, optionally searching for and processing scriptsThe new HTML(optional) true to look for and process scriptsFor async script loading you can be noticed when the update completesDirect access to the Updater <a ext:cls="Ext.Updater" ext:member="update" href="output/Ext.Updater.html#update">Ext.Updater.update</a> method (takes the same parameters).The url for this request or a function to call to get the url(optional) The parameters to pass as either a url encoded string "param1=1&param2=2" or an object {param1: 1, param2: 2}(optional) Callback when transaction is complete - called with signature (oElement, bSuccess)(optional) By default when you execute an update the defaultUrl is changed to the last used url. If true, it will not store the url.Gets this element's UpdaterDisables text selection for this element (normalized across browsers)Calculates the x, y to center this element on the screenCenters the Element in either the viewport, or another Element.(optional) The element in which to center the element.Tests various css rules/browsers to determine if this element uses a border boxReturn a box {x, y, width, height} that can be used to set another elements
size/location to match this element.(optional) If true a box for the content of the element is returned.(optional) If true the element's left and top are returned instead of page x/y.Returns the sum width of the padding and borders for the passed "sides". See getBorderWidth()
for more information about the sides.Sets the element's box. Use getBox() on another element to get a box obj. If animate is true then width, height, x and y will be animated concurrently.The box to fill {x, y, width, height}(optional) Whether to adjust for box-model issues automatically(optional) true for the default animation or a standard Element animation config objectForces the browser to repaint this elementReturns an object with properties top, left, right and bottom representing the margins of this element unless sides is passed,
then it returns the calculated width of the sides (see getPadding)(optional) Any combination of l, r, t, b to get the sum of those sidesCreates a proxy element of this elementThe class name of the proxy element or a DomHelper config object(optional) The element or element id to render the proxy to (defaults to document.body)(optional) True to align and size the proxy to this element now (defaults to false)Puts a mask over this element to disable user interaction. Requires core.css.
This method can only be applied to elements which accept child nodes.(optional) A message to display in the mask(optional) A css class to apply to the msg elementRemoves a previously applied mask.Returns true if this element is maskedCreates an iframe shim for this element to keep selects and other windowed objects from
showing through.Removes this element from the DOM and deletes it from the cacheSets up event handlers to call the passed functions when the mouse is over this element. Automatically
filters child element mouse events.(optional)Sets up event handlers to add and remove a css class when the mouse is over this element(optional) If set to true, it prevents flickering by filtering
mouseout events for children elementsSets up event handlers to add and remove a css class when this element has the focusSets up event handlers to add and remove a css class when the mouse is down and then up on this element (a click effect)Stops the specified event from bubbling and optionally prevents the default action(optional) true to prevent the default action tooGets the next sibling, skipping text nodes(optional) Find the next sibling that matches the passed simple selector(optional) True to return a raw dom node instead of an Ext.ElementGets the previous sibling, skipping text nodes(optional) Find the previous sibling that matches the passed simple selector(optional) True to return a raw dom node instead of an Ext.ElementGets the first child, skipping text nodes(optional) Find the next sibling that matches the passed simple selector(optional) True to return a raw dom node instead of an Ext.ElementGets the last child, skipping text nodes(optional) Find the previous sibling that matches the passed simple selector(optional) True to return a raw dom node instead of an Ext.ElementAppends the passed element(s) to this elementCreates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.DomHelper element config object. If no tag is specified (e.g., {tag:'input'}) then a div will be
automatically generated with the specified attributes.(optional) a child element of this element(optional) true to return the dom node instead of creating an ElementAppends this element to the passed elementThe new parent elementInserts this element before the passed element in the DOMThe element to insert beforeInserts this element after the passed element in the DOMThe element to insert afterInserts (or creates) an element (or DomHelper config) as the first child of the this elementThe id or element to insert or a DomHelper config to create and insertInserts (or creates) the passed element (or DomHelper config) as a sibling of this elementThe id, element to insert or a DomHelper config to create and insert *or* an array of any of those.(optional) 'before' or 'after' defaults to before(optional) True to return the raw DOM element instead of Ext.ElementCreates and wraps this element with another element(optional) DomHelper element config object for the wrapper element or null for an empty div(optional) True to return the raw DOM element instead of Ext.ElementReplaces the passed element with this elementThe element to replaceReplaces this element with the passed elementThe new element or a DomHelper config of an element to createInserts an html fragment into this elementWhere to insert the html in relation to the this element - beforeBegin, afterBegin, beforeEnd, afterEnd.The HTML fragmentTrue to return an Ext.ElementSets the passed attributes as attributes of this element (a style attribute can be a string, object or function)The object with the attributes(optional) false to override the default setAttribute to use expandos.Convenience method for constructing a KeyMapEither a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}The function to call(optional) The scope of the functionCreates a KeyMap for this elementThe KeyMap config. See <a ext:cls="Ext.KeyMap" href="output/Ext.KeyMap.html">Ext.KeyMap</a> for more detailsReturns true if this element is scrollable.Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll().Either "left" for scrollLeft values or "top" for scrollTop values.The new scroll value(optional) true for the default animation or a standard Element animation config objectScrolls this element the specified direction. Does bounds checking to make sure the scroll is
within this element's scrollable range.Possible values are: "l","left" - "r","right" - "t","top","up" - "b","bottom","down".How far to scroll the element in pixels(optional) true for the default animation or a standard Element animation config objectTranslates the passed page coordinates into left/top css values for this elementThe page x or an array containing [x, y]The page yReturns the current scroll position of the element.Return the CSS color for the specified CSS attribute. rgb, 3 digit (like #fff) and valid values
are convert to standard 6 digit hex color.The css attributeThe default value to use when a valid color isn't found(optional) defaults to #. Use an empty string when working with
color anims.Wraps the specified element with a special markup/CSS block that renders by default as a gray container with a
gradient background, rounded corners and a 4-way shadow. Example usage:
<pre><code>
// Basic box wrap
Ext.get("foo").boxWrap();
// You can also add a custom class and use CSS inheritance rules to customize the box look.
// 'x-box-blue' is a built-in alternative -- look at the related CSS definitions as an example
// for how to create a custom box wrap style.
Ext.get("foo").boxWrap().addClass("x-box-blue");</pre></code>(optional) A base CSS class to apply to the containing wrapper element (defaults to 'x-box').
Note that there are a number of CSS rules that are dependent on this name to make the overall effect work,
so if you supply an alternate base class, make sure you also supply all of the necessary rules.Returns the value of a namespaced attribute from the element's underlying DOM node.The namespace in which to look for the attributeThe attribute name<static> Static method to retrieve Element objects. Uses simple caching to consistently return the same object.
Automatically fixes if an object was recreated with the same id via AJAX or DOM.The id of the node, a DOM Node or an existing Element.<static> Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
the dom node can be overwritten by other code.The dom node or id(optional) Allows for creation of named reusable flyweights to
prevent conflicts (e.g. internally Ext uses "_internal")Appends an event handler (shorthand for <a ext:cls="Ext.Element" ext:member="addListener" href="output/Ext.Element.html#addListener">addListener</a>).The type of event to handleThe handler function the event invokes(optional) The scope (this element) of the handler function(optional) An object containing standard <a ext:cls="Ext.Element" ext:member="addListener" href="output/Ext.Element.html#addListener">addListener</a> optionsRemoves an event handler from this element (shorthand for <a ext:cls="Ext.Element" ext:member="removeListener" href="output/Ext.Element.html#removeListener">removeListener</a>).the type of event to removethe method the event invokesRegisters event handlers that want to receive a normalized EventObject instead of the standard browser event and provides
several useful events directly.
See <a ext:cls="Ext.EventObject" href="output/Ext.EventObject.html">Ext.EventObject</a> for more details on normalized event objects.<br><br><i>This class is a singleton and cannot be created directly.</i>Url used for onDocumentReady with using SSL (defaults to Ext.SSL_SECURE_URL)The frequency, in milliseconds, to check for text resize events (defaults to 50)Appends an event handler to an element. The shorthand version <a ext:cls="Ext.EventManager" ext:member="on" href="output/Ext.EventManager.html#on">on</a> is equivalent. Typically you will
use <a ext:cls="Ext.Element" ext:member="addListener" href="output/Ext.Element.html#addListener">Ext.Element.addListener</a> directly on an Element in favor of calling this version.The html element or id to assign the event handler toThe type of event to listen forThe handler function the event invokes(optional) The scope in which to execute the handler
function (the handler function's "this" context)(optional) An object containing handler configuration properties.
This may contain any of the following properties:<ul>
<li>scope {Object} : The scope in which to execute the handler function. The handler function's "this" context.</li>
<li>delegate {String} : A simple selector to filter the target or look for a descendant of the target</li>
<li>stopEvent {Boolean} : True to stop the event. That is stop propagation, and prevent the default action.</li>
<li>preventDefault {Boolean} : True to prevent the default action</li>
<li>stopPropagation {Boolean} : True to prevent event propagation</li>
<li>normalized {Boolean} : False to pass a browser event to the handler function instead of an Ext.EventObject</li>
<li>delay {Number} : The number of milliseconds to delay the invocation of the handler after te event fires.</li>
<li>single {Boolean} : True to add a handler to handle just the next firing of the event, and then remove itself.</li>
<li>buffer {Number} : Causes the handler to be scheduled to run in an <a ext:cls="Ext.util.DelayedTask" href="output/Ext.util.DelayedTask.html">Ext.util.DelayedTask</a> delayed
by the specified number of milliseconds. If the event fires again within that time, the original
handler is <em>not</em> invoked, but the new handler is scheduled in its place.</li>
</ul><br>
<p>See <a ext:cls="Ext.Element" ext:member="addListener" href="output/Ext.Element.html#addListener">Ext.Element.addListener</a> for examples of how to use these options.</p>Removes an event handler from an element. The shorthand version <a ext:cls="Ext.EventManager" ext:member="un" href="output/Ext.EventManager.html#un">un</a> is equivalent. Typically
you will use <a ext:cls="Ext.Element" ext:member="removeListener" href="output/Ext.Element.html#removeListener">Ext.Element.removeListener</a> directly on an Element in favor of calling this version.The id or html element from which to remove the eventThe type of eventThe handler function to removeFires when the document is ready (before onload and before images are loaded). Can be
accessed shorthanded as Ext.onReady().The method the event invokes(optional) An object that becomes the scope of the handler(optional) An object containing standard <a ext:cls="Ext.EventManager" ext:member="addListener" href="output/Ext.EventManager.html#addListener">addListener</a> optionsFires when the window is resized and provides resize event buffering (50 milliseconds), passes new viewport width and height to handlers.The method the event invokesAn object that becomes the scope of the handlerFires when the user changes the active text size. Handler gets called with 2 params, the old size and the new size.The method the event invokesAn object that becomes the scope of the handlerRemoves the passed window resize listener.The method the event invokesThe scope of handlerAppends an event handler to an element. Shorthand for <a ext:cls="Ext.EventManager" ext:member="addListener" href="output/Ext.EventManager.html#addListener">addListener</a>.The html element or id to assign the event handler toThe type of event to listen forThe handler function the event invokes(optional) The scope in which to execute the handler
function (the handler function's "this" context)(optional) An object containing standard <a ext:cls="Ext.EventManager" ext:member="addListener" href="output/Ext.EventManager.html#addListener">addListener</a> optionsRemoves an event handler from an element. Shorthand for <a ext:cls="Ext.EventManager" ext:member="removeListener" href="output/Ext.EventManager.html#removeListener">removeListener</a>.The id or html element from which to remove the eventThe type of eventThe handler function to removeEventObject exposes the Yahoo! UI Event functionality directly on the object
passed to your event handler. It exists mostly for convenience. It also fixes the annoying null checks automatically to cleanup your code
Example:
<pre><code>function handleClick(e){ // e is not a standard event object, it is a Ext.EventObject
e.preventDefault();
var target = e.getTarget();
...
}
var myDiv = Ext.get("myDiv");
myDiv.on("click", handleClick);
//or
Ext.EventManager.on("myDiv", 'click', handleClick);
Ext.EventManager.addListener("myDiv", 'click', handleClick);</code></pre><br><br><i>This class is a singleton and cannot be created directly.</i>The normal browser eventThe button pressed in a mouse eventTrue if the shift key was down during the eventTrue if the control key was down during the eventTrue if the alt key was down during the eventKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantKey constantStop the event (preventDefault and stopPropagation)Prevents the browsers default handling of the event.Cancels bubbling of the event.Gets the key code for the event.Returns a normalized keyCode for the event.Gets the x coordinate of the event.Gets the y coordinate of the event.Gets the time of the event.Gets the page coordinates of the event.Gets the target for the event.(optional) A simple selector to filter the target or look for an ancestor of the target(optional) The max depth to
search as a number or element (defaults to 10 || document.body)(optional) True to return a Ext.Element object instead of DOM nodeGets the related target.Normalizes mouse wheel delta across browsersReturns true if the control, meta, shift or alt key was pressed during this event.Returns true if the target of this event equals el or is a child of el(optional) true to test if the related target is within el instead of the target<p>A class to provide basic animation and visual effects support. <b>Note:</b> This class is automatically applied
to the <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a> interface when included, so all effects calls should be performed via Element.
Conversely, since the effects are not actually defined in Element, Ext.Fx <b>must</b> be included in order for the
Element effects to work.</p><br/>
<p>It is important to note that although the Fx methods and many non-Fx Element methods support "method chaining" in that
they return the Element object itself as the method return value, it is not always possible to mix the two in a single
method chain. The Fx methods use an internal effects queue so that each effect can be properly timed and sequenced.
Non-Fx methods, on the other hand, have no such internal queueing and will always execute immediately. For this reason,
while it may be possible to mix certain Fx and non-Fx method calls in a single chain, it may not always provide the
expected results and should be done with care.</p><br/>
<p>Motion effects support 8-way anchoring, meaning that you can choose one of 8 different anchor points on the Element
that will serve as either the start or end point of the animation. Following are all of the supported anchor positions:</p>
<pre>Value Description
----- -----------------------------
tl The top left corner
t The center of the top edge
tr The top right corner
l The center of the left edge
r The center of the right edge
bl The bottom left corner
b The center of the bottom edge
br The bottom right corner</pre>
<b>Although some Fx methods accept specific custom config parameters, the ones shown in the Config Options section
below are common options that can be passed to any Fx method.</b>Slides the element into view. An anchor point can be optionally passed to set the point of
origin for the slide effect. This function automatically handles wrapping the element with
a fixed-size container if needed. See the Fx class overview for valid anchor point options.
Usage:
<pre><code>// default: slide the element in from the top
el.slideIn();
// custom: slide the element in from the right with a 2-second duration
el.slideIn('r', { duration: 2 });
// common config options shown with default values
el.slideIn('t', {
easing: 'easeOut',
duration: .5
});</code></pre>(optional) One of the valid Fx anchor positions (defaults to top: 't')(optional) Object literal with any of the Fx config optionsSlides the element out of view. An anchor point can be optionally passed to set the end point
for the slide effect. When the effect is completed, the element will be hidden (visibility =
'hidden') but block elements will still take up space in the document. The element must be removed
from the DOM using the 'remove' config option if desired. This function automatically handles
wrapping the element with a fixed-size container if needed. See the Fx class overview for valid anchor point options.
Usage:
<pre><code>// default: slide the element out to the top
el.slideOut();
// custom: slide the element out to the right with a 2-second duration
el.slideOut('r', { duration: 2 });
// common config options shown with default values
el.slideOut('t', {
easing: 'easeOut',
duration: .5,
remove: false,
useDisplay: false
});</code></pre>(optional) One of the valid Fx anchor positions (defaults to top: 't')(optional) Object literal with any of the Fx config optionsFades the element out while slowly expanding it in all directions. When the effect is completed, the
element will be hidden (visibility = 'hidden') but block elements will still take up space in the document.
The element must be removed from the DOM using the 'remove' config option if desired.
Usage:
<pre><code>// default
el.puff();
// common config options shown with default values
el.puff({
easing: 'easeOut',
duration: .5,
remove: false,
useDisplay: false
});</code></pre>(optional) Object literal with any of the Fx config optionsBlinks the element as if it was clicked and then collapses on its center (similar to switching off a television).
When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still
take up space in the document. The element must be removed from the DOM using the 'remove' config option if desired.
Usage:
<pre><code>// default
el.switchOff();
// all config options shown with default values
el.switchOff({
easing: 'easeIn',
duration: .3,
remove: false,
useDisplay: false
});</code></pre>(optional) Object literal with any of the Fx config optionsHighlights the Element by setting a color (applies to the background-color by default, but can be
changed using the "attr" config option) and then fading back to the original color. If no original
color is available, you should provide the "endColor" config option which will be cleared after the animation.
Usage:
<pre><code>// default: highlight background to yellow
el.highlight();
// custom: highlight foreground text to blue for 2 seconds
el.highlight("0000ff", { attr: 'color', duration: 2 });
// common config options shown with default values
el.highlight("ffff9c", {
attr: "background-color", //can be any valid CSS property (attribute) that supports a color value
endColor: (current color) or "ffffff",
easing: 'easeIn',
duration: 1
});</code></pre>(optional) The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c')(optional) Object literal with any of the Fx config optionsShows a ripple of exploding, attenuating borders to draw attention to an Element.
Usage:
<pre><code>// default: a single light blue ripple
el.frame();
// custom: 3 red ripples lasting 3 seconds total
el.frame("ff0000", 3, { duration: 3 });
// common config options shown with default values
el.frame("C3DAF9", 1, {
duration: 1 //duration of entire animation (not each individual ripple)
// Note: Easing is not configurable and will be ignored if included
});</code></pre>(optional) The color of the border. Should be a 6 char hex color without the leading # (defaults to light blue: 'C3DAF9').(optional) The number of ripples to display (defaults to 1)(optional) Object literal with any of the Fx config optionsCreates a pause before any subsequent queued effects begin. If there are
no effects queued after the pause it will have no effect.
Usage:
<pre><code>el.pause(1);</code></pre>The length of time to pause (in seconds)Fade an element in (from transparent to opaque). The ending opacity can be specified
using the "endOpacity" config option.
Usage:
<pre><code>// default: fade in from opacity 0 to 100%
el.fadeIn();
// custom: fade in from opacity 0 to 75% over 2 seconds
el.fadeIn({ endOpacity: .75, duration: 2});
// common config options shown with default values
el.fadeIn({
endOpacity: 1, //can be any value between 0 and 1 (e.g. .5)
easing: 'easeOut',
duration: .5
});</code></pre>(optional) Object literal with any of the Fx config optionsFade an element out (from opaque to transparent). The ending opacity can be specified
using the "endOpacity" config option.
Usage:
<pre><code>// default: fade out from the element's current opacity to 0
el.fadeOut();
// custom: fade out from the element's current opacity to 25% over 2 seconds
el.fadeOut({ endOpacity: .25, duration: 2});
// common config options shown with default values
el.fadeOut({
endOpacity: 0, //can be any value between 0 and 1 (e.g. .5)
easing: 'easeOut',
duration: .5
remove: false,
useDisplay: false
});</code></pre>(optional) Object literal with any of the Fx config optionsAnimates the transition of an element's dimensions from a starting height/width
to an ending height/width.
Usage:
<pre><code>// change height and width to 100x100 pixels
el.scale(100, 100);
// common config options shown with default values. The height and width will default to
// the element's existing values if passed as null.
el.scale(
[element's width],
[element's height], {
easing: 'easeOut',
duration: .35
});</code></pre>The new width (pass undefined to keep the original width)The new height (pass undefined to keep the original height)(optional) Object literal with any of the Fx config optionsAnimates the transition of any combination of an element's dimensions, xy position and/or opacity.
Any of these properties not specified in the config object will not be changed. This effect
requires that at least one new dimension, position or opacity setting must be passed in on
the config object in order for the function to have any effect.
Usage:
<pre><code>// slide the element horizontally to x position 200 while changing the height and opacity
el.shift({ x: 200, height: 50, opacity: .8 });
// common config options shown with default values.
el.shift({
width: [element's width],
height: [element's height],
x: [element's x position],
y: [element's y position],
opacity: [element's opacity],
easing: 'easeOut',
duration: .35
});</code></pre>Object literal with any of the Fx config optionsSlides the element while fading it out of view. An anchor point can be optionally passed to set the
ending point of the effect.
Usage:
<pre><code>// default: slide the element downward while fading out
el.ghost();
// custom: slide the element out to the right with a 2-second duration
el.ghost('r', { duration: 2 });
// common config options shown with default values
el.ghost('b', {
easing: 'easeOut',
duration: .5
remove: false,
useDisplay: false
});</code></pre>(optional) One of the valid Fx anchor positions (defaults to bottom: 'b')(optional) Object literal with any of the Fx config optionsEnsures that all effects queued after syncFx is called on the element are
run concurrently. This is the opposite of <a ext:cls="Ext.Fx" ext:member="sequenceFx" href="output/Ext.Fx.html#sequenceFx">sequenceFx</a>.Ensures that all effects queued after sequenceFx is called on the element are
run in sequence. This is the opposite of <a ext:cls="Ext.Fx" ext:member="syncFx" href="output/Ext.Fx.html#syncFx">syncFx</a>.Returns true if the element has any effects actively running or queued, else returns false.Stops any running effects and clears the element's internal effects queue if it contains
any additional effects that haven't started yet.Returns true if the element is currently blocking so that no other effect can be queued
until this effect is finished, else returns false if blocking is not set. This is commonly
used to ensure that an effect initiated by a user action runs to completion prior to the
same effect being restarted (e.g., firing only one effect even if the user clicks several times).Handles mapping keys to actions for an element. One key map can be used for multiple actions.
The constructor accepts the same config object as defined by <a ext:cls="Ext.KeyMap" ext:member="addBinding" href="output/Ext.KeyMap.html#addBinding">addBinding</a>.
If you bind a callback function to a KeyMap, anytime the KeyMap handles an expected key
combination it will call the function with this signature (if the match is a multi-key
combination the callback will still be called only once): (String key, Ext.EventObject e)
A KeyMap can also handle a string representation of keys.<br />
Usage:
<pre><code>// map one key by key code
var map = new Ext.KeyMap("my-element", {
key: 13, // or Ext.EventObject.ENTER
fn: myHandler,
scope: myObject
});
// map multiple keys to one action by string
var map = new Ext.KeyMap("my-element", {
key: "a\r\n\t",
fn: myHandler,
scope: myObject
});
// map multiple keys to multiple actions by strings and array of codes
var map = new Ext.KeyMap("my-element", [
{
key: [10,13],
fn: function(){ alert("Return was pressed"); }
}, {
key: "abc",
fn: function(){ alert('a, b or c was pressed'); }
}, {
key: "\t",
ctrl:true,
shift:true,
fn: function(){ alert('Control + shift + tab was pressed.'); }
}
]);</code></pre>
<b>Note: A KeyMap starts enabled</b>The element to bind toThe config (see <a ext:cls="Ext.KeyMap" ext:member="addBinding" href="output/Ext.KeyMap.html#addBinding">addBinding</a>)(optional) The event to bind to (defaults to "keydown")True to stop the event from bubbling and prevent the default browser action if the
key was handled by the KeyMap (defaults to false)Add a new binding to this KeyMap. The following config object properties are supported:
<pre>Property Type Description
---------- --------------- ----------------------------------------------------------------------
key String/Array A single keycode or an array of keycodes to handle
shift Boolean True to handle key only when shift is pressed (defaults to false)
ctrl Boolean True to handle key only when ctrl is pressed (defaults to false)
alt Boolean True to handle key only when alt is pressed (defaults to false)
fn Function The function to call when KeyMap finds the expected key combination
scope Object The scope of the callback function</pre>
Usage:
<pre><code>// Create a KeyMap
var map = new Ext.KeyMap(document, {
key: Ext.EventObject.ENTER,
fn: handleKey,
scope: this
});
//Add a new binding to the existing KeyMap later
map.addBinding({
key: 'abc',
shift: true,
fn: handleKey,
scope: this
});</code></pre>A single KeyMap config or an array of configsShorthand for adding a single key listenerEither the numeric key code, array of key codes or an object with the
following options:
{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}The function to call(optional) The scope of the functionReturns true if this KeyMap is enabledEnables this KeyMapDisable this KeyMap<p>Provides a convenient wrapper for normalized keyboard navigation. KeyNav allows you to bind
navigation keys to function calls that will get called when the keys are pressed, providing an easy
way to implement custom navigation schemes for any UI component.</p>
<p>The following are all of the possible keys that can be implemented: enter, left, right, up, down, tab, esc,
pageUp, pageDown, del, home, end. Usage:</p>
<pre><code>var nav = new Ext.KeyNav("my-element", {
"left" : function(e){
this.moveLeft(e.ctrlKey);
},
"right" : function(e){
this.moveRight(e.ctrlKey);
},
"enter" : function(e){
this.save();
},
scope : this
});</code></pre>The element to bind toThe configEnable this KeyNavDisable this KeyNavAn extended <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a> object that supports a shadow and shim, constrain to viewport and
automatic maintaining of shadow/shim positions.An object with config options.(optional) Uses an existing DOM element. If the element is not found it creates it.Sets the z-index of this layer and adjusts any shadow and shim z-indexes. The layer z-index is automatically
incremented by two more than the value passed in so that it always shows above any shadow or shim (the shadow
element, if any, will be assigned z-index + 1, and the shim element, if any, will be assigned the unmodified z-index).The new z-index to setA simple utility class for generically masking elements while loading data. If the element being masked has
an underlying <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>, the masking will be automatically synchronized with the store's loading
process and the mask element will be cached for reuse. For all other elements, this mask will replace the
element's Updater load indicator and will be destroyed after the initial load.Create a new LoadMaskThe element or DOM node, or its idThe config objectRead-only. True if the mask is currently disabled so that it will not be displayed (defaults to false)Disables the mask to prevent it from being displayedEnables the mask so that it can be displayed<p>Utility class for generating different styles of message boxes. The alias Ext.Msg can also be used.<p/>
<p>Note that the MessageBox is asynchronous. Unlike a regular JavaScript <code>alert</code> (which will halt
browser execution), showing a MessageBox will not cause the code to stop. For this reason, if you have code
that should only run <em>after</em> some user feedback from the MessageBox, you must use a callback function
(see the <code>function</code> parameter for <a ext:cls="Ext.MessageBox" ext:member="show" href="output/Ext.MessageBox.html#show">show</a> for more details).</p>
<p>Example usage:</p>
<pre><code>// Basic alert:
Ext.Msg.alert('Status', 'Changes saved successfully.');
// Prompt for user data and process the result using a callback:
Ext.Msg.prompt('Name', 'Please enter your name:', function(btn, text){
if (btn == 'ok'){
// process text value and close...
}
});
// Show a dialog using config options:
Ext.Msg.show({
title:'Save Changes?',
msg: 'Your are closing a tab that has unsaved changes. Would you like to save your changes?',
buttons: Ext.Msg.YESNOCANCEL,
fn: processResult,
animEl: 'elId',
icon: Ext.MessageBox.QUESTION
});</code></pre><br><br><i>This class is a singleton and cannot be created directly.</i>Button config that displays a single OK buttonButton config that displays Yes and No buttonsButton config that displays OK and Cancel buttonsButton config that displays Yes, No and Cancel buttonsThe CSS class that provides the INFO icon imageThe CSS class that provides the WARNING icon imageThe CSS class that provides the QUESTION icon imageThe CSS class that provides the ERROR icon imageThe default height in pixels of the message box's multiline textarea if displayed (defaults to 75)The maximum width in pixels of the message box (defaults to 600)The minimum width in pixels of the message box (defaults to 100)The minimum width in pixels of the message box if it is a progress-style dialog. This is useful
for setting a different minimum width than text-only dialogs may need (defaults to 250)An object containing the default button text strings that can be overriden for localized language support.
Supported properties are: ok, cancel, yes and no. Generally you should include a locale-specific
resource file for handling language support across the framework.
Customize the default text like so: Ext.MessageBox.buttonText.yes = "oui"; //frenchReturns a reference to the underlying <a ext:cls="Ext.Window" href="output/Ext.Window.html">Ext.Window</a> elementUpdates the message box body text(optional) Replaces the message box element's innerHTML with the specified string (defaults to
the XHTML-compliant non-breaking space character '&#160;')Updates a progress-style message box's text and progress bar. Only relevant on message boxes
initiated via <a ext:cls="Ext.MessageBox" ext:member="progress" href="output/Ext.MessageBox.html#progress">Ext.MessageBox.progress</a> or by calling <a ext:cls="Ext.MessageBox" ext:member="show" href="output/Ext.MessageBox.html#show">Ext.MessageBox.show</a> with progress: true.Any number between 0 and 1 (e.g., .5, defaults to 0)The progress text to display inside the progress bar (defaults to '')The message box's body text is replaced with the specified string (defaults to undefined
so that any existing body text will not get overwritten by default unless a new value is passed in)Returns true if the message box is currently displayedHides the message box if it is displayedDisplays a new message box, or reinitializes an existing message box, based on the config options
passed in. All display functions (e.g. prompt, alert, etc.) on MessageBox call this function internally,
although those calls are basic shortcuts and do not support all of the config options allowed here.
The following config object properties are supported:
<pre>Property Type Description
---------------- --------------- -----------------------------------------------------------------------------
animEl String/Element An id or Element from which the message box should animate as it opens and
closes (defaults to undefined)
buttons Object/Boolean A button config object (e.g., Ext.MessageBox.OKCANCEL or {ok:'Foo',
cancel:'Bar'}), or false to not show any buttons (defaults to false)
closable Boolean False to hide the top-right close button (defaults to true). Note that
progress and wait dialogs will ignore this property and always hide the
close button as they can only be closed programmatically.
cls String A custom CSS class to apply to the message box element
defaultTextHeight Number The default height in pixels of the message box's multiline textarea if
displayed (defaults to 75)
fn Function A callback function to execute after closing the dialog. The arguments to the
function will be btn (the name of the button that was clicked, if applicable,
e.g. "ok"), and text (the value of the active text field, if applicable).
Progress and wait dialogs will ignore this option since they do not respond to
user actions and can only be closed programmatically, so any required function
should be called by the same code after it closes the dialog.
icon String A CSS class that provides a background image to be used as an icon for
the dialog (e.g., Ext.MessageBox.WARNING or 'custom-class', defaults to '')
maxWidth Number The maximum width in pixels of the message box (defaults to 600)
minWidth Number The minimum width in pixels of the message box (defaults to 100)
modal Boolean False to allow user interaction with the page while the message box is
displayed (defaults to true)
msg String A string that will replace the existing message box body text (defaults
to the XHTML-compliant non-breaking space character ' ')
multiline Boolean True to prompt the user to enter multi-line text (defaults to false)
progress Boolean True to display a progress bar (defaults to false)
progressText String The text to display inside the progress bar if progress = true (defaults to '')
prompt Boolean True to prompt the user to enter single-line text (defaults to false)
proxyDrag Boolean True to display a lightweight proxy while dragging (defaults to false)
title String The title text
value String The string value to set into the active textbox element if displayed
wait Boolean True to display a progress bar (defaults to false)
waitConfig Object A <a ext:cls="Ext.ProgressBar" ext:member="waitConfig" href="output/Ext.ProgressBar.html#waitConfig">Ext.ProgressBar.waitConfig</a> object (applies only if wait = true)
width Number The width of the dialog in pixels</pre>
Example usage:
<pre><code>Ext.Msg.show({
title: 'Address',
msg: 'Please enter your address:',
width: 300,
buttons: Ext.MessageBox.OKCANCEL,
multiline: true,
fn: saveAddress,
animEl: 'addAddressBtn',
icon: Ext.MessagBox.INFO
});</code></pre>Configuration optionsAdds the specified icon to the dialog. By default, the class 'ext-mb-icon' is applied for default
styling, and the class passed in is expected to supply the background image url. Pass in empty string ('')
to clear any existing icon. The following built-in icon classes are supported, but you can also pass
in a custom class name:
<pre>Ext.MessageBox.INFO
Ext.MessageBox.WARNING
Ext.MessageBox.QUESTION
Ext.MessageBox.ERROR</pre>A CSS classname specifying the icon's background image url, or empty string to clear the iconDisplays a message box with a progress bar. This message box has no buttons and is not closeable by
the user. You are responsible for updating the progress bar as needed via <a ext:cls="Ext.MessageBox" ext:member="updateProgress" href="output/Ext.MessageBox.html#updateProgress">Ext.MessageBox.updateProgress</a>
and closing the message box when the process is complete.The title bar textThe message box body textThe text to display inside the progress bar (defaults to '')Displays a message box with an infinitely auto-updating progress bar. This can be used to block user
interaction while waiting for a long-running process to complete that does not have defined intervals.
You are responsible for closing the message box when the process is complete.The message box body text(optional) The title bar text(optional) A <a ext:cls="Ext.ProgressBar" ext:member="waitConfig" href="output/Ext.ProgressBar.html#waitConfig">Ext.ProgressBar.waitConfig</a> objectDisplays a standard read-only message box with an OK button (comparable to the basic JavaScript alert prompt).
If a callback function is passed it will be called after the user clicks the button, and the
id of the button that was clicked will be passed as the only parameter to the callback
(could also be the top-right close button).The title bar textThe message box body text(optional) The callback function invoked after the message box is closed(optional) The scope of the callback functionDisplays a confirmation message box with Yes and No buttons (comparable to JavaScript's confirm).
If a callback function is passed it will be called after the user clicks either button,
and the id of the button that was clicked will be passed as the only parameter to the callback
(could also be the top-right close button).The title bar textThe message box body text(optional) The callback function invoked after the message box is closed(optional) The scope of the callback functionDisplays a message box with OK and Cancel buttons prompting the user to enter some text (comparable to JavaScript's prompt).
The prompt can be a single-line or multi-line textbox. If a callback function is passed it will be called after the user
clicks either button, and the id of the button that was clicked (could also be the top-right
close button) and the text that was entered will be passed as the two parameters to the callback.The title bar textThe message box body text(optional) The callback function invoked after the message box is closed(optional) The scope of the callback function(optional) True to create a multiline textbox using the defaultTextHeight
property, or the height in pixels to create the textbox (defaults to false / single-line)A specialized toolbar that is bound to a <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> and provides automatic paging controls.Create a new PagingToolbarThe config objectCustomizable piece of the default paging text (defaults to "Page")Customizable piece of the default paging text (defaults to "of %0")Customizable piece of the default paging text (defaults to "First Page")Customizable piece of the default paging text (defaults to "Previous Page")Customizable piece of the default paging text (defaults to "Next Page")Customizable piece of the default paging text (defaults to "Last Page")Customizable piece of the default paging text (defaults to "Refresh")Object mapping of parameter names for load calls (defaults to {start: 'start', limit: 'limit'})Unbinds the paging toolbar from the specified <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>The data store to unbindBinds the paging toolbar to the specified <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>The data store to bindPanel is a container that has specific functionality and structural components that make it the perfect building
block for application-oriented user interfaces. The Panel contains bottom and top toolbars, along with separate
header, footer and body sections. It also provides built-in expandable and collapsible behavior, along with a
variety of prebuilt tool buttons that can be wired up to provide other customized behavior. Panels can be easily
dropped into any Container or layout, and the layout and rendering pipeline is completely managed by the framework.The config objectThe Panel's header {@link Ext.Element Element}. Read-only.
The Panel's body {@link Ext.Element Element} which may be used either to contain HTML content,
or to house a Layout. Read-only.
The Panel's footer {@link Ext.Element Element}. Read-only.Sets the CSS class that provides the icon image for this panel. This method will replace any existing
icon class if one has already been set.The new CSS class nameReturns the toolbar from the top (tbar) section of the panel.Returns the toolbar from the bottom (bbar) section of the panel.Adds a button to this panel. Note that this method must be called prior to rendering. The preferred
approach is to add buttons via the <a ext:cls="Ext.Panel" ext:member="buttons" href="output/Ext.Panel.html#buttons">buttons</a> config.A valid <a ext:cls="Ext.Button" href="output/Ext.Button.html">Ext.Button</a> config. A string will become the text for a default
button config, an object will be treated as a button config object.The function to be called on button <a ext:cls="Ext.Button" ext:member="click" href="output/Ext.Button.html#click">Ext.Button.click</a>The scope to use for the button handler functionCollapses the panel body so that it becomes hidden. Fires the <a ext:cls="Ext.Panel" ext:member="beforecollapse" href="output/Ext.Panel.html#beforecollapse">beforecollapse</a> event which will
cancel the collapse action if it returns false.True to animate the transition, else false (defaults to the value of the
<a ext:cls="Ext.Panel" ext:member="animCollapse" href="output/Ext.Panel.html#animCollapse">animCollapse</a> panel config)Expands the panel body so that it becomes visible. Fires the <a ext:cls="Ext.Panel" ext:member="beforeexpand" href="output/Ext.Panel.html#beforeexpand">beforeexpand</a> event which will
cancel the expand action if it returns false.True to animate the transition, else false (defaults to the value of the
<a ext:cls="Ext.Panel" ext:member="animCollapse" href="output/Ext.Panel.html#animCollapse">animCollapse</a> panel config)Shortcut for performing an <a ext:cls="Ext.Panel" ext:member="expand" href="output/Ext.Panel.html#expand">expand</a> or <a ext:cls="Ext.Panel" ext:member="collapse" href="output/Ext.Panel.html#collapse">collapse</a> based on the current state of the panel.True to animate the transition, else false (defaults to the value of the
<a ext:cls="Ext.Panel" ext:member="animCollapse" href="output/Ext.Panel.html#animCollapse">animCollapse</a> panel config)Returns the width in pixels of the framing elements of this panel (not including the body width). To
retrieve the body width see <a ext:cls="Ext.Panel" ext:member="getInnerWidth" href="output/Ext.Panel.html#getInnerWidth">getInnerWidth</a>.Returns the height in pixels of the framing elements of this panel (including any top and bottom bars and
header and footer elements, but not including the body height). To retrieve the body height see <a ext:cls="Ext.Panel" ext:member="getInnerHeight" href="output/Ext.Panel.html#getInnerHeight">getInnerHeight</a>.Returns the width in pixels of the body element (not including the width of any framing elements).
For the frame width see <a ext:cls="Ext.Panel" ext:member="getFrameWidth" href="output/Ext.Panel.html#getFrameWidth">getFrameWidth</a>.Returns the height in pixels of the body element (not including the height of any framing elements).
For the frame height see <a ext:cls="Ext.Panel" ext:member="getFrameHeight" href="output/Ext.Panel.html#getFrameHeight">getFrameHeight</a>.Sets the title text for the panel and optioanlly the icon class.The title text to seticonCls A CSS class that provides the icon image for this panelGet the <a ext:cls="Ext.Updater" href="output/Ext.Updater.html">Ext.Updater</a> for this panel. Enables you to perform Ajax updates of this panel's body.Loads this content panel immediately with content returned from an XHR call.A config object containing any of the following options:
<pre><code>panel.load({
url: "your-url.php",
params: {param1: "foo", param2: "bar"}, // or a URL encoded string
callback: yourFunction,
scope: yourObject, // optional scope for the callback
discardUrl: false,
nocache: false,
text: "Loading...",
timeout: 30,
scripts: false
});</code></pre>
The only required property is url. The optional properties nocache, text and scripts
are shorthand for disableCaching, indicatorText and loadScripts and are used to set their
associated property on this panel Updater instance.<p>An updateable progress bar component. The progress bar supports two different modes: manual and automatic.</p>
<p>In manual mode, you are responsible for showing, updating (via <a ext:cls="Ext.ProgressBar" ext:member="updateProgress" href="output/Ext.ProgressBar.html#updateProgress">updateProgress</a>) and clearing the
progress bar as needed from your own code. This method is most appropriate when you want to show progress
throughout an operation that has predictable points of interest at which you can update the control.</p>
<p>In automatic mode, you simply call <a ext:cls="Ext.ProgressBar" ext:member="wait" href="output/Ext.ProgressBar.html#wait">wait</a> and let the progress bar run indefinitely, only clearing it
once the operation is complete. You can optionally have the progress bar wait for a specific amount of time
and then clear itself. Automatic mode is most appropriate for timed operations or asymchronous operations in
which you have no need for indicating intermediate progress.</p>Updates the progress bar value, and optionally its text. If the text argument is not specified,
any existing text value will be unchanged. To blank out existing text, pass ''. Note that even
if the progress bar value exceeds 1, it will never automatically reset -- you are responsible for
determining when the progress is complete and calling <a ext:cls="Ext.ProgressBar" ext:member="reset" href="output/Ext.ProgressBar.html#reset">reset</a> to clear and/or hide the control.(optional) A floating point value between 0 and 1 (e.g., .5, defaults to 0)(optional) The string to display in the progress text element (defaults to '')Initiates an auto-updating progress bar. A duration can be specified, in which case the progress
bar will automatically reset after a fixed amount of time and optionally call a callback function
if specified. If no duration is passed in, then the progress bar will run indefinitely and must
be manually cleared by calling <a ext:cls="Ext.ProgressBar" ext:member="reset" href="output/Ext.ProgressBar.html#reset">reset</a>. The wait method accepts a config object with
the following properties:
<pre>Property Type Description
---------- ------------ ----------------------------------------------------------------------
duration Number The length of time in milliseconds that the progress bar should
run before resetting itself (defaults to undefined, in which case it
will run indefinitely until reset is called)
interval Number The length of time in milliseconds between each progress update
(defaults to 1000 ms)
increment Number The number of progress update segments to display within the progress
bar (defaults to 10). If the bar reaches the end and is still
updating, it will automatically wrap back to the beginning.
fn Function A callback function to execute after the progress bar finishes auto-
updating. The function will be called with no arguments. This function
will be ignored if duration is not specified since in that case the
progress bar can only be stopped programmatically, so any required function
should be called by the same code after it resets the progress bar.
scope Object The scope that is passed to the callback function (only applies when
duration and fn are both passed).</pre>
Example usage:
<pre><code>var p = new Ext.ProgressBar({
renderTo: 'my-el'
});
//Wait for 5 seconds, then update the status el (progress bar will auto-reset)
p.wait({
interval: 100, //bar will move fast!
duration: 5000,
increment: 15,
scope: this,
fn: function(){
Ext.fly('status').update('Done!');
}
});
//Or update indefinitely until some async action completes, then reset manually
p.wait();
myAction.on('complete', function(){
p.reset();
Ext.fly('status').update('Done!');
});</code></pre>(optional) Configuration optionsReturns true if the progress bar is currently in a <a ext:cls="Ext.ProgressBar" ext:member="wait" href="output/Ext.ProgressBar.html#wait">wait</a> operationUpdates the progress bar text. If specified, textEl will be updated, otherwise the progress
bar itself will display the updated text.(optional) The string to display in the progress text element (defaults to '')Sets the size of the progress bar.The new width in pixelsThe new height in pixelsResets the progress bar value to 0 and text to empty string. If hide = true, the progress
bar will also be hidden (using the <a ext:cls="Ext.ProgressBar" ext:member="hideMode" href="output/Ext.ProgressBar.html#hideMode">hideMode</a> property internally).(optional) True to hide the progress bar (defaults to false)A specialized tooltip class for tooltips that can be specified in markup and automatically managed by the global
<a ext:cls="Ext.QuickTips" href="output/Ext.QuickTips.html">Ext.QuickTips</a> instance.Create a new TipThe configuration optionsConfigures a new quick tip instance and assigns it to a target element. The following config options
are supported:
<pre>Property Type Description
---------- --------------------- ------------------------------------------------------------------------
target Element/String/Array An Element, id or array of ids that this quick tip should be tied to</pre>The config objectRemoves this quick tip from its element and destroys it.The element from which the quick tip is to be removed.The global QuickTips instance that reads quick tip configs from existing markup and manages quick tips.<br><br><i>This class is a singleton and cannot be created directly.</i>Initialize the global QuickTips instance and prepare any quick tips.Enable quick tips globally.Disable quick tips globally.Returns true if quick tips are enabled, else false.<p>Applies drag handles to an element to make it resizable. The drag handles are inserted into the element
and positioned absolute. Some elements, such as a textarea or image, don't support this. To overcome that, you can wrap
the textarea in a div and set "resizeChild" to true (or to the id of the element), <b>or</b> set wrap:true in your config and
the element will be wrapped for you automatically.</p>
<p>Here is the list of valid resize handles:</p>
<pre>Value Description
------ -------------------
'n' north
's' south
'e' east
'w' west
'nw' northwest
'sw' southwest
'se' southeast
'ne' northeast
'all' all</pre>
<p>Here's an example showing the creation of a typical Resizable:</p>
<pre><code>var resizer = new Ext.Resizable("element-id", {
handles: 'all',
minWidth: 200,
minHeight: 100,
maxWidth: 500,
maxHeight: 400,
pinned: true
});
resizer.on("resize", myHandler);</code></pre>
<p>To hide a particular handle, set its display to none in CSS, or through script:<br>
resizer.east.setDisplayed(false);</p>Create a new resizable componentThe id or element to resizeconfiguration options
Perform a manual resizeSimple class that can provide a shadow effect for any element. Note that the element MUST be absolutely positioned,
and the shadow does not provide any shimming. This should be used only in simple cases -- for more advanced
functionality that can also provide the same shadow effect, see the <a ext:cls="Ext.Layer" href="output/Ext.Layer.html">Ext.Layer</a> class.Create a new ShadowThe config objectDisplays the shadow under the target elementThe id or element under which the shadow should displayReturns true if the shadow is visible, else falseDirect alignment when values are already available. Show must be called at least once before
calling this method to ensure it is initialized.The target element left positionThe target element top positionThe target element widthThe target element heightHides this shadowAdjust the z-index of this shadowThe new z-indexCreates draggable splitter bar functionality from two elements (element to be dragged and element to be resized).
<br><br>
Usage:
<pre><code>var split = new Ext.SplitBar("elementToDrag", "elementToSize",
Ext.SplitBar.HORIZONTAL, Ext.SplitBar.LEFT);
split.setAdapter(new Ext.SplitBar.AbsoluteLayoutAdapter("container"));
split.minSize = 100;
split.maxSize = 600;
split.animate = true;
split.on('moved', splitterMoved);</code></pre>Create a new SplitBarThe element to be dragged and act as the SplitBar.The element to be resized based on where the SplitBar element is dragged(optional) Either Ext.SplitBar.HORIZONTAL or Ext.SplitBar.VERTICAL. (Defaults to HORIZONTAL)(optional) Either Ext.SplitBar.LEFT or Ext.SplitBar.RIGHT for horizontal or
Ext.SplitBar.TOP or Ext.SplitBar.BOTTOM for vertical. (By default, this is determined automatically by the initial
position of the SplitBar).The minimum size of the resizing element. (Defaults to 0)The maximum size of the resizing element. (Defaults to 2000)Whether to animate the transition to the new sizeWhether to create a transparent shim that overlays the page when dragging, enables dragging across iframes.Get the adapter this SplitBar usesSet the adapter this SplitBar usesA SplitBar adapter objectGets the minimum size for the resizing elementSets the minimum size for the resizing elementThe minimum sizeGets the maximum size for the resizing elementSets the maximum size for the resizing elementThe maximum sizeSets the initialize size for the resizing elementThe initial sizeDestroy this splitbar.True to remove the elementAdapter that moves the splitter element to align with the resized sizing element.
Used with an absolute positioned SplitBar.<static> Orientation constant - Create a vertical SplitBar<static> Orientation constant - Create a horizontal SplitBar<static> Placement constant - The resizing element is to the left of the splitter element<static> Placement constant - The resizing element is to the right of the splitter element<static> Placement constant - The resizing element is positioned above the splitter element<static> Placement constant - The resizing element is positioned under splitter elementDefault Adapter. It assumes the splitter and resizing element are not positioned
elements and only gets/sets the width of the element. Generally used for table based layouts.Called before drag operations to get the current size of the resizing element.The SplitBar using this adapterCalled after drag operations to set the size of the resizing element.The SplitBar using this adapterThe new size to setA function to be invoked when resizing is completeA split button that provides a built-in dropdown arrow that can fire an event separately from the default
click event of the button. Typically this would be used to display a dropdown menu that provides additional
options to the primary button action, but any custom handler can provide the arrowclick implementation.Create a new menu buttonThe config objectSets this button's arrow click handlerThe function to call when the arrow is clicked(optional) Scope for the function passed aboveThe default global group of stores.<br><br><i>This class is a singleton and cannot be created directly.</i>Gets a registered Store by idThe id of the Store or a Store<p>A basic tab container. Tab panels can be used exactly like a standard <a ext:cls="Ext.Panel" href="output/Ext.Panel.html">Ext.Panel</a> for layout
purposes, but also have special support for containing child Panels that get automatically converted into tabs.</p>
<p>There is no actual tab class — each tab is simply an <a ext:cls="Ext.Panel" href="output/Ext.Panel.html">Ext.Panel</a>. However, when rendered in a
TabPanel, each child Panel can fire additional events that only exist for tabs and are not available to other
Panels. These are:</p>
<ul>
<li><b>activate</b>: Fires when this Panel becomes the active tab.
<div class="mdetail-params">
<strong style="font-weight: normal;">Listeners will be called with the following arguments:</strong>
<ul><li><code>tab</code> : Panel<div class="sub-desc">The tab that was activated</div></li></ul>
</div></li>
<li><b>deactivate</b>: Fires when this Panel that was the active tab becomes deactivated.
<div class="mdetail-params">
<strong style="font-weight: normal;">Listeners will be called with the following arguments:</strong>
<ul><li><code>tab</code> : Panel<div class="sub-desc">The tab that was deactivated</div></li></ul>
</div></li>
</ul>
<p>There are several methods available for creating TabPanels. The output of the following examples should be
exactly the same. The tabs can be created and rendered completely in code, as in this example:</p>
<pre><code>
var tabs = new Ext.TabPanel({
renderTo: Ext.getBody(),
activeTab: 0,
items: [{
title: 'Tab 1',
html: 'A simple tab'
},{
title: 'Tab 2',
html: 'Another one'
}]
});</pre></code>
<p>TabPanels can also be rendered from markup in a couple of ways. See the <a ext:cls="Ext.TabPanel" ext:member="autoTabs" href="output/Ext.TabPanel.html#autoTabs">autoTabs</a> example for
rendering entirely from markup that is already structured correctly as a TabPanel (a container div with
one or more nested tab divs with class 'x-tab'). You can also render from markup that is not strictly
structured by simply specifying by id which elements should be the container and the tabs. Using this method,
tab content can be pulled from different elements within the page by id regardless of page structure. Note
that the tab divs in this example contain the class 'x-hide-display' so that they can be rendered deferred
without displaying outside the tabs. You could alternately set <a ext:cls="Ext.TabPanel" ext:member="deferredRender" href="output/Ext.TabPanel.html#deferredRender">deferredRender</a> to false to render all
content tabs on page load. For example:
<pre><code>
var tabs = new Ext.TabPanel({
renderTo: 'my-tabs',
activeTab: 0,
items:[
{contentEl:'tab1', title:'Tab 1'},
{contentEl:'tab2', title:'Tab 2'}
]
});
// Note that the tabs do not have to be nested within the container (although they can be)
<div id="my-tabs"></div>
<div id="tab1" class="x-hide-display">A simple tab</div>
<div id="tab2" class="x-hide-display">Another one</div></pre></code>The configuration optionsTrue to scan the markup in this tab panel for autoTabs using the autoTabSelectorTrue to remove existing tabsGets the DOM element for a specified tab.The tabSuspends any internal calculations or scrolling while doing a bulk operation. See <a ext:cls="Ext.TabPanel" ext:member="endUpdate" href="output/Ext.TabPanel.html#endUpdate">endUpdate</a>Resumes calculations and scrolling at the end of a bulk operation. See <a ext:cls="Ext.TabPanel" ext:member="beginUpdate" href="output/Ext.TabPanel.html#beginUpdate">beginUpdate</a>Hides the tab strip item for the passed tabThe tab index, id or itemUnhides the tab strip item for the passed tabThe tab index, id or itemSets the specified tab as the active tab. This method fires the <a ext:cls="Ext.TabPanel" ext:member="beforetabchange" href="output/Ext.TabPanel.html#beforetabchange">beforetabchange</a> event which
can return false to cancel the tab change.The id or tab Panel to activateGets the currently active tab.Gets the specified tab by id.The tab idScrolls to a particular tab if tab scrolling is enabledThe item to scroll toTrue to enable animationsSets the specified tab as the active tab. This method fires the <a ext:cls="Ext.TabPanel" ext:member="beforetabchange" href="output/Ext.TabPanel.html#beforetabchange">beforetabchange</a> event which
can return false to cancel the tab change.The id or tab Panel to activateA static <a ext:cls="Ext.util.TaskRunner" href="output/Ext.util.TaskRunner.html">Ext.util.TaskRunner</a> instance that can be used to start and stop arbitrary tasks. See
<a ext:cls="Ext.util.TaskRunner" href="output/Ext.util.TaskRunner.html">Ext.util.TaskRunner</a> for supported methods and task config properties.
<pre><code>// Start a simple clock task that updates a div once per second
var task = {
run: function(){
Ext.fly('clock').update(new Date().format('g:i:s A'));
},
interval: 1000 //1 second
}
Ext.TaskMgr.start(task);</code></pre><br><br><i>This class is a singleton and cannot be created directly.</i>Represents an HTML fragment template. Templates can be precompiled for greater performance.
For a list of available format functions, see <a ext:cls="Ext.util.Format" href="output/Ext.util.Format.html">Ext.util.Format</a>.<br />
Usage:
<pre><code>var t = new Ext.Template(
'<div name="{id}">',
'<span class="{cls}">{name:trim} {value:ellipsis(10)}</span>',
'</div>'
);
t.append('some-element', {id: 'myid', cls: 'myclass', name: 'foo', value: 'bar'});</code></pre>
For more information see this blog post with examples: <a href="http://www.jackslocum.com/blog/2006/10/06/domhelper-create-elements-using-dom-html-fragments-or-templates/">DomHelper - Create Elements using DOM, HTML fragments and Templates</a>.The HTML fragment or an array of fragments to join("") or multiple arguments to join("")True to disable format functions (defaults to false)The regular expression used to match template variablesReturns an HTML fragment of this template with the specified values applied.The template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})Sets the HTML used as the template and optionally compiles it.(optional) True to compile the template (defaults to undefined)Compiles the template into an internal function, eliminating the RegEx overhead.Applies the supplied values to the template and inserts the new node(s) as the first child of el.The context elementThe template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})(optional) true to return a Ext.Element (defaults to undefined)Applies the supplied values to the template and inserts the new node(s) before el.The context elementThe template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})(optional) true to return a Ext.Element (defaults to undefined)Applies the supplied values to the template and inserts the new node(s) after el.The context elementThe template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})(optional) true to return a Ext.Element (defaults to undefined)Applies the supplied values to the template and appends the new node(s) to el.The context elementThe template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})(optional) true to return a Ext.Element (defaults to undefined)Applies the supplied values to the template and overwrites the content of el with the new node(s).The context elementThe template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})(optional) true to return a Ext.Element (defaults to undefined)Alias for <a ext:cls="Ext.Template" ext:member="applyTemplate" href="output/Ext.Template.html#applyTemplate">applyTemplate</a><static> Creates a template from the passed element's value (<i>display:none</i> textarea, preferred) or innerHTML.A DOM element or its idA configuration objectThis is the base class for <a ext:cls="Ext.QuickTip" href="output/Ext.QuickTip.html">Ext.QuickTip</a> and <a ext:cls="Ext.Tooltip" href="output/Ext.Tooltip.html">Ext.Tooltip</a> that provides the basic layout and
positioning that all tip-based classes require. This class can be used directly for simple, statically-positioned
tips that are displayed programmatically, or it can be extended to provide custom tip implementations.Create a new TipThe configuration optionsShows this tip at the specified XY position. Example usage:
<pre><code>// Show the tip at x:50 and y:100
tip.showAt([50,100]);</code></pre>An array containing the x and y coordinatesShows this tip at a position relative to another element using a standard <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">Ext.Element.alignTo</a>
anchor position value. Example usage:
<pre><code>// Show the tip at the default position ('tl-br?')
tip.showBy('my-el');
// Show the tip's top-left corner anchored to the element's top-right corner
tip.showBy('my-el', 'tl-tr');</code></pre>An HTMLElement, Ext.Element or string id of the target element to align to(optional) A valid <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">Ext.Element.alignTo</a> anchor position (defaults to 'tl-br?')A standard tooltip implementation for providing additional information when hovering over a target element.Create a new TooltipThe configuration optionsHides this tooltip if visible.Shows this tooltip at the current event target XY position.Basic Toolbar class.Creates a new ToolbarA config object or an array of buttons to addAdds element(s) to the toolbar -- this function takes a variable number of
arguments of mixed type and adds them to the toolbar.The following types of arguments are all valid:<br />
<ul>
<li><a ext:cls="Ext.Toolbar.Button" href="output/Ext.Toolbar.Button.html">Ext.Toolbar.Button</a> config: A valid button config object (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addButton" href="output/Ext.Toolbar.html#addButton">addButton</a>)</li>
<li>HtmlElement: Any standard HTML element (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addElement" href="output/Ext.Toolbar.html#addElement">addElement</a>)</li>
<li>Field: Any form field (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addField" href="output/Ext.Toolbar.html#addField">addField</a>)</li>
<li>Item: Any subclass of <a ext:cls="Ext.Toolbar.Item" href="output/Ext.Toolbar.Item.html">Ext.Toolbar.Item</a> (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addItem" href="output/Ext.Toolbar.html#addItem">addItem</a>)</li>
<li>String: Any generic string (gets wrapped in a <a ext:cls="Ext.Toolbar.TextItem" href="output/Ext.Toolbar.TextItem.html">Ext.Toolbar.TextItem</a>, equivalent to <a ext:cls="Ext.Toolbar" ext:member="addText" href="output/Ext.Toolbar.html#addText">addText</a>).
Note that there are a few special strings that are treated differently as explained next.</li>
<li>'separator' or '-': Creates a separator element (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addSeparator" href="output/Ext.Toolbar.html#addSeparator">addSeparator</a>)</li>
<li>' ': Creates a spacer element (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addSpacer" href="output/Ext.Toolbar.html#addSpacer">addSpacer</a>)</li>
<li>'->': Creates a fill element (equivalent to <a ext:cls="Ext.Toolbar" ext:member="addFill" href="output/Ext.Toolbar.html#addFill">addFill</a>)</li>
</ul>Adds a separatorAdds a spacer elementAdds a fill element that forces subsequent additions to the right side of the toolbarAdds any standard HTML element to the toolbarThe element or id of the element to addAdds any Toolbar.Item or subclassAdds a button (or buttons). See <a ext:cls="Ext.Toolbar.Button" href="output/Ext.Toolbar.Button.html">Ext.Toolbar.Button</a> for more info on the config.A button config or array of configsAdds text to the toolbarThe text to addInserts any <a ext:cls="Ext.Toolbar.Item" href="output/Ext.Toolbar.Item.html">Ext.Toolbar.Item</a>/<a ext:cls="Ext.Toolbar.Button" href="output/Ext.Toolbar.Button.html">Ext.Toolbar.Button</a> at the specified index.The index where the item is to be insertedbe Array)} item The button, or button config object to be inserted.Adds a new element to the toolbar from the passed <a ext:cls="Ext.DomHelper" href="output/Ext.DomHelper.html">Ext.DomHelper</a> configAdds a dynamically rendered Ext.form field (TextField, ComboBox, etc). Note: the field should not have
been rendered yet. For a field that has already been rendered, use <a ext:cls="Ext.Toolbar" ext:member="addElement" href="output/Ext.Toolbar.html#addElement">addElement</a>.A button that renders into a toolbar.Creates a new ButtonA standard <a ext:cls="Ext.Button" href="output/Ext.Button.html">Ext.Button</a> config objectA simple element that adds a greedy (100% width) horizontal space to a toolbar.Creates a new SpacerThe base class that other classes should extend in order to get some basic common toolbar item functionality.Creates a new ItemGet this item's HTML ElementRemoves and destroys this item.Shows this item.Hides this item.Convenience function for boolean show/hide.true to show/false to hideTry to focus this itemDisables this item.Enables this item.A simple toolbar separator classCreates a new SeparatorA simple element that adds extra horizontal space to a toolbar.Creates a new SpacerA menu button that renders into a toolbar.Creates a new SplitButtonA standard <a ext:cls="Ext.SplitButton" href="output/Ext.SplitButton.html">Ext.SplitButton</a> config objectA simple class that renders text directly into a toolbar.Creates a new TextItemProvides AJAX-style update for Element object.<br><br>
Usage:<br>
<pre><code>// Get it from a Ext.Element object
var el = Ext.get("foo");
var mgr = el.getUpdater();
mgr.update("http://myserver.com/index.php", "param1=1&param2=2");
...
mgr.formUpdate("myFormId", "http://myserver.com/index.php");
<br>
// or directly (returns the same Updater instance)
var mgr = new Ext.Updater("myElementId");
mgr.startAutoRefresh(60, "http://myserver.com/index.php");
mgr.on("update", myFcnNeedsToKnow);
<br>
// short handed call directly from the element object
Ext.get("foo").load({
url: "bar.php",
scripts:true,
params: "for=bar",
text: "Loading Foo..."
});</code></pre>Create new Updater directly.The element to update(optional) By default the constructor checks to see if the passed element already has an Updater and if it does it returns the same instance. This will skip that check (useful for extending this class).The Element objectCached url to use for refreshes. Overwritten every time update() is called unless "discardUrl" param is set to true.Blank page URL to use with SSL file uploads (Defaults to Ext.Updater.defaults.sslBlankUrl or "about:blank").Whether to append unique parameter on get request to disable caching (Defaults to Ext.Updater.defaults.disableCaching or false).Text for loading indicator (Defaults to Ext.Updater.defaults.indicatorText or '<div class="loading-indicator">Loading...</div>').Whether to show indicatorText when loading (Defaults to Ext.Updater.defaults.showLoadIndicator or true).Timeout for requests or form posts in seconds (Defaults to Ext.Updater.defaults.timeout or 30 seconds).True to process scripts in the output (Defaults to Ext.Updater.defaults.loadScripts (false)).Transaction object of current executing transactionDelegate for refresh() prebound to "this", use myUpdater.refreshDelegate.createCallback(arg1, arg2) to bind argumentsDelegate for update() prebound to "this", use myUpdater.updateDelegate.createCallback(arg1, arg2) to bind argumentsDelegate for formUpdate() prebound to "this", use myUpdater.formUpdateDelegate.createCallback(arg1, arg2) to bind argumentsThe renderer for this Updater. Defaults to <a ext:cls="Ext.Updater.BasicRenderer" href="output/Ext.Updater.BasicRenderer.html">Ext.Updater.BasicRenderer</a>.Get the Element this Updater is bound toPerforms an <b>asynchronous</b> request, updating this element with the response.
If params are specified it uses POST, otherwise it uses GET.<br>
<p>
<b>NB:</b> Due to the asynchronous nature of remote server requests, the returned data will
not be available to the line immediately following the load() call. To process the returned
data, use the callback option, or an {@link #event-update update} event handler.The url for this request or a function to call to get the url or a config object containing any of the following options:
<pre><code>um.update({
url: "your-url.php",
params: {param1: "foo", param2: "bar"}, // or a URL encoded string
callback: yourFunction,
scope: yourObject, //(optional scope)
discardUrl: false,
nocache: false,
text: "Loading...",
timeout: 30,
scripts: false
});</code></pre>
The only required property is url. The optional properties nocache, text and scripts
are shorthand for disableCaching, indicatorText and loadScripts and are used to set their associated property on this Updater instance.(optional) The parameters to pass as either a url encoded string "param1=1&param2=2" or an object {param1: 1, param2: 2}(optional) Callback when transaction is complete - called with signature (oElement, bSuccess, oResponse)(optional) By default when you execute an update the defaultUrl is changed to the last used url. If true, it will not store the url.Performs an async form post, updating this element with the response. If the form has the attribute enctype="multipart/form-data", it assumes it's a file upload.
Uses this.sslBlankUrl for SSL file uploads to prevent IE security warning.The form Id or form element(optional) The url to pass the form to. If omitted the action attribute on the form will be used.(optional) Whether to try to reset the form after the update(optional) Callback when transaction is complete - called with signature (oElement, bSuccess, oResponse)Refresh the element with the last used url or defaultUrl. If there is no url, it returns immediately(optional) Callback when transaction is complete - called with signature (oElement, bSuccess)Set this element to auto refresh.How often to update (in seconds).(optional) The url for this request or a function to call to get the url (Defaults to the last used url)(optional) The parameters to pass as either a url encoded string "¶m1=1¶m2=2" or as an object {param1: 1, param2: 2}(optional) Callback when transaction is complete - called with signature (oElement, bSuccess)(optional) Whether to execute the refresh now, or wait the intervalStop auto refresh on this element.Called to update the element to "Loading" state. Override to perform custom action.Set the content renderer for this Updater. See <a ext:cls="Ext.Updater.BasicRenderer" ext:member="render" href="output/Ext.Updater.BasicRenderer.html#render">Ext.Updater.BasicRenderer.render</a> for more details.The object implementing the render() methodSet the defaultUrl used for updatesThe url or a function to call to get the urlAborts the executing transactionReturns true if an update is in progress<b>Deprecated.</b> <static> Static convenience method. This method is deprecated in favor of el.load({url:'foo.php', ...}).
Usage:
<pre><code>Ext.Updater.updateElement("my-div", "stuff.php");</code></pre>The element to updateThe url(optional) Url encoded param string or an object of name/value pairs(optional) A config object with any of the Updater properties you want to set - for example: {disableCaching:true, indicatorText: "Loading data..."}Default Content renderer. Updates the elements innerHTML with the responseText.This is called when the transaction is completed and it's time to update the element - The BasicRenderer
updates the elements innerHTML with the responseText - To perform a custom render (i.e. XML or JSON processing),
create an object with a "render(el, response)" method and pass it to setRenderer on the Updater.The element being renderedThe XMLHttpRequest objectThe calling update managerA callback that will need to be called if loadScripts is true on the UpdaterThe defaults collection enables customizing the default properties of UpdaterTimeout for requests or form posts in seconds (Defaults 30 seconds).True to process scripts by default (Defaults to false).Blank page URL to use with SSL file uploads (Defaults to "javascript:false").Whether to append unique parameter on get request to disable caching (Defaults to false).Whether to show indicatorText when loading (Defaults to true).Text for loading indicator (Defaults to '<div class="loading-indicator">Loading...</div>').A specialized container representing the viewable application area (the browser viewport). It automatically
sizes itself to the size of the browser viewport and manages window resizing. The Viewport does not provide
scrolling, so layout elements within the Viewport should provide for scrolling if needed.Create a new ViewportThe config objectA specialized panel intended for use as an application window. Windows are floated and draggable by default, and
also provide specific behavior like the ability to maximize and restore (with an event for minimizing, since the
minimize behavior is application-specific). Windows can also be linked to a <a ext:cls="Ext.WindowGroup" href="output/Ext.WindowGroup.html">Ext.WindowGroup</a> or managed
by the <a ext:cls="Ext.WindowManager" href="output/Ext.WindowManager.html">Ext.WindowManager</a> to provide grouping, activation, to front/back and other application-specific behavior.The config objectFocuses the window. If a defaultButton is set, it will receive focus, otherwise the
window itself will receive focus.Sets the target element from which the window should animate while opening.The target element or idShows the window, rendering it first if necessary, or activates it and brings it to front if hidden.(optional) The target element or id from which the window should
animate while opening (defaults to null with no animation)(optional) A callback function to call after the window is displayed(optional) The scope in which to execute the callbackHides the window, setting it to invisible and applying negative offsets.(optional) The target element or id to which the window should
animate while hiding (defaults to null with no animation)(optional) A callback function to call after the window is hidden(optional) The scope in which to execute the callbackPlaceholder method for minimizing the window. By default, this method simply fires the minimize event
since the behavior of minimizing a window is application-specific. To implement custom minimize behavior,
either the minimize event can be handled or this method can be overridden.Closes the window, removes it from the DOM and destroys the window object. The beforeclose event is fired
before the close happens and will cancel the close action if it returns false.Fits the window within its current container and automatically replaces the 'maximize' tool button with
the 'restore' tool button.Restores a maximized window back to its original size and position prior to being maximized and also replaces
the 'restore' tool button with the 'maximize' tool button.A shortcut method for toggling between <a ext:cls="Ext.Window" ext:member="maximize" href="output/Ext.Window.html#maximize">maximize</a> and <a ext:cls="Ext.Window" ext:member="restore" href="output/Ext.Window.html#restore">restore</a> based on the current maximized
state of the window.Aligns the window to the specified elementThe element to align to.The position to align to (see <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">Ext.Element.alignTo</a> for more details).(optional) Offset the positioning by [x, y]Anchors this window to another element and realigns it when the window is resized or scrolled.The element to align to.The position to align to (see <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">Ext.Element.alignTo</a> for more details)(optional) Offset the positioning by [x, y](optional) true to monitor body scroll and reposition. If this parameter
is a number, it is used as the buffer delay (defaults to 50ms).Brings this window to the front of any other visible windowsMakes this the active window by showing its shadow, or deactivates it by hiding its shadow. This method also
fires the activate or deactivate event depending on which action occurred.True to activate the window, false to deactivate it (defaults to false)Sends this window to the back of (lower z-index than) any other visible windowsCenters this window in the viewportAn object that represents a grouop of <a ext:cls="Ext.Window" href="output/Ext.Window.html">Ext.Window</a> instances and provides z-order management
and window activation behavior.The starting z-index for windows (defaults to 9000)Gets a registered window by id.The id of the window or a <a ext:cls="Ext.Window" href="output/Ext.Window.html">Ext.Window</a> instanceBrings the specified window to the front of any other active windows.The id of the window or a <a ext:cls="Ext.Window" href="output/Ext.Window.html">Ext.Window</a> instanceSends the specified window to the back of other active windows.The id of the window or a <a ext:cls="Ext.Window" href="output/Ext.Window.html">Ext.Window</a> instanceHides all windows in the group.Gets the currently-active window in the group.Returns zero or more windows in the group using the custom search function passed to this method.
The function should accept a single <a ext:cls="Ext.Window" href="output/Ext.Window.html">Ext.Window</a> reference as its only argument and should
return true if the window matches the search criteria, otherwise it should return false.The search function(optional) The scope in which to execute the function (defaults to the window
that gets passed to the function if not specified)Executes the specified function once for every window in the group, passing each
window as the only parameter. Returning false from the function will stop the iteration.The function to execute for each item(optional) The scope in which to execute the functionThe default global window group that is available automatically. To have more than one group of windows
with separate z-order stacks, create additional instances of <a ext:cls="Ext.WindowGroup" href="output/Ext.WindowGroup.html">Ext.WindowGroup</a> as needed.<br><br><i>This class is a singleton and cannot be created directly.</i>A template class that supports advanced functionality like autofilling arrays, conditional processing with
basic comparison operators, sub-templates, basic math function support, special built-in template variables,
inline code execution and more.The HTML fragment or an array of fragments to join("") or multiple arguments to join("")Alias of <a ext:cls="Ext.XTemplate" ext:member="applyTemplate" href="output/Ext.XTemplate.html#applyTemplate">applyTemplate</a>.Returns an HTML fragment of this template with the specified values applied.The template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})Compile the template to a function for optimized performance. Recommended if the template will be used frequently.<static> Creates a template from the passed element's value (<i>display:none</i> textarea, preferred) or innerHTML.A DOM element or its idData reader class to create an Array of Ext.data.Record 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 <em>mapping</em> property
of the field definition if it exists, or the field's ordinal position in the definition.<br>
<p>
Example code:.
<pre><code>var Employee = Ext.data.Record.create([
{name: 'name', mapping: 1}, // "mapping" only needed if an "id" field is present which
{name: 'occupation', mapping: 2} // precludes using the ordinal position as the index.
]);
var myReader = new Ext.data.ArrayReader({
id: 0 // The subscript within row Array that provides an ID for the Record (optional)
}, Employee);</code></pre>
<p>
This would consume an Array like this:
<pre><code>[ [1, 'Bill', 'Gardener'], [2, 'Ben', 'Horticulturalist'] ]</code></pre>Create a new ArrayReaderMetadata configuration options.Either an Array of field definition objects
as specified to <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">Ext.data.Record.create</a>,
or an <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> object
created using <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">Ext.data.Record.create</a>.Create a data block containing Ext.data.Records from an XML document.An Array of row objects which represents the dataset.The 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.<br><br>
<p>
Requests made by this class are asynchronous, and will return immediately. No data from
the server will be available to the statement immediately following the <a ext:cls="Ext.data.Connection" ext:member="request" href="output/Ext.data.Connection.html#request">request</a> call.
To process returned data, use a callback in the request options object, or an event listener.</p><br>
<p>
Note: If you are doing a file upload, you will not get a normal response object sent back to
your callback or event handler. Since the upload is handled via in IFRAME, there is no XMLHttpRequest.
The response object is created using the innerHTML of the IFRAME's document as the responseText
property and, if present, the IFRAME's XML document as the responseXML property.</p><br>
This means that a valid XML or HTML document must be returned. If JSON data is required, it is suggested
that it be placed either inside a <textarea> in an HTML document and retrieved from the responseText
using a regex, or inside a CDATA section in an XML document and retrieved from the responseXML using
standard DOM methods.a configuration object.Sends an HTTP request to a remote server.An object which may contain the following properties:<ul>
<li><b>url</b> {String} (Optional) The URL to which to send the request. Defaults to configured URL</li>
<li><b>params</b> {Object/String/Function} (Optional) An object containing properties which are used as parameters to the
request, a url encoded string or a function to call to get either.</li>
<li><b>method</b> {String} (Optional) The HTTP method to use for the request. Defaults to the configured method, or
if no method was configured, "GET" if no parameters are being sent, and "POST" if parameters are being sent.</li>
<li><b>callback</b> {Function} (Optional) The function to be called upon receipt of the HTTP response.
The callback is called regardless of success or failure and is passed the following parameters:<ul>
<li>options {Object} The parameter to the request call.</li>
<li>success {Boolean} True if the request succeeded.</li>
<li>response {Object} The XMLHttpRequest object containing the response data.</li>
</ul></li>
<li><b>success</b> {Function} (Optional) The function to be called upon success of the request.
The callback is passed the following parameters:<ul>
<li>response {Object} The XMLHttpRequest object containing the response data.</li>
<li>options {Object} The parameter to the request call.</li>
</ul></li>
<li><b>failure</b> {Function} (Optional) The function to be called upon failure of the request.
The callback is passed the following parameters:<ul>
<li>response {Object} The XMLHttpRequest object containing the response data.</li>
<li>options {Object} The parameter to the request call.</li>
</ul></li>
<li><b>scope</b> {Object} (Optional) The scope in which to execute the callbacks: The "this" object
for the callback function. Defaults to the browser window.</li>
<li><b>form</b> {Object/String} (Optional) A form object or id to pull parameters from.</li>
<li><b>isUpload</b> {Boolean} (Optional) True if the form object is a file upload (will usually be automatically detected).</li>
<li><b>headers</b> {Object} (Optional) Request headers to set for the request.</li>
<li><b>xmlData</b> {Object} (Optional) XML document to use for the post. Note: This will be used instead of
params for the post data. Any params will be appended to the URL.</li>
<li><b>disableCaching</b> {Boolean} (Optional) True to add a unique cache-buster param to GET requests.</li>
</ul>Determine whether this object has a request outstanding.(Optional) defaults to the last transactionAborts any outstanding request.(Optional) defaults to the last transactionThis class is an abstract base class for implementations which provide retrieval of
unformatted data objects.<br>
<p>
DataProxy implementations are usually used in conjunction with an implementation of Ext.data.DataReader
(of the appropriate type which knows how to parse the data object) to provide a block of
<a ext:cls="Ext.data.Records" href="output/Ext.data.Records.html">Ext.data.Records</a> to an <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>.<br>
<p>
Custom implementations must implement the load method as described in
<a ext:cls="Ext.data.HttpProxy" ext:member="load" href="output/Ext.data.HttpProxy.html#load">Ext.data.HttpProxy.load</a>.Abstract base class for reading structured data from a data source and converting
it into an object containing <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> objects and metadata for use
by an <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>. This class is intended to be extended and should not
be created directly. For existing implementations, see <a ext:cls="Ext.data.ArrayReader" href="output/Ext.data.ArrayReader.html">Ext.data.ArrayReader</a>,
<a ext:cls="Ext.data.JsonReader" href="output/Ext.data.JsonReader.html">Ext.data.JsonReader</a> and <a ext:cls="Ext.data.XmlReader" href="output/Ext.data.XmlReader.html">Ext.data.XmlReader</a>.Create a new DataReaderMetadata configuration options (implementation-specific)Either an Array of field definition objects as specified
in <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">Ext.data.Record.create</a>, or an <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> object created
using <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">Ext.data.Record.create</a>.A specialized store implementation that provides for grouping records by one of the available fields.Creates a new GroupingStore.A config object containing the objects needed for the Store to access data,
and read the data into Records.Clears any existing grouping and refreshes the data using the default sort.Groups the data by the specified field.The field name by which to sort the store's data(optional) True to force the group to be refreshed even if the field passed
in is the same as the current grouping field, false to skip grouping on the same field (defaults to false)An implementation of <a ext:cls="Ext.data.DataProxy" href="output/Ext.data.DataProxy.html">Ext.data.DataProxy</a> that reads a data object from an <a ext:cls="Ext.data.Connection" href="output/Ext.data.Connection.html">Ext.data.Connection</a> object
configured to reference a certain URL.<br><br>
<p>
<em>Note that this class cannot be used to retrieve data from a domain other than the domain
from which the running page was served.<br><br>
<p>
For cross-domain access to remote data, use an <a ext:cls="Ext.data.ScriptTagProxy" href="output/Ext.data.ScriptTagProxy.html">Ext.data.ScriptTagProxy</a>.</em><br><br>
<p>
Be aware that to enable the browser to parse an XML document, the server must set
the Content-Type header in the HTTP response to "text/xml".Connection config options to add to each request (e.g. {url: 'foo.php'} or
an <a ext:cls="Ext.data.Connection" href="output/Ext.data.Connection.html">Ext.data.Connection</a> object. If a Connection config is passed, the singleton <a ext:cls="Ext.Ajax" href="output/Ext.Ajax.html">Ext.Ajax</a> object
will be used to make the request.Return the <a ext:cls="Ext.data.Connection" href="output/Ext.data.Connection.html">Ext.data.Connection</a> object being used by this Proxy.Load data from the configured <a ext:cls="Ext.data.Connection" href="output/Ext.data.Connection.html">Ext.data.Connection</a>, read the data object into
a block of Ext.data.Records using the passed <a ext:cls="Ext.data.DataReader" href="output/Ext.data.DataReader.html">Ext.data.DataReader</a> implementation, and
process that block using the passed callback.An object containing properties which are to be used as HTTP parameters
for the request to the remote server.The Reader object which converts the data
object into a block of Ext.data.Records.The function into which to pass the block of Ext.data.Records.
The function must be passed <ul>
<li>The Record block object</li>
<li>The "arg" argument from the load function</li>
<li>A boolean success indicator</li>
</ul>The scope in which to call the callbackAn optional argument which is passed to the callback as its second parameter.Data reader class to create an Array of Ext.data.Record objects from a JSON response
based on mappings in a provided Ext.data.Record constructor.<br>
<p>
Example code:
<pre><code>var Employee = Ext.data.Record.create([
{name: 'name', mapping: 'name'}, // "mapping" property not needed if it's the same as "name"
{name: 'occupation'} // This field will use "occupation" as the mapping.
]);
var myReader = new Ext.data.JsonReader({
totalProperty: "results", // The property which contains the total dataset size (optional)
root: "rows", // The property which contains an Array of row objects
id: "id" // The property within each row object that provides an ID for the record (optional)
}, Employee);</code></pre>
<p>
This would consume a JSON file like this:
<pre><code>{ 'results': 2, 'rows': [
{ 'id': 1, 'name': 'Bill', occupation: 'Gardener' },
{ 'id': 2, 'name': 'Ben', occupation: 'Horticulturalist' } ]
}</code></pre>Create a new JsonReaderMetadata configuration optionsEither an Array of field definition objects,
or an <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> object created using <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">Ext.data.Record.create</a>.After any data loads, the raw JSON data is available for further custom processing. If no data is
loaded or there is a load exception this property will be undefined.This method is only used by a DataProxy which has retrieved data from a remote server.The XHR object which contains the JSON data in its responseText.Create a data block containing Ext.data.Records from an XML document.An object which contains an Array of row objects in the property specified
in the config as 'root, and optionally a property, specified in the config as 'totalProperty'
which contains the total size of the dataset.Small helper class to make creating Stores for JSON data easier. <br/>
<pre><code>var store = new Ext.data.JsonStore({
url: 'get-images.php',
root: 'images',
fields: ['name', 'url', {name:'size', type: 'float'}, {name:'lastmod', type:'date'}]
});</code></pre>
<b>Note: Although they are not listed, this class inherits all of the config options of Store,
JsonReader and HttpProxy (unless inline data is provided).</b>An implementation of Ext.data.DataProxy that simply passes the data specified in its constructor
to the Reader when its load method is called.The data object which the Reader uses to construct a block of Ext.data.Records.Load data from the requested source (in this case an in-memory
data object passed to the constructor), read the data object into
a block of Ext.data.Records using the passed Ext.data.DataReader implementation, and
process that block using the passed callback.This parameter is not used by the MemoryProxy class.The Reader object which converts the data
object into a block of Ext.data.Records.The function into which to pass the block of Ext.data.records.
The function must be passed <ul>
<li>The Record block object</li>
<li>The "arg" argument from the load function</li>
<li>A boolean success indicator</li>
</ul>The scope in which to call the callbackAn optional argument which is passed to the callback as its second parameter.The attributes/config for the nodeThe attributes supplied for the node. You can use this property to access any custom attributes you supplied.The node id.All child nodes of this node.The parent node for this node.The first direct child node of this node, or null if this node has no child nodes.The last direct child node of this node, or null if this node has no child nodes.The node immediately preceding this node in the tree, or null if there is no sibling node.The node immediately following this node in the tree, or null if there is no sibling node.Returns true if this node is a leafReturns true if this node is the last child of its parentReturns true if this node is the first child of its parentInsert node(s) as the last child node of this node.The node or Array of nodes to appendRemoves a child node from this node.The node to removeInserts the first node before the second node in this nodes childNodes collection.The node to insertThe node to insert before (if null the node is appended)Removes this node from it's parentReturns the child node at the specified index.Replaces one child node in this node with another.The replacement nodeThe node to replaceReturns the index of a child nodeReturns the tree this node is in.Returns depth of this node (the root node has a depth of 0)Returns the path for this node. The path can be used to expand or select this node programmatically.(optional) The attr to use for the path (defaults to the node's id)Bubbles up the tree from this node, calling the specified function with each node. The scope (<i>this</i>) of
function call will be the scope provided or the current node. The arguments to the function
will be the args provided or the current node. If the function returns false at any point,
the bubble is stopped.The function to call(optional) The scope of the function (defaults to current node)(optional) The args to call the function with (default to passing the current node)Cascades down the tree from this node, calling the specified function with each node. The scope (<i>this</i>) of
function call will be the scope provided or the current node. The arguments to the function
will be the args provided or the current node. If the function returns false at any point,
the cascade is stopped on that branch.The function to call(optional) The scope of the function (defaults to current node)(optional) The args to call the function with (default to passing the current node)Interates the child nodes of this node, calling the specified function with each node. The scope (<i>this</i>) of
function call will be the scope provided or the current node. The arguments to the function
will be the args provided or the current node. If the function returns false at any point,
the iteration stops.The function to call(optional) The scope of the function (defaults to current node)(optional) The args to call the function with (default to passing the current node)Finds the first child that has the attribute with the specified value.The attribute nameThe value to search forFinds the first child by a custom function. The child matches if the function passed
returns true.(optional)Sorts this nodes children using the supplied sort function(optional)Returns true if this node is an ancestor (at any point) of the passed node.Returns true if the passed node is an ancestor (at any point) of this node.Instances of this class encapsulate both record <em>definition</em> information, and record
<em>value</em> information for use in <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> objects, or any code which needs
to access Records cached in an <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> object.<br>
<p>
Constructors for this class are generated by passing an Array of field definition objects to <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">create</a>.
Instances are usually only created by <a ext:cls="Ext.data.Reader" href="output/Ext.data.Reader.html">Ext.data.Reader</a> implementations when processing unformatted data
objects.<br>
<p>
Record objects generated by this constructor inherit all the methods of Ext.data.Record listed below.This constructor should not be used to create Record objects. Instead, use the constructor generated by
<a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">create</a>. The parameters are the same.An associative Array of data values keyed by the field name.(Optional) The id of the record. This id should be unique, and is used by the
<a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> object which owns the Record to index its collection of Records. If
not specified an integer id is generated.The data for this record an object hash.
The unique ID of the record as specified at construction time.
Readonly flag - true if this record has been modified.This object contains a key and value storing the original values of all modified fields or is null if no fields have been modified.<static> Generate a constructor for a specific record layout.An Array of field definition objects which specify field names, and optionally,
data types, and a mapping for an <a ext:cls="Ext.data.Reader" href="output/Ext.data.Reader.html">Ext.data.Reader</a> to extract the field's value from a data object.
Each field definition object may contain the following properties: <ul>
<li><b>name</b> : String<p style="margin-left:1em">The name by which the field is referenced within the Record. This is referenced by,
for example the <em>dataIndex</em> property in column definition objects passed to <a ext:cls="Ext.grid.ColumnModel" href="output/Ext.grid.ColumnModel.html">Ext.grid.ColumnModel</a></p></li>
<li><b>mapping</b> : String<p style="margin-left:1em">(Optional) A path specification for use by the <a ext:cls="Ext.data.Reader" href="output/Ext.data.Reader.html">Ext.data.Reader</a> implementation
that is creating the Record to access the data value from the data object. If an <a ext:cls="Ext.data.JsonReader" href="output/Ext.data.JsonReader.html">Ext.data.JsonReader</a>
is being used, then this is a string containing the javascript expression to reference the data relative to
the record item's root. If an <a ext:cls="Ext.data.XmlReader" href="output/Ext.data.XmlReader.html">Ext.data.XmlReader</a> is being used, this is an <a ext:cls="Ext.DomQuery" href="output/Ext.DomQuery.html">Ext.DomQuery</a> path
to the data item relative to the record element. If the mapping expression is the same as the field name,
this may be omitted.</p></li>
<li><b>type</b> : String<p style="margin-left:1em">(Optional) The data type for conversion to displayable value. Possible values are
<ul><li>auto (Default, implies no conversion)</li>
<li>string</li>
<li>int</li>
<li>float</li>
<li>boolean</li>
<li>date</li></ul></p></li>
<li><b>sortType</b> : Mixed<p style="margin-left:1em">(Optional) A member of <a ext:cls="Ext.data.SortTypes" href="output/Ext.data.SortTypes.html">Ext.data.SortTypes</a>.</p></li>
<li><b>sortDir</b> : String<p style="margin-left:1em">(Optional) Initial direction to sort. "ASC" or "DESC"</p></li>
<li><b>convert</b> : Function<p style="margin-left:1em">(Optional) A function which converts the value provided
by the Reader into an object that will be stored in the Record. It is passed the
following parameters:<ul>
<li><b>v</b> : Mixed<p style="margin-left:1em">The data value as read by the Reader.</p></li>
</ul></p></li>
<li><b>dateFormat</b> : String<p style="margin-left:1em">(Optional) A format String for the Date.parseDate function.</p></li>
</ul>
<br>usage:<br><pre><code>var TopicRecord = Ext.data.Record.create(
{name: 'title', mapping: 'topic_title'},
{name: 'author', mapping: 'username'},
{name: 'totalPosts', mapping: 'topic_replies', type: 'int'},
{name: 'lastPost', mapping: 'post_time', type: 'date'},
{name: 'lastPoster', mapping: 'user2'},
{name: 'excerpt', mapping: 'post_text'}
);
var myNewRecord = new TopicRecord({
title: 'Do my job please',
author: 'noobie',
totalPosts: 1,
lastPost: new Date(),
lastPoster: 'Animal',
excerpt: 'No way dude!'
});
myStore.add(myNewRecord);</code></pre>Set the named field to the specified value.The name of the field to set.The value to set the field to.Get the value of the named field.The name of the field to get the value of.Begin an edit. While in edit mode, no events are relayed to the containing store.Cancels all changes made in the current edit operation.End an edit. If any data was modified, the containing store is notified.Usually called by the <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> which owns the Record.
Rejects all changes made to the Record since either creation, or the last commit operation.
Modified fields are reverted to their original values.
<p>
Developers should subscribe to the <a ext:cls="Ext.data.Store" ext:member="update" href="output/Ext.data.Store.html#update">Ext.data.Store.update</a> event to have their code notified
of reject operations.(optional) True to skip notification of the owning store of the change (defaults to false)Usually called by the <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> which owns the Record.
Commits all changes made to the Record since either creation, or the last commit operation.
<p>
Developers should subscribe to the <a ext:cls="Ext.data.Store" ext:member="update" href="output/Ext.data.Store.html#update">Ext.data.Store.update</a> event to have their code notified
of commit operations.(optional) True to skip notification of the owning store of the change (defaults to false)Gets a hash of only the fields that have been modified since this record was created or commited.Creates a copy of this record.(optional) A new record id if you don't want to use this record's idAn implementation of Ext.data.DataProxy that reads a data object from a URL which may be in a domain
other than the originating domain of the running page.<br><br>
<p>
<em>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 must use this class, rather than DataProxy.</em><br><br>
<p>
The content passed back from a server resource requested by a ScriptTagProxy is executable JavaScript
source code that is used as the source inside a <script> tag.<br><br>
<p>
In order for the browser to process the returned data, the server must wrap the data object
with a call to a callback function, the name of which is passed as a parameter by the ScriptTagProxy.
Below is a Java example for a servlet which returns data for either a ScriptTagProxy, or an HttpProxy
depending on whether the callback name was passed:
<p>
<pre><code>
boolean scriptTag = false;
String cb = request.getParameter("callback");
if (cb != null) {
scriptTag = true;
response.setContentType("text/javascript");
} else {
response.setContentType("application/x-json");
}
Writer out = response.getWriter();
if (scriptTag) {
out.write(cb + "(");
}
out.print(dataBlock.toJsonString());
if (scriptTag) {
out.write(");");
}</pre></code>A configuration object.Load data from the configured URL, read the data object into
a block of Ext.data.Records using the passed Ext.data.DataReader implementation, and
process that block using the passed callback.An object containing properties which are to be used as HTTP parameters
for the request to the remote server.The Reader object which converts the data
object into a block of Ext.data.Records.The function into which to pass the block of Ext.data.Records.
The function must be passed <ul>
<li>The Record block object</li>
<li>The "arg" argument from the load function</li>
<li>A boolean success indicator</li>
</ul>The scope in which to call the callbackAn optional argument which is passed to the callback as its second parameter.Abort the current server request.Small helper class to make creating Stores from Array data easier.<br><br><i>This class is a singleton and cannot be created directly.</i>The regular expression used to strip tagsDefault sort that does nothingThe value being convertedStrips all HTML tags to sort on text onlyThe value being convertedStrips all HTML tags to sort on text only - Case insensitiveThe value being convertedCase insensitive stringThe value being convertedDate sortingThe value being convertedFloat sortingThe value being convertedInteger sortingThe value being convertedThe Store class encapsulates a client side cache of <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> objects which provide input data
for widgets such as the Ext.grid.Grid, or the Ext.form.ComboBox.<br>
<p>
A Store object uses an implementation of <a ext:cls="Ext.data.DataProxy" href="output/Ext.data.DataProxy.html">Ext.data.DataProxy</a> to access a data object unless you call
loadData() directly and pass in your data. The Store object
has no knowledge of the format of the data returned by the Proxy.<br>
<p>
A Store object uses its configured implementation of <a ext:cls="Ext.data.DataReader" href="output/Ext.data.DataReader.html">Ext.data.DataReader</a> to create <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a>
instances from the data object. These records are cached and made available through accessor functions.Creates a new Store.A config object containing the objects needed for the Store to access data,
and read the data into Records.Add Records to the Store and fires the add event.An Array of Ext.data.Record objects to add to the cache.(Local sort only) Inserts the passed the record in the Store at the index where it
should go based on the current sort informationRemove a Record from the Store and fires the remove event.Th Ext.data.Record object to remove from the cache.Remove all Records from the Store and fires the clear event.Inserts Records to the Store at the given index and fires the add event.The start index at which to insert the passed Records.An Array of Ext.data.Record objects to add to the cache.Get the index within the cache of the passed Record.The Ext.data.Record object to to find.Get the index within the cache of the Record with the passed id.The id of the Record to find.Get the Record with the specified id.The id of the Record to find.Get the Record at the specified index.The index of the Record to find.Returns a range of Records between specified indices.(optional) The starting index (defaults to 0)(optional) The ending index (defaults to the last Record in the Store)Loads the Record cache from the configured Proxy using the configured Reader.
<p>
If using remote paging, then the first load call must specify the <em>start</em>
and <em>limit</em> properties in the options.params property to establish the initial
position within the dataset, and the number of Records to cache on each read from the Proxy.
<p>
<strong>It is important to note that for remote data sources, loading is asynchronous,
and this call will return before the new data has been loaded. Perform any post-processing
in a callback function, or in a "load" event handler.</strong>
<p>An object containing properties which control loading options:<ul>
<li>params {Object} An object containing properties to pass as HTTP parameters to a remote data source.</li>
<li>callback {Function} A function to be called after the Records have been loaded. The callback is
passed the following arguments:<ul>
<li>r : Ext.data.Record[]</li>
<li>options: Options object from the load call</li>
<li>success: Boolean success indicator</li></ul></li>
<li>scope {Object} Scope with which to call the callback (defaults to the Store object)</li>
<li>add {Boolean} indicator to append loaded records rather than replace the current cache.</li>
</ul>Reloads the Record cache from the configured Proxy using the configured Reader and
the options from the last load operation performed.(optional) An object containing properties which may override the options
used in the last load operation. See <a ext:cls="Ext.data.Store" ext:member="load" href="output/Ext.data.Store.html#load">load</a> for details (defaults to null, in which case
the most recently used options are reused).Loads data from a passed data block. A Reader which understands the format of the data
must have been configured in the constructor.The data block from which to read the Records. The format of the data expected
is dependent on the type of Reader that is configured and should correspond to that Reader's readRecords parameter.(Optional) True to append the new Records rather than replace the existing cache.Gets the number of cached records.
<p>
<em>If using paging, this may not be the total size of the dataset. If the data object
used by the Reader contains the dataset size, then the getTotalCount() function returns
the data set size</em>Gets the total number of records in the dataset as returned by the server.
<p>
<em>If using paging, for this to be accurate, the data object used by the Reader must contain
the dataset size</em>Returns the sort state of the Store as an object with two properties:
<pre><code>field {String} The name of the field by which the Records are sorted
direction {String} The sort order, "ASC" or "DESC"</code></pre>Sets the default sort column and order to be used by the next load operation.The name of the field to sort by.(optional) The sort order, "ASC" or "DESC" (defaults to "ASC")Sort the Records.
If remote sorting is used, the sort is performed on the server, and the cache is
reloaded. If local sorting is used, the cache is sorted internally.The name of the field to sort by.(optional) The sort order, "ASC" or "DESC" (defaults to "ASC")Calls the specified function for each of the Records in the cache.The function to call. The Record is passed as the first parameter.
Returning <em>false</em> aborts and exits the iteration.(optional) The scope in which to call the function (defaults to the Record).Gets all records modified since the last commit. Modified records are persisted across load operations
(e.g., during paging).Sums the value of <i>property</i> for each record between start and end and returns the result.A field on your recordsThe record index to start at (defaults to 0)The last record index to include (defaults to length - 1)Filter the records by a specified property.A field on your recordsEither a string that the field
should start with or a RegExp to test against the field(optional) True to match any part not just the beginning(optional) True for case sensitive comparisonFilter by a function. The specified function will be called with each
record in this data source. If the function returns true the record is included,
otherwise it is filtered.The function to be called, it will receive 2 args (record, id)(optional) The scope of the function (defaults to this)Query the records by a specified property.A field on your recordsEither a string that the field
should start with or a RegExp to test against the field(optional) True to match any part not just the beginning(optional) True for case sensitive comparisonQuery by a function. The specified function will be called with each
record in this data source. If the function returns true the record is included
in the results.The function to be called, it will receive 2 args (record, id)(optional) The scope of the function (defaults to this)Finds the index of the first matching record in this store by a specific property/value.
Returns a new collection that has been filtered.A property on your objectsEither string that the property values
should start with or a RegExp to test against the property.(optional) The index to start searching at(optional) True to match any part of the string, not just the beginning(optional) True for case sensitive comparisonFind the index of the first matching record in this store by a function.
If the function returns <i>true<i> it is considered a match.The function to be called, it will receive the args o (the object), k (the key)(optional) The scope of the function (defaults to this)(optional) The index to start searching atCollects unique values for a particular dataIndex from this store.The property to collect(optional) Pass true to allow null, undefined or empty string values(optional) Pass true to collect from all records, even ones which are filteredRevert to a view of the Record cache with no filtering applied.If true the filter is cleared silently without notifying listenersReturns true if this store is currently filteredCommit all Records with outstanding changes. To handle updates for changes, subscribe to the
Store's "update" event, and perform updating when the third parameter is Ext.data.Record.COMMIT.Cancel outstanding changes on all changed records.Represents a tree data structure and bubbles all the events for its nodes. The nodes
in the tree have most standard DOM functionality.(optional) The root nodeThe root node for this treeReturns the root node for this tree.Sets the root node for this tree.Gets a node in this tree by its id.Data reader class to create an Array of <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> objects from an XML document
based on mappings in a provided Ext.data.Record constructor.<br><br>
<p>
<em>Note that in order for the browser to parse a returned XML document, the Content-Type
header in the HTTP response must be set to "text/xml".</em>
<p>
Example code:
<pre><code>var Employee = Ext.data.Record.create([
{name: 'name', mapping: 'name'}, // "mapping" property not needed if it's the same as "name"
{name: 'occupation'} // This field will use "occupation" as the mapping.
]);
var myReader = new Ext.data.XmlReader({
totalRecords: "results", // The element which contains the total dataset size (optional)
record: "row", // The repeated element which contains row information
id: "id" // The element within the row that provides an ID for the record (optional)
}, Employee);</code></pre>
<p>
This would consume an XML file like this:
<pre><code><?xml?>
<dataset>
<results>2</results>
<row>
<id>1</id>
<name>Bill</name>
<occupation>Gardener</occupation>
</row>
<row>
<id>2</id>
<name>Ben</name>
<occupation>Horticulturalist</occupation>
</row>
</dataset></code></pre>Create a new XmlReader.Metadata configuration optionsThe definition of the data record type to produce. This can be either a valid
Record subclass created with <a ext:cls="Ext.data.Record" ext:member="create" href="output/Ext.data.Record.html#create">Ext.data.Record.create</a>, or an array of objects with which to call
Ext.data.Record.create. See the <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> class for more details.After any data loads/reads, the raw XML Document is available for further custom processing.This method is only used by a DataProxy which has retrieved data from a remote server.The XHR object which contains the parsed XML document. The response is expected
to contain a method called 'responseXML' that returns an XML document object.Create a data block containing Ext.data.Records from an XML document.A parsed XML document.A DragDrop implementation where the linked element follows the
mouse cursor during a drag.the id of the linked elementthe group of related DragDrop itemsan object containing configurable attributes
Valid properties for DD:
scrollWhen set to true, the utility automatically tries to scroll the browser
window wehn a drag and drop element is dragged near the viewport boundary.
Defaults to true.Sets the pointer offset to the distance between the linked element's top
left corner and the location the element was clickedthe X coordinate of the clickthe Y coordinate of the clickSets the pointer offset. You can call this directly to force the
offset to be in a particular location (e.g., pass in 0,0 to set it
to the center of the object)the distance from the leftthe distance from the topSets the drag element to the location of the mousedown or click event,
maintaining the cursor location relative to the location on the element
that was clicked. Override this if you want to place the element in a
location other than where the cursor is.the X coordinate of the mousedown or drag eventthe Y coordinate of the mousedown or drag eventSets the element to the location of the mousedown or click event,
maintaining the cursor location relative to the location on the element
that was clicked. Override this if you want to place the element in a
location other than where the cursor is.the element to movethe X coordinate of the mousedown or drag eventthe Y coordinate of the mousedown or drag eventSaves the most recent position so that we can reset the constraints and
tick marks on-demand. We need to know this so that we can calculate the
number of pixels the element is offset from its original position.current x position (optional, this just makes it so we
don't have to look it up again)current y position (optional, this just makes it so we
don't have to look it up again)A DragDrop implementation that inserts an empty, bordered div into
the document that follows the cursor during drag operations. At the time of
the click, the frame div is resized to the dimensions of the linked html
element, and moved to the exact location of the linked element.
References to the "frame" element refer to the single proxy element that
was created to be dragged in place of all DDProxy elements on the
page.the id of the linked html elementthe group of related DragDrop objectsan object containing configurable attributes
Valid properties for DDProxy in addition to those in DragDrop:
resizeFrame, centerFrame, dragElId<static> The default drag frame div idBy default we resize the drag frame to be the same size as the element
we want to drag (this is to get the frame effect). We can turn it off
if we want a different behavior.By default the frame is positioned exactly where the drag element is, so
we use the cursor offset provided by Ext.dd.DD. Another option that works only if
you do not have constraints on the obj is to have the drag frame centered
around the cursor. Set centerFrame to true for this effect.Creates the proxy element if it does not yet existInitialization for the drag frame element. Must be called in the
constructor of all subclassesA DragDrop implementation that does not move, but can be a drop
target. You would get the same result by simply omitting implementation
for the event callbacks, but this way we reduce the processing cost of the
event listener and the callbacks.the id of the element that is a drop targetthe group of related DragDrop objectsan object containing configurable attributes
Valid properties for DDTarget in addition to those in
DragDrop:
noneDefines the interface and base operation of items that that can be
dragged or can be drop targets. It was designed to be extended, overriding
the event handlers for startDrag, onDrag, onDragOver and onDragOut.
Up to three html elements can be associated with a DragDrop instance:
<ul>
<li>linked element: the element that is passed into the constructor.
This is the element which defines the boundaries for interaction with
other DragDrop objects.</li>
<li>handle element(s): The drag operation only occurs if the element that
was clicked matches a handle element. By default this is the linked
element, but there are times that you will want only a portion of the
linked element to initiate the drag operation, and the setHandleElId()
method provides a way to define this.</li>
<li>drag element: this represents the element that would be moved along
with the cursor during a drag operation. By default, this is the linked
element itself as in <a ext:cls="Ext.dd.DD" href="output/Ext.dd.DD.html">Ext.dd.DD</a>. setDragElId() lets you define
a separate element that would be moved, as in <a ext:cls="Ext.dd.DDProxy" href="output/Ext.dd.DDProxy.html">Ext.dd.DDProxy</a>.
</li>
</ul>
This class should not be instantiated until the onload event to ensure that
the associated elements are available.
The following would define a DragDrop obj that would interact with any
other DragDrop obj in the "group1" group:
<pre>dd = new Ext.dd.DragDrop("div1", "group1");</pre>
Since none of the event handlers have been implemented, nothing would
actually happen if you were to run the code above. Normally you would
override this class or one of the default implementations, but you can
also override the methods you want on an instance of the class...
<pre>dd.onDragDrop = function(e, id) {
alert("dd was dropped on " + id);
}</pre>of the element that is linked to this instancethe group of related DragDrop objectsan object containing configurable attributes
Valid properties for DragDrop:
padding, isTarget, maintainOffset, primaryButtonOnlyThe id of the element associated with this object. This is what we
refer to as the "linked element" because the size and position of
this element is used to determine when the drag and drop objects have
interacted.Configuration attributes passed into the constructorAn associative array of HTML tags that will be ignored if clicked.An associative array of ids for elements that will be ignored if clickedAn indexted array of css class names for elements that will be ignored
if clicked.The group defines a logical collection of DragDrop objects that are
related. Instances only get events when interacting with other
DragDrop object in the same group. This lets us define multiple
groups using a single DragDrop subclass if we want.By default, all insances can be a drop target. This can be disabled by
setting isTarget to false.The padding configured for this drag and drop object for calculating
the drop zone intersection with this object.Maintain offsets when we resetconstraints. Set to true when you want
the position of the element relative to its parent to stay the same
when the page changesArray of pixel locations the element will snap to if we specified a
horizontal graduation/interval. This array is generated automatically
when you define a tick interval.Array of pixel locations the element will snap to if we specified a
vertical graduation/interval. This array is generated automatically
when you define a tick interval.By default the drag and drop instance will only respond to the primary
button click (left button for a right-handed mouse). Set to true to
allow drag and drop to start with any mouse click that is propogated
by the browserThe availabe property is false until the linked dom element is accessible.By default, drags can only be initiated if the mousedown occurs in the
region the linked element is. This is done in part to work around a
bug in some browsers that mis-report the mousedown if the previous
mouseup happened outside of the window. This property is set to true
if outer handles are defined.Lock this instanceUnlock this instaceAbstract method called after a drag/drop object is clicked
and the drag or mousedown time thresholds have beeen met.click locationclick locationAbstract method called during the onMouseMove event while dragging an
object.the mousemove eventAbstract method called when this element fist begins hovering over
another DragDrop objthe mousemove eventIn POINT mode, the element
id this is hovering over. In INTERSECT mode, an array of one or more
dragdrop items being hovered over.Abstract method called when this element is hovering over another
DragDrop objthe mousemove eventIn POINT mode, the element
id this is hovering over. In INTERSECT mode, an array of dd items
being hovered over.Abstract method called when we are no longer hovering over an elementthe mousemove eventIn POINT mode, the element
id this was hovering over. In INTERSECT mode, an array of dd items
that the mouse is no longer over.Abstract method called when this item is dropped on another DragDrop
objthe mouseup eventIn POINT mode, the element
id this was dropped on. In INTERSECT mode, an array of dd items this
was dropped on.Abstract method called when this item is dropped on an area with no
drop targetthe mouseup eventFired when we are done dragging the objectthe mouseup eventEvent handler that fires when a drag/drop obj gets a mousedownthe mousedown eventEvent handler that fires when a drag/drop obj gets a mouseupthe mouseup eventOverride the onAvailable method to do what is needed after the initial
position was determined.Returns a reference to the linked elementReturns a reference to the actual element to drag. By default this is
the same as the html element, but it can be assigned to another
element. An example of this can be found in Ext.dd.DDProxySets up the DragDrop object. Must be called in the constructor of any
Ext.dd.DragDrop subclassid of the linked elementthe group of related itemsconfiguration attributesInitializes Targeting functionality only... the object does not
get a mousedown handler.id of the linked elementthe group of related itemsconfiguration attributesApplies the configuration parameters that were passed into the constructor.
This is supposed to happen at each level through the inheritance chain. So
a DDProxy implentation will execute apply config on DDProxy, DD, and
DragDrop in order to get all of the parameters that are available in
each object.Configures the padding for the target zone in px. Effectively expands
(or reduces) the virtual object size for targeting calculations.
Supports css-style shorthand; if only one parameter is passed, all sides
will have that padding, and if only two are passed, the top and bottom
will have the first param, the left and right the second.Top padRight padBot padLeft padStores the initial placement of the linked element.the X offset, default 0the Y offset, default 0Add this instance to a group of related drag/drop objects. All
instances belong to at least one group, and can belong to as many
groups as needed.the name of the groupRemove's this instance from the supplied interaction groupThe group to dropAllows you to specify that an element other than the linked element
will be moved with the cursor during a dragthe id of the element that will be used to initiate the dragAllows you to specify a child of the linked element that should be
used to initiate the drag operation. An example of this would be if
you have a content div with text and links. Clicking anywhere in the
content area would normally start the drag operation. Use this method
to specify that an element inside of the content div is the element
that starts the drag operation.the id of the element that will be used to
initiate the drag.Allows you to set an element outside of the linked element as a drag
handleid of the element that will be used to initiate the dragRemove all drag and drop hooks for this elementReturns true if this instance is locked, or the drag drop mgr is locked
(meaning that all drag/drop is disabled on the page.)Allows you to specify a tag name that should not start a drag operation
when clicked. This is designed to facilitate embedding links within a
drag handle that do something other than start the drag.the type of element to excludeLets you to specify an element id for a child of a drag handle
that should not initiate a dragthe element id of the element you wish to ignoreLets you specify a css class of elements that will not initiate a dragthe class of the elements you wish to ignoreUnsets an excluded tag name set by addInvalidHandleTypethe type of element to unexcludeUnsets an invalid handle idthe id of the element to re-enableUnsets an invalid css classthe class of the element(s) you wish to
re-enableChecks the tag exclusion list to see if this click should be ignoredthe HTMLElement to evaluateBy default, the element can be dragged any place on the screen. Use
this method to limit the horizontal travel of the element. Pass in
0,0 for the parameters if you want to lock the drag to the y axis.the number of pixels the element can move to the leftthe number of pixels the element can move to the
rightoptional parameter for specifying that the
element
should move iTickSize pixels at a time.Clears any constraints applied to this instance. Also clears ticks
since they can't exist independent of a constraint at this time.Clears any tick interval defined for this instanceBy default, the element can be dragged any place on the screen. Set
this to limit the vertical travel of the element. Pass in 0,0 for the
parameters if you want to lock the drag to the x axis.the number of pixels the element can move upthe number of pixels the element can move downoptional parameter for specifying that the
element should move iTickSize pixels at a time.resetConstraints must be called if you manually reposition a dd element.toString methodDragDropMgr is a singleton that tracks the element interaction for
all DragDrop items in the window. Generally, you will not call
this class directly, but it does have helper methods that could
be useful in your DragDrop implementations.<br><br><i>This class is a singleton and cannot be created directly.</i><static> Flag to determine if we should prevent the default behavior of the
events we define. By default this is true, but this can be set to
false if you need the default behavior (not recommended)<static> Flag to determine if we should stop the propagation of the events
we generate. This is true by default but you may want to set it to
false if the html element contains other features that require the
mouse click.<static> In point mode, drag and drop interaction is defined by the
location of the cursor during the drag/drop<static> In intersect mode, drag and drop interactio nis defined by the
overlap of two or more drag and drop objects.<static> The current drag and drop mode. Default: POINT<static> Set useCache to false if you want to force object the lookup of each
drag and drop linked element constantly during a drag.<static> The number of pixels that the mouse needs to move after the
mousedown before the drag is initiated. Default=3;<static> The number of milliseconds after the mousedown event to initiate the
drag if we don't get a mouseup event. Default=1000The elementThe element idA reference to the style property<static> Lock all drag and drop functionality<static> Unlock all drag and drop functionality<static> Is drag and drop locked?<static> Each DragDrop instance must be registered with the DragDropMgr.
This is executed in DragDrop.init()the DragDrop object to registerthe name of the group this element belongs to<static> Each DragDrop handle element must be registered. This is done
automatically when executing DragDrop.setHandleElId()the DragDrop id this element is a handle forthe id of the element that is the drag
handle<static> Utility function to determine if a given element has been
registered as a drag drop item.the element id to check<static> Returns the drag and drop instances that are in all groups the
passed in instance belongs to.the obj to get related data forif true, only return targetable objs<static> Returns true if the specified dd target is a legal target for
the specifice drag objdrag objtarget<static> My goal is to be able to transparently determine if an object is
typeof DragDrop, and the exact subclass of DragDrop. typeof
returns "object", oDD.constructor.toString() always returns
"DragDrop" and not the name of the subclass. So for now it just
evaluates a well-known variable in DragDrop.object to evaluate<static> Utility function to determine if a given element has been
registered as a drag drop handle for the given Drag Drop object.the element id to check<static> Returns the DragDrop instance for a given idthe id of the DragDrop object<static> Fired when either the drag pixel threshol or the mousedown hold
time threshold has been met.the X position of the original mousedownthe Y position of the original mousedown<static> Utility to stop event propagation and event default, if these
features are turned on.the event as returned by this.getEvent()<static> Helper function for getting the best match from the list of drag
and drop objects returned by the drag and drop events when we are
in INTERSECT mode. It returns either the first object that the
cursor is over, or the object that has the greatest overlap with
the dragged element.The array of drag and drop objects
targeted<static> Refreshes the cache of the top-left and bottom-right points of the
drag and drop objects in the specified group(s). This is in the
format that is stored in the drag and drop instance, so typical
usage is:
<code>
Ext.dd.DragDropMgr.refreshCache(ddinstance.groups);
</code>
Alternatively:
<code>
Ext.dd.DragDropMgr.refreshCache({group1:true, group2:true});
</code>
@TODO this really should be an indexed array. Alternatively this
method could accept both.an associative array of groups to refresh<static> This checks to make sure an element exists and is in the DOM. The
main purpose is to handle cases where innerHTML is used to remove
drag and drop objects from the DOM. IE provides an 'unspecified
error' when trying to access the offsetParent of such an elementthe element to check<static> Returns a Region object containing the drag and drop element's position
and size, including the padding configured for itthe drag and drop object to get the
location for<b>Deprecated.</b> <static> Returns the actual DOM elementthe id of the elment to get<b>Deprecated.</b> <static> Returns the style property for the DOM element (i.e.,
document.getElById(id).style)the id of the elment to get<b>Deprecated.</b> <static> Returns the X position of an html elementelement for which to get the position<b>Deprecated.</b> <static> Returns the Y position of an html elementelement for which to get the position<static> Swap two nodes. In IE, we use the native method, for others we
emulate the IE behaviorfirst node to swapother node to swap<b>Deprecated.</b> <static> Returns the specified element style propertythe elementthe style property<static> Gets the scrollTop<static> Gets the scrollLeft<static> Sets the x/y position of an element to the location of the
target element.The element to moveThe position reference element<static> Numeric array sort function<static> Recursively searches the immediate parent and all child nodes for
the handle element in order to determine wheter or not it was
clicked.html element to inspectA simple class that provides the basic implementation needed to make any element draggable.The container elementAn empty function by default, but provided so that you can perform a custom action once the initial
drag event has begun. The drag cannot be canceled from this function.Returns the data object associated with this drag sourceAn empty function by default, but provided so that you can perform a custom action
when the dragged item enters the drop target by providing an implementation.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action
before the dragged item enters the drop target and optionally cancel the onDragEnter.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action
while the dragged item is over the drop target by providing an implementation.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action
while the dragged item is over the drop target and optionally cancel the onDragOver.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action
after the dragged item is dragged out of the target without dropping.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action before the dragged
item is dragged out of the target without dropping, and optionally cancel the onDragOut.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action
after a valid drag drop has occurred by providing an implementation.The drop targetThe event objectThe id of the dropped elementAn empty function by default, but provided so that you can perform a custom action before the dragged
item is dropped onto the target and optionally cancel the onDragDrop.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action
after an invalid drop has occurred by providing an implementation.The event objectThe id of the dropped elementAn empty function by default, but provided so that you can perform a custom action after an invalid
drop has occurred.The drop targetThe event objectThe id of the dragged elementAn empty function by default, but provided so that you can perform a custom action before the initial
drag event begins and optionally cancel it.An object containing arbitrary data to be shared with drop targetsThe event objectReturns the drag source's underlying <a ext:cls="Ext.dd.StatusProxy" href="output/Ext.dd.StatusProxy.html">Ext.dd.StatusProxy</a>Hides the drag source's <a ext:cls="Ext.dd.StatusProxy" href="output/Ext.dd.StatusProxy.html">Ext.dd.StatusProxy</a>This class provides a container DD instance that proxies for multiple child node sources.<br />
By default, this class requires that draggable child nodes are registered with <a ext:cls="Ext.dd.Registry" href="output/Ext.dd.Registry.html">Ext.dd.Registry</a>.The container element
Called when a mousedown occurs in this container. Looks in <a ext:cls="Ext.dd.Registry" href="output/Ext.dd.Registry.html">Ext.dd.Registry</a>
for a valid target to drag based on the mouse down. Override this method
to provide your own lookup logic (e.g. finding a child by class name). Make sure your returned
object has a "ddel" attribute (with an HTML Element) for other functions to work.The mouse down eventCalled once drag threshold has been reached to initialize the proxy element. By default, it clones the
this.dragData.ddelThe x position of the click on the dragged objectThe y position of the click on the dragged objectCalled after a repair of an invalid drop. By default, highlights this.dragData.ddelCalled before a repair of an invalid drop to get the XY to animate to. By default returns
the XY of this.dragData.ddelThe mouse up eventA simple class that provides the basic implementation needed to make any element a drop target that can have
draggable items dropped onto it. The drop has no effect until an implementation of notifyDrop is provided.The container elementThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls once to notify this drop target that the source is now over the
target. This default implementation adds the CSS class specified by overClass (if any) to the drop element
and returns the dropAllowed config value. This method should be overridden if drop validation is required.The drag source that was dragged over this drop targetThe eventAn object containing arbitrary data supplied by the drag sourceThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls continuously while it is being dragged over the target.
This method will be called on every mouse movement while the drag source is over the drop target.
This default implementation simply returns the dropAllowed config value.The drag source that was dragged over this drop targetThe eventAn object containing arbitrary data supplied by the drag sourceThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls once to notify this drop target that the source has been dragged
out of the target without dropping. This default implementation simply removes the CSS class specified by
overClass (if any) from the drop element.The drag source that was dragged over this drop targetThe eventAn object containing arbitrary data supplied by the drag sourceThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls once to notify this drop target that the dragged item has
been dropped on it. This method has no default implementation and returns false, so you must provide an
implementation that does something to process the drop event and returns true so that the drag source's
repair action does not run.The drag source that was dragged over this drop targetThe eventAn object containing arbitrary data supplied by the drag sourceThis class provides a container DD instance that proxies for multiple child node targets.<br />
By default, this class requires that child nodes accepting drop are registered with <a ext:cls="Ext.dd.Registry" href="output/Ext.dd.Registry.html">Ext.dd.Registry</a>.The container elementReturns a custom data object associated with the DOM node that is the target of the event. By default
this looks up the event target in the <a ext:cls="Ext.dd.Registry" href="output/Ext.dd.Registry.html">Ext.dd.Registry</a>, although you can override this method to
provide your own custom lookup.The eventCalled internally when the DropZone determines that a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> has entered a drop node
that it has registered. This method has no default implementation and should be overridden to provide
node-specific processing if necessary.The custom data associated with the drop node (this is the same value returned from
<a ext:cls="Ext.dd.DropZone" ext:member="getTargetFromEvent" href="output/Ext.dd.DropZone.html#getTargetFromEvent">getTargetFromEvent</a> for this node)The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceCalled internally while the DropZone determines that a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> is over a drop node
that it has registered. The default implementation returns this.dropNotAllowed, so it should be
overridden to provide the proper feedback.The custom data associated with the drop node (this is the same value returned from
<a ext:cls="Ext.dd.DropZone" ext:member="getTargetFromEvent" href="output/Ext.dd.DropZone.html#getTargetFromEvent">getTargetFromEvent</a> for this node)The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceCalled internally when the DropZone determines that a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> has been dragged out of
the drop node without dropping. This method has no default implementation and should be overridden to provide
node-specific processing if necessary.The custom data associated with the drop node (this is the same value returned from
<a ext:cls="Ext.dd.DropZone" ext:member="getTargetFromEvent" href="output/Ext.dd.DropZone.html#getTargetFromEvent">getTargetFromEvent</a> for this node)The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceCalled internally when the DropZone determines that a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> has been dropped onto
the drop node. The default implementation returns false, so it should be overridden to provide the
appropriate processing of the drop event and return true so that the drag source's repair action does not run.The custom data associated with the drop node (this is the same value returned from
<a ext:cls="Ext.dd.DropZone" ext:member="getTargetFromEvent" href="output/Ext.dd.DropZone.html#getTargetFromEvent">getTargetFromEvent</a> for this node)The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceCalled internally while the DropZone determines that a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> is being dragged over it,
but not over any of its registered drop nodes. The default implementation returns this.dropNotAllowed, so
it should be overridden to provide the proper feedback if necessary.The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceCalled internally when the DropZone determines that a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> has been dropped on it,
but not on any of its registered drop nodes. The default implementation returns false, so it should be
overridden to provide the appropriate processing of the drop event if you need the drop zone itself to
be able to accept drops. It should return true when valid so that the drag source's repair action does not run.The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls once to notify this drop zone that the source is now over
the zone. The default implementation returns this.dropNotAllowed and expects that only registered drop
nodes can process drag drop operations, so if you need the drop zone itself to be able to process drops
you should override this method and provide a custom implementation.The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls continuously while it is being dragged over the drop zone.
This method will be called on every mouse movement while the drag source is over the drop zone.
It will call <a ext:cls="Ext.dd.DropZone" ext:member="onNodeOver" href="output/Ext.dd.DropZone.html#onNodeOver">onNodeOver</a> while the drag source is over a registered node, and will also automatically
delegate to the appropriate node-specific methods as necessary when the drag source enters and exits
registered nodes (<a ext:cls="Ext.dd.DropZone" ext:member="onNodeEnter" href="output/Ext.dd.DropZone.html#onNodeEnter">onNodeEnter</a>, <a ext:cls="Ext.dd.DropZone" ext:member="onNodeOut" href="output/Ext.dd.DropZone.html#onNodeOut">onNodeOut</a>). If the drag source is not currently over a
registered node, it will call <a ext:cls="Ext.dd.DropZone" ext:member="onContainerOver" href="output/Ext.dd.DropZone.html#onContainerOver">onContainerOver</a>.The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls once to notify this drop zone that the source has been dragged
out of the zone without dropping. If the drag source is currently over a registered node, the notification
will be delegated to <a ext:cls="Ext.dd.DropZone" ext:member="onNodeOut" href="output/Ext.dd.DropZone.html#onNodeOut">onNodeOut</a> for node-specific handling, otherwise it will be ignored.The drag source that was dragged over this drop targetThe eventAn object containing arbitrary data supplied by the drag zoneThe function a <a ext:cls="Ext.dd.DragSource" href="output/Ext.dd.DragSource.html">Ext.dd.DragSource</a> calls once to notify this drop zone that the dragged item has
been dropped on it. The drag zone will look up the target node based on the event passed in, and if there
is a node registered for that event, it will delegate to <a ext:cls="Ext.dd.DropZone" ext:member="onNodeDrop" href="output/Ext.dd.DropZone.html#onNodeDrop">onNodeDrop</a> for node-specific handling,
otherwise it will call <a ext:cls="Ext.dd.DropZone" ext:member="onContainerDrop" href="output/Ext.dd.DropZone.html#onContainerDrop">onContainerDrop</a>.The drag source that was dragged over this drop zoneThe eventAn object containing arbitrary data supplied by the drag sourceProvides easy access to all drag drop components that are registered on a page. Items can be retrieved either
directly by DOM node id, or by passing in the drag drop event that occurred and looking up the event target.<br><br><i>This class is a singleton and cannot be created directly.</i>Resgister a drag drop elementThe id or DOM node to register(optional) An custom data object that will be passed between the elements that are involved
in drag drop operations. You can populate this object with any arbitrary properties that your own code
knows how to interpret, plus there are some specific properties known to the Registry that should be
populated in the data object (if applicable):
<pre>Value Description<br />
--------- ------------------------------------------<br />
handles Array of DOM nodes that trigger dragging<br />
for the element being registered<br />
isHandle True if the element passed in triggers<br />
dragging itself, else false</pre>Unregister a drag drop elementThe id or DOM node to unregisterReturns the handle registered for a DOM Node by idThe DOM node or id to look upReturns the handle that is registered for the DOM node that is the target of the eventThe eventReturns a custom data object that is registered for a DOM node by idThe DOM node or id to look upReturns a custom data object that is registered for the DOM node that is the target of the eventThe eventProvides automatic scrolling of overflow regions in the page during drag operations.<br><br>
<b>Note: This class uses "Point Mode" and is untested in "Intersect Mode".</b><br><br><i>This class is a singleton and cannot be created directly.</i>The number of pixels from the top or bottom edge of a container the pointer needs to be to
trigger scrolling (defaults to 25)The number of pixels from the right or left edge of a container the pointer needs to be to
trigger scrolling (defaults to 25)The number of pixels to scroll in each scroll increment (defaults to 50)The frequency of scrolls in milliseconds (defaults to 500)True to animate the scroll (defaults to true)The animation duration in seconds -
MUST BE less than Ext.dd.ScrollManager.frequency! (defaults to .4)Registers new overflow element(s) to auto scrollThe id of or the element to be scrolled or an array of eitherUnregisters overflow element(s) so they are no longer scrolledThe id of or the element to be removed or an array of eitherManually trigger a cache refresh.A specialized drag proxy that supports a drop status icon, <a ext:cls="Ext.Layer" href="output/Ext.Layer.html">Ext.Layer</a> styles and auto-repair. This is the
default drag proxy used by all Ext.dd components.Updates the proxy's visual element to indicate the status of whether or not drop is allowed
over the current target element.The css class for the new drop status indicator imageResets the status indicator to the default dropNotAllowed valueTrue to also remove all content from the ghost, false to preserve itUpdates the contents of the ghost elementThe html that will replace the current innerHTML of the ghost elementReturns the underlying proxy <a ext:cls="Ext.Layer" href="output/Ext.Layer.html">Ext.Layer</a>Returns the ghost elementHides the proxyTrue to reset the status and clear the ghost contents, false to preserve themStops the repair animation if it's currently runningDisplays this proxyForce the Layer to sync its shadow and shim positions to the elementCauses the proxy to return to its position of origin via an animation. Should be called after an
invalid drop operation by the item being dragged.The XY position of the element ([x, y])The function to call after the repair is completeThe scope in which to execute the callbackThe subclasses of this class provide actions to perform upon <a ext:cls="Ext.form.BasicForm" href="output/Ext.form.BasicForm.html">Ext.form.BasicForm</a>s.
<br><br>
Instances of this class are only created by an <a ext:cls="Ext.form.BasicForm" href="output/Ext.form.BasicForm.html">Ext.form.BasicForm</a> when
the Form needs to perform an action such as submit or load.
<br><br>
The instance of Action which performed the action is passed to the success
and failure callbacks of the Form's action methods ({@link Ext.form.BasicForm#submit submit},
{@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction}),
and to the <a ext:cls="Ext.form.BasicForm" ext:member="actioncomplete" href="output/Ext.form.BasicForm.html#actioncomplete">Ext.form.BasicForm.actioncomplete</a> and
<a ext:cls="Ext.form.BasicForm" ext:member="actionfailed" href="output/Ext.form.BasicForm.html#actionfailed">Ext.form.BasicForm.actionfailed</a> event handlers.<static> Failure type returned when client side validation of the Form fails
thus aborting a submit action.<static> Failure type returned when server side validation of the Form fails
indicating that field-specific error messages have been returned in the
response's <tt style="font-weight:bold">errors</tt> property.<static> Failure type returned when a communication error happens when attempting
to send a request to the remote server.<static> Failure type returned when no field values are returned in the response's
<tt style="font-weight:bold">data</tt> property.
The type of action this Action instance performs.
Currently only "submit" and "load" are supported.The type of failure detected. See <a ext:cls="Ext.form.Action" ext:member="CLIENT_INVALID" href="output/Ext.form.Action.html#CLIENT_INVALID">CLIENT_INVALID</a>, <a ext:cls="Ext.form.Action" ext:member="SERVER_INVALID" href="output/Ext.form.Action.html#SERVER_INVALID">SERVER_INVALID</a>,
<a ext:cls="Ext.form.Action" ext:member="CONNECT_FAILURE" href="output/Ext.form.Action.html#CONNECT_FAILURE">CONNECT_FAILURE</a>, <a ext:cls="Ext.form.Action" ext:member="LOAD_FAILURE" href="output/Ext.form.Action.html#LOAD_FAILURE">LOAD_FAILURE</a>
The XMLHttpRequest object used to perform the action.
The decoded response object containing a boolean <tt style="font-weight:bold">success</tt> property and
other, action-specific properties.A class which handles loading of data from a server into the Fields of
an <a ext:cls="Ext.form.BasicForm" href="output/Ext.form.BasicForm.html">Ext.form.BasicForm</a>.
<br><br>
Instances of this class are only created by a {@link Ext.form.BasicForm Form} when
submitting.
<br><br>
A response packet <b>must</b> contain a boolean <tt style="font-weight:bold">success</tt> property, and
an <tt style="font-weight:bold">data</tt> property. The <tt style="font-weight:bold">data</tt> property contains the
values of Fields to load. The individual value object for each Field
is passed to the Field's {@link Ext.form.Field#setValue setValue} method.
<br><br>
By default, response packets are assumed to be JSON, so a typical response
packet may look like this:
<br><br><pre><code>{
success: true,
data: {
clientName: "Fred. Olsen Lines",
portOfLoading: "FXT",
portOfDischarge: "OSL"
}
}</code></pre>
<br><br>
Other data may be placed into the response for processing the the {@link Ext.form.BasicForm Form}'s callback
or event handler methods.A class which handles submission of data from {@link Ext.form.BasicForm Form}s
and processes the returned response.
<br><br>
Instances of this class are only created by a {@link Ext.form.BasicForm Form} when
submitting.
<br><br>
A response packet must contain a boolean <tt style="font-weight:bold">success</tt> property, and, optionally
an <tt style="font-weight:bold">errors</tt> property. The <tt style="font-weight:bold">errors</tt> property contains error
messages for invalid fields.
<br><br>
By default, response packets are assumed to be JSON, so a typical response
packet may look like this:
<br><br><pre><code>{
success: false,
errors: {
clientCode: "Client not found",
portOfLoading: "This field must not be null"
}
}</code></pre>
<br><br>
Other data may be placed into the response for processing the the <a ext:cls="Ext.form.BasicForm" href="output/Ext.form.BasicForm.html">Ext.form.BasicForm</a>'s callback
or event handler methods.Supplies the functionality to do "actions" on forms and initialize Ext.form.Field types on existing markup.
<br><br>
By default, Ext Forms are submitted through Ajax, using <a ext:cls="Ext.form.Action" href="output/Ext.form.Action.html">Ext.form.Action</a>.
To enable normal browser submission of an Ext Form, override the Form's onSubmit,
and submit methods:<br><br><pre><code>var myForm = new Ext.form.BasicForm("form-el-id", {
onSubmit: Ext.emptyFn,
submit: function() {
this.getEl().dom.submit();
}
});</code></pre><br>The form element or its idConfiguration optionsGet the HTML form ElementReturns true if client-side validation on the form is successful.Returns true if any fields in this form have changed since their original load.Performs a predefined action (<a ext:cls="Ext.form.Action.Submit" href="output/Ext.form.Action.Submit.html">Ext.form.Action.Submit</a> or
<a ext:cls="Ext.form.Action.Load" href="output/Ext.form.Action.Load.html">Ext.form.Action.Load</a>) or a custom extension of <a ext:cls="Ext.form.Action" href="output/Ext.form.Action.html">Ext.form.Action</a>
to perform application-specific processing.The name of the predefined action type,
or instance of <a ext:cls="Ext.form.Action" href="output/Ext.form.Action.html">Ext.form.Action</a> to perform.(optional) The options to pass to the <a ext:cls="Ext.form.Action" href="output/Ext.form.Action.html">Ext.form.Action</a>.
All of the config options listed below are supported by both the submit
and load actions unless otherwise noted (custom actions could also accept
other config options):
<pre>Property Type Description
---------------- --------------- ----------------------------------------------------------------------------------
url String The url for the action (defaults to the form's url)
method String The form method to use (defaults to the form's method, or POST if not defined)
params String/Object The params to pass (defaults to the form's baseParams, or none if not defined)
success Function The callback that will be invoked after a successful response. Note that this
is HTTP success (the transaction was sent and received correctly), but the resulting
response data can still contain data errors.
failure Function The callback that will be invoked after a failed transaction attempt. Note that
this is HTTP faillure, which means a non-successful HTTP code was returned from
the server.
clientValidation Boolean Applies to submit only. Pass true to call form.isValid() prior to posting to
validate the form on the client (defaults to false)</pre>Shortcut to do a submit action.The options to pass to the action (see <a ext:cls="Ext.form.BasicForm" ext:member="doAction" href="output/Ext.form.BasicForm.html#doAction">doAction</a> for details)Shortcut to do a load action.The options to pass to the action (see <a ext:cls="Ext.form.BasicForm" ext:member="doAction" href="output/Ext.form.BasicForm.html#doAction">doAction</a> for details)Persists the values in this form into the passed Ext.data.Record object in a beginEdit/endEdit block.The record to editLoads an Ext.data.Record into this form.The record to loadFind a Ext.form.Field in this form by id, dataIndex, name or hiddenName.The value to search forMark fields in this form invalid in bulk.Either an array in the form [{id:'fieldId', msg:'The message'},...] or an object hash of {id: msg, id2: msg2}Set values for fields in this form in bulk.Either an array in the form:<br><br><code><pre>[{id:'clientName', value:'Fred. Olsen Lines'},
{id:'portOfLoading', value:'FXT'},
{id:'portOfDischarge', value:'OSL'} ]</pre></code><br><br>
or an object hash of the form:<br><br><code><pre>{
clientName: 'Fred. Olsen Lines',
portOfLoading: 'FXT',
portOfDischarge: 'OSL'
}</pre></code><br>Returns the fields in this form as an object with key/value pairs. If multiple fields exist with the same name
they are returned as an array.Clears all invalid messages in this form.Resets this form.Add Ext.form components to this form.(optional)(optional)Removes a field from the items collection (does NOT remove its markup).Looks at the fields in this form, checks them for an id attribute,
and calls applyTo on the existing dom element with that id.Calls <a ext:cls="Ext" ext:member="apply" href="output/Ext.html#apply">Ext.apply</a> for all fields in this form with the passed object.Calls <a ext:cls="Ext" ext:member="applyIf" href="output/Ext.html#applyIf">Ext.applyIf</a> for all field in this form with the passed object.Single checkbox field. Can be used as a direct replacement for traditional checkbox fields.Creates a new CheckboxConfiguration optionsReturns the checked state of the checkbox.Sets the checked state of the checkbox.True, 'true', '1', or 'on' to check the checkbox, any other value will uncheck it.A combobox control with support for autocomplete, remote-loading, paging and many other features.Create a new ComboBox.Configuration optionsThe {@link Ext.DataView DataView} used to display the ComboBox's options.Allow or prevent the user from directly editing the field text. If false is passed,
the user will only be able to select from the items defined in the dropdown list. This method
is the runtime equivalent of setting the 'editable' config option at config time.True to allow the user to directly edit the field textReturns the currently selected field value or empty string if no value is set.Clears any text/value currently set in the fieldSets the specified value into the field. If the value finds a match, the corresponding record text
will be displayed in the field. If the value does not match the data value of an existing item,
and the valueNotFoundText config option is defined, it will be displayed as the default field text.
Otherwise the field will be blank (although the value will still be set).The value to matchReturns true if the dropdown list is expanded, else false.Select an item in the dropdown list by its data value. This function does NOT cause the select event to fire.
The store must be loaded and the list expanded for this function to work, otherwise use setValue.The data value of the item to selectFalse to prevent the dropdown list from autoscrolling to display the
selected item if it is not currently in view (defaults to true)Select an item in the dropdown list by its numeric index in the list. This function does NOT cause the select event to fire.
The store must be loaded and the list expanded for this function to work, otherwise use setValue.The zero-based index of the list item to selectFalse to prevent the dropdown list from autoscrolling to display the
selected item if it is not currently in view (defaults to true)Execute a query to filter the dropdown list. Fires the beforequery event prior to performing the
query allowing the query action to be canceled if needed.The SQL query to executeTrue to force the query to execute even if there are currently fewer characters
in the field than the minimum specified by the minChars config option. It also clears any filter previously
saved in the current store (defaults to false)Hides the dropdown list if it is currently expanded. Fires the 'collapse' event on completion.Expands the dropdown list if it is currently hidden. Fires the 'expand' event on completion.@hideProvides a date input field with a <a ext:cls="Ext.DatePicker" href="output/Ext.DatePicker.html">Ext.DatePicker</a> dropdown and automatic date validation.Create a new DateFieldReturns the current date value of the date field.Sets the value of the date field. You can pass a date object or any string that can be parsed into a valid
date, using DateField.format as the date format, according to the same rules as <a ext:cls="Date" ext:member="parseDate" href="output/Date.html#parseDate">Date.parseDate</a>
(the default format used is "m/d/y").
<br />Usage:
<pre><code>//All of these calls set the same date value (May 4, 2006)
//Pass a date object:
var dt = new Date('5/4/06');
dateField.setValue(dt);
//Pass a date string (default format):
dateField.setValue('5/4/06');
//Pass a date string (custom format):
dateField.format = 'Y-m-d';
dateField.setValue('2006-5-4');</code></pre>The date or valid date string
@hideBase class for form fields that provides default event handling, sizing, value handling and other functionality.Creates a new FieldConfiguration optionsReturns the name attribute of the field if availableReturns true if this field has been changed since it was originally loaded and is not disabled.Resets the current field value to the originally loaded value and clears any validation messagesReturns whether or not the field value is currently validTrue to disable marking the field invalidValidates the field valueMark this field as invalidThe validation messageClear any invalid styles/messages for this fieldReturns the raw data value which may or may not be a valid, defined value. To return a normalized value see <a ext:cls="Ext.form.Field" ext:member="getValue" href="output/Ext.form.Field.html#getValue">getValue</a>.Returns the normalized data value (undefined or emptyText will be returned as ''). To return the raw value see <a ext:cls="Ext.form.Field" ext:member="getRawValue" href="output/Ext.form.Field.html#getRawValue">getRawValue</a>.Sets the underlying DOM field's value directly, bypassing validation. To set the value with validation see <a ext:cls="Ext.form.Field" ext:member="setValue" href="output/Ext.form.Field.html#setValue">setValue</a>.The value to setSets a data value into the field and validates it. To set the value directly without validation see <a ext:cls="Ext.form.Field" ext:member="setRawValue" href="output/Ext.form.Field.html#setRawValue">setRawValue</a>.The value to setStandard container used for grouping form fields.Configuration optionsStandard form container.
<p><b>Although they are not listed, this class also accepts all the config options required to configure its internal <a ext:cls="Ext.form.BasicForm" href="output/Ext.form.BasicForm.html">Ext.form.BasicForm</a></b></p>
<br><br>
By default, Ext Forms are submitted through Ajax, using <a ext:cls="Ext.form.Action" href="output/Ext.form.Action.html">Ext.form.Action</a>.
To enable normal browser submission of the Ext Form contained in this FormPanel,
override the Form's onSubmit, and submit methods:<br><br><pre><code>var myForm = new Ext.form.FormPanel({
onSubmit: Ext.emptyFn,
submit: function() {
this.getEl().dom.submit();
}
});</code></pre><br>Configuration optionsStarts monitoring of the valid state of this form. Usually this is done by passing the config
option "monitorValid"Stops monitoring of the valid state of this formA basic hidden field for storing hidden values in forms that need to be passed in the form submit.Create a new Hidden field.Configuration optionsProvides a lightweight HTML Editor component.
<br><br><b>Note: The focus/blur and validation marking functionality inherited from Ext.form.Field is NOT
supported by this editor.</b><br/><br/>
An Editor is a sensitive component that can't be used in all spots standard fields can be used. Putting an Editor within
any element that has display set to 'none' can cause problems in Safari and Firefox due to their default iframe reloading bugs.Object collection of toolbar tooltips for the buttons in the editor. The key
is the command id associated with that button and the value is a valid QuickTips object.
For example:
<pre><code>{
bold : {
title: 'Bold (Ctrl+B)',
text: 'Make the selected text bold.',
cls: 'x-html-editor-tip'
},
italic : {
title: 'Italic (Ctrl+I)',
text: 'Make the selected text italic.',
cls: 'x-html-editor-tip'
},
...</code></pre>Protected method that will not generally be called directly. It
is called when the editor creates its toolbar. Override this method if you need to
add custom toolbar buttons.Protected method that will not generally be called directly. It
is called when the editor initializes the iframe with HTML contents. Override this method if you
want to change the initialization markup of the iframe (e.g. to add stylesheets).Toggles the editor between standard and source edit mode.(optional) True for source edit, false for standardOverridden and disabled. The editor element does not support standard valid/invalid marking. @hideOverridden and disabled. The editor element does not support standard valid/invalid marking. @hideProtected method that will not generally be called directly. If you need/want
custom HTML cleanup, this is the method you should override.The HTML to be cleaned
return {String} The cleaned HTMLProtected method that will not generally be called directly. Syncs the contents
of the editor iframe with the textarea.Protected method that will not generally be called directly. Pushes the value of the textarea
into the iframe editor.Protected method that will not generally be called directly. It triggers
a toolbar update by reading the markup state of the current selection in the editor.Executes a Midas editor command on the editor document and performs necessary focus and
toolbar updates. <b>This should only be called after the editor is initialized.</b>The Midas command(optional) The value to pass to the command (defaults to null)Executes a Midas editor command directly on the editor document.
For visual commands, you should use <a ext:cls="Ext.form.HtmlEditor" ext:member="relayCmd" href="output/Ext.form.HtmlEditor.html#relayCmd">relayCmd</a> instead.
<b>This should only be called after the editor is initialized.</b>The Midas command(optional) The value to pass to the command (defaults to null)Inserts the passed text at the current cursor position. Note: the editor must be initialized and activated
to insert text.Returns the editor's toolbar. <b>This is only available after the editor has been rendered.</b>Numeric text field that provides automatic keystroke filtering and numeric validation.Creates a new NumberFieldConfiguration optionsSingle radio field. Same as Checkbox, but provided as a convenience for automatically setting the input type.
Radio grouping is handled automatically by the browser if you give each radio in a group the same name.Creates a new RadioConfiguration optionsIf this radio is part of a group, it will return the selected valueMultiline text field. Can be used as a direct replacement for traditional textarea fields, plus adds
support for auto-sizing.Creates a new TextAreaConfiguration optionsAutomatically grows the field to accommodate the height of the text up to the maximum field height allowed.
This only takes effect if grow = true, and fires the autosize event if the height changes.Basic text field. Can be used as a direct replacement for traditional text inputs, or as the base
class for more sophisticated input controls (like <a ext:cls="Ext.form.TextArea" href="output/Ext.form.TextArea.html">Ext.form.TextArea</a> and <a ext:cls="Ext.form.ComboBox" href="output/Ext.form.ComboBox.html">Ext.form.ComboBox</a>).Creates a new TextFieldConfiguration optionsResets the current field value to the originally-loaded value and clears any validation messages.
Also adds emptyText and emptyClass if the original value was blank.Validates a value according to the field's validation rules and marks the field as invalid
if the validation failsThe value to validateSelects text in this field(optional) The index where the selection should start (defaults to 0)(optional) The index where the selection should end (defaults to the text length)Automatically grows the field to accommodate the width of the text up to the maximum field width allowed.
This only takes effect if grow = true, and fires the autosize event.Provides a time input field with a time dropdown and automatic time validation.Create a new TimeField
@hideProvides a convenient wrapper for TextFields that adds a clickable trigger button (looks like a combobox by default).
The trigger has no default action, so you must assign a function to implement the trigger click handler by
overriding <a ext:cls="Ext.form.TriggerField" ext:member="onTriggerClick" href="output/Ext.form.TriggerField.html#onTriggerClick">onTriggerClick</a>. You can create a TriggerField directly, as it renders exactly like a combobox
for which you can provide a custom implementation. For example:
<pre><code>var trigger = new Ext.form.TriggerField();
trigger.onTriggerClick = myTriggerFn;
trigger.applyTo('my-field');</code></pre>
However, in general you will most likely want to use TriggerField as the base class for a reusable component.
<a ext:cls="Ext.form.DateField" href="output/Ext.form.DateField.html">Ext.form.DateField</a> and <a ext:cls="Ext.form.ComboBox" href="output/Ext.form.ComboBox.html">Ext.form.ComboBox</a> are perfect examples of this.Create a new TriggerField.Configuration options (valid {@Ext.form.TextField} config options will also be applied
to the base TextField)@hideThe function that should handle the trigger's click event. This method does nothing by default until overridden
by an implementing function.Overridable validation definitions. The validations provided are basic and intended to be easily customizable and extended.<br><br><i>This class is a singleton and cannot be created directly.</i>The error text to display when the email validation function returns falseThe keystroke filter mask to be applied on email inputThe error text to display when the url validation function returns falseThe error text to display when the alpha validation function returns falseThe keystroke filter mask to be applied on alpha inputThe error text to display when the alphanumeric validation function returns falseThe keystroke filter mask to be applied on alphanumeric inputThe function used to validate email addressesThe email addressThe function used to validate URLsThe URLThe function used to validate alpha valuesThe valueThe function used to validate alphanumeric valuesThe valueAbstract base class for grid SelectionModels. It provides the interface that should be
implemented by descendant classes. This class should not be directly instantiated.Locks the selections.Unlocks the selections.Returns true if the selections are locked.This class provides the basic implementation for cell selection in a grid.The object containing the configuration of this model.Returns the currently selected cell,.Clears all selections.to prevent the gridview from being notified about the change.Returns true if there is a selection.Selects a cell.A custom selection model that renders a column of checkboxes that can be toggled to select or deselect rows.The configuration optionsThis is the default implementation of a ColumnModel used by the Grid. This class is initialized
with an Array of column config objects.
<br><br>
An individual column's config object defines the header string, the <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a>
field the column draws its data from, an otional rendering function to provide customized
data formatting, and the ability to apply a CSS class to all cells in a column through its
<a ext:cls="Ext.grid.ColumnModel" ext:member="id" href="output/Ext.grid.ColumnModel.html#id">id</a> config option.<br>
<br>Usage:<br>
<pre><code>var colModel = new Ext.grid.ColumnModel([
{header: "Ticker", width: 60, sortable: true},
{header: "Company Name", width: 150, sortable: true},
{header: "Market Cap.", width: 100, sortable: true},
{header: "$ Sales", width: 100, sortable: true, renderer: money},
{header: "Employees", width: 100, sortable: true, resizable: false}
]);</code></pre>
<p>
The config options listed for this class are options which may appear in each
individual column definition.An Array of column config objects. See this class's
config objects for details.The config passed into the constructorThe width of columns which have no width specified (defaults to 100)Default sortable of columns which have no sortable specified (defaults to false)
Returns the id of the column at the specified index.The column indexReconfigures this column modelArray of Column configsReturns the column for a specified id.The column idReturns the index for a specified column id.The column idReturns the number of columns.Returns the column configs that return true by the passed function that is called with (columnConfig, index)(optional)Returns true if the specified column is sortable.The column indexReturns the rendering (formatting) function defined for the column.The column index.Sets the rendering (formatting) function for a column.The column indexThe function to use to process the cell's raw data
to return HTML markup for the grid view. The render function is called with
the following parameters:<ul>
<li>Data value.</li>
<li>Cell metadata. An object in which you may set the following attributes:<ul>
<li>css A CSS class name to add to the cell's TD element.</li>
<li>attr An HTML attribute definition string to apply to the data container element <i>within</i> the table cell
(e.g. 'style="color:red;"').</li></ul>
<li>The <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> from which the data was extracted.</li>
<li>Row index</li>
<li>Column index</li>
<li>The <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> object from which the Record was extracted</li></ul>Returns the width for the specified column.The column indexSets the width for a column.The column indexThe new widthReturns the total width of all columns.True to include hidden column widthsReturns the header for the specified column.The column indexSets the header for a column.The column indexThe new headerReturns the tooltip for the specified column.The column indexSets the tooltip for a column.The column indexThe new tooltipReturns the dataIndex for the specified column.The column indexSets the dataIndex for a column.The column indexThe new dataIndexReturns true if the cell is editable.The column indexThe row indexReturns the editor defined for the cell/column.The column indexThe row indexSets if a column is editable.The column indexTrue if the column is editableReturns true if the column is hidden.The column indexReturns true if the column width cannot be changedReturns true if the column can be resizedSets if a column is hidden.The column indexTrue if the column is hiddenSets the editor for a column.The column indexThe editor objectClass for creating and editable grid.Starts editing the specified for the specified row/columnStops any active editingThis class represents the primary interface of a component based grid control.
<br><br>Usage:
<pre><code>var grid = new Ext.grid.GridPanel({
store: new Ext.data.Store({
reader: reader,
data: xg.dummyData
}),
columns: [
{id:'company', header: "Company", width: 200, sortable: true, dataIndex: 'company'},
{header: "Price", width: 120, sortable: true, renderer: Ext.util.Format.usMoney, dataIndex: 'price'},
{header: "Change", width: 120, sortable: true, dataIndex: 'change'},
{header: "% Change", width: 120, sortable: true, dataIndex: 'pctChange'},
{header: "Last Updated", width: 135, sortable: true, renderer: Ext.util.Format.dateRenderer('m/d/Y'), dataIndex: 'lastChange'}
],
viewConfig: {
forceFit: true
},
sm: new Ext.grid.RowSelectionModel({singleSelect:true}),
width:600,
height:300,
frame:true,
title:'Framed with Checkbox Selection and Horizontal Scrolling',
iconCls:'icon-grid'
});</code></pre>
<b>Note:</b> Although this class inherits many configuration options from base classes, some of them
(such as autoScroll, layout, items, etc) won't function as they do with the base Panel class.The config object
Configures the text in the drag proxy (defaults to "{0} selected row(s)").
{0} is replaced with the number of selected rows.Reconfigures the grid to use a different Store and Column Model.
The View will be bound to the new objects and refreshed.The new <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> objectThe new <a ext:cls="Ext.grid.ColumnModel" href="output/Ext.grid.ColumnModel.html">Ext.grid.ColumnModel</a> objectReturns the grid's underlying element.Returns the grid's SelectionModel.Returns the grid's data store.Returns the grid's ColumnModel.Returns the grid's GridView object.Called to get grid's drag proxy text, by default returns this.ddText.<p>This class encapsulates the user interface of an <a ext:cls="Ext.grid.GridPanel" href="output/Ext.grid.GridPanel.html">Ext.grid.GridPanel</a>.
Methods of this class may be used to access user interface elements to enable
special display effects. Do not change the DOM structure of the user interface.</p>
<p>This class does not provide ways to manipulate the underlying data. The data
model of a Grid is held in an <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>.</p>
The amount of space to reserve for the scrollbar (defaults to 19 pixels)The CSS classes applied to a header when it is sorted. (defaults to ["sort-asc", "sort-desc"])The text displayed in the "Sort Ascending" menu itemThe text displayed in the "Sort Descending" menu itemThe text displayed in the "Columns" menu itemOverride this function to apply custom CSS classes to rows during rendering. You can also supply custom
parameters to the row template for the current row to customize how it is rendered using the <b>rowParams</b>
parameter. This function should return the CSS class name (or empty string '' for none) that will be added
to the row's wrapping div. To apply multiple class names, simply return them space-delimited within the string
(e.g., 'my-class another-class').The <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> corresponding to the current rowThe row indexA config object that is passed to the row template during rendering that allows
customization of various aspects of a body row, if applicable. Note that this object will only be applied if
<a ext:cls="Ext.grid.GridView" ext:member="enableRowBody" href="output/Ext.grid.GridView.html#enableRowBody">enableRowBody</a> = true, otherwise it will be ignored. The object may contain any of these properties:<ul>
<li><code>body</code> : String <div class="sub-desc">An HTML fragment to be rendered as the cell's body content (defaults to '').</div></li>
<li><code>bodyStyle</code> : String <div class="sub-desc">A CSS style string that will be applied to the row's TR style attribute (defaults to '').</div></li>
<li><code>cols</code> : Number <div class="sub-desc">The column count to apply to the body row's TD colspan attribute (defaults to the current
column count of the grid).</div></li>
</ul>The <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a> this grid is bound toReturn the <TR> HtmlElement which represents a Grid row for the specified index.The row indexReturns the grid's <TD> HtmlElement at the specified coordinates.The row index in which to find the cell.The column index of the cell.Return the <TD> HtmlElement which represents the Grid's header cell for the specified column index.The column indexScrolls the grid to the topFocuses the specified row..The row indexFocuses the specified cell.The row indexThe column indexRefreshs the grid UI(optional) True to also refresh the headersAdds the ability for single level grouping to the grid.
<pre><code>var grid = new Ext.grid.GridPanel({
// A groupingStore is required for a GroupingView
store: new Ext.data.GroupingStore({
reader: reader,
data: xg.dummyData,
sortInfo:{field: 'company', direction: "ASC"},
groupField:'industry'
}),
columns: [
{id:'company',header: "Company", width: 60, sortable: true, dataIndex: 'company'},
{header: "Price", width: 20, sortable: true, renderer: Ext.util.Format.usMoney, dataIndex: 'price'},
{header: "Change", width: 20, sortable: true, dataIndex: 'change', renderer: Ext.util.Format.usMoney},
{header: "Industry", width: 20, sortable: true, dataIndex: 'industry'},
{header: "Last Updated", width: 20, sortable: true, renderer: Ext.util.Format.dateRenderer('m/d/Y'), dataIndex: 'lastChange'}
],
view: new Ext.grid.GroupingView({
forceFit:true,
// custom grouping text template to display the number of items per group
groupTextTpl: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Items" : "Item"]})'
}),
frame:true,
width: 700,
height: 450,
collapsible: true,
animCollapse: false,
title: 'Grouping Example',
iconCls: 'icon-grid',
renderTo: document.body
});</code></pre>Toggles the specified group if no value is passed, otherwise sets the expanded state of the group to the value passed.The groupId assigned to the group (see getGroupId)(optional)Toggles all groups if no value is passed, otherwise sets the expanded state of all groups to the value passed.(optional)Dynamically tries to determine the groupId of a specific valueA custom column model for the <a ext:cls="Ext.grid.PropertyGrid" href="output/Ext.grid.PropertyGrid.html">Ext.grid.PropertyGrid</a>. Generally it should not need to be used directly.The grid this store will be bound toThe source data config objectA specialized grid implementation intended to mimic the traditional property grid as typically seen in
development IDEs. Each row in the grid represents a property of some object, and the data is stored
as a set of name/value pairs in <a ext:cls="Ext.grid.PropertyRecord" href="output/Ext.grid.PropertyRecord.html">Ext.grid.PropertyRecord</a>s. Example usage:
<pre><code>
var grid = new Ext.grid.PropertyGrid({
title: 'Properties Grid',
autoHeight: true,
width: 300,
renderTo: 'grid-ct',
source: {
"(name)": "My Object",
"Created": new Date(Date.parse('10/15/2006')),
"Available": false,
"Version": .01,
"Description": "A test object"
}
});</pre></code>The grid config objectSets the source data object containing the property data. The data object can contain one or more name/value
pairs representing all of the properties of an object to display in the grid, and this data will automatically
be loaded into the grid's <a ext:cls="Ext.grid.PropertyGrid" ext:member="store" href="output/Ext.grid.PropertyGrid.html#store">store</a>. If the grid already contains data, this method will replace any
existing data. See also the <a ext:cls="Ext.grid.PropertyGrid" ext:member="source" href="output/Ext.grid.PropertyGrid.html#source">source</a> config value. Example usage:
<pre><code>grid.setSource({
"(name)": "My Object",
"Created": new Date(Date.parse('10/15/2006')),
"Available": false,
"Version": .01,
"Description": "A test object"
});</code></pre>The data objectGets the source data object containing the property data. See <a ext:cls="Ext.grid.PropertyGrid" ext:member="setSource" href="output/Ext.grid.PropertyGrid.html#setSource">setSource</a> for details regarding the
format of the data object.A specific <a ext:cls="Ext.data.Record" href="output/Ext.data.Record.html">Ext.data.Record</a> type that represents a name/value pair and is made to work with the
<a ext:cls="Ext.grid.PropertyGrid" href="output/Ext.grid.PropertyGrid.html">Ext.grid.PropertyGrid</a>. Typically, PropertyRecords do not need to be created directly as they can be
created implicitly by simply using the appropriate data configs either via the <a ext:cls="Ext.grid.PropertyGrid" ext:member="source" href="output/Ext.grid.PropertyGrid.html#source">Ext.grid.PropertyGrid.source</a>
config property or by calling <a ext:cls="Ext.grid.PropertyGrid" ext:member="setSource" href="output/Ext.grid.PropertyGrid.html#setSource">Ext.grid.PropertyGrid.setSource</a>. However, if the need arises, these records
can also be created explicitly as shwon below. Example usage:
<pre><code>var rec = new Ext.grid.PropertyRecord({
name: 'Birthday',
value: new Date(Date.parse('05/26/1972'))
});
// Add record to an already populated grid
grid.store.addSorted(rec);</code></pre>A data object in the format: {name: [name], value: [value]}. The specified value's type
will be read automatically by the grid to determine the type of editor to use when displaying it.A custom wrapper for the <a ext:cls="Ext.grid.PropertyGrid" href="output/Ext.grid.PropertyGrid.html">Ext.grid.PropertyGrid</a>'s <a ext:cls="Ext.data.Store" href="output/Ext.data.Store.html">Ext.data.Store</a>. This class handles the mapping
between the custom data source objects supported by the grid and the <a ext:cls="Ext.grid.PropertyRecord" href="output/Ext.grid.PropertyRecord.html">Ext.grid.PropertyRecord</a> format
required for compatibility with the underlying store. Generally this class should not need to be used directly --
the grid's data should be accessed from the underlying store via the <a ext:cls="Ext.grid.PropertyStore" ext:member="store" href="output/Ext.grid.PropertyStore.html#store">store</a> property.The grid this store will be bound toThe source data config objectThis is a utility class that can be passed into a <a ext:cls="Ext.grid.ColumnModel" href="output/Ext.grid.ColumnModel.html">Ext.grid.ColumnModel</a> as a column config that provides
an automatic row numbering column.
<br>Usage:<br>
<pre><code>// This is a typical column config with the first column providing row numbers
var colModel = new Ext.grid.ColumnModel([
new Ext.grid.RowNumberer(),
{header: "Name", width: 80, sortable: true},
{header: "Code", width: 50, sortable: true},
{header: "Description", width: 200, sortable: true}
]);</code></pre>The configuration optionsThe default SelectionModel used by <a ext:cls="Ext.grid.Grid" href="output/Ext.grid.Grid.html">Ext.grid.Grid</a>.
It supports multiple selections and keyboard selection/navigation. <br><br>Select records.The records to select(optional) True to keep existing selectionsGets the number of selected rows.Selects the first row in the grid.Select the last row.(optional) True to keep existing selectionsSelects the row immediately following the last selected row.(optional) True to keep existing selectionsSelects the row that precedes the last selected row.(optional) True to keep existing selectionsReturns true if there is a next record to selectReturns true if there is a previous record to selectReturns the selected recordsReturns the first selected record.Calls the passed function with each selection. If the function returns false, iteration is
stopped and this function returns false. Otherwise it returns true.(optional)Clears all selections.Selects all rows.Returns True if there is a selection.Returns True if the specified row is selected.The record or index of the record to checkReturns True if the specified record id is selected.The id of record to checkSelects multiple rows.Array of the indexes of the row to select(optional) True to keep existing selectionsSelects a range of rows. All rows in between startRow and endRow are also selected.The index of the first row in the rangeThe index of the last row in the range(optional) True to retain existing selectionsDeselects a range of rows. All rows in between startRow and endRow are also deselected.The index of the first row in the rangeThe index of the last row in the rangeSelects a row.The index of the row to select(optional) True to keep existing selectionsDeselects a row.The index of the row to deselect<p>Inherits the anchoring of <a ext:cls="Ext.layout.AnchorLayout" href="output/Ext.layout.AnchorLayout.html">Ext.layout.AnchorLayout</a> and adds the ability for x/y positioning using the
standard x and y component config options.</p>@hide<p>This is a layout that contains multiple panels in an expandable accordion style such that only one
panel can be open at any given time. Each panel has built-in support for expanding and collapsing.
This class is intended to be extended or created via the layout:'accordion' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a>
config, and should generally not need to be created directly via the new keyword.</p>
<p>Note that when creating a layout via config, the layout-specific config properties must be passed in via
the <a ext:cls="Ext.Container" ext:member="layoutConfig" href="output/Ext.Container.html#layoutConfig">Ext.Container.layoutConfig</a> object which will then be applied internally to the layout.
Example usage:</p>
<pre><code>var accordion = new Ext.Panel({
title: 'Accordion Layout',
layout:'accordion',
defaults: {
// applied to each contained panel
bodyStyle: 'padding:15px'
},
layoutConfig: {
// layout-specific configs go here
titleCollapse: false,
animate: true,
activeOnTop: true
}
items: [{
title: 'Panel 1',
html: '<p>Panel content!</p>'
},{
title: 'Panel 2',
html: '<p>Panel content!</p>'
},{
title: 'Panel 3',
html: '<p>Panel content!</p>'
}]
});</code></pre><p>This is a layout that enables anchoring of contained elements relative to the container's dimensions. If
the container is resized, all anchored items are automatically rerendered according to their anchor rules.
This class is intended to be extended or created via the layout:'anchor' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a> config,
and should generally not need to be created directly via the new keyword.</p>
<p>AnchorLayout does not have any direct config options (other than inherited ones). However, the container
using the AnchorLayout can supply an anchoring-specific config property of <b>anchorSize</b>. By default,
AnchorLayout will calculate anchor measurements based on the size of the container itself. However, if
anchorSize is specifed, the layout will use it as a virtual container for the purposes of calculating anchor
measurements based on it instead, allowing the container to be sized independently of the anchoring logic if necessary.</p>
<p>The items added to an AnchorLayout can also supply an anchoring-specific config property of <b>anchor</b> which
is a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%').
This value is what tells the layout how the item should be anchored to the container. The following types of
anchor values are supported:
<ul>
<li><b>Percentage</b>: Any value between 1 and 100, expressed as a percentage. The first anchor is the percentage
width that the item should take up within the container, and the second is the percentage height. Example: '100% 50%'
would render an item the complete width of the container and 1/2 its height. If only one anchor value is supplied
it is assumed to be the width value and the height will default to auto.</li>
<li><b>Offsets</b>: Any positive or negative integer value. The first anchor is the offset from the right edge of
the container, and the second is the offset from the bottom edge. Example: '-50 -100' would render an item the
complete width of the container minus 50 pixels and the complete height minus 100 pixels. If only one anchor value
is supplied it is assumed to be the right offset value and the bottom offset will default to 0.</li>
<li><b>Sides</b>: Valid values are 'right' (or 'r') and 'bottom' (or 'b'). Either the container must have a fixed
size or an anchorSize config value defined at render time in order for these to have any effect.</li>
</ul>
<p>Anchor values can also be mixed as needed. For example, '-50 75%' would render the width offset from the
container right edge by 50 pixels and 75% of the container's height.</p>@hide<p>This is a multi-pane, application-oriented UI layout style that supports multiple nested panels, automatic
split bars between regions and built-in expanding and collapsing of regions.
This class is intended to be extended or created via the layout:'border' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a> config,
and should generally not need to be created directly via the new keyword.</p>
<p>BorderLayout does not have any direct config options (other than inherited ones). All configs available
for customizing the BorderLayout are at the <a ext:cls="Ext.layout.BorderLayout.Region" href="output/Ext.layout.BorderLayout.Region.html">Ext.layout.BorderLayout.Region</a> and
<a ext:cls="Ext.layout.BorderLayout.SplitRegion" href="output/Ext.layout.BorderLayout.SplitRegion.html">Ext.layout.BorderLayout.SplitRegion</a> levels. Example usage:</p>
<pre><code>var border = new Ext.Panel({
title: 'Border Layout',
layout:'border',
items: [{
title: 'South Panel',
region: 'south',
height: 100,
minSize: 75,
maxSize: 250,
margins: '0 5 5 5'
},{
title: 'West Panel',
region:'west',
margins: '5 0 0 5',
cmargins: '5 5 0 5',
width: 200,
minSize: 100,
maxSize: 300
},{
title: 'Main Content',
region:'center',
margins: '5 5 0 0'
}]
});</code></pre>@hideThis is a region of a BorderLayout that acts as a subcontainer within the layout. Each region has its own
layout that is independent of other regions and the containing BorderLayout, and can be any of the valid
Ext layout types. Region size is managed automatically and cannot be changed by the user -- for resizable
regions, see <a ext:cls="Ext.layout.BorderLayout.SplitRegion" href="output/Ext.layout.BorderLayout.SplitRegion.html">Ext.layout.BorderLayout.SplitRegion</a>.Create a new Region.Any valid Ext layout classThe configuration optionsThe region position. Valid values are: north, south, east, west and center. Every
BorderLayout must have a center region for the primary content -- all other regions are optional.True if this region is collapsed. Read-only.
This region's layout position (north, south, east, west or center). Read-only.True if this region is currently visible, else false.Returns the current margins for this region. If the region is collapsed, the cmargins (collapsed
margins) value will be returned, otherwise the margins value will be returned.Returns the current size of this region. If the region is collapsed, the size of the collapsedEl will
be returned, otherwise the size of the region's panel will be returned.Sets the specified panel as the container element for this region.The new panelReturns the minimum allowable width for this region.Returns the minimum allowable height for this region.This is a specialized type of BorderLayout region that has a built-in <a ext:cls="Ext.SplitBar" href="output/Ext.SplitBar.html">Ext.SplitBar</a> for user resizing of regions.Create a new SplitRegion.Any valid Ext layout classThe configuration optionsThe region position. Valid values are: north, south, east, west and center. Every
BorderLayout must have a center region for the primary content -- all other regions are optional.Returns a reference to the split bar in use by this region.<p>This layout contains multiple panels, each fit to the container, where only a single panel can be
visible at any given time. This layout style is most commonly used for wizards, tab implementations, etc.
This class is intended to be extended or created via the layout:'card' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a> config,
and should generally not need to be created directly via the new keyword.</p>
<p>The CardLayout's focal method is <a ext:cls="Ext.layout.CardLayout" ext:member="setActiveItem" href="output/Ext.layout.CardLayout.html#setActiveItem">setActiveItem</a>. Since only one panel is displayed at a time,
the only way to move from one panel to the next is by calling setActiveItem, passing the id or index of
the next panel to display. The layout itself does not provide a mechanism for handling this navigation,
so that functionality must be provided by the developer.</p>
<p>In the following example, a simplistic wizard setup is demonstrated. A button bar is added
to the footer of the containing panel to provide navigation buttons. The buttons will be handled by a
common navigation routine -- for this example, the implementation of that routine has been ommitted since
it can be any type of custom logic. Note that other uses of a CardLayout (like a tab control) would require a
completely different implementation. For serious implementations, a better approach would be to extend
CardLayout to provide the custom functionality needed. Example usage:</p>
<pre><code>var navHandler = function(direction){
// This routine could contain business logic required to manage the navigation steps.
// It would call setActiveItem as needed, manage navigation button state, handle any
// branching logic that might be required, handle alternate actions like cancellation
// or finalization, etc. A complete wizard implementation could get pretty
// sophisticated depending on the complexity required, and should probably be
// done as a subclass of CardLayout in a real-world implementation.
};
var card = new Ext.Panel({
title: 'Example Wizard',
layout:'card',
activeItem: 0, // make sure the active item is set on the container config!
bodyStyle: 'padding:15px',
defaults: {
// applied to each contained panel
border:false
},
// just an example of one possible navigation scheme, using buttons
bbar: [
{
id: 'move-prev',
text: 'Back',
handler: navHandler.createDelegate(this, [-1]),
disabled: true
},
'->', // greedy spacer so that the buttons are aligned to each side
{
id: 'move-next',
text: 'Next',
handler: navHandler.createDelegate(this, [1])
}
],
// the panels (or "cards") within the layout
items: [{
id: 'card-0',
html: '<h1>Welcome to the Wizard!</h1><p>Step 1 of 3</p>'
},{
id: 'card-1',
html: '<p>Step 2 of 3</p>'
},{
id: 'card-2',
html: '<h1>Congratulations!</h1><p>Step 3 of 3 - Complete</p>'
}]
});</code></pre>Sets the active (visible) item in the layout.The string component id or numeric index of the item to activate<p>This is the layout style of choice for creating structural layouts in a multi-column format where the width of
each column can be specified as a percentage or fixed width, but the height is allowed to vary based on the content.
This class is intended to be extended or created via the layout:'column' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a> config,
and should generally not need to be created directly via the new keyword.</p>
<p>ColumnLayout does not have any direct config options (other than inherited ones), but it does support a
specific config property of <b>columnWidth</b> that can be included in the config of any panel added to it. The
layout will use the width (if pixels) or columnWidth (if percent) of each panel during layout to determine how to size each panel.
If width or columnWidth is not specified for a given panel, its width will default to the panel's width (or auto).</p>
<p>The width property is evaluated as pixels must be a number greater than or equal to 1. The columnWidth property
is evaluated as percentage width and must be a decimal value greater than 0 and less than 1 (e.g., .25).</p>
<p>The basic rules for specifying column widths are pretty simple. The logic makes two passes through the
set of contained panels. During the first layout pass, all panels that either have a fixed width or none
specified (auto) are skipped, but their widths are subtracted from the overall container width. During the second
pass, all panels with columnWidths are assigned pixel widths in proportion to their percentages based on
the total <b>remaining</b> container width. In other words, percentage width panels are designed to fill the space
left over by all the fixed-width or auto-width panels. Because of this, while you can specify any number of columns
with different percentages, the columnWidths must always add up to 1 (or 100%) when added together, otherwise your
layout may not render as expected. Example usage:</p>
<pre><code>// All columns are percentages -- they must add up to 1
var p = new Ext.Panel({
title: 'Column Layout - Percentage Only',
layout:'column',
items: [{
title: 'Column 1',
columnWidth: .25
},{
title: 'Column 2',
columnWidth: .6
},{
title: 'Column 3',
columnWidth: .15
}]
});
// Mix of width and columnWidth -- all columnWidth values values must add
// up to 1. The first column will take up exactly 120px, and the last two
// columns will fill the remaining container width.
var p = new Ext.Panel({
title: 'Column Layout - Mixed',
layout:'column',
items: [{
title: 'Column 1',
width: 120
},{
title: 'Column 2',
columnWidth: .8
},{
title: 'Column 3',
columnWidth: .2
}]
});</code></pre>@hideEvery layout is composed of one or more <a ext:cls="Ext.Container" href="output/Ext.Container.html">Ext.Container</a> elements internally, and ContainerLayout provides
the basic foundation for all other layout classes in Ext. It is a non-visual class that simply provides the
base logic required for a Container to function as a layout. This class is intended to be extended and should
generally not need to be created directly via the new keyword.
A reference to the <a ext:cls="Ext.Component" href="output/Ext.Component.html">Ext.Component</a> that is active. For example,
if(myPanel.layout.activeItem.id == 'item-1') { ... }. activeItem only applies to layout styles that can
display items one at a time (like <a ext:cls="Ext.layout.Accordion" href="output/Ext.layout.Accordion.html">Ext.layout.Accordion</a>, <a ext:cls="Ext.layout.CardLayout" href="output/Ext.layout.CardLayout.html">Ext.layout.CardLayout</a>
and <a ext:cls="Ext.layout.FitLayout" href="output/Ext.layout.FitLayout.html">Ext.layout.FitLayout</a>). Read-only. Related to <a ext:cls="Ext.Container" ext:member="activeItem" href="output/Ext.Container.html#activeItem">Ext.Container.activeItem</a>.<p>This is a base class for layouts that contain a single item that automatically expands to fill the layout's
container. This class is intended to be extended or created via the layout:'fit' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a>
config, and should generally not need to be created directly via the new keyword.</p>
<p>FitLayout does not have any direct config options (other than inherited ones). To fit a panel to a container
using FitLayout, simply set layout:'fit' on the container and add a single panel to it. If the container has
multiple panels, only the first one will be displayed. Example usage:</p>
<pre><code>var p = new Ext.Panel({
title: 'Fit Layout',
layout:'fit',
items: {
title: 'Inner Panel',
html: '<p>This is the inner panel content</p>',
border: false
}
});</code></pre><p>This is a layout specifically designed for creating forms.
This class can be extended or created via the layout:'form' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a> config,
and should generally not need to be created directly via the new keyword. However, when used in an application,
it will usually be preferrable to use a <a ext:cls="Ext.FormPanel" href="output/Ext.FormPanel.html">Ext.FormPanel</a> (which automatically uses FormLayout as its layout
class) since it also provides built-in functionality for loading, validating and submitting the form.</p>
<p>Note that when creating a layout via config, the layout-specific config properties must be passed in via
the <a ext:cls="Ext.Container" ext:member="layoutConfig" href="output/Ext.Container.html#layoutConfig">Ext.Container.layoutConfig</a> object which will then be applied internally to the layout. The container
using the FormLayout can also supply the following form-specific config properties which will be applied by the layout:
<ul>
<li><b>hideLabels</b>: (Boolean) True to hide field labels by default (defaults to false)</li>
<li><b>itemCls</b>: (String) A CSS class to add to the div wrapper that contains each field label
and field element (the default class is 'x-form-item' and itemCls will be added to that)</li>
<li><b>labelAlign</b>: (String) The default label alignment. The default value is empty string ''
for left alignment, but specifying 'top' will align the labels above the fields.</li>
<li><b>labelPad</b>: (Number) The default padding in pixels for field labels (defaults to 5). labelPad only
applies if labelWidth is also specified, otherwise it will be ignored.</li>
<li><b>labelWidth</b>: (Number) The default width in pixels of field labels (defaults to 100)</li>
</ul></p>
<p>Any type of components can be added to a FormLayout, but items that inherit from <a ext:cls="Ext.form.Field" href="output/Ext.form.Field.html">Ext.form.Field</a>
can also supply the following field-specific config properties:
<ul>
<li><b>clearCls</b>: (String) The CSS class to apply to the special clearing div rendered directly after each
form field wrapper (defaults to 'x-form-clear-left')</li>
<li><b>fieldLabel</b>: (String) The text to display as the label for this field (defaults to '')</li>
<li><b>hideLabel</b>: (Boolean) True to hide the label and separator for this field (defaults to false).</li>
<li><b>itemCls</b>: (String) A CSS class to add to the div wrapper that contains this field label
and field element (the default class is 'x-form-item' and itemCls will be added to that). If supplied,
itemCls at the field level will override the default itemCls supplied at the container level.</li>
<li><b>labelSeparator</b>: (String) The separator to display after the text of the label for this field
(defaults to a colon ':' or the layout's value for <a ext:cls="Ext.layout.FormLayout" ext:member="labelSeparator" href="output/Ext.layout.FormLayout.html#labelSeparator">labelSeparator</a>). To hide the separator use empty string ''.</li>
<li><b>labelStyle</b>: (String) A CSS style specification string to add to the field label for this field
(defaults to '' or the layout's value for <a ext:cls="Ext.layout.FormLayout" ext:member="labelStyle" href="output/Ext.layout.FormLayout.html#labelStyle">labelStyle</a>).</li>
</ul>
Example usage:</p>
<pre><code>// Required if showing validation messages
Ext.QuickTips.init();
// While you can create a basic Panel with layout:'form', practically
// you should usually use a FormPanel to also get its form functionality
// since it already creates a FormLayout internally.
var form = new Ext.FormPanel({
labelWidth: 75,
title: 'Form Layout',
bodyStyle:'padding:15px',
width: 350,
labelPad: 10,
defaultType: 'textfield',
defaults: {
// applied to each contained item
width: 230,
msgTarget: 'side'
},
layoutConfig: {
// layout-specific configs go here
labelSeparator: ''
},
items: [{
fieldLabel: 'First Name',
name: 'first',
allowBlank: false
},{
fieldLabel: 'Last Name',
name: 'last'
},{
fieldLabel: 'Company',
name: 'company'
},{
fieldLabel: 'Email',
name: 'email',
vtype:'email'
}
],
buttons: [{
text: 'Save'
},{
text: 'Cancel'
}]
});</code></pre>@hide<p>This layout allows you to easily render content into an HTML table. The total number of columns can be
specified, and rowspan and colspan can be used to create complex layouts within the table.
This class is intended to be extended or created via the layout:'table' <a ext:cls="Ext.Container" ext:member="layout" href="output/Ext.Container.html#layout">Ext.Container.layout</a> config,
and should generally not need to be created directly via the new keyword.</p>
<p>Note that when creating a layout via config, the layout-specific config properties must be passed in via
the <a ext:cls="Ext.Container" ext:member="layoutConfig" href="output/Ext.Container.html#layoutConfig">Ext.Container.layoutConfig</a> object which will then be applied internally to the layout. In the
case of TableLayout, the only valid layout config property is <a ext:cls="Ext.layout.TableLayout" ext:member="columns" href="output/Ext.layout.TableLayout.html#columns">columns</a>. However, the items added to a
TableLayout can supply table-specific config properties of <b>rowspan</b> and <b>colspan</b>, as explained below.</p>
<p>The basic concept of building up a TableLayout is conceptually very similar to building up a standard
HTML table. You simply add each panel (or "cell") that you want to include along with any span attributes
specified as the special config properties of rowspan and colspan which work exactly like their HTML counterparts.
Rather than explicitly creating and nesting rows and columns as you would in HTML, you simply specify the
total column count in the layoutConfig and start adding panels in their natural order from left to right,
top to bottom. The layout will automatically figure out, based on the column count, rowspans and colspans,
how to position each panel within the table. Just like with HTML tables, your rowspans and colspans must add
up correctly in your overall layout or you'll end up with missing and/or extra cells! Example usage:</p>
<pre><code>// This code will generate a layout table that is 3 columns by 2 rows
// with some spanning included. The basic layout will be:
// +--------+-----------------+
// | A | B |
// | |--------+--------|
// | | C | D |
// +--------+--------+--------+
var table = new Ext.Panel({
title: 'Table Layout',
layout:'table',
defaults: {
// applied to each contained panel
bodyStyle:'padding:20px'
},
layoutConfig: {
// The total column count must be specified here
columns: 3
},
items: [{
html: '<p>Cell A content</p>',
rowspan: 2
},{
html: '<p>Cell B content</p>',
colspan: 2
},{
html: '<p>Cell C content</p>'
},{
html: '<p>Cell D content</p>'
}]
});</code></pre>@hideA base utility class that adapts a non-menu component so that it can be wrapped by a menu item and added to a menu.
It provides basic rendering, activation management and enable/disable logic required to work in menus.Creates a new AdapterThe component being adapted to render into a menuConfiguration optionsThe base class for all items that render into menus. BaseItem provides default rendering, activated state
management and base configuration options shared by all menu components.Creates a new BaseItemConfiguration optionsSets the function that will handle click events for this item (equivalent to passing in the <a ext:cls="Ext.menu.BaseItem" ext:member="handler" href="output/Ext.menu.BaseItem.html#handler">handler</a>
config property). If an existing handler is already registered, it will be unregistered for you.The function that should be called on clickThe scope that should be passed to the handlerAdds a menu item that contains a checkbox by default, but can also be part of a radio group.Creates a new CheckItemConfiguration optionsA function that handles the checkchange event. The function is undefined by default, but if an implementation
is provided, it will be called automatically when the checkchange event fires.The checked value that was setSet the checked state of this itemThe new checked value(optional) True to prevent the checkchange event from firing (defaults to false)A menu item that wraps the <a ext:cls="Ext.ColorPalette" href="output/Ext.ColorPalette.html">Ext.ColorPalette</a> component.Creates a new ColorItemConfiguration optionsThe Ext.ColorPalette objectA menu containing a <a ext:cls="Ext.menu.ColorItem" href="output/Ext.menu.ColorItem.html">Ext.menu.ColorItem</a> component (which provides a basic color picker).Creates a new ColorMenuConfiguration optionsThe <a ext:cls="Ext.ColorPalette" href="output/Ext.ColorPalette.html">Ext.ColorPalette</a> instance for this ColorMenuA menu item that wraps the <a ext:cls="Ext.DatPicker" href="output/Ext.DatPicker.html">Ext.DatPicker</a> component.Creates a new DateItemConfiguration optionsThe Ext.DatePicker objectA menu containing a <a ext:cls="Ext.menu.DateItem" href="output/Ext.menu.DateItem.html">Ext.menu.DateItem</a> component (which provides a date picker).Creates a new DateMenuConfiguration optionsThe <a ext:cls="Ext.DatePicker" href="output/Ext.DatePicker.html">Ext.DatePicker</a> instance for this DateMenuA base class for all menu items that require menu-related functionality (like sub-menus) and are not static
display items. Item extends the base functionality of <a ext:cls="Ext.menu.BaseItem" href="output/Ext.menu.BaseItem.html">Ext.menu.BaseItem</a> by adding menu-specific
activation and click handling.Creates a new ItemConfiguration optionsSets the text to display in this menu itemThe text to displaySets the CSS class to apply to the item's icon elementThe CSS class to applyA menu object. This is the container to which you add all other menu items. Menu can also serve a as a base class
when you want a specialzed menu based off of another component (like <a ext:cls="Ext.menu.DateMenu" href="output/Ext.menu.DateMenu.html">Ext.menu.DateMenu</a> for example).Creates a new MenuConfiguration optionsRead-only. Returns true if the menu is currently displayed, else false.Displays this menu relative to another elementThe element to align to(optional) The <a ext:cls="Ext.Element" ext:member="alignTo" href="output/Ext.Element.html#alignTo">Ext.Element.alignTo</a> anchor position to use in aligning to
the element (defaults to this.defaultAlign)(optional) This menu's parent menu, if applicable (defaults to undefined)Displays this menu at a specific xy positionContains X & Y [x, y] values for the position at which to show the menu (coordinates are page-based)(optional) This menu's parent menu, if applicable (defaults to undefined)Hides this menu and optionally all parent menus(optional) True to hide all parent menus recursively, if any (defaults to false)Adds one or more items of any type supported by the Menu class, or that can be converted into menu items.
Any of the following are valid:
<ul>
<li>Any menu item object based on <a ext:cls="Ext.menu.Item" href="output/Ext.menu.Item.html">Ext.menu.Item</a></li>
<li>An HTMLElement object which will be converted to a menu item</li>
<li>A menu item config object that will be created as a new menu item</li>
<li>A string, which can either be '-' or 'separator' to add a menu separator, otherwise
it will be converted into a <a ext:cls="Ext.menu.TextItem" href="output/Ext.menu.TextItem.html">Ext.menu.TextItem</a> and added</li>
</ul>
Usage:
<pre><code>// Create the menu
var menu = new Ext.menu.Menu();
// Create a menu item to add by reference
var menuItem = new Ext.menu.Item({ text: 'New Item!' });
// Add a bunch of items at once using different methods.
// Only the last item added will be returned.
var item = menu.add(
menuItem, // add existing item by ref
'Dynamic Item', // new TextItem
'-', // new separator
{ text: 'Config Item' } // new item by config
);</code></pre>One or more menu items, menu item configs or other objects that can be converted to menu itemsReturns this menu's underlying <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a> objectAdds a separator bar to the menuAdds an <a ext:cls="Ext.Element" href="output/Ext.Element.html">Ext.Element</a> object to the menuThe element or DOM node to add, or its idAdds an existing object based on <a ext:cls="Ext.menu.Item" href="output/Ext.menu.Item.html">Ext.menu.Item</a> to the menuThe menu item to addCreates a new <a ext:cls="Ext.menu.Item" href="output/Ext.menu.Item.html">Ext.menu.Item</a> based an the supplied config object and adds it to the menuA MenuItem config objectCreates a new <a ext:cls="Ext.menu.TextItem" href="output/Ext.menu.TextItem.html">Ext.menu.TextItem</a> with the supplied text and adds it to the menuThe text to display in the menu itemInserts an existing object based on <a ext:cls="Ext.menu.Item" href="output/Ext.menu.Item.html">Ext.menu.Item</a> to the menu at a specified indexThe index in the menu's list of current items where the new item should be insertedThe menu item to addRemoves an <a ext:cls="Ext.menu.Item" href="output/Ext.menu.Item.html">Ext.menu.Item</a> from the menu and destroys the objectThe menu item to removeRemoves and destroys all items in the menuProvides a common registry of all menu items on a page so that they can be easily accessed by id.<br><br><i>This class is a singleton and cannot be created directly.</i>Hides all menus that are currently visibleReturns a <a ext:cls="Ext.menu.Menu" href="output/Ext.menu.Menu.html">Ext.menu.Menu</a> objectThe string menu id, an existing menu object reference, or a Menu config that will
be used to generate and return a new Menu instance.Adds a separator bar to a menu, used to divide logical groups of menu items. Generally you will
add one of these by using "-" in you call to add() or in your items config rather than creating one directly.Configuration optionsAdds a static text string to a menu, usually used as either a heading or group separator.Creates a new TextItemThe text to displayThe default Provider implementation which saves state via cookies.
<br />Usage:
<pre><code>var cp = new Ext.state.CookieProvider({
path: "/cgi-bin/",
expires: new Date(new Date().getTime()+(1000*60*60*24*30)), //30 days
domain: "extjs.com"
});
Ext.state.Manager.setProvider(cp);</code></pre>Create a new CookieProviderThe configuration objectThis is the global state manager. By default all components that are "state aware" check this class
for state information if you don't pass them a custom state provider. In order for this class
to be useful, it must be initialized with a provider when your application initializes.
<pre><code>// in your initialization function
init : function(){
Ext.state.Manager.setProvider(new Ext.state.CookieProvider());
...
// supposed you have a <a ext:cls="Ext.BorderLayout" href="output/Ext.BorderLayout.html">Ext.BorderLayout</a>
var layout = new Ext.BorderLayout(...);
layout.restoreState();
// or a {Ext.BasicDialog}
var dialog = new Ext.BasicDialog(...);
dialog.restoreState();</code></pre><br><br><i>This class is a singleton and cannot be created directly.</i>Configures the default state provider for your applicationThe state provider to setReturns the current value for a keyThe key nameThe default value to return if the key lookup does not matchSets the value for a keyThe key nameThe state dataClears a value from the stateThe key nameGets the currently configured state providerAbstract base class for state provider implementations. This class provides methods
for encoding and decoding <b>typed</b> variables including dates and defines the
Provider interface.Returns the current value for a keyThe key nameA default value to return if the key's value is not foundClears a value from the stateThe key nameSets the value for a keyThe key nameThe value to setDecodes a string previously encoded with <a ext:cls="Ext.state.Provider" ext:member="encodeValue" href="output/Ext.state.Provider.html#encodeValue">encodeValue</a>.The value to decodeEncodes a value including type information. Decode with <a ext:cls="Ext.state.Provider" ext:member="decodeValue" href="output/Ext.state.Provider.html#decodeValue">decodeValue</a>.The value to encodeThe attributes/config for the node or just a string with the text for the node
The loader used by this node (defaults to using the tree's defined loader)Returns true if this node is currently loadingReturns true if this node has been loadedTrigger a reload for this nodeThe default single selection for a TreePanel.Select a node.The node to selectDeselect a node.The node to unselectClear all selectionsGet the selected nodeReturns true if the node is selectedThe node to checkSelects the node above the selected node in the tree, intelligently walking the nodesSelects the node above the selected node in the tree, intelligently walking the nodesMulti selection for a TreePanel.Select a node.The node to select(optional) An event associated with the selectionTrue to retain existing selectionsDeselect a node.The node to unselectClear all selectionsReturns true if the node is selectedThe node to checkReturns an array of the selected nodesThis class provides the default UI implementation for <b>root</b> Ext TreeNodes.
The RootTreeNode UI implementation allows customizing the appearance of the root tree node.<br>
<p>
If you are customizing the Tree's user interface, you
may need to extend this class, but you should never need to instantiate this class.<br>The <a ext:cls="Ext.tree.TreePanel" href="output/Ext.tree.TreePanel.html">Ext.tree.TreePanel</a> for which to enable draggingThe TreePanel for this drag zoneThe <a ext:cls="Ext.tree.TreePanel" href="output/Ext.tree.TreePanel.html">Ext.tree.TreePanel</a> for which to enable droppingThe TreePanel for this drop zoneArbitrary data that can be associated with this tree and will be included in the event object that gets
passed to any nodedragover event handler (defaults to {})Provides editor functionality for inline tree node editing. Any valid <a ext:cls="Ext.form.Field" href="output/Ext.form.Field.html">Ext.form.Field</a> can be used
as the editor field.Either a prebuilt <a ext:cls="Ext.form.Field" href="output/Ext.form.Field.html">Ext.form.Field</a> instance or a Field config objectNote this class is experimental and doesn't update the indent (lines) or expand collapse icons of the nodesFilter the data by a specific attribute.Either string that the attribute value
should start with or a RegExp to test against the attribute(optional) The attribute passed in your node's attributes collection. Defaults to "text".(optional) The node to start the filter at.Filter by a function. The passed function will be called with each
node in the tree (or from the startNode). If the function returns true, the node is kept
otherwise it is filtered. If a node is filtered, its children are also filtered.The filter function(optional) The scope of the function (defaults to the current node)Clears the current filter. Note: with the "remove" option
set a filter cannot be cleared.A TreeLoader provides for lazy loading of an <a ext:cls="Ext.tree.TreeNode" href="output/Ext.tree.TreeNode.html">Ext.tree.TreeNode</a>'s child
nodes from a specified URL. The response must be a JavaScript Array definition
whose elements are node definition objects. eg:
<pre><code>[{
id: 1,
text: 'A leaf Node',
leaf: true
},{
id: 2,
text: 'A folder Node',
children: [{
id: 3,
text: 'A child Node',
leaf: true
}]
}]</code></pre>
<br><br>
A server request is sent, and child nodes are loaded only when a node is expanded.
The loading node's id is passed to the server under the parameter name "node" to
enable the server to produce the correct child nodes.
<br><br>
To pass extra parameters, an event handler may be attached to the "beforeload"
event, and the parameters specified in the TreeLoader's baseParams property:
<pre><code>myTreeLoader.on("beforeload", function(treeLoader, node) {
this.baseParams.category = node.attributes.category;
}, this);</code></pre><
This would pass an HTTP parameter called "category" to the server containing
the value of the Node's "category" attribute.Creates a new Treeloader.A config object containing config properties.Load an <a ext:cls="Ext.tree.TreeNode" href="output/Ext.tree.TreeNode.html">Ext.tree.TreeNode</a> from the URL specified in the constructor.
This is called automatically when a node is expanded, but may be used to reload
a node (or append new children if the <a ext:cls="Ext.tree.TreeLoader" ext:member="clearOnLoad" href="output/Ext.tree.TreeLoader.html#clearOnLoad">clearOnLoad</a> option is false.)Override this function for custom TreeNode node implementationThe attributes/config for the node or just a string with the text for the nodeRead-only. The text for this node. To change it use setText().True if this node is disabled.Read-only. The UI for this nodeReturns true if this node is expandedReturns the UI object for this node.Sets the text for this nodeTriggers selection of this nodeTriggers deselection of this nodeReturns true if this node is selectedExpand this node.(optional) True to expand all children as well(optional) false to cancel the default animation(optional) A callback to be called when
expanding this node completes (does not wait for deep expand to complete).
Called with 1 parameter, this node.Collapse this node.(optional) True to collapse all children as well(optional) false to cancel the default animationToggles expanded/collapsed state of the nodeEnsures all parent nodes are expandedExpand all child nodes(optional) true if the child nodes should also expand their child nodesCollapse all child nodes(optional) true if the child nodes should also collapse their child nodesDisables this nodeEnables this nodeThis class provides the default UI implementation for Ext TreeNodes.
The TreeNode UI implementation is separate from the
tree implementation, and allows customizing of the appearance of
tree nodes.<br>
<p>
If you are customizing the Tree's user interface, you
may need to extend this class, but you should never need to instantiate this class.<br>
<p>
This class provides access to the user interface components of an Ext TreeNode, through
<a ext:cls="Ext.tree.TreeNode" ext:member="getUI" href="output/Ext.tree.TreeNode.html#getUI">Ext.tree.TreeNode.getUI</a>Adds one or more CSS classes to the node's UI element.
Duplicate classes are automatically filtered out.The CSS class to add, or an array of classesRemoves one or more CSS classes from the node's UI element.The CSS class to remove, or an array of classesHides this node.Shows this node.Sets the checked status of the tree node to the passed value, or, if no value was passed,
toggles the checked status. If the node was rendered with no checkbox, this has no effect.The new checked status.Returns the <a> element that provides focus for the node's UI.Returns the text node.Returns the icon <img> element.Returns the checked status of the node. If the node was rendered with no
checkbox, it returns false.The root node for this treeThe dropZone used by this tree if drop is enabledThe dragZone used by this tree if drag is enabledReturns this root node for this treeSets the root node for this tree during initialization.Gets a node in this tree by its idRetrieve an array of checked nodes, or an array of a specific attribute of checked nodes (e.g. "id")(optional) Defaults to null (return the actual nodes)(optional) The node to start from, defaults to the rootReturns the container element for this TreePanel.Returns the default <a ext:cls="Ext.tree.TreeLoader" href="output/Ext.tree.TreeLoader.html">Ext.tree.TreeLoader</a> for this TreePanel.Expand all nodesCollapse all nodesReturns the selection model used by this TreePanel.Expands a specified path in this TreePanel. A path can be retrieved from a node with <a ext:cls="Ext.data.Node" ext:member="getPath" href="output/Ext.data.Node.html#getPath">Ext.data.Node.getPath</a>(optional) The attribute used in the path (see <a ext:cls="Ext.data.Node" ext:member="getPath" href="output/Ext.data.Node.html#getPath">Ext.data.Node.getPath</a> for more info)(optional) The callback to call when the expand is complete. The callback will be called with
(bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded.Selects the node in this tree at the specified path. A path can be retrieved from a node with <a ext:cls="Ext.data.Node" ext:member="getPath" href="output/Ext.data.Node.html#getPath">Ext.data.Node.getPath</a>(optional) The attribute used in the path (see <a ext:cls="Ext.data.Node" ext:member="getPath" href="output/Ext.data.Node.html#getPath">Ext.data.Node.getPath</a> for more info)(optional) The callback to call when the selection is complete. The callback will be called with
(bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node.Returns the underlying Element for this treeProvides sorting of nodes in a TreePanelUtility class for manipulating CSS rules<br><br><i>This class is a singleton and cannot be created directly.</i>Create a stylesheet from a text blob of CSS rules.The text containing the css rulesAn id to add to the stylesheet for later removalRemoves a style or link tag by idThe id of the tagDynamically swaps an existing stylesheet reference for a new oneThe id of an existing link tag to removeThe href of the new stylesheet to includeRefresh the rule cache if you have dynamically added stylesheetsGets all css rules for the documenttrue to refresh the internal cacheGets an an individual CSS rule by selector(s)The CSS selector or an array of selectors to try. The first selector that is found is returned.true to refresh the internal cache if you have recently updated any rules or added styles dynamicallyUpdates a rule propertyIf it's an array it tries each selector until it finds one. Stops immediately once one is found.The css propertyThe new value for the propertyA wrapper class which can be applied to any element. Fires a "click" event while the
mouse is pressed. The interval between firings may be specified in the config but
defaults to 20 milliseconds.
Optionally, a CSS class may be applied to the element during the time it is pressed.The element to listen onProvides a convenient method of performing setTimeout where a new
timeout cancels the old timeout. An example would be performing validation on a keypress.
You can use this class to buffer
the keypress events for a certain number of milliseconds, and perform only if they stop
for that amount of time.The parameters to this constructor serve as defaults and are not required.(optional) The default function to timeout(optional) The default scope of that timeout(optional) The default Array of argumentsCancels any pending timeout and queues a new oneThe milliseconds to delay(optional) Overrides function passed to constructor(optional) Overrides scope passed to constructor(optional) Overrides args passed to constructorCancel the last queued timeoutReusable data formatting functions<br><br><i>This class is a singleton and cannot be created directly.</i>Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified lengthThe string to truncateThe maximum length to allow before truncatingChecks a reference and converts it to empty string if it is undefinedReference to checkChecks a reference and converts it to the default value if it's emptyReference to checkThe value to insert of it's undefined (defaults to "")Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.The string to encodeConvert certain characters (&, <, >, and ') from their HTML character equivalents.The string to decodeTrims any whitespace from either side of a stringThe text to trimReturns a substring from within an original stringThe original textThe start index of the substringThe length of the substringConverts a string to all lower case lettersThe text to convertConverts a string to all upper case lettersThe text to convertConverts the first character only of a string to upper caseThe text to convertFormat a number as US currencyThe numeric value to formatParse a value into a formatted date using the specified format pattern.The value to format(optional) Any valid date format string (defaults to 'm/d/Y')Returns a date rendering function that can be reused to apply a date format multiple times efficientlyAny valid date format stringStrips all HTML tagsThe text from which to strip tagsStrips all script tagsThe text from which to strip script tagsSimple format for a file size (xxx bytes, xxx KB, xxx MB)The numeric value to formatModified version of Douglas Crockford"s json.js that doesn"t
mess with the Object prototype
http://www.json.org/js.html<br><br><i>This class is a singleton and cannot be created directly.</i>Encodes an Object, Array or other valueThe variable to encodeDecodes (parses) a JSON string to an object. If the JSON is invalid, this function throws a SyntaxError.The JSON stringA Collection class that maintains both numeric indexes and keys and exposes events.True if the addAll function should add function references to the
collection (defaults to false)A function that can accept an item of the type(s) stored in this MixedCollection
and return the key value for that item. This is used when available to look up the key on items that
were passed without an explicit key parameter to a MixedCollection method. Passing this parameter is
equivalent to providing an implementation for the <a ext:cls="Ext.util.MixedCollection" ext:member="getKey" href="output/Ext.util.MixedCollection.html#getKey">getKey</a> method.Adds an item to the collection. Fires the <a ext:cls="Ext.util.MixedCollection" ext:member="add" href="output/Ext.util.MixedCollection.html#add">add</a> event when complete.The key to associate with the itemThe item to add.MixedCollection has a generic way to fetch keys if you implement getKey.
<pre><code>// normal way
var mc = new Ext.util.MixedCollection();
mc.add(someEl.dom.id, someEl);
mc.add(otherEl.dom.id, otherEl);
//and so on
// using getKey
var mc = new Ext.util.MixedCollection();
mc.getKey = function(el){
return el.dom.id;
};
mc.add(someEl);
mc.add(otherEl);
// or via the constructor
var mc = new Ext.util.MixedCollection(false, function(el){
return el.dom.id;
});
mc.add(someEl);
mc.add(otherEl);</code></pre>The item for which to find the key.Replaces an item in the collection. Fires the <a ext:cls="Ext.util.MixedCollection" ext:member="replace" href="output/Ext.util.MixedCollection.html#replace">replace</a> event when complete.The key associated with the item to replace, or the item to replace.o (optional) If the first parameter passed was a key, the item to associate with that key.Adds all elements of an Array or an Object to the collection.An Object containing properties which will be added to the collection, or
an Array of values, each of which are added to the collection.Executes the specified function once for every item in the collection, passing each
item as the first and only parameter. Returning false from the function will stop the iteration.The function to execute for each item.(optional) The scope in which to execute the function.Executes the specified function once for every key in the collection, passing each
key, and its associated item as the first two parameters.The function to execute for each item.(optional) The scope in which to execute the function.Returns the first item in the collection which elicits a true return value from the
passed selection function.The selection function to execute for each item.(optional) The scope in which to execute the function.Inserts an item at the specified index in the collection. Fires the <a ext:cls="Ext.util.MixedCollection" ext:member="add" href="output/Ext.util.MixedCollection.html#add">add</a> event when complete.The index to insert the item at.The key to associate with the new item, or the item itself.(optional) If the second parameter was a key, the new item.Removed an item from the collection.The item to remove.Remove an item from a specified index in the collection. Fires the <a ext:cls="Ext.util.MixedCollection" ext:member="remove" href="output/Ext.util.MixedCollection.html#remove">remove</a> event when complete.The index within the collection of the item to remove.Removed an item associated with the passed key fom the collection.The key of the item to remove.Returns the number of items in the collection.Returns index within the collection of the passed Object.The item to find the index of.Returns index within the collection of the passed key.The key to find the index of.Returns the item associated with the passed key OR index. Key has priority over index. This is the equivalent
of calling <a ext:cls="Ext.util.MixedCollection" ext:member="key" href="output/Ext.util.MixedCollection.html#key">key</a> first, then if nothing matched calling <a ext:cls="Ext.util.MixedCollection" ext:member="itemAt" href="output/Ext.util.MixedCollection.html#itemAt">itemAt</a>.The key or index of the item.Returns the item at the specified index.The index of the item.Returns the item associated with the passed key.The key of the item.Returns true if the collection contains the passed Object as an item.The Object to look for in the collection.Returns true if the collection contains the passed Object as a key.The key to look for in the collection.Removes all items from the collection. Fires the <a ext:cls="Ext.util.MixedCollection" ext:member="clear" href="output/Ext.util.MixedCollection.html#clear">clear</a> event when complete.Returns the first item in the collection.Returns the last item in the collection.Sorts this collection with the passed comparison function(optional) "ASC" or "DESC"(optional) comparison functionSorts this collection by keys(optional) "ASC" or "DESC"(optional) a comparison function (defaults to case insensitive string)Returns a range of items in this collection(optional) defaults to 0(optional) default to the last itemFilter the <i>objects</i> in this collection by a specific property.
Returns a new collection that has been filtered.A property on your objectsEither string that the property values
should start with or a RegExp to test against the property(optional) True to match any part of the string, not just the beginning(optional) True for case sensitive comparisonFilter by a function. * Returns a new collection that has been filtered.
The passed function will be called with each
object in the collection. If the function returns true, the value is included
otherwise it is filtered.The function to be called, it will receive the args o (the object), k (the key)(optional) The scope of the function (defaults to this)Finds the index of the first matching object in this collection by a specific property/value.
Returns a new collection that has been filtered.A property on your objectsEither string that the property values
should start with or a RegExp to test against the property.(optional) The index to start searching at(optional) True to match any part of the string, not just the beginning(optional) True for case sensitive comparisonFind the index of the first matching object in this collection by a function.
If the function returns <i>true<i> it is considered a match.The function to be called, it will receive the args o (the object), k (the key)(optional) The scope of the function (defaults to this)(optional) The index to start searching atCreates a duplicate of this collectionReturns the item associated with the passed key or index.The key or index of the item.Abstract base class that provides a common interface for publishing events. Subclasses are expected to
to have a property "events" with all the events defined.<br>
For example:
<pre><code>Employee = function(name){
this.name = name;
this.addEvents({
"fired" : true,
"quit" : true
});
}
Ext.extend(Employee, Ext.util.Observable);</code></pre>Fires the specified event with the passed parameters (minus the event name).Variable number of parameters are passed to handlersAppends an event handler to this componentThe type of event to listen forThe method the event invokes(optional) The scope in which to execute the handler
function. The handler function's "this" context.(optional) An object containing handler configuration
properties. This may contain any of the following properties:<ul>
<li>scope {Object} The scope in which to execute the handler function. The handler function's "this" context.</li>
<li>delay {Number} The number of milliseconds to delay the invocation of the handler after te event fires.</li>
<li>single {Boolean} True to add a handler to handle just the next firing of the event, and then remove itself.</li>
<li>buffer {Number} Causes the handler to be scheduled to run in an <a ext:cls="Ext.util.DelayedTask" href="output/Ext.util.DelayedTask.html">Ext.util.DelayedTask</a> delayed
by the specified number of milliseconds. If the event fires again within that time, the original
handler is <em>not</em> invoked, but the new handler is scheduled in its place.</li>
</ul><br>
<p>
<b>Combining Options</b><br>
Using the options argument, it is possible to combine different types of listeners:<br>
<br>
A normalized, delayed, one-time listener that auto stops the event and passes a custom argument (forumId)
<pre><code>el.on('click', this.onClick, this, {
single: true,
delay: 100,
forumId: 4
});</code></pre>
<p>
<b>Attaching multiple handlers in 1 call</b><br>
The method also allows for a single argument to be passed which is a config object containing properties
which specify multiple handlers.
<p>
<pre><code>foo.on({
'click' : {
fn: this.onClick
scope: this,
delay: 100
},
'mouseover' : {
fn: this.onMouseOver
scope: this
},
'mouseout' : {
fn: this.onMouseOut
scope: this
}
});</code></pre>
<p>
Or a shorthand syntax:<br>
<pre><code>foo.on({
'click' : this.onClick,
'mouseover' : this.onMouseOver,
'mouseout' : this.onMouseOut
scope: this
});</code></pre>Removes a listenerThe type of event to listen forThe handler to remove(optional) The scope (this object) for the handlerRemoves all listeners for this objectUsed to define events on this ObservableThe object with the events definedChecks to see if this object has any listeners for a specified eventThe name of the event to check forSuspend the firing of all events. (see <a ext:cls="Ext.util.Observable" ext:member="resumeEvents" href="output/Ext.util.Observable.html#resumeEvents">resumeEvents</a>)Resume firing events. (see <a ext:cls="Ext.util.Observable" ext:member="suspendEvents" href="output/Ext.util.Observable.html#suspendEvents">suspendEvents</a>)Appends an event handler to this element (shorthand for addListener)The type of event to listen forThe method the event invokes(optional) The scope in which to execute the handler
function. The handler function's "this" context.(optional)Removes a listener (shorthand for removeListener)The type of event to listen forThe handler to remove(optional) The scope (this object) for the handler<static> Starts capture on the specified Observable. All events will be passed
to the supplied function with the event name + standard signature of the event
<b>before</b> the event is fired. If the supplied function returns false,
the event will not fire.The Observable to captureThe function to call(optional) The scope (this object) for the fn<static> Removes <b>all</b> added captures from the Observable.The Observable to releaseProvides the ability to execute one or more arbitrary tasks in a multithreaded manner. Generally, you can use
the singleton <a ext:cls="Ext.TaskMgr" href="output/Ext.TaskMgr.html">Ext.TaskMgr</a> instead, but if needed, you can create separate instances of TaskRunner. Any
number of separate tasks can be started at any time and will run independently of each other. Example usage:
<pre><code>// Start a simple clock task that updates a div once per second
var task = {
run: function(){
Ext.fly('clock').update(new Date().format('g:i:s A'));
},
interval: 1000 //1 second
}
var runner = new Ext.util.TaskRunner();
runner.start(task);</code></pre>(optional) The minimum precision in milliseconds supported by this TaskRunner instance
(defaults to 10)Starts a new task.A config object that supports the following properties:<ul>
<li><code>run</code> : Function<div class="sub-desc">The function to execute each time the task is run. The
function will be called at each interval and passed the <code>args</code> argument if specified. If a
particular scope is required, be sure to specify it using the <code>scope</scope> argument.</div></li>
<li><code>interval</code> : Number<div class="sub-desc">The frequency in milliseconds with which the task
should be executed.</div></li>
<li><code>args</code> : Array<div class="sub-desc">(optional) An array of arguments to be passed to the function
specified by <code>run</code>.</div></li>
<li><code>scope</code> : Object<div class="sub-desc">(optional) The scope in which to execute the
<code>run</code> function.</div></li>
<li><code>duration</code> : Number<div class="sub-desc">(optional) The length of time in milliseconds to execute
the task before stopping automatically (defaults to indefinite).</div></li>
<li><code>repeat</code> : Number<div class="sub-desc">(optional) The number of times to execute the task before
stopping automatically (defaults to indefinite).</div></li>
</ul>Stops an existing running task.The task to stopStops all tasks that are currently running.Provides precise pixel measurements for blocks of text so that you can determine exactly how high and
wide, in pixels, a given block of text will be.<br><br><i>This class is a singleton and cannot be created directly.</i>Measures the size of the specified textThe element, dom node or id from which to copy existing CSS styles
that can affect the size of the rendered textThe text to measure(optional) If the text will be multiline, you have to set a fixed width
in order to accurately measure the text heightReturn a unique TextMetrics instance that can be bound directly to an element and reused. This reduces
the overhead of multiple calls to initialize the style properties on each measurement.The element, dom node or id that the instance will be bound to(optional) If the text will be multiline, you have to set a fixed width
in order to accurately measure the text heightReturns the size of the specified text based on the internal element's style and width propertiesThe text to measureBinds this TextMetrics instance to an element from which to copy existing CSS styles
that can affect the size of the rendered textThe element, dom node or idSets a fixed width on the internal measurement element. If the text will be multiline, you have
to set a fixed width in order to accurately measure the text height.The width to set on the elementReturns the measured width of the specified textThe text to measureReturns the measured height of the specified text. For multiline text, be sure to call
<a ext:cls="Ext.util.TextMetrics" ext:member="setFixedWidth" href="output/Ext.util.TextMetrics.html#setFixedWidth">setFixedWidth</a> if necessary.The text to measureThese functions are available on every Function object (any JavaScript function).Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
Call directly on any function. Example: <code>myFunction.createCallback(myarg, myarg2)</code>
Will create a function that is bound to those 2 args.Creates a delegate (callback) that sets the scope to obj.
Call directly on any function. Example: <code>this.myFunction.createDelegate(this)</code>
Will create a function that is automatically scoped to this.(optional) The object for which the scope is set(optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)(optional) if True args are appended to call args instead of overriding,
if a number the args are inserted at the specified positionCalls this function after the number of millseconds specified.The number of milliseconds for the setTimeout call (if 0 the function is executed immediately)(optional) The object for which the scope is set(optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)(optional) if True args are appended to call args instead of overriding,
if a number the args are inserted at the specified positionCreate a combined function call sequence of the original function + the passed function.
The resulting function returns the results of the original function.
The passed fcn is called with the parameters of the original functionThe function to sequence(optional) The scope of the passed fcn (Defaults to scope of original function or window)Creates an interceptor function. The passed fcn 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 passed fcn is called with the parameters of the original function.
@addonThe function to call before the original(optional) The scope of the passed fcn (Defaults to scope of original function or window)Checks whether or not the current number is within a desired range. If the number is already within the
range it is returned, otherwise the min or max value is returned depending on which side of the range is
exceeded. Note that this method returns the constrained value but does not change the current number.The minimum number in the rangeThe maximum number in the rangeThese functions are available as static methods on the JavaScript String object.<static> Escapes the passed string for ' and \The string to escape<static> Pads the left side of a string with a specified character. This is especially useful
for normalizing number and date strings. Example usage:
<pre><code>var s = String.leftPad('123', 5, '0');
// s now contains the string: '00123'</code></pre>The original stringThe total length of the output string(optional) The character with which to pad the original string (defaults to empty string " ")<static> Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens. Each
token must be unique, and must increment in the format {0}, {1}, etc. Example usage:
<pre><code>var cls = 'my-class', text = 'Some text';
var s = String.format('<div class="{0}">{1}</div>', cls, text);
// s now contains the string: '<div class="my-class">Some text</div>'</code></pre>The tokenized string to be formattedThe value to replace token {0}Etc...Utility function that allows you to easily switch a string between two alternating values. The passed value
is compared to the current string, and if they are equal, the other value that was passed in is returned. If
they are already different, the first value passed in is returned. Note that this method returns the new value
but does not change the current string.
<pre><code>// alternate sort directions
sort = sort.toggle('ASC', 'DESC');
// instead of conditional logic:
sort = (sort == 'ASC' ? 'DESC' : 'ASC');</code></pre>The value to compare to the current stringThe new value to use if the string already equals the first value passed inTrims whitespace from either end of a string, leaving spaces within the string intact. Example:
<pre><code>var s = ' foo bar ';
alert('-' + s + '-'); //alerts "- foo bar -"
alert('-' + s.trim() + '-'); //alerts "-foo bar-"</code></pre>