Multithreaded File/Folder Finder

using System;
using System.Collections;
using System.Globalization;

namespace FileFind
{
    /// <summary>
    /// Contains visibility and positioning information for columns in a gridView,
    /// class ColumnInfo describes an individual column
    /// class GridInfo describes a set of ColumnInfo
    /// </summary>
    public class ColumnInfo : ICloneable
    {   //Contains visibility and position information for an individual column in a gridView
        private string columnName;
        private bool visible;
        private int displayOrder;
        private int columnWidth;
        private bool used;

        public ColumnInfo(string ColumnName, bool IsVisible, int DisplayOrder, int Width)
        {
            columnName = ColumnName;
            visible = IsVisible;
            displayOrder = DisplayOrder;
            columnWidth = Width;
            used = false;
        }
        public ColumnInfo(ColumnInfo columnInfo)
        {
            columnName = columnInfo.ColumnName;
            visible = columnInfo.Visible;
            displayOrder = columnInfo.DisplayOrder;
            columnWidth = columnInfo.Width;
        }

        public string ColumnName
        { get { return columnName; } }

        public bool Visible
        {
            get { return visible; }
            set { visible = value; }
        }

        public int DisplayOrder
        {
            get { return displayOrder; }
            set { displayOrder = value; }
        }

        public int Width
        {
            get { return columnWidth; }
            set { columnWidth = value; }
        }
        public bool Used
        {
            get { return used; }
            set { used = value; }
        }

        public object Clone()
        { return MemberwiseClone(); }

    } //ends class ColumnInfo

    /// <summary>
    /// Contains information for a set of columns in a grid view
    /// </summary>
    public class GridInfoCollection : ICollection, IComparer, IEnumerable, IList, ICloneable
    {   // Contains information for a set of columns in a grid view
        protected ArrayList localColumnInfo;
        protected string gridViewName = "";
        protected bool dirty = false;

        public string ViewName
        {
            get { return gridViewName; }
            set { gridViewName = value; }
        }

        public bool IsDirty
        {
            get { return dirty; }
            set { dirty = value; }
        }

        public GridInfoCollection()
        { localColumnInfo = new ArrayList(); }
        public GridInfoCollection(string name)
        {
            localColumnInfo = new ArrayList();
            gridViewName = name;
        }
        private GridInfoCollection(ArrayList copyArrayList)
        { localColumnInfo = new ArrayList(copyArrayList); }

        /// <summary>
        /// returns number of columns in a grid view
        /// </summary>
        public int Count
        { get { return localColumnInfo.Count; } }

        public bool IsSynchronized
        { get { return localColumnInfo.IsSynchronized; } }

        public object SyncRoot
        { get { return localColumnInfo.SyncRoot; } }

        public void CopyTo(Array dest)
        { localColumnInfo.CopyTo(dest); }
        public void CopyTo(Array dest, int index)
        { localColumnInfo.CopyTo(dest, index); }

        public int Compare(object gridinfo1, object gridinfo2)
        { return String.Compare(gridinfo1.ToString(), gridinfo2.ToString(), true, CultureInfo.InvariantCulture); }

        public bool IsFixedSize
        { get { return localColumnInfo.IsFixedSize; } }
        public bool IsReadOnly
        { get { return false; } }
        public object this[int index]
        {
            get
            {
                if ((index < 0) || (index > localColumnInfo.Count))
                    return (ColumnInfo)null;
                return (ColumnInfo)localColumnInfo[index];
            }
            set { localColumnInfo.Add(value); }
        }

        public int Add(object columnInfo)
        {
            if (columnInfo is ColumnInfo)
            {
                dirty = true;
                if (!localColumnInfo.Contains(columnInfo))
                    return localColumnInfo.Add(columnInfo);
            }
            return -1;
        }

        /// <summary>
        /// Removes all column information for a grid view
        /// </summary>
        public void Clear()
        { localColumnInfo.Clear(); }

        /// <summary>
        /// returns true if column information is present
        /// </summary>
        /// <param name="columnInfo">may be a column name or a ColumnInfo object</param>
        /// <returns></returns>
        public bool Contains(object columnInfo)
        {
            if (columnInfo is ColumnInfo)
                return localColumnInfo.Contains(columnInfo);
            if (columnInfo is string)
            {
                string str = columnInfo as string;
                foreach (ColumnInfo columninfo in localColumnInfo)
                    if (0 == String.Compare(str, columninfo.ColumnName, true, CultureInfo.InvariantCulture))
                        return true;
            }
            return false;
        }
        public int IndexOf(object columnInfo)
        { return localColumnInfo.IndexOf(columnInfo); }
        public void Insert(int index, object columnInfo)
        { localColumnInfo.Insert(index, columnInfo); }
        public void Remove(object columnInfo)
        {
            dirty = true;
            if (columnInfo is ColumnInfo)
                Remove(columnInfo);
            else if (columnInfo is string)
            {
                string str = columnInfo as string;
                foreach (ColumnInfo columninfo in localColumnInfo)
                    if (0 == String.Compare(str, columninfo.ColumnName, true, CultureInfo.InvariantCulture))
                    {
                        localColumnInfo.Remove(columnInfo);
                        break;
                    }
            }
        }
        public void RemoveAt(int index)
        {
            if ((index > -1) && (index < Count))
            {
                dirty = true;
                localColumnInfo.RemoveAt(index);
            }
        }

        public IEnumerator GetEnumerator()
        { return new gridinfoEnumerator(localColumnInfo); }

        private class gridinfoEnumerator : IEnumerator
        {
            ArrayList entities;
            IEnumerator myEnumerator;
            public gridinfoEnumerator(ArrayList entities)
            {
                this.entities = entities;
                myEnumerator = entities.GetEnumerator();
            }
            public object Current
            { get { return myEnumerator.Current; } }
            public bool MoveNext()
            { return myEnumerator.MoveNext(); }
            public void Reset()
            { }
        } //ends class gridinfoEnumerator

        /// <summary>
        /// Deep copy
        /// </summary>
        /// <returns></returns>
        public object Clone()
        {
            GridInfoCollection newColumnsInfo = new GridInfoCollection();
            newColumnsInfo.ViewName = this.ViewName;
            newColumnsInfo.localColumnInfo = new ArrayList();
            foreach (ColumnInfo columnInfo in localColumnInfo)
                newColumnsInfo.localColumnInfo.Add(columnInfo.Clone());     //works!
            //newColumnsInfo.localColumnInfo.Add(new ColumnInfo(columnInfo)); //also works!
            newColumnsInfo.dirty = false;
            return newColumnsInfo;
        }

        /// <summary>
        /// Changes the value of the IsUsed parameter
        /// </summary>
        /// <param name="columnName">name of column</param>
        /// <param name="newValue">true if update occured, false if column name was not found</param>
        public bool UpdateIsUsed(string columnName, bool newValue)
        {
            foreach (ColumnInfo columnInfo in localColumnInfo)
                if (0 == String.Compare(columnName, columnInfo.ColumnName, true, CultureInfo.InvariantCulture))
                {
                    columnInfo.Used = newValue;
                    return true;
                }
            return false;
        }

        /// <summary>
        /// Turns the IsUsed flag off for all columns
        /// </summary>
        public void SetAllIsUsedOff()
        {
            foreach (ColumnInfo columnInfo in localColumnInfo)
                columnInfo.Used = false;
        }

        public void SortByDisplayOrder()
        {
            IComparer myComparer = new DisplayOrderSort();
            localColumnInfo.Sort(myComparer);
        }

        public bool Visible(string colName)
        {
            foreach (ColumnInfo columninfo in localColumnInfo)
                if (0 == String.Compare(colName, columninfo.ColumnName, true, CultureInfo.InvariantCulture))
                    return columninfo.Visible;
            return false;
        }
        /// <summary>
        /// updates the visibility of a column
        /// </summary>
        /// <param name="colName">name of column</param>
        /// <param name="newVisible">true if column is to be visible</param>
        /// <returns>true if update occured, false if column name was not found</returns>
        public bool UpdateVisible(string colName, bool newVisible)
        {
            foreach (ColumnInfo columnInfo in localColumnInfo)
                if (0 == String.Compare(colName, columnInfo.ColumnName, true, CultureInfo.InvariantCulture))
                {
                    columnInfo.Visible = newVisible;
                    return true;
                }
            return false;
        }

        /// <summary>
        /// fetches the saved display order for a column
        /// </summary>
        /// <param name="colName">name of column</param>
        /// <returns>display order index or -1 if error</returns>
        public int DisplayOrder(string colName)
        {
            foreach (ColumnInfo columnInfo in localColumnInfo)
                if (0 == String.Compare(colName, columnInfo.ColumnName, true, CultureInfo.InvariantCulture))
                    return columnInfo.DisplayOrder;
            return -1;
        }

        /// <summary>
        /// updates the display order for a column
        /// </summary>
        /// <param name="columnName">name of column</param>
        /// <param name="newDisplayOrder">new display order</param>
        /// <returns>true if update occured, false if column name was not found</returns>
        public bool UpdateDisplayOrder(string columnName, int newDisplayOrder)
        {
            foreach (ColumnInfo columnInfo in localColumnInfo)
                if (0 == String.Compare(columnName, columnInfo.ColumnName, true, CultureInfo.InvariantCulture))
                {
                    dirty = true;
                    columnInfo.DisplayOrder = newDisplayOrder;
                    return true;
                }
            return false;
        }

        private class DisplayOrderSort : IComparer
        {   // Compares the display positions for sorting
            int IComparer.Compare(Object x, Object y)
            {
                ColumnInfo xInfo = x as ColumnInfo;
                ColumnInfo yInfo = y as ColumnInfo;
                return (xInfo.DisplayOrder - yInfo.DisplayOrder);
            }
        } //ends private class DisplayOrderSort

    } //ends GridInfo
}