Added STNodeEditor and translated to english

CodeWalker.WinForms/STNodeEditor/FrmNodePreviewPanel.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace ST.Library.UI.NodeEditor
+{
+    internal class FrmNodePreviewPanel : Form
+    {
+        public Color BorderColor { get; set; }
+        public bool AutoBorderColor { get; set; }
+
+        private bool m_bRight;
+        private Point m_ptHandle;
+        private int m_nHandleSize;
+        private Rectangle m_rect_handle;
+        private Rectangle m_rect_panel;
+        private Rectangle m_rect_exclude;
+        private Region m_region;
+        private Type m_type;
+        private STNode m_node;
+        private STNodeEditor m_editor;
+        private STNodePropertyGrid m_property;
+
+        private Pen m_pen = new Pen(Color.Black);
+        private SolidBrush m_brush = new SolidBrush(Color.Black);
+        private static FrmNodePreviewPanel m_last_frm;
+
+        [DllImport("user32.dll")]
+        private static extern int SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool bRedraw);
+
+        public FrmNodePreviewPanel(Type stNodeType, Point ptHandle, int nHandleSize, bool bRight, STNodeEditor editor, STNodePropertyGrid propertyGrid) {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+
+            if (m_last_frm != null) m_last_frm.Close();
+            m_last_frm = this;
+
+            m_editor = editor;
+            m_property = propertyGrid;
+            m_editor.Size = new Size(200, 200);
+            m_property.Size = new Size(200, 200);
+            m_editor.Location = new Point(1 + (bRight ? nHandleSize : 0), 1);
+            m_property.Location = new Point(m_editor.Right, 1);
+            m_property.InfoFirstOnDraw = true;
+            this.Controls.Add(m_editor);
+            this.Controls.Add(m_property);
+            this.ShowInTaskbar = false;
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
+            this.Size = new Size(402 + nHandleSize, 202);
+
+            m_type = stNodeType;
+            m_ptHandle = ptHandle;
+            m_nHandleSize = nHandleSize;
+            m_bRight = bRight;
+
+            this.AutoBorderColor = true;
+            this.BorderColor = Color.DodgerBlue;
+        }
+
+        protected override void OnLoad(EventArgs e) {
+            base.OnLoad(e);
+            m_node = (STNode)Activator.CreateInstance(m_type);
+            m_node.Left = 20; m_node.Top = 20;
+            m_editor.Nodes.Add(m_node);
+            m_property.SetNode(m_node);
+
+            m_rect_panel = new Rectangle(0, 0, 402, 202);
+            m_rect_handle = new Rectangle(m_ptHandle.X, m_ptHandle.Y, m_nHandleSize, m_nHandleSize);
+            m_rect_exclude = new Rectangle(0, m_nHandleSize, m_nHandleSize, this.Height - m_nHandleSize);
+            if (m_bRight) {
+                this.Left = m_ptHandle.X;
+                m_rect_panel.X = m_ptHandle.X + m_nHandleSize;
+            } else {
+                this.Left = m_ptHandle.X - this.Width + m_nHandleSize;
+                m_rect_exclude.X = this.Width - m_nHandleSize;
+                m_rect_panel.X = this.Left;
+            }
+            if (m_ptHandle.Y + this.Height > Screen.GetWorkingArea(this).Bottom) {
+                this.Top = m_ptHandle.Y - this.Height + m_nHandleSize;
+                m_rect_exclude.Y -= m_nHandleSize;
+            } else this.Top = m_ptHandle.Y;
+            m_rect_panel.Y = this.Top;
+            m_region = new Region(new Rectangle(Point.Empty, this.Size));
+            m_region.Exclude(m_rect_exclude);
+            using (Graphics g = this.CreateGraphics()) {
+                IntPtr h = m_region.GetHrgn(g);
+                FrmNodePreviewPanel.SetWindowRgn(this.Handle, h, false);
+                m_region.ReleaseHrgn(h);
+            }
+
+            this.MouseLeave += Event_MouseLeave;
+            m_editor.MouseLeave += Event_MouseLeave;
+            m_property.MouseLeave += Event_MouseLeave;
+            this.BeginInvoke(new MethodInvoker(() => {
+                m_property.Focus();
+            }));
+        }
+
+        protected override void OnClosing(CancelEventArgs e) {
+            base.OnClosing(e);
+            this.Controls.Clear();
+            m_editor.Nodes.Clear();
+            m_editor.MouseLeave -= Event_MouseLeave;
+            m_property.MouseLeave -= Event_MouseLeave;
+            m_last_frm = null;
+        }
+
+        void Event_MouseLeave(object sender, EventArgs e) {
+            Point pt = Control.MousePosition;
+            if (m_rect_panel.Contains(pt) || m_rect_handle.Contains(pt)) return;
+            this.Close();
+        }
+
+        protected override void OnPaint(PaintEventArgs e) {
+            base.OnPaint(e);
+            Graphics g = e.Graphics;
+            m_pen.Color = this.AutoBorderColor ? m_node.TitleColor : this.BorderColor;
+            m_brush.Color = m_pen.Color;
+            g.DrawRectangle(m_pen, 0, 0, this.Width - 1, this.Height - 1);
+            g.FillRectangle(m_brush, m_rect_exclude.X - 1, m_rect_exclude.Y - 1, m_rect_exclude.Width + 2, m_rect_exclude.Height + 2);
+
+            Rectangle rect = this.RectangleToClient(m_rect_handle);
+            rect.Y = (m_nHandleSize - 14) / 2;
+            rect.X += rect.Y + 1;
+            rect.Width = rect.Height = 14;
+            m_pen.Width = 2;
+            g.DrawLine(m_pen, rect.X + 4, rect.Y + 3, rect.X + 10, rect.Y + 3);
+            g.DrawLine(m_pen, rect.X + 4, rect.Y + 6, rect.X + 10, rect.Y + 6);
+            g.DrawLine(m_pen, rect.X + 4, rect.Y + 11, rect.X + 10, rect.Y + 11);
+            g.DrawLine(m_pen, rect.X + 7, rect.Y + 7, rect.X + 7, rect.Y + 10);
+            m_pen.Width = 1;
+            g.DrawRectangle(m_pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/FrmSTNodePropertyInput.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Windows.Forms;
+using System.Drawing;
+using ST.Library.UI.NodeEditor;
+
+namespace ST.Library.UI
+{
+    internal class FrmSTNodePropertyInput : Form
+    {
+        private STNodePropertyDescriptor m_descriptor;
+        private Rectangle m_rect;
+        private Pen m_pen;
+        private SolidBrush m_brush;
+        private TextBox m_tbx;
+
+        public FrmSTNodePropertyInput(STNodePropertyDescriptor descriptor) {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+
+            m_rect = descriptor.RectangleR;
+            m_descriptor = descriptor;
+            this.ShowInTaskbar = false;
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
+            this.BackColor = descriptor.Control.AutoColor ? descriptor.Node.TitleColor : descriptor.Control.ItemSelectedColor;
+            m_pen = new Pen(descriptor.Control.ForeColor, 1);
+            m_brush = new SolidBrush(this.BackColor);
+        }
+
+        protected override void OnLoad(EventArgs e) {
+            base.OnLoad(e);
+            Point pt = m_descriptor.Control.PointToScreen(m_rect.Location);
+            pt.Y += m_descriptor.Control.ScrollOffset;
+            this.Location = pt;
+            this.Size = new System.Drawing.Size(m_rect.Width + m_rect.Height, m_rect.Height);
+
+            m_tbx = new TextBox();
+            m_tbx.Font = m_descriptor.Control.Font;
+            m_tbx.ForeColor = m_descriptor.Control.ForeColor;
+            m_tbx.BackColor = Color.FromArgb(255, m_descriptor.Control.ItemValueBackColor);
+            m_tbx.BorderStyle = BorderStyle.None;
+
+            m_tbx.Size = new Size(this.Width - 4 - m_rect.Height, this.Height - 2);
+            m_tbx.Text = m_descriptor.GetStringFromValue();
+            this.Controls.Add(m_tbx);
+            m_tbx.Location = new Point(2, (this.Height - m_tbx.Height) / 2);
+            m_tbx.SelectAll();
+            m_tbx.LostFocus += (s, ea) => this.Close();
+            m_tbx.KeyDown += new KeyEventHandler(tbx_KeyDown);
+        }
+
+        protected override void OnPaint(PaintEventArgs e) {
+            base.OnPaint(e);
+            Graphics g = e.Graphics;
+            m_brush.Color = m_tbx.BackColor;
+            g.FillRectangle(m_brush, 1, 1, this.Width - 2 - m_rect.Height, this.Height - 2);
+            m_brush.Color = m_descriptor.Control.ForeColor;
+            //Enter
+            g.FillPolygon(m_brush, new Point[]{
+                new Point(this.Width - 21, this.Height - 2),
+                new Point(this.Width - 14, this.Height - 2),
+                new Point(this.Width - 14, this.Height - 8)
+            });
+            g.DrawLine(m_pen, this.Width - 14, this.Height - 3, this.Width - 4, this.Height - 3);
+            g.DrawLine(m_pen, this.Width - 4, this.Height - 3, this.Width - 4, 14);
+            g.DrawLine(m_pen, this.Width - 8, 13, this.Width - 4, 13);
+            //----
+            g.DrawLine(m_pen, this.Width - 19, 11, this.Width - 4, 11);
+            //E
+            g.DrawLine(m_pen, this.Width - 19, 3, this.Width - 16, 3);
+            g.DrawLine(m_pen, this.Width - 19, 6, this.Width - 16, 6);
+            g.DrawLine(m_pen, this.Width - 19, 9, this.Width - 16, 9);
+            g.DrawLine(m_pen, this.Width - 19, 3, this.Width - 19, 9);
+            //S
+            g.DrawLine(m_pen, this.Width - 13, 3, this.Width - 10, 3);
+            g.DrawLine(m_pen, this.Width - 13, 6, this.Width - 10, 6);
+            g.DrawLine(m_pen, this.Width - 13, 9, this.Width - 10, 9);
+            g.DrawLine(m_pen, this.Width - 13, 3, this.Width - 13, 6);
+            g.DrawLine(m_pen, this.Width - 10, 6, this.Width - 10, 9);
+            //C
+            g.DrawLine(m_pen, this.Width - 7, 3, this.Width - 4, 3);
+            g.DrawLine(m_pen, this.Width - 7, 9, this.Width - 4, 9);
+            g.DrawLine(m_pen, this.Width - 7, 3, this.Width - 7, 9);
+        }
+
+        void tbx_KeyDown(object sender, KeyEventArgs e) {
+            if (e.KeyCode == Keys.Escape) this.Close();
+            if (e.KeyCode != Keys.Enter) return;
+            try {
+                m_descriptor.SetValue(((TextBox)sender).Text, null);
+                m_descriptor.Control.Invalidate();//add rect;
+            } catch (Exception ex) {
+                m_descriptor.OnSetValueError(ex);
+            }
+            this.Close();
+        }
+
+        private void InitializeComponent() {
+            this.SuspendLayout();
+            // 
+            // FrmSTNodePropertyInput
+            // 
+            this.ClientSize = new System.Drawing.Size(292, 273);
+            this.Name = "FrmSTNodePropertyInput";
+            this.ResumeLayout(false);
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/FrmSTNodePropertySelect.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Windows.Forms;
+using System.Drawing;
+
+namespace ST.Library.UI.NodeEditor
+{
+    internal class FrmSTNodePropertySelect : Form
+    {
+        private STNodePropertyDescriptor m_descriptor;
+        private int m_nItemHeight = 25;
+
+        private static Type m_t_bool = typeof(bool);
+        private Pen m_pen;
+        private SolidBrush m_brush;
+        private StringFormat m_sf;
+        private Color m_clr_item_1 = Color.FromArgb(10, 0, 0, 0);// Color.FromArgb(255, 40, 40, 40);
+        private Color m_clr_item_2 = Color.FromArgb(10, 255, 255, 255);// Color.FromArgb(255, 50, 50, 50);
+        private object m_item_hover;
+
+        public FrmSTNodePropertySelect(STNodePropertyDescriptor descriptor) {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+
+            m_descriptor = descriptor;
+            this.Size = descriptor.RectangleR.Size;
+            this.ShowInTaskbar = false;
+            this.BackColor = descriptor.Control.BackColor;
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
+            m_pen = new Pen(descriptor.Control.AutoColor ? descriptor.Node.TitleColor : descriptor.Control.ItemSelectedColor, 1);
+            m_brush = new SolidBrush(this.BackColor);
+            m_sf = new StringFormat();
+            m_sf.LineAlignment = StringAlignment.Center;
+            m_sf.FormatFlags = StringFormatFlags.NoWrap;
+        }
+
+        private List<object> m_lst_item = new List<object>();
+
+        protected override void OnLoad(EventArgs e) {
+            base.OnLoad(e);
+            Point pt = m_descriptor.Control.PointToScreen(m_descriptor.RectangleR.Location);
+            pt.Y += m_descriptor.Control.ScrollOffset;
+            this.Location = pt;
+            if (m_descriptor.PropertyInfo.PropertyType.IsEnum) {
+                foreach (var v in Enum.GetValues(m_descriptor.PropertyInfo.PropertyType)) m_lst_item.Add(v);
+            } else if (m_descriptor.PropertyInfo.PropertyType == m_t_bool) {
+                m_lst_item.Add(true);
+                m_lst_item.Add(false);
+            } else {
+                this.Close();
+                return;
+            }
+            this.Height = m_lst_item.Count * m_nItemHeight;
+            Rectangle rect = Screen.GetWorkingArea(this);
+            if (this.Bottom > rect.Bottom) this.Top -= (this.Bottom - rect.Bottom);
+            this.MouseLeave += (s, ea) => this.Close();
+            this.LostFocus += (s, ea) => this.Close();
+        }
+
+        protected override void OnPaint(PaintEventArgs e) {
+            base.OnPaint(e);
+            Graphics g = e.Graphics;
+            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
+            Rectangle rect_back = new Rectangle(0, 0, this.Width, m_nItemHeight);
+            Rectangle rect_font = new Rectangle(10, 0, this.Width - 13, m_nItemHeight);
+            int nIndex = 0;
+            string strVal = m_descriptor.GetStringFromValue();
+            foreach (var v in m_lst_item) {
+                m_brush.Color = nIndex++ % 2 == 0 ? m_clr_item_1 : m_clr_item_2;
+                g.FillRectangle(m_brush, rect_back);
+                if (v == m_item_hover) {
+                    m_brush.Color = m_descriptor.Control.ItemHoverColor;
+                    g.FillRectangle(m_brush, rect_back);
+                }
+                if (v.ToString() == strVal) {
+                    m_brush.Color = m_descriptor.Control.ItemSelectedColor;
+                    g.FillRectangle(m_brush, 4, rect_back.Top + 10, 5, 5);
+                }
+                m_brush.Color = m_descriptor.Control.ForeColor;
+                g.DrawString(v.ToString(), m_descriptor.Control.Font, m_brush, rect_font, m_sf);
+                rect_back.Y += m_nItemHeight;
+                rect_font.Y += m_nItemHeight;
+            }
+            g.DrawRectangle(m_pen, 0, 0, this.Width - 1, this.Height - 1);
+        }
+
+        protected override void OnMouseMove(MouseEventArgs e) {
+            base.OnMouseMove(e);
+            int nIndex = e.Y / m_nItemHeight;
+            if (nIndex < 0 || nIndex >= m_lst_item.Count) return;
+            var item = m_lst_item[e.Y / m_nItemHeight];
+            if (m_item_hover == item) return;
+            m_item_hover = item;
+            this.Invalidate();
+        }
+
+        protected override void OnMouseClick(MouseEventArgs e) {
+            base.OnMouseClick(e);
+            this.Close();
+            int nIndex = e.Y / m_nItemHeight;
+            if (nIndex < 0) return;
+            if (nIndex > m_lst_item.Count) return;
+            try {
+                m_descriptor.SetValue(m_lst_item[nIndex], null);
+            } catch (Exception ex) {
+                m_descriptor.OnSetValueError(ex);
+            }
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeAttribute.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace ST.Library.UI.NodeEditor
+{
+    /// <summary>
+    /// STNode node characteristics
+    /// Used to describe STNode developer information and some behaviors
+    /// </summary>
+    public class STNodeAttribute : Attribute
+    {
+        private string _Path;
+        /// <summary>
+        /// Get the path that the STNode node expects in the tree control
+        /// </summary>
+        public string Path {
+            get { return _Path; }
+        }
+
+        private string _Author;
+        /// <summary>
+        /// Get the author name of the STNode node
+        /// </summary>
+        public string Author {
+            get { return _Author; }
+        }
+
+        private string _Mail;
+        /// <summary>
+        /// Get the author mailbox of the STNode node
+        /// </summary>
+        public string Mail {
+            get { return _Mail; }
+        }
+
+        private string _Link;
+        /// <summary>
+        /// Get the author link of the STNode node
+        /// </summary>
+        public string Link {
+            get { return _Link; }
+        }
+
+        private string _Description;
+        /// <summary>
+        /// Get the description information of the STNode node
+        /// </summary>
+        public string Description {
+            get { return _Description; }
+        }
+
+        private static char[] m_ch_splitter = new char[] { '/', '\\' };
+        private static Regex m_reg = new Regex(@"^https?://", RegexOptions.IgnoreCase);
+        /// <summary>
+        /// Constructs an STNode property
+        /// </summary>
+        /// <param name="strPath">expected path</param>
+        public STNodeAttribute(string strPath) : this(strPath, null, null, null, null) { }
+        /// <summary>
+        /// Constructs an STNode property
+        /// </summary>
+        /// <param name="strPath">expected path</param>
+        /// <param name="strDescription">Description</param>
+        public STNodeAttribute(string strPath, string strDescription) : this(strPath, null, null, null, strDescription) { }
+        /// <summary>
+        /// Constructs an STNode property
+        /// </summary>
+        /// <param name="strPath">expected path</param>
+        /// <param name="strAuthor">STNode author name</param>
+        /// <param name="strMail">STNode author mailbox</param>
+        /// <param name="strLink">STNode author link</param>
+        /// <param name="strDescription">STNode node description information</param>
+        public STNodeAttribute(string strPath, string strAuthor, string strMail, string strLink, string strDescription) {
+            if (!string.IsNullOrEmpty(strPath))
+                strPath = strPath.Trim().Trim(m_ch_splitter).Trim();
+
+            this._Path = strPath;
+
+            this._Author = strAuthor;
+            this._Mail = strMail;
+            this._Description = strDescription;
+            if (string.IsNullOrEmpty(strLink) || strLink.Trim() == string.Empty) return;
+            strLink = strLink.Trim();
+            if (m_reg.IsMatch(strLink))
+                this._Link = strLink;
+            else
+                this._Link = "http://" + strLink;
+        }
+
+        private static Dictionary<Type, MethodInfo> m_dic = new Dictionary<Type, MethodInfo>();
+        /// <summary>
+        /// Get type helper function
+        /// </summary>
+        /// <param name="stNodeType">Node Type</param>
+        /// <returns>Function information</returns>
+        public static MethodInfo GetHelpMethod(Type stNodeType) {
+            if (m_dic.ContainsKey(stNodeType)) return m_dic[stNodeType];
+            var mi = stNodeType.GetMethod("ShowHelpInfo");
+            if (mi == null) return null;
+            if (!mi.IsStatic) return null;
+            var ps = mi.GetParameters ();
+            if (ps.Length != 1) return null;
+            if (ps[0].ParameterType != typeof(string)) return null;
+            m_dic.Add(stNodeType, mi);
+            return mi;
+        }
+        /// <summary>
+        /// Execute the helper function for the corresponding node type
+        /// </summary>
+        /// <param name="stNodeType">Node Type</param>
+        public static void ShowHelp(Type stNodeType) {
+            var mi = STNodeAttribute.GetHelpMethod (stNodeType);
+            if (mi == null) return;
+            mi.Invoke(null, new object[] { stNodeType.Module.FullyQualifiedName });
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeCollection.cs

@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections;
+using System.Drawing;
+
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeCollection : IList, ICollection, IEnumerable
+    {
+        private int _Count;
+        public int Count { get { return _Count; } }
+        private STNode[] m_nodes;
+        private STNodeEditor m_owner;
+
+        internal STNodeCollection(STNodeEditor owner) {
+            if (owner == null) throw new ArgumentNullException("Owner cannot be null");
+            m_owner = owner;
+            m_nodes = new STNode[4];
+        }
+
+        public void MoveToEnd(STNode node) {
+            if (this._Count < 1) return;
+            if (m_nodes[this._Count - 1] == node) return;
+            bool bFound = false;
+            for (int i = 0; i < _Count - 1; i++) {
+                if (m_nodes[i] == node) {
+                    bFound = true;
+                }
+                if (bFound) m_nodes[i] = m_nodes[i + 1];
+            }
+            m_nodes[this._Count - 1] = node;
+        }
+
+        public int Add(STNode node) {
+            if (node == null) throw new ArgumentNullException("Add object cannot be null");
+            this.EnsureSpace(1);
+            int nIndex = this.IndexOf(node);
+            if (-1 == nIndex) {
+                nIndex = this._Count;
+                node.Owner = m_owner;
+                //node.BuildSize(true, true, false);
+                m_nodes[this._Count++] = node;
+                m_owner.BuildBounds();
+                m_owner.OnNodeAdded(new STNodeEditorEventArgs(node));
+                m_owner.Invalidate();
+                //m_owner.Invalidate(m_owner.CanvasToControl(new Rectangle(node.Left - 5, node.Top - 5, node.Width + 10, node.Height + 10)));
+                //Console.WriteLine(node.Rectangle);
+            }
+            return nIndex;
+        }
+
+        public void AddRange(STNode[] nodes) {
+            if (nodes == null) throw new ArgumentNullException("Add object cannot be null");
+            this.EnsureSpace(nodes.Length);
+            foreach (var n in nodes) {
+                if (n == null) throw new ArgumentNullException("Add object cannot be null");
+                if (-1 == this.IndexOf(n)) {
+                    n.Owner = m_owner;
+                    m_nodes[this._Count++] = n;
+                }
+                m_owner.OnNodeAdded(new STNodeEditorEventArgs(n));
+            }
+            m_owner.Invalidate();
+            m_owner.BuildBounds();
+        }
+
+        public void Clear() {
+            for (int i = 0; i < this._Count; i++) {
+                m_nodes[i].Owner = null;
+                foreach (STNodeOption op in m_nodes[i].InputOptions) op.DisConnectionAll();
+                foreach (STNodeOption op in m_nodes[i].OutputOptions) op.DisConnectionAll();
+                m_owner.OnNodeRemoved(new STNodeEditorEventArgs(m_nodes[i]));
+                m_owner.InternalRemoveSelectedNode(m_nodes[i]);
+            }
+            this._Count = 0;
+            m_nodes = new STNode[4];
+            m_owner.SetActiveNode(null);
+            m_owner.BuildBounds();
+            m_owner.ScaleCanvas(1, 0, 0); //The coordinate system returns when there is no node
+            m_owner.MoveCanvas(10, 10, true, CanvasMoveArgs.All);
+            m_owner.Invalidate(); //If the canvas position and zoom are in the initial state, the above two lines of code will not cause the control to redraw
+        }
+
+        public bool Contains(STNode node) {
+            return this.IndexOf(node) != -1;
+        }
+
+        public int IndexOf(STNode node) {
+            return Array.IndexOf<STNode>(m_nodes, node);
+        }
+
+        public void Insert(int nIndex, STNode node) {
+            if (nIndex < 0 || nIndex >= this._Count)
+                throw new IndexOutOfRangeException("Index out of bounds");
+            if (node == null)
+                throw new ArgumentNullException("Insert object cannot be null");
+            this.EnsureSpace(1);
+            for (int i = this._Count; i > nIndex; i--)
+                m_nodes[i] = m_nodes[i - 1];
+            node.Owner = m_owner;
+            m_nodes[nIndex] = node;
+            this._Count++;
+            //node.BuildSize(true, true,false);
+            m_owner.Invalidate();
+            m_owner.BuildBounds();
+        }
+
+        public bool IsFixedSize {
+            get { return false; }
+        }
+
+        public bool IsReadOnly {
+            get { return false; }
+        }
+
+        public void Remove(STNode node) {
+            int nIndex = this.IndexOf(node);
+            if (nIndex != -1) this.RemoveAt(nIndex);
+        }
+
+        public void RemoveAt(int nIndex) {
+            if (nIndex < 0 || nIndex >= this._Count)
+                throw new IndexOutOfRangeException("Index out of bounds");
+            m_nodes[nIndex].Owner = null;
+            m_owner.InternalRemoveSelectedNode(m_nodes[nIndex]);
+            if (m_owner.ActiveNode == m_nodes[nIndex]) m_owner.SetActiveNode(null);
+            m_owner.OnNodeRemoved(new STNodeEditorEventArgs(m_nodes[nIndex]));
+            this._Count--;
+            for (int i = nIndex, Len = this._Count; i < Len; i++)
+                m_nodes[i] = m_nodes[i + 1];
+            if (this._Count == 0) { //The coordinate system returns when there is no node
+                m_owner.ScaleCanvas(1, 0, 0);
+                m_owner.MoveCanvas(10, 10, true, CanvasMoveArgs.All);
+            } else {
+                m_owner.Invalidate();
+                m_owner.BuildBounds();
+            }
+        }
+
+        public STNode this[int nIndex] {
+            get {
+                if (nIndex < 0 || nIndex >= this._Count)
+                    throw new IndexOutOfRangeException("Index out of bounds");
+                return m_nodes[nIndex];
+            }
+            set { throw new InvalidOperationException("No reassignment of elements"); }
+        }
+
+        public void CopyTo(Array array, int index) {
+            if (array == null)
+                throw new ArgumentNullException("Array cannot be empty");
+            m_nodes.CopyTo(array, index);
+        }
+
+        public bool IsSynchronized {
+            get { return true; }
+        }
+
+        public object SyncRoot {
+            get { return this; }
+        }
+
+        public IEnumerator GetEnumerator() {
+            for (int i = 0, Len = this._Count; i < Len; i++)
+                yield return m_nodes[i];
+        }
+        /// <summary>
+        /// Check if there is enough space to expand the capacity
+        /// </summary>
+        /// <param name="elements">Number of elements to be added</param>
+        private void EnsureSpace(int elements) {
+            if (elements + this._Count > m_nodes.Length) {
+                STNode[] arrTemp = new STNode[Math.Max(m_nodes.Length * 2, elements + this._Count)];
+                m_nodes.CopyTo(arrTemp, 0);
+                m_nodes = arrTemp;
+            }
+        }
+        //============================================================================
+        int IList.Add(object value) {
+            return this.Add((STNode)value);
+        }
+
+        void IList.Clear() {
+            this.Clear();
+        }
+
+        bool IList.Contains(object value) {
+            return this.Contains((STNode)value);
+        }
+
+        int IList.IndexOf(object value) {
+            return this.IndexOf((STNode)value);
+        }
+
+        void IList.Insert(int index, object value) {
+            this.Insert(index, (STNode)value);
+        }
+
+        bool IList.IsFixedSize {
+            get { return this.IsFixedSize; }
+        }
+
+        bool IList.IsReadOnly {
+            get { return this.IsReadOnly; }
+        }
+
+        void IList.Remove(object value) {
+            this.Remove((STNode)value);
+        }
+
+        void IList.RemoveAt(int index) {
+            this.RemoveAt(index);
+        }
+
+        object IList.this[int index] {
+            get {
+                return this[index];
+            }
+            set {
+                this[index] = (STNode)value;
+            }
+        }
+
+        void ICollection.CopyTo(Array array, int index) {
+            this.CopyTo(array, index);
+        }
+
+        int ICollection.Count {
+            get { return this._Count; }
+        }
+
+        bool ICollection.IsSynchronized {
+            get { return this.IsSynchronized; }
+        }
+
+        object ICollection.SyncRoot {
+            get { return this.SyncRoot; }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() {
+            return this.GetEnumerator();
+        }
+
+        public STNode[] ToArray() {
+            STNode[] nodes = new STNode[this._Count];
+            for (int i = 0; i < nodes.Length; i++)
+                nodes[i] = m_nodes[i];
+            return nodes;
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeControl.cs

@@ -0,0 +1,319 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+/*
+MIT License
+
+Copyright (c) 2021 DebugST@crystal_lz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+/*
+ * time: 2021-01-06
+ * Author: Crystal_lz
+ * blog: st233.com
+ * Github: DebugST.github.io
+ */
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeControl
+    {
+        private STNode _Owner;
+
+        public STNode Owner {
+            get { return _Owner; }
+            internal set { _Owner = value; }
+        }
+
+        private int _Left;
+
+        public int Left {
+            get { return _Left; }
+            set {
+                _Left = value;
+                this.OnMove(EventArgs.Empty);
+                this.Invalidate();
+            }
+        }
+
+        private int _Top;
+
+        public int Top {
+            get { return _Top; }
+            set {
+                _Top = value;
+                this.OnMove(EventArgs.Empty);
+                this.Invalidate();
+            }
+        }
+
+        private int _Width;
+
+        public int Width {
+            get { return _Width; }
+            set {
+                _Width = value;
+                this.OnResize(EventArgs.Empty);
+                this.Invalidate();
+            }
+        }
+
+        private int _Height;
+
+        public int Height {
+            get { return _Height; }
+            set {
+                _Height = value;
+                this.OnResize(EventArgs.Empty);
+                this.Invalidate();
+            }
+        }
+
+        public int Right { get { return this._Left + this._Width; } }
+
+        public int Bottom { get { return this._Top + this._Height; } }
+
+        public Point Location {
+            get { return new Point(this._Left, this._Top); }
+            set {
+                this.Left = value.X;
+                this.Top = value.Y;
+            }
+        }
+        public Size Size {
+            get { return new Size(this._Width, this._Height); }
+            set {
+                this.Width = value.Width;
+                this.Height = value.Height;
+            }
+        }
+        public Rectangle DisplayRectangle {
+            get { return new Rectangle(this._Left, this._Top, this._Width, this._Height); }
+            set {
+                this.Left = value.X;
+                this.Top = value.Y;
+                this.Width = value.Width;
+                this.Height = value.Height;
+            }
+        }
+        public Rectangle ClientRectangle {
+            get { return new Rectangle(0, 0, this._Width, this._Height); }
+        }
+
+        private Color _BackColor = Color.FromArgb(127, 0, 0, 0);
+
+        public Color BackColor {
+            get { return _BackColor; }
+            set {
+                _BackColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private Color _ForeColor = Color.White;
+
+        public Color ForeColor {
+            get { return _ForeColor; }
+            set {
+                _ForeColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private string _Text = "STNCTRL";
+
+        public string Text {
+            get { return _Text; }
+            set {
+                _Text = value;
+                this.Invalidate();
+            }
+        }
+
+        private Font _Font;
+
+        public Font Font {
+            get { return _Font; }
+            set {
+                if (value == _Font) return;
+                if (value == null) throw new ArgumentNullException("Value cannot be null");
+                _Font = value;
+                this.Invalidate();
+            }
+        }
+
+        private bool _Enabled = true;
+
+        public bool Enabled {
+            get { return _Enabled; }
+            set {
+                if (value == _Enabled) return;
+                _Enabled = value;
+                this.Invalidate();
+            }
+        }
+
+        private bool _Visable = true;
+
+        public bool Visable {
+            get { return _Visable; }
+            set {
+                if (value == _Visable) return;
+                _Visable = value;
+                this.Invalidate();
+            }
+        }
+
+        protected StringFormat m_sf;
+
+        public STNodeControl() {
+            m_sf = new StringFormat();
+            m_sf.Alignment = StringAlignment.Center;
+            m_sf.LineAlignment = StringAlignment.Center;
+            this._Font = new Font("courier new", 8.25f);
+            this.Width = 75;
+            this.Height = 23;
+        }
+
+        protected internal virtual void OnPaint(DrawingTools dt) {
+            Graphics g = dt.Graphics;
+            SolidBrush brush = dt.SolidBrush;
+            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
+            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
+            brush.Color = this._BackColor;
+            g.FillRectangle(brush, 0, 0, this.Width, this.Height);
+            if (!string.IsNullOrEmpty(this._Text)) {
+                brush.Color = this._ForeColor;
+                g.DrawString(this._Text, this._Font, brush, this.ClientRectangle, m_sf);
+            }
+            if (this.Paint != null) this.Paint(this, new STNodeControlPaintEventArgs(dt));
+        }
+
+        public void Invalidate() {
+            if (this._Owner == null) return;
+            this._Owner.Invalidate(new Rectangle(this._Left, this._Top + this._Owner.TitleHeight, this.Width, this.Height));
+        }
+
+        public void Invalidate(Rectangle rect) {
+            if (this._Owner == null) return;
+            this._Owner.Invalidate(this.RectangleToParent(rect));
+        }
+
+        public Rectangle RectangleToParent(Rectangle rect) {
+            return new Rectangle(this._Left, this._Top + this._Owner.TitleHeight, this.Width, this.Height);
+        }
+
+        public event EventHandler GotFocus;
+        public event EventHandler LostFocus;
+        public event EventHandler MouseEnter;
+        public event EventHandler MouseLeave;
+        public event MouseEventHandler MouseDown;
+        public event MouseEventHandler MouseMove;
+        public event MouseEventHandler MouseUp;
+        public event MouseEventHandler MouseClick;
+        public event MouseEventHandler MouseWheel;
+        public event EventHandler MouseHWheel;
+
+        public event KeyEventHandler KeyDown;
+        public event KeyEventHandler KeyUp;
+        public event KeyPressEventHandler KeyPress;
+
+        public event EventHandler Move;
+        public event EventHandler Resize;
+
+        public event STNodeControlPaintEventHandler Paint;
+
+        protected internal virtual void OnGotFocus(EventArgs e) {
+            if (this.GotFocus != null) this.GotFocus(this, e);
+        }
+        protected internal virtual void OnLostFocus(EventArgs e) {
+            if (this.LostFocus != null) this.LostFocus(this, e);
+        }
+        protected internal virtual void OnMouseEnter(EventArgs e) {
+            if (this.MouseEnter != null) this.MouseEnter(this, e);
+        }
+        protected internal virtual void OnMouseLeave(EventArgs e) {
+            if (this.MouseLeave != null) this.MouseLeave(this, e);
+        }
+        protected internal virtual void OnMouseDown(MouseEventArgs e) {
+            if (this.MouseDown != null) this.MouseDown(this, e);
+        }
+        protected internal virtual void OnMouseMove(MouseEventArgs e) {
+            if (this.MouseMove != null) this.MouseMove(this, e);
+        }
+        protected internal virtual void OnMouseUp(MouseEventArgs e) {
+            if (this.MouseUp != null) this.MouseUp(this, e);
+        }
+        protected internal virtual void OnMouseClick(MouseEventArgs e) {
+            if (this.MouseClick != null) this.MouseClick(this, e);
+        }
+        protected internal virtual void OnMouseWheel(MouseEventArgs e) {
+            if (this.MouseWheel != null) this.MouseWheel(this, e);
+        }
+        protected internal virtual void OnMouseHWheel(MouseEventArgs e) {
+            if (this.MouseHWheel != null) this.MouseHWheel(this, e);
+        }
+
+        protected internal virtual void OnKeyDown(KeyEventArgs e) {
+            if (this.KeyDown != null) this.KeyDown(this, e);
+        }
+        protected internal virtual void OnKeyUp(KeyEventArgs e) {
+            if (this.KeyUp != null) this.KeyUp(this, e);
+        }
+        protected internal virtual void OnKeyPress(KeyPressEventArgs e) {
+            if (this.KeyPress != null) this.KeyPress(this, e);
+        }
+
+        protected internal virtual void OnMove(EventArgs e) {
+            if (this.Move != null) this.Move(this, e);
+        }
+
+        protected internal virtual void OnResize(EventArgs e) {
+            if (this.Resize != null) this.Resize(this, e);
+        }
+
+        public IAsyncResult BeginInvoke(Delegate method) { return this.BeginInvoke(method, null); }
+        public IAsyncResult BeginInvoke(Delegate method, params object[] args) {
+            if (this._Owner == null) return null;
+            return this._Owner.BeginInvoke(method, args);
+        }
+        public object Invoke(Delegate method) { return this.Invoke(method, null); }
+        public object Invoke(Delegate method, params object[] args) {
+            if (this._Owner == null) return null;
+            return this._Owner.Invoke(method, args);
+        }
+    }
+
+    public delegate void STNodeControlPaintEventHandler(object sender, STNodeControlPaintEventArgs e);
+
+    public class STNodeControlPaintEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Drawing tools
+        /// </summary>
+        public DrawingTools DrawingTools { get; private set; }
+
+        public STNodeControlPaintEventArgs(DrawingTools dt) {
+            this.DrawingTools = dt;
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeControlCollection.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections;
+
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeControlCollection: IList, ICollection, IEnumerable
+    {
+        /*
+         * To ensure security, only inheritors can access the collection in STNode
+         */
+        private int _Count;
+        public int Count { get { return _Count; } }
+        private STNodeControl[] m_controls;
+        private STNode m_owner;
+
+        internal STNodeControlCollection(STNode owner) {
+            if (owner == null) throw new ArgumentNullException("Owner cannot be null");
+            m_owner = owner;
+            m_controls = new STNodeControl[4];
+        }
+
+        public int Add(STNodeControl control) {
+            if (control == null) throw new ArgumentNullException("Add object cannot be null");
+            this.EnsureSpace(1);
+            int nIndex = this.IndexOf(control);
+            if (-1 == nIndex) {
+                nIndex = this._Count;
+                control.Owner = m_owner;
+                m_controls[this._Count++] = control;
+                this.Redraw();
+            }
+            return nIndex;
+        }
+
+        public void AddRange(STNodeControl[] controls) {
+            if (controls == null) throw new ArgumentNullException("Add object cannot be null");
+            this.EnsureSpace(controls.Length);
+            foreach (var op in controls) {
+                if (op == null) throw new ArgumentNullException("Add object cannot be null");
+                if (-1 == this.IndexOf(op)) {
+                    op.Owner = m_owner;
+                    m_controls[this._Count++] = op;
+                }
+            }
+            this.Redraw();
+        }
+
+        public void Clear() {
+            for (int i = 0; i < this._Count; i++) m_controls[i].Owner = null;
+            this._Count = 0;
+            m_controls = new STNodeControl[4];
+            this.Redraw();
+        }
+
+        public bool Contains(STNodeControl option) {
+            return this.IndexOf(option) != -1;
+        }
+
+        public int IndexOf(STNodeControl option) {
+            return Array.IndexOf<STNodeControl>(m_controls, option);
+        }
+
+        public void Insert(int index, STNodeControl control) {
+            if (index < 0 || index >= this._Count)
+                throw new IndexOutOfRangeException("Index out of bounds");
+            if (control == null)
+                throw new ArgumentNullException("Insert object cannot be null");
+            this.EnsureSpace(1);
+            for (int i = this._Count; i > index; i--)
+                m_controls[i] = m_controls[i - 1];
+            control.Owner = m_owner;
+            m_controls[index] = control;
+            this._Count++;
+            this.Redraw();
+        }
+
+        public bool IsFixedSize {
+            get { return false; }
+        }
+
+        public bool IsReadOnly {
+            get { return false; }
+        }
+
+        public void Remove(STNodeControl control) {
+            int nIndex = this.IndexOf(control);
+            if (nIndex != -1) this.RemoveAt(nIndex);
+        }
+
+        public void RemoveAt(int index) {
+            if (index < 0 || index >= this._Count)
+                throw new IndexOutOfRangeException("Index out of bounds");
+            this._Count--;
+            m_controls[index].Owner = null;
+            for (int i = index, Len = this._Count; i < Len; i++)
+                m_controls[i] = m_controls[i + 1];
+            this.Redraw();
+        }
+
+        public STNodeControl this[int index] {
+            get {
+                if (index < 0 || index >= this._Count)
+                    throw new IndexOutOfRangeException("Index out of bounds");
+                return m_controls[index];
+            }
+            set { throw new InvalidOperationException("No reassignment of elements"); }
+        }
+
+        public void CopyTo(Array array, int index) {
+            if (array == null)
+                throw new ArgumentNullException("Array cannot be empty");
+            m_controls.CopyTo(array, index);
+        }
+
+        public bool IsSynchronized {
+            get { return true; }
+        }
+
+        public object SyncRoot {
+            get { return this; }
+        }
+
+        public IEnumerator GetEnumerator() {
+            for (int i = 0, Len = this._Count; i < Len; i++)
+                yield return m_controls[i];
+        }
+        /// <summary>
+        /// Check if there is enough space to expand the capacity
+        /// </summary>
+        /// <param name="elements">Number of elements to be added</param>
+        private void EnsureSpace(int elements) {
+            if (elements + this._Count > m_controls.Length) {
+                STNodeControl[] arrTemp = new STNodeControl[Math.Max(m_controls.Length * 2, elements + this._Count)];
+                m_controls.CopyTo(arrTemp, 0);
+                m_controls = arrTemp;
+            }
+        }
+
+        protected void Redraw() {
+            if (m_owner != null && m_owner.Owner != null) {
+                //m_owner.BuildSize();
+                m_owner.Owner.Invalidate(m_owner.Owner.CanvasToControl(m_owner.Rectangle));
+            }
+        }
+        //===================================================================================
+        int IList.Add(object value) {
+            return this.Add((STNodeControl)value);
+        }
+
+        void IList.Clear() {
+            this.Clear();
+        }
+
+        bool IList.Contains(object value) {
+            return this.Contains((STNodeControl)value);
+        }
+
+        int IList.IndexOf(object value) {
+            return this.IndexOf((STNodeControl)value);
+        }
+
+        void IList.Insert(int index, object value) {
+            this.Insert(index, (STNodeControl)value);
+        }
+
+        bool IList.IsFixedSize {
+            get { return this.IsFixedSize; }
+        }
+
+        bool IList.IsReadOnly {
+            get { return this.IsReadOnly; }
+        }
+
+        void IList.Remove(object value) {
+            this.Remove((STNodeControl)value);
+        }
+
+        void IList.RemoveAt(int index) {
+            this.RemoveAt(index);
+        }
+
+        object IList.this[int index] {
+            get {
+                return this[index];
+            }
+            set {
+                this[index] = (STNodeControl)value;
+            }
+        }
+
+        void ICollection.CopyTo(Array array, int index) {
+            this.CopyTo(array, index);
+        }
+
+        int ICollection.Count {
+            get { return this._Count; }
+        }
+
+        bool ICollection.IsSynchronized {
+            get { return this.IsSynchronized; }
+        }
+
+        object ICollection.SyncRoot {
+            get { return this.SyncRoot; }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() {
+            return this.GetEnumerator();
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeEditorDataType.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+using System.Drawing;
+
+namespace ST.Library.UI.NodeEditor
+{
+    public enum ConnectionStatus
+    {
+        /// <summary>
+        /// No owner exists
+        /// </summary>
+        [Description("No owner exists")]
+        NoOwner,
+        /// <summary>
+        /// same owner
+        /// </summary>
+        [Description("same owner")]
+        SameOwner,
+        /// <summary>
+        /// Both are input or output options
+        /// </summary>
+        [Description("both input or output options")]
+        SameInputOrOutput,
+        /// <summary>
+        /// Different data types
+        /// </summary>
+        [Description("Different data types")]
+        ErrorType,
+        /// <summary>
+        /// Single connection node
+        /// </summary>
+        [Description("Single connection node")]
+        SingleOption,
+        /// <summary>
+        /// A circular path appears
+        /// </summary>
+        [Description("A circular path appears")]
+        Loop,
+        /// <summary>
+        /// Existing connection
+        /// </summary>
+        [Description("existing connection")]
+        Exists,
+        /// <summary>
+        /// blank options
+        /// </summary>
+        [Description("Blank option")]
+        EmptyOption,
+        /// <summary>
+        /// already connected
+        /// </summary>
+        [Description("Connected")]
+        Connected,
+        /// <summary>
+        /// The connection is disconnected
+        /// </summary>
+        [Description("The connection was disconnected")]
+        DisConnected,
+        /// <summary>
+        /// Node is locked
+        /// </summary>
+        [Description("Node is locked")]
+        Locked,
+        /// <summary>
+        /// Operation rejected
+        /// </summary>
+        [Description("Operation denied")]
+        Reject,
+        /// <summary>
+        /// is being connected
+        /// </summary>
+        [Description("being connected")]
+        Connecting,
+        /// <summary>
+        /// Disconnecting
+        /// </summary>
+        [Description("Disconnecting")]
+        DisConnecting
+    }
+
+    public enum AlertLocation
+    {
+        Left,
+        Top,
+        Right,
+        Bottom,
+        Center,
+        LeftTop,
+        RightTop,
+        RightBottom,
+        LeftBottom,
+    }
+
+    public struct DrawingTools
+    {
+        public Graphics Graphics;
+        public Pen Pen;
+        public SolidBrush SolidBrush;
+    }
+
+    public enum CanvasMoveArgs //View the parameters needed when moving the canvas ->MoveCanvas()
+    {
+        Left = 1, //indicates that only the X coordinate is moved
+        Top = 2, //Indicates that only the Y coordinate is moved
+        All = 4 //Indicates that XY move at the same time
+    }
+
+    public struct NodeFindInfo
+    {
+        public STNode Node;
+        public STNodeOption NodeOption;
+        public string Mark;
+        public string[] MarkLines;
+    }
+
+    public struct ConnectionInfo
+    {
+        public STNodeOption Input;
+        public STNodeOption Output;
+    }
+
+    public delegate void STNodeOptionEventHandler(object sender, STNodeOptionEventArgs e);
+
+    public class STNodeOptionEventArgs : EventArgs
+    {
+        private STNodeOption _TargetOption;
+        /// <summary>
+        /// The corresponding Option that triggers this event
+        /// </summary>
+        public STNodeOption TargetOption {
+            get { return _TargetOption; }
+        }
+
+        private ConnectionStatus _Status;
+        /// <summary>
+        /// Connection status between Option
+        /// </summary>
+        public ConnectionStatus Status {
+            get { return _Status; }
+            internal set { _Status = value; }
+        }
+
+        private bool _IsSponsor;
+        /// <summary>
+        /// Whether it is the initiator of this behavior
+        /// </summary>
+        public bool IsSponsor {
+            get { return _IsSponsor; }
+        }
+
+        public STNodeOptionEventArgs(bool isSponsor, STNodeOption opTarget, ConnectionStatus cr) {
+            this._IsSponsor = isSponsor;
+            this._TargetOption = opTarget;
+            this._Status = cr;
+        }
+    }
+
+    public delegate void STNodeEditorEventHandler(object sender, STNodeEditorEventArgs e);
+    public delegate void STNodeEditorOptionEventHandler(object sender, STNodeEditorOptionEventArgs e);
+
+
+    public class STNodeEditorEventArgs : EventArgs
+    {
+        private STNode _Node;
+
+        public STNode Node {
+            get { return _Node; }
+        }
+
+        public STNodeEditorEventArgs(STNode node) {
+            this._Node = node;
+        }
+    }
+
+    public class STNodeEditorOptionEventArgs : STNodeOptionEventArgs
+    {
+
+        private STNodeOption _CurrentOption;
+        /// <summary>
+        /// Option to actively trigger events
+        /// </summary>
+        public STNodeOption CurrentOption {
+            get { return _CurrentOption; }
+        }
+
+        private bool _Continue = true;
+        /// <summary>
+        /// Whether to continue the downward operation for Begin(Connecting/DisConnecting) whether to continue the backward operation
+        /// </summary>
+        public bool Continue {
+            get { return _Continue; }
+            set { _Continue = value; }
+        }
+
+        public STNodeEditorOptionEventArgs(STNodeOption opTarget, STNodeOption opCurrent, ConnectionStatus cr)
+            : base(false, opTarget, cr) {
+            this._CurrentOption = opCurrent;
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeEditorPanel.cs

@@ -0,0 +1,329 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.ComponentModel;
+
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeEditorPannel : Control
+    {
+        private bool _LeftLayout = true;
+        /// <summary>
+        /// Gets or sets whether it is the left layout
+        /// </summary>
+        [Description("Get or set whether it is the left layout"), DefaultValue(true)]
+        public bool LeftLayout {
+            get { return _LeftLayout; }
+            set {
+                if (value == _LeftLayout) return;
+                _LeftLayout = value;
+                this.SetLocation();
+                this.Invalidate();
+            }
+        }
+
+        private Color _SplitLineColor = Color.Black;
+        /// <summary>
+        /// Gets or this is the color of the dividing line
+        /// </summary>
+        [Description("Get or set the color of the dividing line"), DefaultValue(typeof(Color), "Black")]
+        public Color SplitLineColor {
+            get { return _SplitLineColor; }
+            set { _SplitLineColor = value; }
+        }
+
+        private Color _HandleLineColor = Color.Gray;
+        /// <summary>
+        /// Gets or sets the color of the dividing line handle
+        /// </summary>
+        [Description("Get or set the color of the dividing line handle"), DefaultValue(typeof(Color), "Gray")]
+        public Color HandleLineColor {
+            get { return _HandleLineColor; }
+            set { _HandleLineColor = value; }
+        }
+
+        private bool _ShowScale = true;
+        /// <summary>
+        /// Get or set the display scale when the editor is zoomed
+        /// </summary>
+        [Description("Get or set the display scale when the editor is zoomed"), DefaultValue(true)]
+        public bool ShowScale {
+            get { return _ShowScale; }
+            set { _ShowScale = value; }
+        }
+
+        private bool _ShowConnectionStatus = true;
+        /// <summary>
+        /// Get or set whether to display the status when the node is connected
+        /// </summary>
+        [Description("Get or set whether to display the status when the node is connected"), DefaultValue(true)]
+        public bool ShowConnectionStatus {
+            get { return _ShowConnectionStatus; }
+            set { _ShowConnectionStatus = value; }
+        }
+
+        private int _X;
+        /// <summary>
+        /// Gets or sets the horizontal width of the dividing line
+        /// </summary>
+        [Description("Get or set the horizontal width of the dividing line"), DefaultValue(201)]
+        public int X {
+            get { return _X; }
+            set {
+                if (value < 122) value = 122;
+                else if (value > this.Width - 122) value = this.Width - 122;
+                if (_X == value) return;
+                _X = value;
+                this.SetLocation();
+            }
+        }
+
+        private int _Y;
+        /// <summary>
+        /// Gets or sets the vertical height of the dividing line
+        /// </summary>
+        [Description("Get or set the vertical height of the dividing line")]
+        public int Y {
+            get { return _Y; }
+            set {
+                if (value < 122) value = 122;
+                else if (value > this.Height - 122) value = this.Height - 122;
+                if (_Y == value) return;
+                _Y = value;
+                this.SetLocation();
+            }
+        }
+        /// <summary>
+        /// Get the STNodeEditor in the panel
+        /// </summary>
+        [Description("Get the STNodeEditor in the panel"), Browsable(false)]
+        public STNodeEditor Editor {
+            get { return m_editor; }
+        }
+        /// <summary>
+        /// Get the STNodeTreeView in the panel
+        /// </summary>
+        [Description("Get the STNodeTreeView in the panel"), Browsable(false)]
+        public STNodeTreeView TreeView {
+            get { return m_tree; }
+        }
+        /// <summary>
+        /// Get the STNodePropertyGrid in the panel
+        /// </summary>
+        [Description("Get the STNodePropertyGrid in the panel"), Browsable(false)]
+        public STNodePropertyGrid PropertyGrid {
+            get { return m_grid; }
+        }
+
+        private Point m_pt_down;
+        private bool m_is_mx;
+        private bool m_is_my;
+        private Pen m_pen;
+
+        private bool m_nInited;
+        private Dictionary<ConnectionStatus, string> m_dic_status_key = new Dictionary<ConnectionStatus, string>();
+
+        private STNodeEditor m_editor;
+        private STNodeTreeView m_tree;
+        private STNodePropertyGrid m_grid;
+
+        public override Size MinimumSize {
+            get {
+                return base.MinimumSize;
+            }
+            set {
+                value = new Size(250, 250);
+                base.MinimumSize = value;
+            }
+        }
+
+        [DllImport("user32.dll")]
+        private static extern bool MoveWindow(IntPtr hWnd, int x, int y, int w, int h, bool bRedraw);
+
+        public STNodeEditorPannel() {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+
+            m_editor = new STNodeEditor();
+            m_tree = new STNodeTreeView();
+            m_grid = new STNodePropertyGrid();
+            m_grid.Text = "NodeProperty";
+            this.Controls.Add(m_editor);
+            this.Controls.Add(m_tree);
+            this.Controls.Add(m_grid);
+            this.Size = new Size(500, 500);
+            this.MinimumSize = new Size(250, 250);
+            this.BackColor = Color.FromArgb(255, 34, 34, 34);
+
+            m_pen = new Pen(this.BackColor, 3);
+
+            Type t = typeof(ConnectionStatus);
+            var vv = Enum.GetValues(t);
+            var vvv = vv.GetValue(0);
+            foreach (var f in t.GetFields()) {
+                if (!f.FieldType.IsEnum) continue;
+                foreach (var a in f.GetCustomAttributes(true)) {
+                    if (!(a is DescriptionAttribute)) continue;
+                    m_dic_status_key.Add((ConnectionStatus)f.GetValue(f), ((DescriptionAttribute)a).Description);
+                }
+            }
+
+            m_editor.ActiveChanged += (s, e) => m_grid.SetNode(m_editor.ActiveNode);
+            m_editor.CanvasScaled += (s, e) => {
+                if (this._ShowScale)
+                    m_editor.ShowAlert(m_editor.CanvasScale.ToString("F2"), Color.White, Color.FromArgb(127, 255, 255, 0));
+            };
+            m_editor.OptionConnected += (s, e) => {
+                if (this._ShowConnectionStatus)
+                    m_editor.ShowAlert(m_dic_status_key[e.Status], Color.White, e.Status == ConnectionStatus.Connected ? Color.FromArgb(125, Color.Lime) : Color.FromArgb(125, Color.Red));
+            };
+        }
+
+        protected override void OnResize(EventArgs e) {
+            base.OnResize(e);
+            if (!m_nInited) {
+                this._Y = this.Height / 2;
+                if (this._LeftLayout)
+                    this._X = 201;
+                else
+                    this._X = this.Width - 202;
+                m_nInited = true;
+                this.SetLocation();
+                return;
+            }
+            this.SetLocation();
+        }
+
+        protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
+            if (width < 250) width = 250;
+            if (height < 250) height = 250;
+            base.SetBoundsCore(x, y, width, height, specified);
+        }
+
+        protected override void OnPaint(PaintEventArgs e) {
+            base.OnPaint(e);
+            Graphics g = e.Graphics;
+            m_pen.Width = 3;
+            m_pen.Color = this._SplitLineColor;
+            g.DrawLine(m_pen, this._X, 0, this._X, this.Height);
+            int nX = 0;
+            if (this._LeftLayout) {
+                g.DrawLine(m_pen, 0, this._Y, this._X - 1, this._Y);
+                nX = this._X / 2;
+            } else {
+                g.DrawLine(m_pen, this._X + 2, this._Y, this.Width, this._Y);
+                nX = this._X + (this.Width - this._X) / 2;
+            }
+            m_pen.Width = 1;
+            this._HandleLineColor = Color.Gray;
+            m_pen.Color = this._HandleLineColor;
+            g.DrawLine(m_pen, this._X, this._Y - 10, this._X, this._Y + 10);
+            g.DrawLine(m_pen, nX - 10, this._Y, nX + 10, this._Y);
+        }
+
+        private void SetLocation() {
+            if (this._LeftLayout) {
+                //m_tree.Location = Point.Empty;
+                //m_tree.Size = new Size(m_sx - 1, m_sy - 1);
+                STNodeEditorPannel.MoveWindow(m_tree.Handle, 0, 0, this._X - 1, this._Y - 1, false);
+
+                //m_grid.Location = new Point (0, m_sy + 2);
+                //m_grid.Size = new Size(m_sx - 1, this.Height - m_sy - 2);
+                STNodeEditorPannel.MoveWindow(m_grid.Handle, 0, this._Y + 2, this._X - 1, this.Height - this._Y - 2, false);
+
+                //m_editor.Location = new Point(m_sx + 2, 0);
+                //m_editor.Size = new Size(this.Width - m_sx - 2, this.Height);
+                STNodeEditorPannel.MoveWindow(m_editor.Handle, this._X + 2, 0, this.Width - this._X - 2, this.Height, false);
+            } else {
+                STNodeEditorPannel.MoveWindow(m_editor.Handle, 0, 0, this._X - 1, this.Height, false);
+                STNodeEditorPannel.MoveWindow(m_tree.Handle, this._X + 2, 0, this.Width - this._X - 2, this._Y - 1, false);
+                STNodeEditorPannel.MoveWindow(m_grid.Handle, this._X + 2, this._Y + 2, this.Width - this._X - 2, this.Height - this._Y - 2, false);
+            }
+        }
+
+        protected override void OnMouseDown(MouseEventArgs e) {
+            base.OnMouseDown(e);
+            m_pt_down = e.Location;
+            m_is_mx = m_is_my = false;
+            if (this.Cursor == Cursors.VSplit) {
+                m_is_mx = true;
+            } else if (this.Cursor == Cursors.HSplit) {
+                m_is_my = true;
+            }
+        }
+
+        protected override void OnMouseMove(MouseEventArgs e) {
+            base.OnMouseMove(e);
+            if (e.Button == MouseButtons.Left) {
+                int nw = 122;// (int)(this.Width * 0.1f);
+                int nh = 122;// (int)(this.Height * 0.1f);
+                if (m_is_mx) {
+                    this._X = e.X;// -m_pt_down.X;
+                    if (this._X < nw) this._X = nw;
+                    else if (_X + nw > this.Width) this._X = this.Width - nw;
+                } else if (m_is_my) {
+                    this._Y = e.Y;
+                    if (this._Y < nh) this._Y = nh;
+                    else if (this._Y + nh > this.Height) this._Y = this.Height - nh;
+                }
+                //m_rx = this.Width - m_sx;// (float)m_sx / this.Width;
+                //m_fh = (float)m_sy / this.Height;
+                this.SetLocation();
+                this.Invalidate();
+                return;
+            }
+            if (Math.Abs(e.X - this._X) < 2)
+                this.Cursor = Cursors.VSplit;
+            else if (Math.Abs(e.Y - this._Y) < 2)
+                this.Cursor = Cursors.HSplit;
+            else this.Cursor = Cursors.Arrow;
+        }
+
+        protected override void OnMouseLeave(EventArgs e) {
+            base.OnMouseLeave(e);
+            m_is_mx = m_is_my = false;
+            this.Cursor = Cursors.Arrow;
+        }
+        /// <summary>
+        /// Add a STNode to the tree control
+        /// </summary>
+        /// <param name="stNodeType">STNode type</param>
+        /// <returns>Whether the addition is successful</returns>
+        public bool AddSTNode(Type stNodeType) {
+            return m_tree.AddNode(stNodeType);
+        }
+        /// <summary>
+        /// Load STNode from assembly
+        /// </summary>
+        /// <param name="strFileName">Assembly path</param>
+        /// <returns>Add success number</returns>
+        public int LoadAssembly(string strFileName) {
+            m_editor.LoadAssembly(strFileName);
+            return m_tree.LoadAssembly(strFileName);
+        }
+        /// <summary>
+        /// Sets the text for the editor to display the connection status
+        /// </summary>
+        /// <param name="status">Connection status</param>
+        /// <param name="strText">Corresponding display text</param>
+        /// <returns>Old text</returns>
+        public string SetConnectionStatusText(ConnectionStatus status, string strText) {
+            string strOld = null;
+            if (m_dic_status_key.ContainsKey(status)) {
+                strOld = m_dic_status_key[status];
+                m_dic_status_key[status] = strText;
+                return strOld;
+            }
+            m_dic_status_key.Add(status, strText);
+            return strText;
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeHub.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Drawing;
+/*
+MIT License
+
+Copyright (c) 2021 DebugST@crystal_lz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+/*
+ * create: 2021-12-08
+ * modify: 2021-03-02
+ * Author: Crystal_lz
+ * blog: http://st233.com
+ * Gitee: https://gitee.com/DebugST
+ * Github: https://github.com/DebugST
+ */
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeHub : STNode
+    {
+        private bool m_bSingle;
+        private string m_strIn;
+        private string m_strOut;
+
+        public STNodeHub() : this(false, "IN", "OUT") { }
+        public STNodeHub(bool bSingle) : this(bSingle, "IN", "OUT") { }
+        public STNodeHub(bool bSingle, string strTextIn, string strTextOut) {
+            m_bSingle = bSingle;
+            m_strIn = strTextIn;
+            m_strOut = strTextOut;
+            this.Addhub();
+            this.Title = "HUB";
+            this.AutoSize = false;
+            this.TitleColor = System.Drawing.Color.FromArgb(200, System.Drawing.Color.DarkOrange);
+        }
+
+        protected override void OnOwnerChanged() {
+            base.OnOwnerChanged();
+            if (this.Owner == null) return;
+            using (Graphics g = this.Owner.CreateGraphics()) {
+                this.Width = base.GetDefaultNodeSize(g).Width;
+            }
+        }
+
+        private void Addhub() {
+            var input = new STNodeHubOption(m_strIn, typeof(object), m_bSingle);
+            var output = new STNodeHubOption(m_strOut, typeof(object), false);
+            this.InputOptions.Add(input);
+            this.OutputOptions.Add(output);
+            input.Connected += new STNodeOptionEventHandler(input_Connected);
+            input.DataTransfer += new STNodeOptionEventHandler(input_DataTransfer);
+            input.DisConnected += new STNodeOptionEventHandler(input_DisConnected);
+            output.Connected += new STNodeOptionEventHandler(output_Connected);
+            output.DisConnected += new STNodeOptionEventHandler(output_DisConnected);
+            this.Height = this.TitleHeight + this.InputOptions.Count * 20;
+        }
+
+        void output_DisConnected(object sender, STNodeOptionEventArgs e) {
+            STNodeOption op = sender as STNodeOption;
+            if (op.ConnectionCount != 0) return;
+            int nIndex = this.OutputOptions.IndexOf(op);
+            if (this.InputOptions[nIndex].ConnectionCount != 0) return;
+            this.InputOptions.RemoveAt(nIndex);
+            this.OutputOptions.RemoveAt(nIndex);
+            if (this.Owner != null) this.Owner.BuildLinePath();
+            this.Height -= 20;
+        }
+
+        void output_Connected(object sender, STNodeOptionEventArgs e) {
+            STNodeOption op = sender as STNodeOption;
+            int nIndex = this.OutputOptions.IndexOf(op);
+            var t = typeof(object);
+            if (this.InputOptions[nIndex].DataType == t) {
+                op.DataType = e.TargetOption.DataType;
+                this.InputOptions[nIndex].DataType = op.DataType;
+                foreach (STNodeOption v in this.InputOptions) {
+                    if (v.DataType == t) return;
+                }
+                this.Addhub();
+            }
+        }
+
+        void input_DisConnected(object sender, STNodeOptionEventArgs e) {
+            STNodeOption op = sender as STNodeOption;
+            if (op.ConnectionCount != 0) return;
+            int nIndex = this.InputOptions.IndexOf(op);
+            if (this.OutputOptions[nIndex].ConnectionCount != 0) return;
+            this.InputOptions.RemoveAt(nIndex);
+            this.OutputOptions.RemoveAt(nIndex);
+            if (this.Owner != null) this.Owner.BuildLinePath();
+            this.Height -= 20;
+        }
+
+        void input_DataTransfer(object sender, STNodeOptionEventArgs e) {
+            STNodeOption op = sender as STNodeOption;
+            int nIndex = this.InputOptions.IndexOf(op);
+            if (e.Status != ConnectionStatus.Connected)
+                this.OutputOptions[nIndex].Data = null;
+            else
+                this.OutputOptions[nIndex].Data = e.TargetOption.Data;
+            this.OutputOptions[nIndex].TransferData();
+        }
+
+        void input_Connected(object sender, STNodeOptionEventArgs e) {
+            STNodeOption op = sender as STNodeOption;
+            int nIndex = this.InputOptions.IndexOf(op);
+            var t = typeof(object);
+            if (op.DataType == t) {
+                op.DataType = e.TargetOption.DataType;
+                this.OutputOptions[nIndex].DataType = op.DataType;
+                foreach (STNodeOption v in this.InputOptions) {
+                    if (v.DataType == t) return;
+                }
+                this.Addhub();
+            } else {
+                //this.OutputOptions[nIndex].Data = e.TargetOption.Data;
+                this.OutputOptions[nIndex].TransferData(e.TargetOption.Data);
+            }
+        }
+
+        protected override void OnSaveNode(Dictionary<string, byte[]> dic) {
+            dic.Add("count", BitConverter.GetBytes(this.InputOptionsCount));
+            //dic.Add("single", new byte[] { (byte)(m_bSingle ? 1 : 0) });
+            //dic.Add("strin", Encoding.UTF8.GetBytes(m_strIn));
+            //dic.Add("strout", Encoding.UTF8.GetBytes(m_strOut));
+        }
+
+        protected internal override void OnLoadNode(Dictionary<string, byte[]> dic) {
+            base.OnLoadNode(dic);
+            int nCount = BitConverter.ToInt32(dic["count"], 0);
+            while (this.InputOptionsCount < nCount && this.InputOptionsCount != nCount) this.Addhub();
+            //m_bSingle = dic["single"][0] == 1;
+            //m_strIn = Encoding.UTF8.GetString(dic["strin"]);
+            //m_strOut = Encoding.UTF8.GetString(dic["strout"]);
+        }
+
+        public class STNodeHubOption : STNodeOption
+        {
+            public STNodeHubOption(string strText, Type dataType, bool bSingle) : base(strText, dataType, bSingle) { }
+
+            public override ConnectionStatus ConnectOption(STNodeOption op) {
+                var t = typeof(object);
+                if (this.DataType != t) return base.ConnectOption(op);
+                this.DataType = op.DataType;
+                var ret = base.ConnectOption(op);
+                if (ret != ConnectionStatus.Connected) this.DataType = t;
+                return ret;
+            }
+
+            public override ConnectionStatus CanConnect(STNodeOption op) {
+                if (op == STNodeOption.Empty) return ConnectionStatus.EmptyOption; 
+                if (this.DataType != typeof(object)) return base.CanConnect(op);
+                if (this.IsInput == op.IsInput) return ConnectionStatus.SameInputOrOutput;
+                if (op.Owner == null || this.Owner == null) return ConnectionStatus.NoOwner;
+                if (op.Owner == this.Owner) return ConnectionStatus.SameOwner;
+                if (this.Owner.LockOption || op.Owner.LockOption) return ConnectionStatus.Locked;
+                if (this.IsSingle && m_hs_connected.Count == 1) return ConnectionStatus.SingleOption;
+                if (op.IsInput && STNodeEditor.CanFindNodePath(op.Owner, this.Owner)) return ConnectionStatus.Loop;
+                if (m_hs_connected.Contains(op)) return ConnectionStatus.Exists;
+                if (op.DataType == typeof(object)) return ConnectionStatus.ErrorType;
+
+                if (!this.IsInput) return ConnectionStatus.Connected;
+                foreach (STNodeOption owner_input in this.Owner.InputOptions) {
+                    foreach (STNodeOption o in owner_input.ConnectedOption) {
+                        if (o == op) return ConnectionStatus.Exists;
+                    }
+                }
+                return ConnectionStatus.Connected; ;
+            }
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeOption.cs

@@ -0,0 +1,456 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Drawing;
+
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeOption
+    {
+        #region Properties
+
+        public static readonly STNodeOption Empty = new STNodeOption();
+
+        private STNode _Owner;
+        /// <summary>
+        /// Get the Node to which the current Option belongs
+        /// </summary>
+        public STNode Owner {
+            get { return _Owner; }
+            internal set {
+                if (value == _Owner) return;
+                if (_Owner != null) this.DisConnectionAll(); //Disconnect all current connections when the owner changes
+                _Owner = value;
+            }
+        }
+
+        private bool _IsSingle;
+        /// <summary>
+        /// Get whether the current Option can only be connected once
+        /// </summary>
+        public bool IsSingle {
+            get { return _IsSingle; }
+        }
+
+        private bool _IsInput;
+        /// <summary>
+        /// Get whether the current Option is an input option
+        /// </summary>
+        public bool IsInput {
+            get { return _IsInput; }
+            internal set { _IsInput = value; }
+        }
+
+        private Color _TextColor = Color.White;
+        /// <summary>
+        /// Gets or sets the current Option text color
+        /// </summary>
+        public Color TextColor {
+            get { return _TextColor; }
+            internal set {
+                if (value == _TextColor) return;
+                _TextColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private Color _DotColor = Color.Transparent;
+        /// <summary>
+        /// Gets or sets the color of the current Option connection point
+        /// </summary>
+        public Color DotColor {
+            get { return _DotColor; }
+            internal set {
+                if (value == _DotColor) return;
+                _DotColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private string _Text;
+        /// <summary>
+        /// Gets or sets the current Option display text
+        /// This property cannot be modified when AutoSize is set
+        /// </summary>
+        public string Text {
+            get { return _Text; }
+            internal set {
+                if (value == _Text) return;
+                _Text = value;
+                if (this._Owner == null) return;
+                this._Owner.BuildSize(true, true, true);
+            }
+        }
+
+        private int _DotLeft;
+        /// <summary>
+        /// Get the left coordinate of the current Option connection point
+        /// </summary>
+        public int DotLeft {
+            get { return _DotLeft; }
+            internal set { _DotLeft = value; }
+        }
+        private int _DotTop;
+        /// <summary>
+        /// Get the upper coordinate of the current Option connection point
+        /// </summary>
+        public int DotTop {
+            get { return _DotTop; }
+            internal set { _DotTop = value; }
+        }
+
+        private int _DotSize;
+        /// <summary>
+        /// Get the width of the current Option connection point
+        /// </summary>
+        public int DotSize {
+            get { return _DotSize; }
+            protected set { _DotSize = value; }
+        }
+
+        private Rectangle _TextRectangle;
+        /// <summary>
+        /// Get the current Option text area
+        /// </summary>
+        public Rectangle TextRectangle {
+            get { return _TextRectangle; }
+            internal set { _TextRectangle = value; }
+        }
+
+        private object _Data;
+        /// <summary>
+        /// Get or set the data contained in the current Option
+        /// </summary>
+        public object Data {
+            get { return _Data; }
+            set {
+                if (value != null) {
+                    if (this._DataType == null) return;
+                    var t = value.GetType();
+                    if (t != this._DataType && !t.IsSubclassOf(this._DataType)) {
+                        throw new ArgumentException("Invalid data type The data type must be the specified data type or its subclass");
+                    }
+                }
+                _Data = value;
+            }
+        }
+
+        private Type _DataType;
+        /// <summary>
+        /// Get the current Option data type
+        /// </summary>
+        public Type DataType {
+            get { return _DataType; }
+            internal set { _DataType = value; }
+        }
+
+        //private Rectangle _DotRectangle;
+        /// <summary>
+        /// Get the area of ​​the current Option connection point
+        /// </summary>
+        public Rectangle DotRectangle {
+            get {
+                return new Rectangle(this._DotLeft, this._DotTop, this._DotSize, this._DotSize);
+            }
+        }
+        /// <summary>
+        /// Get the current number of Option connected
+        /// </summary>
+        public int ConnectionCount {
+            get { return m_hs_connected.Count; }
+        }
+        /// <summary>
+        /// Get the Option collection that the current Option is connected to
+        /// </summary>
+        internal HashSet<STNodeOption> ConnectedOption {
+            get { return m_hs_connected; }
+        }
+
+        #endregion Properties
+        /// <summary>
+        /// Save the points that have been connected
+        /// </summary>
+        protected HashSet<STNodeOption> m_hs_connected;
+
+        #region Constructor
+
+        private STNodeOption() { }
+
+        /// <summary>
+        /// Constructs an Option
+        /// </summary>
+        /// <param name="strText">Display text</param>
+        /// <param name="dataType">Data Type</param>
+        /// <param name="bSingle">Whether it is a single connection</param>
+        public STNodeOption(string strText, Type dataType, bool bSingle) {
+            if (dataType == null) throw new ArgumentNullException("The specified data type cannot be null");
+            this._DotSize = 10;
+            m_hs_connected = new HashSet<STNodeOption>();
+            this._DataType = dataType;
+            this._Text = strText;
+            this._IsSingle = bSingle;
+        }
+
+        #endregion Builder
+
+        #region Event
+
+        /// <summary>
+        /// Occurs when connected
+        /// </summary>
+        public event STNodeOptionEventHandler Connected;
+        /// <summary>
+        /// Occurs when a connection starts happening
+        /// </summary>
+        public event STNodeOptionEventHandler Connecting;
+        /// <summary>
+        /// Occurs when the connection is disconnected
+        /// </summary>
+        public event STNodeOptionEventHandler DisConnected;
+        /// <summary>
+        /// Occurs when the connection starts to drop
+        /// </summary>
+        public event STNodeOptionEventHandler DisConnecting;
+        /// <summary>
+        /// Occurs when data is passed
+        /// </summary>
+        public event STNodeOptionEventHandler DataTransfer;
+
+        #endregion Event
+
+        #region protected
+        /// <summary>
+        /// Redraw the entire control
+        /// </summary>
+        protected void Invalidate() {
+            if (this._Owner == null) return;
+            this._Owner.Invalidate();
+        }
+        /*
+         * At first I thought that only input type options should have events because input is passive and output is active
+         * But later found that events are used for output nodes in STNodeHub, for example
+         * Just in case, it is not very problematic to comment the code here. The output option does not register the event, and the same effect
+         */
+        protected internal virtual void OnConnected(STNodeOptionEventArgs e) {
+            if (this.Connected != null/* && this._IsInput*/) this.Connected(this, e);
+        }
+        protected internal virtual void OnConnecting(STNodeOptionEventArgs e) {
+            if (this.Connecting != null) this.Connecting(this, e);
+        }
+        protected internal virtual void OnDisConnected(STNodeOptionEventArgs e) {
+            if (this.DisConnected != null/* && this._IsInput*/) this.DisConnected(this, e);
+        }
+        protected internal virtual void OnDisConnecting(STNodeOptionEventArgs e) {
+            if (this.DisConnecting != null) this.DisConnecting(this, e);
+        }
+        protected internal virtual void OnDataTransfer(STNodeOptionEventArgs e) {
+            if (this.DataTransfer != null/* && this._IsInput*/) this.DataTransfer(this, e);
+        }
+        protected void STNodeEidtorConnected(STNodeEditorOptionEventArgs e) {
+            if (this._Owner == null) return;
+            if (this._Owner.Owner == null) return;
+            this._Owner.Owner.OnOptionConnected(e);
+        }
+        protected void STNodeEidtorDisConnected(STNodeEditorOptionEventArgs e) {
+            if (this._Owner == null) return;
+            if (this._Owner.Owner == null) return;
+            this._Owner.Owner.OnOptionDisConnected(e);
+        }
+        /// <summary>
+        /// The current Option starts to connect to the target Option
+        /// </summary>
+        /// <param name="op">Option to connect</param>
+        /// <returns>Are you allowed to continue the operation?</returns>
+        protected virtual bool ConnectingOption(STNodeOption op) {
+            if (this._Owner == null) return false;
+            if (this._Owner.Owner == null) return false;
+            STNodeEditorOptionEventArgs e = new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Connecting);
+            this._Owner.Owner.OnOptionConnecting(e);
+            this.OnConnecting(new STNodeOptionEventArgs(true, op, ConnectionStatus.Connecting));
+            op.OnConnecting(new STNodeOptionEventArgs(false, this, ConnectionStatus.Connecting));
+            return e.Continue;
+        }
+        /// <summary>
+        /// The current Option starts to disconnect the target Option
+        /// </summary>
+        /// <param name="op">Option to be disconnected</param>
+        /// <returns>Are you allowed to continue the operation?</returns>
+        protected virtual bool DisConnectingOption(STNodeOption op) {
+            if (this._Owner == null) return false;
+            if (this._Owner.Owner == null) return false;
+            STNodeEditorOptionEventArgs e = new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.DisConnecting);
+            this._Owner.Owner.OnOptionDisConnecting(e);
+            this.OnDisConnecting(new STNodeOptionEventArgs(true, op, ConnectionStatus.DisConnecting));
+            op.OnDisConnecting(new STNodeOptionEventArgs(false, this, ConnectionStatus.DisConnecting));
+            return e.Continue;
+        }
+
+        #endregion protected
+
+        #region public
+        /// <summary>
+        /// The current Option is connected to the target Option
+        /// </summary>
+        /// <param name="op">Option to connect</param>
+        /// <returns>Connection result</returns>
+        public virtual ConnectionStatus ConnectOption(STNodeOption op) {
+            if (!this.ConnectingOption(op)) {
+                this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Reject));
+                return ConnectionStatus.Reject;
+            }
+
+            var v = this.CanConnect(op);
+            if (v != ConnectionStatus.Connected) {
+                this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, v));
+                return v;
+            }
+            v = op.CanConnect(this);
+            if (v != ConnectionStatus.Connected) {
+                this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, v));
+                return v;
+            }
+            op.AddConnection(this, false);
+            this.AddConnection(op, true);
+            this.ControlBuildLinePath();
+
+            this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, v));
+            return v;
+        }
+        /// <summary>
+        /// Check whether the current Option can connect to the target Option
+        /// </summary>
+        /// <param name="op">Option to connect</param>
+        /// <returns>Test results</returns>
+        public virtual ConnectionStatus CanConnect(STNodeOption op) {
+            if (this == STNodeOption.Empty || op == STNodeOption.Empty) return ConnectionStatus.EmptyOption;
+            if (this._IsInput == op.IsInput) return ConnectionStatus.SameInputOrOutput;
+            if (op.Owner == null || this._Owner == null) return ConnectionStatus.NoOwner;
+            if (op.Owner == this._Owner) return ConnectionStatus.SameOwner;
+            if (this._Owner.LockOption || op._Owner.LockOption) return ConnectionStatus.Locked;
+            if (this._IsSingle && m_hs_connected.Count == 1) return ConnectionStatus.SingleOption;
+            if (op.IsInput && STNodeEditor.CanFindNodePath(op.Owner, this._Owner)) return ConnectionStatus.Loop;
+            if (m_hs_connected.Contains(op)) return ConnectionStatus.Exists;
+            if (this._IsInput && op._DataType != this._DataType && !op._DataType.IsSubclassOf(this._DataType)) return ConnectionStatus.ErrorType;
+            return ConnectionStatus.Connected;
+        }
+        /// <summary>
+        /// The current Option disconnects the target Option
+        /// </summary>
+        /// <param name="op">Option to be disconnected</param>
+        /// <returns></returns>
+        public virtual ConnectionStatus DisConnectOption(STNodeOption op) {
+            if (!this.DisConnectingOption(op)) {
+                this.STNodeEidtorDisConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Reject));
+                return ConnectionStatus.Reject;
+            }
+
+            if (op.Owner == null) return ConnectionStatus.NoOwner;
+            if (this._Owner == null) return ConnectionStatus.NoOwner;
+            if (op.Owner.LockOption && this._Owner.LockOption) {
+                this.STNodeEidtorDisConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Locked));
+                return ConnectionStatus.Locked;
+            }
+            op.RemoveConnection(this, false);
+            this.RemoveConnection(op, true);
+            this.ControlBuildLinePath();
+
+            this.STNodeEidtorDisConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.DisConnected));
+            return ConnectionStatus.DisConnected;
+        }
+        /// <summary>
+        /// Disconnect all connections of the current Option
+        /// </summary>
+        public void DisConnectionAll() {
+            if (this._DataType == null) return;
+            var arr = m_hs_connected.ToArray();
+            foreach (var v in arr) {
+                this.DisConnectOption(v);
+            }
+        }
+        /// <summary>
+        /// Get the Option collection that the current Option is connected to
+        /// </summary>
+        /// <returns>If it is null, it means that there is no owner, otherwise it returns the collection</returns>
+        public List<STNodeOption> GetConnectedOption() {
+            if (this._DataType == null) return null;
+            if (!this._IsInput)
+                return m_hs_connected.ToList();
+            List<STNodeOption> lst = new List<STNodeOption>();
+            if (this._Owner == null) return null;
+            if (this._Owner.Owner == null) return null;
+            foreach (var v in this._Owner.Owner.GetConnectionInfo()) {
+                if (v.Output == this) lst.Add(v.Input);
+            }
+            return lst;
+        }
+        /// <summary>
+        /// Post data to all Option connected to the current Option
+        /// </summary>
+        public void TransferData() {
+            if (this._DataType == null) return;
+            foreach (var v in m_hs_connected) {
+                v.OnDataTransfer(new STNodeOptionEventArgs(true, this, ConnectionStatus.Connected));
+            }
+        }
+        /// <summary>
+        /// Post data to all Option connected to the current Option
+        /// </summary>
+        /// <param name="data">Data to be delivered</param>
+        public void TransferData(object data) {
+            if (this._DataType == null) return;
+            this.Data = data; //not this._Data
+            foreach (var v in m_hs_connected) {
+                v.OnDataTransfer(new STNodeOptionEventArgs(true, this, ConnectionStatus.Connected));
+            }
+        }
+        /// <summary>
+        /// Post data to all Option connected to the current Option
+        /// </summary>
+        /// <param name="data">Data to be delivered</param>
+        /// <param name="bDisposeOld">Whether to release old data</param>
+        public void TransferData(object data, bool bDisposeOld) {
+            if (bDisposeOld && this._Data != null) {
+                if (this._Data is IDisposable) ((IDisposable)this._Data).Dispose();
+                this._Data = null;
+            }
+            this.TransferData(data);
+        }
+
+        #endregion public
+
+        #region internal
+
+        private bool AddConnection(STNodeOption op, bool bSponsor) {
+            if (this._DataType == null) return false;
+            bool b = m_hs_connected.Add(op);
+            this.OnConnected(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.Connected));
+            if (this._IsInput) this.OnDataTransfer(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.Connected));
+            return b;
+        }
+
+        private bool RemoveConnection(STNodeOption op, bool bSponsor) {
+            if (this._DataType == null) return false;
+            bool b = false;
+            if (m_hs_connected.Contains(op)) {
+                b = m_hs_connected.Remove(op);
+                if (this._IsInput) this.OnDataTransfer(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.DisConnected));
+                this.OnDisConnected(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.Connected));
+            }
+            return b;
+        }
+
+        #endregion internal
+
+        #region private
+
+        private void ControlBuildLinePath() {
+            if (this.Owner == null) return;
+            if (this.Owner.Owner == null) return;
+            this.Owner.Owner.BuildLinePath();
+        }
+
+        #endregion
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeOptionCollection.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Collections;
+
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeOptionCollection : IList, ICollection, IEnumerable
+    {
+        /*
+         * Although the collection provides a complete data interface such as: Add,Remove,...
+         * But try not to use some removal operations such as: Remove,RemoveAt,Clear,this[index] = value,...
+         * Because the Owner of each Option is strictly bound in my definition, some operations such as removal or replacement will affect the change of the Owner
+         * So all the original connections will be disconnected and the DisConnect event will be triggered
+         * To ensure security, only inheritors can access the collection in STNode
+         */
+        private int _Count;
+        public int Count { get { return _Count; } }
+        private STNodeOption[] m_options;
+        private STNode m_owner;
+
+        private bool m_isInput; //Whether the current collection stores the input point
+
+        internal STNodeOptionCollection(STNode owner, bool isInput) {
+            if (owner == null) throw new ArgumentNullException("Owner cannot be null");
+            m_owner = owner;
+            m_isInput = isInput;
+            m_options = new STNodeOption[4];
+        }
+
+        public STNodeOption Add(string strText, Type dataType, bool bSingle) {
+            //not do this code -> out of bounds
+            //return m_options[this.Add(new STNodeOption(strText, dataType, bSingle))];
+            int nIndex = this.Add(new STNodeOption(strText, dataType, bSingle));
+            return m_options[nIndex];
+        }
+
+        public int Add(STNodeOption option) {
+            if (option == null) throw new ArgumentNullException("Add object cannot be null");
+            this.EnsureSpace(1);
+            int nIndex = option == STNodeOption.Empty ? -1 : this.IndexOf(option);
+            if (-1 == nIndex) {
+                nIndex = this._Count;
+                option.Owner = m_owner;
+                option.IsInput = m_isInput;
+                m_options[this._Count++] = option;
+                this.Invalidate();
+            }
+            return nIndex;
+        }
+
+        public void AddRange(STNodeOption[] options) {
+            if (options == null) throw new ArgumentNullException("Add object cannot be null");
+            this.EnsureSpace(options.Length);
+            foreach (var op in options) {
+                if (op == null) throw new ArgumentNullException("Add object cannot be null");
+                if (-1 == this.IndexOf(op)) {
+                    op.Owner = m_owner;
+                    op.IsInput = m_isInput;
+                    m_options[this._Count++] = op;
+                }
+            }
+            this.Invalidate();
+        }
+
+        public void Clear() {
+            for (int i = 0; i < this._Count; i++) m_options[i].Owner = null;
+            this._Count = 0;
+            m_options = new STNodeOption[4];
+            this.Invalidate();
+        }
+
+        public bool Contains(STNodeOption option) {
+            return this.IndexOf(option) != -1;
+        }
+
+        public int IndexOf(STNodeOption option) {
+            return Array.IndexOf<STNodeOption>(m_options, option);
+        }
+
+        public void Insert(int index, STNodeOption option) {
+            if (index < 0 || index >= this._Count)
+                throw new IndexOutOfRangeException("Index out of bounds");
+            if (option == null)
+                throw new ArgumentNullException("Insert object cannot be null");
+            this.EnsureSpace(1);
+            for (int i = this._Count; i > index; i--)
+                m_options[i] = m_options[i - 1];
+            option.Owner = m_owner;
+            m_options[index] = option;
+            this._Count++;
+            this.Invalidate();
+        }
+
+        public bool IsFixedSize {
+            get { return false; }
+        }
+
+        public bool IsReadOnly {
+            get { return false; }
+        }
+
+        public void Remove(STNodeOption option) {
+            int nIndex = this.IndexOf(option);
+            if (nIndex != -1) this.RemoveAt(nIndex);
+        }
+
+        public void RemoveAt(int index) {
+            if (index < 0 || index >= this._Count)
+                throw new IndexOutOfRangeException("Index out of bounds");
+            this._Count--;
+            m_options[index].Owner = null;
+            for (int i = index, Len = this._Count; i < Len; i++)
+                m_options[i] = m_options[i + 1];
+            this.Invalidate();
+        }
+
+        public STNodeOption this[int index] {
+            get {
+                if (index < 0 || index >= this._Count)
+                    throw new IndexOutOfRangeException("Index out of bounds");
+                return m_options[index];
+            }
+            set { throw new InvalidOperationException("No reassignment of elements"); }
+        }
+
+        public void CopyTo(Array array, int index) {
+            if (array == null)
+                throw new ArgumentNullException("Array cannot be empty");
+            m_options.CopyTo(array, index);
+        }
+
+        public bool IsSynchronized {
+            get { return true; }
+        }
+
+        public object SyncRoot {
+            get { return this; }
+        }
+
+        public IEnumerator GetEnumerator() {
+            for (int i = 0, Len = this._Count; i < Len; i++)
+                yield return m_options[i];
+        }
+        /// <summary>
+        /// Check if there is enough space to expand the capacity
+        /// </summary>
+        /// <param name="elements">Number of elements to be added</param>
+        private void EnsureSpace(int elements) {
+            if (elements + this._Count > m_options.Length) {
+                STNodeOption[] arrTemp = new STNodeOption[Math.Max(m_options.Length * 2, elements + this._Count)];
+                m_options.CopyTo(arrTemp, 0);
+                m_options = arrTemp;
+            }
+        }
+
+        protected void Invalidate() {
+            if (m_owner != null && m_owner.Owner != null) {
+                m_owner.BuildSize(true, true, true);
+                //m_owner.Invalidate();//.Owner.Invalidate();
+            }
+        }
+        //===================================================================================
+        int IList.Add(object value) {
+            return this.Add((STNodeOption)value);
+        }
+
+        void IList.Clear() {
+            this.Clear();
+        }
+
+        bool IList.Contains(object value) {
+            return this.Contains((STNodeOption)value);
+        }
+
+        int IList.IndexOf(object value) {
+            return this.IndexOf((STNodeOption)value);
+        }
+
+        void IList.Insert(int index, object value) {
+            this.Insert(index, (STNodeOption)value);
+        }
+
+        bool IList.IsFixedSize {
+            get { return this.IsFixedSize; }
+        }
+
+        bool IList.IsReadOnly {
+            get { return this.IsReadOnly; }
+        }
+
+        void IList.Remove(object value) {
+            this.Remove((STNodeOption)value);
+        }
+
+        void IList.RemoveAt(int index) {
+            this.RemoveAt(index);
+        }
+
+        object IList.this[int index] {
+            get {
+                return this[index];
+            }
+            set {
+                this[index] = (STNodeOption)value;
+            }
+        }
+
+        void ICollection.CopyTo(Array array, int index) {
+            this.CopyTo(array, index);
+        }
+
+        int ICollection.Count {
+            get { return this._Count; }
+        }
+
+        bool ICollection.IsSynchronized {
+            get { return this.IsSynchronized; }
+        }
+
+        object ICollection.SyncRoot {
+            get { return this.SyncRoot; }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() {
+            return this.GetEnumerator();
+        }
+
+        public STNodeOption[] ToArray() {
+            STNodeOption[] ops = new STNodeOption[this._Count];
+            for (int i = 0; i < ops.Length; i++)
+                ops[i] = m_options[i];
+            return ops;
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodePropertyAttribute.cs

@@ -0,0 +1,334 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Drawing;
+using System.Reflection;
+using System.Windows.Forms;
+
+namespace ST.Library.UI.NodeEditor
+{
+    /// <summary>
+    /// STNode node attribute characteristics
+    /// Used to describe STNode node attribute information and behavior on the attribute editor
+    /// </summary>
+    public class STNodePropertyAttribute : Attribute
+    {
+        private string _Name;
+        /// <summary>
+        /// Get the name of the property that needs to be displayed on the property editor
+        /// </summary>
+        public string Name {
+            get { return _Name; }
+        }
+
+        private string _Description;
+        /// <summary>
+        /// Get the description of the property that needs to be displayed on the property editor
+        /// </summary>
+        public string Description {
+            get { return _Description; }
+        }
+
+        private Type _ConverterType = typeof(STNodePropertyDescriptor);
+        /// <summary>
+        /// Get the property descriptor type
+        /// </summary>
+        public Type DescriptorType {
+            get { return _ConverterType; }
+            set { _ConverterType = value; }
+        }
+
+        /// <summary>
+        /// Constructs an STNode property attribute
+        /// </summary>
+        /// <param name="strKey">Name to be displayed</param>
+        /// <param name="strDesc">Description information to be displayed</param>
+        public STNodePropertyAttribute(string strKey, string strDesc) {
+            this._Name = strKey;
+            this._Description = strDesc;
+        }
+        //private Type m_descriptor_type_base = typeof(STNodePropertyDescriptor);
+    }
+    /// <summary>
+    /// STNode property descriptor
+    /// Used to determine how to interact with the property's value on the property editor and to determine how the property's value will be drawn and interacted on the property editor
+    /// </summary>
+    public class STNodePropertyDescriptor
+    {
+        /// <summary>
+        /// Get the target node
+        /// </summary>
+        public STNode Node { get; internal set; }
+        /// <summary>
+        /// Get the node attribute editor control to which it belongs
+        /// </summary>
+        public STNodePropertyGrid Control { get; internal set; }
+        /// <summary>
+        /// Get the area where the option is located
+        /// </summary>
+        public Rectangle Rectangle { get; internal set; }
+        /// <summary>
+        /// Get the area where the option name is located
+        /// </summary>
+        public Rectangle RectangleL { get; internal set; }
+        /// <summary>
+        /// Get the area where the option value is located
+        /// </summary>
+        public Rectangle RectangleR { get; internal set; }
+        /// <summary>
+        /// Get the name of the option that needs to be displayed
+        /// </summary>
+        public string Name { get; internal set; }
+        /// <summary>
+        /// Get the description information corresponding to the attribute
+        /// </summary>
+        public string Description { get; internal set; }
+        /// <summary>
+        /// Get attribute information
+        /// </summary>
+        public PropertyInfo PropertyInfo { get; internal set; }
+
+        private static Type m_t_int = typeof(int);
+        private static Type m_t_float = typeof(float);
+        private static Type m_t_double = typeof(double);
+        private static Type m_t_string = typeof(string);
+        private static Type m_t_bool = typeof(bool);
+
+        private StringFormat m_sf;
+
+        /// <summary>
+        /// Construct a descriptor
+        /// </summary>
+        public STNodePropertyDescriptor() {
+            m_sf = new StringFormat();
+            m_sf.LineAlignment = StringAlignment.Center;
+            m_sf.FormatFlags = StringFormatFlags.NoWrap;
+        }
+
+        /// <summary>
+        /// Occurs when determining the position of the STNode property on the property editor
+        /// </summary>
+        protected internal virtual void OnSetItemLocation() { }
+        /// <summary>
+        /// Converts the property value in the form of a string to the value of the property target type
+        /// By default, only int float double string bool and Array of the above types are supported
+        /// If the target type is not in the above, please rewrite this function to convert it yourself
+        /// </summary>
+        /// <param name="strText">Attribute value in string form</param>
+        /// <returns>The value of the real target type of the attribute</returns>
+        protected internal virtual object GetValueFromString(string strText) {
+            Type t = this.PropertyInfo.PropertyType;
+            if (t == m_t_int) return int.Parse(strText);
+            if (t == m_t_float) return float.Parse(strText);
+            if (t == m_t_double) return double.Parse(strText);
+            if (t == m_t_string) return strText;
+            if (t == m_t_bool) return bool.Parse(strText);
+            if (t.IsEnum) {
+                return Enum.Parse(t, strText);
+            } else if (t.IsArray) {
+                var t_1 = t.GetElementType();
+                if (t_1 == m_t_string) return strText.Split(',');
+                string[] strs = strText.Trim(new char[] { ' ', ',' }).Split(',');//add other place trim()
+                if (t_1 == m_t_int) {
+                    int[] arr = new int[strs.Length];
+                    for (int i = 0; i < strs.Length; i++) arr[i] = int.Parse(strs[i].Trim());
+                    return arr;
+                }
+                if (t_1 == m_t_float) {
+                    float[] arr = new float[strs.Length];
+                    for (int i = 0; i < strs.Length; i++) arr[i] = float.Parse(strs[i].Trim());
+                    return arr;
+                }
+                if (t_1 == m_t_int) {
+                    double[] arr = new double[strs.Length];
+                    for (int i = 0; i < strs.Length; i++) arr[i] = double.Parse(strs[i].Trim());
+                    return arr;
+                }
+                if (t_1 == m_t_int) {
+                    bool[] arr = new bool[strs.Length];
+                    for (int i = 0; i < strs.Length; i++) arr[i] = bool.Parse(strs[i].Trim());
+                    return arr;
+                }
+            }
+            throw new InvalidCastException("Unable to complete the conversion of [string] to [" + t.FullName + "], please overload [STNodePropertyDescriptor.GetValueFromString(string)]");
+        }
+        /// <summary>
+        /// Converts the value of the attribute target type to a value in the form of a string
+        /// ToString() operation on type value by default
+        /// If you need special processing, please rewrite this function to convert it yourself
+        /// </summary>
+        /// <returns>String form of attribute value</returns>
+        protected internal virtual string GetStringFromValue() {
+            var v = this.PropertyInfo.GetValue(this.Node, null);
+            var t = this.PropertyInfo.PropertyType;
+            if (v == null) return null;
+            if (t.IsArray) {
+                List<string> lst = new List<string>();
+                foreach (var item in (Array)v) lst.Add(item.ToString());
+                return string.Join(",", lst.ToArray());
+            }
+            return v.ToString();
+        }
+        /// <summary>
+        /// Convert the attribute value in binary form to the value of the attribute target type for restoring the attribute value from the data in the file store
+        /// Convert it to a string by default and then call GetValueFromString(string)
+        /// This function corresponds to GetBytesFromValue(). If the function needs to be rewritten, the two functions should be rewritten together
+        /// </summary>
+        /// <param name="byData">Binary data</param>
+        /// <returns>The value of the real target type of the attribute</returns>
+        protected internal virtual object GetValueFromBytes(byte[] byData) {
+            if (byData == null) return null;
+            string strText = Encoding.UTF8.GetString(byData);
+            return this.GetValueFromString(strText);
+        }
+        /// <summary>
+        /// Called when converting the value of the attribute target type to a binary value for file storage
+        /// Calls GetStringFromValue() by default and converts the string to binary data
+        /// For special handling, please rewrite this function to convert it yourself and rewrite GetValueFromBytes()
+        /// </summary>
+        /// <returns>Binary form of attribute value</returns>
+        protected internal virtual byte[] GetBytesFromValue() {
+            string strText = this.GetStringFromValue();
+            if (strText == null) return null;
+            return Encoding.UTF8.GetBytes(strText);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.GetValue()
+        /// </summary>
+        /// <param name="index">The optional index value of the indexed attribute should be null for non-indexed attributes</param>
+        /// <returns>Attribute value</returns>
+        protected internal virtual object GetValue(object[] index) {
+            return this.PropertyInfo.GetValue(this.Node, index);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.SetValue()
+        /// </summary>
+        /// <param name="value">Attribute value to be set</param>
+        protected internal virtual void SetValue(object value) {
+            this.PropertyInfo.SetValue(this.Node, value, null);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.SetValue()
+        /// GetValueFromString(strValue) will be processed by default before calling
+        /// </summary>
+        /// <param name="strValue">The value of the attribute string that needs to be set</param>
+        protected internal virtual void SetValue(string strValue) {
+            this.PropertyInfo.SetValue(this.Node, this.GetValueFromString(strValue), null);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.SetValue()
+        /// GetValueFromBytes(byte[]) will be processed by default before calling
+        /// </summary>
+        /// <param name="byData">Attribute binary data to be set</param>
+        protected internal virtual void SetValue(byte[] byData) {
+            this.PropertyInfo.SetValue(this.Node, this.GetValueFromBytes(byData), null);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.SetValue()
+        /// </summary>
+        /// <param name="value">Attribute value to be set</param>
+        /// <param name="index">The optional index value of the indexed attribute should be null for non-indexed attributes</param>
+        protected internal virtual void SetValue(object value, object[] index) {
+            this.PropertyInfo.SetValue(this.Node, value, index);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.SetValue()
+        /// GetValueFromString(strValue) will be processed by default before calling
+        /// </summary>
+        /// <param name="strValue">The value of the attribute string that needs to be set</param>
+        /// <param name="index">The optional index value of the indexed attribute should be null for non-indexed attributes</param>
+        protected internal virtual void SetValue(string strValue, object[] index) {
+            this.PropertyInfo.SetValue(this.Node, this.GetValueFromString(strValue), index);
+        }
+        /// <summary>
+        /// This function corresponds to System.Reflection.PropertyInfo.SetValue()
+        /// GetValueFromBytes(byte[]) will be processed by default before calling
+        /// </summary>
+        /// <param name="byData">Attribute binary data to be set</param>
+        /// <param name="index">The optional index value of the indexed attribute should be null for non-indexed attributes</param>
+        protected internal virtual void SetValue(byte[] byData, object[] index) {
+            this.PropertyInfo.SetValue(this.Node, this.GetValueFromBytes(byData), index);
+        }
+        /// <summary>
+        /// Occurs when there is an error setting the property value
+        /// </summary>
+        /// <param name="ex">Exception information</param>
+        protected internal virtual void OnSetValueError(Exception ex) {
+            this.Control.SetErrorMessage(ex.Message);
+        }
+        /// <summary>
+        /// Occurs when drawing the property's value area on the property editor
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        protected internal virtual void OnDrawValueRectangle(DrawingTools dt) {
+            Graphics g = dt.Graphics;
+            SolidBrush brush = dt.SolidBrush;
+            STNodePropertyGrid ctrl = this.Control;
+            //STNodePropertyItem item = this._PropertyItem;
+            brush.Color = ctrl.ItemValueBackColor;
+
+            g.FillRectangle(brush, this.RectangleR);
+            Rectangle rect = this.RectangleR;
+            rect.Width--; rect.Height--;
+            brush.Color = this.Control.ForeColor;
+            g.DrawString(this.GetStringFromValue(), ctrl.Font, brush, this.RectangleR, m_sf);
+
+            if (this.PropertyInfo.PropertyType.IsEnum || this.PropertyInfo.PropertyType == m_t_bool) {
+                g.FillPolygon(Brushes.Gray, new Point[]{
+                        new Point(rect.Right - 13, rect.Top + rect.Height / 2 - 2),
+                        new Point(rect.Right - 4, rect.Top + rect.Height / 2 - 2),
+                        new Point(rect.Right - 9, rect.Top + rect.Height / 2 + 3)
+                    });
+            }
+        }
+        /// <summary>
+        /// Occurs when the mouse enters the area where the property value is located
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected internal virtual void OnMouseEnter(EventArgs e) { }
+        /// <summary>
+        /// Occurs when the mouse is clicked in the area where the property value is located
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected internal virtual void OnMouseDown(MouseEventArgs e) {
+        }
+        /// <summary>
+        /// Occurs when the mouse moves in the area where the property value is located
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected internal virtual void OnMouseMove(MouseEventArgs e) { }
+        /// <summary>
+        /// Occurs when the mouse is raised in the area where the property value is located
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected internal virtual void OnMouseUp(MouseEventArgs e) { }
+        /// <summary>
+        /// Occurs when the mouse leaves the area where the property value is located
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected internal virtual void OnMouseLeave(EventArgs e) { }
+        /// <summary>
+        /// Occurs when the mouse is clicked in the area where the property value is located
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected internal virtual void OnMouseClick(MouseEventArgs e) {
+            Type t = this.PropertyInfo.PropertyType;
+            if (t == m_t_bool || t.IsEnum) {
+                new FrmSTNodePropertySelect(this).Show(this.Control);
+                return;
+            }
+            Rectangle rect = this.Control.RectangleToScreen(this.RectangleR);
+            new FrmSTNodePropertyInput(this).Show(this.Control);
+        }
+        /// <summary>
+        /// Redraw the options area
+        /// </summary>
+        public void Invalidate() {
+            Rectangle rect = this.Rectangle;
+            rect.X -= this.Control.ScrollOffset;
+            this.Control.Invalidate(rect);
+        }
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodePropertyGrid.cs

@@ -0,0 +1,860 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Drawing;
+using System.Reflection;
+using System.Windows.Forms;
+using System.ComponentModel;
+/*
+MIT License
+
+Copyright (c) 2021 DebugST@crystal_lz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+/*
+ * create: 2021-01-28
+ * modify: 2021-03-02
+ * Author: Crystal_lz
+ * blog: http://st233.com
+ * Gitee: https://gitee.com/DebugST
+ * Github: https://github.com/DebugST
+ */
+namespace ST.Library.UI.NodeEditor
+{
+    /// <summary>
+    /// STNode node attribute editor
+    /// </summary>
+    public class STNodePropertyGrid : Control
+    {
+        #region properties ==========
+
+        private STNode _STNode;
+        /// <summary>
+        /// The currently displayed STNode
+        /// </summary>
+        [Description("Currently displayed STNode"), Browsable(false)]
+        public STNode STNode {
+            get { return _STNode; }
+        }
+
+        private Color _ItemHoverColor = Color.FromArgb(50, 125, 125, 125);
+        /// <summary>
+        /// Gets or sets the background color when the property option is hovered by the mouse
+        /// </summary>
+        [Description("Get or set the background color when the property option is hovered by the mouse")]
+        public Color ItemHoverColor {
+            get { return _ItemHoverColor; }
+            set { _ItemHoverColor = value; }
+        }
+
+        private Color _ItemSelectedColor = Color.DodgerBlue;
+        /// <summary>
+        /// Gets or sets the background color when the property option is selected. This property cannot be set when AutoColor is set
+        /// </summary>
+        [Description("Background color when get or set property option is selected and this property cannot be set when AutoColor is set"), DefaultValue(typeof(Color), "DodgerBlue")]
+        public Color ItemSelectedColor {
+            get { return _ItemSelectedColor; }
+            set {
+                if (this._AutoColor) return;
+                if (value == _ItemSelectedColor) return;
+                _ItemSelectedColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private Color _ItemValueBackColor = Color.FromArgb(255, 80, 80, 80);
+        /// <summary>
+        /// Gets or sets the background color of the attribute option value
+        /// </summary>
+        [Description("Get or set attribute option value background color")]
+        public Color ItemValueBackColor {
+            get { return _ItemValueBackColor; }
+            set {
+                _ItemValueBackColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private Color _TitleColor = Color.FromArgb(127, 0, 0, 0);
+        /// <summary>
+        /// Gets or sets the default title background color
+        /// </summary>
+        [Description("Get or set the default title background color")]
+        public Color TitleColor {
+            get { return _TitleColor; }
+            set {
+                _TitleColor = value;
+                if (!this._ShowTitle) return;
+                this.Invalidate(m_rect_title);
+            }
+        }
+
+        private Color _ErrorColor = Color.FromArgb(200, Color.Brown);
+        /// <summary>
+        /// Get or set the background color of the prompt message when the property is set incorrectly
+        /// </summary>
+        [Description("Get or set the background color of the message when the property is set incorrectly")]
+        public Color ErrorColor {
+            get { return _ErrorColor; }
+            set { _ErrorColor = value; }
+        }
+
+        private Color _DescriptionColor = Color.FromArgb(200, Color.DarkGoldenrod);
+        /// <summary>
+        /// Gets or sets the background color of the attribute description information
+        /// </summary>
+        [Description("Get or set the background color of attribute description information")]
+        public Color DescriptionColor {
+            get { return _DescriptionColor; }
+            set { _DescriptionColor = value; }
+        }
+
+        private bool _ShowTitle = true;
+        /// <summary>
+        /// Gets or sets whether to display the node title
+        /// </summary>
+        [Description("Get or set whether to display the node title")]
+        public bool ShowTitle {
+            get { return _ShowTitle; }
+            set {
+                _ShowTitle = value;
+                this.SetItemRectangle();
+                this.Invalidate();
+            }
+        }
+
+        private bool _AutoColor = true;
+        /// <summary>
+        /// Get or set whether to automatically set the control highlight color according to STNode
+        /// </summary>
+        [Description("Get or set whether to automatically set the control highlight color according to STNode"), DefaultValue(true)]
+        public bool AutoColor {
+            get { return _AutoColor; }
+            set { _AutoColor = value; }
+        }
+
+        private bool _InfoFirstOnDraw;
+        /// <summary>
+        /// Gets or whether the information panel is drawn first when the node is set
+        /// </summary>
+        [Description("Get or set whether to draw the information panel first when the node is set"), DefaultValue(false)]
+        public bool InfoFirstOnDraw {
+            get { return _InfoFirstOnDraw; }
+            set { _InfoFirstOnDraw = value; }
+        }
+
+        private bool _ReadOnlyModel;
+        /// <summary>
+        /// Gets or sets whether the current property editor is in read-only mode
+        /// </summary>
+        [Description("Get or set whether the current property editor is in read-only mode"), DefaultValue(false)]
+        public bool ReadOnlyModel {
+            get { return _ReadOnlyModel; }
+            set {
+                if (value == _ReadOnlyModel) return;
+                _ReadOnlyModel = value;
+                this.Invalidate(m_rect_title);
+            }
+        }
+        /// <summary>
+        /// Get the current scroll bar height
+        /// </summary>
+        [Description("Get the current scroll bar height")]
+        public int ScrollOffset { get { return m_nOffsetY; } }
+
+        #endregion
+
+        #region protected fields ==========
+
+        /// <summary>
+        /// Author link address area
+        /// </summary>
+        protected Rectangle m_rect_link;
+        /// <summary>
+        /// View the help button area
+        /// </summary>
+        protected Rectangle m_rect_help;
+        /// <summary>
+        /// Editor title area
+        /// </summary>
+        protected Rectangle m_rect_title;
+        /// <summary>
+        /// Panel toggle button area
+        /// </summary>
+        protected Rectangle m_rect_switch;
+
+        /// <summary>
+        /// The vertical scroll offset used by the control during drawing
+        /// </summary>
+        protected int m_nOffsetY;
+        /// <summary>
+        /// Saved info panel vertical scroll offset
+        /// </summary>
+        protected int m_nInfoOffsetY;
+        /// <summary>
+        /// Saved property panel vertical scroll offset
+        /// </summary>
+        protected int m_nPropertyOffsetY;
+
+        /// <summary>
+        /// The total height of the drawing area used by the control during drawing
+        /// </summary>
+        protected int m_nVHeight;
+        /// <summary>
+        /// The total height required for the saved info panel
+        /// </summary>
+        protected int m_nInfoVHeight;
+        /// <summary>
+        /// The total height required by the saved property panel
+        /// </summary>
+        protected int m_nPropertyVHeight;
+        /// <summary>
+        /// Key in the information panel displays the required horizontal width
+        /// </summary>
+        protected int m_nInfoLeft;
+
+        #endregion
+
+        private Type m_type;
+        private string[] m_KeysString = new string[] { "author", "email", "link", "view help" };
+
+        private int m_nTitleHeight = 20;
+        private int m_item_height = 30;
+        private Color m_clr_item_1 = Color.FromArgb(10, 0, 0, 0);
+        private Color m_clr_item_2 = Color.FromArgb(10, 255, 255, 255);
+        //All property lists are saved in this List
+        private List<STNodePropertyDescriptor> m_lst_item = new List<STNodePropertyDescriptor>();
+
+        private STNodePropertyDescriptor m_item_hover; //The currently hovered option
+        private STNodePropertyDescriptor m_item_hover_value; //The current value area is hovered by the mouse
+        private STNodePropertyDescriptor m_item_down_value; //The option that the current value area is clicked by the mouse
+        private STNodePropertyDescriptor m_item_selected; //The currently selected option
+        private STNodeAttribute m_node_attribute; //Node parameter information
+        private bool m_b_hover_switch; //Whether the mouse hovers over the panel switch button
+        private bool m_b_current_draw_info; //The current drawing is the information panel
+
+        private Point m_pt_move; //The real-time coordinates of the mouse on the control
+        private Point m_pt_down; //The coordinates of the last mouse click on the control
+        private string m_str_err; // draw error message when set
+        private string m_str_desc; //Draw description information when set
+
+        private Pen m_pen;
+        private SolidBrush m_brush;
+        private StringFormat m_sf;
+        private DrawingTools m_dt;
+
+        /// <summary>
+        /// Construct a node attribute editor
+        /// </summary>
+        public STNodePropertyGrid() {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+
+            m_pen = new Pen(Color.Black, 1);
+            m_brush = new SolidBrush(Color.Black);
+            m_sf = new StringFormat();
+            m_sf.LineAlignment = StringAlignment.Center;
+            m_sf.FormatFlags = StringFormatFlags.NoWrap;
+            m_dt.Pen = m_pen;
+            m_dt.SolidBrush = m_brush;
+
+            this.ForeColor = Color.White;
+            this.BackColor = Color.FromArgb(255, 35, 35, 35);
+
+            this.MinimumSize = new Size(120, 50);
+            this.Size = new Size(200, 150);
+        }
+
+        #region private method ==========
+
+        private List<STNodePropertyDescriptor> GetProperties(STNode node) {
+            List<STNodePropertyDescriptor> lst = new List<STNodePropertyDescriptor>();
+            if (node == null) return lst;
+            Type t = node.GetType();
+            foreach (var p in t.GetProperties()) {
+                var attrs = p.GetCustomAttributes(true);
+                foreach (var a in attrs) {
+                    if (!(a is STNodePropertyAttribute)) continue;
+                    var attr = a as STNodePropertyAttribute;
+                    object obj = Activator.CreateInstance(attr.DescriptorType);
+                    if (!(obj is STNodePropertyDescriptor))
+                        throw new ArgumentException("[STNodePropertyAttribute.DescriptorType] parameter value must be the type of [STNodePropertyDescriptor] or its subclass");
+                    var desc = (STNodePropertyDescriptor)Activator.CreateInstance(attr.DescriptorType);
+                    desc.Node = node;
+                    desc.Name = attr.Name;
+                    desc.Description = attr.Description;
+                    desc.PropertyInfo = p;
+                    desc.Control = this;
+                    lst.Add(desc);
+                }
+            }
+            return lst;
+        }
+
+        private STNodeAttribute GetNodeAttribute(STNode node) {
+            if (node == null) return null;
+            Type t = node.GetType();
+            foreach (var v in t.GetCustomAttributes(true)) {
+                if (!(v is STNodeAttribute)) continue;
+                return (STNodeAttribute)v;
+            }
+            return null;
+        }
+
+        private void SetItemRectangle() {
+            int nw_p = 0, nw_h = 0;
+            using (Graphics g = this.CreateGraphics()) {
+                foreach (var v in m_lst_item) {
+                    SizeF szf = g.MeasureString(v.Name, this.Font);
+                    if (szf.Width > nw_p) nw_p = (int)Math.Ceiling(szf.Width);
+                }
+                for (int i = 0; i < m_KeysString.Length - 1; i++) {
+                    SizeF szf = g.MeasureString(m_KeysString[i], this.Font);
+                    if (szf.Width > nw_h) nw_h = (int)Math.Ceiling(szf.Width);
+                }
+                nw_p += 5; nw_h += 5;
+                nw_p = Math.Min(nw_p, this.Width >> 1);
+                m_nInfoLeft = Math.Min(nw_h, this.Width >> 1);
+
+                int nTitleHeight = this._ShowTitle ? m_nTitleHeight : 0;
+                for (int i = 0; i < m_lst_item.Count; i++) {
+                    STNodePropertyDescriptor item = m_lst_item[i];
+                    Rectangle rect = new Rectangle(0, i * m_item_height + nTitleHeight, this.Width, m_item_height);
+                    item.Rectangle = rect;
+                    rect.Width = nw_p;
+                    item.RectangleL = rect;
+                    rect.X = rect.Right;
+                    rect.Width = this.Width - rect.Left - 1;
+                    rect.Inflate(-4, -4);
+                    item.RectangleR = rect;
+                    item.OnSetItemLocation();
+                }
+                m_nPropertyVHeight = m_lst_item.Count * m_item_height;
+                if (this._ShowTitle) m_nPropertyVHeight += m_nTitleHeight;
+            }
+        }
+
+        #endregion
+
+        #region override ==========
+
+        /// <summary>
+        /// Occurs when the control is redrawn
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnPaint(PaintEventArgs e) {
+            base.OnPaint(e);
+            Graphics g = e.Graphics;
+            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
+            m_dt.Graphics = g;
+
+            m_nOffsetY = m_b_current_draw_info ? m_nInfoOffsetY : m_nPropertyOffsetY;
+            g.TranslateTransform(0, m_nOffsetY);
+
+            if (m_b_current_draw_info) {
+                m_nVHeight = m_nInfoVHeight;
+                this.OnDrawInfo(m_dt);
+            } else {
+                m_nVHeight = m_nPropertyVHeight;
+                for (int i = 0; i < m_lst_item.Count; i++) {
+                    this.OnDrawPropertyItem(m_dt, m_lst_item[i], i);
+                }
+            }
+
+            g.ResetTransform();
+
+            if (this._ShowTitle) this.OnDrawTitle(m_dt);
+            m_sf.FormatFlags = 0;
+            if (!string.IsNullOrEmpty(m_str_err)) this.OnDrawErrorInfo(m_dt);
+            if (!string.IsNullOrEmpty(m_str_desc)) this.OnDrawDescription(m_dt);
+        }
+        /// <summary>
+        /// Occurs when the mouse moves over the control
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnMouseMove(MouseEventArgs e) {
+            base.OnMouseMove(e);
+            m_pt_move = e.Location;
+            bool bHover = this._ShowTitle && m_rect_switch.Contains(e.Location);
+            if (bHover != m_b_hover_switch) {
+                m_b_hover_switch = bHover;
+                this.Invalidate(m_rect_switch);
+            }
+            Point pt = new Point(e.X, e.Y - (int)m_nOffsetY);
+            MouseEventArgs mea = new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta);
+            if (m_b_current_draw_info)
+                this.OnProcessHelpMouseMove(mea);
+            else
+                this.OnProcessPropertyMouseMove(mea);
+        }
+        /// <summary>
+        /// Occurs when the mouse is clicked on the control
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnMouseDown(MouseEventArgs e) {
+            base.OnMouseDown(e);
+            m_pt_down = e.Location;
+            this.Focus();
+            bool bRedraw = false;
+            if (m_str_err != null) {
+                bRedraw = true;
+                m_str_err = null;
+            }
+            if (this._ShowTitle) {
+                if (m_rect_switch.Contains(e.Location)) {
+                    if (m_node_attribute == null || m_lst_item.Count == 0) return;
+                    m_b_current_draw_info = !m_b_current_draw_info;
+                    this.Invalidate();
+                    return;
+                } else if (m_rect_title.Contains(e.Location)) {
+                    return;
+                }
+            }
+            if (this._ShowTitle && m_rect_switch.Contains(e.Location)) {
+                if (m_node_attribute == null || m_lst_item.Count == 0) return;
+                m_b_current_draw_info = !m_b_current_draw_info;
+                this.Invalidate();
+                return;
+            }
+            Point pt = new Point(e.X, e.Y - (int)m_nOffsetY);
+            MouseEventArgs mea = new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta);
+
+            if (m_b_current_draw_info)
+                this.OnProcessInfoMouseDown(mea);
+            else
+                this.OnProcessPropertyMouseDown(mea);
+            if (bRedraw) this.Invalidate();
+        }
+        /// <summary>
+        /// Occurs when the mouse is raised over the control
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnMouseUp(MouseEventArgs e) {
+            base.OnMouseUp(e);
+            m_str_desc = null;
+            if (m_item_down_value != null && !this._ReadOnlyModel) {
+                Point pt = new Point(e.X, e.Y - (int)m_nOffsetY);
+                MouseEventArgs mea = new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta);
+                m_item_down_value.OnMouseUp(mea);
+                if (m_pt_down == e.Location && !this._ReadOnlyModel) {
+                    m_item_down_value.OnMouseClick(mea);
+                }
+            }
+            m_item_down_value = null;
+            this.Invalidate();
+        }
+        /// <summary>
+        /// Occurs when the mouse leaves the control
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnMouseLeave(EventArgs e) {
+            base.OnMouseLeave(e);
+            m_b_hover_switch = false;
+            if (m_item_hover_value != null && !this._ReadOnlyModel) m_item_hover_value.OnMouseLeave(e);
+            m_item_hover = null;
+            this.Invalidate();
+        }
+        /// <summary>
+        /// Occurs when the mouse rolls the wheel on the control
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnMouseWheel(MouseEventArgs e) {
+            base.OnMouseWheel(e);
+            if (e.Delta > 0) {
+                if (m_nOffsetY == 0) return;
+                m_nOffsetY += m_item_height;
+                if (m_nOffsetY > 0) m_nOffsetY = 0;
+            } else {
+                if (this.Height - m_nOffsetY >= m_nVHeight) return;
+                m_nOffsetY -= m_item_height;
+            }
+            if (m_b_current_draw_info)
+                m_nInfoOffsetY = m_nOffsetY;
+            else
+                m_nPropertyOffsetY = m_nOffsetY;
+            this.Invalidate();
+        }
+        /// <summary>
+        /// Occurs when the control rectangle area is set
+        /// </summary>
+        /// <param name="x">x coordinate</param>
+        /// <param name="y">y coordinate</param>
+        /// <param name="width">width</param>
+        /// <param name="height">height</param>
+        /// <param name="specified">Specify the identifier to be set</param>
+        //protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
+        //    if (width < 120) width = 120;
+        //    if (height < 50) height = 50;
+        //    base.SetBoundsCore(x, y, width, height, specified);
+        //}
+        /// <summary>
+        /// Occurs when the control size changes
+        /// </summary>
+        /// <param name="e">Event parameters</param>
+        protected override void OnResize(EventArgs e) {
+            base.OnResize(e);
+            m_rect_title.Width = this.Width;
+            m_rect_title.Height = m_nTitleHeight;
+            if (this._ShowTitle)
+                m_rect_switch = new Rectangle(this.Width - m_nTitleHeight + 2, 2, m_nTitleHeight - 4, m_nTitleHeight - 4);
+            if (this._STNode != null) this.SetItemRectangle();
+        }
+
+        #endregion
+
+        #region virtual method ==========
+
+        /// <summary>
+        /// Occurs when drawing attribute options
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        /// <param name="item">Target attribute option descriptor</param>
+        /// <param name="nIndex">The index of the option</param>
+        protected virtual void OnDrawPropertyItem(DrawingTools dt, STNodePropertyDescriptor item, int nIndex) {
+            Graphics g = dt.Graphics;
+            m_brush.Color = (nIndex % 2 == 0) ? m_clr_item_1 : m_clr_item_2;
+            g.FillRectangle(m_brush, item.Rectangle);
+            if (item == m_item_hover || item == m_item_selected) {
+                m_brush.Color = this._ItemHoverColor;
+                g.FillRectangle(m_brush, item.Rectangle);
+            }
+            if (m_item_selected == item) {
+                g.FillRectangle(m_brush, item.Rectangle.X, item.Rectangle.Y, 5, item.Rectangle.Height);
+                if (this._AutoColor && this._STNode != null)
+                    m_brush.Color = this._STNode.TitleColor;
+                else
+                    m_brush.Color = this._ItemSelectedColor;
+                g.FillRectangle(m_brush, item.Rectangle.X, item.Rectangle.Y + 4, 5, item.Rectangle.Height - 8);
+            }
+            m_sf.Alignment = StringAlignment.Far;
+            m_brush.Color = this.ForeColor;
+            g.DrawString(item.Name, this.Font, m_brush, item.RectangleL, m_sf);
+
+            item.OnDrawValueRectangle(m_dt);
+            if (this._ReadOnlyModel) {
+                m_brush.Color = Color.FromArgb(125, 125, 125, 125);
+                g.FillRectangle(m_brush, item.RectangleR);
+                m_pen.Color = this.ForeColor;
+                //g.DrawLine(m_pen,
+                //    item.RectangleR.Left - 2, item.RectangleR.Top + item.RectangleR.Height / 2,
+                //    item.RectangleR.Right + 1, item.RectangleR.Top + item.RectangleR.Height / 2);
+            }
+        }
+        /// <summary>
+        /// Draw the property window title
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        protected virtual void OnDrawTitle(DrawingTools dt) {
+            Graphics g = dt.Graphics;
+            if (this._AutoColor)
+                m_brush.Color = this._STNode == null ? this._TitleColor : this._STNode.TitleColor;
+            else
+                m_brush.Color = this._TitleColor;
+            g.FillRectangle(m_brush, m_rect_title);
+            m_brush.Color = this._STNode == null ? this.ForeColor : this._STNode.ForeColor;
+            m_sf.Alignment = StringAlignment.Center;
+            g.DrawString(this._STNode == null ? this.Text : this._STNode.Title, this.Font, m_brush, m_rect_title, m_sf);
+
+            if (this._ReadOnlyModel) {
+                m_brush.Color = this.ForeColor;
+                g.FillRectangle(dt.SolidBrush, 4, 5, 2, 4);
+                g.FillRectangle(dt.SolidBrush, 6, 5, 2, 2);
+                g.FillRectangle(dt.SolidBrush, 8, 5, 2, 4);
+                g.FillRectangle(dt.SolidBrush, 3, 9, 8, 6);
+            }
+            //Whether to draw the panel switch button
+            if (m_node_attribute == null || m_lst_item.Count == 0) return;
+            if (m_b_hover_switch) {
+                m_brush.Color = this.BackColor;
+                g.FillRectangle(m_brush, m_rect_switch);
+            }
+            m_pen.Color = this._STNode == null ? this.ForeColor : this._STNode.ForeColor;
+            m_brush.Color = m_pen.Color;
+            int nT1 = m_rect_switch.Top + m_rect_switch.Height / 2 - 2;
+            int nT2 = m_rect_switch.Top + m_rect_switch.Height / 2 + 1;
+            g.DrawRectangle(m_pen, m_rect_switch.Left, m_rect_switch.Top, m_rect_switch.Width - 1, m_rect_switch.Height - 1);
+
+            g.DrawLines(m_pen, new Point[]{
+                new Point(m_rect_switch.Left + 2, nT1), new Point(m_rect_switch.Right - 3, nT1),
+                new Point(m_rect_switch.Left + 3, nT1 - 1), new Point(m_rect_switch.Right - 3, nT1 - 1)
+            });
+            g.DrawLines(m_pen, new Point[]{
+                new Point(m_rect_switch.Left + 2, nT2), new Point(m_rect_switch.Right - 3, nT2),
+                new Point(m_rect_switch.Left + 2, nT2 + 1), new Point(m_rect_switch.Right - 4, nT2 + 1),
+            });
+
+            g.FillPolygon(m_brush, new Point[]{
+                new Point(m_rect_switch.Left + 2, nT1),
+                new Point(m_rect_switch.Left + 7, nT1),
+                new Point(m_rect_switch.Left + 7, m_rect_switch.Top  ),
+            });
+            g.FillPolygon(m_brush, new Point[]{
+                new Point(m_rect_switch.Right - 2, nT2),
+                new Point(m_rect_switch.Right - 7, nT2),
+                new Point(m_rect_switch.Right - 7, m_rect_switch.Bottom - 2 ),
+            });
+        }
+        /// <summary>
+        /// Occurs when the attribute description information needs to be drawn
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        protected virtual void OnDrawDescription(DrawingTools dt) {
+            if (string.IsNullOrEmpty(m_str_desc)) return;
+            Graphics g = dt.Graphics;
+            SizeF szf = g.MeasureString(m_str_desc, this.Font, this.Width - 4);
+            Rectangle rect_desc = new Rectangle(0, this.Height - (int)szf.Height - 4, this.Width, (int)szf.Height + 4);
+            m_brush.Color = this._DescriptionColor;
+            g.FillRectangle(m_brush, rect_desc);
+            m_pen.Color = this._DescriptionColor;
+            g.DrawRectangle(m_pen, 0, rect_desc.Top, rect_desc.Width - 1, rect_desc.Height - 1);
+            rect_desc.Inflate(-4, 0);
+            m_brush.Color = this.ForeColor;
+            m_sf.Alignment = StringAlignment.Near;
+            g.DrawString(m_str_desc, this.Font, m_brush, rect_desc, m_sf);
+        }
+        /// <summary>
+        /// Occurs when an error message needs to be drawn
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        protected virtual void OnDrawErrorInfo(DrawingTools dt) {
+            if (string.IsNullOrEmpty(m_str_err)) return;
+            Graphics g = dt.Graphics;
+            SizeF szf = g.MeasureString(m_str_err, this.Font, this.Width - 4);
+            Rectangle rect_desc = new Rectangle(0, 0, this.Width, (int)szf.Height + 4);
+            m_brush.Color = this._ErrorColor;
+            g.FillRectangle(m_brush, rect_desc);
+            m_pen.Color = this._ErrorColor;
+            g.DrawRectangle(m_pen, 0, rect_desc.Top, rect_desc.Width - 1, rect_desc.Height - 1);
+            rect_desc.Inflate(-4, 0);
+            m_brush.Color = this.ForeColor;
+            m_sf.Alignment = StringAlignment.Near;
+            g.DrawString(m_str_err, this.Font, m_brush, rect_desc, m_sf);
+        }
+        /// <summary>
+        /// Occurs when drawing node information
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        protected virtual void OnDrawInfo(DrawingTools dt) {
+            if (m_node_attribute == null) return;
+            var attr = m_node_attribute;
+            Graphics g = dt.Graphics;
+            Color clr_r = Color.FromArgb(this.ForeColor.A / 2, this.ForeColor);
+            m_sf.Alignment = StringAlignment.Near;
+            Rectangle rect = new Rectangle(0, this._ShowTitle ? m_nTitleHeight : 0, this.Width, m_item_height);
+            Rectangle rect_l = new Rectangle(2, rect.Top, m_nInfoLeft - 2, m_item_height);
+            Rectangle rect_r = new Rectangle(m_nInfoLeft, rect.Top, this.Width - m_nInfoLeft, m_item_height);
+            m_brush.Color = m_clr_item_2;
+            g.FillRectangle(m_brush, rect);
+            m_brush.Color = this.ForeColor;
+            m_sf.FormatFlags = StringFormatFlags.NoWrap;
+            m_sf.Alignment = StringAlignment.Near;
+            g.DrawString(m_KeysString[0], this.Font, m_brush, rect_l, m_sf);          //author
+            m_brush.Color = clr_r;
+            g.DrawString(attr.Author, this.Font, m_brush, rect_r, m_sf);
+            rect.Y += m_item_height; rect_l.Y += m_item_height; rect_r.Y += m_item_height;
+
+            m_brush.Color = m_clr_item_1;
+            g.FillRectangle(m_brush, rect);
+            m_brush.Color = this.ForeColor;
+            g.DrawString(m_KeysString[1], this.Font, m_brush, rect_l, m_sf);          //mail
+            m_brush.Color = clr_r;
+            g.DrawString(attr.Mail, this.Font, m_brush, rect_r, m_sf);
+            rect.Y += m_item_height; rect_l.Y += m_item_height; rect_r.Y += m_item_height;
+
+            m_brush.Color = m_clr_item_2;
+            g.FillRectangle(m_brush, rect);
+            m_brush.Color = this.ForeColor;
+            g.DrawString(m_KeysString[2], this.Font, m_brush, rect_l, m_sf);          //link_key
+            m_brush.Color = clr_r;
+            g.DrawString(attr.Link, this.Font, Brushes.CornflowerBlue, rect_r, m_sf); //link
+            if (!string.IsNullOrEmpty(attr.Link)) m_rect_link = rect_r;
+            //fill left
+            m_brush.Color = Color.FromArgb(40, 125, 125, 125);
+            g.FillRectangle(m_brush, 0, this._ShowTitle ? m_nTitleHeight : 0, m_nInfoLeft - 1, m_item_height * 3);
+
+            rect.X = 5; rect.Y += m_item_height;
+            rect.Width = this.Width - 10;
+            if (!string.IsNullOrEmpty(m_node_attribute.Description)) {
+                float h = g.MeasureString(m_node_attribute.Description, this.Font, rect.Width).Height;
+                rect.Height = (int)Math.Ceiling(h / m_item_height) * m_item_height;
+                m_brush.Color = clr_r;
+                m_sf.FormatFlags = 0;
+                g.DrawString(m_node_attribute.Description, this.Font, m_brush, rect, m_sf);
+            }
+            m_nInfoVHeight = rect.Bottom;
+            bool bHasHelp = STNodeAttribute.GetHelpMethod(m_type) != null;
+            rect.X = 5; rect.Y += rect.Height;
+            rect.Height = m_item_height;
+            m_sf.Alignment = StringAlignment.Center;
+            m_brush.Color = Color.FromArgb(125, 125, 125, 125);
+            g.FillRectangle(m_brush, rect);
+            if (bHasHelp) m_brush.Color = Color.CornflowerBlue;
+            g.DrawString(m_KeysString[3], this.Font, m_brush, rect, m_sf);
+            if (bHasHelp) m_rect_help = rect;
+            else {
+                int w = (int)g.MeasureString(m_KeysString[3], this.Font).Width + 1;
+                int x = rect.X + (rect.Width - w) / 2, y = rect.Y + rect.Height / 2;
+                m_pen.Color = m_brush.Color;
+                g.DrawLine(m_pen, x, y, x + w, y);
+            }
+            m_nInfoVHeight = rect.Bottom;
+        }
+        /// <summary>
+        /// Occurs when the mouse is clicked on the property panel
+        /// </summary>
+        /// <param name="e">Mouse event parameters</param>
+        protected virtual void OnProcessPropertyMouseDown(MouseEventArgs e) {
+            bool bRedraw = false;
+            if (m_item_selected != m_item_hover) {
+                m_item_selected = m_item_hover;
+                bRedraw = true;
+            }
+            m_item_down_value = null;
+            if (m_item_selected == null) {
+                if (bRedraw) this.Invalidate();
+                return;
+            }
+            if (m_item_selected.RectangleR.Contains(e.Location)) {
+                m_item_down_value = m_item_selected;
+                if (!this._ReadOnlyModel)
+                    m_item_selected.OnMouseDown(e);
+                else {
+                    return;
+                }
+            } else if (m_item_selected.RectangleL.Contains(e.Location)) {
+                m_str_desc = m_item_selected.Description;
+                bRedraw = true;
+            }
+            if (bRedraw) this.Invalidate();
+        }
+        /// <summary>
+        /// Occurs when the mouse is clicked in the info panel
+        /// </summary>
+        /// <param name="e">Mouse event parameters</param>
+        protected virtual void OnProcessInfoMouseDown(MouseEventArgs e) {
+            try {
+                if (m_rect_link.Contains(e.Location)) {
+                    System.Diagnostics.Process.Start(m_node_attribute.Link);
+                } else if (m_rect_help.Contains(e.Location)) {
+                    STNodeAttribute.ShowHelp(m_type);
+                }
+            } catch (Exception ex) {
+                this.SetErrorMessage(ex.Message);
+            }
+        }
+        /// <summary>
+        /// Occurs when the mouse is moved in the properties panel
+        /// </summary>
+        /// <param name="e">Mouse event parameters</param>
+        protected virtual void OnProcessPropertyMouseMove(MouseEventArgs e) {
+            if (m_item_down_value != null) {
+                m_item_down_value.OnMouseMove(e);
+                return;
+            }
+            STNodePropertyDescriptor item = null;
+            foreach (var v in m_lst_item) {
+                if (v.Rectangle.Contains(e.Location)) {
+                    item = v;
+                    break;
+                }
+            }
+            if (item != null) {
+                if (item.RectangleR.Contains(e.Location)) {
+                    if (m_item_hover_value != item) {
+                        if (m_item_hover_value != null) m_item_hover_value.OnMouseLeave(e);
+                        m_item_hover_value = item;
+                        m_item_hover_value.OnMouseEnter(e);
+                    }
+                    m_item_hover_value.OnMouseMove(e);
+                } else {
+                    if (m_item_hover_value != null) m_item_hover_value.OnMouseLeave(e);
+                }
+            }
+            if (m_item_hover != item) {
+                m_item_hover = item;
+                this.Invalidate();
+            }
+        }
+        /// <summary>
+        /// Occurs when the mouse is moved in the info panel
+        /// </summary>
+        /// <param name="e">Mouse event parameters</param>
+        protected virtual void OnProcessHelpMouseMove(MouseEventArgs e) {
+            if (m_rect_link.Contains(e.Location) || m_rect_help.Contains(e.Location)) {
+                this.Cursor = Cursors.Hand;
+            } else this.Cursor = Cursors.Arrow;
+        }
+
+        #endregion
+
+        #region public ==========
+
+        /// <summary>
+        /// Set the STNode node that needs to be displayed
+        /// </summary>
+        /// <param name="node">target node</param>
+        public void SetNode(STNode node) {
+            if (node == this._STNode) return;
+            m_nInfoOffsetY = m_nPropertyOffsetY = 0;
+            m_nInfoVHeight = m_nPropertyVHeight = 0;
+            m_rect_link = m_rect_help = Rectangle.Empty;
+            m_str_desc = m_str_err = null;
+            this._STNode = node;
+            if (node != null) {
+                m_type = node.GetType();
+                m_lst_item = this.GetProperties(node);
+                m_node_attribute = this.GetNodeAttribute(node);
+                this.SetItemRectangle();
+                m_b_current_draw_info = m_lst_item.Count == 0 || this._InfoFirstOnDraw;
+                if (this._AutoColor) this._ItemSelectedColor = this._STNode.TitleColor;
+            } else {
+                m_type = null;
+                m_lst_item.Clear();
+                m_node_attribute = null;
+            }
+            this.Invalidate();
+        }
+        /// <summary>
+        /// Set the display text of the Key of the information page
+        /// </summary>
+        /// <param name="strAuthor">author</param>
+        /// <param name="strMail">mail</param>
+        /// <param name="strLink">connect</param>
+        /// <param name="strHelp">View help</param>
+        public void SetInfoKey(string strAuthor, string strMail, string strLink, string strHelp) {
+            m_KeysString = new string[] { strAuthor, strMail, strLink, strHelp };
+        }
+        /// <summary>
+        /// Set the error message to display
+        /// </summary>
+        /// <param name="strText">Error message</param>
+        public void SetErrorMessage(string strText) {
+            m_str_err = strText;
+            this.Invalidate();
+        }
+
+        #endregion
+    }
+}

CodeWalker.WinForms/STNodeEditor/STNodeTreeView.cs

@@ -0,0 +1,907 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Drawing;
+using System.Reflection;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.Collections;
+/*
+MIT License
+
+Copyright (c) 2021 DebugST@crystal_lz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+/*
+ * create: 2021-02-23
+ * modify: 2021-03-02
+ * Author: Crystal_lz
+ * blog: http://st233.com
+ * Gitee: https://gitee.com/DebugST
+ * Github: https://github.com/DebugST
+ */
+namespace ST.Library.UI.NodeEditor
+{
+    public class STNodeTreeView : Control
+    {
+        private Color _ItemBackColor = Color.FromArgb(255, 45, 45, 45);
+        /// <summary>
+        /// Get or set the background color of each row attribute option
+        /// </summary>
+        [Description("Get or set the background color of each row attribute option")]
+        public Color ItemBackColor {
+            get { return _ItemBackColor; }
+            set {
+                _ItemBackColor = value;
+            }
+        }
+
+        private Color _ItemHoverColor = Color.FromArgb(50, 125, 125, 125);
+        /// <summary>
+        /// Gets or sets the background color when the property option is hovered by the mouse
+        /// </summary>
+        [Description("Get or set the background color when the property option is hovered by the mouse")]
+        public Color ItemHoverColor {
+            get { return _ItemHoverColor; }
+            set { _ItemHoverColor = value; }
+        }
+
+        private Color _TitleColor = Color.FromArgb(255, 60, 60, 60);
+        /// <summary>
+        /// Get or set the background color of the top retrieval area
+        /// </summary>
+        [Description("Get or set the background color of the top retrieval area")]
+        public Color TitleColor {
+            get { return _TitleColor; }
+            set {
+                _TitleColor = value;
+                this.Invalidate(new Rectangle(0, 0, this.Width, m_nItemHeight));
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the background color of the search text box
+        /// </summary>
+        [Description("Get or set the background color of the search text box")]
+        public Color TextBoxColor {
+            get { return m_tbx.BackColor; }
+            set {
+                m_tbx.BackColor = value;
+                this.Invalidate(new Rectangle(0, 0, this.Width, m_nItemHeight));
+            }
+        }
+
+        private Color _HightLightTextColor = Color.Lime;
+        /// <summary>
+        /// Gets or sets the highlighted text color when retrieving
+        /// </summary>
+        [Description("Get or set the highlighted text color during retrieval"), DefaultValue(typeof(Color), "Lime")]
+        public Color HightLightTextColor {
+            get { return _HightLightTextColor; }
+            set { _HightLightTextColor = value; }
+        }
+
+        private Color _InfoButtonColor = Color.Gray;
+        /// <summary>
+        /// Gets or sets the color of the information display button. If AutoColor is set, this property value cannot be set
+        /// </summary>
+        [Description("Get or set the color of the information display button. If AutoColor is set, this property value cannot be set"), DefaultValue(typeof(Color), "Gray")]
+        public Color InfoButtonColor {
+            get { return _InfoButtonColor; }
+            set { _InfoButtonColor = value; }
+        }
+
+        private Color _FolderCountColor = Color.FromArgb(40, 255, 255, 255);
+        /// <summary>
+        /// Get or set the text color of the count
+        /// </summary>
+        [Description("Get or set the text color of statistics")]
+        public Color FolderCountColor {
+            get { return _FolderCountColor; }
+            set { _FolderCountColor = value; }
+        }
+
+        private Color _SwitchColor = Color.LightGray;
+
+        private bool _ShowFolderCount = true;
+        /// <summary>
+        /// Get or set whether to count the number of STNodes
+        /// </summary>
+        [Description("Get or set whether to count the number of STNodes"), DefaultValue(typeof(Color), "LightGray")]
+        public bool ShowFolderCount {
+            get { return _ShowFolderCount; }
+            set { _ShowFolderCount = value; }
+        }
+
+        private bool _ShowInfoButton = true;
+        /// <summary>
+        /// Gets or sets whether to display the information button
+        /// </summary>
+        [Description("Get or set whether to display the information button"), DefaultValue(true)]
+        public bool ShowInfoButton {
+            get { return _ShowInfoButton; }
+            set { _ShowInfoButton = value; }
+        }
+
+        private bool _InfoPanelIsLeftLayout = true;
+        /// <summary>
+        /// Gets or sets whether the preview window is laid out to the left
+        /// </summary>
+        [Description("Get or set whether the preview window is a left layout"), DefaultValue(true)]
+        public bool InfoPanelIsLeftLayout {
+            get { return _InfoPanelIsLeftLayout; }
+            set { _InfoPanelIsLeftLayout = value; }
+        }
+
+        private bool _AutoColor = true;
+        /// <summary>
+        /// Get or set the title color of the STNode corresponding to some colors in the control
+        /// </summary>
+        [Description("Get or set the title color of STNode corresponding to some colors in the control"), DefaultValue(true)]
+        public bool AutoColor {
+            get { return _AutoColor; }
+            set {
+                _AutoColor = value;
+                this.Invalidate();
+            }
+        }
+
+        private STNodeEditor _Editor;
+        /// <summary>
+        /// STNodeEditor used to get the node preview
+        /// </summary>
+        [Description("STNodeEditor used when getting node preview"), Browsable(false)]
+        public STNodeEditor Editor {
+            get { return _Editor; }
+        }
+
+        private STNodePropertyGrid _PropertyGrid;
+        /// <summary>
+        /// Get the STNodePropertyGrid used when getting the node preview
+        /// </summary>
+        [Description("STNodePropertyGrid used when getting node preview"), Browsable(false)]
+        public STNodePropertyGrid PropertyGrid {
+            get { return _PropertyGrid; }
+        }
+
+        private int m_nItemHeight = 29;
+
+        private static Type m_type_node_base = typeof(STNode);
+        private static char[] m_chr_splitter = new char[] { '/', '\\' };
+        private STNodeTreeCollection m_items_draw;
+        private STNodeTreeCollection m_items_source = new STNodeTreeCollection("ROOT");
+        private Dictionary<Type, string> m_dic_all_type = new Dictionary<Type, string>();
+
+        private Pen m_pen;
+        private SolidBrush m_brush;
+        private StringFormat m_sf;
+        private DrawingTools m_dt;
+        private Color m_clr_item_1 = Color.FromArgb(10, 0, 0, 0);// Color.FromArgb(255, 40, 40, 40);
+        private Color m_clr_item_2 = Color.FromArgb(10, 255, 255, 255);// Color.FromArgb(255, 50, 50, 50);
+
+        private int m_nOffsetY; //The vertical height that needs to be offset when the control is drawn
+        private int m_nSourceOffsetY; //The vertical height that needs to be offset when drawing source data
+        private int m_nSearchOffsetY; //The vertical height that needs to be offset when drawing and retrieving data
+        private int m_nVHeight; //The total height required by the content in the control
+
+        private bool m_bHoverInfo; //Whether the mouse is currently hovering over the information display button
+        private STNodeTreeCollection m_item_hover; //The tree node currently hovered by the mouse
+        private Point m_pt_control; //The coordinates of the mouse on the control
+        private Point m_pt_offsety; //The coordinates of the mouse after the hammer is offset on the control
+        private Rectangle m_rect_clear; //Clear the search button area
+
+        private string m_str_search; // retrieved text
+        private TextBox m_tbx = new TextBox(); //Retrieve the textbox
+        /// <summary>
+        /// Construct a STNode tree control
+        /// </summary>
+        public STNodeTreeView() {
+            this.SetStyle(ControlStyles.UserPaint, true);
+            this.SetStyle(ControlStyles.ResizeRedraw, true);
+            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+
+            this.MinimumSize = new System.Drawing.Size(100, 60);
+            this.Size = new System.Drawing.Size(200, 150);
+            m_items_draw = m_items_source;
+            m_pen = new Pen(Color.Black);
+            m_brush = new SolidBrush(Color.White);
+            m_sf = new StringFormat();
+            m_sf.LineAlignment = StringAlignment.Center;
+            m_dt.Pen = m_pen;
+            m_dt.SolidBrush = m_brush;
+            this.ForeColor = Color.FromArgb(255, 220, 220, 220);
+            this.BackColor = Color.FromArgb(255, 35, 35, 35);
+            m_tbx.Left = 6;
+            m_tbx.BackColor = Color.FromArgb(255, 30, 30, 30);
+            m_tbx.ForeColor = this.ForeColor;
+            m_tbx.BorderStyle = BorderStyle.None;
+            m_tbx.MaxLength = 20;
+            m_tbx.TextChanged += new EventHandler(m_tbx_TextChanged);
+            this.Controls.Add(m_tbx);
+            this.AllowDrop = true;
+
+            this._Editor = new STNodeEditor();
+            this._PropertyGrid = new STNodePropertyGrid();
+        }
+
+        #region private method ==========
+
+        private void m_tbx_TextChanged(object sender, EventArgs e) {
+            m_str_search = m_tbx.Text.Trim().ToLower();
+            m_nSearchOffsetY = 0;
+            if (m_str_search == string.Empty) {
+                m_items_draw = m_items_source;
+                this.Invalidate();
+                return;
+            }
+            m_items_draw = m_items_source.Copy();
+            this.Search(m_items_draw, new Stack<string>(), m_str_search);
+            this.Invalidate();
+        }
+
+        private bool Search(STNodeTreeCollection items, Stack<string> stack, string strText) {
+            bool bFound = false;
+            string[] strName = new string[items.Count];
+            int nCounter = 0;
+            foreach (STNodeTreeCollection v in items) {
+                if (v.NameLower.IndexOf(strText) != -1) {
+                    v.IsOpen = bFound = true;
+                } else {
+                    if (!this.Search(v, stack, strText)) {
+                        stack.Push(v.Name);
+                        nCounter++;
+                    } else {
+                        v.IsOpen = bFound = true;
+                    }
+                }
+            }
+            for (int i = 0; i < nCounter; i++) items.Remove(stack.Pop(), false);
+            return bFound;
+        }
+
+        private bool AddSTNode(Type stNodeType, STNodeTreeCollection items, string strLibName, bool bShowException) {
+            if (m_dic_all_type.ContainsKey(stNodeType)) return false;
+            if (stNodeType == null) return false;
+            if (!stNodeType.IsSubclassOf(m_type_node_base)) {
+                if (bShowException)
+                    throw new ArgumentException("Unsupported type [" + stNodeType.FullName + "] [stNodeType] parameter value must be the type of [STNode] subclass");
+                else return false;
+            }
+            var attr = this.GetNodeAttribute(stNodeType);
+            if (attr == null) {
+                if (bShowException)
+                    throw new InvalidOperationException("Type [" + stNodeType.FullName + "] is not marked by [STNodeAttribute]");
+                else return false;
+            }
+            string strPath = string.Empty;
+            items.STNodeCount++;
+            if (!string.IsNullOrEmpty(attr.Path)) {
+                var strKeys = attr.Path.Split (m_chr_splitter);
+                for (int i = 0; i < strKeys.Length; i++) {
+                    items = items.Add(strKeys[i]);
+                    items.STNodeCount++;
+                    strPath += "/" + strKeys[i];
+                }
+            }
+            try {
+                STNode node = (STNode)Activator.CreateInstance(stNodeType);
+                STNodeTreeCollection stt = new STNodeTreeCollection(node.Title);
+                stt.Path = (strLibName + "/" + attr.Path).Trim('/');
+                stt.STNodeType = stNodeType;
+                items[stt.Name] = stt;
+                stt.STNodeTypeColor = node.TitleColor;
+                m_dic_all_type.Add(stNodeType, stt.Path);
+                this.Invalidate();
+            } catch (Exception ex) {
+                if (bShowException) throw ex;
+                return false;
+            }
+            return true;
+        }
+
+        private STNodeTreeCollection AddAssemblyPrivate(string strFile) {
+            strFile = System.IO.Path.GetFullPath(strFile);
+            var asm = Assembly.LoadFrom(strFile);
+            STNodeTreeCollection items = new STNodeTreeCollection(System.IO.Path.GetFileNameWithoutExtension(strFile));
+            foreach (var v in asm.GetTypes()) {
+                if (v.IsAbstract) continue;
+                if (v.IsSubclassOf(m_type_node_base)) this.AddSTNode(v, items, items.Name, false);
+            }
+            return items;
+        }
+
+        private STNodeAttribute GetNodeAttribute(Type stNodeType) {
+            if (stNodeType == null) return null;
+            foreach (var v in stNodeType.GetCustomAttributes(true)) {
+                if (!(v is STNodeAttribute)) continue;
+                return (STNodeAttribute)v;
+            }
+            return null;
+        }
+
+        private STNodeTreeCollection FindItemByPoint(STNodeTreeCollection items, Point pt) {
+            foreach (STNodeTreeCollection t in items) {
+                if (t.DisplayRectangle.Contains(pt)) return t;
+                if (t.IsOpen) {
+                    var n = FindItemByPoint (t, pt);
+                    if (n != null) return n;
+                }
+            }
+            return null;
+        }
+
+        #endregion
+
+        #region overide method ==========
+
+        protected override void OnCreateControl() {
+            base.OnCreateControl();
+            m_tbx.Top = (m_nItemHeight - m_tbx.Height) / 2;
+        }
+
+        protected override void OnResize(EventArgs e) {
+            base.OnResize(e);
+            m_tbx.Width = this.Width - 29;
+            m_rect_clear = new Rectangle(this.Width - 20, 9, 12, 12);
+        }
+
+        protected override void OnPaint(PaintEventArgs e) {
+            base.OnPaint(e);
+            m_nOffsetY = string.IsNullOrEmpty(m_str_search) ? m_nSourceOffsetY : m_nSearchOffsetY;
+            Graphics g = e.Graphics;
+            m_dt.Graphics = g;
+            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
+            g.TranslateTransform(0, m_nOffsetY);
+            int nCounter = 0;
+            foreach (STNodeTreeCollection v in m_items_draw)
+                nCounter = this.OnStartDrawItem(m_dt, v, nCounter, 0);
+            m_nVHeight = (nCounter + 1) * m_nItemHeight;
+            foreach (STNodeTreeCollection v in m_items_draw)
+                this.OnDrawSwitch(m_dt, v);
+            g.ResetTransform();
+            this.OnDrawSearch(m_dt);
+        }
+
+        protected override void OnMouseMove(MouseEventArgs e) {
+            base.OnMouseMove(e);
+            bool bRedraw = false;
+            m_pt_offsety = m_pt_control = e.Location;
+            m_pt_offsety.Y -= m_nOffsetY;
+            if (!string.IsNullOrEmpty(m_str_search) && m_rect_clear.Contains(e.Location))
+                this.Cursor = Cursors.Hand;
+            else
+                this.Cursor = Cursors.Arrow;
+            var node = this.FindItemByPoint(m_items_draw, m_pt_offsety);
+            if (m_item_hover != node) {
+                m_item_hover = node;
+                bRedraw = true;
+            }
+            if (node != null) {
+                bool bHoverInfo = node.InfoRectangle.Contains(m_pt_offsety);
+                if (bHoverInfo != m_bHoverInfo) {
+                    m_bHoverInfo = bHoverInfo;
+                    bRedraw = true;
+                }
+            }
+            if (bRedraw) this.Invalidate();
+        }
+
+        protected override void OnMouseDown(MouseEventArgs e) {
+            base.OnMouseDown(e);
+            this.Focus();
+            if (!string.IsNullOrEmpty(m_str_search) && m_rect_clear.Contains(e.Location)) {
+                m_tbx.Text = string.Empty;
+                return;
+            }
+            m_pt_offsety = m_pt_control = e.Location;
+            m_pt_offsety.Y -= m_nOffsetY;
+            if (m_item_hover == null) return;
+            if (m_item_hover.SwitchRectangle.Contains(m_pt_offsety)) {
+                m_item_hover.IsOpen = !m_item_hover.IsOpen;
+                this.Invalidate();
+            } else if (m_item_hover.InfoRectangle.Contains(m_pt_offsety)) {
+                Rectangle rect = this.RectangleToScreen(m_item_hover.DisplayRectangle);
+                FrmNodePreviewPanel frm = new FrmNodePreviewPanel(m_item_hover.STNodeType,
+                    new Point(rect.Right - m_nItemHeight, rect.Top + m_nOffsetY),
+                    m_nItemHeight,
+                    this._InfoPanelIsLeftLayout,
+                    this._Editor, this._PropertyGrid);
+                frm.BackColor = this.BackColor;
+                frm.Show(this);
+            } else if (m_item_hover.STNodeType != null) {
+                DataObject d = new DataObject("STNodeType", m_item_hover.STNodeType);
+                this.DoDragDrop(d, DragDropEffects.Copy);
+            }
+        }
+
+        protected override void OnMouseDoubleClick(MouseEventArgs e) {
+            base.OnMouseDoubleClick(e);
+            m_pt_offsety = m_pt_control = e.Location;
+            m_pt_offsety.Y -= m_nOffsetY;
+            STNodeTreeCollection item = this.FindItemByPoint(m_items_draw, m_pt_offsety);
+            if (item == null || item.STNodeType != null) return;
+            item.IsOpen = !item.IsOpen;
+            this.Invalidate();
+        }
+
+        protected override void OnMouseLeave(EventArgs e) {
+            base.OnMouseLeave(e);
+            if (m_item_hover != null) {
+                m_item_hover = null;
+                this.Invalidate();
+            }
+        }
+
+        protected override void OnMouseWheel(MouseEventArgs e) {
+            base.OnMouseWheel(e);
+            if (e.Delta > 0) {
+                if (m_nOffsetY == 0) return;
+                m_nOffsetY += m_nItemHeight;
+                if (m_nOffsetY > 0) m_nOffsetY = 0;
+            } else {
+                if (this.Height - m_nOffsetY >= m_nVHeight) return;
+                m_nOffsetY -= m_nItemHeight;
+            }
+            if (string.IsNullOrEmpty(m_str_search))
+                m_nSourceOffsetY = m_nOffsetY;
+            else
+                m_nSearchOffsetY = m_nOffsetY;
+            this.Invalidate();
+        }
+
+        #endregion
+
+        #region protected method ==========
+        /// <summary>
+        /// Occurs when the retrieved text area is drawn
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        protected virtual void OnDrawSearch(DrawingTools dt) {
+            Graphics g = dt.Graphics;
+            m_brush.Color = this._TitleColor;
+            g.FillRectangle(m_brush, 0, 0, this.Width, m_nItemHeight);
+            m_brush.Color = m_tbx.BackColor;
+            g.FillRectangle(m_brush, 5, 5, this.Width - 10, m_nItemHeight - 10);
+            m_pen.Color = this.ForeColor;
+            if (string.IsNullOrEmpty(m_str_search)) {
+                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+                g.DrawEllipse(m_pen, this.Width - 17, 8, 8, 8);
+                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
+                g.DrawLine(m_pen, this.Width - 13, 17, this.Width - 13, m_nItemHeight - 9);
+            } else {
+                m_pen.Color = this.ForeColor;
+                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+                g.DrawEllipse(m_pen, this.Width - 20, 9, 10, 10);
+                g.DrawLine(m_pen, this.Width - 18, 11, this.Width - 12, 17);
+                g.DrawLine(m_pen, this.Width - 12, 11, this.Width - 18, 17);
+                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
+            }
+        }
+        /// <summary>
+        /// Occurs when starting to draw each node of the tree node
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        /// <param name="Items">The current collection that needs to be drawn</param>
+        /// <param name="nCounter">Counter of drawn counts</param>
+        /// <param name="nLevel">Currently located in the sub-collection of which level</param>
+        /// <returns>Number of already drawn</returns>
+        protected virtual int OnStartDrawItem(DrawingTools dt, STNodeTreeCollection Items, int nCounter, int nLevel) {
+            Graphics g = dt.Graphics;
+            Items.DisplayRectangle = new Rectangle(0, m_nItemHeight * (nCounter + 1), this.Width, m_nItemHeight);
+            Items.SwitchRectangle = new Rectangle(5 + nLevel * 10, (nCounter + 1) * m_nItemHeight, 10, m_nItemHeight);
+            if (this._ShowInfoButton && Items.STNodeType != null)
+                Items.InfoRectangle = new Rectangle(this.Width - 18, Items.DisplayRectangle.Top + (m_nItemHeight - 14) / 2, 14, 14);
+            else Items.InfoRectangle = Rectangle.Empty;
+            this.OnDrawItem(dt, Items, nCounter++, nLevel);
+            if (!Items.IsOpen) return nCounter;
+            foreach (STNodeTreeCollection n in Items) {
+                if (n.STNodeType == null)
+                    nCounter = this.OnStartDrawItem(dt, n, nCounter++, nLevel + 1);
+            }
+            foreach (STNodeTreeCollection n in Items) {
+                if (n.STNodeType != null)
+                    nCounter = this.OnStartDrawItem(dt, n, nCounter++, nLevel + 1);
+            }
+            foreach (STNodeTreeCollection v in Items) this.OnDrawSwitch(dt, v);
+            return nCounter;
+        }
+        /// <summary>
+        /// Occurs when each node of the tree node is drawn
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        /// <param name="items">The current collection that needs to be drawn</param>
+        /// <param name="nCounter">Counter of drawn counts</param>
+        /// <param name="nLevel">Currently located in the sub-collection of which level</param>
+        protected virtual void OnDrawItem(DrawingTools dt, STNodeTreeCollection items, int nCounter, int nLevel) {
+            Graphics g = dt.Graphics;
+            m_brush.Color = nCounter % 2 == 0 ? m_clr_item_1 : m_clr_item_2;
+            g.FillRectangle(m_brush, items.DisplayRectangle);
+            if (items == m_item_hover) {
+                m_brush.Color = this._ItemHoverColor;
+                g.FillRectangle(m_brush, items.DisplayRectangle);
+            }
+            Rectangle rect = new Rectangle(45 + nLevel * 10, items.SwitchRectangle.Top, this.Width - 45 - nLevel * 10, m_nItemHeight);
+            m_pen.Color = Color.FromArgb(100, 125, 125, 125);
+            g.DrawLine(m_pen, 9, items.SwitchRectangle.Top + m_nItemHeight / 2, items.SwitchRectangle.Left + 19, items.SwitchRectangle.Top + m_nItemHeight / 2);
+            if (nCounter != 0) {
+                for (int i = 0; i <= nLevel; i++) {
+                    g.DrawLine(m_pen, 9 + i * 10, items.SwitchRectangle.Top - m_nItemHeight / 2, 9 + i * 10, items.SwitchRectangle.Top + m_nItemHeight / 2 - 1);
+                }
+            }
+            this.OnDrawItemText(dt, items, rect);
+            this.OnDrawItemIcon(dt, items, rect);
+        }
+        /// <summary>
+        /// Occurs when drawing the tree node expand and close switches
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        /// <param name="items">The current collection that needs to be drawn</param>
+        protected virtual void OnDrawSwitch(DrawingTools dt, STNodeTreeCollection items) {
+            Graphics g = dt.Graphics;
+            if (items.Count != 0) {
+                m_pen.Color = this._SwitchColor;
+                m_brush.Color = m_pen.Color;
+                int nT = items.SwitchRectangle.Y + m_nItemHeight / 2 - 4;
+                g.DrawRectangle(m_pen, items.SwitchRectangle.Left, nT, 8, 8);
+                g.DrawLine(m_pen, items.SwitchRectangle.Left + 1, nT + 4, items.SwitchRectangle.Right - 3, nT + 4);
+                if (items.IsOpen) return;
+                g.DrawLine(m_pen, items.SwitchRectangle.Left + 4, nT + 1, items.SwitchRectangle.Left + 4, nT + 7);
+                //if (items.IsOpen) {
+                //    //g.FillPolygon(m_brush, new Point[]{
+                //    //    new Point(items.DotRectangle.Left + 0, items.DotRectangle.Top + m_nItemHeight / 2 - 2),
+                //    //    new Point(items.DotRectangle.Left + 9, items.DotRectangle.Top + m_nItemHeight / 2 - 2),
+                //    //    new Point(items.DotRectangle.Left + 4, items.DotRectangle.Top + m_nItemHeight / 2 + 3)
+                //    //});
+                //    g.DrawRectangle(m_pen, items.SwitchRectangle.Left, nT, 8, 8);
+                //    g.DrawLine(m_pen, items.SwitchRectangle.Left + 1, nT + 4, items.SwitchRectangle.Right - 3, nT + 4);
+                //} else {
+                //    //g.FillPolygon(m_brush, new Point[]{
+                //    //    new Point(items.DotRectangle.Left + 2, items.DotRectangle.Top + m_nItemHeight / 2 - 5),
+                //    //    new Point(items.DotRectangle.Left + 2, items.DotRectangle.Top + m_nItemHeight / 2 + 5),
+                //    //    new Point(items.DotRectangle.Left + 7, items.DotRectangle.Top + m_nItemHeight / 2)
+                //    //});
+                //    g.DrawRectangle(m_pen, items.SwitchRectangle.Left, nT, 8, 8);
+                //    g.DrawLine(m_pen, items.SwitchRectangle.Left + 1, nT + 4, items.SwitchRectangle.Right - 3, nT + 4);
+                //    g.DrawLine(m_pen, items.SwitchRectangle.Left + 4, nT + 1, items.SwitchRectangle.Left + 4, nT + 7);
+                //}
+            }
+        }
+        /// <summary>
+        /// Occurs when the text of the tree node is drawn
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        /// <param name="items">The current collection that needs to be drawn</param>
+        /// <param name="rect">The rectangular area where the text field is located</param>
+        protected virtual void OnDrawItemText(DrawingTools dt, STNodeTreeCollection items, Rectangle rect) {
+            Graphics g = dt.Graphics;
+            rect.Width -= 20;
+            m_sf.FormatFlags = StringFormatFlags.NoWrap;
+            if (!string.IsNullOrEmpty(m_str_search)) {
+                int nIndex = items.NameLower.IndexOf(m_str_search);
+                if (nIndex != -1) {
+                    CharacterRange[] chrs = { new CharacterRange(nIndex, m_str_search.Length) };//global
+                    m_sf.SetMeasurableCharacterRanges(chrs);
+                    Region[] regions = g.MeasureCharacterRanges(items.Name, this.Font, rect, m_sf);
+                    g.SetClip(regions[0], System.Drawing.Drawing2D.CombineMode.Intersect);
+                    m_brush.Color = this._HightLightTextColor;
+                    g.DrawString(items.Name, this.Font, m_brush, rect, m_sf);
+                    g.ResetClip();
+                    g.SetClip(regions[0], System.Drawing.Drawing2D.CombineMode.Exclude);
+                    m_brush.Color = items.STNodeType == null ? Color.FromArgb(this.ForeColor.A * 1 / 2, this.ForeColor) : this.ForeColor;
+                    g.DrawString(items.Name, this.Font, m_brush, rect, m_sf);
+                    g.ResetClip();
+                    return;
+                }
+            }
+            m_brush.Color = items.STNodeType == null ? Color.FromArgb(this.ForeColor.A * 2 / 3, this.ForeColor) : this.ForeColor;
+            g.DrawString(items.Name, this.Font, m_brush, rect, m_sf);
+        }
+        /// <summary>
+        /// Occurs when the tree node icon is drawn
+        /// </summary>
+        /// <param name="dt">Drawing tool</param>
+        /// <param name="items">The current collection that needs to be drawn</param>
+        /// <param name="rect">The rectangular area where the text field is located</param>
+        protected virtual void OnDrawItemIcon(DrawingTools dt, STNodeTreeCollection items, Rectangle rect) {
+            Graphics g = dt.Graphics;
+            if (items.STNodeType != null) {
+                m_pen.Color = this._AutoColor ? items.STNodeTypeColor : Color.DarkCyan;
+                m_brush.Color = Color.LightGray;
+                g.DrawRectangle(m_pen, rect.Left - 15, rect.Top + m_nItemHeight / 2 - 5, 11, 10);
+                g.FillRectangle(m_brush, rect.Left - 17, rect.Top + m_nItemHeight / 2 - 2, 5, 5);
+                g.FillRectangle(m_brush, rect.Left - 6, rect.Top + m_nItemHeight / 2 - 2, 5, 5);
+                if (m_item_hover == items && m_bHoverInfo) {
+                    m_brush.Color = this.BackColor;
+                    g.FillRectangle(m_brush, items.InfoRectangle);
+                }
+                m_pen.Color = this._AutoColor ? items.STNodeTypeColor : this._InfoButtonColor;
+                m_pen.Width = 2;
+                g.DrawLine(m_pen, items.InfoRectangle.X + 4, items.InfoRectangle.Y + 3, items.InfoRectangle.X + 10, items.InfoRectangle.Y + 3);
+                g.DrawLine(m_pen, items.InfoRectangle.X + 4, items.InfoRectangle.Y + 6, items.InfoRectangle.X + 10, items.InfoRectangle.Y + 6);
+                g.DrawLine(m_pen, items.InfoRectangle.X + 4, items.InfoRectangle.Y + 11, items.InfoRectangle.X + 10, items.InfoRectangle.Y + 11);
+                g.DrawLine(m_pen, items.InfoRectangle.X + 7, items.InfoRectangle.Y + 7, items.InfoRectangle.X + 7, items.InfoRectangle.Y + 10);
+                m_pen.Width = 1;
+                g.DrawRectangle(m_pen, items.InfoRectangle.X, items.InfoRectangle.Y, items.InfoRectangle.Width - 1, items.InfoRectangle.Height - 1);
+            } else {
+                if (items.IsLibraryRoot) {
+                    Rectangle rect_box = new Rectangle(rect.Left - 15, rect.Top + m_nItemHeight / 2 - 5, 11, 10);
+                    g.DrawRectangle(Pens.Gray, rect_box);
+                    g.DrawLine(Pens.Cyan, rect_box.X - 2, rect_box.Top, rect_box.X + 2, rect_box.Top);
+                    g.DrawLine(Pens.Cyan, rect_box.X, rect_box.Y - 2, rect_box.X, rect_box.Y + 2);
+                    g.DrawLine(Pens.Cyan, rect_box.Right - 2, rect_box.Bottom, rect_box.Right + 2, rect_box.Bottom);
+                    g.DrawLine(Pens.Cyan, rect_box.Right, rect_box.Bottom - 2, rect_box.Right, rect_box.Bottom + 2);
+                } else {
+                    g.DrawRectangle(Pens.Goldenrod, new Rectangle(rect.Left - 16, rect.Top + m_nItemHeight / 2 - 6, 8, 3));
+                    g.DrawRectangle(Pens.Goldenrod, new Rectangle(rect.Left - 16, rect.Top + m_nItemHeight / 2 - 3, 13, 9));
+                }
+                if (!this._ShowFolderCount) return;
+                m_sf.Alignment = StringAlignment.Far;
+                m_brush.Color = this._FolderCountColor;
+                rect.X -= 4;
+                g.DrawString("[" + items.STNodeCount.ToString() + "]", this.Font, m_brush, rect, m_sf);
+                m_sf.Alignment = StringAlignment.Near;
+            }
+        }
+
+        #endregion
+
+        #region public method ==========
+        /// <summary>
+        /// Retrieve the STNode in the control
+        /// </summary>
+        /// <param name="strText">Text to retrieve</param>
+        public void Search(string strText) {
+            if (strText == null) return;
+            if (strText.Trim() == string.Empty) return;
+            m_tbx.Text = strText.Trim ();
+        }
+        /// <summary>
+        /// Add a STNode type to the control
+        /// </summary>
+        /// <param name="stNodeType">STNode type</param>
+        /// <returns>Whether the addition is successful</returns>
+        public bool AddNode(Type stNodeType) { return this.AddSTNode(stNodeType, m_items_source, null, true); }
+        /// <summary>
+        /// Add the STNode type to the control from the file
+        /// </summary>
+        /// <param name="strFile">Specify file path</param>
+        /// <returns>Add success number</returns>
+        public int LoadAssembly(string strFile) {
+            strFile = System.IO.Path.GetFullPath(strFile);
+            var items = this.AddAssemblyPrivate(strFile);
+            if (items.STNodeCount == 0) return 0;
+            items.IsLibraryRoot = true;
+            m_items_source[items.Name] = items;
+            return items.STNodeCount;
+        }
+        /// <summary>
+        /// Clear all STNode types in the control
+        /// </summary>
+        public void Clear() {
+            m_items_source.Clear();
+            m_items_draw.Clear();
+            m_dic_all_type.Clear();
+            this.Invalidate();
+        }
+        /// <summary>
+        /// Remove an STNode type from the control
+        /// </summary>
+        /// <param name="stNodeType">STNode type</param>
+        /// <returns>Whether the removal is successful</returns>
+        public bool RemoveNode(Type stNodeType) {
+            if (!m_dic_all_type.ContainsKey(stNodeType)) return false;
+            string strPath = m_dic_all_type[stNodeType];
+            STNodeTreeCollection items = m_items_source;
+            if (!string.IsNullOrEmpty(strPath)) {
+                string[] strKeys = strPath.Split(m_chr_splitter);
+                for (int i = 0; i < strKeys.Length; i++) {
+                    items = items[strKeys[i]];
+                    if (items == null) return false;
+                }
+            }
+            try {
+                STNode node = (STNode)Activator.CreateInstance(stNodeType);
+                if (items[node.Title] == null) return false;
+                items.Remove(node.Title, true);
+                m_dic_all_type.Remove(stNodeType);
+            } catch { return false; }
+            this.Invalidate();
+            return true;
+        }
+
+        #endregion
+        //=================================================================================================
+        /// <summary>
+        /// A collection of each item in the STNodeTreeView control
+        /// </summary>
+        protected class STNodeTreeCollection : IEnumerable
+        {
+            private string _Name;
+            /// <summary>
+            /// Get the current tree node display name
+            /// </summary>
+            public string Name {
+                get {
+                    return _Name;
+                }
+            }
+            /// <summary>
+            /// Get the lowercase string of the display name of the current tree node
+            /// </summary>
+            public string NameLower { get; private set; }
+            /// <summary>
+            /// Get the STNode type corresponding to the current tree node
+            /// </summary>
+            public Type STNodeType { get; internal set; }
+            /// <summary>
+            /// Get the parent tree node of the current tree node
+            /// </summary>
+            public STNodeTreeCollection Parent { get; internal set; }
+
+            /// <summary>
+            /// Get the number of STNode types owned by the current tree node
+            /// </summary>
+            public int STNodeCount { get; internal set; }
+            /// <summary>
+            /// Get the corresponding path of the STNode type corresponding to the current tree node in the tree control
+            /// </summary>
+            public string Path { get; internal set; }
+            /// <summary>
+            /// Get the current or set whether the tree node is open
+            /// </summary>
+            public bool IsOpen { get; set; }
+            /// <summary>
+            /// Get whether the current tree node is the root node of the loaded module
+            /// </summary>
+            public bool IsLibraryRoot { get; internal set; }
+            /// <summary>
+            /// Get the display area of ​​the current tree node in the control
+            /// </summary>
+            public Rectangle DisplayRectangle { get; internal set; }
+            /// <summary>
+            /// Get the switch button area of ​​the current tree node in the control
+            /// </summary>
+            public Rectangle SwitchRectangle { get; internal set; }
+            /// <summary>
+            /// Get the information button area of ​​the current tree node in the control
+            /// </summary>
+            public Rectangle InfoRectangle { get; internal set; }
+            /// <summary>
+            /// Get the title color of the STNode type corresponding to the current tree node
+            /// </summary>
+            public Color STNodeTypeColor { get; internal set; }
+            /// <summary>
+            /// Get the number of child nodes contained in the current tree node
+            /// </summary>
+            public int Count { get { return m_dic.Count; } }
+            /// <summary>
+            /// Gets or sets the collection with the specified name
+            /// </summary>
+            /// <param name="strKey">specify name</param>
+            /// <returns>Collection</returns>
+            public STNodeTreeCollection this[string strKey] {
+                get {
+                    if (string.IsNullOrEmpty(strKey)) return null;
+                    if (m_dic.ContainsKey(strKey)) return m_dic[strKey];
+                    return null;
+                }
+                set {
+                    if (string.IsNullOrEmpty(strKey)) return;
+                    if (value == null) return;
+                    if (m_dic.ContainsKey(strKey)) {
+                        m_dic[strKey] = value;
+                    } else {
+                        m_dic.Add(strKey, value);
+                    }
+                    value.Parent = this;
+                }
+            }
+
+            private SortedDictionary<string, STNodeTreeCollection> m_dic = new SortedDictionary<string, STNodeTreeCollection>();
+            /// <summary>
+            /// Construct a tree node collection
+            /// </summary>
+            /// <param name="strName">Display name of the current tree node in the control</param>
+            public STNodeTreeCollection(string strName) {
+                if (strName == null || strName.Trim() == string.Empty)
+                    throw new ArgumentNullException("Display name cannot be null");
+                this._Name = strName.Trim();
+                this.NameLower = this._Name.ToLower();
+            }
+            /// <summary>
+            /// Add a child node to the current tree node
+            /// </summary>
+            /// <param name="strName">node display name</param>
+            /// <returns>Added set of child nodes</returns>
+            public STNodeTreeCollection Add(string strName) {
+                if (!m_dic.ContainsKey(strName))
+                    m_dic.Add(strName, new STNodeTreeCollection(strName) { Parent = this });
+                return m_dic[strName];
+            }
+            /// <summary>
+            /// Delete a subcollection from the current tree node
+            /// </summary>
+            /// <param name="strName">Subcollection name</param>
+            /// <param name="isAutoDelFolder">Whether to automatically clear useless nodes recursively upwards</param>
+            /// <returns>Whether the deletion is successful</returns>
+            public bool Remove(string strName, bool isAutoDelFolder) {
+                if (!m_dic.ContainsKey(strName)) return false;
+                bool b = m_dic.Remove(strName);
+                var temp = this;
+                while (temp != null) {
+                    temp.STNodeCount--;
+                    temp = temp.Parent;
+                }
+                if (isAutoDelFolder && m_dic.Count == 0 && this.Parent != null)
+                    return b && this.Parent.Remove(this.Name, isAutoDelFolder);
+                return b;
+            }
+            /// <summary>
+            /// Clear all child nodes in the current tree node
+            /// </summary>
+            public void Clear() { this.Clear(this); }
+
+            private void Clear(STNodeTreeCollection items) {
+                foreach (STNodeTreeCollection v in items) v.Clear(v);
+                m_dic.Clear();
+            }
+            /// <summary>
+            /// Get all the name arrays in the current tree node
+            /// </summary>
+            /// <returns></returns>
+            public string[] GetKeys() { return m_dic.Keys.ToArray(); }
+            /// <summary>
+            /// Copy all data in the current tree node set
+            /// </summary>
+            /// <returns>Copy copy</returns>
+            public STNodeTreeCollection Copy() {
+                STNodeTreeCollection items = new STNodeTreeCollection("COPY");
+                this.Copy(this, items);
+                return items;
+            }
+
+            private void Copy(STNodeTreeCollection items_src, STNodeTreeCollection items_dst) {
+                foreach (STNodeTreeCollection v in items_src) {
+                    this.Copy(v, items_dst.Add(v.Name));
+                }
+                items_dst.Path = items_src.Path;
+                items_dst.STNodeType = items_src.STNodeType;
+                items_dst.IsLibraryRoot = items_src.IsLibraryRoot;
+                items_dst.STNodeCount = items_src.STNodeCount;
+                items_dst.STNodeTypeColor = items_src.STNodeTypeColor;
+            }
+            /// <summary>
+            /// Returns an Array of System.Collections.IEnumerator
+            /// </summary>
+            /// <returns></returns>
+            public IEnumerator GetEnumerator() {
+                foreach (var v in m_dic.Values) yield return v;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() {
+                return this.GetEnumerator();
+            }
+        }
+    }
+}