/** * Panel is a container that has specific functionality and structural components that make it * the perfect building block for application-oriented user interfaces. * * Panels are, by virtue of their inheritance from {@link Ext.container.Container}, capable of being * configured with a {@link Ext.container.Container#layout layout}, and containing child Components. * * When either specifying child {@link #cfg-items} of a Panel, or dynamically * {@link Ext.container.Container#method-add adding} Components to a Panel, remember to consider * how you wish the Panel to arrange those child elements, and whether those child elements * need to be sized using one of Ext's built-in `{@link Ext.container.Container#layout layout}` * schemes. By default, Panels use the {@link Ext.layout.container.Auto Auto} scheme. This simply * renders child components, appending them one after the other inside the Container, * and **does not apply any sizing** at all. * * {@img Ext.panel.Panel/panel.png Panel components} * * A Panel may also contain {@link #bbar bottom} and {@link #tbar top} toolbars, along with separate * {@link Ext.panel.Header header}, {@link #fbar footer} and body sections. * * Panel also provides built-in {@link #collapsible collapsible, expandable} and {@link #closable} * behavior. Panels can be easily dropped into any {@link Ext.container.Container Container} * or layout, and the layout and rendering pipeline is * {@link Ext.container.Container#method-add completely managed by the framework}. * * **Note:** By default, the `{@link #closable close}` header tool _destroys_ the Panel resulting * in removal of the Panel and the destruction of any descendant Components. This makes the Panel * object, and all its descendants **unusable**. To enable the close tool to simply _hide_ a Panel * for later re-use, configure the Panel with `{@link #closeAction closeAction}: 'hide'`. * * Usually, Panels are used as constituents within an application, in which case, they would be used * as child items of Containers, and would themselves use Ext.Components as child * {@link #cfg-items}. However to illustrate simply rendering a Panel into the document, * here's how to do it: * * @example * Ext.create('Ext.panel.Panel', { * title: 'Hello', * width: 200, * html: '<p>World!</p>', * renderTo: Ext.getBody() * }); * * A more realistic scenario is a Panel created to house input fields which will not be rendered, * but used as a constituent part of a Container: * * @example * var filterPanel = Ext.create('Ext.panel.Panel', { * bodyPadding: 5, // Don't want content to crunch against the borders * width: 300, * title: 'Filters', * items: [{ * xtype: 'datefield', * fieldLabel: 'Start date' * }, { * xtype: 'datefield', * fieldLabel: 'End date' * }], * renderTo: Ext.getBody() * }); * * Note that the Panel above is configured to render into the document and assigned a size. * In a real world scenario, the Panel will often be added inside a Container which will use a * {@link #layout} to render, size and position its child Components. * * Panels will often use specific {@link #layout}s to provide an application with shape * and structure by containing and arranging child Components: * * @example * var resultsPanel = Ext.create('Ext.panel.Panel', { * title: 'Results', * width: 600, * height: 400, * renderTo: Ext.getBody(), * layout: { * type: 'vbox', // Arrange child items vertically * align: 'stretch', // Each takes up full width * padding: 5 * }, * items: [{ * // Results grid specified as a config object with an xtype of 'grid' * xtype: 'grid', * // One header just for show. There's no data * columns: [{header: 'Column One'}], * store: Ext.create('Ext.data.ArrayStore', {}), // A dummy empty data store * // Use 1/3 of Container's height (hint to Box layout) * flex: 1 * }, { * xtype: 'splitter' // A splitter between the two child items * }, { * // Details Panel specified as a config object (no xtype defaults to 'panel'). * title: 'Details', * bodyPadding: 5, * items: [{ * fieldLabel: 'Data item', * xtype: 'textfield' * }], // An array of form fields * flex: 2 // Use 2/3 of Container's height (hint to Box layout) * }] * }); * * The example illustrates one possible method of displaying search results. The Panel contains * a grid with the resulting data arranged in rows. Each selected row may be displayed in detail * in the Panel below. The {@link Ext.layout.container.VBox vbox} layout is used to arrange * the two vertically. It is configured to stretch child items horizontally to full width. * Child items may either be configured with a numeric height, or with a `flex` value to distribute * available space proportionately. * * This Panel itself may be a child item of, for example, a {@link Ext.tab.Panel} which * will size its child items to fit within its content area. * * Using these techniques, as long as the **layout** is chosen and configured correctly, * an application may have any level of nested containment, all dynamically sized according to * configuration, the user's preference and available * browser size. */Ext.define('Ext.panel.Panel', { extend: 'Ext.container.Container', alias: 'widget.panel', alternateClassName: 'Ext.Panel', requires: [ 'Ext.panel.Header', 'Ext.util.MixedCollection', 'Ext.toolbar.Toolbar', 'Ext.fx.Anim', 'Ext.panel.DD', 'Ext.XTemplate', 'Ext.layout.component.Dock', 'Ext.util.Memento' ], mixins: { docking: 'Ext.container.DockingContainer' }, /** * @cfg childEls * @inheritdoc */ childEls: [ 'bodyWrap', 'body' ], /* eslint-disable indent, max-len */ /** * @cfg renderTpl * @inheritdoc */ renderTpl: [ // headingEl can also be inserted in updateHeader '<tpl if="headingText">', '<div id="{id}-headingEl" data-ref="headingEl" role="heading"', ' class="', Ext.baseCSSPrefix, 'hidden-clip" style="height:0">', '{headingText}', '</div>', '</tpl>', '<tpl if="hasTabGuard">{% this.renderTabGuard(out, values, \'before\'); %}</tpl>', '<div id="{id}-bodyWrap" data-ref="bodyWrap" class="{baseCls}-bodyWrap"', '<tpl if="bodyWrapAriaAttributes">', '<tpl foreach="bodyWrapAriaAttributes"> {$}="{.}"</tpl>', '<tpl else>', ' role="presentation"', '</tpl>', '>', // If this Panel is framed, the framing template renders the docked items round the frame '{% this.renderDockedItems(out,values,0); %}', '<div id="{id}-body" data-ref="body" class="{baseCls}-body<tpl if="bodyCls"> {bodyCls}</tpl>', ' {baseCls}-body-{ui}<tpl if="uiCls">', '<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl>', '</tpl>{childElCls}"', '<tpl if="bodyAriaAttributes">', '<tpl foreach="bodyAriaAttributes"> {$}="{.}"</tpl>', '<tpl else>', ' role="presentation"', '</tpl>', '<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>', '{%this.renderContainer(out,values);%}', '</div>', '{% this.renderDockedItems(out,values,1); %}', '</div>', '<tpl if="hasTabGuard">{% this.renderTabGuard(out, values, \'after\'); %}</tpl>' ], /* eslint-enable indent, max-len */ // <editor-fold desc="Config"> // *********************************************************************************** // Begin Config // *********************************************************************************** // For performance reasons we give the following configs their default values on // the class body. This prevents the updaters from running on initialization in the // default configuration scenario headerPosition: 'top', iconAlign: 'left', titleAlign: 'left', titleRotation: 'default', titlePosition: 0, headerConfigs: { glyph: 1, icon: 1, iconAlign: 1, iconCls: 1, title: 1, titleAlign: 1, titlePosition: 1, titleRotation: 1 }, beforeRenderConfig: { /** * @cfg glyph * @inheritdoc Ext.panel.Header#cfg-glyph * @accessor */ glyph: null, /** * @cfg {'top'/'bottom'/'left'/'right'} [headerPosition='top'] * Specify as `'top'`, `'bottom'`, `'left'` or `'right'`. * @accessor */ headerPosition: null, /** * @cfg icon * @inheritdoc Ext.panel.Header#cfg-icon * @accessor */ icon: null, /** * @cfg [iconAlign='left'] * @inheritdoc Ext.panel.Header#cfg-iconAlign * @accessor */ iconAlign: null, /** * @cfg iconCls * @inheritdoc Ext.panel.Header#cfg-iconCls * @accessor */ iconCls: null, /** * @cfg title * @inheritdoc Ext.panel.Header#cfg-title * @localdoc When a `title` is specified, the {@link Ext.panel.Header} will * automatically be created and displayed unless {@link #header} is set to `false`. * @accessor */ title: null, /** * @cfg [titleAlign='left'] * @inheritdoc Ext.panel.Header#cfg-titleAlign * @accessor */ titleAlign: null, /** * @cfg [titlePosition=0] * @inheritdoc Ext.panel.Header#cfg-titlePosition * @accessor * @since 6.5.1 */ titlePosition: null, /** * @cfg [titleRotation='default'] * @inheritdoc Ext.panel.Header#cfg-titleRotation * @accessor */ titleRotation: null }, /** * @cfg {Boolean/Number} animCollapse * `true` to animate the transition when the panel is collapsed, `false` to skip the animation * (defaults to `true` if the {@link Ext.fx.Anim} class is available, otherwise `false`). * May also be specified as the animation duration in milliseconds. */ animCollapse: Ext.enableFx, /** * @cfg {Boolean} bodyBorder * A shortcut to add or remove the border on the body of a panel. In the classic theme * this only applies to a panel which has the {@link #frame} configuration set to `true`. * @since 2.3.0 */ /** * @cfg {String/String[]} bodyCls * A CSS class, space-delimited string of classes, or array of classes to be applied * to the panel's body element. The following examples are all valid: * * bodyCls: 'foo' * bodyCls: 'foo bar' * bodyCls: ['foo', 'bar'] */ /** * @cfg {Number/String} [bodyPadding=undefined] * A shortcut for setting a padding style on the body element. The value can either be * a number to be applied to all sides, or a normal css string describing padding. */ /** * @cfg {String/Object/Function} bodyStyle * Custom CSS styles to be applied to the panel's body element, which can be supplied * as a valid CSS style string, an object containing style property name/value pairs * or a function that returns such a string or object. * For example, these two formats are interpreted to be equivalent: * * bodyStyle: 'background:#ffc; padding:10px;' * * bodyStyle: { * background: '#ffc', * padding: '10px' * } * * @since 2.3.0 */ /** * @cfg {Boolean} border * Specify as `false` to render the Panel with zero width borders. * * Leaving the value as `true` uses the selected theme's * {@link Ext.panel.Panel#$panel-border-width} * * Defaults to `false` when using or extending Neptune. * * **Note:** is ignored when {@link #frame} is set to **true**. */ border: true, /** * @cfg {Boolean} closable * True to display the 'close' tool button and allow the user to close the window, * false to hide the button and disallow closing the window. * * By default, when close is requested by clicking the close button in the header, * the {@link #method-close} method will be called. This will * _{@link Ext.Component#method-destroy destroy}_ the Panel and its content * meaning that it may not be reused. * * To make closing a Panel _hide_ the Panel so that it may be reused, set {@link #closeAction} * to 'hide'. * @accessor */ closable: false, /** * @cfg {String} closeAction * The action to take when the close header tool is clicked: * * - **`'{@link #method-destroy}'`** : * * {@link #method-remove remove} the window from the DOM and * {@link Ext.Component#method-destroy destroy} it and all descendant Components. * The window will **not** be available to be redisplayed via the {@link #method-show} method. * * - **`'{@link #method-hide}'`** : * * {@link #method-hide} the window by setting visibility to hidden and applying negative * offsets. The window will be available to be redisplayed via the {@link #method-show} * method. * * **Note:** This behavior has changed! setting *does* affect the {@link #method-close} method * which will invoke the appropriate closeAction. */ closeAction: 'destroy', /** * @cfg {String} closeToolText * Text to be announced by screen readers when the **close** * {@link Ext.panel.Tool tool} is focused. Will also be set as the close tool's * {@link Ext.panel.Tool#cfg-tooltip tooltip} text. * * **Note:** Applicable when the panel is {@link #closable}: true * @locale */ closeToolText: 'Close panel', /** * @cfg {Boolean} collapsed * `true` to render the panel collapsed, `false` to render it expanded. */ collapsed: false, /** * @cfg {String} collapsedCls * A CSS class to add to the panel's element after it has been collapsed. */ collapsedCls: 'collapsed', /** * @cfg {String} collapseDirection * The direction to collapse the Panel when the toggle button is clicked. * * Defaults to the {@link #cfg-headerPosition} * * **Important: This config is _ignored_ for {@link #collapsible} Panels which are direct child * items of a {@link Ext.layout.container.Border border layout}.** * * Specify as `'top'`, `'bottom'`, `'left'` or `'right'`. */ /** * @cfg {Boolean} collapseFirst * `true` to make sure the collapse/expand toggle button always renders first (to the left of) * any other tools in the panel's title bar, `false` to render it last. */ collapseFirst: true, /** * @cfg {Boolean} collapsible * True to make the panel collapsible and have an expand/collapse toggle Tool added * into the header tool button area. False to keep the panel sized either statically, * or by an owning layout manager, with no toggle Tool. * When a panel is used in a {@link Ext.layout.container.Border border layout}, the * {@link #floatable} option can influence the behavior of collapsing. * See {@link #collapseMode} and {@link #collapseDirection} */ collapsible: undefined, /** * @cfg {String} collapseMode * **Important: this config is only effective for {@link #collapsible} Panels which are direct * child items of a {@link Ext.layout.container.Border border layout}.** * * When _not_ a direct child item of a {@link Ext.layout.container.Border border layout}, * then the Panel's header remains visible, and the body is collapsed to zero dimensions. * If the Panel has no header, then a new header (orientated correctly depending on the * {@link #collapseDirection}) will be inserted to show a the title and a re-expand tool. * * When a child item of a {@link Ext.layout.container.Border border layout}, this config * has three possible values: * * - `undefined` - When collapsed, a placeholder {@link Ext.panel.Header Header} is injected * into the layout to represent the Panel and to provide a UI with a Tool to allow the user * to re-expand the Panel. * * - `"header"` - The Panel collapses to leave its header visible as when not inside a * {@link Ext.layout.container.Border border layout}. * * - `"mini"` - The Panel collapses without a visible header. */ /** * @cfg {String} collapseToolText * Text to be announced by screen readers when **collapse** * {@link Ext.panel.Tool tool} is focused. Will also be set as the collapse tool's * {@link Ext.panel.Tool#cfg-tooltip tooltip} text. * * **Note:** Applicable when the panel is {@link #collapsible}: true * @locale */ collapseToolText: 'Collapse panel', /** * @cfg {String} expandToolText * Text to be announced by screen readers when **expand** {@link Ext.panel.Tool tool} * is focused. Will also be set as the expand tool's * {@link Ext.panel.Tool#cfg-tooltip tooltip} text. * * **Note:** Applicable when the panel is {@link #collapsible}: true * @locale */ expandToolText: 'Expand panel', /** * @cfg {Boolean} constrain * True to constrain the panel within its containing element, false to allow it to fall outside * of its containing element. By default floating components such as Windows will be rendered to * `document.body`. To render and constrain the window within another element specify * {@link #renderTo}. Optionally the header only can be constrained using * {@link #constrainHeader}. */ constrain: false, /** * @cfg {Boolean} constrainHeader * True to constrain the panel header within its containing element (allowing the panel body * to fall outside of its containing element) or false to allow the header to fall outside * its containing element. * Optionally the entire panel can be constrained using {@link #constrain}. */ constrainHeader: false, // @cmd-auto-dependency {aliasPrefix: "widget.", typeProperty: "xtype"} /** * @cfg {Object/Object[]} dockedItems * A component or series of components to be added as docked items to this panel. The docked * items can be docked to either the top, right, left or bottom of a panel. This is typically * used for things like toolbars or tab bars: * * var panel = new Ext.panel.Panel({ * dockedItems: [{ * xtype: 'toolbar', * dock: 'top', * items: [{ * text: 'Docked to the top' * }] * }] * }); */ dockedItems: null, /** * @cfg {String} buttonAlign * The alignment of any buttons added to this panel. Valid values are 'right', 'left' * and 'center' (defaults to 'right' for buttons/fbar, 'left' for other toolbar types). * * **NOTE:** The preferred way to specify toolbars is to use the dockedItems config. * Instead of buttonAlign you would add the layout: { pack: 'start' | 'center' | 'end' } option * to the dockedItem config. */ // @cmd-auto-dependency {aliasPrefix: "widget.", typeProperty: "xtype", defaultType: "toolbar"} /** * @cfg {Object/Object[]} tbar * Convenience config. Short for 'Top Bar'. * * tbar: [ * { xtype: 'button', text: 'Button 1' } * ] * * is equivalent to * * dockedItems: [{ * xtype: 'toolbar', * dock: 'top', * items: [ * { xtype: 'button', text: 'Button 1' } * ] * }] */ tbar: null, // @cmd-auto-dependency {aliasPrefix: "widget.", typeProperty: "xtype", defaultType: "toolbar"} /** * @cfg {Object/Object[]} bbar * Convenience config. Short for 'Bottom Bar'. * * bbar: [ * { xtype: 'button', text: 'Button 1' } * ] * * is equivalent to * * dockedItems: [{ * xtype: 'toolbar', * dock: 'bottom', * items: [ * { xtype: 'button', text: 'Button 1' } * ] * }] */ bbar: null, // @cmd-auto-dependency {aliasPrefix: "widget.", typeProperty: "xtype", defaultType: "toolbar"} /** * @cfg {Object/Object[]} fbar * Convenience config used for adding items to the bottom of the panel. Short for Footer Bar. * * fbar: [ * { type: 'button', text: 'Button 1' } * ] * * is equivalent to * * dockedItems: [{ * xtype: 'toolbar', * dock: 'bottom', * ui: 'footer', * defaults: { * minWidth: 200 * }, * items: [ * { xtype: 'component', flex: 1 }, * { xtype: 'button', text: 'Button 1' } * ] * }] * * The {@link #minButtonWidth} is used as the default * {@link Ext.button.Button#minWidth minWidth} for each of the buttons in the fbar. */ fbar: null, // @cmd-auto-dependency {aliasPrefix: "widget.", typeProperty: "xtype", defaultType: "toolbar"} /** * @cfg {Object/Object[]} lbar * Convenience config. Short for 'Left Bar' (left-docked, vertical toolbar). * * lbar: [ * { xtype: 'button', text: 'Button 1' } * ] * * is equivalent to * * dockedItems: [{ * xtype: 'toolbar', * dock: 'left', * items: [ * { xtype: 'button', text: 'Button 1' } * ] * }] */ lbar: null, // @cmd-auto-dependency {aliasPrefix: "widget.", typeProperty: "xtype", defaultType: "toolbar"} /** * @cfg {Object/Object[]} rbar * Convenience config. Short for 'Right Bar' (right-docked, vertical toolbar). * * rbar: [ * { xtype: 'button', text: 'Button 1' } * ] * * is equivalent to * * dockedItems: [{ * xtype: 'toolbar', * dock: 'right', * items: [ * { xtype: 'button', text: 'Button 1' } * ] * }] */ rbar: null, /** * @cfg {Object[]} buttons * Convenience config used for adding buttons docked to the bottom of the panel. This is a * synonym for the {@link #fbar} config. * * buttons: [ * { text: 'Button 1' } * ] * * is equivalent to * * dockedItems: [{ * xtype: 'toolbar', * dock: 'bottom', * ui: 'footer', * defaults: { * minWidth: 200 * }, * items: [ * { xtype: 'component', flex: 1 }, * { xtype: 'button', text: 'Button 1' } * ] * }] * * The {@link #minButtonWidth} is used as the default * {@link Ext.button.Button#minWidth minWidth} for each of the buttons in the buttons toolbar. */ buttons: null, /** * @cfg draggable * @inheritdoc * @localdoc **NOTE:** The private {@link Ext.panel.DD} class is used instead of * ComponentDragger when {@link #simpleDrag} is false (_default_). In this case you * may pass a config for {@link Ext.dd.DragSource}. * * See also {@link #dd}. */ /** * @cfg {Boolean} floatable * **Important: This config is only effective for {@link #collapsible} Panels which are direct * child items of a {@link Ext.layout.container.Border border layout}.** * * true to allow clicking a collapsed Panel's {@link #placeholder} to display the Panel floated * above the layout, false to force the user to fully expand a collapsed region by clicking * the expand button to see it again. */ floatable: true, /** * @cfg {Boolean} frame * True to apply a frame to the panel. * * **Note:** `frame: true` overrides {@link #border border:false} */ frame: false, /** * @cfg {Boolean} frameHeader * True to apply a frame to the panel panels header (if 'frame' is true). */ frameHeader: true, /** * @cfg {Boolean/Object} header * Pass as `false` to prevent a Header from being created and shown. * * Pass as a config object (optionally containing an `xtype`) to custom-configure this Panel's * header. * * See {@link Ext.panel.Header} for all the options that may be specified here. * * A {@link Ext.panel.Header panel header} is a {@link Ext.container.Container} which contains * the Panel's {@link #title} and {@link #tools}. You may also configure the Panel's `header` * option with its own child items which go *before* the {@link #tools} * * By default the panel {@link #title} is inserted after items configured in this config, * but before any tools. To insert the title at any point in the full array, specify the * {@link Ext.panel.Header#cfg-titlePosition titlePosition} config: * * new Ext.panel.Panel({ * title: 'Test', * tools: [{ * type: 'refresh' * }, { * type: 'help' * }], * titlePosition: 2 // Title will come AFTER the two tools * ... * }); * */ /** * @cfg {String} headerOverCls * Optional CSS class to apply to the header element on mouseover */ /** * @cfg {Boolean} hideCollapseTool * `true` to hide the expand/collapse toggle button when `{@link #collapsible} == true`, * `false` to display it. */ hideCollapseTool: false, /** * @cfg {Boolean} [manageHeight=true] When true, the dock component layout writes * height information to the panel's DOM elements based on its shrink wrap height * calculation. This ensures that the browser respects the calculated height. * When false, the dock component layout will not write heights on the panel or its * body element. In some simple layout cases, not writing the heights to the DOM may * be desired because this allows the browser to respond to direct DOM manipulations * (like animations). */ manageHeight: true, /** * @cfg {String} maskElement * * The name of the element property in this Panel to mask when masked by a LoadMask. * * Defaults to `"el"` to indicate that any LoadMask should be rendered into this Panel's * encapsulating element. * * This could be configured to be `"body"` so that only the body is masked and toolbars * and the header are still mouse-accessible. */ maskElement: 'el', /** * @cfg {Number} minButtonWidth * Minimum width of all footer toolbar buttons in pixels. If set, this will be used * as the default value for the {@link Ext.button.Button#minWidth} config of each Button * added to the **footer toolbar** via the {@link #fbar} or {@link #buttons} configurations. * It will be ignored for buttons that have a minWidth configured some other way, * e.g. in their own config object or via the {@link Ext.container.Container#defaults defaults} * of their parent container. */ minButtonWidth: 75, /** * @cfg {Boolean} overlapHeader * True to overlap the header in a panel over the framing of the panel itself. This is needed * when `frame: true` (and is done automatically for you). Otherwise it is undefined. * If you manually add rounded corners to a panel header which does not have `frame: true`, * this will need to be set to true. */ /** * @cfg {Ext.Component/Object} placeholder * **Important: This config is only effective for {@link #collapsible} Panels which are direct * child items of a {@link Ext.layout.container.Border border layout} when not using * the `'header'` {@link #collapseMode}.** * * **Optional.** A Component (or config object for a Component) to show in place of this Panel * when this Panel is collapsed by a {@link Ext.layout.container.Border border layout}. * Defaults to a generated {@link Ext.panel.Header Header} containing a * {@link Ext.panel.Tool Tool} to re-expand the Panel. */ /** * @cfg {Number} [placeholderCollapseHideMode=Ext.Element.VISIBILITY] * The {@link Ext.dom.Element#setVisibilityMode mode} for hiding collapsed panels when * using {@link #collapseMode} "placeholder". */ // placeholderCollapseHideMode: Ext.Element.VISIBILITY, /** * @cfg {Boolean} preventHeader * @deprecated 4.1.0 Use {@link #header} instead. * Prevent a Header from being created and shown. */ preventHeader: false, /** * @cfg {Boolean} maintainTitlePosition * For panels that are collapsed to the left or right, * {@link Ext.panel.Header#titlePosition} may be temporarily changed for UI consistency. * Setting this config to true will force the specified titlePosition to be maintained * @since 6.5.1 */ maintainTitlePosition: false, /** * @cfg [shrinkWrap=2] * @inheritdoc * @localdoc ##Panels (subclasses and instances) * * By default, when a panel is configured to shrink wrap in a given dimension, only * the panel's "content" (items and html content inside the panel body) contributes * to its size, and the content of docked items is ignored. Optionally you can use * the {@link #shrinkWrapDock} config to allow docked items to contribute to the * panel's size as well. For example, if shrinkWrap and shrinkWrapDock are both set * to true, the width of the panel would be the width of the panel's content and the * panel's header text. */ /** * @cfg {Boolean/Number} shrinkWrapDock * Allows for this panel to include the {@link #dockedItems} when trying to determine * the overall size of the panel. This option is only applicable when this panel is * also shrink wrapping in the same dimensions. See {@link Ext.Panel#shrinkWrap} for * an explanation of the configuration options. */ shrinkWrapDock: false, /** * @cfg {Boolean} [simpleDrag=false] * When {@link #cfg-draggable} is `true`, Specify this as `true` to cause the `draggable` * config to work the same as it does in {@link Ext.window.Window Window}. This Panel * just becomes movable. No DragDrop instances receive any notifications. * For example: * * @example * var win = Ext.create('widget.window', { * height: 300, * width: 300, * title: 'Constraining Window', * closable: false, * items: { * title: "Floating Panel", * width: 100, * height: 100, * floating: true, * draggable: true, * constrain: true, * simpleDrag: true * } * }); * win.show(); * // Floating components begin life hidden * win.child('[title=Floating Panel]').show(); * */ /** * @cfg stateEvents * @inheritdoc Ext.state.Stateful#cfg-stateEvents * @localdoc By default the following stateEvents are added: * * - {@link #event-resize} - _(added by Ext.Component)_ * - {@link #event-collapse} * - {@link #event-expand} */ /** * @cfg {Boolean} titleCollapse * `true` to allow expanding and collapsing the panel (when `{@link #collapsible} = true`) * by clicking anywhere in the header bar, `false`) to allow it only by clicking to tool * button). When a panel is used in a {@link Ext.layout.container.Border border layout}, * the {@link #floatable} option can influence the behavior of collapsing. */ titleCollapse: undefined, /** * @cfg {Object[]/Ext.panel.Tool[]} tools * An array of {@link Ext.panel.Tool} configs/instances to be added to the header tool area. * The tools are stored as child components of the header container. They can be accessed using * {@link #down} and {#query}, as well as the other component methods. The toggle tool * is automatically created if {@link #collapsible} is set to true. * * Note that, apart from the toggle tool which is provided when a panel is collapsible, * these tools only provide the visual button. Any required functionality must be provided * by adding handlers that implement the necessary behavior. * * Example usage: * * tools: [{ * type:'refresh', * tooltip: 'Refresh form Data', * // hidden:true, * handler: function(event, toolEl, panelHeader) { * // refresh logic * } * }, * { * type:'help', * tooltip: 'Get Help', * callback: function(panel, tool, event) { * // show help here * } * }] * * The difference between `handler` and `callback` is the signature. For details on * the distinction, see {@link Ext.panel.Tool}. */ /** * @cfg {String} defaultButton * Reference name of the component to act as the default button for this Panel. * Default button is activated by pressing Enter key while focus is contained within * the Panel's {@link #defaultButtonTarget}. * * The most obvious use for `defaultButton` is submitting a form: * * var loginWindow = new Ext.window.Window({ * autoShow: true, * width: 300, * layout: 'form', * title: 'Enter login information', * referenceHolder: true, * defaultFocus: 'textfield', * defaultButton: 'okButton', * * items: [{ * xtype: 'textfield', * fieldLabel: 'User name' * }, { * xtype: 'textfield', * fieldLabel: 'Password' * }], * * buttons: [{ * reference: 'okButton', * text: 'Login', * handler: function() { * Ext.Msg.alert('Submit', 'Your login is being processed'); * } * }] * }); */ /** * @cfg {String} [defaultButtonTarget] Name of the element that will be the target of * {@link #defaultButton} keydown listener. The default element is Panel body, which * means that pressing Enter key while focus is on docked items will not fire `defaultButton` * action. * * If you want `defaultButton` action to fire in docked items, set this config to `"el"`. */ // *********************************************************************************** // End Config // *********************************************************************************** // </editor-fold> // <editor-fold desc="Properties"> // *********************************************************************************** // Begin Properties // *********************************************************************************** /** * @cfg baseCls * @inheritdoc */ baseCls: Ext.baseCSSPrefix + 'panel', /** * @property {Ext.dom.Element} body * The Panel's body {@link Ext.dom.Element Element} which may be used to contain HTML content. * The content may be specified in the {@link #html} config, or it may be loaded using the * {@link #loader} config. Read-only. * * If this is used to load visible HTML elements in either way, then * the Panel may not be used as a Layout for hosting nested Panels. * * If this Panel is intended to be used as the host of a Layout (See {@link #cfg!layout} * then the body Element must not be loaded or changed - it is under the control * of the Panel's Layout. * * @readonly */ bodyPosProps: { x: 'x', y: 'y' }, /** * @cfg componentLayout * @inheritdoc */ componentLayout: 'dock', /** * @property contentPaddingProperty * @inheritdoc */ contentPaddingProperty: 'bodyPadding', emptyArray: [], /** * @property {Boolean} isPanel * `true` in this class to identify an object as an instantiated Panel, or subclass thereof. */ isPanel: true, /** * @property defaultBindProperty * @inheritdoc */ defaultBindProperty: 'title', // *********************************************************************************** // End Properties // *********************************************************************************** // </editor-fold> // <editor-fold desc="Events"> // *********************************************************************************** // Begin Events // *********************************************************************************** /** * @event beforeclose * Fires before the user closes the panel. Return false from any listener to stop * the close event being fired * @param {Ext.panel.Panel} panel The Panel object */ /** * @event beforecollapse * Fires before this panel is collapsed. Return false to prevent the collapse. * @param {Ext.panel.Panel} p The Panel being collapsed. * @param {String} direction . The direction of the collapse. One of * * - Ext.Component.DIRECTION_TOP * - Ext.Component.DIRECTION_RIGHT * - Ext.Component.DIRECTION_BOTTOM * - Ext.Component.DIRECTION_LEFT * * @param {Boolean} animate True if the collapse is animated, else false. */ /** * @event beforeexpand * Fires before this panel is expanded. Return false to prevent the expand. * @param {Ext.panel.Panel} p The Panel being expanded. * @param {Boolean} animate True if the expand is animated, else false. */ /** * @event close * Fires when the user closes the panel. * @param {Ext.panel.Panel} panel The Panel object */ /** * @event collapse * Fires after this Panel has collapsed. * @param {Ext.panel.Panel} p The Panel that has been collapsed. */ /** * @event expand * Fires after this Panel has expanded. * @param {Ext.panel.Panel} p The Panel that has been expanded. */ /** * @event float * Fires after a collapsed Panel has been "floated" by clicking on * it's header. Only applicable when the Panel is an item in a * {@link Ext.layout.container.Border Border Layout}. */ /** * @event glyphchange * Fired when the Panel glyph has been changed by the {@link #setGlyph} method. * @param {Ext.panel.Panel} this * @param {Number/String} newGlyph * @param {Number/String} oldGlyph */ /** * @event iconalignchange * Fires after the Panel iconAlign has been set or changed. * @param {Ext.panel.Panel} this The Panel which has the iconAlign changed. * @param {String} newIconAlign * @param {String} oldIconAlign * @since 6.5.1 */ /** * @event iconchange * Fires after the Panel icon has been set or changed. * @param {Ext.panel.Panel} this The Panel which has the icon changed. * @param {String} newIcon The path to the new icon image. * @param {String} oldIcon The path to the previous panel icon image. */ /** * @event iconclschange * Fires after the Panel iconCls has been set or changed. * @param {Ext.panel.Panel} this The Panel which has the iconCls changed. * @param {String} newIconCls The new iconCls. * @param {String} oldIconCls The previous panel iconCls. */ /** * @event titlealignchange * Fires after the Panel titleAlign has been set or changed. * @param {Ext.panel.Panel} this the Panel which has the titleAlign changed. * @param {String} newTitleAlign * @param {String} oldTitleAlign * @since 6.5.1 */ /** * @event titlechange * Fires after the Panel title has been set or changed. * @param {Ext.panel.Panel} this the Panel which has been resized. * @param {String} newTitle The new title. * @param {String} oldTitle The previous panel title. */ /** * @event titlepositionchange * Fires after the Panel titlePosition has been set or changed. * @param {Ext.panel.Panel} this the Panel which has the titlePosition changed. * @param {String} newTitlePosition * @param {String} oldTitlePosition * @since 6.5.1 */ /** * @event titlerotationchange * Fires after the Panel titleRotation has been set or changed. * @param {Ext.panel.Panel} this the Panel which has the titleRotation changed. * @param {String} newTitleRotation * @param {String} oldTitleRotation * @since 6.5.1 */ /** * @event unfloat * Fires after a "floated" Panel has returned to it's collapsed state * as a result of the mouse leaving the Panel. Only applicable when * the Panel is an item in a * {@link Ext.layout.container.Border Border Layout}. */ // *********************************************************************************** // End Events // *********************************************************************************** // </editor-fold> // <editor-fold desc="Component Methods"> // *********************************************************************************** // Begin Methods // *********************************************************************************** /** * Adds a CSS class to the body element. If not rendered, the class will * be added when the panel is rendered. * @param {String/String[]} cls The class to add * @return {Ext.panel.Panel} this */ addBodyCls: function(cls) { var me = this, body = me.rendered ? me.body : me.getProtoBody(); body.addCls(cls); return me; }, /** * Add tools to this panel {@link Ext.panel.Header header} * * panel.addTool({ * type: 'gear', * handler: function() { * // .... * } * }); * * panel.addTool([{ * type: 'gear', * handler: 'viewControllerGearMethod' * }, { * type: 'save', * handler: 'viewControllerSaveMethod' * }]); * * By default the tools will be accessible via keyboard, with the exception of * automatically added collapse/expand and close tools. * * If you implement keyboard equivalents of your tools' actions elsewhere and do not * want the tools to participate in keyboard navigation, you can make them * presentational instead: * * panel.addTool({ * type: 'mytool', * focusable: false, * ariaRole: 'presentation' * // ... * }); * * @param {Object/Object[]/Ext.panel.Tool/Ext.panel.Tool[]} tools The tool or tools to * add. */ addTool: function(tools) { if (!Ext.isArray(tools)) { tools = [tools]; } // eslint-disable-next-line vars-on-top var me = this, header = me.header, len = tools.length, curTools = me.tools, t, tool; if (!header || !header.isHeader) { header = null; if (!curTools) { me.tools = curTools = []; } } for (t = 0; t < len; t++) { tool = tools[t]; if (typeof tool !== 'string' && !tool.isTool) { tool = Ext.apply({}, tool); } tool.toolOwner = me; if (header) { header.addTool(tool); } else { // only modify the tools array if the header isn't created, // otherwise, defer to the header to manage curTools.push(tool); } } me.updateHeader(); }, /** * @method * @protected * @template * Template method to be implemented in subclasses to add their tools after * the collapsible tool. */ addTools: Ext.emptyFn, getClosable: function() { return this.closable; }, setClosable: function(closable) { var me = this, tab = me.tab; closable = !!closable; if (me.closable !== closable) { me.closable = closable; if (tab) { tab.setClosable(closable); } } }, setCollapsible: function(collapsible) { var me = this, current = me.collapsible, collapseTool = me.collapseTool; me.collapsible = collapsible; if (collapsible && !current) { me.updateCollapseTool(); collapseTool = me.collapseTool; if (collapseTool) { collapseTool.show(); } } else if (!collapsible && current) { if (collapseTool) { collapseTool.hide(); } } }, /** * @method addUIClsToElement * @inheritdoc */ addUIClsToElement: function(cls) { var me = this, result = me.callParent(arguments); me.addBodyCls([Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls]); return result; }, /** * Invoked after the Panel is Collapsed. * * @param {Boolean} animated * * @template * @protected */ afterCollapse: function(animated) { var me = this, ownerLayout = me.ownerLayout; me.isCollapsingOrExpanding = 0; me.updateCollapseTool(); // The x-animating-size class sets overflow:hidden so that overflowing // content is clipped during animation. if (animated) { me.removeCls(Ext.baseCSSPrefix + 'animating-size'); } if (ownerLayout) { ownerLayout.afterCollapse(me, animated); } me.setHiddenDocked(); me.fireEvent('collapse', me); }, /** * Invoked after the Panel is Expanded. * * @param {Boolean} animated * * @template * @protected */ afterExpand: function(animated) { var me = this, ownerLayout = me.ownerLayout; me.isCollapsingOrExpanding = 0; me.updateCollapseTool(); // The x-animating-size class sets overflow:hidden so that overflowing // content is clipped during animation. if (animated) { me.removeCls(Ext.baseCSSPrefix + 'animating-size'); } if (ownerLayout) { ownerLayout.afterExpand(me, animated); } me.fireEvent('expand', me); me.fireHierarchyEvent('expand'); }, doDestroy: function() { var me = this; if (me.slideOutTask) { me.slideOutTask.cancel(); } Ext.destroy( me.placeholder, me.ghostPanel, me.dd, me.accordionHeaderKeyNav, me.accordionBodyKeyNav, me.defaultButtonKeyNav ); me.destroyDockedItems(); me.callParent(); }, beforeRender: function() { var me = this, wasCollapsed; // Ensure the protoBody exists so that initOverflow gets right answer from getOverflowEl. // If this Panel was applied to an existing element (such as being used as a Viewport) // then it will not have been created. me.getProtoBody(); me.callParent(); // Add class-specific header tools. // Panel adds collapsible and closable. me.initTools(); // Dock the header/title unless we are configured specifically not to create a header. // If the panel participates in a border layout it should have the ARIA role of 'region'. // In that case we need to render a heading element even if the panel is configured // not to have a header. if (!(me.preventHeader || (me.header === false)) || me.isViewportBorderChild) { me.updateHeader(); } me.afterHeaderInit = true; // If we are rendering collapsed, we still need to save and modify various configs if (me.collapsed) { if (me.isPlaceHolderCollapse()) { if (!me.hidden) { me.setHiddenState(true); // This will insert the placeholder Component into the ownerCt's // child collection. // Its getRenderTree call which is calling this will then iterate again and // recreate the child items array to include the new Component. // Prevent the first collapse from firing me.preventCollapseFire = true; me.placeholderCollapse(); delete me.preventCollapseFire; wasCollapsed = me.collapsed; // Temporarily clear the flag so that the header is rendered // with a collapse tool in it. // Placeholder collapse panels never really collapse, they just hide. // The tool is always a collapse tool. me.collapsed = false; } } else { me.beginCollapse(); me.addClsWithUI(me.collapsedCls); } } // Restore the flag if we are being rendered initially placeholder collapsed. if (wasCollapsed) { me.collapsed = wasCollapsed; } }, /** * @private * Memento Factory method * @param {String} name Name of the Memento (used as prefix for named Memento) */ getMemento: function(name) { var me = this; if (name && typeof name === 'string') { name += 'Memento'; return me[name] || (me[name] = new Ext.util.Memento(me)); } }, /** * @private * Called before the change from default, configured state into the collapsed state. * This method may be called at render time to enable rendering in an initially collapsed state, * or at runtime when an existing, fully laid out Panel may be collapsed. * It basically saves configs which need to be clobbered for the duration of the collapsed * state. */ beginCollapse: function() { var me = this, lastBox = me.lastBox, rendered = me.rendered, collapseMemento = me.getMemento('collapse'), sizeModel = me.getSizeModel(), header = me.header, reExpander; // When we collapse a panel, the panel is in control of one dimension (depending on // collapse direction) and sets that on the component. We must restore the user's // original value (including non-existence) when we expand. Using this technique, we // mimic setCalculatedSize for the dimension we do not control and setSize for the // one we do (only while collapsed). // Additionally, the panel may have a shrink wrapped width and/or height. For shrinkWrapped // panels this can be problematic, since a collapsed, shrink-wrapped panel has no way // of determining its width (or height if the collapse direction is horizontal). It is // therefore necessary to capture both the width and height regardless of collapse direction // This allows us to set a configured width or height on the panel when it is collapsed, // and it will be restored to an unconfigured-width shrinkWrapped state on expand. collapseMemento.capture(['height', 'minHeight', 'width', 'minWidth']); if (lastBox) { collapseMemento.capture(me.restoreDimension(), lastBox, 'last.'); } // If the panel has a shrinkWrapped height/width and is already rendered, configure // its width/height as its calculated width/height, so that the collapsed header // will have the same width or height as the panel did before it was collapsed. // If the shrinkWrapped panel has not yet been rendered, as will be the case when a panel // is initially configured with collapsed:true, we attempt to use the configured // width/height, and fall back to minWidth or minHeight if width/height has not been // configured, and fall back to a value of 100 if a minWidth/minHeight has not been // configured. if (me.collapsedVertical()) { if (sizeModel.width.shrinkWrap) { me.width = rendered ? me.getWidth() : me.width || me.minWidth || 100; } delete me.height; me.minHeight = 0; } else if (me.collapsedHorizontal()) { if (sizeModel.height.shrinkWrap) { me.height = rendered ? me.getHeight() : me.height || me.minHeight || 100; } delete me.width; me.minWidth = 0; } if (me.ownerCt) { me.ownerCt.getLayout().beginCollapse(me); } // Get a reExpander header. This will return the Panel Header if the Header // is in the correct orientation // If we are using the Header as the reExpander, change its UI to collapsed state if (!me.isPlaceHolderCollapse() && header !== false) { if (header === (reExpander = me.getReExpander())) { header.collapseImmune = true; header.getInherited().collapseImmune = true; header.addClsWithUI(me.getHeaderCollapsedClasses(header)); // Ensure that the reExpander has the correct framing applied. if (header.rendered) { header.updateFrame(); } } else if (reExpander.el) { // We're going to use a temporary reExpander: show it. reExpander.el.show(); reExpander.hidden = false; } } if (me.resizer) { me.resizer.disable(); } if (me.rendered) { me.ariaEl.dom.setAttribute('aria-expanded', false); // In accordion layout, panel body has the role of tabpanel // and needs to be updated accordingly when the panel is collapsed if (me.isAccordionPanel) { me.body.dom.setAttribute('aria-hidden', true); } } }, beginDrag: function() { if (this.floatingDescendants) { this.floatingDescendants.hide(); } }, beginExpand: function() { var me = this, lastBox = me.lastBox, collapseMemento = me.getMemento('collapse'), restoreDimension = me.restoreDimension(), header = me.header, reExpander; if (collapseMemento) { collapseMemento.restore(['minHeight', 'minWidth', restoreDimension]); if (lastBox) { collapseMemento.restore(restoreDimension, true, lastBox, 'last.'); } } if (me.ownerCt) { me.ownerCt.getLayout().beginExpand(me); } if (!me.isPlaceHolderCollapse() && header !== false) { // If we have been using our Header as the reExpander then restore the Header // to expanded UI if (header === (reExpander = me.getReExpander())) { delete header.collapseImmune; delete header.getInherited().collapseImmune; header.removeClsWithUI(me.getHeaderCollapsedClasses(header)); // Ensure that the reExpander has the correct framing applied. if (header.rendered) { header.expanding = true; header.updateFrame(); delete header.expanding; } } else { // We've been using a temporary reExpander: hide it. reExpander.hidden = true; reExpander.el.hide(); } } if (me.resizer) { me.resizer.enable(); } if (me.rendered) { me.ariaEl.dom.setAttribute('aria-expanded', true); // In accordion layout, panel body has the role of tabpanel // and needs to be updated accordingly when the panel is expanded if (me.isAccordionPanel) { me.body.dom.setAttribute('aria-hidden', false); } } }, bridgeToolbars: function() { var me = this, docked = [], minButtonWidth = me.minButtonWidth, fbar, fbarDefaults, fbarIsButtons; function initToolbar(toolbar, pos, useButtonAlign, disableFocusableContainer) { if (Ext.isArray(toolbar)) { toolbar = { xtype: 'toolbar', items: toolbar }; } else if (!toolbar.isComponent) { // Incoming toolbar config can be a property on the prototype toolbar = Ext.apply({}, toolbar); } if (!toolbar.xtype) { toolbar.xtype = 'toolbar'; } toolbar.dock = pos; if (disableFocusableContainer) { toolbar.focusableContainer = false; } // Legacy support for buttonAlign (only used by buttons/fbar) if (useButtonAlign) { toolbar.layout = Ext.apply({ // default to 'end' (right-aligned) if me.buttonAlign is undefined or invalid pack: { left: 'start', center: 'center' }[me.buttonAlign] || 'end' }, toolbar.layout); } return toolbar; } if (me.tbar) { docked.push(initToolbar(me.tbar, 'top')); me.tbar = null; } if (me.bbar) { docked.push(initToolbar(me.bbar, 'bottom')); me.bbar = null; } if (me.buttons) { me.fbar = me.buttons; me.buttons = null; fbarIsButtons = true; } if (me.fbar) { fbar = initToolbar(me.fbar, 'bottom', true, fbarIsButtons); // only we useButtonAlign fbar.ui = 'footer'; // Apply the minButtonWidth config to buttons in the toolbar if (minButtonWidth) { fbarDefaults = fbar.defaults; fbar.defaults = function(config) { var defaults = fbarDefaults || {}, // no xtype or a button instance isButton = !config.xtype || config.isButton, cls; // Here we have an object config with an xtype, check if it's a button // or a button subclass if (!isButton) { cls = Ext.ClassManager.getByAlias('widget.' + config.xtype); if (cls) { isButton = cls.prototype.isButton; } } if (isButton && !('minWidth' in defaults)) { defaults = Ext.apply({ minWidth: minButtonWidth }, defaults); } return defaults; }; } docked.push(fbar); me.fbar = null; } if (me.lbar) { docked.push(initToolbar(me.lbar, 'left')); me.lbar = null; } if (me.rbar) { docked.push(initToolbar(me.rbar, 'right')); me.rbar = null; } if (me.dockedItems) { if (me.dockedItems.isMixedCollection) { me.addDocked(docked); } else { if (!Ext.isArray(me.dockedItems)) { me.dockedItems = [me.dockedItems]; } me.dockedItems = me.dockedItems.concat(docked); } } else { me.dockedItems = docked; } }, /** * Closes the Panel. By default, this method, removes it from the DOM, * {@link Ext.Component#method-destroy destroy}s the Panel object and all its descendant * Components. The {@link #beforeclose beforeclose} event is fired before the * close happens and will cancel the close action if it returns false. * * **Note:** This method is also affected by the {@link #closeAction} setting. * For more explicit control use {@link #method-destroy} and {@link #method-hide} methods. */ close: function() { if (this.fireEvent('beforeclose', this) !== false) { this.doClose(); } }, /** * Collapses the panel body so that the body becomes hidden. Docked Components parallel * to the border towards which the collapse takes place will remain visible. Fires the * {@link #beforecollapse} event which will cancel the collapse action if it returns false. * * @param {String} [direction] The direction to collapse towards. Must be one of * * - Ext.Component.DIRECTION_TOP * - Ext.Component.DIRECTION_RIGHT * - Ext.Component.DIRECTION_BOTTOM * - Ext.Component.DIRECTION_LEFT * * Defaults to {@link #collapseDirection}. * * @param {Boolean/Number} [animate] True to animate the transition, else false * (defaults to the value of the {@link #animCollapse} panel config). May * also be specified as the animation duration in milliseconds. * @return {Ext.panel.Panel} this */ collapse: function(direction, animate) { var me = this, collapseDir = direction || me.collapseDirection, ownerCt = me.ownerCt, layout = me.ownerLayout, rendered = me.rendered; if (me.isCollapsingOrExpanding) { return me; } if (arguments.length < 2) { animate = me.animCollapse; } if (me.collapsed || me.fireEvent('beforecollapse', me, direction, animate) === false) { return me; } if (layout && layout.onBeforeComponentCollapse) { if (layout.onBeforeComponentCollapse(me) === false) { return me; } } if (rendered && ownerCt && me.isPlaceHolderCollapse()) { return me.placeholderCollapse(direction, animate); } me.collapsed = collapseDir; if (rendered) { me.beginCollapse(); } me.getInherited().collapsed = true; me.fireHierarchyEvent('collapse'); if (rendered) { me.doCollapseExpand(1, animate); } return me; }, collapsedHorizontal: function() { var dir = this.getCollapsed(); return dir === 'left' || dir === 'right'; }, collapsedVertical: function() { var dir = this.getCollapsed(); return dir === 'top' || dir === 'bottom'; }, /** * converts a collapsdDir into an anchor argument for Element.slideIn * overridden in rtl mode to switch "l" and "r" */ convertCollapseDir: function(collapseDir) { return collapseDir.substr(0, 1); }, createGhost: function(cls) { var me = this, header = me.header, frame = me.frame && !me.alwaysFramed; return { xtype: 'panel', hidden: false, header: header ? { titleAlign: header.getTitleAlign() } : null, ui: frame ? me.ui.replace(/-framed$/, '') : me.ui, id: me.id + '-ghost', renderTo: Ext.getBody(), // The ghost's opacity causes the resize handles to obscure the frame in // IE, so always force resizable to be false. resizable: false, // The ghost must not be draggable (the actual class instantiated // may be draggable in its prototype) draggable: false, // Tools are explicitly copied. closable: false, focusable: false, floating: true, alignOnScroll: false, shadow: false, frame: frame, shim: me.shim, alwaysFramed: me.alwaysFramed, overlapHeader: me.overlapHeader, headerPosition: me.getHeaderPosition(), titleRotation: me.getTitleRotation(), baseCls: me.baseCls, getRefOwner: function() { return me.getRefOwner(); }, cls: me.baseCls + '-ghost ' + (cls || '') }; }, createReExpander: function(direction, defaults) { var me = this, isLeft = direction === 'left', isRight = direction === 'right', isVertical = isLeft || isRight, ownerCt = me.ownerCt, header = me.header, result = Ext.apply({ hideMode: 'offsets', title: me.getTitle(), titleAlign: me.getTitleAlign(), titlePosition: me.getTitlePosition(), vertical: isVertical, textCls: me.headerTextCls, icon: me.getIcon(), iconCls: me.getIconCls(), iconAlign: me.getIconAlign(), glyph: me.getGlyph(), baseCls: me.self.prototype.baseCls + '-header', ui: me.ui, frame: me.frame && me.frameHeader, ignoreParentFrame: me.frame || me.overlapHeader, ignoreBorderManagement: me.frame || me.ignoreHeaderBorderManagement, indicateDrag: me.draggable, collapseImmune: true, ariaRole: me.ariaRole, preventRefocus: true, ownerCt: (ownerCt && me.collapseMode === 'placeholder') ? ownerCt : me, ownerLayout: me.componentLayout, forceOrientation: true, margin: me.margin, // When placeholder is focused, focus the expander tool. // TODO: When https://sencha.jira.com/browse/EXTJS-19718 is // fixed, this should not be needed. // placeholder is a FocusableContainer defaultFocus: 'tool[isDefaultExpandTool]' }, defaults); // If we're in mini mode, set the placeholder size to only 1px since // we don't need it to show up. if (me.collapseMode === 'mini') { if (isVertical) { result.width = 1; } else { result.height = 1; } } if (header) { Ext.apply(result, { focusableContainer: header.focusableContainer, activeChildTabIndex: header.activeChildTabIndex, inactiveChildTabIndex: header.inactiveChildTabIndex, allowFocusingDisabledChildren: header.allowFocusingDisabledChildren }); } // Create the re expand tool // For UI consistency reasons, collapse:left reExpanders, and region: 'west' placeHolders // have the re expand tool at the *top* with a bit of space. if (!me.hideCollapseTool) { if (!me.maintainTitlePosition && (isLeft || (isRight && me.isPlaceHolderCollapse()))) { // adjust the title position if the collapse tool needs to be at the // top of a vertical header result.titlePosition = 1; } result.tools = [{ xtype: 'tool', type: 'expand-' + me.getOppositeDirection(direction), isDefaultExpandTool: true, uiCls: ['top'], handler: me.toggleCollapse, scope: me, tooltip: me.expandToolText }]; } result = new Ext.panel.Header(result); result.addClsWithUI(me.getHeaderCollapsedClasses(result)); result.expandTool = result.down('tool[isDefaultExpandTool=true]'); return result; }, /** * @private */ doClose: function() { this.fireEvent('close', this); this[this.closeAction](); }, doCollapseExpand: function(flags, animate) { var me = this, originalAnimCollapse = me.animCollapse, ownerLayout = me.ownerLayout; // we need to temporarily set animCollapse to the animate value here because ContextItem // uses the animCollapse property to determine if the collapse/expand should be animated me.animCollapse = animate; // Flag used by the layout ContextItem to impose an animation policy based upon the // collapse direction and the animCollapse setting. me.isCollapsingOrExpanding = flags; // The x-animating-size class sets overflow:hidden so that overflowing // content is clipped during animation. if (animate) { me.addCls(Ext.baseCSSPrefix + 'animating-size'); } if (ownerLayout && !animate) { ownerLayout.onContentChange(me); } else { me.updateLayout({ isRoot: true }); } // set animCollapse back to its original value me.animCollapse = originalAnimCollapse; return me; }, endDrag: function() { if (this.floatingDescendants) { this.floatingDescendants.show(); } }, /** * Expands the panel body so that it becomes visible. Fires the {@link #beforeexpand} * event which will cancel the expand action if it returns false. * @param {Boolean} [animate] True to animate the transition, else false * (defaults to the value of the {@link #animCollapse} panel config). May * also be specified as the animation duration in milliseconds. * @return {Ext.panel.Panel} this */ expand: function(animate) { var me = this, layout = me.ownerLayout, rendered = me.rendered; if (me.isCollapsingOrExpanding) { return me; } if (!arguments.length) { animate = me.animCollapse; } if (!me.collapsed && !me.floatedFromCollapse) { return me; } if (me.fireEvent('beforeexpand', me, animate) === false) { return me; } if (layout && layout.onBeforeComponentExpand) { if (layout.onBeforeComponentExpand(me) === false) { return me; } } delete me.getInherited().collapsed; if (rendered && me.isPlaceHolderCollapse()) { return me.placeholderExpand(animate); } me.restoreHiddenDocked(); if (rendered) { me.beginExpand(); } me.collapsed = false; if (me.rendered) { me.doCollapseExpand(2, animate); } return me; }, findReExpander: function(direction) { var me = this, c = Ext.Component, dockedItems = me.dockedItems.items, dockedItemCount = dockedItems.length, comp, i; // never use the header if we're in collapseMode mini if (me.collapseMode === 'mini') { return; } switch (direction) { case c.DIRECTION_TOP: case c.DIRECTION_BOTTOM: // Attempt to find a reExpander Component (docked in a horizontal orientation) // Also, collect all other docked items which we must hide after collapse. for (i = 0; i < dockedItemCount; i++) { comp = dockedItems[i]; if (!comp.hidden) { if (comp.isHeader && (!comp.dock || comp.dock === 'top' || comp.dock === 'bottom')) { return comp; } } } break; case c.DIRECTION_LEFT: case c.DIRECTION_RIGHT: // Attempt to find a reExpander Component (docked in a vertical orientation) // Also, collect all other docked items which we must hide after collapse. for (i = 0; i < dockedItemCount; i++) { comp = dockedItems[i]; if (!comp.hidden) { if (comp.isHeader && (comp.dock === 'left' || comp.dock === 'right')) { return comp; } } } break; default: throw new Error('Panel#findReExpander must be passed a valid collapseDirection'); } }, floatCollapsedPanel: function() { var me = this, placeholder = me.placeholder, splitter = me.splitter, phBox = Ext.util.Region.from(placeholder.getBox(false, true)), floatCls = Ext.panel.Panel.floatCls, collapsed = me.collapsed, layoutOwner = me.ownerCt || me, slideDirection, myBox, hoverlisteners = { mouseleave: me.onMouseLeaveFloated, mouseenter: me.onMouseEnterFloated, scope: me, destroyable: true }; if (me.isSliding) { return; } // Already floated if (me.el.hasCls(floatCls)) { me.slideOutFloatedPanel(); return; } me.isSliding = true; // Lay out in fully expanded mode to ensure we are at the correct size, // and collect our expanded box placeholder.el.hide(); placeholder.hidden = true; me.el.show(); me.setHiddenState(false); me.collapsed = false; layoutOwner.updateLayout(); // Then go back immediately to collapsed state from which to initiate the float into view. placeholder.el.show(); placeholder.hidden = false; me.el.hide(); me.setHiddenState(true); me.collapsed = collapsed; layoutOwner.updateLayout(); myBox = me.getBox(false, true); if (me.fireEvent('beginfloat', me) === false) { return; } me.slideOutTask = me.slideOutTask || new Ext.util.DelayedTask(me.slideOutFloatedPanel, me); // Tap/mousedown/mousemove outside the floated element, its placeholder, // or its splitter slides it back. me.pointerLeaveListener = Ext.getDoc().on({ mousedown: me.onFloatedPointerEvent, mousemove: me.onFloatedPointerEvent, scope: me, destroyable: true }); if (!me.placeholderListener) { me.placeholderListener = placeholder.on({ resize: me.onPlaceholderResize, scope: me, destroyable: true }); } me.phHoverListeners = placeholder.el.on(hoverlisteners); me.elHoverListeners = me.el.on(hoverlisteners); me.el.addCls(floatCls); me.floated = collapsed; // Hide collapse tool in header if there is one (we might be headerless) if (me.collapseTool) { me.collapseTool.el.hide(); } if (splitter) { phBox = phBox.union(splitter.getBox(false, true)); } switch (me.collapsed) { case 'top': me.width = phBox.width; me.setLocalXY(myBox.x, myBox.y + phBox.height); break; case 'right': me.height = phBox.height; me.setLocalXY(myBox.x - phBox.width, myBox.y); break; case 'bottom': me.width = phBox.width; me.setLocalXY(myBox.x, myBox.y - phBox.height); break; case 'left': me.height = phBox.height; me.setLocalXY(myBox.x + phBox.width, myBox.y); break; } slideDirection = me.convertCollapseDir(me.collapsed); // Remember how we are really collapsed so we can restore it, but also so we can // become a layoutRoot while we are floated: me.floatedFromCollapse = me.collapsed; me.collapsed = false; me.setHiddenState(false); me.el.slideIn(slideDirection, { preserveScroll: true, duration: Ext.Number.from(me.animCollapse, Ext.fx.Anim.prototype.duration), listeners: { afteranimate: function() { me.isSliding = false; me.fireEvent('endfloat', me); me.fireEvent('float', me); } } }); }, onFloatedPointerEvent: function(event) { var me = this; // If any pointer event occurs inside the component tree, cancel any slideOut. // This includes if we are slid out and the pointer is inside the region // because locked grids have pointer-events: none to allow interaction with // the Y scroller below them. if (me.owns(event) || me.placeholder.owns(event) || (me.splitter && me.splitter.owns(event)) || (me.floatCollapsedPanel && me.el.getRegion().contains(event.getPoint()))) { me.slideOutTask.cancel(); } // Mousemove outside, or tap outside, schedule a slideOut unless they change their minds and // tap/mousemove back inside within 500ms else { me.slideOutTask.delay(500); } }, onMouseEnterFloated: function(e) { this.slideOutTask.cancel(); }, onMouseLeaveFloated: function(e) { var toElement = e.getRelatedTarget(); // If the toElement is in the component tree, do not collapse if (toElement && (this.owns(toElement) || this.placeholder.owns(toElement))) { return; } this.slideOutTask.delay(500); }, onPlaceholderResize: function(ph, newWidth, newHeight) { var me = this, splitter = me.splitter, myBox = me.getBox(false, true), phBox = Ext.util.Region.from(ph.getBox(false, true)); if (splitter) { phBox = phBox.union(splitter.getBox(false, true)); } // Position floated panel alongside the placeholder, and sync the parallel dimension switch (me.floated) { case 'top': me.width = newWidth; me.setLocalY(phBox.y + phBox.height); break; case 'right': me.height = newHeight; me.setLocalX(phBox.x - myBox.width); break; case 'bottom': me.width = newWidth; me.setLocalY(phBox.y - myBox.height); break; case 'left': me.height = newHeight; me.setLocalX(phBox.x + phBox.width); break; } me.updateLayout({ isRoot: true }); }, getAnimationProps: function() { var me = this, props; props = me.callParent(); if (typeof me.animCollapseDuration === 'number') { props.duration = me.animCollapseDuration; } else if (typeof me.animCollapse === 'number') { props.duration = me.animCollapse; } return props; }, /** * Returns the current collapsed state of the panel. * @return {Boolean/String} False when not collapsed, otherwise the value of * {@link #collapseDirection}. */ getCollapsed: function() { var me = this; // The collapsed flag, when the Panel is collapsed acts as the direction // in which the collapse took place. It can still be tested as truthy/falsy // if only a truth value is required. if (me.collapsed === true) { return me.collapseDirection; } return me.collapsed; }, getCollapsedDockedItems: function() { var me = this; return me.header === false || (me.collapseMode === 'placeholder' ? me.emptyArray : [me.getReExpander()]); }, /** * Attempts a default component lookup (see {@link Ext.container.Container#getComponent}). * If the component is not found in the normal items, the dockedItems are searched * and the matched component (if any) returned (see {@link #getDockedComponent}). * Note that docked items will only be matched by component id or itemId -- if you pass * a numeric index only non-docked child components will be searched. * @param {String/Number} comp The component id, itemId or position to find * @return {Ext.Component} The component (if found) * @since 2.3.0 */ getComponent: function(comp) { var component = this.callParent(arguments); if (component === undefined && !Ext.isNumber(comp)) { // If the arg is a numeric index skip docked items component = this.getDockedComponent(comp); } return component; }, /** * Gets the {@link Ext.panel.Header Header} for this panel. * @return {Ext.panel.Header} */ getHeader: function() { return this.header; }, /** * @private * Create the class array to add to the Header when collapsed. */ getHeaderCollapsedClasses: function(header) { var me = this, collapsedCls = me.collapsedCls, collapsedClasses; collapsedClasses = [ collapsedCls, collapsedCls + '-' + header.getDockName()]; if (me.border && (!me.frame || (me.frame && Ext.supports.CSS3BorderRadius))) { collapsedClasses.push(collapsedCls + '-border-' + header.getDockName()); } return collapsedClasses; }, getOppositeDirection: function(d) { var c = Ext.Component; switch (d) { case c.DIRECTION_TOP: return c.DIRECTION_BOTTOM; case c.DIRECTION_RIGHT: return c.DIRECTION_LEFT; case c.DIRECTION_BOTTOM: return c.DIRECTION_TOP; case c.DIRECTION_LEFT: return c.DIRECTION_RIGHT; } }, getPlaceholder: function(direction) { var me = this, collapseDir = direction || me.collapseDirection, listeners = null, placeholder = me.placeholder, floatable = me.floatable, titleCollapse = me.titleCollapse; if (!placeholder) { if (floatable || (me.collapsible && titleCollapse)) { listeners = { click: { // titleCollapse needs to take precedence over floatable fn: function(e, target) { var expandTool = placeholder.expandTool; // If the element click was specifically on the tool, // that tool's handler will process it and we must not: // https://sencha.jira.com/browse/EXTJS-21045 if (!(expandTool && expandTool.el.dom.contains(arguments[1]))) { // eslint-disable-next-line max-len me[(!titleCollapse && floatable) ? 'floatCollapsedPanel' : 'toggleCollapse'](); } }, element: 'el', scope: me } }; } me.placeholder = placeholder = Ext.widget(me.createReExpander(collapseDir, { id: me.id + '-placeholder', listeners: listeners })); } // User created placeholder was passed in if (!placeholder.placeholderFor) { // Handle the case of a placeholder config if (!placeholder.isComponent) { me.placeholder = placeholder = me.lookupComponent(placeholder); } Ext.applyIf(placeholder, { margin: me.margin, placeholderFor: me, synthetic: true // not user-defined }); placeholder.addCls([ Ext.baseCSSPrefix + 'region-collapsed-placeholder', Ext.baseCSSPrefix + 'region-collapsed-' + collapseDir + '-placeholder', me.collapsedCls ]); } return placeholder; }, getProtoBody: function() { var me = this, body = me.protoBody; if (!body) { me.protoBody = body = new Ext.util.ProtoElement({ cls: me.bodyCls, style: me.bodyStyle, clsProp: 'bodyCls', styleProp: 'bodyStyle', styleIsText: true }); } return body; }, getReExpander: function(direction) { var me = this, collapseDir = direction || me.collapseDirection, reExpander = me.reExpander || me.findReExpander(collapseDir), titleCollapse = me.titleCollapse, listeners = null; me.expandDirection = me.getOppositeDirection(collapseDir); if (!reExpander) { if (titleCollapse) { listeners = { click: { fn: me.toggleCollapse, element: 'el', scope: me } }; } // We did not find a Header of the required orientation: create one. me.reExpander = reExpander = me.createReExpander(collapseDir, { dock: collapseDir, cls: Ext.baseCSSPrefix + 'docked ' + me.baseCls + '-' + me.ui + '-collapsed', isCollapsedExpander: true, listeners: listeners }); me.dockedItems.insert(0, reExpander); } return reExpander; }, getRefItems: function(deep) { var placeholder = this.placeholder, result; // Collapsed placeholder must be queryable if it is a Container. // The placeholder can be objects/ Ext.Component and thus check // is required before it is further processed as a component if (placeholder && placeholder.isComponent) { result = [placeholder]; if (deep && placeholder.getRefItems) { result.push.apply(result, placeholder.getRefItems(deep)); } } else { result = []; } // And the rest. result.push.apply(result, this.getDockingRefItems(deep, this.callParent([deep]))); return result; }, getState: function() { var me = this, state = me.callParent() || {}, collapsed = me.collapsed, floated = me.floated, memento, placeholder; // When taking state to restore on a page refresh, floated means collapsed if (floated) { me.collapsed = floated; } state = me.addPropertyToState(state, 'collapsed'); if (floated) { me.collapsed = collapsed; } // If a collapse has taken place, use remembered values as the dimensions. if (me.getCollapsed()) { memento = me.getMemento('collapse').data; state = me.addPropertyToState(state, 'collapsed', memento); placeholder = me.isPlaceHolderCollapse(); if (me.collapsedVertical()) { if (placeholder) { state = me.addPropertyToState(state, 'height'); delete state.width; } else { delete state.height; if (memento) { state = me.addPropertyToState(state, 'height', memento.height); } } } else { if (placeholder) { state = me.addPropertyToState(state, 'width'); delete state.height; } else { delete state.width; if (memento) { state = me.addPropertyToState(state, 'width', memento.width); } } } } return state; }, applyState: function(state) { var me = this, collapseMemento = {}, collapsed; if (state) { collapsed = state.collapsed; if (collapsed) { collapseMemento = me.getMemento('collapse'); Ext.Object.merge(collapseMemento.data, collapsed); state.collapsed = true; } me.callParent([state]); } }, /** * @private * Used for dragging. */ ghost: function(cls) { var me = this, myEl = me.el, ghostPanel = me.ghostPanel, box = me.getBox(), header = me.header, ghostHeader, tools, icon, iconCls, glyph, i; Ext.suspendLayouts(); if (!ghostPanel) { me.ghostPanel = ghostPanel = Ext.widget(me.createGhost(cls)); ghostPanel.el.dom.removeAttribute('tabIndex'); } else { ghostPanel.el.show(); } // Important to do this before the setSize call otherwise it won't // stamp the sizes onto the element. ghostPanel.setHiddenState(false); ghostPanel.setXY([box.x, box.y]); ghostPanel.setSize(box.width, box.height); ghostPanel.floatParent = me.floatParent; // Only churn ghost's header if our header has changed composition if (header && !me.preventHeader && me.lastHeaderGen !== header.items.generation) { ghostHeader = ghostPanel.header; // restore options tools = ghostHeader.query('tool'); for (i = tools.length; i--;) { ghostHeader.remove(tools[i]); } // reset the title position to ensure that the title gets moved into the correct // place after we add the tools (if the position didn't change the updater won't run) ghostHeader.setTitlePosition(0); ghostPanel.addTool(me.ghostTools()); ghostPanel.setTitle(me.getTitle()); ghostHeader.setTitlePosition(header.getTitlePosition()); ghostHeader.setIconAlign(header.getIconAlign()); ghostHeader.setTitleAlign(header.getTitleAlign()); iconCls = me.getIconCls(); if (iconCls) { ghostPanel.setIconCls(iconCls); } else { icon = me.getIcon(); if (icon) { ghostPanel.setIcon(icon); } else { glyph = me.getGlyph(); if (glyph) { ghostPanel.setGlyph(glyph); } } } ghostHeader.addCls(Ext.baseCSSPrefix + 'header-ghost'); me.lastHeaderGen = header.items.generation; } Ext.resumeLayouts(true); // Hide element, but do not disturb focus or clobber accessibility me.elVisMode = myEl.getVisibilityMode(); myEl.setVisibilityMode(Ext.Element.CLIP); myEl.hide(); return ghostPanel; }, /** * @private * Helper function for ghost */ ghostTools: function() { var tools = [], header = this.header, headerTools = header ? header.query('tool[hidden=false]') : [], t, tLen, tool; if (headerTools.length) { t = 0; tLen = headerTools.length; for (; t < tLen; t++) { tool = headerTools[t]; // Some tools can be full components, and copying them into the ghost // actually removes them from the owning panel. You could also potentially // end up with duplicate DOM ids as well. To avoid any issues we just make // a simple bare-minimum clone of each tool for ghosting purposes. tools.push({ type: tool.type, focusable: false }); } } else { tools = [{ type: 'placeholder' }]; } return tools; }, initBodyBorder: function() { var me = this; if (me.frame && me.bodyBorder) { if (!Ext.isNumber(me.bodyBorder)) { me.bodyBorder = 1; } me.getProtoBody().setStyle('border-width', this.unitizeBox(me.bodyBorder)); } }, /** * Parses the {@link #bodyStyle} config if available to create a style string * that will be applied to the body element. * This also includes {@link #bodyPadding} and {@link #bodyBorder} if available. * @return {String} A CSS style string with body styles, padding and border. * @private */ initBodyStyles: function() { var me = this, body = me.getProtoBody(); if (me.bodyPadding !== undefined) { if (me.layout.managePadding) { // If the container layout manages padding, the layout will apply the // padding to an inner element rather than the body element. The // assumed intent is for the configured padding to override any padding // that is applied to the body element via style sheet rules. It is // therefore necessary to set the body element's padding to "0". body.setStyle('padding', 0); } else { body.setStyle( 'padding', this.unitizeBox((me.bodyPadding === true) ? 5 : me.bodyPadding) ); } } me.initBodyBorder(); }, initBorderProps: function() { var me = this; if (me.frame && me.border && me.bodyBorder === undefined) { me.bodyBorder = false; } if (me.frame && me.border && (me.bodyBorder === false || me.bodyBorder === 0)) { me.manageBodyBorders = true; } }, initComponent: function() { var me = this; if (me.collapsible) { // Save state on these two events. me.addStateEvents(['expand', 'collapse']); } if (me.unstyled) { me.setUI('plain'); } if (me.frame) { me.setUI(me.ui + '-framed'); } // Backwards compatibility me.bridgeToolbars(); me.initBorderProps(); me.callParent(); me.collapseDirection = me.collapseDirection || me.getHeaderPosition() || Ext.Component.DIRECTION_TOP; // Certain layouts will reset animCollapse to false but we'd like to preserve // the duration to use with animations, if it was configured if (typeof me.animCollapse === 'number') { me.animCollapseDuration = me.animCollapse; } // Used to track hidden content elements during collapsed state me.hiddenOnCollapse = new Ext.dom.CompositeElement(); }, initItems: function() { this.callParent(); this.initDockingItems(); }, /** * Initialized the renderData to be used when rendering the renderTpl. * @return {Object} Object with keys and values that are going to be applied to the renderTpl * @private */ initRenderData: function() { var me = this, bodyWrapRole = me.bodyWrapAriaRole, bodyRole = me.bodyAriaRole, data; data = me.callParent(); me.initBodyStyles(); me.protoBody.writeTo(data); delete me.protoBody; if (me.headingText) { data.headingText = me.headingText; me.addChildEl('headingEl'); } if (bodyWrapRole) { data.bodyWrapAriaAttributes = { role: bodyWrapRole }; if (!me.ariaStaticRoles[bodyWrapRole] && me.bodyWrapAriaRenderAttributes) { Ext.apply(data.bodyWrapAriaAttributes, me.bodyWrapAriaRenderAttributes); } } if (bodyRole) { data.bodyAriaAttributes = { role: bodyRole }; if (!me.ariaStaticRoles[bodyRole] && me.bodyAriaRenderAttributes) { Ext.apply(data.bodyAriaAttributes, me.bodyAriaRenderAttributes); } } return data; }, /** * @private * Override of Positionable method to calculate constrained position based upon possibly only * constraining our header. */ calculateConstrainedPosition: function(constrainTo, proposedPosition, local, proposedSize) { var me = this, header = me.header, lastBox, fp; // If we are only constraining the header, ask the header for its constrained position // based upon the size the header will take on based upon this panel's proposedSize if (me.constrainHeader) { lastBox = header.lastBox; if (proposedSize) { if (!header.vertical) { proposedSize = [proposedSize[0], lastBox ? lastBox.height : proposedSize[1]]; } else { proposedSize = [lastBox ? lastBox.width : proposedSize[0], proposedSize[1]]; } } else if (lastBox) { proposedSize = [lastBox.width, lastBox.height]; } fp = me.floatParent; constrainTo = constrainTo || me.constrainTo || (fp ? fp.getTargetEl() : null) || me.container || me.el.parent(); } return me.callParent([constrainTo, proposedPosition, local, proposedSize]); }, /** * @private * Tools are a Panel-specific capability. * Panel uses initTools. Subclasses may contribute tools by implementing addTools. */ initTools: function() { var me = this, tools = me.tools, len = tools && tools.length, i, toolCfg, tool; me.tools = []; if (len) { for (i = 0; i < len; ++i) { tool = tools[i]; if (typeof tool !== 'string' && !tool.isTool) { tool = Ext.apply({}, tool); } me.tools.push(tool); tool.toolOwner = me; } } // Add a collapse tool unless configured to not show a collapse tool // or to not even show a header. if (me.collapsible && !(me.hideCollapseTool || me.header === false || me.preventHeader)) { me.updateCollapseTool(); // Prepend collapse tool is configured to do so. if (me.collapseFirst) { me.tools.unshift(me.collapseTool); } } // Add subclass-specific tools. me.addTools(); if (me.pinnable) { me.initPinnable(); } // Make Panel closable. if (me.closable) { me.addClsWithUI('closable'); toolCfg = { xtype: 'tool', type: 'close', scope: me, handler: me.close, tooltip: me.closeToolText }; // Same as with the collapse/expand tool, we have a way to close // the panel via keyboard by pressing Alt-Del key when panel's // title is focused; hence we do not need to have the close tool // in the tab order. We still need to have the tool itself for // pointer interaction and presentational purposes. // This configuration will make sure the tool is working as it was // in Ext JS older than 6.0. if (me.isAccordionPanel || me.disableCloseToolFocus) { toolCfg.focusable = false; toolCfg.ariaRole = 'presentation'; } me.addTool(toolCfg); } // Append collapse tool if needed. if (me.collapseTool && !me.collapseFirst) { me.addTool(me.collapseTool); } }, isLayoutRoot: function() { if (this.floatedFromCollapse) { return true; } return this.callParent(); }, isPlaceHolderCollapse: function() { return this.collapseMode === 'placeholder'; }, isVisible: function(deep) { var me = this; if (me.collapsed && me.placeholder) { return me.placeholder.isVisible(deep); } return me.callParent(arguments); }, onBoxReady: function() { var me = this, target; me.callParent(arguments); if (me.collapsed) { me.setHiddenDocked(); } if (me.isAccordionPanel) { // ARIA state like expanded/collapsed are reflected // on the panel header's title component. me.ariaEl = me.header.titleCmp.el; me.ariaEl.dom.setAttribute('aria-expanded', !me.collapsed); me.ariaEl.dom.setAttribute('aria-controls', me.body.id); // Body element has the role="tabpanel"; when the panel is collapsed // or expanded we will update ARIA attributes on the body. me.body.dom.setAttribute('aria-labelledby', me.header.titleCmp.id); me.body.dom.setAttribute('aria-hidden', !!me.collapsed); me.accordionHeaderKeyNav = new Ext.util.KeyNav({ target: me.header.titleCmp.el, scope: me, left: me.navigateAccordionHeader, right: me.navigateAccordionHeader, up: me.navigateAccordionHeader, down: me.navigateAccordionHeader, home: me.navigateAccordionHeader, end: me.navigateAccordionHeader, space: me.toggleCollapse, enter: me.toggleCollapse, del: { alt: true, fn: me.maybeClose } }); me.accordionBodyKeyNav = new Ext.util.KeyNav({ target: me.bodyWrap, scope: me, up: { ctrl: true, fn: me.navigateAccordionBody } }); } if (me.defaultButton) { target = me.defaultButtonTarget ? me[me.defaultButtonTarget] : me.body; me.defaultButtonKeyNav = new Ext.util.KeyNav({ target: target, scope: me, defaultEventAction: 'stopEvent', enter: me.fireDefaultButton }); } }, onHide: function(animateTarget, cb, scope) { var me = this, dd = me.dd; // If floated out from collapse, hide the el immediately. // We continue with the hide from a collapsed state. if (me.floatedFromCollapse) { me.slideOutFloatedPanel(true); } if (me.draggable && dd) { // Panels w/o headers won't have a Component Dragger. dd.endDrag(); } if (me.collapsed && me.placeholder) { if (me.splitter) { Ext.suspendLayouts(); me.splitter.hide(); Ext.resumeLayouts(); } me.placeholder.hide(); } else { me.callParent([animateTarget, cb, scope]); } }, /** * @method onRemoved * @inheritdoc */ onRemoved: function(destroying) { var me = this; // If we are removed but not being destroyed, ensure our placeholder is also removed // but not destroyed // If we are being destroyed, our destroy processing will destroy the placeholder. // Must run before callParent because that breaks the ownerCt link if (me.placeholder && !destroying) { me.ownerCt.remove(me.placeholder, false); } me.callParent(arguments); }, onShow: function() { var me = this; if (me.collapsed && me.isPlaceHolderCollapse()) { if (me.splitter) { Ext.suspendLayouts(); me.splitter.show(); Ext.resumeLayouts(); } // force hidden back to true, since this gets set by the layout me.setHiddenState(true); me.placeholderCollapse(); } else { me.callParent(arguments); } }, placeholderCollapse: function(direction, animate) { var me = this, ownerCt = me.ownerCt, collapseDir = direction || me.collapseDirection, floatCls = Ext.panel.Panel.floatCls, collapseTool = me.collapseTool, placeholder = me.getPlaceholder(collapseDir), slideInDirection; if (Ext.Component.layoutSuspendCount || me.isLayoutSuspended()) { animate = false; } me.fireEvent('beginfloat', me); me.isCollapsingOrExpanding = 1; // Upcoming layout run will ignore this Component me.setHiddenState(true); me.collapsed = collapseDir; if (placeholder.rendered) { // We may have been added to another Container from that in which we rendered // the placeholder if (placeholder.el.dom.parentNode !== me.el.dom.parentNode) { me.el.dom.parentNode.insertBefore(placeholder.el.dom, me.el.dom); } placeholder.hidden = false; placeholder.setHiddenState(false); placeholder.el.show(); ownerCt.updateLayout(); } else { ownerCt.insert(ownerCt.items.indexOf(me), placeholder); } if (me.rendered) { // The doPlaceholderCollapse callback must not make assumptions about where // to restore focus to. We decide that here. me.focusPlaceholderExpandTool = me.focusPlaceHolder = false; // We assume that if collapse was caused by keyboard action // on focused collapse tool, the logical focus transition // is to placeholder's expand tool. Note that it may not be // the case when the user *clicked* collapse tool while focus // was elsewhere; in that case we dare not touch focus // to avoid sudden jumps. if (collapseTool && Ext.ComponentManager.getActiveComponent() === collapseTool) { me.focusPlaceholderExpandTool = true; } // If the focus was otherwise owned by us, just focus the placeholder else if (me.containsFocus) { me.focusPlaceHolder = true; } // We MUST NOT hide using display because that resets all scroll information. me.el.setVisibilityMode(me.placeholderCollapseHideMode); if (animate) { me.el.addCls(floatCls); placeholder.el.hide(); slideInDirection = me.convertCollapseDir(collapseDir); me.el.slideOut(slideInDirection, { preserveScroll: true, duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration), listeners: { scope: me, afteranimate: function() { var me = this, placeholderEl = me.placeholder.el; me.el.removeCls(floatCls); /* We need to show the element so that slideIn will work correctly. * However, if we leave it visible then it can be seen before * the animation starts, causing a flicker. The solution, * borrowed from date picker, is to hide it using display:none. * The slideIn effect includes a call to fixDisplay() that will * undo the display none at the appropriate time. * * Also note that presently there is no way to abort slideIn * animation sequence so this callback will be fired even if * the panel was removed while collapsing. * In that case we must not set "display: none" on the placeholder * because fixDisplay() will not reset it and that will break * subsequent layouts if the panel is re-added back to the owner * container again. */ placeholderEl.show(); if (me.ownerCt) { placeholderEl.setStyle('display', 'none'); placeholderEl.slideIn(slideInDirection, { easing: 'linear', duration: 100, listeners: { afteranimate: me.doPlaceholderCollapse, scope: me } }); } else { me.doPlaceholderCollapse(); } } } }); } else { me.el.hide(); me.doPlaceholderCollapse(); } } else { me.isCollapsingOrExpanding = 0; if (!me.preventCollapseFire) { me.fireEvent('collapse', me); } } return me; }, doPlaceholderCollapse: function() { var me = this, placeholder = me.placeholder, expandTool = placeholder.expandTool, dom; // See the comment in placeholderCollapse(). if (me.focusPlaceholderExpandTool && expandTool) { expandTool.focus(); } // However when focus was *not* on the collapse tool, // and we contained focus, we still need to try and // focus the placeholder itself since it may have been // configured with something focusable inside, and delegate focus handling. else if (me.focusPlaceHolder) { placeholder.focus(); } me.focusPlaceholderExpandTool = false; placeholder.setHiddenState(false); // Both panel *and* placeholder are collapsed, // but only panel is hidden. Calling setHiddenState() // above does not reset aria-hidden attribute. if (placeholder.rendered) { dom = placeholder.ariaEl.dom; dom.setAttribute('aria-hidden', false); dom.setAttribute('aria-expanded', false); } dom = me.ariaEl.dom; dom.setAttribute('aria-hidden', true); dom.setAttribute('aria-expanded', false); me.isCollapsingOrExpanding = 0; me.fireEvent('collapse', me); me.fireEvent('endfloat', me); }, placeholderExpand: function(animate) { var me = this, collapseDir = me.collapsed, expandTool = me.placeholder.expandTool, floatCls = Ext.panel.Panel.floatCls, center = me.ownerLayout ? me.ownerLayout.centerRegion : null, finalPos, floatedPos; // Layouts suspended - don't bother with animation shenanigans if (Ext.Component.layoutSuspendCount) { animate = false; } if (me.floatedFromCollapse) { floatedPos = me.getPosition(true); // these are the same cleanups performed by the normal slideOut mechanism: me.slideOutFloatedPanelBegin(); me.slideOutFloatedPanelEnd(); me.floated = false; } // We assume that if expand was caused by keyboard action on focused // placeholder expand tool, the logical focus transition is to the // panel header's collapse tool. // Note that it may not be the case when the user *clicked* expand tool // while focus was elsewhere; in that case we dare not touch focus to avoid // sudden jumps. if (expandTool && Ext.ComponentManager.getActiveComponent() === expandTool) { me.focusHeaderCollapseTool = true; // There is an odd issue with JAWS screen reader: when expanding a panel, // it will announce Expand tool again before focus is forced to Collapse // tool. I'm not sure why that happens since focus does not move from // Expand tool during animation; this hack should work around // the problem until we come up with more understanding and a proper // solution. The attributes are restored below in doPlaceholderExpand. expandTool._ariaRole = expandTool.ariaEl.dom.getAttribute('role'); expandTool._ariaLabel = expandTool.ariaEl.dom.getAttribute('aria-label'); expandTool.ariaEl.dom.setAttribute('role', 'presentation'); expandTool.ariaEl.dom.removeAttribute('aria-label'); } if (animate) { // Expand me and hide the placeholder Ext.suspendLayouts(); me.placeholder.hide(); me.el.show(); me.collapsed = false; me.setHiddenState(false); // Stop the center region from moving when laid out without the placeholder there. // Unless we are expanding from a floated out situation. In that case, // it's laid out immediately. if (center && !floatedPos) { center.hidden = true; } Ext.resumeLayouts(true); if (center) { center.hidden = false; } if (!me.floatedFromCollapse) { me.fireEvent('beginfloat', me); } me.el.addCls(floatCls); // At this point, this Panel is arranged in its correct, expanded layout. // The center region has not been affected because it has been flagged as hidden. // // If we are proceeding from floated, the center region has also been arranged // in its new layout to accommodate this expansion, so no further layout is needed, just // element animation. // // If we are proceeding from fully collapsed, the center region has *not* been relayed // out because the UI look and feel dictates that it stays stable until the expanding // panel has slid in all the way, and *then* it snaps into place. me.isCollapsingOrExpanding = 2; // Floated, move it back to the floated pos, and thence into the correct place if (floatedPos) { finalPos = me.getXY(); me.setLocalXY(floatedPos[0], floatedPos[1]); me.setXY([finalPos[0], finalPos[1]], { duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration), listeners: { scope: me, afteranimate: function() { var me = this; me.el.removeCls(floatCls); me.isCollapsingOrExpanding = 0; me.fireEvent('expand', me); me.fireEvent('endfloat', me); } } }); } // Not floated, slide it in to the correct place else { me.el.hide(); me.placeholder.el.show(); me.placeholder.hidden = false; // Slide this Component's el back into place, after which we lay out AGAIN me.setHiddenState(false); me.el.slideIn(me.convertCollapseDir(collapseDir), { preserveScroll: true, duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration), listeners: { afteranimate: me.doPlaceholderExpand, scope: me } }); } } else { me.floated = me.collapsed = false; me.doPlaceholderExpand(true); } return me; }, doPlaceholderExpand: function(nonAnimated) { var me = this, placeholder = me.placeholder, collapseTool = me.collapseTool, expandTool = placeholder.expandTool; nonAnimated = nonAnimated === true; if (nonAnimated) { Ext.suspendLayouts(); me.show(); } // the ordering of these two lines appears to be important in // IE9. There is an odd expand issue in IE 9 in the border layout // example that causes the index1 child of the south dock region // to get 'hidden' after a collapse / expand cycle. See // EXTJSIV-5318 for details me.el.removeCls(Ext.panel.Panel.floatCls); placeholder.hide(); if (nonAnimated) { Ext.resumeLayouts(true); } else { // The center region has been left in its larger size, so a layout is needed now me.updateLayout(); } // This part is quite tricky in both animated and non-animated sequence. // After the panel is collapsed we will show the placeholder, // but by that time we had already lost the previous focus state. // The subsequent onFocusEnter on the placeholder will thusly reset // placeholder's previousFocus property to null; so when we hide // the placeholder after expanding the panel again, it can't throw focus // back to the panel header by iself. // This is why we nudge it a little here; the assumption is that // if panel expansion has been caused by keyboard action // on focused placeholder expand tool, then the logical focus transition // is to panel header's collapse tool. if (me.focusHeaderCollapseTool && collapseTool) { collapseTool.focus(); } me.focusHeaderCollapseTool = false; placeholder.ariaEl.dom.setAttribute('aria-expanded', true); me.ariaEl.dom.setAttribute('aria-expanded', true); if (expandTool && expandTool._ariaRole) { expandTool.ariaEl.dom.setAttribute('role', expandTool._ariaRole); expandTool.ariaEl.dom.setAttribute('aria-label', expandTool._ariaLabel); expandTool._ariaRole = expandTool._ariaLabel = null; } me.isCollapsingOrExpanding = 0; me.fireEvent('expand', me); me.fireEvent('endfloat', me); }, remove: function(component, autoDestroy) { var dockedItems = this.dockedItems; // When the panel is destroyed, dockedItems is nulled if (dockedItems && dockedItems.contains(component)) { this.removeDocked(component, autoDestroy); } else { this.callParent([component, autoDestroy]); } return component; }, /** * Removes a CSS class from the body element. * @param {String/String[]} cls The class to remove * @return {Ext.panel.Panel} this */ removeBodyCls: function(cls) { var me = this, body = me.rendered ? me.body : me.getProtoBody(); body.removeCls(cls); return me; }, removeUIClsFromElement: function(cls) { var me = this, result = me.callParent(arguments); me.removeBodyCls([ Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls ]); return result; }, restoreDimension: function() { var dir = this.collapseDirection; // If we're collapsing top/bottom, we want to restore the height // If we're collapsing left/right, we want to restore the width return (dir === 'top' || dir === 'bottom') ? 'height' : 'width'; }, restoreHiddenDocked: function() { // Re-show Panel content which was hidden after collapse. this.setDockedItemsVisibility(this.hiddenOnCollapse, true); }, /** * Sets the body style according to the passed parameters. * @param {Mixed} style A full style specification string, or object, or the name of a style * property to set. * @param {String} value If the first param was a style property name, the style property value. * @return {Ext.panel.Panel} this */ setBodyStyle: function(style, value) { var me = this, body = me.rendered ? me.body : me.getProtoBody(); if (Ext.isFunction(style)) { style = style(); } if (arguments.length === 1) { if (Ext.isString(style)) { style = Ext.Element.parseStyles(style); } body.setStyle(style); } else { body.setStyle(style, value); } return me; }, /** * @method setBorder * @inheritdoc */ setBorder: function(border, targetEl) { if (targetEl) { // skip out here, the panel will set the border on the body/header during rendering return; } // eslint-disable-next-line vars-on-top var me = this, header = me.header; if (!border) { border = 0; } else if (border === true) { border = '1px'; } else { border = me.unitizeBox(border); } if (header) { if (header.isHeader) { header.setBorder(border); } else { header.border = border; } } if (me.rendered && me.bodyBorder !== false) { me.body.setStyle('border-width', border); } me.updateLayout(); me.border = border; }, /** * Collapses or expands the panel. * @param {Boolean} collapsed `true` to collapse the panel, `false` to expand it. */ setCollapsed: function(collapsed) { this[collapsed ? 'collapse' : 'expand'](); }, /** * Set visibility of docked items after the panel is collapsed or expanded * * @param {Ext.dom.CompositeElement} els * @param {Boolean} show * * @private */ setDockedItemsVisibility: function(els, show) { var me = this, items = me.getDockedItems(), len = items.length, i = 0, item, reExpander; if (me.header !== false) { reExpander = me.getReExpander(); } for (; i < len; i++) { item = items[i]; if (item && item !== reExpander && item.el) { els.add(item.el); } } els.setStyle('visibility', show ? '' : 'hidden'); els.clear(); }, setGlyph: function(glyph) { this.setHeaderConfig(glyph, 'glyph', 'setGlyph', true); }, setIcon: function(icon) { this.setHeaderConfig(icon, 'icon', 'setIcon', true); }, setIconCls: function(iconCls) { this.setHeaderConfig(iconCls, 'iconCls', 'setIconCls', true); }, setIconAlign: function(iconAlign) { this.setHeaderConfig(iconAlign, 'iconAlign', 'setIconAlign', true); }, setTitleAlign: function(titleAlign) { this.setHeaderConfig(titleAlign, 'titleAlign', 'setTitleAlign', true); }, setTitlePosition: function(titlePosition) { this.setHeaderConfig(titlePosition, 'titlePosition', 'setTitlePosition', true); }, setTitleRotation: function(titleRotation) { this.setHeaderConfig(titleRotation, 'titleRotation', 'setTitleRotation', true); }, /** * Sets the title of this panel. * @param {String} title The new title */ setTitle: function(title) { var me = this, oldTitle = me.title; if (title !== oldTitle && me.headingEl) { me.headingEl.setHtml(title); } this.setHeaderConfig(title, 'title', 'setTitle', false); }, setHeaderConfig: function(value, prop, setter, addToHeaderCfg) { var me = this, oldValue = me[prop], header = me.header, placeholder = me.placeholder, reExpander = me.reExpander, eventName; if (value !== oldValue) { me[prop] = value; if (header) { if (header.isHeader) { header[setter](value); } else if (addToHeaderCfg) { header[prop] = value; } } else if (me.rendered || me.afterHeaderInit) { me.updateHeader(); } if (reExpander) { reExpander[setter](value); } if (placeholder && placeholder[setter]) { placeholder[setter](value); } eventName = prop.toLowerCase() + 'change'; if (me.hasListeners[eventName]) { me.fireEvent(eventName, me, value, oldValue); } } }, setHiddenDocked: function() { // Hide Panel content except reExpander using visibility to prevent focusing of contained // elements. // Track what we hide to re-show on expand except for docked items // Until the panel is expanded the docked items might have been removed var me = this, toHide = new Ext.dom.CompositeElement(); me.hiddenOnCollapse.add(me.body); toHide.add(me.body); me.setDockedItemsVisibility(toHide, false); }, /** * @method setUI * @inheritdoc */ setUI: function(ui) { var me = this; me.callParent(arguments); if (me.header && me.header.rendered) { me.header.setUI(ui); } }, /** * Shortcut for performing an {@link #method-expand} or {@link #method-collapse} based * on the current state of the panel. * @return {Ext.panel.Panel} this */ toggleCollapse: function() { return (this.collapsed || this.floatedFromCollapse) ? this.expand() : this.collapse(); }, updateCollapseTool: function() { var me = this, collapseTool = me.collapseTool, toolCfg; if (!collapseTool && me.collapsible) { me.collapseDirection = me.collapseDirection || me.getHeaderPosition() || 'top'; toolCfg = { xtype: 'tool', handler: me.toggleCollapse, scope: me }; // In accordion layout panels are collapsible/expandable with keyboard // via the panel title that is focusable. There is no need to have a separate // collapse/expand tool for keyboard interaction but we still have to react // to mouse clicks, and historically accordion panels had coolapse tools // so we leave the tool but make it unfocusable and keyboard inactive. // Note that we do the same thing for the automatically added close tool // but NOT for the other tools. if (me.isAccordionPanel) { toolCfg.focusable = false; toolCfg.ariaRole = 'presentation'; } me.collapseTool = me.expandTool = collapseTool = Ext.widget(toolCfg); } if (collapseTool) { if (me.collapsed && !me.isPlaceHolderCollapse()) { collapseTool.setType('expand-' + me.getOppositeDirection(me.collapseDirection)); collapseTool.setTooltip(me.expandToolText); } else { collapseTool.setType('collapse-' + me.collapseDirection); collapseTool.setTooltip(me.collapseToolText); } } }, navigateAccordionHeader: function(e) { var me = this, key, target; key = e.getKey(); switch (key) { case e.UP: case e.LEFT: target = me.findAccordionSibling('prev'); break; case e.DOWN: case e.RIGHT: target = me.findAccordionSibling('next'); break; case e.HOME: target = me.findAccordionSibling('first'); break; case e.END: target = me.findAccordionSibling('last'); break; // Before closing the panel we need to fall back to the previous one, // or to the next one if there is no previous one in the list. // Jumping to the first panel header does not seem logical. case e.DELETE: target = me.findAccordionSibling('prev') || me.findAccordionSibling('next'); // We also need to prevent the panel from closing if it's the only one // panel left in the accordion layout. if (!target) { e.doNotClose = true; } break; } // We need to stop the event in to prevent scrolling the parent container. e.stopEvent(); if (target && target !== me) { target.header.titleCmp.focus(); } }, navigateAccordionBody: function(e) { var target; if (e.getKey() === e.UP) { // Ctrl-Up within the panel body should focus the header element target = this; } // These events are very particular; if they bubbled up to the panel body // it means they were not consumed at the origin components. e.stopEvent(); if (target) { target.header.titleCmp.focus(); } }, findAccordionSibling: function(which, forceFind) { var me = this, siblingSel = '[isAccordionPanel]', sibling; switch (which) { case 'prev': sibling = me.prev(siblingSel); if (!sibling) { if (me.accordionWrapOver) { sibling = me.ownerCt.child(siblingSel + ':last'); } else if (forceFind) { sibling = me; } } break; case 'next': sibling = me.next(siblingSel); if (!sibling) { if (me.accordionWrapOver) { sibling = me.ownerCt.child(siblingSel + ':first'); } else if (forceFind) { sibling = me; } } break; case 'first': sibling = me.ownerCt.child(siblingSel + ':first'); break; case 'last': sibling = me.ownerCt.child(siblingSel + ':last'); break; } return sibling; }, fireDefaultButton: function(e) { var me = this, refHolder, btn; if (e.target.tagName === 'TEXTAREA' || e.target.getAttribute('aria-multiline') === 'true') { return true; } refHolder = me.lookupReferenceHolder(/* skipThis = */ false) || me; btn = refHolder.lookupReference(me.defaultButton); // We call it defaultButton but it can really be any object // that implements `click` method if (btn && btn.click) { btn.click(e); // Stop event propagation through DOM publisher e.stopEvent(); // ... and in case we have other listeners, // stop the loop in Ext.util.Event too return false; } //<debug> else if (!btn) { Ext.raise({ msg: 'No component found for defaultButton reference "' + me.defaultButton + '" in ' + me.xtype + ' ' + me.id, panel: me }); } else { Ext.raise({ msg: 'Component referenced by defaultButton config "' + me.defaultButton + '" in ' + me.xtype + ' ' + me.id + ' does not have click() method', component: btn }); } //</debug> }, maybeClose: function(e) { var me = this; if (me.closable) { me.navigateAccordionHeader(e); // Can't close the last panel in accordion if (!e.doNotClose) { me.close(); } } }, canFocus: function(skipVisibility, includeFocusTarget) { // If we are placeholder collapsed, then the placeholder may be focusable. if (this.collapsed) { // eslint-disable-next-line max-len return !!(this.placeholder && this.placeholder.canFocus(skipVisibility, includeFocusTarget)); } return this.mixins.focusable.canFocus.call(this, skipVisibility, includeFocusTarget); }, focus: function() { var me = this, placeholder = me.placeholder; if (me.collapsed && placeholder && placeholder.canFocus()) { placeholder.focus.apply(placeholder, arguments); } else { me.callParent(arguments); } }, onFocusEnter: function(e) { var me = this, ariaDom = me.ariaEl.dom; me.callParent([e]); if (me.isAccordionPanel && ariaDom) { ariaDom.setAttribute('aria-selected', true); } }, onFocusLeave: function(e) { var me = this, ariaDom = me.ariaEl.dom; me.callParent([e]); if (me.isAccordionPanel && ariaDom) { ariaDom.setAttribute('aria-selected', 'false'); } }, updateHeaderPosition: function(position) { var header = this.header; if (header && header.isHeader) { header.setDock(position); } }, /** * @private */ unghost: function(show, matchPosition, focus) { var me = this, el = me.el, ghostPanel = me.ghostPanel; if (!ghostPanel) { return; } // Show el first to restore the element to the original // visibility mode. el.show(); el.setVisibilityMode(me.elVisMode); if (show !== false) { if (matchPosition !== false) { me.setPagePosition(ghostPanel.getXY()); } } else { el.hide(); } ghostPanel.el.hide(); ghostPanel.setHiddenState(true); }, /** * Create, hide, or show the header component as appropriate based on the current config. * @private * @param {Boolean} force True to force the header to be created */ updateHeader: function(force) { var me = this, header = me.header, title = me.getTitle(), tools = me.tools, icon = me.getIcon(), glyph = me.getGlyph(), iconCls = me.getIconCls(), hasIcon = glyph || icon || iconCls, ariaDom = me.ariaEl.dom, headerPosition = me.getHeaderPosition(), vertical = headerPosition === 'left' || headerPosition === 'right', headingEl, ariaAttr; if (Ext.isObject(header) || (header !== false && (force || (title || hasIcon) || (tools && tools.length) || (me.collapsible && !me.titleCollapse)))) { if (header && header.isHeader) { header.dockToEl = true; header.show(); } else { if (Ext.isObject(header)) { me.syncHeaderConfigs(header); } // Apply the header property to the header config header = me.header = Ext.widget(Ext.merge({ xtype: 'header', title: title, titleAlign: me.getTitleAlign(), titlePosition: me.getTitlePosition(), vertical: vertical, dock: me.getHeaderPosition() || 'top', dockToEl: true, titleRotation: me.getTitleRotation(), textCls: me.headerTextCls, iconCls: iconCls, iconAlign: me.getIconAlign(), icon: icon, glyph: glyph, baseCls: me.baseCls + '-header', tools: tools, ui: me.ui, id: me.id + '_header', overCls: me.headerOverCls, indicateDrag: me.draggable, frame: (me.frame || me.alwaysFramed) && me.frameHeader, ignoreParentFrame: me.frame || me.overlapHeader, ignoreBorderManagement: me.frame || me.ignoreHeaderBorderManagement, isAccordionHeader: me.isAccordionPanel, ownerCt: me, synthetic: true, // not user-defined listeners: me.collapsible && me.titleCollapse ? { click: me.toggleCollapse, scope: me } : null }, me.header)); // Header's onAdd mutates the tools array. // It replaces tool configs at each index with the instantiated tool // It also injects the tool instances as properties keyed by their type. me.addDocked(header, 0); } // Accordion panels are tightly coupled to their headers' titleCmp // via aria-labelledby attribute. There should be no aria-label. if (me.isAccordionPanel) { if (ariaDom) { ariaDom.setAttribute('aria-labelledby', header.id + '-title'); ariaDom.removeAttribute('aria-label'); } else { ariaAttr = me.ariaRenderAttributes || (me.ariaRenderAttributes = {}); ariaAttr['aria-labelledby'] = header.id + '-title'; delete ariaAttr['aria-label']; } } else { if (title) { // If the panel is not an ARIA a region, it still should have // an accessible name via aria-labelledby attribute unless // it is a tabpanel in which case aria-labelledby points // to the corresponding tab and is managed by TabPanel class. if (me.ariaRole !== 'tabpanel') { if (ariaDom) { ariaDom.setAttribute('aria-labelledby', header.id + '-title-textEl'); ariaDom.removeAttribute('aria-label'); } else { ariaAttr = me.ariaRenderAttributes || (me.ariaRenderAttributes = {}); ariaAttr['aria-labelledby'] = header.id + '-title-textEl'; delete ariaAttr['aria-label']; } } } // If there is no title, just make sure no aria-label attribute was added else if (me.ariaRenderAttributes) { delete me.ariaRenderAttributes['aria-label']; } } } else { if (header) { header.hide(); } // Title may contain HTML markup title = Ext.util.Format.stripTags(title); // aria-labelledby could have been set by the TabPanel.onAdd() if (ariaDom) { if (!ariaDom.hasAttribute('aria-labelledby')) { if (title) { ariaDom.setAttribute('aria-label', title); } else { ariaDom.removeAttribute('aria-label'); } } } else { ariaAttr = me.ariaRenderAttributes || (me.ariaRenderAttributes = {}); if (!ariaAttr['aria-labelledby']) { if (title) { ariaAttr['aria-label'] = title; } else { delete ariaAttr['aria-label']; } } } } // If the panel is a child of the Viewport that has border layout, // that automatically makes it a region unless the user overrode that. if (me.isViewportBorderChild && !me.hasOwnProperty('ariaRole')) { me.ariaRole = 'region'; } //<debug> if (me.ariaRole === 'region' && !title) { Ext.ariaWarn( me, "Panel " + me.id + " is a region section of the application, " + "but it does not have a title. Per WAI-ARIA, all regions " + "should have a heading element that contains region's title." ); } //</debug> // An ARIA region should have a title, and a heading which we implement // as an element placed before all other elements within the panel's // main element. The headingEl is hidden via clipping to avoid // visual impact while still allowing it to be published to // Assistive Technologies such as screen readers. if (title && me.ariaRole === 'region') { headingEl = me.headingEl; if (headingEl) { headingEl.setHtml(title); } else { if (me.rendered) { me.headingEl = Ext.dom.Helper.insertFirst(me.el, { tag: 'div', id: me.id + '-headingEl', role: 'heading', 'class': Ext.baseCSSPrefix + 'hidden-clip', style: 'height:0', html: title }, true); ariaDom.removeAttribute('aria-label'); ariaDom.setAttribute('aria-labelledby', me.id + '-headingEl'); } else { me.headingText = me.title; ariaAttr = me.ariaRenderAttributes || (me.ariaRenderAttributes = {}); ariaAttr['aria-labelledby'] = me.id + '-headingEl'; delete ariaAttr['aria-label']; } } } else if (me.headingEl) { me.headingEl.destroy(); me.headingEl = null; } }, // *********************************************************************************** // End Methods // *********************************************************************************** // </editor-fold> statics: { floatCls: Ext.baseCSSPrefix + 'border-region-slide-in' }, privates: { addUIToElement: function() { var me = this; me.callParent(arguments); me.addBodyCls(me.baseCls + '-body-' + me.ui); }, applyTargetCls: function(targetCls) { this.getProtoBody().addCls(targetCls); }, getDefaultContentTarget: function() { return this.body; }, getTargetEl: function() { var me = this; return me.body || me.protoBody || me.frameBody || me.el; }, /** * @private */ initDraggable: function() { var me = this; // For just simple dragging like Windows if (me.simpleDrag) { me.initSimpleDraggable(); } // For DD package aware dragging of Panels else { /** * @property {Ext.dd.DragSource/Ext.util.ComponentDragger} dd * * Only present if this Panel has been configured with {@link #cfg-draggable} * `true`. * * ##Simple dragging## * * If this Panel is configured {@link #cfg-simpleDrag} `true` (the default * is `false`), this property will reference an instance of * {@link Ext.util.ComponentDragger} (A subclass of * {@link Ext.dd.DragTracker DragTracker}) which handles moving the Panel's * DOM Element, and constraining according to the {@link #constrain} and * {@link #constrainHeader} . * * This object fires various events during its lifecycle and during * a drag operation. * * ##Complex dragging interacting with other DragDrop instances## * * By default, this property in a {@link #cfg-draggable} Panel will contain * an instance of {@link Ext.dd.DragSource} which handles dragging the Panel. * * The developer must provide implementations of the abstract methods of * {@link Ext.dd.DragSource} in order to supply behaviour for each stage * of the drag/drop process. * * See also {@link #cfg-draggable}. */ me.dd = new Ext.panel.DD(me, Ext.isBoolean(me.draggable) ? null : me.draggable); } }, initResizable: function(resizable) { this.callParent([resizable]); if (this.collapsed) { this.resizer.disable(); } }, /** * @private * Override Component.initDraggable. * Panel (and subclasses) use the header element as the delegate. */ initSimpleDraggable: function() { var me = this, dd = me.draggable; if (!me.header && !dd.delegate) { me.updateHeader(true); } /* * Check the header here again. If for whatever reason it wasn't created in * updateHeader (we were configured with header: false) then we'll just ignore * the rest since the header acts as the drag handle. */ if (me.header || dd.delegate) { dd = Ext.apply({ el: me.el, delegate: me.header && me.header.el }, dd); // Add extra configs if Window is specified to be constrained if (me.constrain || me.constrainHeader) { dd.constrain = me.constrain; dd.constrainDelegate = me.constrainHeader; dd.constrainTo = me.constrainTo || me.container; } dd = me.dd = new Ext.util.ComponentDragger(me, dd); me.relayEvents(dd, ['dragstart', 'drag', 'dragend']); } }, removeUIFromElement: function() { var me = this; me.callParent(arguments); me.removeBodyCls(me.baseCls + '-body-' + me.ui); }, setupRenderTpl: function(renderTpl) { this.callParent(arguments); this.setupDockingRenderTpl(renderTpl); }, slideOutFloatedPanel: function(preventAnimate) { var me = this, compEl = me.el, collapseDirection, focusTarget, afterSlideOut = function() { me.slideOutFloatedPanelEnd(); // this would be in slideOutFloatedPanelEnd except that the only other // caller removes this cls later me.el.removeCls(Ext.baseCSSPrefix + 'border-region-slide-in'); // Event fired when floated stateus ends me.fireEvent('endfloat', me); }; if (me.isSliding || me.destroyed) { return; } me.isSliding = true; me.floated = false; me.slideOutFloatedPanelBegin(); if (preventAnimate) { compEl.hide(); return afterSlideOut(); } if (typeof me.collapsed === 'string') { collapseDirection = me.convertCollapseDir(me.collapsed); } me.fireEvent('beginfloat', me); compEl.slideOut(collapseDirection, { preserveScroll: true, duration: Ext.Number.from(me.animCollapse, Ext.fx.Anim.prototype.duration), listeners: { afteranimate: afterSlideOut } }); // Focus the placeholder which should delegate into itself if (this.containsFocus) { focusTarget = this.findFocusTarget(); if (focusTarget) { focusTarget.focus(); } } }, /** * This method begins the slide out of the floated panel. * @private */ slideOutFloatedPanelBegin: function() { var me = this; me.collapsed = me.floatedFromCollapse; me.setHiddenState(true); me.floatedFromCollapse = null; // Remove mouse leave/enter monitors, and the mousedown monitor Ext.destroy(me.pointerLeaveListener, me.phHoverListeners, me.elHoverListeners); }, /** * This method cleans up after the slide out of the floated panel. * @private */ slideOutFloatedPanelEnd: function(suppressEvents) { var me = this; if (me.collapseTool) { me.collapseTool.el.show(); } me.slideOutTask.cancel(); me.isSliding = false; if (!suppressEvents) { me.fireEvent('unfloat', me); } }, /* * Syncs shared configs that might be specified on header config * @param {Object} header */ syncHeaderConfigs: function(header) { var me = this, config, value; for (config in header) { value = header[config]; if (me.headerConfigs[config] && value !== undefined) { // set config directly so we don't fire events me[config] = value; } } } } // private}, function() { var proto = this.prototype; proto.animCollapse = Ext.enableFx; proto.placeholderCollapseHideMode = Ext.Element.VISIBILITY;});