DotNet 4.8.1 build of DotNetBar

PROMS/DotNetBar Source Code/Editors/VisualItemCollection.cs

@@ -0,0 +1,305 @@
+#if FRAMEWORK20
+using System;
+using System.Text;
+using System.Collections;
+
+namespace DevComponents.Editors
+{
+    public class VisualItemCollection : CollectionBase
+    {
+        #region Internal Implementation
+        /// <summary>Creates new instance of the class.</summary>
+        public VisualItemCollection() { }
+
+        /// <summary>Creates new instance of the class.</summary>
+        public VisualItemCollection(VisualGroup parent)
+        {
+            _Parent = parent;
+        }
+
+        private VisualGroup _Parent = null;
+        internal VisualGroup Parent
+        {
+            get { return _Parent; }
+            set { _Parent = value; }
+        }
+
+        /// <summary>
+        /// Adds new object to the collection.
+        /// </summary>
+        /// <param name="item">Object to add.</param>
+        /// <returns>Index of newly added object.</returns>
+        public int Add(VisualItem item)
+        {
+            return List.Add(item);
+        }
+
+        /// <summary>
+        /// Adds array of new objects to the collection.
+        /// </summary>
+        /// <param name="items">Array of object to add.</param>
+        public void AddRange(VisualItem[] items)
+        {
+            foreach (VisualItem item in items)
+                this.Add(item);
+        }
+
+        /// <summary>
+        /// Adds array of new objects to the collection.
+        /// </summary>
+        /// <param name="items">Array of object to add.</param>
+        public void AddRange(IList items)
+        {
+            for (int i = 0; i < items.Count; i++)
+            {
+                this.Add((VisualItem)items[i]);
+            }
+        }
+
+        /// <summary>
+        /// Returns reference to the object in collection based on it's index.
+        /// </summary>
+        public VisualItem this[int index]
+        {
+            get { return (VisualItem)(List[index]); }
+            set { List[index] = value; }
+        }
+
+        /// <summary>
+        /// Inserts new object into the collection.
+        /// </summary>
+        /// <param name="index">Position of the object.</param>
+        /// <param name="value">Object to insert.</param>
+        public void Insert(int index, VisualItem value)
+        {
+            List.Insert(index, value);
+        }
+
+        /// <summary>
+        /// Returns index of the object inside of the collection.
+        /// </summary>
+        /// <param name="value">Reference to the object.</param>
+        /// <returns>Index of the object.</returns>
+        public int IndexOf(VisualItem value)
+        {
+            return List.IndexOf(value);
+        }
+
+        /// <summary>
+        /// Returns whether collection contains specified object.
+        /// </summary>
+        /// <param name="value">Object to look for.</param>
+        /// <returns>true if object is part of the collection, otherwise false.</returns>
+        public bool Contains(VisualItem value)
+        {
+            return List.Contains(value);
+        }
+
+        /// <summary>
+        /// Removes specified object from the collection.
+        /// </summary>
+        /// <param name="value"></param>
+        public void Remove(VisualItem value)
+        {
+            List.Remove(value);
+        }
+
+        protected override void OnRemove(int index, object value)
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(null, new VisualItem[] { (VisualItem)value }, eCollectionChangeType.Removing));
+            }
+            base.OnRemove(index, value);
+        }
+        protected override void OnRemoveComplete(int index, object value)
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(null, new VisualItem[] { (VisualItem)value }, eCollectionChangeType.Removed));
+            }
+            base.OnRemoveComplete(index, value);
+        }
+
+        protected override void OnInsert(int index, object value)
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(new VisualItem[] { (VisualItem)value }, null, eCollectionChangeType.Adding));
+            }
+            base.OnInsert(index, value);
+        }
+        protected override void OnInsertComplete(int index, object value)
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(new VisualItem[] { (VisualItem)value }, null, eCollectionChangeType.Added));
+            }
+            base.OnInsertComplete(index, value);
+        }
+
+        protected override void OnClear()
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(null, null, eCollectionChangeType.Clearing));
+            }
+            base.OnClear();
+        }
+
+        protected override void OnClearComplete()
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(null, null, eCollectionChangeType.Cleared));
+            }
+            base.OnClearComplete();
+        }
+
+        protected override void OnSet(int index, object oldValue, object newValue)
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(new VisualItem[] { (VisualItem)oldValue },
+                    new VisualItem[] { (VisualItem)newValue }, eCollectionChangeType.Removing));
+            }
+            base.OnSet(index, oldValue, newValue);
+        }
+
+        protected override void OnSetComplete(int index, object oldValue, object newValue)
+        {
+            if (_Parent != null)
+            {
+                _Parent.ProcessItemsCollectionChanged(new CollectionChangedInfo(new VisualItem[] { (VisualItem)oldValue },
+                    new VisualItem[] { (VisualItem)newValue }, eCollectionChangeType.Removed));
+            }
+            base.OnSetComplete(index, oldValue, newValue);
+        }
+
+        /// <summary>
+        /// Copies collection into the specified array.
+        /// </summary>
+        /// <param name="array">Array to copy collection to.</param>
+        /// <param name="index">Starting index.</param>
+        public void CopyTo(VisualItem[] array, int index)
+        {
+            List.CopyTo(array, index);
+        }
+
+        /// <summary>
+        /// Copies contained items to the VisualItem array.
+        /// </summary>
+        /// <param name="array">Array to copy to.</param>
+        internal void CopyTo(VisualItem[] array)
+        {
+            List.CopyTo(array, 0);
+        }
+
+        #endregion
+    }
+
+    public class CollectionChangedInfo
+    {
+        public CollectionChangedInfo(VisualItem[] added, VisualItem[] removed, eCollectionChangeType changeType)
+        {
+            _Added = added;
+            _Removed = removed;
+            _ChangeType = changeType;
+        }
+
+        private VisualItem[] _Added;
+        public VisualItem[] Added
+        {
+            get { return _Added; }
+        }
+
+        private VisualItem[] _Removed;
+        public VisualItem[] Removed
+        {
+            get { return _Removed; }
+        }
+
+        private eCollectionChangeType _ChangeType;
+        public eCollectionChangeType ChangeType
+        {
+            get { return _ChangeType; }
+        }
+    }
+
+    internal class VisualCollectionEnumerator : IEnumerable, IEnumerator
+    {
+        private IList _ParentCollection = null;
+        private int _CurrentIndex = -1;
+        private int _Direction = 1, _Start = -1, _End = -1;
+
+        public VisualCollectionEnumerator(VisualItemCollection parentCollection, bool rightToLeft)
+        {
+            _ParentCollection = parentCollection;
+            if (rightToLeft)
+            {
+                _Direction = -1;
+                _Start = parentCollection.Count - 1;
+                _End = -1;
+            }
+            else
+            {
+                _Start = 0;
+                _End = parentCollection.Count;
+            }
+        }
+
+        #region IEnumerable Members
+
+        public IEnumerator GetEnumerator()
+        {
+            return this;
+        }
+
+        #endregion
+
+        #region IEnumerator Members
+
+        public object Current
+        {
+            get
+            {
+                if (_CurrentIndex < 0)
+                    throw new InvalidOperationException("IEnumerator Pointer is invalid. Use MoveNext to advance enumerator.");
+                return _ParentCollection[_CurrentIndex];
+            }
+        }
+
+        internal int CurrentIndex
+        {
+            get
+            {
+                return _CurrentIndex;
+            }
+            set
+            {
+                _CurrentIndex = value;
+            }
+        }
+
+        public bool MoveNext()
+        {
+            if (_CurrentIndex == _End && _CurrentIndex >= 0)
+                throw new InvalidOperationException("Enumerator cannot advance beyond the boundaries of array. Use Reset to reset enumerator");
+
+            if (_CurrentIndex == -1) _CurrentIndex = _Start - _Direction;
+
+            _CurrentIndex += _Direction;
+            if (_CurrentIndex == _End) return false;
+
+            return true;
+        }
+
+        public void Reset()
+        {
+            _CurrentIndex = -1;
+        }
+        #endregion
+    }
+}
+#endif
+