FolderTree.cs :  » Network-Clients » IZWebFileManager » IZ » WebFileManager » C# / CSharp Open Source

// Copyright (C) 2006 Igor Zelmanovich <izwebfilemanager@gmail.com>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Globalization;
using IZ.WebFileManager.Components;
using System.IO;
using System.Drawing;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Collections;

namespace IZ.WebFileManager{
  [SupportsEventValidation]
  [DefaultProperty ("Text")]
  [ToolboxData ("<{0}:FolderTree runat=\"server\"></{0}:FolderTree>")]
  public sealed class FolderTree : FileManagerControlBase, ICallbackEventHandler
  {
    #region Constructors

    public FolderTree ()
      : base () {
      InitTreeView ();
    }

    public FolderTree (FileManagerController controller)
      : base (controller) {
      InitTreeView ();
    }

    public FolderTree (FileManagerController controller, FileView fileFiew)
      : this (controller) {
      _fileView = fileFiew;
    }

    #endregion

    #region Fields
    FileView _fileView;

    bool stylesPrepared;
    Style hoverNodeStyle;
    TreeNodeStyle nodeStyle;
    TreeNodeStyle selectedNodeStyle;
    Collection<FolderNode> _nodes;
    Style controlLinkStyle;
    Style nodeLinkStyle;
    Style selectedNodeLinkStyle;
    Style hoverNodeLinkStyle;
    int _registeredStylesCounter = -1;
    Dictionary<Style, string> _registeredStyleClassNames;
    #endregion

    #region Events
    public EventHandler SelectedFolderChanged;
    #endregion

    #region Properties

    // TODO
    string SelectedPath {
      get { return null; }
    }

    [DefaultValue ("")]
    [Description ("The url of the image to show when a node can be collapsed.")]
    [UrlProperty]
    [Category ("Appearance")]
    string CollapseImageUrl {
      get {
        return (string) (ViewState ["CollapseImageUrl"] ?? String.Empty);
      }
      set {
        ViewState ["CollapseImageUrl"] = value;
      }
    }

    [DefaultValue ("")]
    [UrlProperty]
    [Description ("The url of the image to show when a node can be expanded.")]
    [Category ("Appearance")]
    string ExpandImageUrl {
      get {
        return (string) (ViewState ["ExpandImageUrl"] ?? String.Empty);
      }
      set {
        ViewState ["ExpandImageUrl"] = value;
      }
    }

    [PersistenceMode (PersistenceMode.InnerProperty)]
    [NotifyParentProperty (true)]
    [DefaultValue (null)]
    [Category ("Styles")]
    [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
    Style HoverNodeStyle {
      get {
        if (hoverNodeStyle == null) {
          hoverNodeStyle = new Style ();
          if (IsTrackingViewState)
            ((IStateManager) hoverNodeStyle).TrackViewState ();
        }
        return hoverNodeStyle;
      }
    }

    [DefaultValue (20)]
    int NodeIndent {
      get {
        return (int) (ViewState ["NodeIndent"] ?? 20);
      }
      set {
        ViewState ["NodeIndent"] = value;
      }
    }

    Collection<FolderNode> Nodes {
      get {
        if (_nodes == null) {
          _nodes = new Collection<FolderNode> ();
        }
        return _nodes;
      }
    }

    [PersistenceMode (PersistenceMode.InnerProperty)]
    [NotifyParentProperty (true)]
    [DefaultValue (null)]
    [Category ("Styles")]
    [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
    TreeNodeStyle NodeStyle {
      get {
        if (nodeStyle == null) {
          nodeStyle = new TreeNodeStyle ();
          if (IsTrackingViewState)
            ((IStateManager) nodeStyle).TrackViewState ();
        }
        return nodeStyle;
      }
    }

    [UrlProperty]
    [DefaultValue ("")]
    [Description ("The url of the image to show for leaf nodes.")]
    [Category ("Appearance")]
    string NoExpandImageUrl {
      get {
        return (string) (ViewState ["NoExpandImageUrl"] ?? String.Empty);
      }
      set {
        ViewState ["NoExpandImageUrl"] = value;
      }
    }

    char PathSeparator {
      get {
        return '/';
      }
    }

    string ClientScriptReference {
      get {
        if (_fileView != null)
          return FileManagerController.ClientScriptObjectNamePrefix + _fileView.ClientID + "_FolderTree";
        return FileManagerController.ClientScriptObjectNamePrefix + ClientID;
      }
    }

    [PersistenceMode (PersistenceMode.InnerProperty)]
    [NotifyParentProperty (true)]
    [DefaultValue (null)]
    [Category ("Styles")]
    [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
    TreeNodeStyle SelectedNodeStyle {
      get {
        if (selectedNodeStyle == null) {
          selectedNodeStyle = new TreeNodeStyle ();
          if (IsTrackingViewState)
            ((IStateManager) selectedNodeStyle).TrackViewState ();
        }
        return selectedNodeStyle;
      }
    }

    Style ControlLinkStyle {
      get {
        if (controlLinkStyle == null) {
          controlLinkStyle = new Style ();
          controlLinkStyle.Font.Underline = false;
          //controlLinkStyle.AlwaysRenderTextDecoration = true;
        }
        return controlLinkStyle;
      }
    }

    Style NodeLinkStyle {
      get {
        if (nodeLinkStyle == null) {
          nodeLinkStyle = new Style ();
        }
        return nodeLinkStyle;
      }
    }

    Style SelectedNodeLinkStyle {
      get {
        if (selectedNodeLinkStyle == null) {
          selectedNodeLinkStyle = new Style ();
        }
        return selectedNodeLinkStyle;
      }
    }

    Style HoverNodeLinkStyle {
      get {
        if (hoverNodeLinkStyle == null) {
          hoverNodeLinkStyle = new Style ();
        }
        return hoverNodeLinkStyle;
      }
    }

    [DefaultValue (false)]
    bool ShowLines {
      get {
        return (bool) (ViewState ["ShowLines"] ?? false);
      }
      set {
        ViewState ["ShowLines"] = value;
      }
    }

    protected override HtmlTextWriterTag TagKey {
      get { return HtmlTextWriterTag.Div; }
    }

    #endregion

    #region  Methods

    protected override void AddAttributesToRender (HtmlTextWriter writer) {
      base.AddAttributesToRender (writer);

      writer.AddStyleAttribute (HtmlTextWriterStyle.Position, "relative");
      writer.AddStyleAttribute (HtmlTextWriterStyle.ZIndex, "20");
      writer.AddStyleAttribute (HtmlTextWriterStyle.Overflow, "auto");
    }

    void InitTreeView () {
      NodeStyle.HorizontalPadding = 4;
      NodeStyle.Height = 20;
      NodeStyle.ForeColor = Color.Black;
      NodeStyle.Font.Names = new string [] { "Tahoma", "Verdana", "Geneva", "Arial", "Helvetica", "sans-serif" };
      NodeStyle.Font.Size = FontUnit.Parse ("11px", null);
      HoverNodeStyle.Font.Underline = true;
      SelectedNodeStyle.Font.Underline = false;
      SelectedNodeStyle.ForeColor = Color.White;
      SelectedNodeStyle.BackColor = Color.FromArgb (0x316AC5);
    }

    void OnSelectedFolderChanged (object sender, EventArgs e) {
      if (SelectedFolderChanged != null)
        SelectedFolderChanged (this, EventArgs.Empty);
    }

    void OnFolderPopulate (FolderNode node) {
      Controller.EnsureDefaults ();

      DirectoryInfo directoryInfo = Controller.ResolveFileManagerItemInfo (node.ValuePath).Directory;
      if (!directoryInfo.Exists)
        return;

      DirectoryProvider provider = new DirectoryProvider (directoryInfo, SortMode.Name, SortDirection.Ascending);

      foreach (DirectoryInfo dir in provider.GetFileSystemInfos (DirectoryProvider.FileSystemInfosFilter.Directories)) {

        FileViewItem item = new FileViewItem (dir, this);
        if (!ShowHiddenFilesAndFolders && item.Hidden)
          continue;
        
        FolderNode treeNode = new FolderNode (this);
        node.ChildNodes.Add (treeNode);
        treeNode.Text = dir.Name;
        treeNode.Hidden = item.Hidden;
        treeNode.ImageUrl = Controller.GetFolderSmallImage (dir);
        if (_fileView != null)
          treeNode.NavigateUrl = "javascript:WFM_" + _fileView.ClientID + ".Navigate(\"" + treeNode.ValuePath + "\");";
      }
    }

    void BuildTree () {

      for (int i = 0; i < RootDirectories.Count; i++) {
        RootDirectory rootDir = RootDirectories [i];
        FolderNode treeNode = new FolderNode (this);
        Nodes.Add (treeNode);
        treeNode.ImageUrl = Controller.GetRootFolderSmallImage (rootDir);
        SetText (rootDir, treeNode, i);
        treeNode.Value = PathSeparator + rootDir.TextInternal;
        if (_fileView != null)
          treeNode.NavigateUrl = "javascript:WFM_" + _fileView.ClientID + ".Navigate(\"" + treeNode.ValuePath + "\");";
      }

      for (int i = 0; i < RootDirectories.Count; i++)
        ExpandRecursive (Nodes [i], RootDirectories [i].ExpandDepth);

    }

    void SetText (RootDirectory rootDir, FolderNode treeNode, int index) {
      if (rootDir.ShowRootIndex)
        treeNode.Text = String.Format (CultureInfo.InvariantCulture, "{0} ([{1}])", rootDir.TextInternal, index);
      else
        treeNode.Text = rootDir.TextInternal;
    }

    void ExpandRecursive (FolderNode treeNode, int dept) {
      if (dept == 0)
        return;

      treeNode.Expand ();
      foreach (FolderNode child in treeNode.ChildNodes)
        ExpandRecursive (child, dept - 1);
    }

    #endregion

    protected override void TrackViewState () {

      base.TrackViewState ();
      if (hoverNodeStyle != null) {
        ((IStateManager) hoverNodeStyle).TrackViewState ();
      }
      if (nodeStyle != null) {
        ((IStateManager) nodeStyle).TrackViewState ();
      }
      if (selectedNodeStyle != null) {
        ((IStateManager) selectedNodeStyle).TrackViewState ();
      }
    }

    protected override object SaveViewState () {
      object [] states = new object [4];
      states [0] = base.SaveViewState ();
      states [1] = (hoverNodeStyle == null ? null : ((IStateManager) hoverNodeStyle).SaveViewState ());
      states [2] = (nodeStyle == null ? null : ((IStateManager) nodeStyle).SaveViewState ());
      states [3] = (selectedNodeStyle == null ? null : ((IStateManager) selectedNodeStyle).SaveViewState ());

      for (int i = states.Length - 1; i >= 0; i--) {
        if (states [i] != null)
          return states;
      }

      return null;
    }

    protected override void LoadViewState (object savedState) {
      if (savedState == null)
        return;

      object [] states = (object []) savedState;
      base.LoadViewState (states [0]);

      if (states [1] != null)
        ((IStateManager) HoverNodeStyle).LoadViewState (states [1]);
      if (states [2] != null)
        ((IStateManager) NodeStyle).LoadViewState (states [2]);
      if (states [3] != null)
        ((IStateManager) SelectedNodeStyle).LoadViewState (states [3]);
    }

    string callbackResult;

    void ICallbackEventHandler.RaiseCallbackEvent (string eventArgs) {
      int index = eventArgs.IndexOf ('|');
      FolderNode node = new FolderNode (this);
      node.ValuePath = eventArgs.Substring (index + 1);

      node.Expand ();
      int num = node.ChildNodes.Count;
      if (num == 0) {
        callbackResult = "*";
        return;
      }

      ArrayList levelLines = new ArrayList ();
      for (int i = 0; i < index; i++)
        levelLines.Add (eventArgs [i] == '1' ? this : null);

      StringBuilder sb = new StringBuilder ();
      HtmlTextWriter writer = new HtmlTextWriter (new StringWriter (sb));
      EnsureStylesPrepared ();

      for (int n = 0; n < num; n++)
        RenderNode (writer, node.ChildNodes [n], index, levelLines, true, n < num - 1);

      callbackResult = sb.ToString ();
    }

    string ICallbackEventHandler.GetCallbackResult () {
      return callbackResult;
    }

    protected override ControlCollection CreateControlCollection () {
      return new EmptyControlCollection (this);
    }

    protected override void OnPreRender (EventArgs e) {
      base.OnPreRender (e);

      if (Page.Header == null)
        throw new InvalidOperationException ("Using FolderTree requires Page.Header to be non-null (e.g. <head runat=\"server\" />).");

      Page.ClientScript.RegisterClientScriptResource (typeof (FolderTree), "IZ.WebFileManager.resources.FolderTree.js");
      string callbackScript = string.Format ("FolderTree.prototype.PopulateNode = function(argument, clientCallback, context, clientErrorCallback) {{ {0}; }};\n", Page.ClientScript.GetCallbackEventReference ("this._uniqueId", "argument", "clientCallback", "context", "clientErrorCallback", true));
      Page.ClientScript.RegisterClientScriptBlock (typeof (FolderTree), "FolderTree.prototype.PopulateNode", callbackScript, true);

      string folderTree = ClientScriptReference;
      StringBuilder script = new StringBuilder ();
      script.AppendLine ("var " + folderTree + "= new FolderTree ('" + Controller.ClientID + "','" + ClientID + "','" + UniqueID + "','" + GetNodeImageUrl ("Expand") + "','" + GetNodeImageUrl ("Collapse") + "','" + GetNodeImageUrl ("NoExpand") + "');");

      EnsureStylesPrepared ();

      if (selectedNodeStyle != null) {
        script.AppendFormat ("{0}._selectedClass = '{1}';\n", folderTree, _registeredStyleClassNames [SelectedNodeStyle]);
        script.AppendFormat ("{0}._selectedLinkClass = '{1}';\n", folderTree, _registeredStyleClassNames [SelectedNodeLinkStyle]);
      }

      if (hoverNodeStyle != null) {
        script.AppendFormat ("{0}._hoverClass = '{1}';\n", folderTree, _registeredStyleClassNames [HoverNodeStyle]);
        script.AppendFormat ("{0}._hoverLinkClass = '{1}';\n", folderTree, _registeredStyleClassNames [HoverNodeLinkStyle]);
      }
      if (_fileView != null)
        script.AppendLine (folderTree + ".Navigate (['" + String.Join ("','", Controller.GetPathHashCodes (_fileView.CurrentDirectory.FileManagerPath)) + "'],0);");

      Page.ClientScript.RegisterStartupScript (typeof (FolderTree), this.ClientID, script.ToString (), true);

      BuildTree ();
    }

    void EnsureStylesPrepared () {
      if (stylesPrepared)
        return;
      stylesPrepared = true;
      PrepareStyles ();
    }

    private void PrepareStyles () {
      _registeredStyleClassNames = new Dictionary<Style, string> ();

      ControlLinkStyle.Font.CopyFrom (ControlStyle.Font);
      ControlLinkStyle.ForeColor = ControlStyle.ForeColor;
      RegisterStyle (ControlLinkStyle);

      if (nodeStyle != null)
        RegisterStyle (NodeStyle, NodeLinkStyle);

      if (selectedNodeStyle != null)
        RegisterStyle (SelectedNodeStyle, SelectedNodeLinkStyle);

      if (hoverNodeStyle != null)
        RegisterStyle (HoverNodeStyle, HoverNodeLinkStyle);
    }

    void RegisterStyle (Style baseStyle, Style linkStyle) {
      linkStyle.Font.CopyFrom (baseStyle.Font);
      linkStyle.ForeColor = baseStyle.ForeColor;
      linkStyle.BorderStyle = BorderStyle.None;
      baseStyle.Font.ClearDefaults ();
      RegisterStyle (linkStyle);
      RegisterStyle (baseStyle);
    }

    string IncrementStyleClassName () {
      _registeredStylesCounter++;
      return ClientID + "_" + _registeredStylesCounter;
    }

    void RegisterStyle (Style baseStyle) {
      string className = IncrementStyleClassName ();
      Page.Header.StyleSheet.CreateStyleRule (baseStyle, this, "." + className);
      _registeredStyleClassNames [baseStyle] = className;
    }

    string GetBindingKey (string dataMember, int depth) {
      return dataMember + " " + depth;
    }

    protected override void RenderContents (HtmlTextWriter writer) {
      int num = Nodes.Count;
      for (int n = 0; n < num; n++)
        RenderNode (writer, Nodes [n], 0, new ArrayList (), n > 0, n < num - 1);
    }

    void RenderNode (HtmlTextWriter writer, FolderNode node, int level, ArrayList levelLines, bool hasPrevious, bool hasNext) {
      string nodeImage;

      bool hasChildNodes = node.Expanded ? node.ChildNodes.Count > 0 : true;
      if (hasNext)
        levelLines.Add (this);
      else
        levelLines.Add (null);

      writer.AddAttribute ("cellpadding", "0", false);
      writer.AddAttribute ("cellspacing", "0", false);
      writer.AddStyleAttribute ("border-width", "0");
      writer.RenderBeginTag (HtmlTextWriterTag.Table);

      Unit nodeSpacing = GetNodeSpacing (node);

      if (nodeSpacing != Unit.Empty && (node.Depth > 0 || node.Index > 0))
        RenderMenuItemSpacing (writer, nodeSpacing);

      writer.RenderBeginTag (HtmlTextWriterTag.Tr);

      // Vertical lines from previous levels

      nodeImage = GetNodeImageUrl ("I");
      for (int n = 0; n < level; n++) {
        writer.RenderBeginTag (HtmlTextWriterTag.Td);
        writer.AddStyleAttribute ("width", NodeIndent + "px");
        //writer.AddStyleAttribute ("height", "1px");
        writer.RenderBeginTag (HtmlTextWriterTag.Div);
        if (ShowLines && levelLines [n] != null) {
          writer.AddAttribute ("src", nodeImage);
          writer.AddAttribute (HtmlTextWriterAttribute.Alt, "", false);
          writer.RenderBeginTag (HtmlTextWriterTag.Img);
          writer.RenderEndTag ();
        }
        writer.RenderEndTag ();
        writer.RenderEndTag ();  // TD
      }

      // Node image + line

      string shape = String.Empty;

      if (ShowLines) {
        if (hasPrevious && hasNext)
          shape = "T";
        else if (hasPrevious && !hasNext)
          shape = "L";
        else if (!hasPrevious && hasNext)
          shape = "R";
        else
          shape = "Dash";
      }

      if (hasChildNodes) {
        if (node.Expanded)
          shape += "Collapse";
        else
          shape += "Expand";
      }
      else if (!ShowLines)
        shape = "NoExpand";

      if (!String.IsNullOrEmpty (shape)) {
        nodeImage = GetNodeImageUrl (shape);
        writer.RenderBeginTag (HtmlTextWriterTag.Td);  // TD

        writer.AddAttribute (HtmlTextWriterAttribute.Href, GetClientExpandEvent (node));
        writer.RenderBeginTag (HtmlTextWriterTag.A);  // Anchor

        writer.AddAttribute ("alt", String.Empty);

        writer.AddAttribute (HtmlTextWriterAttribute.Id, GetNodeClientId (node, "img"));
        writer.AddAttribute ("src", nodeImage);
        writer.AddStyleAttribute (HtmlTextWriterStyle.BorderWidth, "0");
        writer.RenderBeginTag (HtmlTextWriterTag.Img);
        writer.RenderEndTag ();

        writer.RenderEndTag ();    // Anchor

        writer.RenderEndTag ();    // TD
      }

      writer.RenderBeginTag (HtmlTextWriterTag.Td);
      writer.AddAttribute ("onmouseout", ClientScriptReference + ".UnhoverNode(this)", false);
      writer.AddAttribute ("onmouseover", ClientScriptReference + ".HoverNode(this, event)", false);
      writer.AddAttribute (HtmlTextWriterAttribute.Id, GetNodeClientId (node, null));
      writer.RenderBeginTag (HtmlTextWriterTag.Div);
      writer.AddAttribute ("cellpadding", "0", false);
      writer.AddAttribute ("cellspacing", "0", false);
      writer.AddStyleAttribute ("border-width", "0");
      writer.RenderBeginTag (HtmlTextWriterTag.Table);
      writer.RenderBeginTag (HtmlTextWriterTag.Tr);

      // Node icon

      string imageUrl = node.ImageUrl.Length > 0 ? ResolveClientUrl (node.ImageUrl) : null;

      if (!String.IsNullOrEmpty (imageUrl)) {
        if (node.Hidden)
          Controller.HiddenItemStyle.AddAttributesToRender (writer);
        writer.RenderBeginTag (HtmlTextWriterTag.Td);  // TD
        BeginNodeTag (writer, node);
        writer.AddAttribute ("src", imageUrl);
        writer.AddStyleAttribute (HtmlTextWriterStyle.BorderWidth, "0");
        writer.AddAttribute ("alt", String.Empty);
        writer.RenderBeginTag (HtmlTextWriterTag.Img);
        writer.RenderEndTag ();  // IMG
        writer.RenderEndTag ();  // node tag
        writer.RenderEndTag ();  // TD
      }

      writer.AddStyleAttribute ("white-space", "nowrap");
      AddNodeStyle (writer, node, level);

      writer.AddAttribute ("nodepath", GetNodePath (node, levelLines));
      writer.AddAttribute (HtmlTextWriterAttribute.Id, GetNodeClientId (node, "node"));

      writer.RenderBeginTag (HtmlTextWriterTag.Td);  // TD

      AddNodeLinkStyle (writer, node, level);
      BeginNodeTag (writer, node);
      writer.Write (node.Text);
      writer.RenderEndTag ();  // node tag

      writer.RenderEndTag ();  // TD

      writer.RenderEndTag (); // TR
      writer.RenderEndTag (); // TABLE
      writer.RenderEndTag (); // DIV
      writer.RenderEndTag (); // TD

      writer.RenderEndTag ();  // TR

      if (nodeSpacing != Unit.Empty)
        RenderMenuItemSpacing (writer, nodeSpacing);

      writer.RenderEndTag ();  // TABLE

      // Children

      if (!node.Expanded || node.ChildNodes.Count == 0)
        writer.AddStyleAttribute ("display", "none");
      else
        writer.AddStyleAttribute ("display", "block");
      writer.AddAttribute (HtmlTextWriterAttribute.Id, GetNodeClientId (node, "span"));
      writer.RenderBeginTag (HtmlTextWriterTag.Span);

      if (node.Expanded) {
        //AddChildrenPadding (writer, node);
        int num = node.ChildNodes.Count;
        if (num == 0)
          writer.Write ("*");
        else
          for (int n = 0; n < num; n++)
            RenderNode (writer, node.ChildNodes [n], level + 1, levelLines, true, n < num - 1);
        //if (hasNext)
        //    AddChildrenPadding (writer, node);
      }
      writer.RenderEndTag ();  // SPAN

      levelLines.RemoveAt (level);
    }

    //private void AddChildrenPadding (HtmlTextWriter writer, FolderNode node) {
    //    int level = node.Depth;
    //    Unit cnp = Unit.Empty;

    //    if (cnp.IsEmpty && nodeStyle != null)
    //        cnp = nodeStyle.ChildNodesPadding;

    //    double value;
    //    if (cnp.IsEmpty || (value = cnp.Value) == 0 || cnp.Type != UnitType.Pixel)
    //        return;

    //    writer.RenderBeginTag (HtmlTextWriterTag.Table);
    //    writer.AddAttribute ("height", ((int) value).ToString (), false);
    //    writer.RenderBeginTag (HtmlTextWriterTag.Tr);
    //    writer.RenderBeginTag (HtmlTextWriterTag.Td);
    //    writer.RenderEndTag (); // td
    //    writer.RenderEndTag (); // tr
    //    writer.RenderEndTag (); // table
    //}

    private void RenderMenuItemSpacing (HtmlTextWriter writer, Unit itemSpacing) {
      writer.AddStyleAttribute ("height", itemSpacing.ToString ());
      writer.RenderBeginTag (HtmlTextWriterTag.Tr);
      writer.RenderBeginTag (HtmlTextWriterTag.Td);
      writer.RenderEndTag ();
      writer.RenderEndTag ();
    }

    private Unit GetNodeSpacing (FolderNode node) {
      if (node.Selected && selectedNodeStyle != null && selectedNodeStyle.NodeSpacing != Unit.Empty)
        return selectedNodeStyle.NodeSpacing;
      if (nodeStyle != null)
        return nodeStyle.NodeSpacing;
      else
        return Unit.Empty;
    }

    void AddNodeStyle (HtmlTextWriter writer, FolderNode node, int level) {
      StringBuilder sb = new StringBuilder ();
      if (nodeStyle != null) {
        sb.Append (" ");
        sb.Append (nodeStyle.CssClass);
        sb.Append (" ");
        sb.Append (_registeredStyleClassNames [nodeStyle]);
      }
      if (node.ValuePath == SelectedPath && selectedNodeStyle != null) {
        sb.Append (" ");
        sb.Append (selectedNodeStyle.CssClass);
        sb.Append (" ");
        sb.Append (_registeredStyleClassNames [selectedNodeStyle]);
      }
      writer.AddAttribute (HtmlTextWriterAttribute.Class, sb.ToString ());
    }

    void AddNodeLinkStyle (HtmlTextWriter writer, FolderNode node, int level) {
      StringBuilder sb = new StringBuilder ();
      sb.Append (" ");
      sb.Append (_registeredStyleClassNames [ControlLinkStyle]);

      if (nodeStyle != null) {
        sb.Append (" ");
        sb.Append (nodeLinkStyle.CssClass);
        sb.Append (" ");
        sb.Append (_registeredStyleClassNames [nodeLinkStyle]);
      }
      if (node.ValuePath == SelectedPath && selectedNodeStyle != null) {
        sb.Append (" ");
        sb.Append (selectedNodeLinkStyle.CssClass);
        sb.Append (" ");
        sb.Append (_registeredStyleClassNames [selectedNodeLinkStyle]);
      }
      writer.AddAttribute (HtmlTextWriterAttribute.Class, sb.ToString ());
    }

    void BeginNodeTag (HtmlTextWriter writer, FolderNode node) {
      if (node.ToolTip.Length > 0)
        writer.AddAttribute ("title", node.ToolTip);

      if (!String.IsNullOrEmpty (node.NavigateUrl)) {
        string navUrl = ResolveClientUrl (node.NavigateUrl);
        writer.AddAttribute ("href", navUrl);
        writer.RenderBeginTag (HtmlTextWriterTag.A);
      }
      else
        writer.RenderBeginTag (HtmlTextWriterTag.Span);
    }

    string GetNodeClientId (FolderNode node, string sufix) {
      return ClientID + "_" + node.ClientID + (sufix != null ? "_" + sufix : "");
    }

    string GetNodeImageUrl (string shape) {
      if (!ShowLines) {
        if (shape == "Expand") {
          if (!String.IsNullOrEmpty (ExpandImageUrl))
            return ResolveClientUrl (ExpandImageUrl);
        }
        else if (shape == "Collapse") {
          if (!String.IsNullOrEmpty (CollapseImageUrl))
            return ResolveClientUrl (CollapseImageUrl);
        }
        else if (shape == "NoExpand") {
          if (!String.IsNullOrEmpty (NoExpandImageUrl))
            return ResolveClientUrl (NoExpandImageUrl);
        }
      }
      return Page.ClientScript.GetWebResourceUrl (typeof (Page), "TreeView_Default_" + shape + ".gif");
    }

    string GetNodeIconUrl (string icon) {
      return Page.ClientScript.GetWebResourceUrl (typeof (TreeView), icon + ".gif");
    }

    string GetClientExpandEvent (FolderNode node) {
      return "javascript:" + ClientScriptReference + ".ToggleExpand (\"" + node.ClientID + "\")";
    }

    string GetNodePath (FolderNode node, ArrayList levelLines) {
      StringBuilder arg = new StringBuilder ();
      for (int i = 0; i < levelLines.Count; i++)
        if (levelLines [i] == null)
          arg.Append ('0');
        else
          arg.Append ('1');
      arg.Append ('|');
      arg.Append (node.ValuePath);
      return arg.ToString ();
    }

    sealed class FolderNode
    {
      Collection<FolderNode> _nodes;
      readonly FolderTree _owner;
      FolderNode _parent;
      int _index = -1;
      int _depth = -1;
      string _clientId;
      string _valuePath;
      string _imageUrl;
      string _navigateUrl;
      string _value;
      string _text;
      string _tooltip;
      bool _expanded;
      bool _selected;
      bool _hidden;

      public FolderNode (FolderTree owner) {
        _owner = owner;
      }

      [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
      [Browsable (false)]
      public int Depth {
        get {
          if (_depth != -1)
            return _depth;
          _depth = 0;
          FolderNode node = _parent;
          while (node != null) {
            _depth++;
            node = node.Parent;
          }
          return _depth;
        }
      }

      public Collection<FolderNode> ChildNodes {
        get {
          if (_nodes == null) {
            _nodes = new FolderNodeCollection (this);
          }
          return _nodes;
        }
      }

      public bool Expanded {
        get { return _expanded; }
      }
      
      public bool Hidden {
        get { return _hidden; }
        set { _hidden = value; }
      }

      public string ImageUrl {
        get { return _imageUrl ?? String.Empty; }
        set { _imageUrl = value; }
      }

      public string NavigateUrl {
        get { return _navigateUrl ?? String.Empty; }
        set { _navigateUrl = value; }
      }

      public string Text {
        get { return _text ?? (_value ?? String.Empty); }
        set { _text = value; }
      }

      public string ToolTip {
        get { return _tooltip ?? String.Empty; }
        set { _tooltip = value; }
      }

      public string Value {
        get { return _value ?? (_text ?? String.Empty); }
        set { _value = value; }
      }

      [DefaultValue (false)]
      public bool Selected {
        get { return _selected; }
        set { _selected = value; }
      }

      [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
      [Browsable (false)]
      public FolderNode Parent {
        get { return _parent; }
      }

      [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
      [Browsable (false)]
      public string ValuePath {
        get {
          if (_owner == null)
            return Value;
          if (_valuePath == null) {
            StringBuilder sb = new StringBuilder (Value);
            FolderNode node = Parent;
            if (node != null) {
              sb.Insert (0, _owner.PathSeparator);
              sb.Insert (0, node.ValuePath);
              node = node.Parent;
            }
            _valuePath = sb.ToString ();
          }
          return _valuePath;
        }
        set {
          _valuePath = value;
        }
      }

      internal int Index {
        get {
          if (_index < 0) {
            _index = 0;
            if (Parent != null)
              _index = Parent.ChildNodes.IndexOf (this);
          }
          return _index;
        }
      }

      internal void SetParent (FolderNode node) {
        _parent = node;
        _index = -1;
        _depth = -1;
        _clientId = null;
        _valuePath = null;
      }

      internal string ClientID {
        get {
          if (_clientId == null) {
            _clientId = _owner.Controller.GetPathHashCode (ValuePath);
          }
          return _clientId;
        }
      }

      public void Expand () {
        if (Expanded)
          return;
        _expanded = true;
        _owner.OnFolderPopulate (this);
      }
    }

    class FolderNodeCollection : Collection<FolderNode>
    {
      readonly FolderNode _owner;

      public FolderNodeCollection (FolderNode owner) {
        _owner = owner;
      }

      protected override void InsertItem (int index, FolderNode item) {
        base.InsertItem (index, item);
        item.SetParent (_owner);
      }

      protected override void SetItem (int index, FolderNode item) {
        base.SetItem (index, item);
        item.SetParent (_owner);
      }
    }

  }
}