Instance Methods
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated config.
Called by an owning Panel after the Panel finishes its collapse process.
Called by an owning Panel after the Panel finishes its expand process.
Removes layout's itemCls and owning Container's itemCls.
Clears the managed dimensions flags
Called before any calculation cycles to prepare for layout.
This is a write phase and DOM reads should be strictly avoided when overridding
this method.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
Called before any calculation cycles to reset DOM values and prepare for calculation.
This is a write phase and DOM reads should be strictly avoided when overridding
this method.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
Called to perform the calculations for this layout. This method will be called at
least once and may be called repeatedly if the done property is cleared
before return to indicate that this layout is not yet done. The done property
is always set to true before entering this method.
This is a read phase and DOM writes should be strictly avoided in derived classes.
Instead, DOM writes need to be written to Ext.layout.ContextItem objects to
be flushed at the next opportunity.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
Call the original method that was previously overridden with Ext.Base#override
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callOverridden();
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
args :
Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callOverridden(arguments)
:
Object
Returns the result of calling the overridden method
Deprecated since version 4.1.0
Use method-callParent instead.
Call the "parent" method of the current method. That is the method previously
overridden by derivation or by an override (see Ext#define).
Ext.define('My.Base', {
constructor: function (x) {
this.x = x;
},
statics: {
method: function (x) {
return x;
}
}
});
Ext.define('My.Derived', {
extend: 'My.Base',
constructor: function () {
this.callParent([21]);
}
});
var obj = new My.Derived();
alert(obj.x); // alerts 21
This can be used with an override as follows:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function (x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});
var obj = new My.Derived();
alert(obj.x); // now alerts 42
This also works with static and private methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
// privates: {
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});
alert(My.Base.method(10)); // alerts 10
alert(My.Derived2.method(10)); // alerts 20
Lastly, it also works with overridden static methods.
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
// privates: {
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // now alerts 40
To override a method and replace it and also call the superclass method, use
method-callSuper. This is often done to patch a method to fix a bug.
args :
Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callParent(arguments)
:
Object
Returns the result of calling the parent method
This method is used by an override to call the superclass method but
bypass any overridden method. This is often done to "patch" a method that
contains a bug but for whatever reason cannot be fixed directly.
Consider:
Ext.define('Ext.some.Class', {
method: function () {
console.log('Good');
}
});
Ext.define('Ext.some.DerivedClass', {
extend: 'Ext.some.Class',
method: function () {
console.log('Bad');
// ... logic but with a bug ...
this.callParent();
}
});
To patch the bug in Ext.some.DerivedClass.method, the typical solution is to create an
override:
Ext.define('App.patches.DerivedClass', {
override: 'Ext.some.DerivedClass',
method: function () {
console.log('Fixed');
// ... logic but with bug fixed ...
this.callSuper();
}
});
The patch method cannot use method-callParent to call the superclass
method since that would call the overridden method containing the bug. In
other words, the above patch would only produce "Fixed" then "Good" in the
console log, whereas, using callParent would produce "Fixed" then "Bad"
then "Good".
args :
Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callSuper(arguments)
:
Object
Returns the result of calling the superclass method
This method (if implemented) is called at the end of the cycle in which this layout
completes (by not setting done to false in calculate). It is
possible for the layout to complete and yet become invalid before the end of the cycle,
in which case, this method will not be called. It is also possible for this method to
be called and then later the layout becomes invalidated. This will result in
calculate being called again, followed by another call to this method.
This is a read phase and DOM writes should be strictly avoided in derived classes.
Instead, DOM writes need to be written to Ext.layout.ContextItem objects to
be flushed at the next opportunity.
This method need not be implemented by derived classes and, in fact, should only be
implemented when needed.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
Creates an axis object given the particulars. The process starts by placing the
dockedItems in an idealized box where this method is called once for each side.
The ideal box is defined by the CSS3 border and padding values (which account for
the influence of border-radius). The origin (the (0,0) point) of the ideal box is
the top-left edge of the border or the border-box. Normal dockedItems are placed
inside this box at an offset to clear the border and padding and sit properly in
the panel next to the body.
The origin has to be started differently if the axis is in shrinkWrap mode. When
shrink-wrapping an axis, the axis starts at the edge of the body and expands
outwards as items are docked. This means the ideal (0,0) for shrinkWrap is on the
top-left corner of the body.
The following diagram illustrates this using the vertical axis.
+---------------------------+ 10px (border)
| |
| xxxxxxxxxxxxxxxxxxxxxxx | 5px (padding) shrinkWrap other
| +=====================+ | -50 15
| | Header | | 30px
| | | |
| +=====================+ |
| +---------------------+ | -20 45
| | tbar | | 20 px
| +---------------------+ |
| +---------------------+ | 0 65
| | Body | | 100px
| | | |
| | | |
| +---------------------+ |
| +---------------------+ | 100 165
| | bbar | | 15px
| +---------------------+ |
| xxxxxxxxxxxxxxxxxxxxxxx | 5px
| |
+---------------------------+ 10px
These are sufficient to determine sizes of things, but to finalize this process
and assign proper positions, the tentative coordinates have to be adjusted by an
amount appropriate for the item. Because dockedItems are position:absolute, they
sit inside the border and so must be adjusted for padding. The body is different
because it is position:relative and so it naturally sits inside the padding and
the padding must not be included in its position.
Headers and footers that use ignoreParentFrame interact with this process by
moving themselves outside the border and padding. So in the above diagram, the
Header would move up by 15px and everything else would move up by 10px. When
shrinkWrap is taking place, the 10px of border on the top is removed from the
height as well.
The bbar behaves slightly different when it is ignoreParentFrame. In shrinkWrap
mode, it alone would move down by the padding and the bottom border would not be
included in the height. Otherwise, the bbar would be moved down 15px (since the
edge is fixed) and the next dockedItem would be placed at, or the body would be
stretched down to, 5px (padding) pixels above the bbar.
Destroys this layout. This method removes a targetCls from the target
element and calls onDestroy.
A derived class can override either this method or onDestroy but in all
cases must call the base class versions of these methods to allow the base class to
perform its cleanup.
This method (or onDestroy) are overridden by subclasses most often to purge
event handlers or remove unmanged DOM nodes.
Destroys member properties by name.
If a property name is the name of a config, the getter is not invoked, so
if the config has not been initialized, nothing will be done.
The property will be destroyed, and the corrected name (if the property is a config
and config names are prefixed) will set to null in this object's dictionary.
args :
String...
One or more names of the properties to destroy and remove from the object.
Docks a child item on the specified axis. This boils down to determining if the item
is docked at the "beginning" of the axis ("left" if horizontal, "top" if vertical),
the "end" of the axis ("right" if horizontal, "bottom" if vertical) or stretches
along the axis ("top" or "bottom" if horizontal, "left" or "right" if vertical). It
also has to differentiate between fixed and shrinkWrap sized dimensions.
Docks an item on a fixed-size axis at the "beginning". The "beginning" of the horizontal
axis is "left" and the vertical is "top". For a fixed-size axis, the size works from
the outer element (the panel) towards the body.
Docks an item on a fixed-size axis at the "end". The "end" of the horizontal axis is
"right" and the vertical is "bottom".
Docks an item on a shrinkWrap axis at the "beginning". The "beginning" of the horizontal
axis is "left" and the vertical is "top". For a shrinkWrap axis, the size works from
the body outward to the outermost element (the panel).
During the docking process, coordinates are allowed to be negative. We start with the
body at (0,0) so items docked "top" or "left" will simply be assigned negative x/y. In
the finishPositions method these are corrected and framing is added. This way
the correction is applied as a simple translation of delta x/y on all coordinates to
bring the origin back to (0,0).
Docks an item on a shrinkWrap axis at the "end". The "end" of the horizontal axis is
"right" and the vertical is "bottom".
Docks an item that might stretch across an axis. This is done for dock "top" and
"bottom" items on the horizontal axis and dock "left" and "right" on the vertical.
This method (if implemented) is called after all layouts have completed. In most
ways this is similar to completeLayout. This call can cause this (or any
layout) to be become invalid (see Ext.layout.Context#invalidate), but this
is best avoided. This method is intended to be where final reads are made and so it
is best to avoid invalidating layouts at this point whenever possible. Even so, this
method can be used to perform final checks that may require all other layouts to be
complete and then invalidate some results.
This is a read phase and DOM writes should be strictly avoided in derived classes.
Instead, DOM writes need to be written to Ext.layout.ContextItem objects to
be flushed at the next opportunity.
This method need not be implemented by derived classes and, in fact, should only be
implemented when needed.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
Finishes the calculation of an axis by determining its size. In non-shrink-wrap
cases, this is also where we set the body size.
:
Boolean
Finishes processing of each axis by applying the min/max size constraints.
:
Boolean
Finishes the calculation by setting positions on the body and all of the items.
This method is called after all layouts are complete and their calculations flushed
to the DOM. No further layouts will be run and this method is only called once per
layout run. The base component layout caches lastComponentSize.
This is a write phase and DOM reads should be avoided if possible when overridding
this method.
This method need not be implemented by derived classes and, in fact, should only be
implemented when needed.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
Returns the array of class names to add to a docked item or body element when for
the edges that should collapse with the outer component border. Basically, the
panel's outer border must look visually like a contiguous border but may need to
be realized by using the border of docked items and/or the body. This class name
allows the border color and width to be controlled accordingly and distinctly from
the border of the docked item or body element when it is not having its border
collapsed.
Returns a specified config property value. If the name parameter is not passed,
all current configuration options will be returned as key value pairs.
name :
String
(optional)
The name of the config property to get.
peek :
Boolean
(optional)
true to peek at the raw value without calling the getter.
Defaults to: false
ifInitialized :
Boolean
(optional)
true to only return the initialized property value,
not the raw config value, and not to trigger initialization. Returns undefined if the
property has not yet been initialized.
Defaults to: false
:
Object
The config property value.
Get's the css class name for a given dock position.
dock :
String
top, right, bottom, or left
:
String
Retrieve an ordered and/or filtered array of all docked Components.
order :
String
(optional)
The desired ordering of the items ('render' or 'visual').
Defaults to: 'render'
beforeBody :
Boolean
(optional)
An optional flag to limit the set of items to only those
before the body (true) or after the body (false). All components are returned by
default.
:
Ext.Component[]
Returns the initial configuration passed to the constructor when
instantiating this class.
Given this example Ext.button.Button definition and instance:
Ext.define('MyApp.view.Button', {
extend: 'Ext.button.Button',
xtype: 'mybutton',
scale: 'large',
enableToggle: true
});
var btn = Ext.create({
xtype: 'mybutton',
renderTo: Ext.getBody(),
text: 'Test Button'
});
Calling btn.getInitialConfig() would return an object including the config
options passed to the create method:
xtype: 'mybutton',
renderTo: // The document body itself
text: 'Test Button'
Calling btn.getInitialConfig('text')returns 'Test Button'.
name :
String
(optional)
Name of the config option to return.
:
Object/Mixed
The full config object or a single config value
when name parameter specified.
For a given item, returns the element that participates in the childNodes array
of the layout's target element. This is usually the component's "el", but can
also be a wrapper
:
HTMLElement
Returns an object describing how this layout manages the size of the given component.
This method must be implemented by any layout that manages components.
:
Ext.layout.SizePolicy
An object describing the sizing done by the layout
for this item.
Returns an array containing all the visible docked items inside this layout's owner Panel
:
Array
An array containing all the visible docked items of the Panel
Returns the element into which rendering must take place. Defaults to the owner Component's encapsulating element.
May be overridden in Component layout managers which implement an inner element.
:
Ext.dom.Element
Returns the owner component's resize element.
:
Ext.dom.Element
Initialize configuration for this class. a typical example:
Ext.define('My.awesome.Class', {
// The default config
config: {
name: 'Awesome',
isAwesome: true
},
constructor: function(config) {
this.initConfig(config);
}
});
var awesome = new My.awesome.Class({
name: 'Super Awesome'
});
alert(awesome.getName()); // 'Super Awesome'
:
Ext.Base
A one-time initialization method called just before rendering.
The default weighting of docked items produces this arrangement:
+--------------------------------------------+
| Top 1 |
+--------------------------------------------+
| Top 2 |
+-----+-----+--------------------+-----+-----+
| | | | | |
| | | | | |
| | | | R | R |
| L | L | | I | I |
| E | E | | G | G |
| F | F | | H | H |
| T | T | | T | T |
| | | | | |
| 2 | 1 | | 1 | 2 |
| | | | | |
| | | | | |
+-----+-----+--------------------+-----+-----+
| Bottom 1 |
+--------------------------------------------+
| Bottom 2 |
+--------------------------------------------+
So when we are shrinkWrapDock on the horizontal, the stretch size for top/bottom
docked items is the final axis size. For the vertical axis, however, the stretch
Validates item is in the proper place in the dom.
:
Boolean
Adds a "destroyable" object to an internal list of objects that will be destroyed
when this instance is destroyed (via destroy).
:
Object
Moves Component to the provided target instead.
This method (if implemented) is called after all layouts are finished, and all have
a lastComponentSize cached. No further layouts will be run and this method is only
called once per layout run. It is the bookend to beginLayout.
This is a write phase and DOM reads should be avoided if possible when overridding
this method. This is the catch-all tail method to a layout and so the rules are more
relaxed. Even so, for performance reasons, it is best to avoid reading the DOM. If
a read is necessary, consider implementing a finalizeLayout method to do the
required reads.
This method need not be implemented by derived classes and, in fact, should only be
implemented when needed.
ownerContext :
Ext.layout.ContextItem
The context item for the layout's owner
component.
This method is called when a child item changes in some way. By default this calls
updateLayout on this layout's owner.
child :
Ext.Component
The child item that has changed.
:
Boolean
True if this layout has handled the content change.
Used to render in the correct order, top/left before bottom/right
Renders the given Component into the target Element.
position :
Number
The position within the target to render the item to
Render the top and left docked items before any existing DOM nodes in our render
target and then render the right and bottom docked items after. This is important,
for such things as tab stops and ARIA readers, that the DOM nodes are in a
meaningful order.
Our collection of docked items will already be ordered via Panel.getDockedItems().
Sets a single/multiple configuration options.
name :
String/Object
The name of the property to set, or a set of key value pairs to set.
value :
Object
(optional)
The value to set for the name parameter.
:
Ext.Base
Get the reference to the class from which this object was instantiated. Note that unlike Ext.Base#self,
this.statics() is scope-independent and it always returns the class from which it was called, regardless of what
this points to during run-time
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
alert(statics.speciesName); // always equals to 'Cat' no matter what 'this' refers to
// equivalent to: My.Cat.speciesName
alert(this.self.speciesName); // dependent on 'this'
statics.totalCreated++;
},
clone: function() {
var cloned = new this.self(); // dependent on 'this'
cloned.groupName = this.statics().speciesName; // equivalent to: My.Cat.speciesName
return cloned;
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
},
constructor: function() {
this.callParent();
}
});
var cat = new My.Cat(); // alerts 'Cat', then alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
alert(clone.groupName); // alerts 'Cat'
alert(My.Cat.totalCreated); // alerts 3
:
Ext.Class
Destroys a given set of linked objects. This is only needed if
the linked object is being destroyed before this instance.
names :
String[]
The names of the linked objects to destroy.
:
Ext.Base
Static Methods
Adds new config properties to this class. This is called for classes when they
are declared, then for any mixins that class may define and finally for any
overrides defined that target the class.
mixinClass :
Ext.Class
(optional)
The mixin class if the configs are from a mixin.
Add methods / properties to the prototype of this class.
Ext.define('My.awesome.Cat', {
constructor: function() {
...
}
});
My.awesome.Cat.addMembers({
meow: function() {
alert('Meowww...');
}
});
var kitty = new My.awesome.Cat();
kitty.meow();
members :
Object
The members to add to this class.
isStatic :
Boolean
(optional)
Pass true if the members are static.
Defaults to: false
privacy :
Boolean
(optional)
Pass true if the members are private. This
only has meaning in debug mode and only for methods.
Defaults to: false
:
Add / override static properties of this class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.addStatics({
someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'
method1: function() { ... }, // My.cool.Class.method1 = function() { ... };
method2: function() { ... } // My.cool.Class.method2 = function() { ... };
});
:
Ext.Base
Borrow another class' members to the prototype of this class.
Ext.define('Bank', {
money: '$$$',
printMoney: function() {
alert('$$$$$$$');
}
});
Ext.define('Thief', {
...
});
Thief.borrow(Bank, ['money', 'printMoney']);
var steve = new Thief();
alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'
fromClass :
Ext.Base
The class to borrow members from
members :
Array/String
The names of the members to borrow
:
Ext.Base
Create a new instance of this Class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.create({
someConfig: true
});
All parameters are passed to the constructor of the class.
:
Object
Create aliases for existing prototype methods. Example:
Ext.define('My.cool.Class', {
method1: function() { ... },
method2: function() { ... }
});
var test = new My.cool.Class();
My.cool.Class.createAlias({
method3: 'method1',
method4: 'method2'
});
test.method3(); // test.method1()
My.cool.Class.createAlias('method5', 'method3');
test.method5(); // test.method3() -> test.method1()
alias :
String/Object
The new method name, or an object to set multiple aliases. See
flexSetter
Get the current class' name in string format.
Ext.define('My.cool.Class', {
constructor: function() {
alert(this.self.getName()); // alerts 'My.cool.Class'
}
});
My.cool.Class.getName(); // 'My.cool.Class'
:
String
Used internally by the mixins pre-processor
:
Override members of this class. Overridden methods can be invoked via
callParent.
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
Direct use of this method should be rare. Use Ext.define
instead:
Ext.define('My.CatOverride', {
override: 'My.Cat',
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
The above accomplishes the same result but can be managed by the Ext.Loader
which can properly order the override and its target class and the build process
can determine whether the override is needed based on the required state of the
target class (My.Cat).
members :
Object
The properties to add to this class. This should be
specified as an object literal containing one or more properties.
:
Ext.Base
Ext JS | Terms of Use
