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
}