namespace Nucleo.EventArguments
{
  public class DataEventArgs < T > : EventArgs
  {
    private T _data;
 
    public T Data
    {
      get
      {
        return _data;
      }
    }
 
    public DataEventArgs(T data)
    {
      _data = data;
    }
  }
 
  public delegate void DataEventHandler < T > (object sender, DataEventArgs < T
    > e);
}

public static event DataEventHandler<Document> DocumentClosed;
public static event DataEventHandler<Document> DocumentCreated;
public static event DataEventHandler<Document> DocumentSelected;

namespace Nucleo.Collections
{
  public class StringCollection: StringCollection
  {
    public void FromCommaSeparatedList(string text)
    {
      this.FromSeparatedList(text, ",");
    }
 
    public void FromSeparatedList(string text, string separator)
    {
      string[]items = text.Split(separator.ToCharArray());
      foreach (string item in items)
      {
        if (!string.IsNullOrEmpty(item))
          this.Add(item);
      }
    }
 
    public string ToCommaSeparatedList()
    {
      return ToSeparatedList(",");
    }
 
    public string ToSeparatedList(string separator)
    {
      string list = string.Empty;
 
      for (int i = 0; i < this.Count; i++)
      {
        if (i != 0)
          list += separator;
        list += this[i];
      }
 
      return list;
    }
 
    public static StringCollection FromList(string text, string separator)
    {
      StringCollection collection = new StringCollection();
      collection.FromSeparatedList(text, separator);
      return collection;
    }
  }
}

namespace Nucleo.Configuration
{
  public abstract class ConfigurationElementBase:
    System.Configuration.ConfigurationElement
  {
    protected internal abstract string Key
    {
      get;
    }
  }
}

namespace Nucleo.Configuration
{
  public abstract class ConfigurationCollectionBase < T > :
    ConfigurationElementCollection where T: ConfigurationElementBase
  {
    public override ConfigurationElementCollectionType CollectionType
    {
      get
      {
        return ConfigurationElementCollectionType.AddRemoveClearMap;
      }
    }
 
    public T this[int index]
    {
      get
      {
        return (T)this.BaseGet(index);
      }
      set
      {
        if (this.BaseGet(index) != null)
          this.BaseRemoveAt(index);
        this.BaseAdd(index, value);
      }
    }
 
    new public T this[string key]
    {
      get
      {
        return (T)this.BaseGet(key);
      }
    }
 
    public void Add(T element)
    {
      this.BaseAdd(element);
    }
 
    public void Clear()
    {
      this.BaseClear();
    }
 
    public bool Contains(string key)
    {
      return (this.BaseGet(key) != null);
    }
 
    protected override ConfigurationElement CreateNewElement()
    {
      return Activator.CreateInstance < T > ();
    }
 
    protected override object GetElementKey(ConfigurationElement element)
    {
      return ((T)element).Key;
    }
 
    public void Remove(T element)
    {
      this.Remove(element.Key);
    }
 
    public void Remove(string key)
    {
      this.BaseRemove(key);
    }
 
    public void RemoveAt(int index)
    {
      this.BaseRemoveAt(index);
    }
  }
}

namespace Nucleo.Web.Configuration
{
  public class IndividualPageElement: ConfigurationElementBase
  {
    protected override string Key
    {
      get
      {
        return this.PageName;
      }
    }
  }
}

public class IndividualPageElementCollection :  
ConfigurationCollectionBase<IndividualPageElement> 
{ 
}

namespace Nucleo.Web.Controls
{
  public abstract class BaseDataField: DataControlField
  {
    private bool _insertMode = false;
 
    public string DataField
    {
      get
      {
        object o = ViewState["DataField"];
        return (o == null) ? string.Empty : o.ToString();
      }
      set
      {
        ViewState["DataField"] = value;
      }
    }
 
    protected bool InsertMode
    {
      get
      {
        return _insertMode;
      }
    }
 
    public bool ReadOnly
    {
      get
      {
        object o = ViewState["ReadOnly"];
        return (o == null) ? false : (bool)o;
      }
      set
      {
        ViewState["ReadOnly"] = value;
      }
    }
 
    protected T ExtractValueFromControl < T > (TableCell cell, int index)where
      T: Control
    {
      if (index < 0 || index >= cell.Controls.Count)
        throw new ArgumentOutOfRangeException("index", Errors.OUT_OF_RANGE);
 
      Control control = cell.Controls[index];
      if (control == null)
        throw new InvalidOperationException(Errors.CANT_EXTRACT_CONTROL_IN_CELL)
          ;
      return (T)control;
    }
 
    public override void ExtractValuesFromCell(IOrderedDictionary dictionary,
      DataControlFieldCell cell, DataControlRowState rowState, bool
      includeReadOnly)
    {
      _insertMode = (rowState == DataControlRowState.Insert);
    }
 
    protected T GetDataItemValue < T > (object container, string property)
    {
      if (container == null || this.DesignMode)
        return default(T);
 
      object dataItem = DataBinder.GetDataItem(container);
      if (dataItem == null)
        return default(T);
      object value = DataBinder.GetPropertyValue(dataItem, property);
 
      if (value != null)
        return (T)value;
      else
        return default(T);
    }
 
    protected bool IsReadMode(DataControlRowState rowState)
    {
      return (this.ReadOnly || rowState == DataControlRowState.Normal ||
        rowState == DataControlRowState.Alternate || rowState ==
        DataControlRowState.Selected);
    }
  }
}

namespace Nucleo.Web.Controls
{
  public abstract class BaseCustomDataField: BaseDataField
  {
    public abstract void BindEditControl(object control, bool insertMode);
 
    public override void ExtractValuesFromCell(IOrderedDictionary dictionary,
      DataControlFieldCell cell, DataControlRowState rowState, bool
      includeReadOnly)
    {
      base.ExtractValuesFromCell(dictionary, cell, rowState, includeReadOnly);
      string value = null;
 
      if (cell.Controls.Count > 0)
        value = this.GetEditControlValue(cell);
 
     //If the dictionary contains the data field, overwrite the value
      if (dictionary.Contains(this.DataField))
        dictionary[this.DataField] = value;
     //Create a new dictionary entry
      else
        dictionary.Add(this.DataField, value);
    }
 
    public abstract string GetEditControlValue(TableCell cell);
 
    public override void InitializeCell(DataControlFieldCell cell,
      DataControlCellType cellType, DataControlRowState rowState, int rowIndex)
    {
      base.InitializeCell(cell, cellType, rowState, rowIndex);
      Control control = null;
 
      if (cellType == DataControlCellType.DataCell)
      {
        if (this.IsReadMode(rowState))
          control = cell;
        else
        {
          cell.Controls.Add(this.SetupEditControl());
 
          if (!string.IsNullOrEmpty(this.DataField))
            control = cell.Controls[0];
        }
 
        if (control != null && this.Visible)
          control.DataBinding += new EventHandler(control_DataBinding);
      }
    }
 
    public abstract Control SetupEditControl();
 
    void control_DataBinding(object sender, EventArgs e)
    {
      if (sender is TableCell)
      {
        TableCell cell = sender as TableCell;
        cell.Text = this.GetDataItemValue < string > (cell.NamingContainer);
      }
      else
        this.BindEditControl(sender, this.InsertMode);
    }
  }
}

public class TextField: BaseCustomDataField
{
  protected override DataControlField CreateField()
  {
    return new TextField();
  }
  public override void BindEditControl(object control, bool insertMode)
  {
    TextBox box = control as TextBox;
//If not in insert mode, set the text property
    if (!insertMode)
      box.Text = this.GetDataItemValue < string > (box.NamingContainer);
  }
 
  public override string GetEditControlValue(TableCell cell)
  {
    return this.ExtractValueFromControl < TextBox > (cell).Text;
  }
 
  public override Control SetupEditControl()
  {
    TextBox box = new TextBox();
    box.TextMode = this.TextMode;
    box.Rows = this.Rows;
    box.Columns = this.Columns;
    box.MaxLength = this.MaximumLength;
    box.ToolTip = this.HeaderText;
    return box;
  }
}