    /**
     * @class Ext.tree.TreePanel
     * @extends Ext.Panel
     * <p>The TreePanel provides tree-structured UI representation of tree-structured data.</p>
     * <p>{@link Ext.tree.TreeNode TreeNode}s added to the TreePanel may each contain metadata
     * used by your application in their {@link Ext.tree.TreeNode#attributes attributes} property.</p>
     * <p><b>A TreePanel must have a {@link #root} node before it is rendered.</b> This may either be
     * specified using the {@link #root} config option, or using the {@link #setRootNode} method.
     * <p>An example of tree rendered to an existing div:</p><pre><code>
    var tree = new Ext.tree.TreePanel({
        renderTo: 'tree-div',
        useArrows: true,
        autoScroll: true,
        animate: true,
        enableDD: true,
        containerScroll: true,
        border: false,
        // auto create TreeLoader
        dataUrl: 'get-nodes.php',

        root: {
            nodeType: 'async',
            text: 'Ext JS',
            draggable: false,
            id: 'source'
        }
    });

    tree.getRootNode().expand();
     * </code></pre>
     * <p>The example above would work with a data packet similar to this:</p><pre><code>
    [{
        "text": "adapter",
        "id": "source\/adapter",
        "cls": "folder"
    }, {
        "text": "dd",
        "id": "source\/dd",
        "cls": "folder"
    }, {
        "text": "debug.js",
        "id": "source\/debug.js",
        "leaf": true,
        "cls": "file"
    }]
     * </code></pre>
     * <p>An example of tree within a Viewport:</p><pre><code>
    new Ext.Viewport({
        layout: 'border',
        items: [{
            region: 'west',
            collapsible: true,
            title: 'Navigation',
            xtype: 'treepanel',
            width: 200,
            autoScroll: true,
            split: true,
            loader: new Ext.tree.TreeLoader(),
            root: new Ext.tree.AsyncTreeNode({
                expanded: true,
                children: [{
                    text: 'Menu Option 1',
                    leaf: true
                }, {
                    text: 'Menu Option 2',
                    leaf: true
                }, {
                    text: 'Menu Option 3',
                    leaf: true
                }]
            }),
            rootVisible: false,
            listeners: {
                click: function(n) {
                    Ext.Msg.alert('Navigation Tree Click', 'You clicked: "' + n.attributes.text + '"');
                }
            }
        }, {
            region: 'center',
            xtype: 'tabpanel',
            // remaining code not shown ...
        }]
    });
    </code></pre>
     *
     * @cfg {Ext.tree.TreeNode} root The root node for the tree.
     * @cfg {Boolean} rootVisible <tt>false</tt> to hide the root node (defaults to <tt>true</tt>)
     * @cfg {Boolean} lines <tt>false</tt> to disable tree lines (defaults to <tt>true</tt>)
     * @cfg {Boolean} enableDD <tt>true</tt> to enable drag and drop
     * @cfg {Boolean} enableDrag <tt>true</tt> to enable just drag
     * @cfg {Boolean} enableDrop <tt>true</tt> to enable just drop
     * @cfg {Object} dragConfig Custom config to pass to the {@link Ext.tree.TreeDragZone} instance
     * @cfg {Object} dropConfig Custom config to pass to the {@link Ext.tree.TreeDropZone} instance
     * @cfg {String} ddGroup The DD group this TreePanel belongs to
     * @cfg {Boolean} ddAppendOnly <tt>true</tt> if the tree should only allow append drops (use for trees which are sorted)
     * @cfg {Boolean} ddScroll <tt>true</tt> to enable body scrolling
     * @cfg {Boolean} containerScroll <tt>true</tt> to register this container with ScrollManager
     * @cfg {Boolean} hlDrop <tt>false</tt> to disable node highlight on drop (defaults to the value of {@link Ext#enableFx})
     * @cfg {String} hlColor The color of the node highlight (defaults to <tt>'C3DAF9'</tt>)
     * @cfg {Boolean} animate <tt>true</tt> to enable animated expand/collapse (defaults to the value of {@link Ext#enableFx})
     * @cfg {Boolean} singleExpand <tt>true</tt> if only 1 node per branch may be expanded
     * @cfg {Object} selModel A tree selection model to use with this TreePanel (defaults to an {@link Ext.tree.DefaultSelectionModel})
     * @cfg {Boolean} trackMouseOver <tt>false</tt> to disable mouse over highlighting
     * @cfg {Ext.tree.TreeLoader} loader A {@link Ext.tree.TreeLoader} for use with this TreePanel
     * @cfg {String} pathSeparator The token used to separate sub-paths in path strings (defaults to <tt>'/'</tt>)
     * @cfg {Boolean} useArrows <tt>true</tt> to use Vista-style arrows in the tree (defaults to <tt>false</tt>)
     * @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}).
     *
     * @constructor
     * @param {Object} config
     * @xtype treepanel
     */
    Ext.tree.TreePanel = Ext.extend(Ext.Panel, {
        rootVisible : true,
        animate : Ext.enableFx,
        lines : true,
        enableDD : false,
        hlDrop : Ext.enableFx,
        pathSeparator : '/',

        /**
         * @cfg {Array} bubbleEvents
         * <p>An array of events that, when fired, should be bubbled to any parent container.
         * See {@link Ext.util.Observable#enableBubble}.
         * Defaults to <tt>[]</tt>.
         */
        bubbleEvents : [],

        initComponent : function(){
            Ext.tree.TreePanel.superclass.initComponent.call(this);

            if(!this.eventModel){
                this.eventModel = new Ext.tree.TreeEventModel(this);
            }

            // initialize the loader
            var l = this.loader;
            if(!l){
                l = new Ext.tree.TreeLoader({
                    dataUrl: this.dataUrl,
                    requestMethod: this.requestMethod
                });
            }else if(Ext.isObject(l) && !l.load){
                l = new Ext.tree.TreeLoader(l);
            }
            this.loader = l;

            this.nodeHash = {};

            /**
            * The root node of this tree.
            * @type Ext.tree.TreeNode
            * @property root
            */
            if(this.root){
                var r = this.root;
                delete this.root;
                this.setRootNode(r);
            }

            this.addEvents(

                /**
                * @event append
                * Fires when a new child node is appended to a node in this tree.
                * @param {Tree} tree The owner tree
                * @param {Node} parent The parent node
                * @param {Node} node The newly appended node
                * @param {Number} index The index of the newly appended node
                */
               'append',
               /**
                * @event remove
                * Fires when a child node is removed from a node in this tree.
                * @param {Tree} tree The owner tree
                * @param {Node} parent The parent node
                * @param {Node} node The child node removed
                */
               'remove',
               /**
                * @event movenode
                * Fires when a node is moved to a new location in the tree
                * @param {Tree} tree The owner tree
                * @param {Node} node The node moved
                * @param {Node} oldParent The old parent of this node
                * @param {Node} newParent The new parent of this node
                * @param {Number} index The index it was moved to
                */
               'movenode',
               /**
                * @event insert
                * Fires when a new child node is inserted in a node in this tree.
                * @param {Tree} tree The owner tree
                * @param {Node} parent The parent node
                * @param {Node} node The child node inserted
                * @param {Node} refNode The child node the node was inserted before
                */
               'insert',
               /**
                * @event beforeappend
                * Fires before a new child is appended to a node in this tree, return false to cancel the append.
                * @param {Tree} tree The owner tree
                * @param {Node} parent The parent node
                * @param {Node} node The child node to be appended
                */
               'beforeappend',
               /**
                * @event beforeremove
                * Fires before a child is removed from a node in this tree, return false to cancel the remove.
                * @param {Tree} tree The owner tree
                * @param {Node} parent The parent node
                * @param {Node} node The child node to be removed
                */
               'beforeremove',
               /**
                * @event beforemovenode
                * Fires before a node is moved to a new location in the tree. Return false to cancel the move.
                * @param {Tree} tree The owner tree
                * @param {Node} node The node being moved
                * @param {Node} oldParent The parent of the node
                * @param {Node} newParent The new parent the node is moving to
                * @param {Number} index The index it is being moved to
                */
               'beforemovenode',
               /**
                * @event beforeinsert
                * Fires before a new child is inserted in a node in this tree, return false to cancel the insert.
                * @param {Tree} tree The owner tree
                * @param {Node} parent The parent node
                * @param {Node} node The child node to be inserted
                * @param {Node} refNode The child node the node is being inserted before
                */
                'beforeinsert',

                /**
                * @event beforeload
                * Fires before a node is loaded, return false to cancel
                * @param {Node} node The node being loaded
                */
                'beforeload',
                /**
                * @event load
                * Fires when a node is loaded
                * @param {Node} node The node that was loaded
                */
                'load',
                /**
                * @event textchange
                * Fires when the text for a node is changed
                * @param {Node} node The node
                * @param {String} text The new text
                * @param {String} oldText The old text
                */
                'textchange',
                /**
                * @event beforeexpandnode
                * Fires before a node is expanded, return false to cancel.
                * @param {Node} node The node
                * @param {Boolean} deep
                * @param {Boolean} anim
                */
                'beforeexpandnode',
                /**
                * @event beforecollapsenode
                * Fires before a node is collapsed, return false to cancel.
                * @param {Node} node The node
                * @param {Boolean} deep
                * @param {Boolean} anim
                */
                'beforecollapsenode',
                /**
                * @event expandnode
                * Fires when a node is expanded
                * @param {Node} node The node
                */
                'expandnode',
                /**
                * @event disabledchange
                * Fires when the disabled status of a node changes
                * @param {Node} node The node
                * @param {Boolean} disabled
                */
                'disabledchange',
                /**
                * @event collapsenode
                * Fires when a node is collapsed
                * @param {Node} node The node
                */
                'collapsenode',
                /**
                * @event beforeclick
                * Fires before click processing on a node. Return false to cancel the default action.
                * @param {Node} node The node
                * @param {Ext.EventObject} e The event object
                */
                'beforeclick',
                /**
                * @event click
                * Fires when a node is clicked
                * @param {Node} node The node
                * @param {Ext.EventObject} e The event object
                */
                'click',
                /**
                * @event containerclick
                * Fires when the tree container is clicked
                * @param {Tree} this
                * @param {Ext.EventObject} e The event object
                */
                'containerclick',
                /**
                * @event checkchange
                * Fires when a node with a checkbox's checked property changes
                * @param {Node} this This node
                * @param {Boolean} checked
                */
                'checkchange',
                /**
                * @event beforedblclick
                * Fires before double click processing on a node. Return false to cancel the default action.
                * @param {Node} node The node
                * @param {Ext.EventObject} e The event object
                */
                'beforedblclick',
                /**
                * @event dblclick
                * Fires when a node is double clicked
                * @param {Node} node The node
                * @param {Ext.EventObject} e The event object
                */
                'dblclick',
                /**
                * @event containerdblclick
                * Fires when the tree container is double clicked
                * @param {Tree} this
                * @param {Ext.EventObject} e The event object
                */
                'containerdblclick',
                /**
                * @event contextmenu
                * Fires when a node is right clicked. To display a context menu in response to this
                * event, first create a Menu object (see {@link Ext.menu.Menu} for details), then add
                * a handler for this event:<pre><code>
    new Ext.tree.TreePanel({
        title: 'My TreePanel',
        root: new Ext.tree.AsyncTreeNode({
            text: 'The Root',
            children: [
                { text: 'Child node 1', leaf: true },
                { text: 'Child node 2', leaf: true }
            ]
        }),
        contextMenu: new Ext.menu.Menu({
            items: [{
                id: 'delete-node',
                text: 'Delete Node'
            }],
            listeners: {
                itemclick: function(item) {
                    switch (item.id) {
                        case 'delete-node':
                            var n = item.parentMenu.contextNode;
                            if (n.parentNode) {
                                n.remove();
                            }
                            break;
                    }
                }
            }
        }),
        listeners: {
            contextmenu: function(node, e) {
    //          Register the context node with the menu so that a Menu Item's handler function can access
    //          it via its {@link Ext.menu.BaseItem#parentMenu parentMenu} property.
                node.select();
                var c = node.getOwnerTree().contextMenu;
                c.contextNode = node;
                c.showAt(e.getXY());
            }
        }
    });
    </code></pre>
                * @param {Node} node The node
                * @param {Ext.EventObject} e The event object
                */
                'contextmenu',
                /**
                * @event containercontextmenu
                * Fires when the tree container is right clicked
                * @param {Tree} this
                * @param {Ext.EventObject} e The event object
                */
                'containercontextmenu',
                /**
                * @event beforechildrenrendered
                * Fires right before the child nodes for a node are rendered
                * @param {Node} node The node
                */
                'beforechildrenrendered',
               /**
                 * @event startdrag
                 * Fires when a node starts being dragged
                 * @param {Ext.tree.TreePanel} this
                 * @param {Ext.tree.TreeNode} node
                 * @param {event} e The raw browser event
                 */
                'startdrag',
                /**
                 * @event enddrag
                 * Fires when a drag operation is complete
                 * @param {Ext.tree.TreePanel} this
                 * @param {Ext.tree.TreeNode} node
                 * @param {event} e The raw browser event
                 */
                'enddrag',
                /**
                 * @event dragdrop
                 * Fires when a dragged node is dropped on a valid DD target
                 * @param {Ext.tree.TreePanel} this
                 * @param {Ext.tree.TreeNode} node
                 * @param {DD} dd The dd it was dropped on
                 * @param {event} e The raw browser event
                 */
                'dragdrop',
                /**
                 * @event beforenodedrop
                 * Fires when a DD object is dropped on a node in this tree for preprocessing. Return false to cancel the drop. The dropEvent
                 * passed to handlers has the following properties:<br />
                 * <ul style="padding:5px;padding-left:16px;">
                 * <li>tree - The TreePanel</li>
                 * <li>target - The node being targeted for the drop</li>
                 * <li>data - The drag data from the drag source</li>
                 * <li>point - The point of the drop - append, above or below</li>
                 * <li>source - The drag source</li>
                 * <li>rawEvent - Raw mouse event</li>
                 * <li>dropNode - Drop node(s) provided by the source <b>OR</b> you can supply node(s)
                 * to be inserted by setting them on this object.</li>
                 * <li>cancel - Set this to true to cancel the drop.</li>
                 * <li>dropStatus - If the default drop action is cancelled but the drop is valid, setting this to true
                 * will prevent the animated 'repair' from appearing.</li>
                 * </ul>
                 * @param {Object} dropEvent
                 */
                'beforenodedrop',
                /**
                 * @event nodedrop
                 * Fires after a DD object is dropped on a node in this tree. The dropEvent
                 * passed to handlers has the following properties:<br />
                 * <ul style="padding:5px;padding-left:16px;">
                 * <li>tree - The TreePanel</li>
                 * <li>target - The node being targeted for the drop</li>
                 * <li>data - The drag data from the drag source</li>
                 * <li>point - The point of the drop - append, above or below</li>
                 * <li>source - The drag source</li>
                 * <li>rawEvent - Raw mouse event</li>
                 * <li>dropNode - Dropped node(s).</li>
                 * </ul>
                 * @param {Object} dropEvent
                 */
                'nodedrop',
                 /**
                 * @event nodedragover
                 * Fires when a tree node is being targeted for a drag drop, return false to signal drop not allowed. The dragOverEvent
                 * passed to handlers has the following properties:<br />
                 * <ul style="padding:5px;padding-left:16px;">
                 * <li>tree - The TreePanel</li>
                 * <li>target - The node being targeted for the drop</li>
                 * <li>data - The drag data from the drag source</li>
                 * <li>point - The point of the drop - append, above or below</li>
                 * <li>source - The drag source</li>
                 * <li>rawEvent - Raw mouse event</li>
                 * <li>dropNode - Drop node(s) provided by the source.</li>
                 * <li>cancel - Set this to true to signal drop not allowed.</li>
                 * </ul>
                 * @param {Object} dragOverEvent
                 */
                'nodedragover'
            );
            if(this.singleExpand){
                this.on('beforeexpandnode', this.restrictExpand, this);
            }
        },

        // private
        proxyNodeEvent : function(ename, a1, a2, a3, a4, a5, a6){
            if(ename == 'collapse' || ename == 'expand' || ename == 'beforecollapse' || ename == 'beforeexpand' || ename == 'move' || ename == 'beforemove'){
                ename = ename+'node';
            }
            // args inline for performance while bubbling events
            return this.fireEvent(ename, a1, a2, a3, a4, a5, a6);
        },

        /**
         * Returns this root node for this tree
         * @return {Node}
         */
        getRootNode : function(){
            return this.root;
        },

        /**
         * Sets the root node for this tree. If the TreePanel has already rendered a root node, the
         * previous root node (and all of its descendants) are destroyed before the new root node is rendered.
         * @param {Node} node
         * @return {Node}
         */
        setRootNode : function(node){
            this.destroyRoot();
            if(!node.render){ // attributes passed
                node = this.loader.createNode(node);
            }
            this.root = node;
            node.ownerTree = this;
            node.isRoot = true;
            this.registerNode(node);
            if(!this.rootVisible){
                var uiP = node.attributes.uiProvider;
                node.ui = uiP ? new uiP(node) : new Ext.tree.RootTreeNodeUI(node);
            }
            if(this.innerCt){
                this.clearInnerCt();
                this.renderRoot();
            }
            return node;
        },

        clearInnerCt : function(){
            this.innerCt.update('');
        },

        // private
        renderRoot : function(){
            this.root.render();
            if(!this.rootVisible){
                this.root.renderChildren();
            }
        },

        /**
         * Gets a node in this tree by its id
         * @param {String} id
         * @return {Node}
         */
        getNodeById : function(id){
            return this.nodeHash[id];
        },

        // private
        registerNode : function(node){
            this.nodeHash[node.id] = node;
        },

        // private
        unregisterNode : function(node){
            delete this.nodeHash[node.id];
        },

        // private
        toString : function(){
            return '[Tree'+(this.id?' '+this.id:'')+']';
        },

        // private
        restrictExpand : function(node){
            var p = node.parentNode;
            if(p){
                if(p.expandedChild && p.expandedChild.parentNode == p){
                    p.expandedChild.collapse();
                }
                p.expandedChild = node;
            }
        },

        /**
         * Retrieve an array of checked nodes, or an array of a specific attribute of checked nodes (e.g. 'id')
         * @param {String} attribute (optional) Defaults to null (return the actual nodes)
         * @param {TreeNode} startNode (optional) The node to start from, defaults to the root
         * @return {Array}
         */
        getChecked : function(a, startNode){
            startNode = startNode || this.root;
            var r = [];
            var f = function(){
                if(this.attributes.checked){
                    r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a]));
                }
            };
            startNode.cascade(f);
            return r;
        },

        /**
         * Returns the default {@link Ext.tree.TreeLoader} for this TreePanel.
         * @return {Ext.tree.TreeLoader} The TreeLoader for this TreePanel.
         */
        getLoader : function(){
            return this.loader;
        },

        /**
         * Expand all nodes
         */
        expandAll : function(){
            this.root.expand(true);
        },

        /**
         * Collapse all nodes
         */
        collapseAll : function(){
            this.root.collapse(true);
        },

        /**
         * Returns the selection model used by this TreePanel.
         * @return {TreeSelectionModel} The selection model used by this TreePanel
         */
        getSelectionModel : function(){
            if(!this.selModel){
                this.selModel = new Ext.tree.DefaultSelectionModel();
            }
            return this.selModel;
        },

        /**
         * Expands a specified path in this TreePanel. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
         * @param {String} path
         * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
         * @param {Function} callback (optional) The callback to call when the expand is complete. The callback will be called with
         * (bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded.
         */
        expandPath : function(path, attr, callback){
            if(Ext.isEmpty(path)){
                if(callback){
                    callback(false, undefined);
                }
                return;
            }
            attr = attr || 'id';
            var keys = path.split(this.pathSeparator);
            var curNode = this.root;
            if(curNode.attributes[attr] != keys[1]){ // invalid root
                if(callback){
                    callback(false, null);
                }
                return;
            }
            var index = 1;
            var f = function(){
                if(++index == keys.length){
                    if(callback){
                        callback(true, curNode);
                    }
                    return;
                }
                var c = curNode.findChild(attr, keys[index]);
                if(!c){
                    if(callback){
                        callback(false, curNode);
                    }
                    return;
                }
                curNode = c;
                c.expand(false, false, f);
            };
            curNode.expand(false, false, f);
        },

        /**
         * Selects the node in this tree at the specified path. A path can be retrieved from a node with {@link Ext.data.Node#getPath}
         * @param {String} path
         * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info)
         * @param {Function} callback (optional) The callback to call when the selection is complete. The callback will be called with
         * (bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node.
         */
        selectPath : function(path, attr, callback){
            if(Ext.isEmpty(path)){
                if(callback){
                    callback(false, undefined);
                }
                return;
            }
            attr = attr || 'id';
            var keys = path.split(this.pathSeparator),
                v = keys.pop();
            if(keys.length > 1){
                var f = function(success, node){
                    if(success && node){
                        var n = node.findChild(attr, v);
                        if(n){
                            n.select();
                            if(callback){
                                callback(true, n);
                            }
                        }else if(callback){
                            callback(false, n);
                        }
                    }else{
                        if(callback){
                            callback(false, n);
                        }
                    }
                };
                this.expandPath(keys.join(this.pathSeparator), attr, f);
            }else{
                this.root.select();
                if(callback){
                    callback(true, this.root);
                }
            }
        },

        /**
         * Returns the underlying Element for this tree
         * @return {Ext.Element} The Element
         */
        getTreeEl : function(){
            return this.body;
        },

        // private
        onRender : function(ct, position){
            Ext.tree.TreePanel.superclass.onRender.call(this, ct, position);
            this.el.addClass('x-tree');
            this.innerCt = this.body.createChild({tag:'ul',
                   cls:'x-tree-root-ct ' +
                   (this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')});
        },

        // private
        initEvents : function(){
            Ext.tree.TreePanel.superclass.initEvents.call(this);

            if(this.containerScroll){
                Ext.dd.ScrollManager.register(this.body);
            }
            if((this.enableDD || this.enableDrop) && !this.dropZone){
               /**
                * The dropZone used by this tree if drop is enabled (see {@link #enableDD} or {@link #enableDrop})
                * @property dropZone
                * @type Ext.tree.TreeDropZone
                */
                 this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || {
                   ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true
               });
            }
            if((this.enableDD || this.enableDrag) && !this.dragZone){
               /**
                * The dragZone used by this tree if drag is enabled (see {@link #enableDD} or {@link #enableDrag})
                * @property dragZone
                * @type Ext.tree.TreeDragZone
                */
                this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || {
                   ddGroup: this.ddGroup || 'TreeDD',
                   scroll: this.ddScroll
               });
            }
            this.getSelectionModel().init(this);
        },

        // private
        afterRender : function(){
            Ext.tree.TreePanel.superclass.afterRender.call(this);
            this.renderRoot();
        },

        beforeDestroy : function(){
            if(this.rendered){
                Ext.dd.ScrollManager.unregister(this.body);
                Ext.destroy(this.dropZone, this.dragZone);
            }
            this.destroyRoot();
            Ext.destroy(this.loader);
            this.nodeHash = this.root = this.loader = null;
            Ext.tree.TreePanel.superclass.beforeDestroy.call(this);
        },

        /**
         * Destroy the root node. Not included by itself because we need to pass the silent parameter.
         * @private
         */
        destroyRoot : function(){
            if(this.root && this.root.destroy){
                this.root.destroy(true);
            }
        }

        /**
         * @cfg {String/Number} activeItem
         * @hide
         */
        /**
         * @cfg {Boolean} autoDestroy
         * @hide
         */
        /**
         * @cfg {Object/String/Function} autoLoad
         * @hide
         */
        /**
         * @cfg {Boolean} autoWidth
         * @hide
         */
        /**
         * @cfg {Boolean/Number} bufferResize
         * @hide
         */
        /**
         * @cfg {String} defaultType
         * @hide
         */
        /**
         * @cfg {Object} defaults
         * @hide
         */
        /**
         * @cfg {Boolean} hideBorders
         * @hide
         */
        /**
         * @cfg {Mixed} items
         * @hide
         */
        /**
         * @cfg {String} layout
         * @hide
         */
        /**
         * @cfg {Object} layoutConfig
         * @hide
         */
        /**
         * @cfg {Boolean} monitorResize
         * @hide
         */
        /**
         * @property items
         * @hide
         */
        /**
         * @method cascade
         * @hide
         */
        /**
         * @method doLayout
         * @hide
         */
        /**
         * @method find
         * @hide
         */
        /**
         * @method findBy
         * @hide
         */
        /**
         * @method findById
         * @hide
         */
        /**
         * @method findByType
         * @hide
         */
        /**
         * @method getComponent
         * @hide
         */
        /**
         * @method getLayout
         * @hide
         */
        /**
         * @method getUpdater
         * @hide
         */
        /**
         * @method insert
         * @hide
         */
        /**
         * @method load
         * @hide
         */
        /**
         * @method remove
         * @hide
         */
        /**
         * @event add
         * @hide
         */
        /**
         * @method removeAll
         * @hide
         */
        /**
         * @event afterLayout
         * @hide
         */
        /**
         * @event beforeadd
         * @hide
         */

        /**
         * @cfg {String} allowDomMove  @hide
         */
        /**
         * @cfg {String} autoEl @hide
         */
        /**
         * @cfg {String} applyTo  @hide
         */
        /**
         * @cfg {String} contentEl  @hide
         */
        /**
         * @cfg {Mixed} data  @hide
         */
        /**
         * @cfg {Mixed} tpl  @hide
         */
        /**
         * @cfg {String} tplWriteMode  @hide
         */
        /**
         * @cfg {String} disabledClass  @hide
         */
        /**
         * @cfg {String} elements  @hide
         */
        /**
         * @cfg {String} html  @hide
         */
        /**
         * @cfg {Boolean} preventBodyReset
         * @hide
         */
        /**
         * @property disabled
         * @hide
         */
        /**
         * @method applyToMarkup
         * @hide
         */
        /**
         * @method enable
         * @hide
         */
        /**
         * @method disable
         * @hide
         */
        /**
         * @method setDisabled
         * @hide
         */
    });

    Ext.tree.TreePanel.nodeTypes = {};

    Ext.reg('treepanel', Ext.tree.TreePanel);