    /*!
     * Ext JS Library 3.4.0
     * Copyright(c) 2006-2011 Sencha Inc.
     * licensing@sencha.com
     * http://www.sencha.com/license
     */
    /**
     * @class Ext.layout.CardLayout
     * @extends Ext.layout.FitLayout
     * 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.
     * 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.
     * 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:
     *
    var navHandler = function(direction){
        // This routine could contain business logic required to manage the navigation steps.
        // It would call setActiveItem as needed, manage navigation button state, handle any
        // branching logic that might be required, handle alternate actions like cancellation
        // or finalization, etc.  A complete wizard implementation could get pretty
        // sophisticated depending on the complexity required, and should probably be
        // done as a subclass of CardLayout in a real-world implementation.
    };

    var card = new Ext.Panel({
        title: 'Example Wizard',
        layout:'card',
        activeItem: 0, // make sure the active item is set on the container config!
        bodyStyle: 'padding:15px',
        defaults: {
            // applied to each contained panel
            border:false
        },
        // just an example of one possible navigation scheme, using buttons
        bbar: [
            {
                id: 'move-prev',
                text: 'Back',
                handler: navHandler.createDelegate(this, [-1]),
                disabled: true
            },
            '->', // greedy spacer so that the buttons are aligned to each side
            {
                id: 'move-next',
                text: 'Next',
                handler: navHandler.createDelegate(this, [1])
            }
        ],
        // the panels (or "cards") within the layout
        items: [{
            id: 'card-0',
            html: '<h1>Welcome to the Wizard!</h1><p>Step 1 of 3</p>'
        },{
            id: 'card-1',
            html: '<p>Step 2 of 3</p>'
        },{
            id: 'card-2',
            html: '<h1>Congratulations!</h1><p>Step 3 of 3 - Complete</p>'
        }]
    });

     */
    Ext.layout.CardLayout = Ext.extend(Ext.layout.FitLayout, {
        /**
         * @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,

        /**
         * @cfg {Boolean} layoutOnCardChange
         * True to force a layout of the active item when the active card is changed. Defaults to false.
         */
        layoutOnCardChange : false,

        /**
         * @cfg {Boolean} renderHidden @hide
         */
        // private
        renderHidden : true,

        type: 'card',

        /**
         * 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);
            }
        },

        // private
        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;