mirror of
https://mirror.ghproxy.com/https://github.com/dexyfex/CodeWalker
synced 2024-08-20 08:59:21 +08:00
253 lines
8.5 KiB
C#
253 lines
8.5 KiB
C#
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;
|
|
}
|
|
}
|
|
} |