161 lines
6.7 KiB
HTML
161 lines
6.7 KiB
HTML
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
<title>The source code</title>
|
|
<link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
|
|
<script type="text/javascript" src="../resources/prettify/prettify.js"></script>
|
|
<style type="text/css">
|
|
.highlight { display: block; background-color: #ddd; }
|
|
</style>
|
|
<script type="text/javascript">
|
|
function highlight() {
|
|
document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
|
|
}
|
|
</script>
|
|
</head>
|
|
<body onload="prettyPrint(); highlight();">
|
|
<pre class="prettyprint lang-js"><span id='Ext-layout-CardLayout'>/**
|
|
</span> * @class Ext.layout.CardLayout
|
|
* @extends Ext.layout.FitLayout
|
|
* <p>This layout manages multiple child Components, each fitted to the Container, where only a single child Component can be
|
|
* visible at any given time. This layout style is most commonly used for wizards, tab implementations, etc.
|
|
* This class is intended to be extended or created via the layout:'card' {@link Ext.Container#layout} config,
|
|
* and should generally not need to be created directly via the new keyword.</p>
|
|
* <p>The CardLayout's focal method is {@link #setActiveItem}. Since only one panel is displayed at a time,
|
|
* the only way to move from one Component to the next is by calling setActiveItem, passing the id or index of
|
|
* the next panel to display. The layout itself does not provide a user interface for handling this navigation,
|
|
* so that functionality must be provided by the developer.</p>
|
|
* <p>In the following example, a simplistic wizard setup is demonstrated. A button bar is added
|
|
* to the footer of the containing panel to provide navigation buttons. The buttons will be handled by a
|
|
* common navigation routine -- for this example, the implementation of that routine has been ommitted since
|
|
* it can be any type of custom logic. Note that other uses of a CardLayout (like a tab control) would require a
|
|
* completely different implementation. For serious implementations, a better approach would be to extend
|
|
* CardLayout to provide the custom functionality needed. Example usage:</p>
|
|
* <pre><code>
|
|
var navHandler = function(direction){
|
|
// This routine could contain business logic required to manage the navigation steps.
|
|
// It would call setActiveItem as needed, manage navigation button state, handle any
|
|
// branching logic that might be required, handle alternate actions like cancellation
|
|
// or finalization, etc. A complete wizard implementation could get pretty
|
|
// sophisticated depending on the complexity required, and should probably be
|
|
// done as a subclass of CardLayout in a real-world implementation.
|
|
};
|
|
|
|
var card = new Ext.Panel({
|
|
title: 'Example Wizard',
|
|
layout:'card',
|
|
activeItem: 0, // make sure the active item is set on the container config!
|
|
bodyStyle: 'padding:15px',
|
|
defaults: {
|
|
// applied to each contained panel
|
|
border:false
|
|
},
|
|
// just an example of one possible navigation scheme, using buttons
|
|
bbar: [
|
|
{
|
|
id: 'move-prev',
|
|
text: 'Back',
|
|
handler: navHandler.createDelegate(this, [-1]),
|
|
disabled: true
|
|
},
|
|
'->', // greedy spacer so that the buttons are aligned to each side
|
|
{
|
|
id: 'move-next',
|
|
text: 'Next',
|
|
handler: navHandler.createDelegate(this, [1])
|
|
}
|
|
],
|
|
// the panels (or "cards") within the layout
|
|
items: [{
|
|
id: 'card-0',
|
|
html: '&lt;h1&gt;Welcome to the Wizard!&lt;/h1&gt;&lt;p&gt;Step 1 of 3&lt;/p&gt;'
|
|
},{
|
|
id: 'card-1',
|
|
html: '&lt;p&gt;Step 2 of 3&lt;/p&gt;'
|
|
},{
|
|
id: 'card-2',
|
|
html: '&lt;h1&gt;Congratulations!&lt;/h1&gt;&lt;p&gt;Step 3 of 3 - Complete&lt;/p&gt;'
|
|
}]
|
|
});
|
|
</code></pre>
|
|
*/
|
|
Ext.layout.CardLayout = Ext.extend(Ext.layout.FitLayout, {
|
|
<span id='Ext-layout-CardLayout-cfg-deferredRender'> /**
|
|
</span> * @cfg {Boolean} deferredRender
|
|
* True to render each contained item at the time it becomes active, false to render all contained items
|
|
* as soon as the layout is rendered (defaults to false). If there is a significant amount of content or
|
|
* a lot of heavy controls being rendered into panels that are not displayed by default, setting this to
|
|
* true might improve performance.
|
|
*/
|
|
deferredRender : false,
|
|
|
|
<span id='Ext-layout-CardLayout-cfg-layoutOnCardChange'> /**
|
|
</span> * @cfg {Boolean} layoutOnCardChange
|
|
* True to force a layout of the active item when the active card is changed. Defaults to false.
|
|
*/
|
|
layoutOnCardChange : false,
|
|
|
|
<span id='Ext-layout-CardLayout-cfg-renderHidden'> /**
|
|
</span> * @cfg {Boolean} renderHidden @hide
|
|
*/
|
|
<span id='Ext-layout-CardLayout-cfg-renderHidden'> // private
|
|
</span> renderHidden : true,
|
|
|
|
<span id='Ext-layout-CardLayout-property-type'> type: 'card',
|
|
</span>
|
|
<span id='Ext-layout-CardLayout-method-setActiveItem'> /**
|
|
</span> * Sets the active (visible) item in the layout.
|
|
* @param {String/Number} item The string component id or numeric index of the item to activate
|
|
*/
|
|
setActiveItem : function(item){
|
|
var ai = this.activeItem,
|
|
ct = this.container;
|
|
item = ct.getComponent(item);
|
|
|
|
// Is this a valid, different card?
|
|
if(item && ai != item){
|
|
|
|
// Changing cards, hide the current one
|
|
if(ai){
|
|
ai.hide();
|
|
if (ai.hidden !== true) {
|
|
return false;
|
|
}
|
|
ai.fireEvent('deactivate', ai);
|
|
}
|
|
|
|
var layout = item.doLayout && (this.layoutOnCardChange || !item.rendered);
|
|
|
|
// Change activeItem reference
|
|
this.activeItem = item;
|
|
|
|
// The container is about to get a recursive layout, remove any deferLayout reference
|
|
// because it will trigger a redundant layout.
|
|
delete item.deferLayout;
|
|
|
|
// Show the new component
|
|
item.show();
|
|
|
|
this.layout();
|
|
|
|
if(layout){
|
|
item.doLayout();
|
|
}
|
|
item.fireEvent('activate', item);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-layout-CardLayout-method-renderAll'> // private
|
|
</span> renderAll : function(ct, target){
|
|
if(this.deferredRender){
|
|
this.renderItem(this.activeItem, undefined, target);
|
|
}else{
|
|
Ext.layout.CardLayout.superclass.renderAll.call(this, ct, target);
|
|
}
|
|
}
|
|
});
|
|
Ext.Container.LAYOUTS['card'] = Ext.layout.CardLayout;
|
|
</pre>
|
|
</body>
|
|
</html>
|