zoukankan      html  css  js  c++  java
  • TreeList

    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 > 0)
            {
              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;
        }
      }
    }
  • 相关阅读:
    ubuntu远程windows桌面
    spring boot 给返回值加状态 BaseData
    spring boot 拦截异常 统一处理
    IntelliJ IDEA spring boot 远程Ddbug调试
    IntelliJ IDEA 常用插件
    spring boot 请求地址带有.json 兼容处理
    spring boot 接口返回值去掉为null的字段
    spring boot 集成disconf
    Spring boot 自定义拦截器
    Linux下安装MySQL
  • 原文地址:https://www.cnblogs.com/liushunli/p/4188021.html
Copyright © 2011-2022 走看看