struts-sandbox/overdrive/Nexus/Web/GridControl.ascx.cs

using System;
using System.Collections;
using System.Web.UI;
using System.Web.UI.WebControls;
using Nexus.Core;
using Nexus.Core.Helpers;
using WQD.Core.Controls;

namespace Nexus.Web
{
	/// <summary>
	/// List, edit, and select items using a DataGrid and IViewHelper commands. 
	/// </summary>
	public class GridControl : ViewControl
	{
		#region Runtime state Properties

		/// <summary>
		/// Provide an attribute token for List_Criteria.
		/// </summary>
		private string LIST_CRITERIA_KEY = "list_Criteria";

		/// <summary>
		/// Set the given criteria to the list_Critieria (creating a new one if null), and, 
		/// if AllowCustomPage is set, 
		/// calculate new Limit and Offset, based on pageIndex, and set to criteria.
		/// </summary>
		/// <remarks><p>
		/// This form is provided to be called by list_Criteria_Init. 
		/// The other form is provided to be called by other methods.
		/// </p></remarks>
		/// <param name="criteria">The criteria instance to store the attributes</param>
		/// <param name="pageIndex">The new page index</param>
		protected IDictionary list_Criteria_NewPageIndex(IDictionary criteria, int pageIndex)
		{
			if (Grid.AllowCustomPaging)
			{
				if (criteria == null) criteria = new Hashtable(); // FIXME: Spring?
				int page = pageIndex;
				int limit = Grid.PageSize;
				int offset = page*limit;
				criteria[ITEM_LIMIT] = limit;
				criteria[ITEM_OFFSET] = offset;
			}
			list_Criteria = criteria;
			return criteria;
		}

		protected IDictionary list_Criteria_NewPageIndex(IDictionary criteria, int pageIndex, bool allowCustomPaging)
		{
			Grid.AllowCustomPaging = allowCustomPaging;
			return list_Criteria_NewPageIndex(criteria, pageIndex);
		}

		protected IDictionary list_Criteria_NewPageIndex(int pageIndex)
		{
			IDictionary criteria = list_Criteria;
			return list_Criteria_NewPageIndex(criteria, pageIndex);
		}

		/// <summary>
		/// Provide values to use with a query statement, persisted across requests.
		/// </summary>
		protected IDictionary list_Criteria
		{
			get
			{
				IDictionary criteria = ViewState[LIST_CRITERIA_KEY] as IDictionary;
				return criteria;
			}
			set { ViewState[LIST_CRITERIA_KEY] = value; }
		}

		/// <summary>
		/// Merge values into list_Criteria.
		/// </summary>
		/// <param name="criteria">Values to append</param>
		public void Read(IDictionary criteria)
		{
			ICollection keys = criteria.Keys;
			foreach (string key in keys)
			{
				list_Criteria[key] = criteria[key];
			}
		}

		/// <summary>
		/// Provide attribute token for List_ItemIndex.
		/// </summary>
		private const string LIST_ITEM_INDEX = "list_ItemIndex";

		/// <summary>
		/// Current item index, used mainly to signal editing. 
		/// </summary>
		public virtual int list_ItemIndex
		{
			get
			{
				object value = ViewState[LIST_ITEM_INDEX];
				if (value == null) return -1;
				return (int) value;
			}
			set
			{
				ViewState[LIST_ITEM_INDEX] = value;
				if (Grid != null) Grid.EditItemIndex = value;
			}
		}

		/// <summary>
		/// Provide attribute token for List_ItemKey.
		/// </summary>
		private const string LIST_ITEM_KEY = "list_ItemKey";

		/// <summary>
		/// Provide data key for the selected item.
		/// </summary>
		public virtual string list_ItemKey
		{
			get { return ViewState[LIST_ITEM_KEY] as string; }
			set { ViewState[LIST_ITEM_KEY] = value; }
		}

		/// <summary>
		/// Provide attribute token for List_Insert.
		/// </summary>
		private const string LIST_INSERT_KEY = "list_Insert";

		/// <summary>
		/// Determine insert mode - are we adding or modifying?
		/// </summary>
		public virtual bool list_Insert
		{
			get
			{
				object value = ViewState[LIST_INSERT_KEY];
				if (value == null) return false;
				return (bool) value;
			}
			set { ViewState[LIST_INSERT_KEY] = value; }
		}

		/// <summary>
		/// Store whether command uses critiera.
		/// </summary>
		private bool _HasCriteria = true;

		/// <summary>
		/// Track whether a criteria is used.
		/// </summary>
		public virtual bool HasCriteria
		{
			get { return _HasCriteria; }
			set { _HasCriteria = value; }
		}

		#endregion

		#region Command properties to set

		/// <summary>
		/// Store the Find Command.
		/// </summary>
		private string _FindCommand;

		/// <summary>
		/// Provide the Find Command to prepare a new search.
		/// </summary>
		public virtual string FindCommand
		{
			get { return _FindCommand; }
			set { _FindCommand = value; }
		}

		/// <summary>
		/// Store the List Command.
		/// </summary>
		private string _ListCommand;

		/// <summary>
		/// Provide the List Command to filter items and populate the DataGrid.
		/// </summary>
		public virtual string ListCommand
		{
			get { return _ListCommand; }
			set { _ListCommand = value; }
		}

		/// <summary>
		/// Store the Save Command.
		/// </summary>
		private string _SaveCommand;

		/// <summary>
		/// Provide the Save Command to retain changes to an item.
		/// </summary>
		public virtual string SaveCommand
		{
			get { return _SaveCommand; }
			set { _SaveCommand = value; }
		}

		#endregion

		#region Column properties to set 

		/// <summary>
		/// Store the key field.
		/// </summary>
		private string _DataKeyField;

		/// <summary>
		/// Provide the key field for the DataGrid.
		/// </summary>
		public virtual string DataKeyField
		{
			get { return _DataKeyField; }
			set { _DataKeyField = value; }
		}

		/// <summary>
		/// Store the list of GridConfig items.
		/// </summary>
		private IList _Configs;

		/// <summary>
		/// Provide a list of the GridConfig items.
		/// </summary>
		/// <remarks><p>
		/// GridConfig is a local class that describes 
		/// the fields needed to program a DataGrid column.
		/// </p></remarks>
		public virtual IList Configs
		{
			get { return _Configs; }
			set { _Configs = value; }
		}

		#endregion

		#region Column properties with defaults

		/// <summary>
		/// Provide default text for the EDIT control.
		/// </summary>
		public const string msg_EDIT_TEXT = "EDIT";
		
		/// <summary>
		/// Provide default text for the CANCEL control.
		/// </summary>
		public const string msg_QUIT_TEXT = "CANCEL";

		/// <summary>
		/// Provide default text for the SAVE control.
		/// </summary>
		public const string msg_SAVE_TEXT = "SAVE";

		/// <summary>
		/// Provide default text for the ITEM control.
		/// </summary>		
		public const string msg_ITEM_TEXT = "#";
		
		/// <summary>
		/// Store the text for the EDIT control.
		/// </summary>
		private string _EditText = msg_EDIT_TEXT;

		/// <summary>
		/// Provide the text for the EDIT control.
		/// </summary>
		public virtual string EditText
		{
			get { return _EditText; }
			set { _EditText = value; }
		}

		/// <summary>
		/// Store the text for the QUIT control.
		/// </summary>
		private string _QuitText = msg_QUIT_TEXT;

		/// <summary>
		/// Provide the text for the QUIT control.
		/// </summary>
		public virtual string QuitText
		{
			get { return _QuitText; }
			set { _QuitText = value; }
		}

		/// <summary>
		/// Store the text for the SAVE control.
		/// </summary>
		private string _SaveText = msg_SAVE_TEXT;

		/// <summary>
		/// Provide the text for the SAVE control.
		/// </summary>
		public virtual string SaveText
		{
			get { return _SaveText; }
			set { _SaveText = value; }
		}

		/// <summary>
		/// Store the text for the ITEM control.
		/// </summary>
		private string _ItemText = msg_ITEM_TEXT;

		/// <summary>
		/// Provide the text for the ITEM control.
		/// </summary>
		public virtual string ItemText
		{
			get { return _ItemText; }
			set { _ItemText = value; }
		}

		/// <summary>
		/// Provide default token to signal an item select command.
		/// </summary>		
		public const string msg_ITEM_COMMAND = "Item";

		/// <summary>
		/// Store the token to signal an item select command. 
		/// </summary>
		private string _ItemCommand = msg_ITEM_COMMAND;

		/// <summary>
		/// Provide the token to signal an item select command. 
		/// </summary>
		public virtual string ItemCommandName
		{
			get { return _ItemCommand; }
			set { _ItemCommand = value; }
		}

		/// <summary>
		/// Store whether an item column is presented [false].
		/// </summary>
		private bool _HasItemColumn = false;

		/// <summary>
		/// Provide whether an item column is presented [false].
		/// </summary>
		public virtual bool HasItemColumn
		{
			get { return _HasItemColumn; }
			set { _HasItemColumn = value; }
		}

		/// <summary>
		/// Store whether an edit column is presented [false].
		/// </summary>
		private bool _HasEditColumn = false;

		/// <summary>
		/// Provide whether an edit column is presented [false].
		/// </summary>
		public virtual bool HasEditColumn
		{
			get { return _HasEditColumn; }
			set { _HasEditColumn = value; }
		}

		/// <summary>
		/// Store whether dataset is being accessed page by page. 
		/// </summary>
		private bool _AllowCustomPaging = true;

		/// <summary>
		/// Provide whether dataset is being accessed page by page. 
		/// </summary>
		/// <remarks><p>
		/// Custom paging refers to whether the entire dataset is retrieved all at once
		/// or whether the items to fill the current page are retrieved.
		/// A DataGrid may be configured to display pages with AllowCusteomPaging set to false, 
		/// but the underlying query should retrieve the entire dataset up front.
		/// Whether page numbers are used is set in the DataGrid markup, not here.
		/// </p></remarks>
		public virtual bool AllowCustomPaging
		{
			get { return _AllowCustomPaging; }
			set { _AllowCustomPaging = value; }
		}

		/// <summary>
		/// Store the ASP.NET default for a DataGrid page size.
		/// </summary>
		const int DEFAULT_DATAGRID_PAGESIZE = 10;
		
		/// <summary>
		/// Store the DataGrid default page size.
		/// </summary>
		private int _PageSize = DEFAULT_DATAGRID_PAGESIZE;

		/// <summary>
		/// Provide the DataGrid default page size.
		/// </summary>
		public virtual int PageSize
		{
			get { return _PageSize; }
			set { _PageSize = value; }
		}

		#endregion		

		#region Binding methods 

		/// <summary>
		/// Set the Helper's outcome to the DataGrid datasource, 
		/// and update the virtual item count if AllowCustomPaging.
		/// </summary>
		/// <param name="helper"></param>
		protected virtual void DataSource(IViewHelper helper)
		{
			IList list = helper.Outcome;
			DataGrid grid = Grid;
			grid.DataSource = list;
			if (grid.AllowCustomPaging)
			{
				grid.VirtualItemCount = GetItemCount(helper);
			}
		}

		/// <summary>
		/// Bind the current datasource to the base control and the DataGrid control.
		/// </summary>
		public override void DataBind()
		{
			base.DataBind();
			Grid.DataBind();
		}

		/// <summary>
		/// Configure a control column to select a DataGrid item (or row).
		/// </summary>
		/// <param name="pos">The column position</param>
		/// <returns>The next column position</returns>
		protected virtual int BindItemColumn(int pos)
		{
			ButtonColumn column = new ButtonColumn();
			column.ButtonType = ButtonColumnType.PushButton;
			column.Text = ItemText;
			column.CommandName = ItemCommandName;
			Grid.Columns.AddAt(pos, column);
			return ++pos;
		}

		/// <summary>
		/// Configure a control column to edit a DataGrid item (or row).
		/// </summary>
		/// <param name="pos">The column position</param>
		/// <returns>The next column position</returns>
		protected virtual int BindEditColumn(int pos)
		{
			EditCommandColumn column = new EditCommandColumn();
			column.ButtonType = ButtonColumnType.PushButton;
			column.EditText = EditText;
			column.CancelText = QuitText;
			column.UpdateText = SaveText;
			Grid.Columns.AddAt(pos, column);
			return ++pos;
		}

		/// <summary>
		/// Configure the list of custom columns, starting from a given column position.
		/// </summary>
		/// <remarks><p>
		/// If the edit or item columns have already been configured, 
		/// then starting position may be 1 or 2.
		/// </p></remarks>
		/// <param name="pos">Starting column position</param>
		/// <returns>Next column position</returns>
		protected virtual int BindColumns(int pos)
		{
			DataGrid grid = Grid;
			grid.DataKeyField = DataKeyField;
			IList configs = Configs;
			int colCount = configs.Count;
			for (int c = 0; c < colCount; c++)
			{
				IGridConfig config = configs[c] as IGridConfig;
				if (config.HasTemplate)
				{
					pos = BindTemplateColumn(pos, config);
				}
				else pos = BindColumn(pos, config);
			}
			return pos;
		}

		/// <summary>
		/// Configure a DataGrid column at the given position, 
		/// using the IGridConfig settings.
		/// </summary>
		/// <param name="pos">Position to insert column</param>
		/// <param name="config">Column settings</param>
		/// <returns>The next column pos</returns>
		protected int BindColumn(int pos, IGridConfig config)
		{
			BoundColumn column = new BoundColumn();
			column.HeaderText = config.HeaderText;
			column.DataField = config.DataField;
			// column.SortExpression = config.sortExpression; // See DataGridColumn.SortExpression Property
			// column.DataFormatString = config.dataFormat; // See Formatting Types in .NET Dev Guide
			Grid.Columns.AddAt(pos, column);
			return pos + 1;
		}

		/// <summary>
		/// Configure a template column at the given position, 
		/// using the IGtridConfig settings.
		/// </summary>
		/// <param name="pos">Position to insert column</param>
		/// <param name="config">Column settings</param>
		/// <returns>The next column pos</returns>
		protected int BindTemplateColumn(int pos, IGridConfig config)
		{
			TemplateColumn column = new TemplateColumn();
			column.HeaderText = config.HeaderText;
			column.ItemTemplate = config.ItemTemplate;
			column.EditItemTemplate = config.EditItemTemplate;
			// column.SortExpression = config.sortExpression; // See DataGridColumn.SortExpression Property
			// column.DataFormatString = config.dataFormat; // See Formatting Types in .NET Dev Guide
			Grid.Columns.AddAt(pos, column);
			return pos + 1;
		}

		/// <summary>
		/// Store whether the DataGrid has bee configured.
		/// </summary>
		private bool bind = true;

		/// <summary>
		/// Initialize the DataGrid with any custom columns.
		/// </summary>
		/// <remarks>
		/// This method is meant to be overriden by subclasses 
		/// to program a custom set of DataGrid columns.
		/// </remarks>
		protected virtual void InitGrid()
		{
			bind = true;
		}

		/// <summary>
		/// Obtain the item count from Helper.
		/// </summary>
		/// <param name="helper">The helper to examine</param>
		/// <returns>Total count of items for all pages</returns>
		/// 	
		protected int GetItemCount(IViewHelper helper)
		{
			return Convert.ToInt32(helper.Criteria[ITEM_COUNT]);
		}

		/// <summary>
		/// Obtain the item page from Helper, or zero if no page set.
		/// </summary>
		/// <param name="helper">The helper to examine</param>
		/// <returns>Current page number within data set</returns>
		/// 	
		protected int GetItemPage(IViewHelper helper)
		{
			object page = helper.Criteria[ITEM_PAGE];
			if (page==null) return 0;			
			return Convert.ToInt32(page);
		}

		/// <summary>
		/// Update the item page from Helper.
		/// </summary>
		/// <param name="helper">The helper to examine</param>
		/// <returns>Current page number for current item</returns>
		/// 	
		protected void SetItemPage(IViewHelper helper, int page)
		{
			helper.Criteria[ITEM_PAGE] = Convert.ToString(page);
		}

		
		/// <summary>
		/// Update the item offset from Helper.
		/// </summary>
		/// <param name="helper">The helper to examine</param>
		/// <returns>Current page number for current item</returns>
		/// 	
		protected void SetItemOffset(IViewHelper helper, int ofs)
		{
			helper.Criteria[ITEM_OFFSET] = Convert.ToString(ofs);
		}


		/// <summary>
		/// Obtain the item key field name.
		/// </summary>
		/// <param name="context">The context to examine</param>
		/// <returns>Name of key field</returns>
		/// 	
		protected object GetItemKey(IDictionary context)
		{
			if (context==null) return null;
			return context[ITEM_KEY];
		}
		
		/// <summary>
		/// Store the item key field name.
		/// </summary>
		/// <param name="context">The context to examine</param>
		/// <param name="key">The name of the item key field</param>
		/// 	
		protected void SetItemKey(IDictionary context, string key)
		{
			if (context!=null) context[ITEM_KEY] = key;
		}
		
		/// <summary>
		/// Obtain the item key value for Helper.
		/// </summary>
		/// <param name="context">The context to examine</param>
		/// <returns>Current page number within data set</returns>
		/// 	
		protected object GetItemKeyValue(IDictionary context)
		{
			if (context==null) return null;
			object key = context[ITEM_KEY];
			if (key==null) return null;
			return context[key];
		}
		
		/// <summary>
		/// Update the item key value for Helper, especially to clear on Add.
		/// </summary>
		/// <param name="context">The context to examine</param>
		/// <returns>Current page number within data set</returns>
		/// 	
		protected void SetItemKeyValue(IDictionary context, string val)
		{
			if (context==null) return;
			object key = context[ITEM_KEY];
			if (key!=null) context[key] = val;
		}

		/// <summary>
		/// Configure the DataGrid for initial display.
		/// </summary>
		/// <param name="helper">The Helper with an outcome to bind as a DataSource</param>
		protected virtual void BindGrid(IViewHelper helper)
		{

			// Only bind columns once
			// WARNING: Won't work with a singleton
			DataGrid grid = Grid;
			int count = (helper.Outcome).Count;
			if (bind)
			{
				bind = false;
				int i = 0;
				if (HasEditColumn) i = BindEditColumn(i);
				if (HasItemColumn) i = BindItemColumn(i);
				// Adopt any direct changes to Grid object
				if (grid.PageSize==DEFAULT_DATAGRID_PAGESIZE) grid.PageSize = PageSize;
				AllowCustomPaging = AllowCustomPaging || grid.AllowCustomPaging;
				// Check custom page settings
				if (AllowCustomPaging)
				{					
					grid.AllowCustomPaging = true;
					count = GetItemCount(helper);
					grid.VirtualItemCount = count;
					int page = GetItemPage(helper);
					if (page!=0) grid.CurrentPageIndex = page;
				}
				BindColumns(i);
			}
			ListPageIndexChanged_Raise(this,
			                           grid.CurrentPageIndex,
			                           grid.PageSize,
			                           count);
			DataSource(helper);
			DataBind();
		}

		#endregion 

		#region Special ReadControls method 

		/// <summary>
		/// Inspect a collection of DataGrid controls and set control values to a dictionary.
		/// </summary>
		/// <param name="controls">DataGrid Control Collection</param>
		/// <param name="dictionary">Output object for control values</param>
		/// <param name="keys">List of control/attribute names to collect</param>
		/// <param name="nullIfEmpty">If value is an empty strong, set to null</param>
		protected void ReadGridControls(ControlCollection controls, IDictionary dictionary, string[] keys, bool nullIfEmpty)
		{
			int i = -1;
			foreach (Control t in controls)
			{
				i++;
				string key = keys[i];
				if (IsTextBox(t))
				{
					TextBox x = (TextBox) t;
					string value = (nullIfEmpty) ? NullOnEmpty(x.Text) : x.Text;
					dictionary.Add(key, value);
					continue;
				}
				if (IsLabel(t))
				{
					Label x = (Label) t;
					string value = (nullIfEmpty) ? NullOnEmpty(x.Text) : x.Text;
					dictionary.Add(key, value);
					continue;
				}
				if (IsListControl(t))
				{
					ListControl x = (ListControl) t;
					string value = (nullIfEmpty) ? NullOnEmpty(x.SelectedValue) : x.SelectedValue;
					dictionary.Add(key, value);
					continue;
				}
				if (IsCheckBox(t))
				{
					CheckBox x = (CheckBox) t;
					string value = (x.Checked) ? key : null;
					dictionary.Add(key, value);
					continue;
				}
				if (IsRadioButton(t))
				{
					RadioButton x = (RadioButton) t;
					string value = (x.Checked) ? key : null;
					dictionary.Add(key, value);
					continue;
				}
			}

			/// Workaround so that template columns can be utilized by a dynamic DataGrid.
			/// [OVR-24] - Template columns not passed by DataGridCommandEventArgs
			foreach (IGridConfig c in Configs)
			{
				bool isTemplateColumn = c.ItemTemplate!=null;
				if (isTemplateColumn)
				{
					string key = c.DataField;
					string value =  FindControlValue(key);
					dictionary.Add(key,value);
				}
			}
		}

		#endregion

		#region Command methods

		/// <summary>
		/// Provide an internal extension point 
		/// that can return an entry item of the appropriate type 
		/// to use when adding a new entry to the dataset.
		/// </summary>
		protected virtual IEntryList NewContextList
		{
			get { throw new NotImplementedException(); }
		}
		
		/// <summary>
		/// Create a blank for editing by creating an empty row 
		/// and temporarily changing the datasource.
		/// </summary>
		/// <returns></returns>
		protected virtual IViewHelper DataInsert()
		{
			DataGrid grid = Grid;
			IEntryList list = NewContextList;
			// Fake a blank row
			IViewHelper helper = GetHelperFor(ListCommand);
			list.Insert(String.Empty);
			helper.Criteria[ListCommand] = list;
			grid.DataSource = list;
			grid.CurrentPageIndex = 0;
			grid.EditItemIndex = 0;
			BindGrid(helper);
			return helper;
		}

		/// <summary>
		/// Invoke a Find command.
		/// </summary>
		/// <param name="key">Data index key for the entry, if any</param>
		/// <param name="controls">The set of controls</param>
		/// <returns>The executed helper</returns>
		protected virtual IViewHelper Find(string key, ControlCollection controls)
		{
			IViewHelper helper = ExecuteBind(FindCommand);
			return helper;
		}

		/// <summary>
		/// Invoke a Save command.
		/// </summary>
		/// <param name="key">Data index key for the entry, if any</param>
		/// <param name="controls">The set of controls</param>
		/// <returns>The executed helper</returns>
		protected virtual IViewHelper Save(string key, ControlCollection controls)
		{
			IViewHelper h = GetHelperFor(SaveCommand);
			if (h.IsNominal)
			{
				IList configs = Configs;
				h.Criteria[DataKeyField] = key;
				int cols = configs.Count;
				string[] keys = new string[2 + cols];
				// reconstruct the standard edit column keys
				// just as placeholders, really
				keys[0] = SaveText;
				keys[1] = QuitText;
				int index = 2;
				// append our field names to the array of keys
				for (int i = 0; i < cols; i++)
					keys[index++] = (configs[i] as IGridConfig).DataField;
				ReadGridControls(controls, h.Criteria, keys, true);

				h.Execute();
			}
			return h;
		}

		#endregion

		#region Loading methods

		/// <summary>
		/// Invoke a ListCommand that doesn't require a criteria.
		/// </summary>
		/// <returns>Executed helper</returns>
		public virtual IViewHelper ExecuteList()
		{
			IViewHelper helper = Execute(ListCommand);
			bool okay = helper.IsNominal;
			if (okay) BindGrid(helper); // DoBindGrid = helper;
			return helper;
		}
		
		/// <summary>
		/// Look for a IssueEventKey, and scroll to it, if found.
		/// </summary>
		/// <param name="criteria">Input/outpout values</param>
		/// <returns>Helper after obtaining list</returns>
		public virtual IViewHelper ExecuteList(IDictionary criteria)
		{
			
			IViewHelper helper = ReadExecute(ListCommand, criteria);

			object issue_event_key = GetItemKeyValue(criteria);
			int count = GetItemCount(helper);
			bool okay = helper.IsNominal;
			bool skip_to_item = (issue_event_key == null) || (count==0) || !okay;
			if (skip_to_item)
			{
				if (okay) BindGrid(helper); // DoBindGrid = helper;
				return helper;
			}
			
			bool found = false; 
			int page = -1;
			int item = -1;
			object key = GetItemKey(criteria);
			while ((!found) && (count>item) && helper.IsNominal)
			{
				page++;
				if (helper.IsNominal)
				{
					IList outcome = helper.Outcome;
					foreach (EntryDictionary e in outcome)
					{
						found = found || (issue_event_key.Equals(e.Criteria[key]));
					}
					if (!found)
					{
						item = item + outcome.Count;
						SetItemOffset(helper,item+1);
						helper.Execute();
					}
				}
			}
			
			if (helper.IsNominal)
			{
				if (found) SetItemPage(helper,page);							
				BindGrid(helper); // DoBindGrid = helper;
			} 
			return helper;
		}
		
		
		
		
		/// <summary>
		/// Setup the DataGrid when the page is first initialized.
		/// </summary>
		/// <param name="criteria">Parameters for the comamnd</param>
		/// <returns></returns>
		public virtual IViewHelper LoadGrid(IDictionary criteria)
		{
			IViewHelper helper;

			if ((Grid.AllowCustomPaging) && (criteria == null))
			{
				list_Criteria_NewPageIndex(criteria, 0, true);
				HasCriteria = true;
			}

			if (HasCriteria) 
			{
				helper = ExecuteList(criteria);
			}
			else
				helper = ExecuteList();
			
			if (Grid.AllowCustomPaging)
			{
				int page = GetItemPage(helper);
				int count = GetItemCount(helper);
				ListPageIndexChanged_Raise(this, page, Grid.PageSize, count);								
			}
			
			return helper;
		}

		#endregion 

		#region List properties to set

		private DataGrid _Grid;

		public DataGrid Grid
		{
			get { return _Grid; }
			set { _Grid = value; }
		}

		#endregion

		#region List methods

		public virtual bool Open()
		{
			IViewHelper helper = LoadGrid(list_Criteria);
			bool okay = helper.IsNominal;
			if (!okay)
			{
				Page_Alert = helper;
			}
			return okay;
		}

		public virtual bool Open(IDictionary criteria)
		{
			Page_Reset();
			list_Criteria_NewPageIndex(criteria, 0, AllowCustomPaging);
			return Open();
		}

		public virtual void Reset(IDictionary criteria)
		{
			list_ResetIndex();
			Open(criteria);
		}

		public virtual void Reset()
		{
			Reset(list_Criteria);
		}

		/// <summary>
		/// Handle standard list Item events by opening item 
		/// or preparing to add a new item.
		/// </summary>
		/// <param name="commandName">The com</param>
		/// <param name="index"></param>
		protected virtual void list_Item(string commandName, int index)
		{
			switch (commandName)
			{
				case "Page":
					// Handled by StepList_PageIndexChanged
					break;
				case msg_ITEM_COMMAND:
					string key = Grid.DataKeys[index] as string;
					list_ItemKey = key;
					list_Item_Click(index);
					break;
				default:
					{
						if (list_Insert)
							// ISSUE: If insert fails, old input is not retained. [WNE-67]
							list_Add();
						else
							list_Refresh();
						break;
					}
			}
		}

		/// <summary>
		/// Handle standard Edit events by setting the index and refreshing display.
		/// </summary>
		/// <param name="index"></param>
		protected virtual void list_Edit(int index)
		{
			// ISSUE: Event? Page_Prompt = msg_EDIT_HINT;
			list_ItemIndex = index;
			list_Refresh();
		}

		/// <summary>
		/// Reset DataGrid state.
		/// </summary>
		protected virtual void list_Quit()
		{
			// ISSUE: Event? Page_Prompt = msg_QUIT_SUCCESS;
			list_Insert = false;
			list_ItemIndex = -1;
			list_Refresh();
		}

		/// <summary>
		/// Refresh DataGrid  by rebinding datasource.
		/// </summary>
		protected virtual void list_Refresh()
		{
			DataBind();
		}

		/// <summary>
		/// Set the selected index to 0. 
		/// </summary>
		/// <remarks><p>
		/// When changing the find set, also call List_ResetIndex;
		/// otherwise, the DataGrid may try to select an item 
		/// that is outside the new found set.
		/// </p></remarks>
		protected void list_ResetIndex()
		{
			Grid.SelectedIndex = 0;
			Grid.CurrentPageIndex = 0; // sic
		}

		/// <summary>
		/// Insert a new row for editing.
		/// </summary>
		protected virtual void list_Add()
		{
			IViewHelper helper = DataInsert();
			bool okay = helper.IsNominal;
			if (okay)
			{
				// ISSUE: Event? Page_Prompt = msg_EDIT_HINT;
				list_Insert = true;
				list_ItemIndex = 0;
				Grid.Visible = true;
			}
			else Page_Alert = helper;
		}

		#endregion

		#region List events

		/// <summary>
		/// Prepare an item for editing and return its key.
		/// </summary>
		/// <returns>Data key for item to edit</returns>
		private string GetDataKey()
		{
			DataGrid grid = Grid;
			int index = grid.EditItemIndex;
			string key = grid.DataKeys[index] as string;
			return key;
		}

		/// <summary>
		/// Harvest a collection of controls from DataGrid
		/// </summary>
		/// <param name="e"></param>
		/// <returns>A control collection for DataGrid</returns>
		public virtual ControlCollection GetControls(DataGridCommandEventArgs e)
		{
			DataGrid grid = Grid;
			ControlCollection controls = new ControlCollection(grid);
			foreach (TableCell t in e.Item.Cells)
			{
				for (int i = 0; i < t.Controls.Count; i++)
					controls.Add(t.Controls[i]);
			}
			return controls;
		}

		// postback events

		/// <summary>
		/// Handle event by presenting selected row in an editable form.
		/// </summary>
		/// <param name="source">Event source</param>
		/// <param name="e">Event parameters</param>
		private void list_Edit(object source, DataGridCommandEventArgs e)
		{
			list_Edit(e.Item.ItemIndex);
		}

		/// <summary>
		/// Handle event by retaining any changes to the selected DataGrid row.
		/// </summary>
		/// <param name="source">Event source</param>
		/// <param name="e">Event parameters</param>
		private void list_Save(object source, DataGridCommandEventArgs e)
		{
			string key = (list_Insert) ? null : GetDataKey();
			ControlCollection controls = GetControls(e);
			IViewHelper helper = Save(key, controls);
			bool okay = helper.IsNominal;
			if (okay)
			{				
				if (View_Save != null) View_Save(this, new ViewArgs(helper));
				list_Insert = false;
				list_ItemIndex = -1;
				okay = Open();
				// ISSUE: Event? Page_Prompt = (List_Insert) ? msg_ADD_SUCCESS : msg_SAVE_SUCCESS;
			}
			if (!okay) Page_Alert = helper;
		}

		
		/// <summary>
		/// Handle event by resetting DataGrid state.
		/// </summary>
		/// <param name="source">Event source</param>
		/// <param name="e">Event parameters</param>
		private void list_Quit(object source, DataGridCommandEventArgs e)
		{
			list_Quit();
		}

		/// <summary>
		/// Handle list add event by inserting a new row, 
		/// and raising a View Add event.
		/// </summary>
		/// <param name="sender">Event source</param>
		/// <param name="e">Event parameters</param>
		protected void list_Add(object sender, EventArgs e)
		{
			list_Add();
			if (View_Add != null) View_Add(sender, e);
		}

		/// <summary>
		/// Handle list item event by opening item or preparing to add new item.
		/// </summary>
		/// <param name="source">Event source</param>
		/// <param name="e">Event parameters</param>
		private void List_Item(object source, DataGridCommandEventArgs e)
		{
			int index = e.Item.ItemIndex;
			list_Item(e.CommandName, index);
		}

		/// <summary>
		/// Provide key to store item limit in criteria.
		/// </summary>
		public const string ITEM_LIMIT = "item_limit";
		
		/// <summary>
		/// Provide key to store item offset in criteria.
		/// </summary>
		public const string ITEM_OFFSET = "item_offset";
		
		/// <summary>
		/// Provide key to store item count in criteria.
		/// </summary>
		public const string ITEM_COUNT = "item_count";

		/// <summary>
		/// Provide key to store item page in criteria.
		/// </summary>
		public const string ITEM_PAGE = "item_page";

		/// <summary>
		/// Provide key to store item key in criteria.
		/// </summary>
		public const string ITEM_KEY = "item_key";
		
		#endregion

		#region ListPageIndexChanged 

		/// <summary>
		/// Signal that the Grid page index has changed, 
		/// and provide values for a page index hint.
		/// </summary>
		/// 
		public event EventHandler ListPageIndexChanged;

		/// <summary>
		/// Provide a default key for message resources that set the hint label.
		/// </summary>
		/// 
		public const string PAGE_INDEX_HINT = "page_index_hint";

		/// <summary>
		/// Provide a default key for the "Not Found" hint.
		/// </summary>
		/// 
		public const string NOT_FOUND_HINT = "not_found_hint";

		/// <summary>
		/// Provide values for a page index message (items x thru x of x).
		/// </summary>
		/// 
		public class ListPageIndexChangedArgs : EventArgs
		{
			public int ItemFrom;
			public int ItemThru;
			public int ItemCount;
		}

		/// <summary>
		/// Optional extension point so that subclasses can make adjustments 
		/// based on whether there are items to display or not. 
		/// </summary>
		/// <remarks><p>
		/// The classic use case for this method is to turn off the Grid 
		/// if there are not any items to display in the Grid. 
		/// In this case, if this control is used more than once in an enclosing 
		/// page or control, then the Grid should be toggled on or off for 
		/// each instance (Visible = isItems);
		/// </p></remarks>
		/// <param name="isItems">True if there are 1 or more items to display</param>
		public virtual void ListPageIndexChanged_IsItems(bool isItems)
		{
			// Override to provide functionalilty	
		}
		
		/// <summary>
		/// Lookup the PAGE_INDEX_HINT or the NOT_FOUND_HINT in the application 
		/// message resources, and return as a formatted string. 
		/// </summary>
		/// <param name="args">Our ListPageIndexChangedArgs with the page index values</param>
		/// <returns>Formatted message string ready to markup and present</returns>
		/// 
		public virtual string ListPageIndexChanged_Message(ListPageIndexChangedArgs args)
		{
			bool isItems = (args.ItemCount > 0);
			ListPageIndexChanged_IsItems(isItems);

			string[] m_args = new string[3];
			m_args[0] = Convert.ToString(args.ItemFrom);
			m_args[1] = Convert.ToString(args.ItemThru);
			m_args[2] = Convert.ToString(args.ItemCount);

			string text = isItems ? GetMessage(PAGE_INDEX_HINT, m_args) : GetMessage(NOT_FOUND_HINT);
			return text;
		}

		/// <summary>
		/// Raise the ListPageIndexChanged event.  
		/// </summary>
		/// <param name="sender">Event source</param>
		/// <param name="page">Current page number</param>
		/// <param name="size">Items per page</param>
		/// <param name="count">Total number of items</param>
		/// 
		private void ListPageIndexChanged_Raise(object sender, int page, int size, int count)
		{
			if (ListPageIndexChanged != null)
			{
				int from = (page*size) + 1;
				int thru = (page*size) + size;
				if (thru > count) thru = count;
				ListPageIndexChangedArgs a = new ListPageIndexChangedArgs();
				a.ItemFrom = from;
				a.ItemThru = thru;
				a.ItemCount = count;
				ListPageIndexChanged(sender, a);
			}
		}

		/// <summary>
		/// Handle the PageIndexChanged raised by our DataGrid.
		/// </summary>
		/// <param name="sender">Event source</param>
		/// <param name="e">Runtime arguements</param>
		/// 
		private void list_PageIndexChanged(object sender, DataGridPageChangedEventArgs e)
		{
			DataGrid grid = Grid;
			int count = (grid.DataSource as IList).Count;

			if (grid.AllowCustomPaging)
			{
				IDictionary criteria = list_Criteria_NewPageIndex(e.NewPageIndex);
				IViewHelper helper = GetHelperFor(ListCommand);
				helper.Read(criteria, true);
				helper.Execute();
				DataSource(helper);
				count = GetItemCount(helper);
			}
			grid.CurrentPageIndex = e.NewPageIndex;

			ListPageIndexChanged_Raise(sender, e.NewPageIndex, grid.PageSize, count);
			list_Refresh();
		}


		#endregion

		/// <summary>
		/// Signal when an item is being added.
		/// </summary>
		/// 
		public event EventHandler View_Add;

		/// <summary>
		/// Handle click event by raising a View Add event 
		/// and passing the list criteria.
		/// </summary>
		/// <param name="sender">Event source</param>
		/// <param name="e">Runtime arguments</param>
		protected void add_Click(object sender, EventArgs e)
		{
			if (View_Add != null)
			{
				SetItemKeyValue(list_Criteria, null);
				FindArgs f = new FindArgs(e, list_Criteria);
				View_Add(sender, f);
			}
		}

		/// <summary>
		/// Provide an internal extension point for handling a selected item.
		/// </summary>
		/// <param name="index">Page index of item being selected</param>
		protected virtual void list_Item_Click(int index)
		{
			// Override to provide implementation			
		}

		/// <summary>
		/// Signal when an item is being saved.
		/// </summary>
		public event EventHandler View_Save;

		/// <summary>
		/// Reset state for this control, including any ViewState attributes
		/// and the page indexes (@see(list_ResetIndex)), 
		/// usually on a new Open event or on a Quit event,
		/// </summary>
		public override void Page_Reset()
		{
			list_ResetIndex();
			base.Page_Reset();
		}

		/// <summary>
		/// Handle the page's Load event.
		/// </summary>
		/// <param name="sender">Event source</param>
		/// <param name="e">Runtime arguments</param>
		private void Page_Load(object sender, EventArgs e)
		{
			DataGrid grid = Grid;
			grid.AutoGenerateColumns = false;
			grid.EditItemIndex = list_ItemIndex;
			grid.CancelCommand += new DataGridCommandEventHandler(list_Quit);
			grid.EditCommand += new DataGridCommandEventHandler(list_Edit);
			grid.UpdateCommand += new DataGridCommandEventHandler(list_Save);
			grid.ItemCommand += new DataGridCommandEventHandler(List_Item);
			grid.PageIndexChanged += new DataGridPageChangedEventHandler(list_PageIndexChanged);
			if (Visible) Open();
		}

		#region Web Form Designer generated code

		/// <summary>
		///		Initialize components.
		/// </summary>
		/// <param name="e">Runtime parameters</param>
		/// 
		protected override void OnInit(EventArgs e)
		{
			//
			// CODEGEN: This call is required by the ASP.NET Web Form Designer.
			//
			InitializeComponent();
			base.OnInit(e);
			InitGrid();
		}

		/// <summary>
		///		Required method for Designer support - do not modify
		///		the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
			this.Load += new EventHandler(this.Page_Load);
		}

		#endregion

		#region Templates

		/// <summary>
		/// Describe the fields needed to program a DataGrid column.
		/// </summary>
		public interface IGridConfig
		{
			string DataField { get; }
			string HeaderText { get; }
			ITemplate ItemTemplate { get; set; }
			ITemplate EditItemTemplate { get; set; }
			bool HasTemplate { get; }
		}

		/// <summary>
		/// Implement IGridConfig.
		/// </summary>
		public class GridConfig : IGridConfig
		{
			/// <summary>
			/// Store attribute name for column (required).
			/// </summary>
			private string _DataField;

			/// <summary>
			/// Provide attribute name for column (required).
			/// </summary>
			public string DataField
			{
				get { return _DataField; }
			}

			/// <summary>
			/// Store heading for this column (optional).
			/// </summary>
			private string _HeaderText;

			/// <summary>
			/// Provide heading for this column (optional).
			/// </summary>
			public string HeaderText
			{
				get
				{
					if (_HeaderText == null) return DataField;
					return _HeaderText;
				}
			}

			/// <summary>
			/// Store item template for this column (optional).
			/// </summary>
			private ITemplate _ItemTemplate;

			/// <summary>
			/// Provide item template for this column (optional).
			/// </summary>
			public ITemplate ItemTemplate
			{
				get { return _ItemTemplate; }
				set { _ItemTemplate = value; }
			}

			/// <summary>
			/// Store edit template for this column (optional).
			/// </summary>
			private ITemplate _EditItemTemplate;

			/// <summary>
			/// Provide edit template for this column (optional).
			/// </summary>
			public ITemplate EditItemTemplate
			{
				get { return _EditItemTemplate; }
				set { _EditItemTemplate = value; }
			}

			// string DataFormat;
			// string SortFormat;
			// ITemplate ItemFormat;

			/// <summary>
			/// Store whether attribute has a template. 
			/// </summary>
			public bool HasTemplate
			{
				get { return (_ItemTemplate != null) || (_EditItemTemplate != null); }
			}

			/// <summary>
			/// Construct a GridConfig from a data field and header test.
			/// </summary>
			/// <param name="dataField">The attribute name for this column</param>
			/// <param name="headerText">The header text for this column</param>
			public GridConfig(string dataField, string headerText)
			{
				_DataField = dataField;
				_HeaderText = headerText;
			}

			/// <summary>
			/// Construct a GridConfig using all attributes.
			/// </summary>
			/// <param name="dataField">The attribute name for this column</param>
			/// <param name="headerText">The header text for this column</param>
			/// <param name="itemTemplate">The item template for this column</param>
			/// <param name="editItemTemplate">The edit template for this column</param>
			public GridConfig(string dataField, string headerText, ITemplate itemTemplate, ITemplate editItemTemplate)
			{
				_DataField = dataField;
				_HeaderText = headerText;
				_ItemTemplate = itemTemplate;
				_EditItemTemplate = editItemTemplate;
			}
		}

		/// <summary>
		/// Add literal text to a DataGrid column.
		/// </summary>
		public class LiteralTemplate : ITemplate
		{
			
			/// <summary>
			/// Store attribute name.
			/// </summary>
			private string _DataField;

			/// <summary>
			/// Handle data binding event by setting control text to data field.
			/// </summary>
			/// <param name="sender"></param>
			/// <param name="e"></param>
			private void OnDataBinding(object sender, EventArgs e)
			{
				Literal control;
				control = (Literal) sender;
				DataGridItem container = (DataGridItem) control.NamingContainer;
				control.Text = DataBinder.Eval(container.DataItem, _DataField) as string;
			}

			public void InstantiateIn(Control container)
			{
				Literal control = new Literal();
				control.ID = _DataField;
				control.DataBinding += new EventHandler(OnDataBinding);
				container.Controls.Add(control);
			}

			/// <summary>
			/// Construct instance from attribute name.
			/// </summary>
			/// <param name="dataField">Attribute name</param>
			public LiteralTemplate(string dataField)
			{
				_DataField = dataField;
			}
		}

		/// <summary>
		/// Configure a DataGrid column to display the selected value on the KeyValue list.
		/// </summary>
		public class KeyValueTemplate : ITemplate
		{
			private string _DataField;
			private IKeyValueList _Control;

			/// <summary>
			/// Handle data binding events by extracting key and value, 
			/// and setting selected value to control text.
			/// </summary>
			/// <param name="sender">Event source</param>
			/// <param name="e">Runtime arguments</param>
			private void OnDataBinding(object sender, EventArgs e)
			{
				Literal control;
				control = (Literal) sender;
				DataGridItem container = (DataGridItem) control.NamingContainer;
				string key = DataBinder.Eval(container.DataItem, _DataField) as string;
				control.Text = _Control.ValueFor(key);
			}

			public void InstantiateIn(Control container)
			{
				Literal control = new Literal();
				control.ID = _DataField;
				control.DataBinding += new EventHandler(OnDataBinding);
				container.Controls.Add(control);
			}

			/// <summary>
			/// Construct instance from a datafield and the list.
			/// </summary>
			/// <param name="dataField">Attribute name</param>
			/// <param name="list">List of keyValue items</param>
			public KeyValueTemplate(string dataField, IKeyValueList list)
			{
				_DataField = dataField;
				_Control = list;				
			}	
		}

		/// <summary>
		/// Present a drop down list control when editing a column.
		/// </summary>
		public class DropDownListTemplate : ITemplate
		{
			/// <summary>
			/// Store attribute name.
			/// </summary>
			private string _DataField;
			
			/// <summary>
			/// Store reference to the DropDownList control.
			/// </summary>
			private DropDownList _Control;

			/// <summary>
			/// Scan list for an item matching value.
			/// </summary>
			/// <param name="control">The control to scan</param>
			/// <param name="value">The value to match</param>
			private void SelectItem(ListControl control, string value)
			{
				if (value != null)
				{
					int index = 0;
					foreach (ListItem i in control.Items)
					{
						if (value.Equals(i.Value))
						{
							control.SelectedIndex = index;
							continue;
						}
						index++;
					}
				}
			}

			/// <summary>
			/// Handle a data binding event by selecting the key row.
			/// </summary>
			/// <param name="sender"></param>
			/// <param name="e"></param>
			private void OnDataBinding(object sender, EventArgs e)
			{
				DropDownList control;
				control = (DropDownList) sender;
				DataGridItem container = (DataGridItem) control.NamingContainer;
				string key = DataBinder.Eval(container.DataItem, _DataField) as string;
				SelectItem(control, key);
				_SelectedIndex = control.SelectedIndex; // FIXME: [OVR-24]
			}

			/// <summary>
			/// Cache the selected index for OnPreRender.
			/// </summary>
			private int _SelectedIndex;

			/// <summary>
			/// Provide a kludge method to set Selected Index.
			/// </summary>
			/// <remarks><p>
			/// After setting the selected index on DataBinding, 
			/// it is somehow being reset to 0 before prerender. 
			/// This method restores the selected index st by 
			/// OnDataBinding. 
			/// </p></remarks>
			/// <param name="sender">Event source</param>
			/// <param name="e">Runtime parameters</param>
			private void OnPreRender(object sender, EventArgs e)
			{
				DropDownList control;
				control = (DropDownList) sender;
				control.SelectedIndex = _SelectedIndex;
			}

			public void InstantiateIn(Control container)
			{
				container.Controls.Add(_Control);
			}

			/// <summary>
			/// Construct a DropDownListTempate from an id and datasource. 
			/// </summary>
			/// <param name="id">Data Field Name</param>
			public DropDownListTemplate(string id, object dataSource)
			{
				_DataField = id;
				_Control = new DropDownList();
				_Control.ID = id;
				_Control.DataSource = dataSource;
				_Control.DataBind();
				_Control.DataBinding += new EventHandler(OnDataBinding);
				_Control.PreRender += new EventHandler(OnPreRender);
			}

			/// <summary>
			/// Construct a DropDownListTempate from an id and list. 
			/// </summary>
			/// <param name="id">Data Field Name</param>
			/// <param name="list">Items to list</param>
			public DropDownListTemplate(string id, IKeyValueList list) : this(id,list,false)
			{}

			/// <summary>
			/// Construct a DropDownListTempate from id, list, insertNullKey.
			/// </summary>
			/// <param name="id">Data Field Name</param>
			/// <param name="list">Items to list</param>
			/// <param name="insertNullKey">Whether to prepend a -v- item to the list</param>
			public DropDownListTemplate(string id, IKeyValueList list, bool insertNullKey)
			{
				if (insertNullKey) 
				{
					lock(list)
					{
						IKeyValue e = list[0] as KeyValue;
						if (!NULL_TOKEN.Equals(e.Text))
						{								
							list.Insert(0, new KeyValue(String.Empty, NULL_TOKEN));						
						}
					}
				}					

				_DataField = id;
				_Control = new DropDownList();
				_Control.ID = id;
				_Control.DataSource = list;
				_Control.DataTextField = "value";
				_Control.DataValueField = "key";
				_Control.DataBind();
				_Control.DataBinding += new EventHandler(OnDataBinding);
				_Control.PreRender += new EventHandler(OnPreRender);
			}
		}

		#endregion
	}

	/* 

	
	#region List Panel

		protected Panel pnlList;
		protected DataGridControl list_report;
		// from BaseGrid: Button cmdListAdd;

		private void List_Init()
		{
			list_report.Helper = this.Helper;
			list_report.List_Init();
			pnlList.Visible = false;
		}

		/// <summary>
		/// Select only those items in control 
		/// whose Value property matches the given value.
		/// If the value is null, no action is taken.
		/// </summary>
		/// <param name="control">ListControl to process</param>
		/// <param name="text">Text label to match</param>
		/// 
		static void SelectItemText (ListControl control, string text)
		{
			if (text != null)
			{
				foreach (ListItem i in control.Items)
					i.Selected = false;

				foreach (ListItem i in control.Items)
				{
					if (text.Equals (i.Text))
						i.Selected = true;
				}
			}
		}

		private void List_Edit_Submit(IDictionary context)
		{									
			Helper.BindControls(pnlEdit.Controls,context,null);
			string county_name = context[App.COUNTY_NAME] as string;
			SelectItemText(county_key_list,county_name);
			Template_Load (App.msg_ROUTING_HEADING, App.msg_ROUTING_EDIT_PROMPT);
			pnlEdit.Visible = true;
			pnlFind.Visible = false;
			pnlList.Visible = false;			
		}

	#endregion	
	
	
	
	 */
}