//------------------------------------------------------------------------------
// <copyright file="TreeNode.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Drawing;
    using System.Drawing.Design;
    using System.Globalization;
    using System.IO;
    using System.Text;
    using System.Web.UI;
    using System.Web.Util;


    /// <devdoc>
    ///     Provides a tree node for use in the TreeView class
    /// </devdoc>
    [ParseChildren(true, "ChildNodes")]
    public class TreeNode : IStateManager, ICloneable {
        private bool _isTrackingViewState;
        private StateBag _viewState;

        private TreeNodeCollection _childNodes;
        private TreeView _owner;
        private TreeNode _parent;

        private bool _populateDesired;
        private int _selectDesired;
        private bool _modifyCheckedNodes;

        private string _parentIsLast;
        private string _toggleNodeAttributeValue;

        private object _dataItem;

        private int _index;

        private string _valuePath;
        private string _internalValuePath;
        private int _depth = -2;

        private bool _isRoot;


        /// <devdoc>
        ///     Constructs a new TreeNode without a text or value
        /// </devdoc>
        public TreeNode() {
            _selectDesired = 0;
        }


        /// <devdoc>
        ///     Constructs a new TreeNode with the specified owner TreeView
        /// </devdoc>
        protected internal TreeNode(TreeView owner, bool isRoot) : this() {
            _owner = owner;
            _isRoot = isRoot;
        }


        /// <devdoc>
        ///     Constructs a new TreeNode with the specified text
        /// </devdoc>
        public TreeNode(string text) : this(text, null, null, null, null) {
        }


        /// <devdoc>
        ///     Constructs a new TreeNode with the specified text, and value
        /// </devdoc>
        public TreeNode(string text, string value) : this(text, value, null, null, null) {
        }


        /// <devdoc>
        ///     Constructs a new TreeNode with the specified text, value, and image URL
        /// </devdoc>
        public TreeNode(string text, string value, string imageUrl) : this(text, value, imageUrl, null, null){
        }


        /// <devdoc>
        ///     Constructs a new TreeNode with the specified text, value, image URL, navigation URL, and target.
        /// </devdoc>
        public TreeNode(string text, string value, string imageUrl, string navigateUrl, string target) : this() {
            if (text != null) {
                Text = text;
            }

            if (value != null) {
                Value = value;
            }

            if (!String.IsNullOrEmpty(imageUrl)) {
                ImageUrl = imageUrl;
            }

            if (!String.IsNullOrEmpty(navigateUrl)) {
                NavigateUrl = navigateUrl;
            }

            if (!String.IsNullOrEmpty(target)) {
                Target = target;
            }
        }


        /// <devdoc>
        ///     Gets and sets the checked state
        /// </devdoc>
        [DefaultValue(false)]
        [WebSysDescription(SR.TreeNode_Checked)]
        public bool Checked {
            get {
                object o = ViewState["Checked"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
            set {
                ViewState["Checked"] = value;
                NotifyOwnerChecked();
            }
        }

        /// <devdov>
        /// </devdoc>
        internal bool CheckedSet {
            get {
                return (ViewState["Checked"] != null);
            }
        }


        /// <devdoc>
        ///     Gets whether this node was creating through databinding
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool DataBound {
            get {
                object o = ViewState["DataBound"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
        }


        /// <devdoc>
        ///     Gets the collection of children nodes parented to this TreeNode
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue(null)]
        [MergableProperty(false)]
        [PersistenceMode(PersistenceMode.InnerDefaultProperty)]
        public TreeNodeCollection ChildNodes {
            get {
                if (_childNodes == null) {
                    _childNodes = new TreeNodeCollection(this);
                }
                return _childNodes;
            }
        }


        /// <devdoc>
        ///     Gets path to the data to which this node is bound.
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue("")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string DataPath {
            get {
                string s = (string)ViewState["DataPath"];
                if (s == null) {
                    return String.Empty;
                }
                return s;
            }
        }


        /// <devdoc>
        ///     Gets the depth of the tree node.
        /// </devdoc>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int Depth {
            get {
                if (_depth == -2) {
                    if (_isRoot) {
                        return -1;
                    }

                    if (Parent != null) {
                        _depth = Parent.Depth + 1;
                    }
                    else if (_owner != null) {
                        _depth = InternalValuePath.Split(TreeView.InternalPathSeparator).Length - 1;
                    }
                    else {
                        return 0;
                    }
                }
                return _depth;
            }
        }

        /// <devdoc>
        ///     Gets and sets the expand state
        /// </devdoc>
        [DefaultValue(typeof(Nullable<bool>), "")]
        [WebSysDescription(SR.TreeNode_Expanded)]
        public bool? Expanded {
            get {
                object o = ViewState["Expanded"];
                if (o == null) {
                    return null;
                }
                return (bool?)o;
            }
            set {
                bool? oldValue = Expanded;
                // We need to set the viewstate so that it wins over ExpandDepth on the get request (VSWhidbey 331936)
                // N.B. We don't want this to happen when restoring ViewState.
                ViewState["Expanded"] = value;
                if (value != oldValue) {
                    if (_owner != null && _owner.DesignMode) return;

                    if (value == true) {
                        if (PopulateOnDemand) {
                            // If the owner isn't set, remember to populate the node when the
                            // owner is determined
                            if (_owner == null) {
                                _populateDesired = true;
                            }
                            // Don't populate when the TreeView is restoring client expand state
                            else if (!_owner.LoadingNodeState) {
                                Populate();
                            }
                        }

                        if (_owner != null) {
                            _owner.RaiseTreeNodeExpanded(this);
                        }
                    }
                    else if ((value == false) && (oldValue == true) && (ChildNodes.Count > 0)) {
                        if (_owner != null) {
                            _owner.RaiseTreeNodeCollapsed(this);
                        }
                    }
                }
            }
        }

        /// <devdoc>
        ///     Gets the data item for the tree node.
        /// </devdoc>
        [Browsable(false)]
        [DefaultValue(null)]
        public object DataItem {
            get {
                return _dataItem;
            }
        }


        /// <devdoc>
        ///     Gets and sets the TreeNode ImageToolTip
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.TreeNode_ImageToolTip)]
        public string ImageToolTip {
            get {
                string s = (string)ViewState["ImageToolTip"];

                if (s == null) {
                    return String.Empty;
                }

                return s;
            }
            set {
                ViewState["ImageToolTip"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the image URl to be rendered for this node
        /// </devdoc>
        [DefaultValue("")]
        [Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))]
        [UrlProperty()]
        [WebSysDescription(SR.TreeNode_ImageUrl)]
        public string ImageUrl {
            get {
                string s = (string)ViewState["ImageUrl"];
                if (s == null) {
                    return String.Empty;
                }
                return s;
            }
            set {
                ViewState["ImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the unique index for the tree node
        /// </devdoc>
        internal int Index {
            get {
                return _index;
            }
            set {
                _index = value;
            }
        }
       
        // This is the value path that we use internally. It is different from ValuePath
        // because we always use the same separator character and escape it from values.
        internal string InternalValuePath {
            get {
                if (_internalValuePath != null ) {
                    return _internalValuePath;
                }
                if (_parent != null) {
                    // StringBuilder.Insert is expensive, but we need to build starting from the end.
                    // First build a list, then build the string starting from the end of the list.
                    List<string> pathParts = new List<string>();
                    pathParts.Add(TreeView.Escape(Value));
                    TreeNode parent = _parent;
                    while ((parent != null) && !parent._isRoot) {
                        if (parent._internalValuePath != null) {
                            pathParts.Add(parent._internalValuePath);
                            break;
                        }
                        else {
                            pathParts.Add(TreeView.Escape(parent.Value));
                        }
                        parent = parent._parent;
                    }
                    pathParts.Reverse();
                    _internalValuePath = String.Join(TreeView.InternalPathSeparator.ToString(), pathParts.ToArray());
                    return _internalValuePath;
                }
                else {
                    return String.Empty;
                }
            }
        }


        /// <devdoc>
        ///     Gets and sets the URL to navigate to when the node is clicked
        /// </devdoc>
        [DefaultValue("")]
        [Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))]
        [UrlProperty()]
        [WebSysDescription(SR.TreeNode_NavigateUrl)]
        public string NavigateUrl {
            get {
                string s = (string)ViewState["NavigateUrl"];
                if (s == null) {
                    return String.Empty;
                }
                return s;
            }
            set {
                ViewState["NavigateUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the owner TreeView for this TreeNode, if there is one
        /// </devdoc>
        internal TreeView Owner {
            get {
                return _owner;
            }
        }


        /// <devdoc>
        ///     Gets the parent TreeNode
        /// </devdoc>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public TreeNode Parent {
            get {
                if ((_parent == null) || _parent._isRoot) {
                    return null;
                }

                return _parent;
            }

        }


        /// <devdoc>
        ///     Gets and sets whether node has been populated
        /// </devdoc>
        internal bool Populated {
            get {
                object o = ViewState["Populated"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
            set {
                ViewState["Populated"] = value;
            }
        }


        /// <devdoc>
        ///     Specifies whether the node should have its children populate immediately or
        ///     only when the node is expanded.
        /// </devdoc>
        [DefaultValue(false)]
        [WebSysDescription(SR.TreeNode_PopulateOnDemand)]
        public bool PopulateOnDemand {
            get {
                object o = ViewState["PopulateOnDemand"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
            set {
                ViewState["PopulateOnDemand"] = value;
                if (value && (Expanded == true)) {
                    Expanded = null;
                }
            }
        }


        /// <devdoc>
        ///     Gets and sets the PreserveChecked state
        /// </devdoc>
        [DefaultValue(false)]
        internal bool PreserveChecked {
            get {
                object o = ViewState["PreserveChecked"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
            set {
                ViewState["PreserveChecked"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the action which the TreeNode will perform when selected
        /// </devdoc>
        [DefaultValue(TreeNodeSelectAction.Select)]
        [WebSysDescription(SR.TreeNode_SelectAction)]
        public TreeNodeSelectAction SelectAction {
            get {
                object o = ViewState["SelectAction"];
                if (o == null) {
                    return TreeNodeSelectAction.Select;
                }
                return (TreeNodeSelectAction)o;
            }
            set {
                ViewState["SelectAction"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the selected state
        /// </devdoc>
        [DefaultValue(false)]
        [WebSysDescription(SR.TreeNode_Selected)]
        public bool Selected {
            get {
                object o = ViewState["Selected"];
                if (o == null) {
                    return false;
                }
                return (bool)o;
            }
            set {
                SetSelected(value);
                if (_owner == null) {
                    _selectDesired = (value ? +1 : -1);
                    return;
                }
                else if (value) {
                    // Set the TreeView's selected node to this one
                    _owner.SetSelectedNode(this);
                }
                else if (this == _owner.SelectedNode) {
                    _owner.SetSelectedNode(null);
                }
            }
        }
        
        internal string SelectID {
            get {
                if (_owner.ShowExpandCollapse) {
                    return _owner.CreateNodeTextId(Index);
                }
                else {
                    return _owner.CreateNodeId(Index);
                }
            }
        }


        /// <devdoc>
        ///     Gets and sets whether the TreeNode has a CheckBox
        ///     See ShouldSerializeShowCheckBox remarks.
        /// </devdoc>
        [DefaultValue(typeof(Nullable<bool>), "")]
        [WebSysDescription(SR.TreeNode_ShowCheckBox)]
        public bool? ShowCheckBox {
            get {
                object o = ViewState["ShowCheckBox"];
                if (o == null) {
                    return null;
                }
                return (bool?)o;
            }
            set {
                ViewState["ShowCheckBox"] = value;
            }
        }

        /// <devdoc>
        ///     Gets and sets the target window that the TreeNode will browse to if selected
        /// </devdoc>
        [DefaultValue("")]
        [WebSysDescription(SR.TreeNode_Target)]
        public string Target {
            get {
                string s = (string)ViewState["Target"];
                if (s == null) {
                    return String.Empty;
                }
                return s;
            }
            set {
                ViewState["Target"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the display text
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.TreeNode_Text)]
        public string Text {
            get {
                string s = (string)ViewState["Text"];
                if (s == null) {
                    s = (string)ViewState["Value"];
                    if (s == null) {
                        return String.Empty;
                    }
                }
                return s;
            }
            set {
                ViewState["Text"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the TreeNode tooltip
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.TreeNode_ToolTip)]
        public string ToolTip {
            get {
                string s = (string)ViewState["ToolTip"];
                if (s == null) {
                    return String.Empty;
                }
                return s;
            }
            set {
                ViewState["ToolTip"] = value;
            }
        }


        /// <devdoc>
        ///     Gets and sets the value
        /// </devdoc>
        [DefaultValue("")]
        [Localizable(true)]
        [WebSysDescription(SR.TreeNode_Value)]
        public string Value {
            get {
                string s = (string)ViewState["Value"];
                if (s == null) {
                    s = (string)ViewState["Text"];
                    if (s == null) {
                        return String.Empty;
                    }
                }
                return s;
            }
            set {
                ViewState["Value"] = value;
                ResetValuePathRecursive();
            }
        }


        /// <devdoc>
        ///     Gets the full path of the TreeNode
        /// </devdoc>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string ValuePath {
            get {
                if (_valuePath != null) {
                    return _valuePath;
                }

                if (_parent != null) {
                    string parentPath = _parent.ValuePath;
                    _valuePath = ((parentPath.Length == 0) && (_parent.Depth == -1)) ?
                        Value : parentPath + _owner.PathSeparator + Value;
                    return _valuePath;
                }
                else if ((Owner != null) && !String.IsNullOrEmpty(InternalValuePath)) {
                    // Reconstruct the value path from the internal value path (callback case, VSWhidbey 340121)
                    string[] splitValuePath = InternalValuePath.Split(TreeView.InternalPathSeparator);
                    for (int i = 0; i < splitValuePath.Length; i++) {
                        splitValuePath[i] = TreeView.UnEscape(splitValuePath[i]);
                    }
                    _valuePath = String.Join(Owner.PathSeparator.ToString(), splitValuePath);
                    return _valuePath;
                }
                else {
                    return String.Empty;
                }
            }
        }


        /// <devdoc>
        ///     The state for this TreeNode
        /// </devdoc>
        private StateBag ViewState {
            get {
                if (_viewState == null) {
                    _viewState = new StateBag();
                    if (_isTrackingViewState) {
                        ((IStateManager)_viewState).TrackViewState();
                    }
                }
                return _viewState;
            }
        }

        private void ApplyAttributeList(HtmlTextWriter writer, ArrayList list) {
            for (int i = 0; i < list.Count; i += 2) {
                object o = list[i];
                if (o is string) {
                    writer.AddAttribute((string)o, (string)list[i + 1]);
                }
                else {
                    writer.AddAttribute((HtmlTextWriterAttribute)o, (string)list[i + 1]);
                }
            }
        }


        /// <devdoc>
        ///     Collapses the current node
        /// </devdoc>
        public void Collapse() {
            Expanded = false;
        }


        /// <devdoc>
        ///     Collapse the current node and all children recursively
        /// </devdoc>
        public void CollapseAll() {
            SetExpandedRecursive(false);
        }


        /// <devdoc>
        ///     Expands the current node
        /// </devdoc>
        public void Expand() {
            Expanded = true;
        }


        /// <devdoc>
        ///     Expands the current node and all children recursively
        /// </devdoc>
        public void ExpandAll() {
            SetExpandedRecursive(true);
        }

        internal TreeNode GetParentInternal() {
            return _parent;
        }


        /// <devdoc>
        ///     Adds the href javascript for doing client-side node population
        /// </devdoc>
        private string GetPopulateNodeAttribute(HtmlTextWriter writer, string myId, string selectId, string selectImageId, string lineType, int depth, bool[] isLast) {
            string populateNodeAttributeValue = String.Empty;

            // In a callback population scenario, we need to know which node is last in
            // order to render lines or childNodesPadding properly
            if (_parentIsLast == null) {
                char[] parentIsLast = new char[depth + 1];
                for (int i = 0; i < depth + 1; i++) {
                    if (isLast[i]) {
                        parentIsLast[i] = 't';
                    }
                    else {
                        parentIsLast[i] = 'f';
                    }
                }
                _parentIsLast = new string(parentIsLast);
            }

            // function populateNode(data,index,node,lineType,text,path,databound,datapath)
            string indexString = Index.ToString(CultureInfo.InvariantCulture);
            if (_owner.IsNotIE) {
                populateNodeAttributeValue = "javascript:TreeView_PopulateNode(" +
                                             _owner.ClientDataObjectID + "," +
                                             indexString + "," +
                                             "document.getElementById('" + myId + "')," +
                                             "document.getElementById('" + selectId + "')," +
                                             ((selectImageId.Length == 0) ? "null" : ("document.getElementById('" + selectImageId + "')")) + "," +
                                             "'" + lineType + "'," +
                                             "'" + Util.QuoteJScriptString(Text, true) + "'," +
                                             "'" + Util.QuoteJScriptString(InternalValuePath, true) + "'," +
                                             "'" + (DataBound ? 't' : 'f') + "'," +
                                             "'" + Util.QuoteJScriptString(DataPath, true) + "','" +
                                             _parentIsLast + "')";
            }
            else {
                populateNodeAttributeValue = "javascript:TreeView_PopulateNode(" +
                                             _owner.ClientDataObjectID + "," +
                                             indexString + "," +
                                             myId + "," +
                                             selectId + "," +
                                             ((selectImageId.Length == 0) ? "null" : selectImageId) + "," +
                                             "'" + lineType + "'," +
                                             "'" + Util.QuoteJScriptString(Text, true) + "'," +
                                             "'" + Util.QuoteJScriptString(InternalValuePath, true) + "'," +
                                             "'" + (DataBound ? 't' : 'f') + "'," +
                                             "'" + Util.QuoteJScriptString(DataPath, true) + "','" +
                                             _parentIsLast + "')";
            }
            if (_owner.Page != null) {
                _owner.Page.ClientScript.RegisterForEventValidation(_owner.UniqueID,
                    String.Concat(indexString, Text, InternalValuePath, DataPath));
            }

            return populateNodeAttributeValue;
        }

        internal bool GetEffectiveShowCheckBox() {
            return GetEffectiveShowCheckBox(GetTreeNodeType());
        }

        private bool GetEffectiveShowCheckBox(TreeNodeTypes type) {
            if (ShowCheckBox == true) {
                return true;
            }
            if (ShowCheckBox == false) {
                return false;
            }
            return ((_owner.ShowCheckBoxes & type) != 0);
        }

        /// <devdoc>
        ///     Adds the href javascript for doing client-side node expand state toggling
        /// </devdoc>
        private string GetToggleNodeAttributeValue(string myId, string lineType) {
            Debug.Assert(ChildNodes.Count > 0, "No nodes for expansion, why are we rendering an expander?");
            if (_toggleNodeAttributeValue == null) {
                if (_owner.IsNotIE) {
                    _toggleNodeAttributeValue = "javascript:TreeView_ToggleNode(" +
                                                _owner.ClientDataObjectID + "," +
                                                Index.ToString(CultureInfo.InvariantCulture) + "," +
                                                "document.getElementById('" + myId + "')," +
                                                "'" + lineType + "'," +
                                                "document.getElementById('" + myId + "Nodes'))";
                }
                else {
                    _toggleNodeAttributeValue = "javascript:TreeView_ToggleNode(" +
                                                _owner.ClientDataObjectID + "," +
                                                Index.ToString(CultureInfo.InvariantCulture) + "," +
                                                myId + "," +
                                                "'" + lineType + "'," +
                                                myId + "Nodes)";
                }
            }

            return _toggleNodeAttributeValue;
        }

        private TreeNodeTypes GetTreeNodeType() {
            TreeNodeTypes type = TreeNodeTypes.Leaf;
            if ((Depth == 0) && (ChildNodes.Count > 0)) {
                type = TreeNodeTypes.Root;
            }
            else if ((ChildNodes.Count > 0) || PopulateOnDemand) {
                type = TreeNodeTypes.Parent;
            }
            return type;
        }

        private void NotifyOwnerChecked() {
            if (_owner == null) {
                _modifyCheckedNodes = true;
            }
            else {
                object o = ViewState["Checked"];
                if ((o != null) && ((bool)o == true)) {
                    TreeNodeCollection checkedNodes = _owner.CheckedNodes;
                    if (!checkedNodes.Contains(this)) {
                        _owner.CheckedNodes.Add(this);
                    }
                }
                else {
                    _owner.CheckedNodes.Remove(this);
                }
            }
        }


        /// <devdoc>
        ///     Fills in the children for the tree node.
        /// </devdoc>
        internal void Populate() {
            if (!Populated && (ChildNodes.Count == 0)) {
                if (_owner != null) {
                    _owner.PopulateNode(this);
                }
                // If the owner hasn't been determined yet, remember that we need to populate this node
                // when the owner actually does get set
                else {
                    _populateDesired = true;
                }
            }
        }


        /// <devdoc>
        ///     Renders the contents of the node and its children.  It uses the position and isLast parameters
        ///     to determine which lines and which kind of lines to render.
        /// </devdoc>
        internal void Render(HtmlTextWriter writer, int position, bool[] isLast, bool enabled) {
            string myId = String.Empty;
            Debug.Assert(Index != -1, "Didn't assign an index to a node.");
            myId = _owner.CreateNodeId(Index);

            int depth = Depth;
            bool last = false;
            if (depth > -1) {
                last = isLast[depth];
            }

            bool expanded = (Expanded == true);

            TreeNodeStyle mergedStyle = _owner.GetStyle(this);

            // <table cellpadding="0" cellspacing="0" border="0" height="nodespacing">
            writer.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
            writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
            writer.AddStyleAttribute(HtmlTextWriterStyle.BorderWidth, "0");
            writer.RenderBeginTag(HtmlTextWriterTag.Table);

            // Don't render the top spacing if this is the first root node
            if ((mergedStyle != null) && !mergedStyle.NodeSpacing.IsEmpty && ((depth != 0) || (position != 0))) {
                writer.AddStyleAttribute(HtmlTextWriterStyle.Height,
                    mergedStyle.NodeSpacing.ToString(CultureInfo.InvariantCulture));
                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.RenderEndTag();
                writer.RenderEndTag();
            }
            // <tr>
            writer.RenderBeginTag(HtmlTextWriterTag.Tr);

            // If this is not a root node, fill in the lines or indent space
            if (depth > 0) {
                for (int i = 0; i < depth; i++) {
                    if (writer is Html32TextWriter) {
                        // <td>
                        writer.RenderBeginTag(HtmlTextWriterTag.Td);
                        writer.AddStyleAttribute(HtmlTextWriterStyle.Width, _owner.NodeIndent.ToString(CultureInfo.InvariantCulture) + "px");
                        writer.RenderBeginTag(HtmlTextWriterTag.Table);
                        writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                        writer.RenderBeginTag(HtmlTextWriterTag.Td);
                        if (_owner.ShowLines && !isLast[i]) {
                            writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.GetImageUrl(TreeView.IImageIndex));
                            writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
                            writer.RenderBeginTag(HtmlTextWriterTag.Img);
                            writer.RenderEndTag();
                        }
                        writer.RenderEndTag();
                        writer.RenderEndTag();
                        writer.RenderEndTag();
                        // </td>
                        writer.RenderEndTag();
                    }
                    else {
                        // <td>
                        writer.RenderBeginTag(HtmlTextWriterTag.Td);
                        writer.Write("<div style=\"width:" + _owner.NodeIndent.ToString(CultureInfo.InvariantCulture) + "px;height:1px\">");
                        if (_owner.ShowLines && !isLast[i]) {
                            writer.AddAttribute(HtmlTextWriterAttribute.Src, _owner.GetImageUrl(TreeView.IImageIndex));
                            writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
                            writer.RenderBeginTag(HtmlTextWriterTag.Img);
                            writer.RenderEndTag();
                        }
                        writer.Write("</div>");
                        // </td>
                        writer.RenderEndTag();
                    }
                }
            }

            // A node can expand if its populate on demand or if it has children
            bool canExpand = (PopulateOnDemand || (ChildNodes.Count > 0)) && _owner.ShowExpandCollapse;

            string imageUrl = String.Empty;
            string lineType = " ";
            string imageToolTip = String.Empty;
            if (last) {
                if (canExpand) {
                    if (expanded) {
                        if (_owner.ShowLines) {
                            if (depth == 0) {
                                if (position == 0) {
                                    // The first and only root node
                                    lineType = "-";
                                    imageUrl = _owner.GetImageUrl(TreeView.DashMinusImageIndex);
                                    imageToolTip = _owner.CollapseImageToolTip;
                                }
                                else {
                                    // The last root node
                                    lineType = "l";
                                    imageUrl = _owner.GetImageUrl(TreeView.LMinusImageIndex);
                                    imageToolTip = _owner.CollapseImageToolTip;
                                }
                            }
                            else {
                                // The last node in a set of siblings
                                lineType = "l";
                                imageUrl = _owner.GetImageUrl(TreeView.LMinusImageIndex);
                                imageToolTip = _owner.CollapseImageToolTip;
                            }
                        }
                        else {
                            imageUrl = _owner.GetImageUrl(TreeView.MinusImageIndex);
                            imageToolTip = _owner.CollapseImageToolTip;
                        }
                    }
                    else {
                        if (_owner.ShowLines) {
                            if (depth == 0) {
                                if (position == 0) {
                                    // The first and only root node
                                    lineType = "-";
                                    imageUrl = _owner.GetImageUrl(TreeView.DashPlusImageIndex);
                                    imageToolTip = _owner.ExpandImageToolTip;
                                }
                                else {
                                    // The last root node
                                    lineType = "l";
                                    imageUrl = _owner.GetImageUrl(TreeView.LPlusImageIndex);
                                    imageToolTip = _owner.ExpandImageToolTip;
                                }
                            }
                            else {
                                // The last node in a set of sibling
                                lineType = "l";
                                imageUrl = _owner.GetImageUrl(TreeView.LPlusImageIndex);
                                imageToolTip = _owner.ExpandImageToolTip;
                            }
                        }
                        else {
                            imageUrl = _owner.GetImageUrl(TreeView.PlusImageIndex);
                            imageToolTip = _owner.ExpandImageToolTip;
                        }
                    }
                }
                else {
                    if (_owner.ShowLines) {
                        if (depth == 0) {
                            if (position == 0) {
                                // The first and only node, no children
                                lineType = "-";
                                imageUrl = _owner.GetImageUrl(TreeView.DashImageIndex);
                            }
                            else {
                                // The last root node, no children
                                lineType = "l";
                                imageUrl = _owner.GetImageUrl(TreeView.LImageIndex);
                            }
                        }
                        else {
                            // The last node in a set of siblings, no children
                            lineType = "l";
                            imageUrl = _owner.GetImageUrl(TreeView.LImageIndex);
                        }
                    }
                    else if (_owner.ShowExpandCollapse) {
                        imageUrl = _owner.GetImageUrl(TreeView.NoExpandImageIndex);
                    }
                }
            }
            else {
                if (canExpand) {
                    if (expanded) {
                        if (_owner.ShowLines) {
                            if (depth == 0) {
                                if (position == 0) {
                                    // The first root node
                                    lineType = "r";
                                    imageUrl = _owner.GetImageUrl(TreeView.RMinusImageIndex);
                                    imageToolTip = _owner.CollapseImageToolTip;
                                }
                                else {
                                    // A middle root node
                                    lineType = "t";
                                    imageUrl = _owner.GetImageUrl(TreeView.TMinusImageIndex);
                                    imageToolTip = _owner.CollapseImageToolTip;
                                }
                            }
                            else {
                                // A middle node
                                lineType = "t";
                                imageUrl = _owner.GetImageUrl(TreeView.TMinusImageIndex);
                                imageToolTip = _owner.CollapseImageToolTip;
                            }
                        }
                        else {
                            imageUrl = _owner.GetImageUrl(TreeView.MinusImageIndex);
                            imageToolTip = _owner.CollapseImageToolTip;
                        }
                    }
                    else {
                        if (_owner.ShowLines) {
                            if (depth == 0) {
                                if (position == 0) {
                                    // The first root node
                                    lineType = "r";
                                    imageUrl = _owner.GetImageUrl(TreeView.RPlusImageIndex);
                                    imageToolTip = _owner.ExpandImageToolTip;
                                }
                                else {
                                    // A middle root node
                                    lineType = "t";
                                    imageUrl = _owner.GetImageUrl(TreeView.TPlusImageIndex);
                                    imageToolTip = _owner.ExpandImageToolTip;
                                }
                            }
                            else {
                                // A middle node
                                lineType = "t";
                                imageUrl = _owner.GetImageUrl(TreeView.TPlusImageIndex);
                                imageToolTip = _owner.ExpandImageToolTip;
                            }
                        }
                        else {
                            imageUrl = _owner.GetImageUrl(TreeView.PlusImageIndex);
                            imageToolTip = _owner.ExpandImageToolTip;
                        }
                    }
                }
                else {
                    if (_owner.ShowLines) {
                        if (depth == 0) {
                            if (position == 0) {
                                // The first root node, no children
                                lineType = "r";
                                imageUrl = _owner.GetImageUrl(TreeView.RImageIndex);
                            }
                            else {
                                // A middle root node, no children
                                lineType = "t";
                                imageUrl = _owner.GetImageUrl(TreeView.TImageIndex);
                            }
                        }
                        else {
                            // A middle node, no children
                            lineType = "t";
                            imageUrl = _owner.GetImageUrl(TreeView.TImageIndex);
                        }
                    }
                    else if (_owner.ShowExpandCollapse) {
                        imageUrl = _owner.GetImageUrl(TreeView.NoExpandImageIndex);
                    }
                }
            }

            TreeNodeTypes type = GetTreeNodeType();

            // Figure out the proper node icon
            string nodeImageUrl = String.Empty;

            if (ImageUrl.Length > 0) {
                nodeImageUrl = _owner.ResolveClientUrl(ImageUrl);
            }
            else {
                if ((depth < _owner.LevelStyles.Count) && (_owner.LevelStyles[depth] != null) && mergedStyle.ImageUrl.Length > 0) {
                    nodeImageUrl = _owner.GetLevelImageUrl(depth);
                }
                else {
                    switch (type) {
                        case TreeNodeTypes.Root:
                            nodeImageUrl = _owner.GetImageUrl(TreeView.RootImageIndex);
                            break;
                        case TreeNodeTypes.Parent:
                            nodeImageUrl = _owner.GetImageUrl(TreeView.ParentImageIndex);
                            break;
                        case TreeNodeTypes.Leaf:
                            nodeImageUrl = _owner.GetImageUrl(TreeView.LeafImageIndex);
                            break;
                    }
                }
            }

            string selectImageId = String.Empty;
            if (nodeImageUrl.Length > 0) {
                selectImageId = SelectID + "i";
            }

            if (imageUrl.Length > 0) {
                // <td>
                writer.RenderBeginTag(HtmlTextWriterTag.Td);

                if (canExpand) {
                    // If we are using client script and there aren't any expand/collapse handlers attached, do all the toggling/populating
                    if (_owner.RenderClientScript && !_owner.CustomExpandCollapseHandlerExists) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Id, myId);

                        if (PopulateOnDemand) {
                            // If we are populating from the client, add all the needed attributes and call the client script needed to make the callback
                            if (_owner.PopulateNodesFromClient) {
                                if (ChildNodes.Count != 0) {
                                    throw new InvalidOperationException(SR.GetString(SR.TreeView_PopulateOnlyEmptyNodes, _owner.ID));
                                }
                                writer.AddAttribute(HtmlTextWriterAttribute.Href, GetPopulateNodeAttribute(writer, myId, SelectID, selectImageId, lineType, depth, isLast));
                            }
                            // If we aren't populating from the client, make a postback to do the population
                            else {
                                string href = "javascript:0";
                                if (_owner.Page != null) {
                                    href = _owner.Page.ClientScript.GetPostBackClientHyperlink(_owner,
                                        "t" + InternalValuePath, true, true);
                                }
                                writer.AddAttribute(HtmlTextWriterAttribute.Href, href);
                            }
                        }
                        else {
                            writer.AddAttribute(HtmlTextWriterAttribute.Href, GetToggleNodeAttributeValue(myId, lineType));
                        }
                    }
                    else {
                        string href = "javascript:0";
                        if (_owner.Page != null) {
                            href = _owner.Page.ClientScript.GetPostBackClientHyperlink(_owner, "t" + InternalValuePath, true);
                        }
                        // If we aren't using client script to perform expansions, get a postback reference
                        writer.AddAttribute(HtmlTextWriterAttribute.Href, href);
                    }

                    if (enabled == true) {
                        // <a href=href>
                        writer.RenderBeginTag(HtmlTextWriterTag.A);
                    }

                    writer.AddAttribute(HtmlTextWriterAttribute.Src, imageUrl);
                    writer.AddStyleAttribute(HtmlTextWriterStyle.BorderWidth, "0");
                    if (imageToolTip.Length > 0) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Alt,
                            String.Format(CultureInfo.CurrentCulture, imageToolTip, Text));
			            //fix bug 1197460, quirk it so the fix will only be enabled on projects on 4.6.1 or later version of framework
			            if (BinaryCompatibility.Current.TargetsAtLeastFramework461) {
                            writer.AddAttribute(HtmlTextWriterAttribute.Title,
                                String.Format(CultureInfo.CurrentCulture, imageToolTip, Text));
			            }
                    }
                    else {
                        writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
			            //fix bug 1197460, quirk it so the fix will only be enabled on projects on 4.6.1 or later version of framework
			            if (BinaryCompatibility.Current.TargetsAtLeastFramework461) {
                        	writer.AddAttribute(HtmlTextWriterAttribute.Title, String.Empty);
			            }
                    }
                    writer.RenderBeginTag(HtmlTextWriterTag.Img);
                    writer.RenderEndTag();

                    if (enabled == true) {
                        // </a>
                        writer.RenderEndTag();
                    }
                }
                else {
                    writer.AddAttribute(HtmlTextWriterAttribute.Src, imageUrl);
                    writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
                    writer.RenderBeginTag(HtmlTextWriterTag.Img);
                    writer.RenderEndTag();
                }

                // </td>
                writer.RenderEndTag();
            }

            // Since we need the same set of anchor attributes on both the image and the text
            // accumulate a list here first
            ArrayList anchorAttributes = new ArrayList();
            // If there is a navigation url on this node, set up the navigation stuff
            if (NavigateUrl.Length > 0) {
                // writer.AddAttribute(HtmlTextWriterAttribute.Href, _owner.ResolveClientUrl(NavigateUrl));
                anchorAttributes.Add(HtmlTextWriterAttribute.Href);
                anchorAttributes.Add(_owner.ResolveClientUrl(NavigateUrl));

                // Use the TreeNode Target if it has one, the TreeView's if it doesn't
                string target = ViewState["Target"] as string;
                if (target == null) {
                    target = _owner.Target;
                }

                if (target.Length > 0) {
                    // writer.AddAttribute(HtmlTextWriterAttribute.Target, Target);
                    anchorAttributes.Add(HtmlTextWriterAttribute.Target);
                    anchorAttributes.Add(target);

                    if (_owner.RenderClientScript) {
                        // Use client-script to merge in the selected node style
                        string onClick = String.Empty;
                        if (_owner.Page != null && _owner.Page.SupportsStyleSheets &&
                            (SelectAction == TreeNodeSelectAction.Select) || (SelectAction == TreeNodeSelectAction.SelectExpand)) {

                            onClick = Util.MergeScript(onClick,
                                "TreeView_SelectNode(" + _owner.ClientDataObjectID + 
                                    ", this,'" + SelectID + "');");
                        }

                        if ((SelectAction == TreeNodeSelectAction.Expand) || (SelectAction == TreeNodeSelectAction.SelectExpand)) {
                            if (PopulateOnDemand) {
                                // Postback to populate
                                // 
                                onClick = Util.MergeScript(onClick,
                                    _owner.Page.ClientScript.GetPostBackClientHyperlink(_owner, "t" + InternalValuePath, true, true));
                            }
                            else if (!_owner.CustomExpandCollapseHandlerExists && canExpand) {
                                onClick = Util.MergeScript(onClick, GetToggleNodeAttributeValue(myId, lineType));
                            }
                        }

                        // writer.AddAttribute("onclick", onClick);
                        if (onClick.Length != 0) {
                            anchorAttributes.Add("onclick");
                            anchorAttributes.Add(onClick);
                        }
                    }
                }
            }
            // Otherwise, write out a postback that will select the node
            else {
                // If client script is on, call the proper javascript and the select action is expand
                if (_owner.RenderClientScript && (SelectAction == TreeNodeSelectAction.Expand) && !_owner.CustomExpandCollapseHandlerExists) {
                    // and if the node is being populated on demand, and we are populating nodes from the client, call the populateNode javascript
                    if (PopulateOnDemand) {
                        if (_owner.PopulateNodesFromClient) {
                            // writer.AddAttribute(HtmlTextWriterAttribute.Href, GetPopulateNodeAttribute(writer, myId, SelectID, lineType, depth, isLast));
                            anchorAttributes.Add(HtmlTextWriterAttribute.Href);
                            anchorAttributes.Add(GetPopulateNodeAttribute(writer, myId, SelectID, selectImageId, lineType, depth, isLast));
                        }
                        else {
                            // If we're not populating from the client, postback to populate
                            // writer.AddAttribute(HtmlTextWriterAttribute.Href, _owner.Page.GetPostBackClientHyperlink(_owner, "t" + HttpUtility.HtmlEncode(InternalValuePath), true));
                            anchorAttributes.Add(HtmlTextWriterAttribute.Href);

                            string href = "javascript:0";
                            if (_owner.Page != null) {
                                href = _owner.Page.ClientScript.GetPostBackClientHyperlink(
                                    _owner, "t" + InternalValuePath, true, true);
                            }
                            anchorAttributes.Add(href);
                        }
                    }
                    else if (canExpand) {
                        // writer.AddAttribute(HtmlTextWriterAttribute.Href, GetToggleNodeAttributeValue(myId, lineType));
                        anchorAttributes.Add(HtmlTextWriterAttribute.Href);
                        anchorAttributes.Add(GetToggleNodeAttributeValue(myId, lineType));
                    }
                }
                // If not, just render an href for a postback
                else if (SelectAction != TreeNodeSelectAction.None) {
                    // writer.AddAttribute(HtmlTextWriterAttribute.Href, _owner.Page.GetPostBackClientHyperlink(_owner, "s" + HttpUtility.HtmlEncode(InternalValuePath), true));
                    anchorAttributes.Add(HtmlTextWriterAttribute.Href);

                    if (_owner.Page != null) {
                        string href = _owner.Page.ClientScript.GetPostBackClientHyperlink(
                            _owner, "s" + InternalValuePath, true, true);
                        anchorAttributes.Add(href);

                        if (_owner.RenderClientScript) {
                            anchorAttributes.Add("onclick");
                            anchorAttributes.Add("TreeView_SelectNode(" + _owner.ClientDataObjectID + 
                                ", this,'" + SelectID + "');");
                        }
                    }
                    else {
                        anchorAttributes.Add("javascript:0");
                    }
                }
            }

            if (ToolTip.Length > 0) {
                anchorAttributes.Add(HtmlTextWriterAttribute.Title);
                anchorAttributes.Add(ToolTip);
            }

            // Render out the node icon, if it is set
            if (nodeImageUrl.Length > 0) {
                // <td>
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                // <a>
                ApplyAttributeList(writer, anchorAttributes);

                // Set the id of the text hyperlink
                writer.AddAttribute(HtmlTextWriterAttribute.Id, selectImageId);

                if (enabled == true && SelectAction != TreeNodeSelectAction.None) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Tabindex, "-1");
                    writer.RenderBeginTag(HtmlTextWriterTag.A);
                }
                writer.AddAttribute(HtmlTextWriterAttribute.Src, nodeImageUrl);
                writer.AddStyleAttribute(HtmlTextWriterStyle.BorderWidth, "0");
                if (ImageToolTip.Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Alt, ImageToolTip);
		            //fix bug 1197460, quirk it so the fix will only be enabled on projects on 4.6.1 or later version of framework
	                if (BinaryCompatibility.Current.TargetsAtLeastFramework461) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Title, ImageToolTip);
		            }
                }
                else {
                    writer.AddAttribute(HtmlTextWriterAttribute.Alt, String.Empty);
		    	    //fix bug 1197460, quirk it so the fix will only be enabled on projects on 4.6.1 or later version of framework
			        if (BinaryCompatibility.Current.TargetsAtLeastFramework461) {
	                    writer.AddAttribute(HtmlTextWriterAttribute.Title, String.Empty);
			        }
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Img);
                writer.RenderEndTag();
                if (enabled == true && SelectAction != TreeNodeSelectAction.None) {
                    // </a>
                    writer.RenderEndTag();
                }
                // </td>
                writer.RenderEndTag();
            }

            // <td nowrap="nowrap">
            if (!_owner.NodeWrap) {
                writer.AddStyleAttribute(HtmlTextWriterStyle.WhiteSpace, "nowrap");
            }

            if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                string styleClass = _owner.GetCssClassName(this, false);
                if (styleClass.Trim().Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, styleClass);
                }
            }
            else {
                if (mergedStyle != null) {
                    mergedStyle.AddAttributesToRender(writer);
                }
            }

            if (_owner.EnableHover && (SelectAction != TreeNodeSelectAction.None)) {
                writer.AddAttribute("onmouseover", "TreeView_HoverNode(" + _owner.ClientDataObjectID + ", this)");
                writer.AddAttribute("onmouseout", "TreeView_UnhoverNode(this)");
            }

            writer.RenderBeginTag(HtmlTextWriterTag.Td);

            // Render a check box if we need to
            if (GetEffectiveShowCheckBox(type)) {
                writer.AddAttribute(HtmlTextWriterAttribute.Type, "checkbox");
                string id = myId + "CheckBox";
                writer.AddAttribute(HtmlTextWriterAttribute.Name, id);
                writer.AddAttribute(HtmlTextWriterAttribute.Id, id);  // VSWhidbey 497326: Render id for easier client-side scripting
                if (Checked) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Checked, "checked");
                }
                if (enabled == false) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Disabled, "disabled");
                    if (!_owner.Enabled && (_owner.RenderingCompatibility >= VersionUtil.Framework40) 
                        && !String.IsNullOrEmpty(WebControl.DisabledCssClass)) {
                        writer.AddAttribute(HtmlTextWriterAttribute.Class, WebControl.DisabledCssClass);
                    }
                }

                if (ToolTip.Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Title, ToolTip);
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Input);
                writer.RenderEndTag();
            }

            // Rendering hook for extended treeviews
            RenderPreText(writer);
            if (_owner.Page != null && _owner.Page.SupportsStyleSheets) {
                bool renderInlineBorder;
                string styleClass = _owner.GetCssClassName(this, true, out renderInlineBorder);
                if (styleClass.Trim().Length > 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, styleClass);
                    if (renderInlineBorder) {
                        // Add inline style to force the border to none to override any CssClass (VSWhidbey 336610)
                        writer.AddStyleAttribute(HtmlTextWriterStyle.BorderStyle, "none");
                        // And an inline font-size of 1em to avoid squaring relative font sizes by applying them twice
                        writer.AddStyleAttribute(HtmlTextWriterStyle.FontSize, "1em");
                    }
                }
            }
            else {
                if (mergedStyle != null) {
                    mergedStyle.HyperLinkStyle.AddAttributesToRender(writer);
                }
            }

            ApplyAttributeList(writer, anchorAttributes);
            writer.AddAttribute(HtmlTextWriterAttribute.Id, SelectID);

            if ((SelectAction == TreeNodeSelectAction.None) || !enabled) {
                // Render a span so that the styles get applied, with the ID so that POD works
                writer.RenderBeginTag(HtmlTextWriterTag.Span);
                // Render plain text if the select action was none
                writer.Write(Text);
                writer.RenderEndTag();
            }
            else {
                // AccessKey
                if (!_owner.AccessKeyRendered && _owner.AccessKey.Length != 0) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Accesskey, _owner.AccessKey, true);
                    _owner.AccessKeyRendered = true;
                }
                // <a href=href>
                writer.RenderBeginTag(HtmlTextWriterTag.A);
                writer.Write(Text);
                writer.RenderEndTag(); // </a>
            }
            // Rendering hook for extended treeviews
            RenderPostText(writer);

            // </td>
            writer.RenderEndTag();

            // </tr>
            writer.RenderEndTag();

            if ((mergedStyle != null) && !mergedStyle.NodeSpacing.IsEmpty) {
                writer.AddStyleAttribute(HtmlTextWriterStyle.Height, mergedStyle.NodeSpacing.ToString(CultureInfo.InvariantCulture));
                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.RenderEndTag();
                writer.RenderEndTag();
            }

            // </table>
            writer.RenderEndTag();

            // If children exist, maybe render them
            if (ChildNodes.Count > 0) {
                if (isLast.Length < depth + 2) {
                    bool[] newIsLast = new bool[depth + 5];
                    Array.Copy(isLast, 0, newIsLast, 0, isLast.Length);
                    isLast = newIsLast;
                }

                // If client script is enabled, always render the child nodes, and also render a div around the child nodes, with a 'display' style
                if (_owner.RenderClientScript) {
                    if (!expanded) {
                        writer.AddStyleAttribute("display", "none");
                    }
                    else {
                        writer.AddStyleAttribute("display", "block");
                    }
                    writer.AddAttribute(HtmlTextWriterAttribute.Id, myId + "Nodes");
                    writer.RenderBeginTag(HtmlTextWriterTag.Div);
                    RenderChildNodes(writer, depth, isLast, enabled);
                    writer.RenderEndTag();
                }
                // If client script is not enabled, only render the children if this node is expanded
                else {
                    if (expanded) {
                        RenderChildNodes(writer, depth, isLast, enabled);
                    }
                }
            }
        }


        /// <devdoc>
        ///     Renders the children nodes of the TreeNode
        /// </devdoc>
        internal void RenderChildNodes(HtmlTextWriter writer, int depth, bool[] isLast, bool enabled) {
            TreeNodeStyle mergedStyle = _owner.GetStyle(this);
            // Render the child nodes padding
            if (!mergedStyle.ChildNodesPadding.IsEmpty) {
                writer.AddAttribute(HtmlTextWriterAttribute.Height, mergedStyle.ChildNodesPadding.ToString(CultureInfo.InvariantCulture));
                writer.RenderBeginTag(HtmlTextWriterTag.Table);
                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.RenderEndTag();
                writer.RenderEndTag();
                writer.RenderEndTag();
            }

            for (int i = 0; i < ChildNodes.Count; i++) {
                TreeNode node = ChildNodes[i];
                isLast[depth + 1] = (i == ChildNodes.Count - 1);
                node.Render(writer, i, isLast, enabled);
            }

            // Render the child nodes padding only if there is another sibling node
            if (!isLast[depth] && !mergedStyle.ChildNodesPadding.IsEmpty) {
                writer.AddAttribute(HtmlTextWriterAttribute.Height, mergedStyle.ChildNodesPadding.ToString(CultureInfo.InvariantCulture));
                writer.RenderBeginTag(HtmlTextWriterTag.Table);
                writer.RenderBeginTag(HtmlTextWriterTag.Tr);
                writer.RenderBeginTag(HtmlTextWriterTag.Td);
                writer.RenderEndTag();
                writer.RenderEndTag();
                writer.RenderEndTag();
            }
        }

        protected virtual void RenderPostText(HtmlTextWriter writer) {
        }

        protected virtual void RenderPreText(HtmlTextWriter writer) {
        }

        internal void ResetValuePathRecursive() {
            if (_valuePath != null) {
                _valuePath = null;
                foreach (TreeNode child in ChildNodes) {
                    child.ResetValuePathRecursive();
                }
            }
        }


        /// <devdoc>
        ///     Selects the TreeNode
        /// </devdoc>
        public void Select() {
            Selected = true;
        }


        /// <devdoc>
        ///     Marks this node as a databound node
        /// </devdoc>
        internal void SetDataBound(bool dataBound) {
            ViewState["DataBound"] = dataBound;
        }


        /// <devdoc>
        ///     Used by ExpandAll and CollapseAll to recusively set all nodes' Expanded property to the specified value
        /// </devdoc>
        private void SetExpandedRecursive(bool value) {
            Expanded = value;
            if (ChildNodes.Count > 0) {
                for (int i = 0; i < ChildNodes.Count; i++) {
                    ChildNodes[i].SetExpandedRecursive(value);
                }
            }
        }


        /// <devdoc>
        ///     Sets the data item for use by the user in databinding
        /// </devdoc>
        internal void SetDataItem(object dataItem) {
            _dataItem = dataItem;
        }

        /// <devdoc>
        ///     Sets the data path for use by the TreeView in databinding
        /// </devdoc>
        internal void SetDataPath(string dataPath) {
            ViewState["DataPath"] = dataPath;
        }

        internal void SetDirty() {
            ViewState.SetDirty(true);

            if (ChildNodes.Count > 0) {
                ChildNodes.SetDirty();
            }
        }


        /// <devdoc>
        ///     Sets the owner TreeView of this node.
        /// </devdoc>
        internal void SetOwner(TreeView owner) {
            _owner = owner;

            if (_selectDesired == +1) {
                _selectDesired = 0;
                Selected = true;
            }
            else if (_selectDesired == -1) {
                _selectDesired = 0;
                Selected = false;
            }

            if (_populateDesired) {
                _populateDesired = false;
                Populate();
            }

            if (_modifyCheckedNodes) {
                if (_owner != null) {
                    _modifyCheckedNodes = false;

                    if (Checked) {
                        TreeNodeCollection checkedNodes = _owner.CheckedNodes;
                        if (!checkedNodes.Contains(this)) {
                            _owner.CheckedNodes.Add(this);
                        }
                    }
                    else {
                        _owner.CheckedNodes.Remove(this);
                    }
                }
            }

            foreach (TreeNode node in ChildNodes) {
                node.SetOwner(_owner);
            }
        }


        /// <devdoc>
        ///     Sets the parent TreeNode of the node
        /// </devdoc>
        internal void SetParent(TreeNode parent) {
            _parent = parent;
            SetPath(null);
        }


        /// <devdoc>
        ///     Sets the path of the node (without reparenting).  Used in the PopulateNodesFromClient scenario.
        /// </devdoc>
        internal void SetPath(string newPath) {
            _internalValuePath = newPath;
            _depth = -2;
        }

        internal void SetSelected(bool value) {
            ViewState["Selected"] = value;
            // If the owner hasn't been set, remember that we want to select this node
            // when the owner is determined
            if (_owner == null) {
                _selectDesired = (value ? +1 : -1);
            }
        }

        /// <devdoc>
        ///     Switches the expand state of the node
        /// </devdoc>
        public void ToggleExpandState() {
            Expanded = !(Expanded == true);
        }

        #region IStateManager implementation

        /// <internalonly/>
        bool IStateManager.IsTrackingViewState {
            get {
                return IsTrackingViewState;
            }
        }

        protected bool IsTrackingViewState {
            get {
                return _isTrackingViewState;
            }
        }


        /// <internalonly/>
        void IStateManager.LoadViewState(object state) {
            LoadViewState(state);
        }

        protected virtual void LoadViewState(object state) {
            object[] nodeState = (object[])state;

            if (nodeState != null) {
                if (nodeState[0] != null) {
                    ((IStateManager)ViewState).LoadViewState(nodeState[0]);
                    NotifyOwnerChecked();
                }

                if (nodeState[1] != null) {
                    ((IStateManager)ChildNodes).LoadViewState(nodeState[1]);
                }
            }
        }


        /// <internalonly/>
        object IStateManager.SaveViewState() {
            return SaveViewState();
        }

        protected virtual object SaveViewState() {
            object[] state = new object[2];
            if (_viewState != null) {
                state[0] = ((IStateManager)_viewState).SaveViewState();
            }

            if (_childNodes != null) {
                state[1] = ((IStateManager)_childNodes).SaveViewState();
            }

            if ((state[0] == null) && (state[1] == null)) {
                return null;
            }

            return state;
        }


        /// <internalonly/>
        void IStateManager.TrackViewState() {
            TrackViewState();
        }

        protected void TrackViewState() {
            _isTrackingViewState = true;

            if (_viewState != null) {
                ((IStateManager)_viewState).TrackViewState();
            }

            if (_childNodes != null) {
                ((IStateManager)_childNodes).TrackViewState();
            }
        }
        #endregion

        #region ICloneable implementation

        /// <internalonly/>
        object ICloneable.Clone() {
            return Clone();
        }

        protected virtual object Clone() {
            TreeNode newNode = new TreeNode();
            newNode.Checked = Checked;
            newNode.Expanded = Expanded;
            newNode.ImageUrl = ImageUrl;
            newNode.ImageToolTip = ImageToolTip;
            newNode.NavigateUrl = NavigateUrl;
            newNode.PopulateOnDemand = PopulateOnDemand;
            newNode.SelectAction = SelectAction;
            newNode.Selected = Selected;
            if (ViewState["ShowCheckBox"] != null) {
                newNode.ShowCheckBox = ShowCheckBox;
            }
            newNode.Target = Target;
            newNode.Text = Text;
            newNode.ToolTip = ToolTip;
            newNode.Value = Value;

            return newNode;
        }
        #endregion
    }
}