Ext.data.JsonP.Ext_layout_component_Dock({"alternateClassNames":["Ext.layout.component.AbstractDock"],"aliases":{"layout":["dock"]},"enum":null,"parentMixins":[],"tagname":"class","subclasses":[],"extends":"Ext.layout.component.Component","uses":[],"html":"
Alternate names
Ext.layout.component.AbstractDockHierarchy
Ext.BaseExt.layout.LayoutExt.layout.component.ComponentExt.layout.component.DockFiles
NOTE This is a private utility class for internal use by the framework. Don't rely on its existence.
This ComponentLayout handles docking for Panels. It takes care of panels that are\npart of a ContainerLayout that sets this Panel's size and Panels that are part of\nan AutoContainerLayout in which this panel get his height based of the CSS or\nor its content.
\nDefaults to: {readsWidth: 1, readsHeight: 1, setsWidth: 0, setsHeight: 0}
This object is indexed by a component's baseCls
to yield another object which\nis then indexed by the component's ui
to produce an array of CSS class names.\nThis array is indexed in the same manner as the noBorderClassTable
and indicates\nthe a particular edge of a docked item or the body element is actually \"collapsed\"\nwith the component's outer border.
Defaults to: {}
Defaults to: {top: 'border-top-width', right: 'border-right-width', bottom: 'border-bottom-width', left: 'border-left-width'}
Used only during a layout run, this value indicates that a\nlayout has finished its calculations. This flag is set to true prior to the call to\ncalculate and should be set to false if this layout has more work to do.
\nDefaults to: {name: 'horz', oppositeName: 'vert', dockBegin: 'left', dockEnd: 'right', horizontal: true, marginBegin: 'margin-left', maxSize: 'maxWidth', minSize: 'minWidth', pos: 'x', setSize: 'setWidth', shrinkWrapDock: 'shrinkWrapDockWidth', size: 'width', sizeModel: 'widthModel'}
true
in this class to identify an object as an instantiated Layout, or subclass thereof.
Defaults to: true
Defaults to: [Ext.baseCSSPrefix + 'docked-noborder-top', Ext.baseCSSPrefix + 'docked-noborder-right', Ext.baseCSSPrefix + 'docked-noborder-bottom', Ext.baseCSSPrefix + 'docked-noborder-left']
Defaults to: {top: Ext.baseCSSPrefix + 'docked-noborder-top', right: Ext.baseCSSPrefix + 'docked-noborder-right', bottom: Ext.baseCSSPrefix + 'docked-noborder-bottom', left: Ext.baseCSSPrefix + 'docked-noborder-left'}
Get the reference to the current class from which this object was instantiated. Unlike statics,\nthis.self
is scope-dependent and it's meant to be used for dynamic inheritance. See statics\nfor a detailed comparison
Ext.define('My.Cat', {\n statics: {\n speciesName: 'Cat' // My.Cat.speciesName = 'Cat'\n },\n\n constructor: function() {\n alert(this.self.speciesName); // dependent on 'this'\n },\n\n clone: function() {\n return new this.self();\n }\n});\n\n\nExt.define('My.SnowLeopard', {\n extend: 'My.Cat',\n statics: {\n speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'\n }\n});\n\nvar cat = new My.Cat(); // alerts 'Cat'\nvar snowLeopard = new My.SnowLeopard(); // alerts 'Snow Leopard'\n\nvar clone = snowLeopard.clone();\nalert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'\n
\nDefaults to: {nostretch: {setsWidth: 0, setsHeight: 0}, horz: {shrinkWrap: {setsWidth: 1, setsHeight: 0, readsWidth: 1}, stretch: {setsWidth: 1, setsHeight: 0}}, vert: {shrinkWrap: {setsWidth: 0, setsHeight: 1, readsHeight: 1}, stretch: {setsWidth: 0, setsHeight: 1}}, stretchV: {setsWidth: 0, setsHeight: 1}, autoStretchH: {readsWidth: 1, setsWidth: 1, setsHeight: 0}, autoStretchV: {readsHeight: 1, setsWidth: 0, setsHeight: 1}}
Defaults to: {name: 'vert', oppositeName: 'horz', dockBegin: 'top', dockEnd: 'bottom', horizontal: false, marginBegin: 'margin-top', maxSize: 'maxHeight', minSize: 'minHeight', pos: 'y', setSize: 'setHeight', shrinkWrapDock: 'shrinkWrapDockHeight', size: 'height', sizeModel: 'heightModel'}
Removes layout's itemCls and owning Container's itemCls.\nClears the managed dimensions flags
\nOverrides: Ext.layout.Layout.afterRemove
Called before any calculation cycles to prepare for layout.
\n\nThis is a write phase and DOM reads should be strictly avoided when overridding\nthis method.
\nThe context item for the layout's owner\ncomponent.
\nOverrides: Ext.layout.Layout.beginLayout
Called before any calculation cycles to reset DOM values and prepare for calculation.
\n\nThis is a write phase and DOM reads should be strictly avoided when overridding\nthis method.
\nThe context item for the layout's owner\ncomponent.
\nCalled to perform the calculations for this layout. This method will be called at\nleast once and may be called repeatedly if the done property is cleared\nbefore return to indicate that this layout is not yet done. The done property\nis always set to true
before entering this method.
This is a read phase and DOM writes should be strictly avoided in derived classes.\nInstead, DOM writes need to be written to Ext.layout.ContextItem objects to\n be flushed at the next opportunity.
\nThe context item for the layout's owner\ncomponent.
\nOverrides: Ext.layout.Layout.calculate
Call the original method that was previously overridden with override
\n\nExt.define('My.Cat', {\n constructor: function() {\n alert(\"I'm a cat!\");\n }\n});\n\nMy.Cat.override({\n constructor: function() {\n alert(\"I'm going to be a cat!\");\n\n this.callOverridden();\n\n alert(\"Meeeeoooowwww\");\n }\n});\n\nvar kitty = new My.Cat(); // alerts \"I'm going to be a cat!\"\n // alerts \"I'm a cat!\"\n // alerts \"Meeeeoooowwww\"\n
\n This method has been deprecated
\nas of 4.1. Use callParent instead.
\n\nThe arguments, either an array or the arguments
object\nfrom the current method, for example: this.callOverridden(arguments)
Returns the result of calling the overridden method
\nCall the \"parent\" method of the current method. That is the method previously\noverridden by derivation or by an override (see Ext.define).
\n\n Ext.define('My.Base', {\n constructor: function (x) {\n this.x = x;\n },\n\n statics: {\n method: function (x) {\n return x;\n }\n }\n });\n\n Ext.define('My.Derived', {\n extend: 'My.Base',\n\n constructor: function () {\n this.callParent([21]);\n }\n });\n\n var obj = new My.Derived();\n\n alert(obj.x); // alerts 21\n
\n\nThis can be used with an override as follows:
\n\n Ext.define('My.DerivedOverride', {\n override: 'My.Derived',\n\n constructor: function (x) {\n this.callParent([x*2]); // calls original My.Derived constructor\n }\n });\n\n var obj = new My.Derived();\n\n alert(obj.x); // now alerts 42\n
\n\nThis also works with static methods.
\n\n Ext.define('My.Derived2', {\n extend: 'My.Base',\n\n statics: {\n method: function (x) {\n return this.callParent([x*2]); // calls My.Base.method\n }\n }\n });\n\n alert(My.Base.method(10); // alerts 10\n alert(My.Derived2.method(10); // alerts 20\n
\n\nLastly, it also works with overridden static methods.
\n\n Ext.define('My.Derived2Override', {\n override: 'My.Derived2',\n\n statics: {\n method: function (x) {\n return this.callParent([x*2]); // calls My.Derived2.method\n }\n }\n });\n\n alert(My.Derived2.method(10); // now alerts 40\n
\n\nTo override a method and replace it and also call the superclass method, use\ncallSuper. This is often done to patch a method to fix a bug.
\nThe arguments, either an array or the arguments
object\nfrom the current method, for example: this.callParent(arguments)
Returns the result of calling the parent method
\nThis method is used by an override to call the superclass method but bypass any\noverridden method. This is often done to \"patch\" a method that contains a bug\nbut for whatever reason cannot be fixed directly.
\n\nConsider:
\n\n Ext.define('Ext.some.Class', {\n method: function () {\n console.log('Good');\n }\n });\n\n Ext.define('Ext.some.DerivedClass', {\n method: function () {\n console.log('Bad');\n\n // ... logic but with a bug ...\n\n this.callParent();\n }\n });\n
\n\nTo patch the bug in DerivedClass.method
, the typical solution is to create an\noverride:
Ext.define('App.paches.DerivedClass', {\n override: 'Ext.some.DerivedClass',\n\n method: function () {\n console.log('Fixed');\n\n // ... logic but with bug fixed ...\n\n this.callSuper();\n }\n });\n
\n\nThe patch method cannot use callParent
to call the superclass method
since\nthat would call the overridden method containing the bug. In other words, the\nabove patch would only produce \"Fixed\" then \"Good\" in the console log, whereas,\nusing callParent
would produce \"Fixed\" then \"Bad\" then \"Good\".
The arguments, either an array or the arguments
object\nfrom the current method, for example: this.callSuper(arguments)
Returns the result of calling the superclass method
\nThis method (if implemented) is called at the end of the cycle in which this layout\ncompletes (by not setting done to false
in calculate). It is\npossible for the layout to complete and yet become invalid before the end of the cycle,\nin which case, this method will not be called. It is also possible for this method to\nbe called and then later the layout becomes invalidated. This will result in\ncalculate 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.\nInstead, DOM writes need to be written to Ext.layout.ContextItem objects to\nbe flushed at the next opportunity.
\n\nThis method need not be implemented by derived classes and, in fact, should only be\nimplemented when needed.
\nThe context item for the layout's owner\ncomponent.
\nWe are overriding the Ext.layout.Layout configureItem method to also add a class that\nindicates the position of the docked item. We use the itemCls (x-docked) as a prefix.\nAn example of a class added to a dock: right item is x-docked-right
\nThe item we are configuring
\nOverrides: Ext.layout.Layout.configureItem
Creates an axis object given the particulars. The process starts by placing the\ndockedItems in an idealized box where this method is called once for each side.\nThe ideal box is defined by the CSS3 border and padding values (which account for\nthe influence of border-radius). The origin (the (0,0) point) of the ideal box is\nthe top-left edge of the border or the border-box. Normal dockedItems are placed\ninside this box at an offset to clear the border and padding and sit properly in\nthe panel next to the body.
\n\nThe origin has to be started differently if the axis is in shrinkWrap mode. When\nshrink-wrapping an axis, the axis starts at the edge of the body and expands\noutwards as items are docked. This means the ideal (0,0) for shrinkWrap is on the\ntop-left corner of the body.
\n\nThe following diagram illustrates this using the vertical axis.
\n\n +---------------------------+ 10px (border)\n | |\n | xxxxxxxxxxxxxxxxxxxxxxx | 5px (padding) shrinkWrap other\n | +=====================+ | -50 15\n | | Header | | 30px\n | | | |\n | +=====================+ |\n | +---------------------+ | -20 45\n | | tbar | | 20 px\n | +---------------------+ |\n | +---------------------+ | 0 65\n | | Body | | 100px\n | | | |\n | | | |\n | +---------------------+ |\n | +---------------------+ | 100 165\n | | bbar | | 15px\n | +---------------------+ |\n | xxxxxxxxxxxxxxxxxxxxxxx | 5px\n | |\n +---------------------------+ 10px\n
\n\nThese are sufficient to determine sizes of things, but to finalize this process\nand assign proper positions, the tentative coordinates have to be adjusted by an\namount appropriate for the item. Because dockedItems are position:absolute, they\nsit inside the border and so must be adjusted for padding. The body is different\nbecause it is position:relative and so it naturally sits inside the padding and\nthe padding must not be included in its position.
\n\nHeaders and footers that use ignoreParentFrame
interact with this process by\nmoving themselves outside the border and padding. So in the above diagram, the\nHeader would move up by 15px and everything else would move up by 10px. When\nshrinkWrap is taking place, the 10px of border on the top is removed from the\nheight as well.
The bbar behaves slightly different when it is ignoreParentFrame
. In shrinkWrap\nmode, it alone would move down by the padding and the bottom border would not be\nincluded in the height. Otherwise, the bbar would be moved down 15px (since the\nedge is fixed) and the next dockedItem would be placed at, or the body would be\nstretched down to, 5px (padding) pixels above the bbar.
Destroys this layout. This method removes a targetCls
from the target
\nelement and calls onDestroy
.
A derived class can override either this method or onDestroy
but in all\ncases must call the base class versions of these methods to allow the base class to\nperform its cleanup.
This method (or onDestroy
) are overridden by subclasses most often to purge\nevent handlers or remove unmanged DOM nodes.
Overrides: Ext.Base.destroy
Docks a child item on the specified axis. This boils down to determining if the item\nis docked at the \"beginning\" of the axis (\"left\" if horizontal, \"top\" if vertical),\nthe \"end\" of the axis (\"right\" if horizontal, \"bottom\" if vertical) or stretches\nalong the axis (\"top\" or \"bottom\" if horizontal, \"left\" or \"right\" if vertical). It\nalso has to differentiate between fixed and shrinkWrap sized dimensions.
\nDocks an item on a fixed-size axis at the \"beginning\". The \"beginning\" of the horizontal\naxis is \"left\" and the vertical is \"top\". For a fixed-size axis, the size works from\nthe outer element (the panel) towards the body.
\nDocks an item on a shrinkWrap axis at the \"beginning\". The \"beginning\" of the horizontal\naxis is \"left\" and the vertical is \"top\". For a shrinkWrap axis, the size works from\nthe body outward to the outermost element (the panel).
\n\nDuring the docking process, coordinates are allowed to be negative. We start with the\nbody at (0,0) so items docked \"top\" or \"left\" will simply be assigned negative x/y. In\nthe finishPositions method these are corrected and framing is added. This way\nthe correction is applied as a simple translation of delta x/y on all coordinates to\nbring the origin back to (0,0).
\nThis method (if implemented) is called after all layouts have completed. In most\nways this is similar to completeLayout. This call can cause this (or any\nlayout) to be become invalid (see Ext.layout.Context.invalidate), but this\nis best avoided. This method is intended to be where final reads are made and so it\nis best to avoid invalidating layouts at this point whenever possible. Even so, this\nmethod can be used to perform final checks that may require all other layouts to be\ncomplete and then invalidate some results.
\n\nThis is a read phase and DOM writes should be strictly avoided in derived classes.\nInstead, DOM writes need to be written to Ext.layout.ContextItem objects to\nbe flushed at the next opportunity.
\n\nThis method need not be implemented by derived classes and, in fact, should only be\nimplemented when needed.
\nThe context item for the layout's owner\ncomponent.
\nThis method is called after all layouts are complete and their calculations flushed\nto the DOM. No further layouts will be run and this method is only called once per\nlayout run. The base component layout caches lastComponentSize
.
This is a write phase and DOM reads should be avoided if possible when overridding\nthis method.
\n\nThis method need not be implemented by derived classes and, in fact, should only be\nimplemented when needed.
\nThe context item for the layout's owner\ncomponent.
\nReturns the array of class names to add to a docked item or body element when for\nthe edges that should collapse with the outer component border. Basically, the\npanel's outer border must look visually like a contiguous border but may need to\nbe realized by using the border of docked items and/or the body. This class name\nallows the border color and width to be controlled accordingly and distinctly from\nthe border of the docked item or body element when it is not having its border\ncollapsed.
\nRetrieve an ordered and/or filtered array of all docked Components.
\nThe desired ordering of the items ('render' or 'visual').
\nDefaults to: 'render'
An optional flag to limit the set of items to only those\n before the body (true) or after the body (false). All components are returned by\n default.
\nAn array of components.
\nReturns an object describing how this layout manages the size of the given component.\nThis method must be implemented by any layout that manages components.
\nAn object describing the sizing done by the layout\nfor this item.
\nOverrides: Ext.layout.Layout.getItemSizePolicy
Returns an array containing all the visible docked items inside this layout's owner Panel
\nAn array containing all the visible docked items of the Panel
\nOverrides: Ext.layout.Layout.getLayoutItems
Returns the element into which rendering must take place. Defaults to the owner Component's encapsulating element.
\n\nMay be overridden in Component layout managers which implement an inner element.
\nInitialize configuration for this class. a typical example:
\n\nExt.define('My.awesome.Class', {\n // The default config\n config: {\n name: 'Awesome',\n isAwesome: true\n },\n\n constructor: function(config) {\n this.initConfig(config);\n }\n});\n\nvar awesome = new My.awesome.Class({\n name: 'Super Awesome'\n});\n\nalert(awesome.getName()); // 'Super Awesome'\n
\nthis
\nA one-time initialization method called just before rendering.
\nThe default weighting of docked items produces this arrangement:
\n\n +--------------------------------------------+\n | Top 1 |\n +--------------------------------------------+\n | Top 2 |\n +-----+-----+--------------------+-----+-----+\n | | | | | |\n | | | | | |\n | | | | R | R |\n | L | L | | I | I |\n | E | E | | G | G |\n | F | F | | H | H |\n | T | T | | T | T |\n | | | | | |\n | 2 | 1 | | 1 | 2 |\n | | | | | |\n | | | | | |\n +-----+-----+--------------------+-----+-----+\n | Bottom 1 |\n +--------------------------------------------+\n | Bottom 2 |\n +--------------------------------------------+\n
\n\nSo when we are shrinkWrapDock on the horizontal, the stretch size for top/bottom\ndocked items is the final axis size. For the vertical axis, however, the stretch
\nContent size includes padding but not borders, so subtract them off
\nOverrides: Ext.layout.component.Component.measureContentWidth
This method (if implemented) is called after all layouts are finished, and all have\na lastComponentSize
cached. No further layouts will be run and this method is only\ncalled 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\nthis method. This is the catch-all tail method to a layout and so the rules are more\nrelaxed. Even so, for performance reasons, it is best to avoid reading the DOM. If\na read is necessary, consider implementing a finalizeLayout method to do the\nrequired reads.
\n\nThis method need not be implemented by derived classes and, in fact, should only be\nimplemented when needed.
\nThe context item for the layout's owner\ncomponent.
\nOverrides: Ext.layout.Layout.notifyOwner
This method is called when a child item changes in some way. By default this calls\nExt.AbstractComponent.updateLayout on this layout's owner.
\nThe child item that has changed.
\nTrue if this layout has handled the content change.
\noverride inherited.\nWe need to render in the correct order, top/left before bottom/right
\nOverrides: Ext.layout.Layout.renderChildren
Renders the given Component into the target Element.
\nThe Component to render
\nThe target Element
\nThe position within the target to render the item to
\nRender the top and left docked items before any existing DOM nodes in our render target,\nand then render the right and bottom docked items after. This is important, for such things\nas tab stops and ARIA readers, that the DOM nodes are in a meaningful order.\nOur collection of docked items will already be ordered via Panel.getDockedItems().
\nOverrides: Ext.layout.Layout.renderItems
Get the reference to the class from which this object was instantiated. Note that unlike self,\nthis.statics()
is scope-independent and it always returns the class from which it was called, regardless of what\nthis
points to during run-time
Ext.define('My.Cat', {\n statics: {\n totalCreated: 0,\n speciesName: 'Cat' // My.Cat.speciesName = 'Cat'\n },\n\n constructor: function() {\n var statics = this.statics();\n\n alert(statics.speciesName); // always equals to 'Cat' no matter what 'this' refers to\n // equivalent to: My.Cat.speciesName\n\n alert(this.self.speciesName); // dependent on 'this'\n\n statics.totalCreated++;\n },\n\n clone: function() {\n var cloned = new this.self; // dependent on 'this'\n\n cloned.groupName = this.statics().speciesName; // equivalent to: My.Cat.speciesName\n\n return cloned;\n }\n});\n\n\nExt.define('My.SnowLeopard', {\n extend: 'My.Cat',\n\n statics: {\n speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'\n },\n\n constructor: function() {\n this.callParent();\n }\n});\n\nvar cat = new My.Cat(); // alerts 'Cat', then alerts 'Cat'\n\nvar snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'\n\nvar clone = snowLeopard.clone();\nalert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'\nalert(clone.groupName); // alerts 'Cat'\n\nalert(My.Cat.totalCreated); // alerts 3\n
\nAdd methods / properties to the prototype of this class.
\n\nExt.define('My.awesome.Cat', {\n constructor: function() {\n ...\n }\n});\n\n My.awesome.Cat.addMembers({\n meow: function() {\n alert('Meowww...');\n }\n });\n\n var kitty = new My.awesome.Cat;\n kitty.meow();\n
\nAdd / override static properties of this class.
\n\nExt.define('My.cool.Class', {\n ...\n});\n\nMy.cool.Class.addStatics({\n someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'\n method1: function() { ... }, // My.cool.Class.method1 = function() { ... };\n method2: function() { ... } // My.cool.Class.method2 = function() { ... };\n});\n
\nthis
\nBorrow another class' members to the prototype of this class.
\n\nExt.define('Bank', {\n money: '$$$',\n printMoney: function() {\n alert('$$$$$$$');\n }\n});\n\nExt.define('Thief', {\n ...\n});\n\nThief.borrow(Bank, ['money', 'printMoney']);\n\nvar steve = new Thief();\n\nalert(steve.money); // alerts '$$$'\nsteve.printMoney(); // alerts '$$$$$$$'\n
\nThe class to borrow members from
\nThe names of the members to borrow
\nthis
\nCreate a new instance of this Class.
\n\nExt.define('My.cool.Class', {\n ...\n});\n\nMy.cool.Class.create({\n someConfig: true\n});\n
\n\nAll parameters are passed to the constructor of the class.
\nthe created instance.
\nCreate aliases for existing prototype methods. Example:
\n\nExt.define('My.cool.Class', {\n method1: function() { ... },\n method2: function() { ... }\n});\n\nvar test = new My.cool.Class();\n\nMy.cool.Class.createAlias({\n method3: 'method1',\n method4: 'method2'\n});\n\ntest.method3(); // test.method1()\n\nMy.cool.Class.createAlias('method5', 'method3');\n\ntest.method5(); // test.method3() -> test.method1()\n
\nThe new method name, or an object to set multiple aliases. See\nflexSetter
\nThe original method name
\nGet the current class' name in string format.
\n\nExt.define('My.cool.Class', {\n constructor: function() {\n alert(this.self.getName()); // alerts 'My.cool.Class'\n }\n});\n\nMy.cool.Class.getName(); // 'My.cool.Class'\n
\nclassName
\nAdds members to class.
\nThis method has been deprecated since 4.1
\nUse addMembers instead.
\n\nOverride members of this class. Overridden methods can be invoked via\ncallParent.
\n\nExt.define('My.Cat', {\n constructor: function() {\n alert(\"I'm a cat!\");\n }\n});\n\nMy.Cat.override({\n constructor: function() {\n alert(\"I'm going to be a cat!\");\n\n this.callParent(arguments);\n\n alert(\"Meeeeoooowwww\");\n }\n});\n\nvar kitty = new My.Cat(); // alerts \"I'm going to be a cat!\"\n // alerts \"I'm a cat!\"\n // alerts \"Meeeeoooowwww\"\n
\n\nAs of 4.1, direct use of this method is deprecated. Use Ext.define\ninstead:
\n\nExt.define('My.CatOverride', {\n override: 'My.Cat',\n constructor: function() {\n alert(\"I'm going to be a cat!\");\n\n this.callParent(arguments);\n\n alert(\"Meeeeoooowwww\");\n }\n});\n
\n\nThe above accomplishes the same result but can be managed by the Ext.Loader\nwhich can properly order the override and its target class and the build process\ncan determine whether the override is needed based on the required state of the\ntarget class (My.Cat).
\nThis method has been deprecated since 4.1.0
\nUse Ext.define instead
\n\nThe properties to add to this class. This should be\nspecified as an object literal containing one or more properties.
\nthis class
\n