Added STNodeEditor and translated to english

2026-05-14 07:44:46 +08:00 · 2022-01-28 04:16:19 +11:00
parent 8207da8d70
commit 7eaf984005
17 changed files with 8026 additions and 0 deletions
@@ -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();
+        }
+    }
+}