CodeWalker/CodeWalker.WinForms/STNodeEditor/STNodeControlCollection.cs

214 lines
6.7 KiB
C#
Raw Normal View History

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();
}
}
}