using System;

 using System.Collections.Generic;

 using System.Drawing;

 using System.Windows.Forms;

 using DevExpress.XtraBars;

 using DevExpress.XtraTreeList;

 using DevExpress.XtraTreeList.Nodes;

 namespace DevExpressUtilHelpV3

 {

   public static class TreeListToolV3

   {

     public delegate string BuildPathRule(string nodeText, string fullPathInfo);

     /// <summary>

     /// 获取选中节点到根节点的所有信息

     /// </summary>

     /// <param name="focusedNode">TreeListNode</param>

     /// <param name="columnID">列名称</param>

     /// <param name="buildPathRule">规则委托</param>

     /// <returns>路径信息</returns>

     public static string FullPathInfo(this TreeListNode focusedNode, string columnID, BuildPathRule buildPathRule)

     {

       if (focusedNode == null)

         throw new ArgumentNullException("focusedNode");

       if (string.IsNullOrEmpty("columnID"))

         throw new ArgumentNullException("columnID");

       string _fullPathInfo = string.Empty;

       _fullPathInfo = focusedNode.GetDisplayText(columnID);

       while (focusedNode.ParentNode != null)

       {

         focusedNode = focusedNode.ParentNode;

         string _nodeText = focusedNode.GetDisplayText(columnID).Trim();

         _fullPathInfo = buildPathRule(_nodeText, _fullPathInfo);

       }

       return _fullPathInfo;

     }

     public delegate bool CompareNodeRule(TreeListNode focusedNode);

     /// <summary>

     /// 获取筛选节点到根节点的所有信息

     /// </summary>

     /// <param name="focusedNode">TreeListNode</param>

     /// <param name="columnID">列名称</param>

     /// <param name="compareNodeRule">规则委托</param>

     /// <param name="buildPathRule">规则委托</param>

     /// <returns>路径信息</returns>

     public static string FilterPathInfo(this TreeListNode focusedNode, string columnID, CompareNodeRule compareNodeRule, BuildPathRule buildPathRule)

     {

       if (focusedNode == null)

         throw new ArgumentNullException("focusedNode");

       if (string.IsNullOrEmpty("columnID"))

         throw new ArgumentNullException("columnID");

       string _fullPathInfo = string.Empty;

       _fullPathInfo = focusedNode.GetDisplayText(columnID);

       while (focusedNode.ParentNode != null)

       {

         focusedNode = focusedNode.ParentNode;

         if (compareNodeRule(focusedNode))

         {

           string _nodeText = focusedNode.GetDisplayText(columnID).Trim();

           _fullPathInfo = buildPathRule(_nodeText, _fullPathInfo);

         }

       }

       return _fullPathInfo;

     }

     /// <summary>

     /// 递归遍历树节点

     /// </summary>

     /// <param name="tree"></param>

     /// <param name="opreateRule"></param>

     public static void LoopTree(this TreeList tree, Action<TreeListNode> opreateRule)

     {

       if (tree == null)

         throw new ArgumentNullException("tree");

       foreach (TreeListNode node in tree.Nodes)

       {

         opreateRule(node);

         if (node.Nodes.Count > )

         {

           LoopTreeNodes(node, opreateRule);

         }

       }

     }

     /// <summary>

     /// 递归遍历TreeListNode节点

     /// </summary>

     /// <param name="node"></param>

     /// <param name="opreateRule"></param>

     public static void LoopTreeNodes(this TreeListNode node, Action<TreeListNode> opreateRule)

     {

       if (node == null)

         throw new ArgumentNullException("node");

       foreach (TreeListNode _childNode in node.Nodes)

   {

   opreateRule(_childNode);

   LoopTreeNodes(_childNode, opreateRule);

   }

   }

 /// <summary>

 /// 递归遍历TreeListNode,当opreateRule返回false停止循环

 /// </summary>

 /// <param name="node">TreeListNode</param>

 /// <param name="opreateRule">Func<TreeListNode, bool></param>

 public static void LoopTreeNodes_Break(this TreeListNode node, Func<TreeListNode, bool> opreateRule)

   {

 if (node == null)

 throw new ArgumentNullException("node");

 foreach (TreeListNode _childNode in node.Nodes)

   {

 if (!opreateRule(_childNode))

 break;

   LoopTreeNodes_Break(_childNode, opreateRule);

   }

   }

 /// <summary>

 /// 递归遍历TreeListNode,当opreateRule返回false跳出循环，直接进入下次循环

 /// </summary>

 /// <param name="node">TreeListNode</param>

 /// <param name="opreateRule">Func<TreeListNode, bool></param>

 public static void LoopTreeNodes_Continue(this TreeListNode node, Func<TreeListNode, bool> opreateRule)

   {

 if (node == null)

 throw new ArgumentNullException("node");

 foreach (TreeListNode _childNode in node.Nodes)

   {

 if (!opreateRule(_childNode))

 continue;

   LoopTreeNodes_Continue(_childNode, opreateRule);

   }

   }

 public delegate bool CheckNodeRule(TreeListNode fucusedNode);

 public delegate void CheckNodeNullRule();

 /// <summary>

 /// 节点为null检查

 /// </summary>

 /// <param name="fucusedNode">TreeListNode</param>

 /// <param name="checkNodeRule">若为NULL,处理逻辑</param>

 /// <returns>TreeListNode</returns>

 public static TreeListNode CheckNull(this TreeListNode fucusedNode, CheckNodeNullRule checkNodeRule)

   {

 if (fucusedNode == null)

   {

   checkNodeRule();

 return null;

   }

 return fucusedNode;

   }

 /// <summary>

 /// 正对节点的检查逻辑

 /// </summary>

 /// <param name="fucusedNode">TreeListNode</param>

 /// <param name="checkNodeRule">检查逻辑代码[委托]</param>

 /// <returns>TreeListNode</returns>

 public static TreeListNode Check(this TreeListNode fucusedNode, CheckNodeRule checkNodeRule)

   {

 if (fucusedNode != null)

 return checkNodeRule(fucusedNode) == true ? fucusedNode : null;

 return null;

   }

 /// <summary>

 /// 水平滚动条

 /// </summary>

 /// <param name="tree">TreeList</param>

 public static void HorzScroll(this TreeList tree)

   {

 if (tree == null)

 throw new ArgumentNullException("tree");

   tree.OptionsView.AutoWidth = false;

   tree.BestFitColumns();

   tree.HorzScrollVisibility = ScrollVisibility.Always;

   }

 /// <summary>

 /// 为TreeList附加右键菜单

 /// MouseUp(object sender, MouseEventArgs e)事件中调用

 /// </summary>

 /// <param name="tree">TreeList</param>

 /// <param name="e">MouseEventArgs</param>

 /// <param name="menu">PopupMenu</param>

 /// <param name="attachMenuRule">AttachMenuRule</param>

 public static void AttachMenu(this TreeList tree, MouseEventArgs e, PopupMenu menu, Func<TreeListNode, bool> attachMenuRule)

   {

 if (tree == null)

 throw new ArgumentNullException("tree");

 if (menu == null)

 throw new ArgumentNullException("menu");

 if (e.Button == MouseButtons.Right && Control.ModifierKeys == Keys.None && tree.State == TreeListState.Regular)

   {

   Point _point = new Point(Cursor.Position.X, Cursor.Position.Y);

   TreeListHitInfo _hitInfo = tree.CalcHitInfo(e.Location);

 if (_hitInfo.HitInfoType == HitInfoType.Cell)

   tree.SetFocusedNode(_hitInfo.Node);

 if (attachMenuRule(tree.FocusedNode))

   menu.ShowPopup(_point);

   }

   }

 /// <summary>

 /// 设置父节点的状态AfterCheckNode(object sender, NodeEventArgs e)

 /// </summary>

 /// <param name="node"></param>

 /// <param name="check"></param>

 public static void ProcessNodeCheckState(this TreeListNode node, CheckState check)

   {

 if (node == null)

 throw new ArgumentNullException("node");

   SetCheckedChildNodes(node, check);

   SetCheckedParentNodes(node, check);

   }

 /// <summary>

 /// 设置子节点CheckState

 /// </summary>

 /// <param name="node"></param>

 /// <param name="check"></param>

 private static void SetCheckedChildNodes(TreeListNode node, CheckState check)

   {

 if (node != null)

   {

   node.LoopTreeNodes((TreeListNode _node) =>

   {

   _node.CheckState = check;

   });

   }

   }

 /// <summary>

 /// 设置父节点CheckState

 /// </summary>

 /// <param name="node"></param>

 /// <param name="check"></param>

 private static void SetCheckedParentNodes(TreeListNode node, CheckState check)

   {

 if (node.ParentNode != null)

   {

 bool _checkStatus = false;

   CheckState _nodeState;

   node.LoopTreeNodes_Break((TreeListNode _node) =>

   {

   _nodeState = _node.CheckState;

 if (!check.Equals(_nodeState))

   {

   _checkStatus = !_checkStatus;

 return false;//跳出循环

   }

 return true;//继续循环

   });

   node.ParentNode.CheckState = _checkStatus ? CheckState.Indeterminate : check;

   SetCheckedParentNodes(node.ParentNode, check);

   }

   }

 /// <summary>

 /// 根据CheckState获取TreeListNode

 /// </summary>

 /// <param name="tree">TreeList</param>

 /// <param name="state">CheckState</param>

 /// <param name="GetNodesByStateRule">返回True的时候继续</param>

 /// <returns>TreeListNode集合</returns>

 public static List<TreeListNode> GetNodesByState(this TreeList tree, CheckState state, Func<TreeListNode, bool> GetNodesByStateRule)

   {

 if (tree == null)

 throw new ArgumentNullException("tree");

   List<TreeListNode> _checkNodes = new List<TreeListNode>();

   tree.LoopTree((TreeListNode node) =>

   {

 if (GetNodesByStateRule(node))

   {

 if (node.CheckState == state)

   _checkNodes.Add(node);

   }

   });

 return _checkNodes;

   }

   }

 }