FormView.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / FormView.cs / 1305376 / FormView.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.Collections; 
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Drawing; 
    using System.Drawing.Design;
    using System.Globalization; 
    using System.Web.UI.WebControls.Adapters; 
    using System.Web.Util;
 
    /// 
    ///    
    ///       Displays a data record from a data source in a table layout. The data source
    ///       is any object that implements IEnumerable or IListSource, which includes ADO.NET data, 
    ///       arrays, ArrayLists, DataSourceControl, etc.
    ///     
    ///  
    [
    Designer("System.Web.UI.Design.WebControls.FormViewDesigner, " + AssemblyRef.SystemDesign), 
    ControlValueProperty("SelectedValue"),
    DefaultEvent("PageIndexChanging"),
    SupportsEventValidation
    ] 
    [DataKeyProperty("DataKey")]
    public class FormView : CompositeDataBoundControl, IDataItemContainer, IPostBackEventHandler, 
                            IPostBackContainer, IDataBoundItemControl, IRenderOuterTableControl { 

        private static readonly object EventPageIndexChanged = new object(); 
        private static readonly object EventPageIndexChanging = new object();
        private static readonly object EventItemCommand = new object();
        private static readonly object EventItemCreated = new object();
        private static readonly object EventItemDeleted = new object(); 
        private static readonly object EventItemDeleting = new object();
        private static readonly object EventItemInserting = new object(); 
        private static readonly object EventItemInserted = new object(); 
        private static readonly object EventItemUpdating = new object();
        private static readonly object EventItemUpdated = new object(); 
        private static readonly object EventModeChanged = new object();
        private static readonly object EventModeChanging = new object();

        private ITemplate _itemTemplate; 
        private ITemplate _editItemTemplate;
        private ITemplate _insertItemTemplate; 
        private ITemplate _headerTemplate; 
        private ITemplate _footerTemplate;
        private ITemplate _pagerTemplate; 
        private ITemplate _emptyDataTemplate;

        private TableItemStyle _rowStyle;
        private TableItemStyle _headerStyle; 
        private TableItemStyle _footerStyle;
        private TableItemStyle _editRowStyle; 
        private TableItemStyle _insertRowStyle; 
        private TableItemStyle _emptyDataRowStyle;
 
        private FormViewRow _bottomPagerRow;
        private FormViewRow _footerRow;
        private FormViewRow _headerRow;
        private FormViewRow _topPagerRow; 
        private FormViewRow _row;
 
        private TableItemStyle _pagerStyle; 
        private PagerSettings _pagerSettings;
 
        private int _pageCount;
        private object _dataItem;
        private int _dataItemIndex;
        private OrderedDictionary _boundFieldValues; 
        private DataKey _dataKey;
        private OrderedDictionary _keyTable; 
        private string[] _dataKeyNames; 

        private int _pageIndex; 
        private FormViewMode _defaultMode = FormViewMode.ReadOnly;
        private FormViewMode _mode;
        private bool _modeSet;
        private bool _useServerPaging; 
        private string _modelValidationGroup;
 
        private IOrderedDictionary _deleteKeys; 
        private IOrderedDictionary _deleteValues;
        private IOrderedDictionary _insertValues; 
        private IOrderedDictionary _updateKeys;
        private IOrderedDictionary _updateOldValues;
        private IOrderedDictionary _updateNewValues;
 

 
        ///  
        /// Gets or sets a value that indicates whether paging is allowed.
        ///  
        [
        WebCategory("Paging"),
        DefaultValue(false),
        WebSysDescription(SR.FormView_AllowPaging) 
        ]
        public virtual bool AllowPaging { 
            get { 
                object o = ViewState["AllowPaging"];
                if (o != null) 
                    return (bool)o;
                return false;
            }
            set { 
                bool oldValue = AllowPaging;
                if (value != oldValue) { 
                    ViewState["AllowPaging"] = value; 
                    if (Initialized) {
                        RequiresDataBinding = true; 
                    }
                }
            }
        } 

        ///  
        /// Gets or sets the URL of an image to display in the 
        /// background of the .
        ///  
        [
        WebCategory("Appearance"),
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)), 
        UrlProperty(),
        WebSysDescription(SR.WebControl_BackImageUrl) 
        ] 
        public virtual string BackImageUrl {
            get { 
                if (ControlStyleCreated == false) {
                    return String.Empty;
                }
                return ((TableStyle)ControlStyle).BackImageUrl; 
            }
            set { 
                ((TableStyle)ControlStyle).BackImageUrl = value; 
            }
        } 


        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ] 
        public virtual FormViewRow BottomPagerRow { 
            get {
                if (_bottomPagerRow == null) { 
                    EnsureChildControls();
                }
                return _bottomPagerRow;
            } 
        }
 
        private IOrderedDictionary BoundFieldValues { 
            get {
                if (_boundFieldValues == null) { 
                    int capacity = 25;
                    _boundFieldValues = new OrderedDictionary(capacity);
                }
                return _boundFieldValues; 
            }
        } 
 

        [ 
        Localizable(true),
        DefaultValue(""),
        WebCategory("Accessibility"),
        WebSysDescription(SR.DataControls_Caption) 
        ]
        public virtual string Caption { 
            get { 
                string s = (string)ViewState["Caption"];
                return (s != null) ? s : String.Empty; 
            }
            set {
                ViewState["Caption"] = value;
            } 
        }
 
 
        [
        DefaultValue(TableCaptionAlign.NotSet), 
        WebCategory("Accessibility"),
        WebSysDescription(SR.WebControl_CaptionAlign)
        ]
        public virtual TableCaptionAlign CaptionAlign { 
            get {
                object o = ViewState["CaptionAlign"]; 
                return (o != null) ? (TableCaptionAlign)o : TableCaptionAlign.NotSet; 
            }
            set { 
                if ((value < TableCaptionAlign.NotSet) ||
                    (value > TableCaptionAlign.Right)) {
                    throw new ArgumentOutOfRangeException("value");
                } 
                ViewState["CaptionAlign"] = value;
            } 
        } 

 

        /// 
        /// Indicates the amount of space between cells.
        ///  
        [
        WebCategory("Layout"), 
        DefaultValue(-1), 
        WebSysDescription(SR.FormView_CellPadding)
        ] 
        public virtual int CellPadding {
            get {
                if (ControlStyleCreated == false) {
                    return -1; 
                }
                return ((TableStyle)ControlStyle).CellPadding; 
            } 
            set {
                ((TableStyle)ControlStyle).CellPadding = value; 
            }
        }

 
        /// 
        /// Gets or sets the amount of space between the contents of 
        /// a cell and the cell's border. 
        /// 
        [ 
        WebCategory("Layout"),
        DefaultValue(0),
        WebSysDescription(SR.FormView_CellSpacing)
        ] 
        public virtual int CellSpacing {
            get { 
                if (ControlStyleCreated == false) { 
                    return 0;
                } 
                return ((TableStyle)ControlStyle).CellSpacing;
            }
            set {
                ((TableStyle)ControlStyle).CellSpacing = value; 
            }
        } 
 

        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public FormViewMode CurrentMode { 
            get {
                return Mode; 
            } 
        }
 
        // implement this publicly so DataBinder.Eval(container.DataItem, "x") still works.
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public virtual object DataItem { 
            get { 
                if (CurrentMode == FormViewMode.Insert) {
                    return null; 
                }
                return _dataItem;
            }
        } 

        [ 
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ] 
        public int DataItemCount {
            get {
                return PageCount;
            } 
        }
 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public virtual int DataItemIndex {
            get {
                if (CurrentMode == FormViewMode.Insert) { 
                    return -1;
                } 
                return _dataItemIndex; 
            }
        } 


        [
        DefaultValue(null), 
        Editor("System.Web.UI.Design.WebControls.DataFieldEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        TypeConverterAttribute(typeof(StringArrayConverter)), 
        WebCategory("Data"), 
        WebSysDescription(SR.DataControls_DataKeyNames)
        ] 
        public virtual string[] DataKeyNames {
            get {
                object o = _dataKeyNames;
                if (o != null) { 
                    return (string[])((string[])o).Clone();
                } 
                return new string[0]; 
            }
            set { 
                if (!DataBoundControlHelper.CompareStringArrays(value, DataKeyNamesInternal)) {
                    if (value != null) {
                        _dataKeyNames = (string[])value.Clone();
                    } else { 
                        _dataKeyNames = null;
                    } 
 
                    _keyTable = null;
                    if (Initialized) { 
                        RequiresDataBinding = true;
                    }
                }
            } 
        }
 
        // This version doesn't clone the array 
        private string[] DataKeyNamesInternal {
            get { 
                object o = _dataKeyNames;
                if (o != null) {
                    return (string[])o;
                } 
                return new string[0];
            } 
        } 

 
        /// 
        /// 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.FormView_DataKey) 
        ] 
        public virtual DataKey DataKey {
            get { 
                if (_dataKey == null) {
                    _dataKey = new DataKey(KeyTable);
                }
                return _dataKey; 
            }
        } 
 

        [ 
        WebCategory("Behavior"),
        DefaultValue(FormViewMode.ReadOnly),
        WebSysDescription(SR.View_DefaultMode)
        ] 
        public virtual FormViewMode DefaultMode {
            get { 
                return _defaultMode; 
            }
            set { 
                if (value < FormViewMode.ReadOnly || value > FormViewMode.Insert) {
                    throw new ArgumentOutOfRangeException("value");
                }
                _defaultMode = value; 
            }
        } 
 

        ///  
        /// Indicates the template to use for an item set in edit mode within the FormView.
        /// This template is also used for Insert if no InsertItemTemplate is defined.
        /// 
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
        WebSysDescription(SR.FormView_EditItemTemplate) 
        ]
        public virtual ITemplate EditItemTemplate {
            get {
                return _editItemTemplate; 
            }
            set { 
                _editItemTemplate = value; 
            }
        } 


        /// 
        /// Indicates the style properties of each row when in edit mode. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.View_EditRowStyle)
        ] 
        public TableItemStyle EditRowStyle {
            get { 
                if (_editRowStyle == null) { 
                    _editRowStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)_editRowStyle).TrackViewState();
                }
                return _editRowStyle;
            } 
        }
 
 
        /// 
        /// Indicates the style properties of null rows. 
        /// 
        [
        WebCategory("Styles"),
        DefaultValue(null), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.View_EmptyDataRowStyle)
        ] 
        public TableItemStyle EmptyDataRowStyle {
            get {
                if (_emptyDataRowStyle == null) {
                    _emptyDataRowStyle = new TableItemStyle(); 
                    if (IsTrackingViewState)
                        ((IStateManager)_emptyDataRowStyle).TrackViewState(); 
                } 
                return _emptyDataRowStyle;
            } 
        }


        ///  
        /// Indicates the template to use when no records are returned from the datasource within the FormView.
        ///  
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)),
        WebSysDescription(SR.View_EmptyDataTemplate)
        ] 
        public virtual ITemplate EmptyDataTemplate {
            get { 
                return _emptyDataTemplate; 
            }
            set { 
                _emptyDataTemplate = value;
            }
        }
 

        ///  
        /// The header text displayed if no EmptyDataTemplate is defined. 
        /// 
        [ 
        Localizable(true),
        WebCategory("Appearance"),
        DefaultValue(""),
        WebSysDescription(SR.View_EmptyDataText), 
        ]
        public virtual String EmptyDataText { 
            get { 
                object o = ViewState["EmptyDataText"];
                if (o != null) { 
                    return (string)o;
                }
                return String.Empty;
            } 
            set {
                ViewState["EmptyDataText"] = value; 
            } 
        }
 
        [
        WebCategory("Behavior"),
        DefaultValue(true),
        WebSysDescription(SR.DataBoundControl_EnableModelValidation) 
        ]
        public virtual bool EnableModelValidation { 
            get { 
                object o = ViewState["EnableModelValidation"];
                if (o != null) { 
                    return (bool)o;
                }
                return true;
            } 
            set {
                ViewState["EnableModelValidation"] = value; 
            } 
        }
 
        [
        WebCategory("Layout"),
        DefaultValue(true),
        WebSysDescription(SR.FormView_RenderOuterTable), 
        SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
            Justification = "Interface denotes existence of property, not used for security.") 
        ] 
        public virtual bool RenderOuterTable {
            get { 
                object o = ViewState["RenderOuterTable"];
                return (o != null) ? (bool)o : true;
            }
            set { 
                ViewState["RenderOuterTable"] = value;
            } 
        } 

        private int FirstDisplayedPageIndex { 
            get {
                object o = ViewState["FirstDisplayedPageIndex"];
                if (o != null) {
                    return (int)o; 
                }
                return -1; 
            } 
            set {
                ViewState["FirstDisplayedPageIndex"] = value; 
            }
        }

 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        ]
        public virtual FormViewRow FooterRow { 
            get {
                if (_footerRow == null) {
                    EnsureChildControls();
                } 
                return _footerRow;
            } 
        } 

 
        /// 
        /// Indicates the style properties of the footer row.
        /// 
        [ 
        WebCategory("Styles"),
        DefaultValue(null), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.FormView_FooterStyle)
        ]
        public TableItemStyle FooterStyle {
            get { 
                if (_footerStyle == null) {
                    _footerStyle = new TableItemStyle(); 
                    if (IsTrackingViewState) 
                        ((IStateManager)_footerStyle).TrackViewState();
                } 
                return _footerStyle;
            }
        }
 

        ///  
        /// Indicates the template to use for a footer item within the FormView. 
        /// 
        [ 
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)), 
        WebSysDescription(SR.FormView_FooterTemplate)
        ] 
        public virtual ITemplate FooterTemplate { 
            get {
                return _footerTemplate; 
            }
            set {
                _footerTemplate = value;
            } 
        }
 
 
        /// 
        /// The header text displayed if no FooterTemplate is defined. 
        /// 
        [
        Localizable(true),
        WebCategory("Appearance"), 
        DefaultValue(""),
        WebSysDescription(SR.View_FooterText), 
        ] 
        public virtual String FooterText {
            get { 
                object o = ViewState["FooterText"];
                if (o != null) {
                    return (string)o;
                } 
                return String.Empty;
            } 
            set { 
                ViewState["FooterText"] = value;
            } 
        }


        ///  
        /// Gets or sets a value that specifies the grid line style.
        ///  
        [ 
        WebCategory("Appearance"),
        DefaultValue(GridLines.None), 
        WebSysDescription(SR.DataControls_GridLines)
        ]
        public virtual GridLines GridLines {
            get { 
                if (ControlStyleCreated == false) {
                    return GridLines.None; 
                } 
                return ((TableStyle)ControlStyle).GridLines;
            } 
            set {
                ((TableStyle)ControlStyle).GridLines = value;
            }
        } 

 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        ]
        public virtual FormViewRow HeaderRow {
            get {
                if (_headerRow == null) { 
                    EnsureChildControls();
                } 
                return _headerRow; 
            }
        } 


        /// 
        /// Indicates the style properties of the header row. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.WebControl_HeaderStyle)
        ] 
        public TableItemStyle HeaderStyle {
            get { 
                if (_headerStyle == null) { 
                    _headerStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)_headerStyle).TrackViewState();
                }
                return _headerStyle;
            } 
        }
 
 
        /// 
        /// Indicates the template to use for a header item within the FormView. 
        /// 
        [
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)), 
        WebSysDescription(SR.WebControl_HeaderTemplate) 
        ]
        public virtual ITemplate HeaderTemplate { 
            get {
                return _headerTemplate;
            }
            set { 
                _headerTemplate = value;
            } 
        } 

 
        /// 
        /// The header text displayed if no HeaderTemplate is defined.
        /// 
        [ 
        Localizable(true),
        WebCategory("Appearance"), 
        DefaultValue(""), 
        WebSysDescription(SR.View_HeaderText),
        ] 
        public virtual String HeaderText {
            get {
                object o = ViewState["HeaderText"];
                if (o != null) { 
                    return (string)o;
                } 
                return String.Empty; 
            }
            set { 
                ViewState["HeaderText"] = value;
            }
        }
 

        ///  
        /// Gets or sets a value that specifies the alignment of a rows with respect 
        /// surrounding text.
        ///  
        [
        Category("Layout"),
        DefaultValue(HorizontalAlign.NotSet),
        WebSysDescription(SR.WebControl_HorizontalAlign) 
        ]
        public virtual HorizontalAlign HorizontalAlign { 
            get { 
                if (ControlStyleCreated == false) {
                    return HorizontalAlign.NotSet; 
                }
                return ((TableStyle)ControlStyle).HorizontalAlign;
            }
            set { 
                ((TableStyle)ControlStyle).HorizontalAlign = value;
            } 
        } 

 
        /// 
        /// Indicates the template to use for an item set in insert mode within the FormView.
        /// 
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
        WebSysDescription(SR.FormView_InsertItemTemplate) 
        ]
        public virtual ITemplate InsertItemTemplate {
            get {
                return _insertItemTemplate; 
            }
            set { 
                _insertItemTemplate = value; 
            }
        } 


        /// 
        /// Indicates the style properties of each row when in insert mode. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.View_InsertRowStyle)
        ] 
        public TableItemStyle InsertRowStyle {
            get { 
                if (_insertRowStyle == null) { 
                    _insertRowStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)_insertRowStyle).TrackViewState();
                }
                return _insertRowStyle;
            } 
        }
 
 
        /// 
        /// Indicates the template to use for an item within the FormView. 
        /// 
        [
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView), BindingDirection.TwoWay), 
        WebSysDescription(SR.View_InsertRowStyle) 
        ]
        public virtual ITemplate ItemTemplate { 
            get {
                return _itemTemplate;
            }
            set { 
                _itemTemplate = value;
            } 
        } 

        private OrderedDictionary KeyTable { 
            get {
                if (_keyTable == null) {
                    _keyTable = new OrderedDictionary(DataKeyNamesInternal.Length);
                } 
                return _keyTable;
            } 
        } 

 
        private FormViewMode Mode {
            get {
                // if the mode wasn't explicitly set by LoadControlState or by the user, the mode is the DefaultMode.
                if (!_modeSet || DesignMode) { 
                    _mode = DefaultMode;
                    _modeSet = true; 
                } 
                return _mode;
            } 
            set {
                if (value < FormViewMode.ReadOnly || value > FormViewMode.Insert) {
                    throw new ArgumentOutOfRangeException("value");
                } 

                _modeSet = true; 
                if (_mode != value) { 
                    _mode = value;
                    if (Initialized) { 
                        RequiresDataBinding = true;
                    }
                }
            } 
        }
 
 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual int PageCount {
            get { 
                return _pageCount;
            } 
        } 

        ///  
        ///    Gets or sets the index of the currently displayed record.
        ///     This property echos the public one so that we can set PageIndex to -1
        ///     internally when we switch to insert mode, but users should never do that.
        ///  
        private int PageIndexInternal {
            get { 
                return _pageIndex; 
            }
            set { 
                int currentPageIndex = PageIndexInternal;
                if (value != currentPageIndex) {
                    _pageIndex = value;
                    if (Initialized) { 
                        RequiresDataBinding = true;
                    } 
                } 
            }
        } 


        /// 
        /// Gets or sets the index of the currently displayed record. 
        /// 
        [ 
        Bindable(true), 
        DefaultValue(0),
        WebCategory("Data"), 
        WebSysDescription(SR.FormView_PageIndex)
        ]
        public virtual int PageIndex {
            get { 
                // if we're in design mode, we don't want a change to the mode to set the PageIndex to -1.
                if (Mode == FormViewMode.Insert && !DesignMode) { 
                    return -1; 
                }
                return PageIndexInternal; 
            }
            set {
                // since we don't know at property set time how many DataItems we'll have,
                // don't throw if we're above PageCount 
                if (value < -1) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                if (value >= 0) {
                    PageIndexInternal = value; 
                }
            }
        }
 

        ///  
        /// Gets the settings of the pager buttons for the 
        /// . This
        /// property is read-only. 
        /// 
        [
        WebCategory("Paging"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.GridView_PagerSettings) 
        ]
        public virtual PagerSettings PagerSettings { 
            get {
                if (_pagerSettings == null) {
                    _pagerSettings = new PagerSettings();
                    if (IsTrackingViewState) { 
                        ((IStateManager)_pagerSettings).TrackViewState();
                    } 
                    _pagerSettings.PropertyChanged += new EventHandler(OnPagerPropertyChanged); 
                }
                return _pagerSettings; 
            }
        }

 
        /// 
        /// Gets the style properties of the pager rows for the 
        /// . This 
        /// property is read-only.
        ///  
        [
        WebCategory("Styles"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.WebControl_PagerStyle) 
        ] 
        public TableItemStyle PagerStyle {
            get { 
                if (_pagerStyle == null) {
                    _pagerStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_pagerStyle).TrackViewState(); 
                }
                return _pagerStyle; 
            } 
        }
 

        /// 
        /// Indicates the template to use for a pager item within the FormView.
        ///  
        [
        Browsable(false), 
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)), 
        WebSysDescription(SR.View_PagerTemplate)
        ]
        public virtual ITemplate PagerTemplate {
            get { 
                return _pagerTemplate;
            } 
            set { 
                _pagerTemplate = value;
            } 
        }


        ///  
        /// Gets a collection of  objects representing the individual
        /// rows within the control. 
        /// This property is read-only. 
        /// 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.FormView_Rows)
        ] 
        public virtual FormViewRow Row {
            get { 
                if (_row == null) { 
                    EnsureChildControls();
                } 
                return _row;
            }
        }
 

        ///  
        /// Indicates the style properties of each row. 
        /// 
        [ 
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.View_RowStyle) 
        ] 
        public TableItemStyle RowStyle {
            get { 
                if (_rowStyle == null) {
                    _rowStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_rowStyle).TrackViewState(); 
                }
                return _rowStyle; 
            } 
        }
 

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public object SelectedValue { 
            get { 
                return DataKey.Value;
            } 
        }

        protected override HtmlTextWriterTag TagKey {
            get { 
                return HtmlTextWriterTag.Table;
            } 
        } 

 
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ] 
        public virtual FormViewRow TopPagerRow {
            get { 
                if (_topPagerRow == null) { 
                    EnsureChildControls();
                } 
                return _topPagerRow;
            }
        }
 

        ///  
        /// Occurs when the FormView PageIndex has been changed. 
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.FormView_OnPageIndexChanged)
        ]
        public event EventHandler PageIndexChanged { 
            add {
                Events.AddHandler(EventPageIndexChanged, value); 
            } 
            remove {
                Events.RemoveHandler(EventPageIndexChanged, value); 
            }
        }

 
        /// 
        /// Occurs when the FormView PageIndex is changing. 
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.FormView_OnPageIndexChanging)
        ]
        public event FormViewPageEventHandler PageIndexChanging {
            add { 
                Events.AddHandler(EventPageIndexChanging, value);
            } 
            remove { 
                Events.RemoveHandler(EventPageIndexChanging, value);
            } 
        }


        ///  
        /// Occurs when a command is issued from the FormView.
        ///  
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.FormView_OnItemCommand) 
        ]
        public event FormViewCommandEventHandler ItemCommand {
            add {
                Events.AddHandler(EventItemCommand, value); 
            }
            remove { 
                Events.RemoveHandler(EventItemCommand, value); 
            }
        } 


        /// 
        /// Occurs when a row is created. 
        /// 
        [ 
        WebCategory("Behavior"), 
        WebSysDescription(SR.FormView_OnItemCreated)
        ] 
        public event EventHandler ItemCreated {
            add {
                Events.AddHandler(EventItemCreated, value);
            } 
            remove {
                Events.RemoveHandler(EventItemCreated, value); 
            } 
        }
 

        /// 
        /// Occurs when the FormView item has been deleted.
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataControls_OnItemDeleted) 
        ]
        public event FormViewDeletedEventHandler ItemDeleted { 
            add {
                Events.AddHandler(EventItemDeleted, value);
            }
            remove { 
                Events.RemoveHandler(EventItemDeleted, value);
            } 
        } 

 
        /// 
        /// Occurs when the FormView item is being deleted.
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemDeleting) 
        ] 
        public event FormViewDeleteEventHandler ItemDeleting {
            add { 
                Events.AddHandler(EventItemDeleting, value);
            }
            remove {
                Events.RemoveHandler(EventItemDeleting, value); 
            }
        } 
 

        ///  
        /// Occurs when the FormView item has been inserted.
        /// 
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataControls_OnItemInserted)
        ] 
        public event FormViewInsertedEventHandler ItemInserted { 
            add {
                Events.AddHandler(EventItemInserted, value); 
            }
            remove {
                Events.RemoveHandler(EventItemInserted, value);
            } 
        }
 
 
        /// 
        /// Occurs when the FormView item is being inserted. 
        /// 
        [
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemInserting) 
        ]
        public event FormViewInsertEventHandler ItemInserting { 
            add { 
                Events.AddHandler(EventItemInserting, value);
            } 
            remove {
                Events.RemoveHandler(EventItemInserting, value);
            }
        } 

 
        ///  
        /// Occurs when the FormView item has been updated.
        ///  
        [
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemUpdated)
        ] 
        public event FormViewUpdatedEventHandler ItemUpdated {
            add { 
                Events.AddHandler(EventItemUpdated, value); 
            }
            remove { 
                Events.RemoveHandler(EventItemUpdated, value);
            }
        }
 

        ///  
        /// Occurs when the FormView item is being updated. 
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemUpdating)
        ]
        public event FormViewUpdateEventHandler ItemUpdating { 
            add {
                Events.AddHandler(EventItemUpdating, value); 
            } 
            remove {
                Events.RemoveHandler(EventItemUpdating, value); 
            }
        }

 
        /// 
        /// Occurs when the ViewMode has changed. 
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.FormView_OnModeChanged)
        ]
        public event EventHandler ModeChanged {
            add { 
                Events.AddHandler(EventModeChanged, value);
            } 
            remove { 
                Events.RemoveHandler(EventModeChanged, value);
            } 
        }


        ///  
        /// Occurs when the ViewMode is changing.
        ///  
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.FormView_OnModeChanging) 
        ]
        public event FormViewModeEventHandler ModeChanging {
            add {
                Events.AddHandler(EventModeChanging, value); 
            }
            remove { 
                Events.RemoveHandler(EventModeChanging, value); 
            }
        } 


        public void ChangeMode(FormViewMode newMode) {
            Mode = newMode; 
        }
 
 
        /// 
        /// Creates the control hierarchy that is used to render the FormView. 
        /// This is called whenever a control hierarchy is needed and the
        /// ChildControlsCreated property is false.
        /// The implementation assumes that all the children in the controls
        /// collection have already been cleared. 
        /// 
        protected override int CreateChildControls(IEnumerable dataSource, bool dataBinding) { 
            PagedDataSource pagedDataSource = null; 
            int itemIndex = PageIndex;
            bool allowPaging = AllowPaging; 
            int itemCount = 0;
            FormViewMode mode = Mode;

            // if we're in design mode, PageIndex doesn't return -1 
            if (DesignMode && mode == FormViewMode.Insert) {
                itemIndex = -1; 
            } 

            if (dataBinding) { 
                DataSourceView view = GetData();
                DataSourceSelectArguments arguments = SelectArguments;

                if (view == null) { 
                    throw new HttpException(SR.GetString(SR.DataBoundControl_NullView, ID));
                } 
 
                if (mode != FormViewMode.Insert) {
                    if (allowPaging && !view.CanPage) { 
                        if (dataSource != null && !(dataSource is ICollection)) {
                            arguments.StartRowIndex = itemIndex;
                            arguments.MaximumRows = 1;
                            // This should throw an exception saying the data source can't page. 
                            // We do this because the data source can provide a better error message than we can.
                            view.Select(arguments, SelectCallback); 
                        } 
                    }
 
                    if (_useServerPaging) {
                        if (view.CanRetrieveTotalRowCount) {
                            pagedDataSource = CreateServerPagedDataSource(arguments.TotalRowCount);
                        } else { 
                            ICollection dataSourceCollection = dataSource as ICollection;
                            if (dataSourceCollection == null) { 
                                throw new HttpException(SR.GetString(SR.DataBoundControl_NeedICollectionOrTotalRowCount, GetType().Name)); 
                            }
 
                            pagedDataSource = CreateServerPagedDataSource(checked(PageIndex + dataSourceCollection.Count));
                        }
                    } else {
                        pagedDataSource = CreatePagedDataSource(); 
                    }
                } 
            } else { 
                pagedDataSource = CreatePagedDataSource();
            } 

            if (mode != FormViewMode.Insert) {
                pagedDataSource.DataSource = dataSource;
            } 

            IEnumerator dataSourceEnumerator = null; 
            OrderedDictionary keyTable = KeyTable; 

            if (dataBinding == false) { 
                dataSourceEnumerator = dataSource.GetEnumerator();

                ICollection collection = dataSource as ICollection;
                if (collection == null) { 
                    throw new HttpException(SR.GetString(SR.DataControls_DataSourceMustBeCollectionWhenNotDataBinding));
                } 
                itemCount = collection.Count; 
            } else {
                keyTable.Clear(); 
                if (dataSource != null) {
                    if (mode != FormViewMode.Insert) {
                        ICollection collection = dataSource as ICollection;
                        if ((collection == null) && (pagedDataSource.IsPagingEnabled && !pagedDataSource.IsServerPagingEnabled)) { 
                            throw new HttpException(SR.GetString(SR.FormView_DataSourceMustBeCollection, ID));
                        } 
 
                        if (pagedDataSource.IsPagingEnabled) {
                            itemCount = pagedDataSource.DataSourceCount; 
                        } else if (collection != null) {
                            itemCount = collection.Count;
                        }
                    } 
                    dataSourceEnumerator = dataSource.GetEnumerator();
                } 
            } 

            Table table = CreateTable(); 
            TableRowCollection rows = table.Rows;
            bool moveNextSucceeded = false;
            object lastItem = null;
 
            Controls.Add(table);
 
            if (dataSourceEnumerator != null) { 
                moveNextSucceeded = dataSourceEnumerator.MoveNext();    // goto the first item
            } 

            // if there are no items, only add the tablerow if there's a null template or null text
            if (!moveNextSucceeded && mode != FormViewMode.Insert) {
                if (EmptyDataText.Length > 0 || _emptyDataTemplate != null) { 
                    _row = CreateRow(0, DataControlRowType.EmptyDataRow, DataControlRowState.Normal, rows, null);
                } 
                itemCount = 0; 
            } else {
                int currentItemIndex = 0; 
                if (!_useServerPaging) {
                    // skip over the first records that are before the page we're showing
                    for (; currentItemIndex < itemIndex; currentItemIndex++) {
                        lastItem = dataSourceEnumerator.Current; 
                        moveNextSucceeded = dataSourceEnumerator.MoveNext();
                        if (!moveNextSucceeded) { 
                            _pageIndex = currentItemIndex; 
                            pagedDataSource.CurrentPageIndex = currentItemIndex;
                            itemIndex = currentItemIndex; 
                            break;  // never throw if the PageIndex is out of range: just fix up PageIndex and goto the last item.
                        }
                    }
                } 

                if (moveNextSucceeded) { 
                    _dataItem = dataSourceEnumerator.Current; 
                } else {
                    _dataItem = lastItem;   // if we broke out of the above loop, the current item will be invalid 
                }


                // If we're not using server paging and this isn't a collection, or server paging doesn't return a page count, our _pageCount isn't accurate. 
                // Loop through the rest of the enumeration to figure out how many items are in it.
                if ((!_useServerPaging && !(dataSource is ICollection)) || (_useServerPaging && itemCount < 0)) { 
                    itemCount = currentItemIndex; 
                    while (moveNextSucceeded) {
                        itemCount++; 
                        moveNextSucceeded = dataSourceEnumerator.MoveNext();
                    }
                }
 
                _dataItemIndex = currentItemIndex;
 
                bool singlePage = itemCount <= 1 && !_useServerPaging; // hide pagers if there's only one item 
                if (allowPaging && PagerSettings.Visible && _pagerSettings.IsPagerOnTop && mode != FormViewMode.Insert && !singlePage) {
                    // top pager 
                    _topPagerRow = CreateRow(itemIndex, DataControlRowType.Pager, DataControlRowState.Normal, rows, pagedDataSource);
                }

                _headerRow = CreateRow(itemIndex, DataControlRowType.Header, DataControlRowState.Normal, rows, null); 
                if (_headerTemplate == null && HeaderText.Length == 0) {
                    _headerRow.Visible = false; 
                } 

                _row = CreateDataRow(dataBinding, rows, _dataItem); 

                if (itemIndex >= 0) {
                    string[] keyFields = DataKeyNamesInternal;
                    if (dataBinding && (keyFields.Length != 0)) { 
                        foreach (string keyName in keyFields) {
                            object keyValue = DataBinder.GetPropertyValue(_dataItem, keyName); 
                            keyTable.Add(keyName, keyValue); 
                        }
                        _dataKey = new DataKey(keyTable); 
                    }
                }

                _footerRow = CreateRow(itemIndex, DataControlRowType.Footer, DataControlRowState.Normal, rows, null); 
                if (_footerTemplate == null && FooterText.Length == 0) {
                    _footerRow.Visible = false; 
                } 

                if (allowPaging && PagerSettings.Visible && _pagerSettings.IsPagerOnBottom && mode != FormViewMode.Insert && !singlePage) { 
                    // bottom pager
                    _bottomPagerRow = CreateRow(itemIndex, DataControlRowType.Pager, DataControlRowState.Normal, rows, pagedDataSource);
                }
            } 

            _pageCount = itemCount; 
 
            OnItemCreated(EventArgs.Empty);
 
            if (dataBinding) {
                DataBind(false);
            }
 
            return itemCount;
        } 
 

        ///  
        /// Creates new control style.
        /// 
        protected override Style CreateControlStyle() {
            TableStyle controlStyle = new TableStyle(); 

            // initialize defaults that are different from TableStyle 
            controlStyle.CellSpacing = 0; 

            return controlStyle; 
        }

        private FormViewRow CreateDataRow(bool dataBinding, TableRowCollection rows, object dataItem) {
            ITemplate modeTemplate = null; 

            switch (Mode) { 
                case FormViewMode.Edit: 
                    modeTemplate = _editItemTemplate;
                    break; 
                case FormViewMode.Insert:
                    if (_insertItemTemplate != null) {
                        modeTemplate = _insertItemTemplate;
                    } else { 
                        modeTemplate = _editItemTemplate;
                    } 
                    break; 
                case FormViewMode.ReadOnly:
                    modeTemplate = _itemTemplate; 
                    break;
            }

            if (modeTemplate != null) { 
                return CreateDataRowFromTemplates(dataBinding, rows);
            } 
            return null; 
        }
 
        private FormViewRow CreateDataRowFromTemplates(bool dataBinding, TableRowCollection rows) {
            DataControlRowState rowState = DataControlRowState.Normal;
            int itemIndex = PageIndex;
            FormViewMode mode = Mode; 

            rowState = DataControlRowState.Normal; 
            if (mode == FormViewMode.Edit) 
                rowState |= DataControlRowState.Edit;
            else if (mode == FormViewMode.Insert) 
                rowState |= DataControlRowState.Insert;

            return CreateRow(PageIndex, DataControlRowType.DataRow, rowState, rows, null);
        } 

        protected override DataSourceSelectArguments CreateDataSourceSelectArguments() { 
            DataSourceSelectArguments arguments = new DataSourceSelectArguments(); 
            DataSourceView view = GetData();
 
            _useServerPaging = AllowPaging && view.CanPage;

            // decide if we should use server-side paging
            if (_useServerPaging) { 
                arguments.StartRowIndex = PageIndex;
                if (view.CanRetrieveTotalRowCount) { 
                    arguments.RetrieveTotalRowCount = true; 
                    arguments.MaximumRows = 1;
                } else { 
                    arguments.MaximumRows = -1;
                }
            }
 
            return arguments;
        } 
 
        /// 
        /// Creates the pager for NextPrev and NextPrev with First and Last styles 
        /// 
        private void CreateNextPrevPager(TableRow row, PagedDataSource pagedDataSource, bool addFirstLastPageButtons) {
            PagerSettings pagerSettings = PagerSettings;
            string prevPageImageUrl = pagerSettings.PreviousPageImageUrl; 
            string nextPageImageUrl = pagerSettings.NextPageImageUrl;
            bool isFirstPage = pagedDataSource.IsFirstPage; 
            bool isLastPage = pagedDataSource.IsLastPage; 

 
            if (addFirstLastPageButtons && !isFirstPage) {
                string firstPageImageUrl = pagerSettings.FirstPageImageUrl;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                IButtonControl firstButton;
                if (firstPageImageUrl.Length > 0) { 
                    firstButton = new DataControlImageButton(this); 
                    ((ImageButton)firstButton).ImageUrl = firstPageImageUrl;
                    ((ImageButton)firstButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.FirstPageText); 
                } else {
                    firstButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)firstButton).Text = pagerSettings.FirstPageText;
                } 
                firstButton.CommandName = DataControlCommands.PageCommandName;
                firstButton.CommandArgument = DataControlCommands.FirstPageCommandArgument; 
                cell.Controls.Add((Control)firstButton); 
            }
 
            if (!isFirstPage) {
                IButtonControl prevButton;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                if (prevPageImageUrl.Length > 0) {
                    prevButton = new DataControlImageButton(this); 
                    ((ImageButton)prevButton).ImageUrl = prevPageImageUrl; 
                    ((ImageButton)prevButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.PreviousPageText);
                } else { 
                    prevButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)prevButton).Text = pagerSettings.PreviousPageText;
                }
                prevButton.CommandName = DataControlCommands.PageCommandName; 
                prevButton.CommandArgument = DataControlCommands.PreviousPageCommandArgument;
                cell.Controls.Add((Control)prevButton); 
            } 

 
            if (!isLastPage) {
                IButtonControl nextButton;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                if (nextPageImageUrl.Length > 0) {
                    nextButton = new DataControlImageButton(this); 
                    ((ImageButton)nextButton).ImageUrl = nextPageImageUrl; 
                    ((ImageButton)nextButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.NextPageText);
                } else { 
                    nextButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)nextButton).Text = pagerSettings.NextPageText;
                }
                nextButton.CommandName = DataControlCommands.PageCommandName; 
                nextButton.CommandArgument = DataControlCommands.NextPageCommandArgument;
                cell.Controls.Add((Control)nextButton); 
            } 

            if (addFirstLastPageButtons && !isLastPage) { 
                string lastPageImageUrl = pagerSettings.LastPageImageUrl;
                IButtonControl lastButton;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                if (lastPageImageUrl.Length > 0) {
                    lastButton = new DataControlImageButton(this); 
                    ((ImageButton)lastButton).ImageUrl = lastPageImageUrl; 
                    ((ImageButton)lastButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.LastPageText);
 
                } else {
                    lastButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)lastButton).Text = pagerSettings.LastPageText;
                } 
                lastButton.CommandName = DataControlCommands.PageCommandName;
                lastButton.CommandArgument = DataControlCommands.LastPageCommandArgument; 
                cell.Controls.Add((Control)lastButton); 
            }
        } 

        /// 
        /// Creates the pager for NextPrev and NextPrev with First and Last styles
        ///  
        private void CreateNumericPager(TableRow row, PagedDataSource pagedDataSource, bool addFirstLastPageButtons) {
            PagerSettings pagerSettings = PagerSettings; 
 
            int pages = pagedDataSource.PageCount;
            int currentPage = pagedDataSource.CurrentPageIndex + 1; 
            int pageSetSize = pagerSettings.PageButtonCount;
            int pagesShown = pageSetSize;
            int firstDisplayedPage = FirstDisplayedPageIndex + 1;   // first page displayed on last postback
 
            // ensure the number of pages we show isn't more than the number of pages that do exist
            if (pages < pagesShown) 
                pagesShown = pages; 

            // initialize to the first page set, i.e., pages 1 through number of pages shown 
            int firstPage = 1;
            int lastPage = pagesShown;

            if (currentPage > lastPage) { 
                // The current page is not in the first page set, then we need to slide the
                // range of pages shown by adjusting firstPage and lastPage 
                int currentPageSet = (currentPage - 1) / pageSetSize; 
                bool currentPageInLastDisplayRange = currentPage - firstDisplayedPage >= 0 && currentPage - firstDisplayedPage < pageSetSize;
                if (firstDisplayedPage > 0 && currentPageInLastDisplayRange) { 
                    firstPage = firstDisplayedPage;
                } else {
                    firstPage = currentPageSet * pageSetSize + 1;
                } 
                lastPage = firstPage + pageSetSize - 1;
 
                // now bring back lastPage into the range if its exceeded the number of pages 
                if (lastPage > pages)
                    lastPage = pages; 

                // if theres room to show more pages from the previous page set, then adjust
                // the first page accordingly
                if (lastPage - firstPage + 1 < pageSetSize) { 
                    firstPage = Math.Max(1, lastPage - pageSetSize + 1);
                } 
                FirstDisplayedPageIndex = firstPage - 1; 
            }
 
            LinkButton button;

            if (addFirstLastPageButtons && currentPage != 1 && firstPage != 1) {
                string firstPageImageUrl = pagerSettings.FirstPageImageUrl; 
                IButtonControl firstButton;
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell); 

                if (firstPageImageUrl.Length > 0) { 
                    firstButton = new DataControlImageButton(this);
                    ((ImageButton)firstButton).ImageUrl = firstPageImageUrl;
                    ((ImageButton)firstButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.FirstPageText);
                } else { 
                    firstButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)firstButton).Text = pagerSettings.FirstPageText; 
                } 
                firstButton.CommandName = DataControlCommands.PageCommandName;
                firstButton.CommandArgument = DataControlCommands.FirstPageCommandArgument; 
                cell.Controls.Add((Control)firstButton);
            }

            if (firstPage != 1) { 
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
 
                button = new DataControlPagerLinkButton(this);
                button.Text = "..."; 
                button.CommandName = DataControlCommands.PageCommandName;
                button.CommandArgument = (firstPage - 1).ToString(NumberFormatInfo.InvariantInfo);
                cell.Controls.Add(button);
            } 

            for (int i = firstPage; i <= lastPage; i++) { 
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell);
 
                string pageString = (i).ToString(NumberFormatInfo.InvariantInfo);
                if (i == currentPage) {
                    Label label = new Label();
 
                    label.Text = pageString;
                    cell.Controls.Add(label); 
                } else { 
                    button = new DataControlPagerLinkButton(this);
 
                    button.Text = pageString;
                    button.CommandName = DataControlCommands.PageCommandName;
                    button.CommandArgument = pageString;
                    cell.Controls.Add(button); 
                }
            } 
 
            if (pages > lastPage) {
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell);
                button = new DataControlPagerLinkButton(this);

                button.Text = "..."; 
                button.CommandName = DataControlCommands.PageCommandName;
                button.CommandArgument = (lastPage + 1).ToString(NumberFormatInfo.InvariantInfo); 
                cell.Controls.Add(button); 
            }
 
            bool isLastPageShown = lastPage == pages;
            if (addFirstLastPageButtons && currentPage != pages && !isLastPageShown) {
                string lastPageImageUrl = pagerSettings.LastPageImageUrl;
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell);
 
                IButtonControl lastButton; 
                if (lastPageImageUrl.Length > 0) {
                    lastButton = new DataControlImageButton(this); 
                    ((ImageButton)lastButton).ImageUrl = lastPageImageUrl;
                    ((ImageButton)lastButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.LastPageText);
                } else {
                    lastButton = new DataControlPagerLinkButton(this); 
                    ((DataControlPagerLinkButton)lastButton).Text = pagerSettings.LastPageText;
                } 
                lastButton.CommandName = DataControlCommands.PageCommandName; 
                lastButton.CommandArgument = DataControlCommands.LastPageCommandArgument;
                cell.Controls.Add((Control)lastButton); 
            }
        }

        private PagedDataSource CreatePagedDataSource() { 
            PagedDataSource pagedDataSource = new PagedDataSource();
 
            pagedDataSource.CurrentPageIndex = PageIndex; 
            pagedDataSource.PageSize = 1;
            pagedDataSource.AllowPaging = AllowPaging; 
            pagedDataSource.AllowCustomPaging = false;
            pagedDataSource.AllowServerPaging = false;
            pagedDataSource.VirtualCount = 0;
 
            return pagedDataSource;
        } 
 
        private PagedDataSource CreateServerPagedDataSource(int totalRowCount) {
            PagedDataSource pagedDataSource = new PagedDataSource(); 

            pagedDataSource.CurrentPageIndex = PageIndex;
            pagedDataSource.PageSize = 1;
            pagedDataSource.AllowPaging = AllowPaging; 
            pagedDataSource.AllowCustomPaging = false;
            pagedDataSource.AllowServerPaging = true; 
            pagedDataSource.VirtualCount = totalRowCount; 

            return pagedDataSource; 
        }

        private FormViewRow CreateRow(int itemIndex, DataControlRowType rowType, DataControlRowState rowState, TableRowCollection rows, PagedDataSource pagedDataSource) {
            FormViewRow row = CreateRow(itemIndex, rowType, rowState); 
            row.RenderTemplateContainer = RenderOuterTable;
 
            rows.Add(row); 

            if (rowType != DataControlRowType.Pager) { 
                InitializeRow(row);
            } else {
                InitializePager(row, pagedDataSource);
            } 

            return row; 
        } 

 
        /// 
        /// [To be supplied.]
        /// 
        protected virtual FormViewRow CreateRow(int itemIndex, DataControlRowType rowType, DataControlRowState rowState) { 
            if (rowType == DataControlRowType.Pager) {
                return new FormViewPagerRow(itemIndex, rowType, rowState); 
            } 
            return new FormViewRow(itemIndex, rowType, rowState);
        } 


        /// 
        /// Creates a new ChildTable, which is the containing table 
        /// 
        protected virtual Table CreateTable() { 
            return new ChildTable(String.IsNullOrEmpty(ID) ? null : ClientID); 
        }
 
        /// Data bound controls should override PerformDataBinding instead
        /// of DataBind.  If DataBind if overridden, the OnDataBinding and OnDataBound events will
        /// fire in the wrong order.  However, for backwards compat on ListControl and AdRotator, we
        /// can't seal this method.  It is sealed on all new BaseDataBoundControl-derived controls. 
        public override sealed void DataBind() {
            base.DataBind(); 
        } 

        public virtual void DeleteItem() { 
            // use EnableModelVadliation as the causesValdiation param because the hosting page should not
            // be validated unless model validation is going to be used
            ResetModelValidationGroup(EnableModelValidation, String.Empty);
            HandleDelete(String.Empty); 
        }
 
        ///  
        /// Override EnsureDataBound because we don't want to databind when we're in insert mode
        ///  
        protected override void EnsureDataBound() {
            if (RequiresDataBinding && Mode == FormViewMode.Insert) {
                OnDataBinding(EventArgs.Empty);
 
                RequiresDataBinding = false;
                MarkAsDataBound(); 
                if (AdapterInternal != null) { 
                    DataBoundControlAdapter dataBoundControlAdapter = AdapterInternal as DataBoundControlAdapter;
                    if (dataBoundControlAdapter != null) { 
                        dataBoundControlAdapter.PerformDataBinding(null);
                    } else {
                        PerformDataBinding(null);
                    } 
                } else {
                    PerformDataBinding(null); 
                } 

                OnDataBound(EventArgs.Empty); 
            } else {
                base.EnsureDataBound();
            }
        } 

 
        protected virtual void ExtractRowValues(IOrderedDictionary fieldValues, bool includeKeys) { 
            if (fieldValues == null) {
                Debug.Assert(false, "FormView::ExtractRowValues- must hand in a valid reference to an IDictionary."); 
                return;
            }

            DataBoundControlHelper.ExtractValuesFromBindableControls(fieldValues, this); 

            IBindableTemplate bindableTemplate = null; 
            if (Mode == FormViewMode.ReadOnly && ItemTemplate != null) { 
                bindableTemplate = ItemTemplate as IBindableTemplate;
            } else if ((Mode == FormViewMode.Edit || (Mode == FormViewMode.Insert && InsertItemTemplate == null)) && EditItemTemplate != null) { 
                bindableTemplate = EditItemTemplate as IBindableTemplate;
            } else if (Mode == FormViewMode.Insert && InsertItemTemplate != null) {
                bindableTemplate = InsertItemTemplate as IBindableTemplate;
            } 
            string[] dataKeyNames = DataKeyNamesInternal;
 
            if (bindableTemplate != null) { 
                FormView container = this;
                if (container != null && bindableTemplate != null) { 
                    foreach (DictionaryEntry entry in bindableTemplate.ExtractValues(container)) {
                        if (!includeKeys && Array.IndexOf(dataKeyNames, entry.Key) != -1) {
                            continue;
                        } 
                        fieldValues[entry.Key] = entry.Value;
                    } 
                } 
            }
 
            return;
        }

        private void HandleCancel() { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
 
            FormViewModeEventArgs e = new FormViewModeEventArgs(DefaultMode, true); 
            OnModeChanging(e);
 
            if (e.Cancel) {
                return;
            }
 
            if (isBoundToDataSourceControl) {
                Mode = e.NewMode; 
                OnModeChanged(EventArgs.Empty); 
            }
 
            RequiresDataBinding = true;
        }

        private void HandleDelete(string commandArg) { 
            int pageIndex = PageIndex;
 
            if (pageIndex < 0) {    // don't attempt to delete in Insert mode 
                return;
            } 

            DataSourceView view = null;
            int itemIndex = PageIndex;
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            if (isBoundToDataSourceControl) { 
                view = GetData(); 
                if (view == null) {
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID)); 
                }
            }

            FormViewDeleteEventArgs e = new FormViewDeleteEventArgs(itemIndex); 

 
            ExtractRowValues(e.Values, false/*includeKeys*/); 
            foreach (DictionaryEntry entry in DataKey.Values) {
                e.Keys.Add(entry.Key, entry.Value); 
                if (e.Values.Contains(entry.Key)) {
                    e.Values.Remove(entry.Key);
                }
            } 

 
            OnItemDeleting(e); 

            if (e.Cancel) { 
                return;
            }

            if (isBoundToDataSourceControl) { 
                _deleteKeys = e.Keys;
                _deleteValues = e.Values; 
                view.Delete(e.Keys, e.Values, HandleDeleteCallback); 
            }
        } 

        private bool HandleDeleteCallback(int affectedRows, Exception ex) {
            int pageIndex = PageIndex;
            FormViewDeletedEventArgs fea = new FormViewDeletedEventArgs(affectedRows, ex); 
            fea.SetKeys(_deleteKeys);
            fea.SetValues(_deleteValues); 
 
            OnItemDeleted(fea);
 
            _deleteKeys = null;
            _deleteValues = null;

            if (ex != null && !fea.ExceptionHandled) { 
                // If there is no validator in the validation group that could make sense
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing. 
                if (PageIsValidAfterModelException()) {
                    return false; 
                }
            }

            if (pageIndex == _pageCount - 1) { 
                HandlePage(pageIndex - 1);
            } 
 
            RequiresDataBinding = true;
            return true; 
        }

        private void HandleEdit() {
            if (PageIndex < 0) { 
                return;
            } 
 
            FormViewModeEventArgs e = new FormViewModeEventArgs(FormViewMode.Edit, false);
            OnModeChanging(e); 

            if (e.Cancel) {
                return;
            } 

            if (IsBoundUsingDataSourceID) { 
                Mode = e.NewMode; 
                OnModeChanged(EventArgs.Empty);
            } 

            RequiresDataBinding = true;
        }
 
        private bool HandleEvent(EventArgs e, bool causesValidation, string validationGroup) {
            bool handled = false; 
 
            ResetModelValidationGroup(causesValidation, validationGroup);
 
            FormViewCommandEventArgs dce = e as FormViewCommandEventArgs;

            if (dce != null) {
 
                OnItemCommand(dce);
                handled = true; 
 
                string command = dce.CommandName;
                int newItemIndex = PageIndex; 

                if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.PageCommandName)) {
                    string itemIndexArg = (string)dce.CommandArgument;
 
                    if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.NextPageCommandArgument)) {
                        newItemIndex++; 
                    } else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.PreviousPageCommandArgument)) { 
                        newItemIndex--;
                    } else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.FirstPageCommandArgument)) { 
                        newItemIndex = 0;
                    } else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.LastPageCommandArgument)) {
                        newItemIndex = PageCount - 1;
                    } else { 
                        // argument is page number, and page index is 1 less than that
                        newItemIndex = Convert.ToInt32(itemIndexArg, CultureInfo.InvariantCulture) - 1; 
                    } 
                    HandlePage(newItemIndex);
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.EditCommandName)) { 
                    HandleEdit();
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.UpdateCommandName)) {
                    HandleUpdate((string)dce.CommandArgument, causesValidation);
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.CancelCommandName)) { 
                    HandleCancel();
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.DeleteCommandName)) { 
                    HandleDelete((string)dce.CommandArgument); 
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.InsertCommandName)) {
                    HandleInsert((string)dce.CommandArgument, causesValidation); 
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.NewCommandName)) {
                    HandleNew();
                } else {
                    // unhandled event should be bubbled up here. (DevDiv Bugs 161011) 
                    handled = HandleCommand(command);
                } 
            } 

            return handled; 
        }

        private bool HandleCommand(string commandName) {
            DataSourceView view = null; 

            if (IsBoundUsingDataSourceID) { 
                view = GetData(); 
                if (view == null) {
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID)); 
                }
            }
            else {
                // This feature is only for data sources 
                return false;
            } 
 
            if (!view.CanExecute(commandName)) {
                return false; 
            }

            OrderedDictionary values = new OrderedDictionary();
            OrderedDictionary keys = new OrderedDictionary(); 

            ExtractRowValues(values, false /*includeKey*/); 
 
            foreach (DictionaryEntry entry in DataKey.Values) {
                keys.Add(entry.Key, entry.Value); 
                if (values.Contains(entry.Key)) {
                    values.Remove(entry.Key);
                }
            } 

            view.ExecuteCommand(commandName, keys, values, HandleCommandCallback); 
            return true; 
        }
 
        private bool HandleCommandCallback(int affectedRows, Exception ex) {
            if (ex != null) {
                // If there is no validator in the validation group that could make sense
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing.
                if (PageIsValidAfterModelException()) { 
                    return false; 
                }
            } 

            RequiresDataBinding = true;
            return true;
        } 

        private void HandleInsert(string commandArg, bool causesValidation) { 
            if (causesValidation && Page != null && !Page.IsValid) { 
                return;
            } 

            if (Mode != FormViewMode.Insert) {
                throw new HttpException(SR.GetString(SR.DetailsViewFormView_ControlMustBeInInsertMode, "FormView", ID));
            } 

            DataSourceView view = null; 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            if (isBoundToDataSourceControl) { 
                view = GetData();
                if (view == null) {
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
                } 
            }
 
            FormViewInsertEventArgs e = new FormViewInsertEventArgs(commandArg); 

 
            ExtractRowValues(e.Values, true/*includeKeys*/);


            OnItemInserting(e); 

            if (e.Cancel) { 
                return; 
            }
 
            if (isBoundToDataSourceControl) {
                _insertValues = e.Values;
                view.Insert(e.Values, HandleInsertCallback);
            } 
        }
 
        private bool HandleInsertCallback(int affectedRows, Exception ex) { 
            FormViewInsertedEventArgs fea = new FormViewInsertedEventArgs(affectedRows, ex);
            fea.SetValues(_insertValues); 

            OnItemInserted(fea);

            _insertValues = null; 
            if (ex != null && !fea.ExceptionHandled) {
                // If there is no validator in the validation group that could make sense 
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing.
                if (PageIsValidAfterModelException()) { 
                    return false;
                }
                fea.KeepInInsertMode = true;
            } 

            if (!fea.KeepInInsertMode) { 
                FormViewModeEventArgs eMode = new FormViewModeEventArgs(DefaultMode, false); 
                OnModeChanging(eMode);
                if (!eMode.Cancel) { 
                    Mode = eMode.NewMode;
                    OnModeChanged(EventArgs.Empty);
                    RequiresDataBinding = true;
                } 
            }
            return true; 
        } 

        private void HandleNew() { 
            FormViewModeEventArgs e = new FormViewModeEventArgs(FormViewMode.Insert, false);
            OnModeChanging(e);

            if (e.Cancel) { 
                return;
            } 
 
            if (IsBoundUsingDataSourceID) {
                Mode = e.NewMode; 
                OnModeChanged(EventArgs.Empty);
            }

            RequiresDataBinding = true; 
        }
 
        private void HandlePage(int newPage) { 
            if (!AllowPaging) {
                return; 
            }

            if (PageIndex < 0) {
                return; 
            }
 
            FormViewPageEventArgs e = new FormViewPageEventArgs(newPage); 
            OnPageIndexChanging(e);
 
            if (e.Cancel) {
                return;
            }
 
            if (e.NewPageIndex > -1) {
                // if the requested page is out of range and we're already on the last page, don't rebind 
                if ((e.NewPageIndex >= PageCount && _pageIndex == PageCount - 1)) { 
                    return;
                } 
                // DevDiv Bugs 188830: Don't clear key table if the page is out of range, since control won't be rebound.
                _keyTable = null;
                _pageIndex = e.NewPageIndex;
            } 
            else {
                return; 
            } 

            OnPageIndexChanged(EventArgs.Empty); 
            RequiresDataBinding = true;
        }

        private void HandleUpdate(string commandArg, bool causesValidation) { 
            if (causesValidation && Page != null && !Page.IsValid) {
                return; 
            } 

            if (Mode != FormViewMode.Edit) { 
                throw new HttpException(SR.GetString(SR.DetailsViewFormView_ControlMustBeInEditMode, "FormView", ID));
            }

            if (PageIndex < 0) { 
                return;
            } 
 
            DataSourceView view = null;
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            if (isBoundToDataSourceControl) {
                view = GetData();
                if (view == null) { 
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
                } 
            } 

            FormViewUpdateEventArgs e = new FormViewUpdateEventArgs(commandArg); 


            foreach (DictionaryEntry entry in BoundFieldValues) {
                e.OldValues.Add(entry.Key, entry.Value); 
            }
 
            ExtractRowValues(e.NewValues, true/*includeKeys*/); 
            foreach (DictionaryEntry entry in DataKey.Values) {
                e.Keys.Add(entry.Key, entry.Value); 
            }


 
            OnItemUpdating(e);
 
            if (e.Cancel) { 
                return;
            } 

            if (isBoundToDataSourceControl) {
                _updateKeys = e.Keys;
                _updateOldValues = e.OldValues; 
                _updateNewValues = e.NewValues;
 
                view.Update(e.Keys, e.NewValues, e.OldValues, HandleUpdateCallback); 
            }
        } 

        private bool HandleUpdateCallback(int affectedRows, Exception ex) {
            FormViewUpdatedEventArgs fea = new FormViewUpdatedEventArgs(affectedRows, ex);
            fea.SetOldValues(_updateOldValues); 
            fea.SetNewValues(_updateNewValues);
            fea.SetKeys(_updateKeys); 
 
            OnItemUpdated(fea);
            _updateKeys = null; 
            _updateOldValues = null;
            _updateNewValues = null;

            if (ex != null && !fea.ExceptionHandled) { 
                // If there is no validator in the validation group that could make sense
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing. 
                if (PageIsValidAfterModelException()) {
                    return false; 
                }
                fea.KeepInEditMode = true;
            }
            if (!fea.KeepInEditMode) { 
                FormViewModeEventArgs eMode = new FormViewModeEventArgs(DefaultMode, false);
                OnModeChanging(eMode); 
                if (!eMode.Cancel) { 
                    Mode = eMode.NewMode;
                    OnModeChanged(EventArgs.Empty); 
                    RequiresDataBinding = true;
                }
            }
            return true; 
        }
 
 
        /// 
        ///  
        /// Creates a FormViewRow that contains the paging UI.
        /// The paging UI is a navigation bar that is a built into a single TableCell that
        /// spans across all fields of the FormView.
        ///  
        /// 
        protected virtual void InitializePager(FormViewRow row, PagedDataSource pagedDataSource) { 
            TableCell cell = new TableCell(); 

            PagerSettings pagerSettings = PagerSettings; 

            if (_pagerTemplate != null) {
                _pagerTemplate.InstantiateIn(cell);
            } else { 
                PagerTable pagerTable = new PagerTable();
                TableRow pagerTableRow = new TableRow(); 
                cell.Controls.Add(pagerTable); 
                pagerTable.Rows.Add(pagerTableRow);
                switch (pagerSettings.Mode) { 
                    case PagerButtons.NextPrevious:
                        CreateNextPrevPager(pagerTableRow, pagedDataSource, false);
                        break;
                    case PagerButtons.Numeric: 
                        CreateNumericPager(pagerTableRow, pagedDataSource, false);
                        break; 
                    case PagerButtons.NextPreviousFirstLast: 
                        CreateNextPrevPager(pagerTableRow, pagedDataSource, true);
                        break; 
                    case PagerButtons.NumericFirstLast:
                        CreateNumericPager(pagerTableRow, pagedDataSource, true);
                        break;
                } 
            }
            cell.ColumnSpan = 2; 
            row.Cells.Add(cell); 
        }
 

        /// 
        /// [To be supplied.]
        ///  
        protected virtual void InitializeRow(FormViewRow row) {
            TableCellCollection cells = row.Cells; 
            TableCell contentCell = new TableCell(); 
            ITemplate contentTemplate = _itemTemplate;
            int itemIndex = row.ItemIndex; 
            DataControlRowState rowState = row.RowState;

            switch (row.RowType) {
                case DataControlRowType.DataRow: 
                    contentCell.ColumnSpan = 2;
                    if (((rowState & DataControlRowState.Edit) != 0) && _editItemTemplate != null) { 
                        contentTemplate = _editItemTemplate; 
                    }
                    if ((rowState & DataControlRowState.Insert) != 0) { 
                        if (_insertItemTemplate != null) {
                            contentTemplate = _insertItemTemplate;
                        } else {
                            contentTemplate = _editItemTemplate; 
                        }
                    } 
                    break; 
                case DataControlRowType.Header:
                    contentTemplate = _headerTemplate; 
                    contentCell.ColumnSpan = 2;
                    string headerText = HeaderText;
                    if (_headerTemplate == null && headerText.Length > 0) {
                        contentCell.Text = headerText; 
                    }
                    break; 
                case DataControlRowType.Footer: 
                    contentTemplate = _footerTemplate;
                    contentCell.ColumnSpan = 2; 
                    string footerText = FooterText;
                    if (_footerTemplate == null && footerText.Length > 0) {
                        contentCell.Text = footerText;
                    } 
                    break;
                case DataControlRowType.EmptyDataRow: 
                    contentTemplate = _emptyDataTemplate; 
                    string emptyDataText = EmptyDataText;
                    if (_emptyDataTemplate == null && emptyDataText.Length > 0) { 
                        contentCell.Text = emptyDataText;
                    }
                    break;
            } 

            if (contentTemplate != null) { 
                contentTemplate.InstantiateIn(contentCell); 
            }
            cells.Add(contentCell); 
        }

        public virtual void InsertItem(bool causesValidation) {
            ResetModelValidationGroup(causesValidation, String.Empty); 
            HandleInsert(String.Empty, causesValidation);
        } 
 

        ///  
        /// Determines if the specified data type can be bound to.
        /// 
        public virtual bool IsBindableType(Type type) {
            // NOTE: No one ever calls this function, but we have to keep it for back compat 
            // since it's public.
            return DataBoundControlHelper.IsBindableType(type); 
        } 

 
        /// 
        /// Loads the control state for those properties that should persist across postbacks
        ///   even when EnableViewState=false.
        ///  
        protected internal override void LoadControlState(object savedState) {
            // Any properties that could have been set in the persistance need to be 
            // restored to their defaults if they're not in ControlState, or they will 
            // be restored to their persisted state instead of their empty state.
            _pageIndex = 0; 
            _defaultMode = FormViewMode.ReadOnly;
            _dataKeyNames = new string[0];
            _pageCount = 0;
 
            object[] state = savedState as object[];
            if (state != null) { 
                base.LoadControlState(state[0]); 
                if (state[1] != null) {
                    _pageIndex = (int)state[1]; 
                }

                if (state[2] != null) {
                    _defaultMode = (FormViewMode)state[2]; 
                }
 
                // if Mode isn't saved, it should be restored to DefaultMode.  That will happen in Mode's getter, 
                // since the persistance state hasn't been loaded yet.
                if (state[3] != null) { 
                    Mode = (FormViewMode)state[3];
                }

                if (state[4] != null) { 
                    _dataKeyNames = (string[])state[4];
                } 
 
                if (state[5] != null) {
                    KeyTable.Clear(); 
                    OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)KeyTable, (ArrayList)state[5]);
                }

                if (state[6] != null) { 
                    _pageCount = (int)state[6];
                } 
            } else { 
                base.LoadControlState(null);
            } 

        }

 
        /// 
        /// Loads a saved state of the . 
        ///  
        protected override void LoadViewState(object savedState) {
            if (savedState != null) { 
                object[] myState = (object[])savedState;

                base.LoadViewState(myState[0]);
                if (myState[1] != null) 
                    ((IStateManager)PagerStyle).LoadViewState(myState[1]);
                if (myState[2] != null) 
                    ((IStateManager)HeaderStyle).LoadViewState(myState[2]); 
                if (myState[3] != null)
                    ((IStateManager)FooterStyle).LoadViewState(myState[3]); 
                if (myState[4] != null)
                    ((IStateManager)RowStyle).LoadViewState(myState[4]);
                if (myState[5] != null)
                    ((IStateManager)EditRowStyle).LoadViewState(myState[5]); 
                if (myState[6] != null)
                    ((IStateManager)InsertRowStyle).LoadViewState(myState[6]); 
                if (myState[7] != null) 
                    OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)BoundFieldValues, (ArrayList)myState[7]);
                if (myState[8] != null) 
                    ((IStateManager)PagerSettings).LoadViewState(myState[8]);
                if (myState[9] != null)
                    ((IStateManager)ControlStyle).LoadViewState(myState[9]);
            } else { 
                base.LoadViewState(null);
            } 
        } 

        protected internal virtual string ModifiedOuterTableStylePropertyName() { 
            // Verify that table specific and basic style properties are not not set (not different than their defaults).
            if (!String.IsNullOrEmpty(BackImageUrl)) {
                return "BackImageUrl";
            } 
            if (CellPadding != -1) {
                return "CellPadding"; 
            } 
            if (CellSpacing != 0) {
                return "CellSpacing"; 
            }
            if (GridLines != GridLines.None) {
                return "GridLines";
            } 
            if (HorizontalAlign != HorizontalAlign.NotSet) {
                return "HorizontalAlign"; 
            } 

            // Font styles. 
            if (Font.Bold ||
                Font.Italic ||
                !String.IsNullOrEmpty(Font.Name) ||
                (Font.Names.Length != 0) || 
                Font.Overline ||
                (Font.Size != FontUnit.Empty) || 
                Font.Strikeout || 
                Font.Underline) {
                return "Font"; 
            }

            return LoginUtil.ModifiedOuterTableBasicStylePropertyName(this);
        } 

        ///  
        ///  
        protected override bool OnBubbleEvent(object source, EventArgs e) {
            bool causesValidation = false; 
            string validationGroup = String.Empty;

            FormViewCommandEventArgs fvcea = e as FormViewCommandEventArgs;
            if (fvcea != null) { 
                IButtonControl button = fvcea.CommandSource as IButtonControl;
                if (button != null) { 
                    causesValidation = button.CausesValidation; 
                    validationGroup = button.ValidationGroup;
                } 
            }
            return HandleEvent(e, causesValidation, validationGroup);
        }
 

        ///  
        /// Raises the event. 
        /// 
        protected virtual void OnPageIndexChanged(EventArgs e) { 
            EventHandler handler = (EventHandler)Events[EventPageIndexChanged];
            if (handler != null) handler(this, e);
        }
 

        ///  
        /// Raises the  event. 
        /// 
        protected virtual void OnPageIndexChanging(FormViewPageEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;

            FormViewPageEventHandler handler = (FormViewPageEventHandler)Events[EventPageIndexChanging];
            if (handler != null) { 
                handler(this, e);
            } else { 
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "PageIndexChanging"));
                } 
            }
        }

 
        /// 
        /// FormView initialization. 
        ///  
        protected internal override void OnInit(EventArgs e) {
            base.OnInit(e); 

            if (Page != null) {
                if (DataKeyNames.Length > 0) {
                    Page.RegisterRequiresViewStateEncryption(); 
                }
                Page.RegisterRequiresControlState(this); 
            } 
        }
 

        /// 
        /// Raises the  event.
        ///  
        protected virtual void OnItemCommand(FormViewCommandEventArgs e) {
            FormViewCommandEventHandler handler = (FormViewCommandEventHandler)Events[EventItemCommand]; 
            if (handler != null) { 
                handler(this, e);
            } 
        }


        ///  
        /// Raises the  event.
        ///  
        protected virtual void OnItemCreated(EventArgs e) { 
            EventHandler handler = (EventHandler)Events[EventItemCreated];
            if (handler != null) { 
                handler(this, e);
            }
        }
 

        ///  
        /// Raises the event. 
        /// 
        protected virtual void OnItemDeleted(FormViewDeletedEventArgs e) { 
            FormViewDeletedEventHandler handler = (FormViewDeletedEventHandler)Events[EventItemDeleted];
            if (handler != null) handler(this, e);
        }
 

        ///  
        /// Raises the  event. 
        /// 
        protected virtual void OnItemDeleting(FormViewDeleteEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;

            FormViewDeleteEventHandler handler = (FormViewDeleteEventHandler)Events[EventItemDeleting];
            if (handler != null) { 
                handler(this, e);
            } else { 
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemDeleting"));
                } 
            }
        }

 
        /// 
        /// Raises the event. 
        ///  
        protected virtual void OnItemInserted(FormViewInsertedEventArgs e) {
            FormViewInsertedEventHandler handler = (FormViewInsertedEventHandler)Events[EventItemInserted]; 
            if (handler != null) handler(this, e);
        }

 
        /// 
        /// Raises the  event. 
        ///  
        protected virtual void OnItemInserting(FormViewInsertEventArgs e) {
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            FormViewInsertEventHandler handler = (FormViewInsertEventHandler)Events[EventItemInserting];
            if (handler != null) {
                handler(this, e); 
            } else {
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemInserting")); 
                }
            } 
        }


        ///  
        /// Raises the event.
        ///  
        protected virtual void OnItemUpdated(FormViewUpdatedEventArgs e) { 
            FormViewUpdatedEventHandler handler = (FormViewUpdatedEventHandler)Events[EventItemUpdated];
            if (handler != null) handler(this, e); 
        }


        ///  
        /// Raises the  event.
        ///  
        protected virtual void OnItemUpdating(FormViewUpdateEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
 
            FormViewUpdateEventHandler handler = (FormViewUpdateEventHandler)Events[EventItemUpdating];
            if (handler != null) {
                handler(this, e);
            } else { 
                if (isBoundToDataSourceControl == false && e.Cancel == false) {
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemUpdating")); 
                } 
            }
        } 


        /// 
        /// Raises the event. 
        /// 
        protected virtual void OnModeChanged(EventArgs e) { 
            EventHandler handler = (EventHandler)Events[EventModeChanged]; 
            if (handler != null) handler(this, e);
        } 


        /// 
        /// Raises the  event. 
        /// 
        protected virtual void OnModeChanging(FormViewModeEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            FormViewModeEventHandler handler = (FormViewModeEventHandler)Events[EventModeChanging]; 
            if (handler != null) {
                handler(this, e);
            } else {
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ModeChanging"));
                } 
            } 
        }
 
        private void OnPagerPropertyChanged(object sender, EventArgs e) {
            if (Initialized) {
                RequiresDataBinding = true;
            } 
        }
 
        private bool PageIsValidAfterModelException() { 
            if (_modelValidationGroup == null) {
                return true; 
            }
            Page.Validate(_modelValidationGroup);
            return Page.IsValid;
        } 

        protected internal override void PerformDataBinding(IEnumerable data) { 
            base.PerformDataBinding(data); 
            if (IsBoundUsingDataSourceID && Mode == FormViewMode.Edit && IsViewStateEnabled) {
                ExtractRowValues(BoundFieldValues, false/*includeKeys*/); 
            }
        }

 
        /// 
        ///  
        protected internal virtual void PrepareControlHierarchy() { 
            if (Controls.Count < 1) {
                return; 
            }

            Debug.Assert(Controls[0] is Table);
 
            Table childTable = (Table)Controls[0];
 
            childTable.CopyBaseAttributes(this); 
            if (ControlStyleCreated && !ControlStyle.IsEmpty) {
                childTable.ApplyStyle(ControlStyle); 
            } else {
                // Since we didn't create a ControlStyle yet, the default
                // settings for the default style of the control need to be applied
                // to the child table control directly 
                //
 
                childTable.GridLines = GridLines.None; 
                childTable.CellSpacing = 0;
            } 
            childTable.Caption = Caption;
            childTable.CaptionAlign = CaptionAlign;

 
            Style compositeStyle;
            TableRowCollection rows = childTable.Rows; 
 
            foreach (FormViewRow row in rows) {
                compositeStyle = new TableItemStyle(); 
                DataControlRowState rowState = row.RowState;
                DataControlRowType rowType = row.RowType;

                switch (rowType) { 
                    case DataControlRowType.Header:
                        compositeStyle = _headerStyle; 
                        break; 

                    case DataControlRowType.Footer: 
                        compositeStyle = _footerStyle;
                        break;

                    case DataControlRowType.DataRow: 
                        compositeStyle.CopyFrom(_rowStyle);
 
                        if ((rowState & DataControlRowState.Edit) != 0) { 
                            compositeStyle.CopyFrom(_editRowStyle);
                        } 
                        if ((rowState & DataControlRowState.Insert) != 0) {
                            if (_insertRowStyle != null) {
                                compositeStyle.CopyFrom(_insertRowStyle);
                            } else { 
                                compositeStyle.CopyFrom(_editRowStyle);
                            } 
                        } 
                        break;
 
                    case DataControlRowType.Pager:
                        compositeStyle = _pagerStyle;
                        break;
                    case DataControlRowType.EmptyDataRow: 
                        compositeStyle = _emptyDataRowStyle;
                        break; 
                } 

                if (compositeStyle != null && row.Visible) { 
                    row.MergeStyle(compositeStyle);
                }
            }
        } 

        protected virtual void RaisePostBackEvent(string eventArgument) { 
            ValidateEvent(UniqueID, eventArgument); 

            int separatorIndex = eventArgument.IndexOf('$'); 
            if (separatorIndex < 0) {
                return;
            }
 
            CommandEventArgs cea = new CommandEventArgs(eventArgument.Substring(0, separatorIndex), eventArgument.Substring(separatorIndex + 1));
 
            FormViewCommandEventArgs dvcea = new FormViewCommandEventArgs(this, cea); 
            HandleEvent(dvcea, false, String.Empty);
        } 

        /// 
        /// Displays the control on the client.
        ///  
        protected internal override void Render(HtmlTextWriter writer) {
            if (Page != null) { 
                Page.VerifyRenderingInServerForm(this); 
            }
 
            if (RenderOuterTable) {
                PrepareControlHierarchy();
                RenderContents(writer);
            } else { 
                string propertyName = ModifiedOuterTableStylePropertyName();
                if (!string.IsNullOrEmpty(propertyName)) { 
                    throw new InvalidOperationException(SR.GetString(SR.IRenderOuterTableControl_CannotSetStyleWhenDisableRenderOuterTable, 
                        propertyName, GetType().Name, ID));
                } 

                if (Controls.Count > 0) {
                    //render the children of the inner table
                    Controls[0].RenderChildren(writer); 
                }
            } 
        } 

        private void ResetModelValidationGroup(bool causesValidation, string validationGroup) { 
            _modelValidationGroup = null;
            if (causesValidation && Page != null) {
                Page.Validate(validationGroup);
                if (EnableModelValidation) { 
                    _modelValidationGroup = validationGroup;
                } 
            } 
        }
 
        /// 
        /// Saves the control state for those properties that should persist across postbacks
        ///   even when EnableViewState=false.
        ///  
        protected internal override object SaveControlState() {
            object baseState = base.SaveControlState(); 
            if (baseState != null || 
                _pageIndex != 0 ||
                _mode != _defaultMode || 
                _defaultMode != FormViewMode.ReadOnly ||
                (_dataKeyNames != null && _dataKeyNames.Length > 0) ||
                (_keyTable != null && _keyTable.Count > 0) ||
                _pageCount != 0) { 
                object[] state = new object[7];
                object pageIndexState = null; 
                object modeState = null; 
                object defaultModeState = null;
                object keyNamesState = null; 
                object keyTableState = null;
                object pageCountState = null;

                if (_pageIndex != 0) { 
                    pageIndexState = _pageIndex;
                } 
                if (_defaultMode != FormViewMode.ReadOnly) { 
                    defaultModeState = (int)_defaultMode;
                } 
                // Only save the mode if it's different from the DefaultMode.  Otherwise, the Mode
                // getter will restore it to the DefaultMode value.
                if (_mode != _defaultMode && _modeSet) {
                    modeState = (int)_mode; 
                }
 
                if (_dataKeyNames != null && _dataKeyNames.Length > 0) { 
                    keyNamesState = _dataKeyNames;
                } 

                if (_keyTable != null) {
                    keyTableState = OrderedDictionaryStateHelper.SaveViewState(_keyTable);
                } 

                if (_pageCount != 0) { 
                    pageCountState = _pageCount; 
                }
 
                state[0] = baseState;
                state[1] = pageIndexState;
                state[2] = defaultModeState;
                state[3] = modeState; 
                state[4] = keyNamesState;
                state[5] = keyTableState; 
                state[6] = pageCountState; 

                return state; 
            }
            return true;    // return a dummy that ensures LoadControlState gets called but minimizes persisted size.
        }
 

        ///  
        /// Saves the current state of the . 
        /// 
        protected override object SaveViewState() { 
            object baseState = base.SaveViewState();
            object pagerStyleState = (_pagerStyle != null) ? ((IStateManager)_pagerStyle).SaveViewState() : null;
            object headerStyleState = (_headerStyle != null) ? ((IStateManager)_headerStyle).SaveViewState() : null;
            object footerStyleState = (_footerStyle != null) ? ((IStateManager)_footerStyle).SaveViewState() : null; 
            object rowStyleState = (_rowStyle != null) ? ((IStateManager)_rowStyle).SaveViewState() : null;
            object editRowStyleState = (_editRowStyle != null) ? ((IStateManager)_editRowStyle).SaveViewState() : null; 
            object insertRowStyleState = (_insertRowStyle != null) ? ((IStateManager)_insertRowStyle).SaveViewState() : null; 
            object boundFieldValuesState = (_boundFieldValues != null) ? OrderedDictionaryStateHelper.SaveViewState(_boundFieldValues) : null;
            object pagerSettingsState = (_pagerSettings != null) ? ((IStateManager)_pagerSettings).SaveViewState() : null; 
            object controlState = ControlStyleCreated ? ((IStateManager)ControlStyle).SaveViewState() : null;

            object[] myState = new object[10];
            myState[0] = baseState; 
            myState[1] = pagerStyleState;
            myState[2] = headerStyleState; 
            myState[3] = footerStyleState; 
            myState[4] = rowStyleState;
            myState[5] = editRowStyleState; 
            myState[6] = insertRowStyleState;
            myState[7] = boundFieldValuesState;
            myState[8] = pagerSettingsState;
            myState[9] = controlState; 

            // note that we always have some state, atleast the RowCount 
            return myState; 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
          Justification = "A property already exists. This method does additional work.")]
        public void SetPageIndex(int index) {
            HandlePage(index); 
        }
 
        private void SelectCallback(IEnumerable data) { 
            // The data source should have thrown.  If we're here, it didn't.  We'll throw for it
            // with a generic message. 
            throw new HttpException(SR.GetString(SR.DataBoundControl_DataSourceDoesntSupportPaging));
        }

        ///  
        /// Marks the starting point to begin tracking and saving changes to the
        /// control as part of the control viewstate. 
        ///  
        protected override void TrackViewState() {
            base.TrackViewState(); 

            if (_pagerStyle != null)
                ((IStateManager)_pagerStyle).TrackViewState();
            if (_headerStyle != null) 
                ((IStateManager)_headerStyle).TrackViewState();
            if (_footerStyle != null) 
                ((IStateManager)_footerStyle).TrackViewState(); 
            if (_rowStyle != null)
                ((IStateManager)_rowStyle).TrackViewState(); 
            if (_editRowStyle != null)
                ((IStateManager)_editRowStyle).TrackViewState();
            if (_insertRowStyle != null)
                ((IStateManager)_insertRowStyle).TrackViewState(); 
            if (_pagerSettings != null)
                ((IStateManager)_pagerSettings).TrackViewState(); 
            if (ControlStyleCreated) 
                ((IStateManager)ControlStyle).TrackViewState();
        } 

        public virtual void UpdateItem(bool causesValidation) {
            ResetModelValidationGroup(causesValidation, String.Empty);
            HandleUpdate(String.Empty, causesValidation); 
        }
 
        #region IPostBackContainer implementation 
        PostBackOptions IPostBackContainer.GetPostBackOptions(IButtonControl buttonControl) {
            if (buttonControl == null) { 
                throw new ArgumentNullException("buttonControl");
            }

            if (buttonControl.CausesValidation) { 
                throw new InvalidOperationException(SR.GetString(SR.CannotUseParentPostBackWhenValidating, this.GetType().Name, ID));
            } 
 
            PostBackOptions options = new PostBackOptions(this, buttonControl.CommandName + "$" + buttonControl.CommandArgument);
            options.RequiresJavaScriptProtocol = true; 

            return options;
        }
        #endregion 

        #region IPostBackEventHandler implementation 
        void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) { 
            RaisePostBackEvent(eventArgument);
        } 
        #endregion

        #region IDataItemContainer implementation
        int IDataItemContainer.DataItemIndex { 
            get {
                return DataItemIndex; 
            } 
        }
 
        int IDataItemContainer.DisplayIndex {
            get {
                return 0;
            } 
        }
        #endregion 
 
        #region IDataBoundItemControl implementation
 
        DataKey IDataBoundItemControl.DataKey {
            get {
                return DataKey;
            } 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", 
            Justification = "The property is only used to genericly access the databound control's mode, and should only be accessed through the interface")]
        DataBoundControlMode IDataBoundItemControl.Mode { 
            get {
                switch (Mode) {
                    case FormViewMode.Edit:
                        return DataBoundControlMode.Edit; 
                    case FormViewMode.Insert:
                        return DataBoundControlMode.Insert; 
                    case FormViewMode.ReadOnly: 
                        return DataBoundControlMode.ReadOnly;
                    default: 
                        Debug.Fail("shouldn't get here!");
                        return DataBoundControlMode.ReadOnly;
                }
            } 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")] 
        string IDataBoundControl.DataSourceID {
            get { 
                return DataSourceID;
            }
            set {
                DataSourceID = value; 
            }
        } 
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")]
        IDataSource IDataBoundControl.DataSourceObject { 
            get {
                return DataSourceObject;
            }
        } 

        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")] 
        object IDataBoundControl.DataSource { 
            get {
                return DataSource; 
            }
            set {
                DataSource = value;
            } 
        }
 
        string[] IDataBoundControl.DataKeyNames { 
            get {
                return DataKeyNames; 
            }
            set {
                DataKeyNames = value;
            } 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")] 
        string IDataBoundControl.DataMember {
            get { 
                return DataMember;
            }
            set {
                DataMember = value; 
            }
        } 
 
        #endregion
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.Collections; 
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Drawing; 
    using System.Drawing.Design;
    using System.Globalization; 
    using System.Web.UI.WebControls.Adapters; 
    using System.Web.Util;
 
    /// 
    ///    
    ///       Displays a data record from a data source in a table layout. The data source
    ///       is any object that implements IEnumerable or IListSource, which includes ADO.NET data, 
    ///       arrays, ArrayLists, DataSourceControl, etc.
    ///     
    ///  
    [
    Designer("System.Web.UI.Design.WebControls.FormViewDesigner, " + AssemblyRef.SystemDesign), 
    ControlValueProperty("SelectedValue"),
    DefaultEvent("PageIndexChanging"),
    SupportsEventValidation
    ] 
    [DataKeyProperty("DataKey")]
    public class FormView : CompositeDataBoundControl, IDataItemContainer, IPostBackEventHandler, 
                            IPostBackContainer, IDataBoundItemControl, IRenderOuterTableControl { 

        private static readonly object EventPageIndexChanged = new object(); 
        private static readonly object EventPageIndexChanging = new object();
        private static readonly object EventItemCommand = new object();
        private static readonly object EventItemCreated = new object();
        private static readonly object EventItemDeleted = new object(); 
        private static readonly object EventItemDeleting = new object();
        private static readonly object EventItemInserting = new object(); 
        private static readonly object EventItemInserted = new object(); 
        private static readonly object EventItemUpdating = new object();
        private static readonly object EventItemUpdated = new object(); 
        private static readonly object EventModeChanged = new object();
        private static readonly object EventModeChanging = new object();

        private ITemplate _itemTemplate; 
        private ITemplate _editItemTemplate;
        private ITemplate _insertItemTemplate; 
        private ITemplate _headerTemplate; 
        private ITemplate _footerTemplate;
        private ITemplate _pagerTemplate; 
        private ITemplate _emptyDataTemplate;

        private TableItemStyle _rowStyle;
        private TableItemStyle _headerStyle; 
        private TableItemStyle _footerStyle;
        private TableItemStyle _editRowStyle; 
        private TableItemStyle _insertRowStyle; 
        private TableItemStyle _emptyDataRowStyle;
 
        private FormViewRow _bottomPagerRow;
        private FormViewRow _footerRow;
        private FormViewRow _headerRow;
        private FormViewRow _topPagerRow; 
        private FormViewRow _row;
 
        private TableItemStyle _pagerStyle; 
        private PagerSettings _pagerSettings;
 
        private int _pageCount;
        private object _dataItem;
        private int _dataItemIndex;
        private OrderedDictionary _boundFieldValues; 
        private DataKey _dataKey;
        private OrderedDictionary _keyTable; 
        private string[] _dataKeyNames; 

        private int _pageIndex; 
        private FormViewMode _defaultMode = FormViewMode.ReadOnly;
        private FormViewMode _mode;
        private bool _modeSet;
        private bool _useServerPaging; 
        private string _modelValidationGroup;
 
        private IOrderedDictionary _deleteKeys; 
        private IOrderedDictionary _deleteValues;
        private IOrderedDictionary _insertValues; 
        private IOrderedDictionary _updateKeys;
        private IOrderedDictionary _updateOldValues;
        private IOrderedDictionary _updateNewValues;
 

 
        ///  
        /// Gets or sets a value that indicates whether paging is allowed.
        ///  
        [
        WebCategory("Paging"),
        DefaultValue(false),
        WebSysDescription(SR.FormView_AllowPaging) 
        ]
        public virtual bool AllowPaging { 
            get { 
                object o = ViewState["AllowPaging"];
                if (o != null) 
                    return (bool)o;
                return false;
            }
            set { 
                bool oldValue = AllowPaging;
                if (value != oldValue) { 
                    ViewState["AllowPaging"] = value; 
                    if (Initialized) {
                        RequiresDataBinding = true; 
                    }
                }
            }
        } 

        ///  
        /// Gets or sets the URL of an image to display in the 
        /// background of the .
        ///  
        [
        WebCategory("Appearance"),
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)), 
        UrlProperty(),
        WebSysDescription(SR.WebControl_BackImageUrl) 
        ] 
        public virtual string BackImageUrl {
            get { 
                if (ControlStyleCreated == false) {
                    return String.Empty;
                }
                return ((TableStyle)ControlStyle).BackImageUrl; 
            }
            set { 
                ((TableStyle)ControlStyle).BackImageUrl = value; 
            }
        } 


        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ] 
        public virtual FormViewRow BottomPagerRow { 
            get {
                if (_bottomPagerRow == null) { 
                    EnsureChildControls();
                }
                return _bottomPagerRow;
            } 
        }
 
        private IOrderedDictionary BoundFieldValues { 
            get {
                if (_boundFieldValues == null) { 
                    int capacity = 25;
                    _boundFieldValues = new OrderedDictionary(capacity);
                }
                return _boundFieldValues; 
            }
        } 
 

        [ 
        Localizable(true),
        DefaultValue(""),
        WebCategory("Accessibility"),
        WebSysDescription(SR.DataControls_Caption) 
        ]
        public virtual string Caption { 
            get { 
                string s = (string)ViewState["Caption"];
                return (s != null) ? s : String.Empty; 
            }
            set {
                ViewState["Caption"] = value;
            } 
        }
 
 
        [
        DefaultValue(TableCaptionAlign.NotSet), 
        WebCategory("Accessibility"),
        WebSysDescription(SR.WebControl_CaptionAlign)
        ]
        public virtual TableCaptionAlign CaptionAlign { 
            get {
                object o = ViewState["CaptionAlign"]; 
                return (o != null) ? (TableCaptionAlign)o : TableCaptionAlign.NotSet; 
            }
            set { 
                if ((value < TableCaptionAlign.NotSet) ||
                    (value > TableCaptionAlign.Right)) {
                    throw new ArgumentOutOfRangeException("value");
                } 
                ViewState["CaptionAlign"] = value;
            } 
        } 

 

        /// 
        /// Indicates the amount of space between cells.
        ///  
        [
        WebCategory("Layout"), 
        DefaultValue(-1), 
        WebSysDescription(SR.FormView_CellPadding)
        ] 
        public virtual int CellPadding {
            get {
                if (ControlStyleCreated == false) {
                    return -1; 
                }
                return ((TableStyle)ControlStyle).CellPadding; 
            } 
            set {
                ((TableStyle)ControlStyle).CellPadding = value; 
            }
        }

 
        /// 
        /// Gets or sets the amount of space between the contents of 
        /// a cell and the cell's border. 
        /// 
        [ 
        WebCategory("Layout"),
        DefaultValue(0),
        WebSysDescription(SR.FormView_CellSpacing)
        ] 
        public virtual int CellSpacing {
            get { 
                if (ControlStyleCreated == false) { 
                    return 0;
                } 
                return ((TableStyle)ControlStyle).CellSpacing;
            }
            set {
                ((TableStyle)ControlStyle).CellSpacing = value; 
            }
        } 
 

        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public FormViewMode CurrentMode { 
            get {
                return Mode; 
            } 
        }
 
        // implement this publicly so DataBinder.Eval(container.DataItem, "x") still works.
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public virtual object DataItem { 
            get { 
                if (CurrentMode == FormViewMode.Insert) {
                    return null; 
                }
                return _dataItem;
            }
        } 

        [ 
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ] 
        public int DataItemCount {
            get {
                return PageCount;
            } 
        }
 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public virtual int DataItemIndex {
            get {
                if (CurrentMode == FormViewMode.Insert) { 
                    return -1;
                } 
                return _dataItemIndex; 
            }
        } 


        [
        DefaultValue(null), 
        Editor("System.Web.UI.Design.WebControls.DataFieldEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        TypeConverterAttribute(typeof(StringArrayConverter)), 
        WebCategory("Data"), 
        WebSysDescription(SR.DataControls_DataKeyNames)
        ] 
        public virtual string[] DataKeyNames {
            get {
                object o = _dataKeyNames;
                if (o != null) { 
                    return (string[])((string[])o).Clone();
                } 
                return new string[0]; 
            }
            set { 
                if (!DataBoundControlHelper.CompareStringArrays(value, DataKeyNamesInternal)) {
                    if (value != null) {
                        _dataKeyNames = (string[])value.Clone();
                    } else { 
                        _dataKeyNames = null;
                    } 
 
                    _keyTable = null;
                    if (Initialized) { 
                        RequiresDataBinding = true;
                    }
                }
            } 
        }
 
        // This version doesn't clone the array 
        private string[] DataKeyNamesInternal {
            get { 
                object o = _dataKeyNames;
                if (o != null) {
                    return (string[])o;
                } 
                return new string[0];
            } 
        } 

 
        /// 
        /// 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.FormView_DataKey) 
        ] 
        public virtual DataKey DataKey {
            get { 
                if (_dataKey == null) {
                    _dataKey = new DataKey(KeyTable);
                }
                return _dataKey; 
            }
        } 
 

        [ 
        WebCategory("Behavior"),
        DefaultValue(FormViewMode.ReadOnly),
        WebSysDescription(SR.View_DefaultMode)
        ] 
        public virtual FormViewMode DefaultMode {
            get { 
                return _defaultMode; 
            }
            set { 
                if (value < FormViewMode.ReadOnly || value > FormViewMode.Insert) {
                    throw new ArgumentOutOfRangeException("value");
                }
                _defaultMode = value; 
            }
        } 
 

        ///  
        /// Indicates the template to use for an item set in edit mode within the FormView.
        /// This template is also used for Insert if no InsertItemTemplate is defined.
        /// 
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
        WebSysDescription(SR.FormView_EditItemTemplate) 
        ]
        public virtual ITemplate EditItemTemplate {
            get {
                return _editItemTemplate; 
            }
            set { 
                _editItemTemplate = value; 
            }
        } 


        /// 
        /// Indicates the style properties of each row when in edit mode. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.View_EditRowStyle)
        ] 
        public TableItemStyle EditRowStyle {
            get { 
                if (_editRowStyle == null) { 
                    _editRowStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)_editRowStyle).TrackViewState();
                }
                return _editRowStyle;
            } 
        }
 
 
        /// 
        /// Indicates the style properties of null rows. 
        /// 
        [
        WebCategory("Styles"),
        DefaultValue(null), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.View_EmptyDataRowStyle)
        ] 
        public TableItemStyle EmptyDataRowStyle {
            get {
                if (_emptyDataRowStyle == null) {
                    _emptyDataRowStyle = new TableItemStyle(); 
                    if (IsTrackingViewState)
                        ((IStateManager)_emptyDataRowStyle).TrackViewState(); 
                } 
                return _emptyDataRowStyle;
            } 
        }


        ///  
        /// Indicates the template to use when no records are returned from the datasource within the FormView.
        ///  
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)),
        WebSysDescription(SR.View_EmptyDataTemplate)
        ] 
        public virtual ITemplate EmptyDataTemplate {
            get { 
                return _emptyDataTemplate; 
            }
            set { 
                _emptyDataTemplate = value;
            }
        }
 

        ///  
        /// The header text displayed if no EmptyDataTemplate is defined. 
        /// 
        [ 
        Localizable(true),
        WebCategory("Appearance"),
        DefaultValue(""),
        WebSysDescription(SR.View_EmptyDataText), 
        ]
        public virtual String EmptyDataText { 
            get { 
                object o = ViewState["EmptyDataText"];
                if (o != null) { 
                    return (string)o;
                }
                return String.Empty;
            } 
            set {
                ViewState["EmptyDataText"] = value; 
            } 
        }
 
        [
        WebCategory("Behavior"),
        DefaultValue(true),
        WebSysDescription(SR.DataBoundControl_EnableModelValidation) 
        ]
        public virtual bool EnableModelValidation { 
            get { 
                object o = ViewState["EnableModelValidation"];
                if (o != null) { 
                    return (bool)o;
                }
                return true;
            } 
            set {
                ViewState["EnableModelValidation"] = value; 
            } 
        }
 
        [
        WebCategory("Layout"),
        DefaultValue(true),
        WebSysDescription(SR.FormView_RenderOuterTable), 
        SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
            Justification = "Interface denotes existence of property, not used for security.") 
        ] 
        public virtual bool RenderOuterTable {
            get { 
                object o = ViewState["RenderOuterTable"];
                return (o != null) ? (bool)o : true;
            }
            set { 
                ViewState["RenderOuterTable"] = value;
            } 
        } 

        private int FirstDisplayedPageIndex { 
            get {
                object o = ViewState["FirstDisplayedPageIndex"];
                if (o != null) {
                    return (int)o; 
                }
                return -1; 
            } 
            set {
                ViewState["FirstDisplayedPageIndex"] = value; 
            }
        }

 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        ]
        public virtual FormViewRow FooterRow { 
            get {
                if (_footerRow == null) {
                    EnsureChildControls();
                } 
                return _footerRow;
            } 
        } 

 
        /// 
        /// Indicates the style properties of the footer row.
        /// 
        [ 
        WebCategory("Styles"),
        DefaultValue(null), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.FormView_FooterStyle)
        ]
        public TableItemStyle FooterStyle {
            get { 
                if (_footerStyle == null) {
                    _footerStyle = new TableItemStyle(); 
                    if (IsTrackingViewState) 
                        ((IStateManager)_footerStyle).TrackViewState();
                } 
                return _footerStyle;
            }
        }
 

        ///  
        /// Indicates the template to use for a footer item within the FormView. 
        /// 
        [ 
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)), 
        WebSysDescription(SR.FormView_FooterTemplate)
        ] 
        public virtual ITemplate FooterTemplate { 
            get {
                return _footerTemplate; 
            }
            set {
                _footerTemplate = value;
            } 
        }
 
 
        /// 
        /// The header text displayed if no FooterTemplate is defined. 
        /// 
        [
        Localizable(true),
        WebCategory("Appearance"), 
        DefaultValue(""),
        WebSysDescription(SR.View_FooterText), 
        ] 
        public virtual String FooterText {
            get { 
                object o = ViewState["FooterText"];
                if (o != null) {
                    return (string)o;
                } 
                return String.Empty;
            } 
            set { 
                ViewState["FooterText"] = value;
            } 
        }


        ///  
        /// Gets or sets a value that specifies the grid line style.
        ///  
        [ 
        WebCategory("Appearance"),
        DefaultValue(GridLines.None), 
        WebSysDescription(SR.DataControls_GridLines)
        ]
        public virtual GridLines GridLines {
            get { 
                if (ControlStyleCreated == false) {
                    return GridLines.None; 
                } 
                return ((TableStyle)ControlStyle).GridLines;
            } 
            set {
                ((TableStyle)ControlStyle).GridLines = value;
            }
        } 

 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        ]
        public virtual FormViewRow HeaderRow {
            get {
                if (_headerRow == null) { 
                    EnsureChildControls();
                } 
                return _headerRow; 
            }
        } 


        /// 
        /// Indicates the style properties of the header row. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.WebControl_HeaderStyle)
        ] 
        public TableItemStyle HeaderStyle {
            get { 
                if (_headerStyle == null) { 
                    _headerStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)_headerStyle).TrackViewState();
                }
                return _headerStyle;
            } 
        }
 
 
        /// 
        /// Indicates the template to use for a header item within the FormView. 
        /// 
        [
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)), 
        WebSysDescription(SR.WebControl_HeaderTemplate) 
        ]
        public virtual ITemplate HeaderTemplate { 
            get {
                return _headerTemplate;
            }
            set { 
                _headerTemplate = value;
            } 
        } 

 
        /// 
        /// The header text displayed if no HeaderTemplate is defined.
        /// 
        [ 
        Localizable(true),
        WebCategory("Appearance"), 
        DefaultValue(""), 
        WebSysDescription(SR.View_HeaderText),
        ] 
        public virtual String HeaderText {
            get {
                object o = ViewState["HeaderText"];
                if (o != null) { 
                    return (string)o;
                } 
                return String.Empty; 
            }
            set { 
                ViewState["HeaderText"] = value;
            }
        }
 

        ///  
        /// Gets or sets a value that specifies the alignment of a rows with respect 
        /// surrounding text.
        ///  
        [
        Category("Layout"),
        DefaultValue(HorizontalAlign.NotSet),
        WebSysDescription(SR.WebControl_HorizontalAlign) 
        ]
        public virtual HorizontalAlign HorizontalAlign { 
            get { 
                if (ControlStyleCreated == false) {
                    return HorizontalAlign.NotSet; 
                }
                return ((TableStyle)ControlStyle).HorizontalAlign;
            }
            set { 
                ((TableStyle)ControlStyle).HorizontalAlign = value;
            } 
        } 

 
        /// 
        /// Indicates the template to use for an item set in insert mode within the FormView.
        /// 
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
        WebSysDescription(SR.FormView_InsertItemTemplate) 
        ]
        public virtual ITemplate InsertItemTemplate {
            get {
                return _insertItemTemplate; 
            }
            set { 
                _insertItemTemplate = value; 
            }
        } 


        /// 
        /// Indicates the style properties of each row when in insert mode. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.View_InsertRowStyle)
        ] 
        public TableItemStyle InsertRowStyle {
            get { 
                if (_insertRowStyle == null) { 
                    _insertRowStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)_insertRowStyle).TrackViewState();
                }
                return _insertRowStyle;
            } 
        }
 
 
        /// 
        /// Indicates the template to use for an item within the FormView. 
        /// 
        [
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView), BindingDirection.TwoWay), 
        WebSysDescription(SR.View_InsertRowStyle) 
        ]
        public virtual ITemplate ItemTemplate { 
            get {
                return _itemTemplate;
            }
            set { 
                _itemTemplate = value;
            } 
        } 

        private OrderedDictionary KeyTable { 
            get {
                if (_keyTable == null) {
                    _keyTable = new OrderedDictionary(DataKeyNamesInternal.Length);
                } 
                return _keyTable;
            } 
        } 

 
        private FormViewMode Mode {
            get {
                // if the mode wasn't explicitly set by LoadControlState or by the user, the mode is the DefaultMode.
                if (!_modeSet || DesignMode) { 
                    _mode = DefaultMode;
                    _modeSet = true; 
                } 
                return _mode;
            } 
            set {
                if (value < FormViewMode.ReadOnly || value > FormViewMode.Insert) {
                    throw new ArgumentOutOfRangeException("value");
                } 

                _modeSet = true; 
                if (_mode != value) { 
                    _mode = value;
                    if (Initialized) { 
                        RequiresDataBinding = true;
                    }
                }
            } 
        }
 
 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual int PageCount {
            get { 
                return _pageCount;
            } 
        } 

        ///  
        ///    Gets or sets the index of the currently displayed record.
        ///     This property echos the public one so that we can set PageIndex to -1
        ///     internally when we switch to insert mode, but users should never do that.
        ///  
        private int PageIndexInternal {
            get { 
                return _pageIndex; 
            }
            set { 
                int currentPageIndex = PageIndexInternal;
                if (value != currentPageIndex) {
                    _pageIndex = value;
                    if (Initialized) { 
                        RequiresDataBinding = true;
                    } 
                } 
            }
        } 


        /// 
        /// Gets or sets the index of the currently displayed record. 
        /// 
        [ 
        Bindable(true), 
        DefaultValue(0),
        WebCategory("Data"), 
        WebSysDescription(SR.FormView_PageIndex)
        ]
        public virtual int PageIndex {
            get { 
                // if we're in design mode, we don't want a change to the mode to set the PageIndex to -1.
                if (Mode == FormViewMode.Insert && !DesignMode) { 
                    return -1; 
                }
                return PageIndexInternal; 
            }
            set {
                // since we don't know at property set time how many DataItems we'll have,
                // don't throw if we're above PageCount 
                if (value < -1) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                if (value >= 0) {
                    PageIndexInternal = value; 
                }
            }
        }
 

        ///  
        /// Gets the settings of the pager buttons for the 
        /// . This
        /// property is read-only. 
        /// 
        [
        WebCategory("Paging"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.GridView_PagerSettings) 
        ]
        public virtual PagerSettings PagerSettings { 
            get {
                if (_pagerSettings == null) {
                    _pagerSettings = new PagerSettings();
                    if (IsTrackingViewState) { 
                        ((IStateManager)_pagerSettings).TrackViewState();
                    } 
                    _pagerSettings.PropertyChanged += new EventHandler(OnPagerPropertyChanged); 
                }
                return _pagerSettings; 
            }
        }

 
        /// 
        /// Gets the style properties of the pager rows for the 
        /// . This 
        /// property is read-only.
        ///  
        [
        WebCategory("Styles"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.WebControl_PagerStyle) 
        ] 
        public TableItemStyle PagerStyle {
            get { 
                if (_pagerStyle == null) {
                    _pagerStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_pagerStyle).TrackViewState(); 
                }
                return _pagerStyle; 
            } 
        }
 

        /// 
        /// Indicates the template to use for a pager item within the FormView.
        ///  
        [
        Browsable(false), 
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(FormView)), 
        WebSysDescription(SR.View_PagerTemplate)
        ]
        public virtual ITemplate PagerTemplate {
            get { 
                return _pagerTemplate;
            } 
            set { 
                _pagerTemplate = value;
            } 
        }


        ///  
        /// Gets a collection of  objects representing the individual
        /// rows within the control. 
        /// This property is read-only. 
        /// 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.FormView_Rows)
        ] 
        public virtual FormViewRow Row {
            get { 
                if (_row == null) { 
                    EnsureChildControls();
                } 
                return _row;
            }
        }
 

        ///  
        /// Indicates the style properties of each row. 
        /// 
        [ 
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.View_RowStyle) 
        ] 
        public TableItemStyle RowStyle {
            get { 
                if (_rowStyle == null) {
                    _rowStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_rowStyle).TrackViewState(); 
                }
                return _rowStyle; 
            } 
        }
 

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public object SelectedValue { 
            get { 
                return DataKey.Value;
            } 
        }

        protected override HtmlTextWriterTag TagKey {
            get { 
                return HtmlTextWriterTag.Table;
            } 
        } 

 
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ] 
        public virtual FormViewRow TopPagerRow {
            get { 
                if (_topPagerRow == null) { 
                    EnsureChildControls();
                } 
                return _topPagerRow;
            }
        }
 

        ///  
        /// Occurs when the FormView PageIndex has been changed. 
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.FormView_OnPageIndexChanged)
        ]
        public event EventHandler PageIndexChanged { 
            add {
                Events.AddHandler(EventPageIndexChanged, value); 
            } 
            remove {
                Events.RemoveHandler(EventPageIndexChanged, value); 
            }
        }

 
        /// 
        /// Occurs when the FormView PageIndex is changing. 
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.FormView_OnPageIndexChanging)
        ]
        public event FormViewPageEventHandler PageIndexChanging {
            add { 
                Events.AddHandler(EventPageIndexChanging, value);
            } 
            remove { 
                Events.RemoveHandler(EventPageIndexChanging, value);
            } 
        }


        ///  
        /// Occurs when a command is issued from the FormView.
        ///  
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.FormView_OnItemCommand) 
        ]
        public event FormViewCommandEventHandler ItemCommand {
            add {
                Events.AddHandler(EventItemCommand, value); 
            }
            remove { 
                Events.RemoveHandler(EventItemCommand, value); 
            }
        } 


        /// 
        /// Occurs when a row is created. 
        /// 
        [ 
        WebCategory("Behavior"), 
        WebSysDescription(SR.FormView_OnItemCreated)
        ] 
        public event EventHandler ItemCreated {
            add {
                Events.AddHandler(EventItemCreated, value);
            } 
            remove {
                Events.RemoveHandler(EventItemCreated, value); 
            } 
        }
 

        /// 
        /// Occurs when the FormView item has been deleted.
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataControls_OnItemDeleted) 
        ]
        public event FormViewDeletedEventHandler ItemDeleted { 
            add {
                Events.AddHandler(EventItemDeleted, value);
            }
            remove { 
                Events.RemoveHandler(EventItemDeleted, value);
            } 
        } 

 
        /// 
        /// Occurs when the FormView item is being deleted.
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemDeleting) 
        ] 
        public event FormViewDeleteEventHandler ItemDeleting {
            add { 
                Events.AddHandler(EventItemDeleting, value);
            }
            remove {
                Events.RemoveHandler(EventItemDeleting, value); 
            }
        } 
 

        ///  
        /// Occurs when the FormView item has been inserted.
        /// 
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataControls_OnItemInserted)
        ] 
        public event FormViewInsertedEventHandler ItemInserted { 
            add {
                Events.AddHandler(EventItemInserted, value); 
            }
            remove {
                Events.RemoveHandler(EventItemInserted, value);
            } 
        }
 
 
        /// 
        /// Occurs when the FormView item is being inserted. 
        /// 
        [
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemInserting) 
        ]
        public event FormViewInsertEventHandler ItemInserting { 
            add { 
                Events.AddHandler(EventItemInserting, value);
            } 
            remove {
                Events.RemoveHandler(EventItemInserting, value);
            }
        } 

 
        ///  
        /// Occurs when the FormView item has been updated.
        ///  
        [
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemUpdated)
        ] 
        public event FormViewUpdatedEventHandler ItemUpdated {
            add { 
                Events.AddHandler(EventItemUpdated, value); 
            }
            remove { 
                Events.RemoveHandler(EventItemUpdated, value);
            }
        }
 

        ///  
        /// Occurs when the FormView item is being updated. 
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.DataControls_OnItemUpdating)
        ]
        public event FormViewUpdateEventHandler ItemUpdating { 
            add {
                Events.AddHandler(EventItemUpdating, value); 
            } 
            remove {
                Events.RemoveHandler(EventItemUpdating, value); 
            }
        }

 
        /// 
        /// Occurs when the ViewMode has changed. 
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.FormView_OnModeChanged)
        ]
        public event EventHandler ModeChanged {
            add { 
                Events.AddHandler(EventModeChanged, value);
            } 
            remove { 
                Events.RemoveHandler(EventModeChanged, value);
            } 
        }


        ///  
        /// Occurs when the ViewMode is changing.
        ///  
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.FormView_OnModeChanging) 
        ]
        public event FormViewModeEventHandler ModeChanging {
            add {
                Events.AddHandler(EventModeChanging, value); 
            }
            remove { 
                Events.RemoveHandler(EventModeChanging, value); 
            }
        } 


        public void ChangeMode(FormViewMode newMode) {
            Mode = newMode; 
        }
 
 
        /// 
        /// Creates the control hierarchy that is used to render the FormView. 
        /// This is called whenever a control hierarchy is needed and the
        /// ChildControlsCreated property is false.
        /// The implementation assumes that all the children in the controls
        /// collection have already been cleared. 
        /// 
        protected override int CreateChildControls(IEnumerable dataSource, bool dataBinding) { 
            PagedDataSource pagedDataSource = null; 
            int itemIndex = PageIndex;
            bool allowPaging = AllowPaging; 
            int itemCount = 0;
            FormViewMode mode = Mode;

            // if we're in design mode, PageIndex doesn't return -1 
            if (DesignMode && mode == FormViewMode.Insert) {
                itemIndex = -1; 
            } 

            if (dataBinding) { 
                DataSourceView view = GetData();
                DataSourceSelectArguments arguments = SelectArguments;

                if (view == null) { 
                    throw new HttpException(SR.GetString(SR.DataBoundControl_NullView, ID));
                } 
 
                if (mode != FormViewMode.Insert) {
                    if (allowPaging && !view.CanPage) { 
                        if (dataSource != null && !(dataSource is ICollection)) {
                            arguments.StartRowIndex = itemIndex;
                            arguments.MaximumRows = 1;
                            // This should throw an exception saying the data source can't page. 
                            // We do this because the data source can provide a better error message than we can.
                            view.Select(arguments, SelectCallback); 
                        } 
                    }
 
                    if (_useServerPaging) {
                        if (view.CanRetrieveTotalRowCount) {
                            pagedDataSource = CreateServerPagedDataSource(arguments.TotalRowCount);
                        } else { 
                            ICollection dataSourceCollection = dataSource as ICollection;
                            if (dataSourceCollection == null) { 
                                throw new HttpException(SR.GetString(SR.DataBoundControl_NeedICollectionOrTotalRowCount, GetType().Name)); 
                            }
 
                            pagedDataSource = CreateServerPagedDataSource(checked(PageIndex + dataSourceCollection.Count));
                        }
                    } else {
                        pagedDataSource = CreatePagedDataSource(); 
                    }
                } 
            } else { 
                pagedDataSource = CreatePagedDataSource();
            } 

            if (mode != FormViewMode.Insert) {
                pagedDataSource.DataSource = dataSource;
            } 

            IEnumerator dataSourceEnumerator = null; 
            OrderedDictionary keyTable = KeyTable; 

            if (dataBinding == false) { 
                dataSourceEnumerator = dataSource.GetEnumerator();

                ICollection collection = dataSource as ICollection;
                if (collection == null) { 
                    throw new HttpException(SR.GetString(SR.DataControls_DataSourceMustBeCollectionWhenNotDataBinding));
                } 
                itemCount = collection.Count; 
            } else {
                keyTable.Clear(); 
                if (dataSource != null) {
                    if (mode != FormViewMode.Insert) {
                        ICollection collection = dataSource as ICollection;
                        if ((collection == null) && (pagedDataSource.IsPagingEnabled && !pagedDataSource.IsServerPagingEnabled)) { 
                            throw new HttpException(SR.GetString(SR.FormView_DataSourceMustBeCollection, ID));
                        } 
 
                        if (pagedDataSource.IsPagingEnabled) {
                            itemCount = pagedDataSource.DataSourceCount; 
                        } else if (collection != null) {
                            itemCount = collection.Count;
                        }
                    } 
                    dataSourceEnumerator = dataSource.GetEnumerator();
                } 
            } 

            Table table = CreateTable(); 
            TableRowCollection rows = table.Rows;
            bool moveNextSucceeded = false;
            object lastItem = null;
 
            Controls.Add(table);
 
            if (dataSourceEnumerator != null) { 
                moveNextSucceeded = dataSourceEnumerator.MoveNext();    // goto the first item
            } 

            // if there are no items, only add the tablerow if there's a null template or null text
            if (!moveNextSucceeded && mode != FormViewMode.Insert) {
                if (EmptyDataText.Length > 0 || _emptyDataTemplate != null) { 
                    _row = CreateRow(0, DataControlRowType.EmptyDataRow, DataControlRowState.Normal, rows, null);
                } 
                itemCount = 0; 
            } else {
                int currentItemIndex = 0; 
                if (!_useServerPaging) {
                    // skip over the first records that are before the page we're showing
                    for (; currentItemIndex < itemIndex; currentItemIndex++) {
                        lastItem = dataSourceEnumerator.Current; 
                        moveNextSucceeded = dataSourceEnumerator.MoveNext();
                        if (!moveNextSucceeded) { 
                            _pageIndex = currentItemIndex; 
                            pagedDataSource.CurrentPageIndex = currentItemIndex;
                            itemIndex = currentItemIndex; 
                            break;  // never throw if the PageIndex is out of range: just fix up PageIndex and goto the last item.
                        }
                    }
                } 

                if (moveNextSucceeded) { 
                    _dataItem = dataSourceEnumerator.Current; 
                } else {
                    _dataItem = lastItem;   // if we broke out of the above loop, the current item will be invalid 
                }


                // If we're not using server paging and this isn't a collection, or server paging doesn't return a page count, our _pageCount isn't accurate. 
                // Loop through the rest of the enumeration to figure out how many items are in it.
                if ((!_useServerPaging && !(dataSource is ICollection)) || (_useServerPaging && itemCount < 0)) { 
                    itemCount = currentItemIndex; 
                    while (moveNextSucceeded) {
                        itemCount++; 
                        moveNextSucceeded = dataSourceEnumerator.MoveNext();
                    }
                }
 
                _dataItemIndex = currentItemIndex;
 
                bool singlePage = itemCount <= 1 && !_useServerPaging; // hide pagers if there's only one item 
                if (allowPaging && PagerSettings.Visible && _pagerSettings.IsPagerOnTop && mode != FormViewMode.Insert && !singlePage) {
                    // top pager 
                    _topPagerRow = CreateRow(itemIndex, DataControlRowType.Pager, DataControlRowState.Normal, rows, pagedDataSource);
                }

                _headerRow = CreateRow(itemIndex, DataControlRowType.Header, DataControlRowState.Normal, rows, null); 
                if (_headerTemplate == null && HeaderText.Length == 0) {
                    _headerRow.Visible = false; 
                } 

                _row = CreateDataRow(dataBinding, rows, _dataItem); 

                if (itemIndex >= 0) {
                    string[] keyFields = DataKeyNamesInternal;
                    if (dataBinding && (keyFields.Length != 0)) { 
                        foreach (string keyName in keyFields) {
                            object keyValue = DataBinder.GetPropertyValue(_dataItem, keyName); 
                            keyTable.Add(keyName, keyValue); 
                        }
                        _dataKey = new DataKey(keyTable); 
                    }
                }

                _footerRow = CreateRow(itemIndex, DataControlRowType.Footer, DataControlRowState.Normal, rows, null); 
                if (_footerTemplate == null && FooterText.Length == 0) {
                    _footerRow.Visible = false; 
                } 

                if (allowPaging && PagerSettings.Visible && _pagerSettings.IsPagerOnBottom && mode != FormViewMode.Insert && !singlePage) { 
                    // bottom pager
                    _bottomPagerRow = CreateRow(itemIndex, DataControlRowType.Pager, DataControlRowState.Normal, rows, pagedDataSource);
                }
            } 

            _pageCount = itemCount; 
 
            OnItemCreated(EventArgs.Empty);
 
            if (dataBinding) {
                DataBind(false);
            }
 
            return itemCount;
        } 
 

        ///  
        /// Creates new control style.
        /// 
        protected override Style CreateControlStyle() {
            TableStyle controlStyle = new TableStyle(); 

            // initialize defaults that are different from TableStyle 
            controlStyle.CellSpacing = 0; 

            return controlStyle; 
        }

        private FormViewRow CreateDataRow(bool dataBinding, TableRowCollection rows, object dataItem) {
            ITemplate modeTemplate = null; 

            switch (Mode) { 
                case FormViewMode.Edit: 
                    modeTemplate = _editItemTemplate;
                    break; 
                case FormViewMode.Insert:
                    if (_insertItemTemplate != null) {
                        modeTemplate = _insertItemTemplate;
                    } else { 
                        modeTemplate = _editItemTemplate;
                    } 
                    break; 
                case FormViewMode.ReadOnly:
                    modeTemplate = _itemTemplate; 
                    break;
            }

            if (modeTemplate != null) { 
                return CreateDataRowFromTemplates(dataBinding, rows);
            } 
            return null; 
        }
 
        private FormViewRow CreateDataRowFromTemplates(bool dataBinding, TableRowCollection rows) {
            DataControlRowState rowState = DataControlRowState.Normal;
            int itemIndex = PageIndex;
            FormViewMode mode = Mode; 

            rowState = DataControlRowState.Normal; 
            if (mode == FormViewMode.Edit) 
                rowState |= DataControlRowState.Edit;
            else if (mode == FormViewMode.Insert) 
                rowState |= DataControlRowState.Insert;

            return CreateRow(PageIndex, DataControlRowType.DataRow, rowState, rows, null);
        } 

        protected override DataSourceSelectArguments CreateDataSourceSelectArguments() { 
            DataSourceSelectArguments arguments = new DataSourceSelectArguments(); 
            DataSourceView view = GetData();
 
            _useServerPaging = AllowPaging && view.CanPage;

            // decide if we should use server-side paging
            if (_useServerPaging) { 
                arguments.StartRowIndex = PageIndex;
                if (view.CanRetrieveTotalRowCount) { 
                    arguments.RetrieveTotalRowCount = true; 
                    arguments.MaximumRows = 1;
                } else { 
                    arguments.MaximumRows = -1;
                }
            }
 
            return arguments;
        } 
 
        /// 
        /// Creates the pager for NextPrev and NextPrev with First and Last styles 
        /// 
        private void CreateNextPrevPager(TableRow row, PagedDataSource pagedDataSource, bool addFirstLastPageButtons) {
            PagerSettings pagerSettings = PagerSettings;
            string prevPageImageUrl = pagerSettings.PreviousPageImageUrl; 
            string nextPageImageUrl = pagerSettings.NextPageImageUrl;
            bool isFirstPage = pagedDataSource.IsFirstPage; 
            bool isLastPage = pagedDataSource.IsLastPage; 

 
            if (addFirstLastPageButtons && !isFirstPage) {
                string firstPageImageUrl = pagerSettings.FirstPageImageUrl;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                IButtonControl firstButton;
                if (firstPageImageUrl.Length > 0) { 
                    firstButton = new DataControlImageButton(this); 
                    ((ImageButton)firstButton).ImageUrl = firstPageImageUrl;
                    ((ImageButton)firstButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.FirstPageText); 
                } else {
                    firstButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)firstButton).Text = pagerSettings.FirstPageText;
                } 
                firstButton.CommandName = DataControlCommands.PageCommandName;
                firstButton.CommandArgument = DataControlCommands.FirstPageCommandArgument; 
                cell.Controls.Add((Control)firstButton); 
            }
 
            if (!isFirstPage) {
                IButtonControl prevButton;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                if (prevPageImageUrl.Length > 0) {
                    prevButton = new DataControlImageButton(this); 
                    ((ImageButton)prevButton).ImageUrl = prevPageImageUrl; 
                    ((ImageButton)prevButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.PreviousPageText);
                } else { 
                    prevButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)prevButton).Text = pagerSettings.PreviousPageText;
                }
                prevButton.CommandName = DataControlCommands.PageCommandName; 
                prevButton.CommandArgument = DataControlCommands.PreviousPageCommandArgument;
                cell.Controls.Add((Control)prevButton); 
            } 

 
            if (!isLastPage) {
                IButtonControl nextButton;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                if (nextPageImageUrl.Length > 0) {
                    nextButton = new DataControlImageButton(this); 
                    ((ImageButton)nextButton).ImageUrl = nextPageImageUrl; 
                    ((ImageButton)nextButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.NextPageText);
                } else { 
                    nextButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)nextButton).Text = pagerSettings.NextPageText;
                }
                nextButton.CommandName = DataControlCommands.PageCommandName; 
                nextButton.CommandArgument = DataControlCommands.NextPageCommandArgument;
                cell.Controls.Add((Control)nextButton); 
            } 

            if (addFirstLastPageButtons && !isLastPage) { 
                string lastPageImageUrl = pagerSettings.LastPageImageUrl;
                IButtonControl lastButton;
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
                if (lastPageImageUrl.Length > 0) {
                    lastButton = new DataControlImageButton(this); 
                    ((ImageButton)lastButton).ImageUrl = lastPageImageUrl; 
                    ((ImageButton)lastButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.LastPageText);
 
                } else {
                    lastButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)lastButton).Text = pagerSettings.LastPageText;
                } 
                lastButton.CommandName = DataControlCommands.PageCommandName;
                lastButton.CommandArgument = DataControlCommands.LastPageCommandArgument; 
                cell.Controls.Add((Control)lastButton); 
            }
        } 

        /// 
        /// Creates the pager for NextPrev and NextPrev with First and Last styles
        ///  
        private void CreateNumericPager(TableRow row, PagedDataSource pagedDataSource, bool addFirstLastPageButtons) {
            PagerSettings pagerSettings = PagerSettings; 
 
            int pages = pagedDataSource.PageCount;
            int currentPage = pagedDataSource.CurrentPageIndex + 1; 
            int pageSetSize = pagerSettings.PageButtonCount;
            int pagesShown = pageSetSize;
            int firstDisplayedPage = FirstDisplayedPageIndex + 1;   // first page displayed on last postback
 
            // ensure the number of pages we show isn't more than the number of pages that do exist
            if (pages < pagesShown) 
                pagesShown = pages; 

            // initialize to the first page set, i.e., pages 1 through number of pages shown 
            int firstPage = 1;
            int lastPage = pagesShown;

            if (currentPage > lastPage) { 
                // The current page is not in the first page set, then we need to slide the
                // range of pages shown by adjusting firstPage and lastPage 
                int currentPageSet = (currentPage - 1) / pageSetSize; 
                bool currentPageInLastDisplayRange = currentPage - firstDisplayedPage >= 0 && currentPage - firstDisplayedPage < pageSetSize;
                if (firstDisplayedPage > 0 && currentPageInLastDisplayRange) { 
                    firstPage = firstDisplayedPage;
                } else {
                    firstPage = currentPageSet * pageSetSize + 1;
                } 
                lastPage = firstPage + pageSetSize - 1;
 
                // now bring back lastPage into the range if its exceeded the number of pages 
                if (lastPage > pages)
                    lastPage = pages; 

                // if theres room to show more pages from the previous page set, then adjust
                // the first page accordingly
                if (lastPage - firstPage + 1 < pageSetSize) { 
                    firstPage = Math.Max(1, lastPage - pageSetSize + 1);
                } 
                FirstDisplayedPageIndex = firstPage - 1; 
            }
 
            LinkButton button;

            if (addFirstLastPageButtons && currentPage != 1 && firstPage != 1) {
                string firstPageImageUrl = pagerSettings.FirstPageImageUrl; 
                IButtonControl firstButton;
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell); 

                if (firstPageImageUrl.Length > 0) { 
                    firstButton = new DataControlImageButton(this);
                    ((ImageButton)firstButton).ImageUrl = firstPageImageUrl;
                    ((ImageButton)firstButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.FirstPageText);
                } else { 
                    firstButton = new DataControlPagerLinkButton(this);
                    ((DataControlPagerLinkButton)firstButton).Text = pagerSettings.FirstPageText; 
                } 
                firstButton.CommandName = DataControlCommands.PageCommandName;
                firstButton.CommandArgument = DataControlCommands.FirstPageCommandArgument; 
                cell.Controls.Add((Control)firstButton);
            }

            if (firstPage != 1) { 
                TableCell cell = new TableCell();
                row.Cells.Add(cell); 
 
                button = new DataControlPagerLinkButton(this);
                button.Text = "..."; 
                button.CommandName = DataControlCommands.PageCommandName;
                button.CommandArgument = (firstPage - 1).ToString(NumberFormatInfo.InvariantInfo);
                cell.Controls.Add(button);
            } 

            for (int i = firstPage; i <= lastPage; i++) { 
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell);
 
                string pageString = (i).ToString(NumberFormatInfo.InvariantInfo);
                if (i == currentPage) {
                    Label label = new Label();
 
                    label.Text = pageString;
                    cell.Controls.Add(label); 
                } else { 
                    button = new DataControlPagerLinkButton(this);
 
                    button.Text = pageString;
                    button.CommandName = DataControlCommands.PageCommandName;
                    button.CommandArgument = pageString;
                    cell.Controls.Add(button); 
                }
            } 
 
            if (pages > lastPage) {
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell);
                button = new DataControlPagerLinkButton(this);

                button.Text = "..."; 
                button.CommandName = DataControlCommands.PageCommandName;
                button.CommandArgument = (lastPage + 1).ToString(NumberFormatInfo.InvariantInfo); 
                cell.Controls.Add(button); 
            }
 
            bool isLastPageShown = lastPage == pages;
            if (addFirstLastPageButtons && currentPage != pages && !isLastPageShown) {
                string lastPageImageUrl = pagerSettings.LastPageImageUrl;
                TableCell cell = new TableCell(); 
                row.Cells.Add(cell);
 
                IButtonControl lastButton; 
                if (lastPageImageUrl.Length > 0) {
                    lastButton = new DataControlImageButton(this); 
                    ((ImageButton)lastButton).ImageUrl = lastPageImageUrl;
                    ((ImageButton)lastButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.LastPageText);
                } else {
                    lastButton = new DataControlPagerLinkButton(this); 
                    ((DataControlPagerLinkButton)lastButton).Text = pagerSettings.LastPageText;
                } 
                lastButton.CommandName = DataControlCommands.PageCommandName; 
                lastButton.CommandArgument = DataControlCommands.LastPageCommandArgument;
                cell.Controls.Add((Control)lastButton); 
            }
        }

        private PagedDataSource CreatePagedDataSource() { 
            PagedDataSource pagedDataSource = new PagedDataSource();
 
            pagedDataSource.CurrentPageIndex = PageIndex; 
            pagedDataSource.PageSize = 1;
            pagedDataSource.AllowPaging = AllowPaging; 
            pagedDataSource.AllowCustomPaging = false;
            pagedDataSource.AllowServerPaging = false;
            pagedDataSource.VirtualCount = 0;
 
            return pagedDataSource;
        } 
 
        private PagedDataSource CreateServerPagedDataSource(int totalRowCount) {
            PagedDataSource pagedDataSource = new PagedDataSource(); 

            pagedDataSource.CurrentPageIndex = PageIndex;
            pagedDataSource.PageSize = 1;
            pagedDataSource.AllowPaging = AllowPaging; 
            pagedDataSource.AllowCustomPaging = false;
            pagedDataSource.AllowServerPaging = true; 
            pagedDataSource.VirtualCount = totalRowCount; 

            return pagedDataSource; 
        }

        private FormViewRow CreateRow(int itemIndex, DataControlRowType rowType, DataControlRowState rowState, TableRowCollection rows, PagedDataSource pagedDataSource) {
            FormViewRow row = CreateRow(itemIndex, rowType, rowState); 
            row.RenderTemplateContainer = RenderOuterTable;
 
            rows.Add(row); 

            if (rowType != DataControlRowType.Pager) { 
                InitializeRow(row);
            } else {
                InitializePager(row, pagedDataSource);
            } 

            return row; 
        } 

 
        /// 
        /// [To be supplied.]
        /// 
        protected virtual FormViewRow CreateRow(int itemIndex, DataControlRowType rowType, DataControlRowState rowState) { 
            if (rowType == DataControlRowType.Pager) {
                return new FormViewPagerRow(itemIndex, rowType, rowState); 
            } 
            return new FormViewRow(itemIndex, rowType, rowState);
        } 


        /// 
        /// Creates a new ChildTable, which is the containing table 
        /// 
        protected virtual Table CreateTable() { 
            return new ChildTable(String.IsNullOrEmpty(ID) ? null : ClientID); 
        }
 
        /// Data bound controls should override PerformDataBinding instead
        /// of DataBind.  If DataBind if overridden, the OnDataBinding and OnDataBound events will
        /// fire in the wrong order.  However, for backwards compat on ListControl and AdRotator, we
        /// can't seal this method.  It is sealed on all new BaseDataBoundControl-derived controls. 
        public override sealed void DataBind() {
            base.DataBind(); 
        } 

        public virtual void DeleteItem() { 
            // use EnableModelVadliation as the causesValdiation param because the hosting page should not
            // be validated unless model validation is going to be used
            ResetModelValidationGroup(EnableModelValidation, String.Empty);
            HandleDelete(String.Empty); 
        }
 
        ///  
        /// Override EnsureDataBound because we don't want to databind when we're in insert mode
        ///  
        protected override void EnsureDataBound() {
            if (RequiresDataBinding && Mode == FormViewMode.Insert) {
                OnDataBinding(EventArgs.Empty);
 
                RequiresDataBinding = false;
                MarkAsDataBound(); 
                if (AdapterInternal != null) { 
                    DataBoundControlAdapter dataBoundControlAdapter = AdapterInternal as DataBoundControlAdapter;
                    if (dataBoundControlAdapter != null) { 
                        dataBoundControlAdapter.PerformDataBinding(null);
                    } else {
                        PerformDataBinding(null);
                    } 
                } else {
                    PerformDataBinding(null); 
                } 

                OnDataBound(EventArgs.Empty); 
            } else {
                base.EnsureDataBound();
            }
        } 

 
        protected virtual void ExtractRowValues(IOrderedDictionary fieldValues, bool includeKeys) { 
            if (fieldValues == null) {
                Debug.Assert(false, "FormView::ExtractRowValues- must hand in a valid reference to an IDictionary."); 
                return;
            }

            DataBoundControlHelper.ExtractValuesFromBindableControls(fieldValues, this); 

            IBindableTemplate bindableTemplate = null; 
            if (Mode == FormViewMode.ReadOnly && ItemTemplate != null) { 
                bindableTemplate = ItemTemplate as IBindableTemplate;
            } else if ((Mode == FormViewMode.Edit || (Mode == FormViewMode.Insert && InsertItemTemplate == null)) && EditItemTemplate != null) { 
                bindableTemplate = EditItemTemplate as IBindableTemplate;
            } else if (Mode == FormViewMode.Insert && InsertItemTemplate != null) {
                bindableTemplate = InsertItemTemplate as IBindableTemplate;
            } 
            string[] dataKeyNames = DataKeyNamesInternal;
 
            if (bindableTemplate != null) { 
                FormView container = this;
                if (container != null && bindableTemplate != null) { 
                    foreach (DictionaryEntry entry in bindableTemplate.ExtractValues(container)) {
                        if (!includeKeys && Array.IndexOf(dataKeyNames, entry.Key) != -1) {
                            continue;
                        } 
                        fieldValues[entry.Key] = entry.Value;
                    } 
                } 
            }
 
            return;
        }

        private void HandleCancel() { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
 
            FormViewModeEventArgs e = new FormViewModeEventArgs(DefaultMode, true); 
            OnModeChanging(e);
 
            if (e.Cancel) {
                return;
            }
 
            if (isBoundToDataSourceControl) {
                Mode = e.NewMode; 
                OnModeChanged(EventArgs.Empty); 
            }
 
            RequiresDataBinding = true;
        }

        private void HandleDelete(string commandArg) { 
            int pageIndex = PageIndex;
 
            if (pageIndex < 0) {    // don't attempt to delete in Insert mode 
                return;
            } 

            DataSourceView view = null;
            int itemIndex = PageIndex;
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            if (isBoundToDataSourceControl) { 
                view = GetData(); 
                if (view == null) {
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID)); 
                }
            }

            FormViewDeleteEventArgs e = new FormViewDeleteEventArgs(itemIndex); 

 
            ExtractRowValues(e.Values, false/*includeKeys*/); 
            foreach (DictionaryEntry entry in DataKey.Values) {
                e.Keys.Add(entry.Key, entry.Value); 
                if (e.Values.Contains(entry.Key)) {
                    e.Values.Remove(entry.Key);
                }
            } 

 
            OnItemDeleting(e); 

            if (e.Cancel) { 
                return;
            }

            if (isBoundToDataSourceControl) { 
                _deleteKeys = e.Keys;
                _deleteValues = e.Values; 
                view.Delete(e.Keys, e.Values, HandleDeleteCallback); 
            }
        } 

        private bool HandleDeleteCallback(int affectedRows, Exception ex) {
            int pageIndex = PageIndex;
            FormViewDeletedEventArgs fea = new FormViewDeletedEventArgs(affectedRows, ex); 
            fea.SetKeys(_deleteKeys);
            fea.SetValues(_deleteValues); 
 
            OnItemDeleted(fea);
 
            _deleteKeys = null;
            _deleteValues = null;

            if (ex != null && !fea.ExceptionHandled) { 
                // If there is no validator in the validation group that could make sense
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing. 
                if (PageIsValidAfterModelException()) {
                    return false; 
                }
            }

            if (pageIndex == _pageCount - 1) { 
                HandlePage(pageIndex - 1);
            } 
 
            RequiresDataBinding = true;
            return true; 
        }

        private void HandleEdit() {
            if (PageIndex < 0) { 
                return;
            } 
 
            FormViewModeEventArgs e = new FormViewModeEventArgs(FormViewMode.Edit, false);
            OnModeChanging(e); 

            if (e.Cancel) {
                return;
            } 

            if (IsBoundUsingDataSourceID) { 
                Mode = e.NewMode; 
                OnModeChanged(EventArgs.Empty);
            } 

            RequiresDataBinding = true;
        }
 
        private bool HandleEvent(EventArgs e, bool causesValidation, string validationGroup) {
            bool handled = false; 
 
            ResetModelValidationGroup(causesValidation, validationGroup);
 
            FormViewCommandEventArgs dce = e as FormViewCommandEventArgs;

            if (dce != null) {
 
                OnItemCommand(dce);
                handled = true; 
 
                string command = dce.CommandName;
                int newItemIndex = PageIndex; 

                if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.PageCommandName)) {
                    string itemIndexArg = (string)dce.CommandArgument;
 
                    if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.NextPageCommandArgument)) {
                        newItemIndex++; 
                    } else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.PreviousPageCommandArgument)) { 
                        newItemIndex--;
                    } else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.FirstPageCommandArgument)) { 
                        newItemIndex = 0;
                    } else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.LastPageCommandArgument)) {
                        newItemIndex = PageCount - 1;
                    } else { 
                        // argument is page number, and page index is 1 less than that
                        newItemIndex = Convert.ToInt32(itemIndexArg, CultureInfo.InvariantCulture) - 1; 
                    } 
                    HandlePage(newItemIndex);
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.EditCommandName)) { 
                    HandleEdit();
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.UpdateCommandName)) {
                    HandleUpdate((string)dce.CommandArgument, causesValidation);
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.CancelCommandName)) { 
                    HandleCancel();
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.DeleteCommandName)) { 
                    HandleDelete((string)dce.CommandArgument); 
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.InsertCommandName)) {
                    HandleInsert((string)dce.CommandArgument, causesValidation); 
                } else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.NewCommandName)) {
                    HandleNew();
                } else {
                    // unhandled event should be bubbled up here. (DevDiv Bugs 161011) 
                    handled = HandleCommand(command);
                } 
            } 

            return handled; 
        }

        private bool HandleCommand(string commandName) {
            DataSourceView view = null; 

            if (IsBoundUsingDataSourceID) { 
                view = GetData(); 
                if (view == null) {
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID)); 
                }
            }
            else {
                // This feature is only for data sources 
                return false;
            } 
 
            if (!view.CanExecute(commandName)) {
                return false; 
            }

            OrderedDictionary values = new OrderedDictionary();
            OrderedDictionary keys = new OrderedDictionary(); 

            ExtractRowValues(values, false /*includeKey*/); 
 
            foreach (DictionaryEntry entry in DataKey.Values) {
                keys.Add(entry.Key, entry.Value); 
                if (values.Contains(entry.Key)) {
                    values.Remove(entry.Key);
                }
            } 

            view.ExecuteCommand(commandName, keys, values, HandleCommandCallback); 
            return true; 
        }
 
        private bool HandleCommandCallback(int affectedRows, Exception ex) {
            if (ex != null) {
                // If there is no validator in the validation group that could make sense
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing.
                if (PageIsValidAfterModelException()) { 
                    return false; 
                }
            } 

            RequiresDataBinding = true;
            return true;
        } 

        private void HandleInsert(string commandArg, bool causesValidation) { 
            if (causesValidation && Page != null && !Page.IsValid) { 
                return;
            } 

            if (Mode != FormViewMode.Insert) {
                throw new HttpException(SR.GetString(SR.DetailsViewFormView_ControlMustBeInInsertMode, "FormView", ID));
            } 

            DataSourceView view = null; 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            if (isBoundToDataSourceControl) { 
                view = GetData();
                if (view == null) {
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
                } 
            }
 
            FormViewInsertEventArgs e = new FormViewInsertEventArgs(commandArg); 

 
            ExtractRowValues(e.Values, true/*includeKeys*/);


            OnItemInserting(e); 

            if (e.Cancel) { 
                return; 
            }
 
            if (isBoundToDataSourceControl) {
                _insertValues = e.Values;
                view.Insert(e.Values, HandleInsertCallback);
            } 
        }
 
        private bool HandleInsertCallback(int affectedRows, Exception ex) { 
            FormViewInsertedEventArgs fea = new FormViewInsertedEventArgs(affectedRows, ex);
            fea.SetValues(_insertValues); 

            OnItemInserted(fea);

            _insertValues = null; 
            if (ex != null && !fea.ExceptionHandled) {
                // If there is no validator in the validation group that could make sense 
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing.
                if (PageIsValidAfterModelException()) { 
                    return false;
                }
                fea.KeepInInsertMode = true;
            } 

            if (!fea.KeepInInsertMode) { 
                FormViewModeEventArgs eMode = new FormViewModeEventArgs(DefaultMode, false); 
                OnModeChanging(eMode);
                if (!eMode.Cancel) { 
                    Mode = eMode.NewMode;
                    OnModeChanged(EventArgs.Empty);
                    RequiresDataBinding = true;
                } 
            }
            return true; 
        } 

        private void HandleNew() { 
            FormViewModeEventArgs e = new FormViewModeEventArgs(FormViewMode.Insert, false);
            OnModeChanging(e);

            if (e.Cancel) { 
                return;
            } 
 
            if (IsBoundUsingDataSourceID) {
                Mode = e.NewMode; 
                OnModeChanged(EventArgs.Empty);
            }

            RequiresDataBinding = true; 
        }
 
        private void HandlePage(int newPage) { 
            if (!AllowPaging) {
                return; 
            }

            if (PageIndex < 0) {
                return; 
            }
 
            FormViewPageEventArgs e = new FormViewPageEventArgs(newPage); 
            OnPageIndexChanging(e);
 
            if (e.Cancel) {
                return;
            }
 
            if (e.NewPageIndex > -1) {
                // if the requested page is out of range and we're already on the last page, don't rebind 
                if ((e.NewPageIndex >= PageCount && _pageIndex == PageCount - 1)) { 
                    return;
                } 
                // DevDiv Bugs 188830: Don't clear key table if the page is out of range, since control won't be rebound.
                _keyTable = null;
                _pageIndex = e.NewPageIndex;
            } 
            else {
                return; 
            } 

            OnPageIndexChanged(EventArgs.Empty); 
            RequiresDataBinding = true;
        }

        private void HandleUpdate(string commandArg, bool causesValidation) { 
            if (causesValidation && Page != null && !Page.IsValid) {
                return; 
            } 

            if (Mode != FormViewMode.Edit) { 
                throw new HttpException(SR.GetString(SR.DetailsViewFormView_ControlMustBeInEditMode, "FormView", ID));
            }

            if (PageIndex < 0) { 
                return;
            } 
 
            DataSourceView view = null;
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            if (isBoundToDataSourceControl) {
                view = GetData();
                if (view == null) { 
                    throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
                } 
            } 

            FormViewUpdateEventArgs e = new FormViewUpdateEventArgs(commandArg); 


            foreach (DictionaryEntry entry in BoundFieldValues) {
                e.OldValues.Add(entry.Key, entry.Value); 
            }
 
            ExtractRowValues(e.NewValues, true/*includeKeys*/); 
            foreach (DictionaryEntry entry in DataKey.Values) {
                e.Keys.Add(entry.Key, entry.Value); 
            }


 
            OnItemUpdating(e);
 
            if (e.Cancel) { 
                return;
            } 

            if (isBoundToDataSourceControl) {
                _updateKeys = e.Keys;
                _updateOldValues = e.OldValues; 
                _updateNewValues = e.NewValues;
 
                view.Update(e.Keys, e.NewValues, e.OldValues, HandleUpdateCallback); 
            }
        } 

        private bool HandleUpdateCallback(int affectedRows, Exception ex) {
            FormViewUpdatedEventArgs fea = new FormViewUpdatedEventArgs(affectedRows, ex);
            fea.SetOldValues(_updateOldValues); 
            fea.SetNewValues(_updateNewValues);
            fea.SetKeys(_updateKeys); 
 
            OnItemUpdated(fea);
            _updateKeys = null; 
            _updateOldValues = null;
            _updateNewValues = null;

            if (ex != null && !fea.ExceptionHandled) { 
                // If there is no validator in the validation group that could make sense
                // of the error, return false to proceed with standard exception handling. 
                // But if there is one, we want to let it display its error instead of throwing. 
                if (PageIsValidAfterModelException()) {
                    return false; 
                }
                fea.KeepInEditMode = true;
            }
            if (!fea.KeepInEditMode) { 
                FormViewModeEventArgs eMode = new FormViewModeEventArgs(DefaultMode, false);
                OnModeChanging(eMode); 
                if (!eMode.Cancel) { 
                    Mode = eMode.NewMode;
                    OnModeChanged(EventArgs.Empty); 
                    RequiresDataBinding = true;
                }
            }
            return true; 
        }
 
 
        /// 
        ///  
        /// Creates a FormViewRow that contains the paging UI.
        /// The paging UI is a navigation bar that is a built into a single TableCell that
        /// spans across all fields of the FormView.
        ///  
        /// 
        protected virtual void InitializePager(FormViewRow row, PagedDataSource pagedDataSource) { 
            TableCell cell = new TableCell(); 

            PagerSettings pagerSettings = PagerSettings; 

            if (_pagerTemplate != null) {
                _pagerTemplate.InstantiateIn(cell);
            } else { 
                PagerTable pagerTable = new PagerTable();
                TableRow pagerTableRow = new TableRow(); 
                cell.Controls.Add(pagerTable); 
                pagerTable.Rows.Add(pagerTableRow);
                switch (pagerSettings.Mode) { 
                    case PagerButtons.NextPrevious:
                        CreateNextPrevPager(pagerTableRow, pagedDataSource, false);
                        break;
                    case PagerButtons.Numeric: 
                        CreateNumericPager(pagerTableRow, pagedDataSource, false);
                        break; 
                    case PagerButtons.NextPreviousFirstLast: 
                        CreateNextPrevPager(pagerTableRow, pagedDataSource, true);
                        break; 
                    case PagerButtons.NumericFirstLast:
                        CreateNumericPager(pagerTableRow, pagedDataSource, true);
                        break;
                } 
            }
            cell.ColumnSpan = 2; 
            row.Cells.Add(cell); 
        }
 

        /// 
        /// [To be supplied.]
        ///  
        protected virtual void InitializeRow(FormViewRow row) {
            TableCellCollection cells = row.Cells; 
            TableCell contentCell = new TableCell(); 
            ITemplate contentTemplate = _itemTemplate;
            int itemIndex = row.ItemIndex; 
            DataControlRowState rowState = row.RowState;

            switch (row.RowType) {
                case DataControlRowType.DataRow: 
                    contentCell.ColumnSpan = 2;
                    if (((rowState & DataControlRowState.Edit) != 0) && _editItemTemplate != null) { 
                        contentTemplate = _editItemTemplate; 
                    }
                    if ((rowState & DataControlRowState.Insert) != 0) { 
                        if (_insertItemTemplate != null) {
                            contentTemplate = _insertItemTemplate;
                        } else {
                            contentTemplate = _editItemTemplate; 
                        }
                    } 
                    break; 
                case DataControlRowType.Header:
                    contentTemplate = _headerTemplate; 
                    contentCell.ColumnSpan = 2;
                    string headerText = HeaderText;
                    if (_headerTemplate == null && headerText.Length > 0) {
                        contentCell.Text = headerText; 
                    }
                    break; 
                case DataControlRowType.Footer: 
                    contentTemplate = _footerTemplate;
                    contentCell.ColumnSpan = 2; 
                    string footerText = FooterText;
                    if (_footerTemplate == null && footerText.Length > 0) {
                        contentCell.Text = footerText;
                    } 
                    break;
                case DataControlRowType.EmptyDataRow: 
                    contentTemplate = _emptyDataTemplate; 
                    string emptyDataText = EmptyDataText;
                    if (_emptyDataTemplate == null && emptyDataText.Length > 0) { 
                        contentCell.Text = emptyDataText;
                    }
                    break;
            } 

            if (contentTemplate != null) { 
                contentTemplate.InstantiateIn(contentCell); 
            }
            cells.Add(contentCell); 
        }

        public virtual void InsertItem(bool causesValidation) {
            ResetModelValidationGroup(causesValidation, String.Empty); 
            HandleInsert(String.Empty, causesValidation);
        } 
 

        ///  
        /// Determines if the specified data type can be bound to.
        /// 
        public virtual bool IsBindableType(Type type) {
            // NOTE: No one ever calls this function, but we have to keep it for back compat 
            // since it's public.
            return DataBoundControlHelper.IsBindableType(type); 
        } 

 
        /// 
        /// Loads the control state for those properties that should persist across postbacks
        ///   even when EnableViewState=false.
        ///  
        protected internal override void LoadControlState(object savedState) {
            // Any properties that could have been set in the persistance need to be 
            // restored to their defaults if they're not in ControlState, or they will 
            // be restored to their persisted state instead of their empty state.
            _pageIndex = 0; 
            _defaultMode = FormViewMode.ReadOnly;
            _dataKeyNames = new string[0];
            _pageCount = 0;
 
            object[] state = savedState as object[];
            if (state != null) { 
                base.LoadControlState(state[0]); 
                if (state[1] != null) {
                    _pageIndex = (int)state[1]; 
                }

                if (state[2] != null) {
                    _defaultMode = (FormViewMode)state[2]; 
                }
 
                // if Mode isn't saved, it should be restored to DefaultMode.  That will happen in Mode's getter, 
                // since the persistance state hasn't been loaded yet.
                if (state[3] != null) { 
                    Mode = (FormViewMode)state[3];
                }

                if (state[4] != null) { 
                    _dataKeyNames = (string[])state[4];
                } 
 
                if (state[5] != null) {
                    KeyTable.Clear(); 
                    OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)KeyTable, (ArrayList)state[5]);
                }

                if (state[6] != null) { 
                    _pageCount = (int)state[6];
                } 
            } else { 
                base.LoadControlState(null);
            } 

        }

 
        /// 
        /// Loads a saved state of the . 
        ///  
        protected override void LoadViewState(object savedState) {
            if (savedState != null) { 
                object[] myState = (object[])savedState;

                base.LoadViewState(myState[0]);
                if (myState[1] != null) 
                    ((IStateManager)PagerStyle).LoadViewState(myState[1]);
                if (myState[2] != null) 
                    ((IStateManager)HeaderStyle).LoadViewState(myState[2]); 
                if (myState[3] != null)
                    ((IStateManager)FooterStyle).LoadViewState(myState[3]); 
                if (myState[4] != null)
                    ((IStateManager)RowStyle).LoadViewState(myState[4]);
                if (myState[5] != null)
                    ((IStateManager)EditRowStyle).LoadViewState(myState[5]); 
                if (myState[6] != null)
                    ((IStateManager)InsertRowStyle).LoadViewState(myState[6]); 
                if (myState[7] != null) 
                    OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)BoundFieldValues, (ArrayList)myState[7]);
                if (myState[8] != null) 
                    ((IStateManager)PagerSettings).LoadViewState(myState[8]);
                if (myState[9] != null)
                    ((IStateManager)ControlStyle).LoadViewState(myState[9]);
            } else { 
                base.LoadViewState(null);
            } 
        } 

        protected internal virtual string ModifiedOuterTableStylePropertyName() { 
            // Verify that table specific and basic style properties are not not set (not different than their defaults).
            if (!String.IsNullOrEmpty(BackImageUrl)) {
                return "BackImageUrl";
            } 
            if (CellPadding != -1) {
                return "CellPadding"; 
            } 
            if (CellSpacing != 0) {
                return "CellSpacing"; 
            }
            if (GridLines != GridLines.None) {
                return "GridLines";
            } 
            if (HorizontalAlign != HorizontalAlign.NotSet) {
                return "HorizontalAlign"; 
            } 

            // Font styles. 
            if (Font.Bold ||
                Font.Italic ||
                !String.IsNullOrEmpty(Font.Name) ||
                (Font.Names.Length != 0) || 
                Font.Overline ||
                (Font.Size != FontUnit.Empty) || 
                Font.Strikeout || 
                Font.Underline) {
                return "Font"; 
            }

            return LoginUtil.ModifiedOuterTableBasicStylePropertyName(this);
        } 

        ///  
        ///  
        protected override bool OnBubbleEvent(object source, EventArgs e) {
            bool causesValidation = false; 
            string validationGroup = String.Empty;

            FormViewCommandEventArgs fvcea = e as FormViewCommandEventArgs;
            if (fvcea != null) { 
                IButtonControl button = fvcea.CommandSource as IButtonControl;
                if (button != null) { 
                    causesValidation = button.CausesValidation; 
                    validationGroup = button.ValidationGroup;
                } 
            }
            return HandleEvent(e, causesValidation, validationGroup);
        }
 

        ///  
        /// Raises the event. 
        /// 
        protected virtual void OnPageIndexChanged(EventArgs e) { 
            EventHandler handler = (EventHandler)Events[EventPageIndexChanged];
            if (handler != null) handler(this, e);
        }
 

        ///  
        /// Raises the  event. 
        /// 
        protected virtual void OnPageIndexChanging(FormViewPageEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;

            FormViewPageEventHandler handler = (FormViewPageEventHandler)Events[EventPageIndexChanging];
            if (handler != null) { 
                handler(this, e);
            } else { 
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "PageIndexChanging"));
                } 
            }
        }

 
        /// 
        /// FormView initialization. 
        ///  
        protected internal override void OnInit(EventArgs e) {
            base.OnInit(e); 

            if (Page != null) {
                if (DataKeyNames.Length > 0) {
                    Page.RegisterRequiresViewStateEncryption(); 
                }
                Page.RegisterRequiresControlState(this); 
            } 
        }
 

        /// 
        /// Raises the  event.
        ///  
        protected virtual void OnItemCommand(FormViewCommandEventArgs e) {
            FormViewCommandEventHandler handler = (FormViewCommandEventHandler)Events[EventItemCommand]; 
            if (handler != null) { 
                handler(this, e);
            } 
        }


        ///  
        /// Raises the  event.
        ///  
        protected virtual void OnItemCreated(EventArgs e) { 
            EventHandler handler = (EventHandler)Events[EventItemCreated];
            if (handler != null) { 
                handler(this, e);
            }
        }
 

        ///  
        /// Raises the event. 
        /// 
        protected virtual void OnItemDeleted(FormViewDeletedEventArgs e) { 
            FormViewDeletedEventHandler handler = (FormViewDeletedEventHandler)Events[EventItemDeleted];
            if (handler != null) handler(this, e);
        }
 

        ///  
        /// Raises the  event. 
        /// 
        protected virtual void OnItemDeleting(FormViewDeleteEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;

            FormViewDeleteEventHandler handler = (FormViewDeleteEventHandler)Events[EventItemDeleting];
            if (handler != null) { 
                handler(this, e);
            } else { 
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemDeleting"));
                } 
            }
        }

 
        /// 
        /// Raises the event. 
        ///  
        protected virtual void OnItemInserted(FormViewInsertedEventArgs e) {
            FormViewInsertedEventHandler handler = (FormViewInsertedEventHandler)Events[EventItemInserted]; 
            if (handler != null) handler(this, e);
        }

 
        /// 
        /// Raises the  event. 
        ///  
        protected virtual void OnItemInserting(FormViewInsertEventArgs e) {
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            FormViewInsertEventHandler handler = (FormViewInsertEventHandler)Events[EventItemInserting];
            if (handler != null) {
                handler(this, e); 
            } else {
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemInserting")); 
                }
            } 
        }


        ///  
        /// Raises the event.
        ///  
        protected virtual void OnItemUpdated(FormViewUpdatedEventArgs e) { 
            FormViewUpdatedEventHandler handler = (FormViewUpdatedEventHandler)Events[EventItemUpdated];
            if (handler != null) handler(this, e); 
        }


        ///  
        /// Raises the  event.
        ///  
        protected virtual void OnItemUpdating(FormViewUpdateEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
 
            FormViewUpdateEventHandler handler = (FormViewUpdateEventHandler)Events[EventItemUpdating];
            if (handler != null) {
                handler(this, e);
            } else { 
                if (isBoundToDataSourceControl == false && e.Cancel == false) {
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemUpdating")); 
                } 
            }
        } 


        /// 
        /// Raises the event. 
        /// 
        protected virtual void OnModeChanged(EventArgs e) { 
            EventHandler handler = (EventHandler)Events[EventModeChanged]; 
            if (handler != null) handler(this, e);
        } 


        /// 
        /// Raises the  event. 
        /// 
        protected virtual void OnModeChanging(FormViewModeEventArgs e) { 
            bool isBoundToDataSourceControl = IsBoundUsingDataSourceID; 

            FormViewModeEventHandler handler = (FormViewModeEventHandler)Events[EventModeChanging]; 
            if (handler != null) {
                handler(this, e);
            } else {
                if (isBoundToDataSourceControl == false && e.Cancel == false) { 
                    throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ModeChanging"));
                } 
            } 
        }
 
        private void OnPagerPropertyChanged(object sender, EventArgs e) {
            if (Initialized) {
                RequiresDataBinding = true;
            } 
        }
 
        private bool PageIsValidAfterModelException() { 
            if (_modelValidationGroup == null) {
                return true; 
            }
            Page.Validate(_modelValidationGroup);
            return Page.IsValid;
        } 

        protected internal override void PerformDataBinding(IEnumerable data) { 
            base.PerformDataBinding(data); 
            if (IsBoundUsingDataSourceID && Mode == FormViewMode.Edit && IsViewStateEnabled) {
                ExtractRowValues(BoundFieldValues, false/*includeKeys*/); 
            }
        }

 
        /// 
        ///  
        protected internal virtual void PrepareControlHierarchy() { 
            if (Controls.Count < 1) {
                return; 
            }

            Debug.Assert(Controls[0] is Table);
 
            Table childTable = (Table)Controls[0];
 
            childTable.CopyBaseAttributes(this); 
            if (ControlStyleCreated && !ControlStyle.IsEmpty) {
                childTable.ApplyStyle(ControlStyle); 
            } else {
                // Since we didn't create a ControlStyle yet, the default
                // settings for the default style of the control need to be applied
                // to the child table control directly 
                //
 
                childTable.GridLines = GridLines.None; 
                childTable.CellSpacing = 0;
            } 
            childTable.Caption = Caption;
            childTable.CaptionAlign = CaptionAlign;

 
            Style compositeStyle;
            TableRowCollection rows = childTable.Rows; 
 
            foreach (FormViewRow row in rows) {
                compositeStyle = new TableItemStyle(); 
                DataControlRowState rowState = row.RowState;
                DataControlRowType rowType = row.RowType;

                switch (rowType) { 
                    case DataControlRowType.Header:
                        compositeStyle = _headerStyle; 
                        break; 

                    case DataControlRowType.Footer: 
                        compositeStyle = _footerStyle;
                        break;

                    case DataControlRowType.DataRow: 
                        compositeStyle.CopyFrom(_rowStyle);
 
                        if ((rowState & DataControlRowState.Edit) != 0) { 
                            compositeStyle.CopyFrom(_editRowStyle);
                        } 
                        if ((rowState & DataControlRowState.Insert) != 0) {
                            if (_insertRowStyle != null) {
                                compositeStyle.CopyFrom(_insertRowStyle);
                            } else { 
                                compositeStyle.CopyFrom(_editRowStyle);
                            } 
                        } 
                        break;
 
                    case DataControlRowType.Pager:
                        compositeStyle = _pagerStyle;
                        break;
                    case DataControlRowType.EmptyDataRow: 
                        compositeStyle = _emptyDataRowStyle;
                        break; 
                } 

                if (compositeStyle != null && row.Visible) { 
                    row.MergeStyle(compositeStyle);
                }
            }
        } 

        protected virtual void RaisePostBackEvent(string eventArgument) { 
            ValidateEvent(UniqueID, eventArgument); 

            int separatorIndex = eventArgument.IndexOf('$'); 
            if (separatorIndex < 0) {
                return;
            }
 
            CommandEventArgs cea = new CommandEventArgs(eventArgument.Substring(0, separatorIndex), eventArgument.Substring(separatorIndex + 1));
 
            FormViewCommandEventArgs dvcea = new FormViewCommandEventArgs(this, cea); 
            HandleEvent(dvcea, false, String.Empty);
        } 

        /// 
        /// Displays the control on the client.
        ///  
        protected internal override void Render(HtmlTextWriter writer) {
            if (Page != null) { 
                Page.VerifyRenderingInServerForm(this); 
            }
 
            if (RenderOuterTable) {
                PrepareControlHierarchy();
                RenderContents(writer);
            } else { 
                string propertyName = ModifiedOuterTableStylePropertyName();
                if (!string.IsNullOrEmpty(propertyName)) { 
                    throw new InvalidOperationException(SR.GetString(SR.IRenderOuterTableControl_CannotSetStyleWhenDisableRenderOuterTable, 
                        propertyName, GetType().Name, ID));
                } 

                if (Controls.Count > 0) {
                    //render the children of the inner table
                    Controls[0].RenderChildren(writer); 
                }
            } 
        } 

        private void ResetModelValidationGroup(bool causesValidation, string validationGroup) { 
            _modelValidationGroup = null;
            if (causesValidation && Page != null) {
                Page.Validate(validationGroup);
                if (EnableModelValidation) { 
                    _modelValidationGroup = validationGroup;
                } 
            } 
        }
 
        /// 
        /// Saves the control state for those properties that should persist across postbacks
        ///   even when EnableViewState=false.
        ///  
        protected internal override object SaveControlState() {
            object baseState = base.SaveControlState(); 
            if (baseState != null || 
                _pageIndex != 0 ||
                _mode != _defaultMode || 
                _defaultMode != FormViewMode.ReadOnly ||
                (_dataKeyNames != null && _dataKeyNames.Length > 0) ||
                (_keyTable != null && _keyTable.Count > 0) ||
                _pageCount != 0) { 
                object[] state = new object[7];
                object pageIndexState = null; 
                object modeState = null; 
                object defaultModeState = null;
                object keyNamesState = null; 
                object keyTableState = null;
                object pageCountState = null;

                if (_pageIndex != 0) { 
                    pageIndexState = _pageIndex;
                } 
                if (_defaultMode != FormViewMode.ReadOnly) { 
                    defaultModeState = (int)_defaultMode;
                } 
                // Only save the mode if it's different from the DefaultMode.  Otherwise, the Mode
                // getter will restore it to the DefaultMode value.
                if (_mode != _defaultMode && _modeSet) {
                    modeState = (int)_mode; 
                }
 
                if (_dataKeyNames != null && _dataKeyNames.Length > 0) { 
                    keyNamesState = _dataKeyNames;
                } 

                if (_keyTable != null) {
                    keyTableState = OrderedDictionaryStateHelper.SaveViewState(_keyTable);
                } 

                if (_pageCount != 0) { 
                    pageCountState = _pageCount; 
                }
 
                state[0] = baseState;
                state[1] = pageIndexState;
                state[2] = defaultModeState;
                state[3] = modeState; 
                state[4] = keyNamesState;
                state[5] = keyTableState; 
                state[6] = pageCountState; 

                return state; 
            }
            return true;    // return a dummy that ensures LoadControlState gets called but minimizes persisted size.
        }
 

        ///  
        /// Saves the current state of the . 
        /// 
        protected override object SaveViewState() { 
            object baseState = base.SaveViewState();
            object pagerStyleState = (_pagerStyle != null) ? ((IStateManager)_pagerStyle).SaveViewState() : null;
            object headerStyleState = (_headerStyle != null) ? ((IStateManager)_headerStyle).SaveViewState() : null;
            object footerStyleState = (_footerStyle != null) ? ((IStateManager)_footerStyle).SaveViewState() : null; 
            object rowStyleState = (_rowStyle != null) ? ((IStateManager)_rowStyle).SaveViewState() : null;
            object editRowStyleState = (_editRowStyle != null) ? ((IStateManager)_editRowStyle).SaveViewState() : null; 
            object insertRowStyleState = (_insertRowStyle != null) ? ((IStateManager)_insertRowStyle).SaveViewState() : null; 
            object boundFieldValuesState = (_boundFieldValues != null) ? OrderedDictionaryStateHelper.SaveViewState(_boundFieldValues) : null;
            object pagerSettingsState = (_pagerSettings != null) ? ((IStateManager)_pagerSettings).SaveViewState() : null; 
            object controlState = ControlStyleCreated ? ((IStateManager)ControlStyle).SaveViewState() : null;

            object[] myState = new object[10];
            myState[0] = baseState; 
            myState[1] = pagerStyleState;
            myState[2] = headerStyleState; 
            myState[3] = footerStyleState; 
            myState[4] = rowStyleState;
            myState[5] = editRowStyleState; 
            myState[6] = insertRowStyleState;
            myState[7] = boundFieldValuesState;
            myState[8] = pagerSettingsState;
            myState[9] = controlState; 

            // note that we always have some state, atleast the RowCount 
            return myState; 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
          Justification = "A property already exists. This method does additional work.")]
        public void SetPageIndex(int index) {
            HandlePage(index); 
        }
 
        private void SelectCallback(IEnumerable data) { 
            // The data source should have thrown.  If we're here, it didn't.  We'll throw for it
            // with a generic message. 
            throw new HttpException(SR.GetString(SR.DataBoundControl_DataSourceDoesntSupportPaging));
        }

        ///  
        /// Marks the starting point to begin tracking and saving changes to the
        /// control as part of the control viewstate. 
        ///  
        protected override void TrackViewState() {
            base.TrackViewState(); 

            if (_pagerStyle != null)
                ((IStateManager)_pagerStyle).TrackViewState();
            if (_headerStyle != null) 
                ((IStateManager)_headerStyle).TrackViewState();
            if (_footerStyle != null) 
                ((IStateManager)_footerStyle).TrackViewState(); 
            if (_rowStyle != null)
                ((IStateManager)_rowStyle).TrackViewState(); 
            if (_editRowStyle != null)
                ((IStateManager)_editRowStyle).TrackViewState();
            if (_insertRowStyle != null)
                ((IStateManager)_insertRowStyle).TrackViewState(); 
            if (_pagerSettings != null)
                ((IStateManager)_pagerSettings).TrackViewState(); 
            if (ControlStyleCreated) 
                ((IStateManager)ControlStyle).TrackViewState();
        } 

        public virtual void UpdateItem(bool causesValidation) {
            ResetModelValidationGroup(causesValidation, String.Empty);
            HandleUpdate(String.Empty, causesValidation); 
        }
 
        #region IPostBackContainer implementation 
        PostBackOptions IPostBackContainer.GetPostBackOptions(IButtonControl buttonControl) {
            if (buttonControl == null) { 
                throw new ArgumentNullException("buttonControl");
            }

            if (buttonControl.CausesValidation) { 
                throw new InvalidOperationException(SR.GetString(SR.CannotUseParentPostBackWhenValidating, this.GetType().Name, ID));
            } 
 
            PostBackOptions options = new PostBackOptions(this, buttonControl.CommandName + "$" + buttonControl.CommandArgument);
            options.RequiresJavaScriptProtocol = true; 

            return options;
        }
        #endregion 

        #region IPostBackEventHandler implementation 
        void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) { 
            RaisePostBackEvent(eventArgument);
        } 
        #endregion

        #region IDataItemContainer implementation
        int IDataItemContainer.DataItemIndex { 
            get {
                return DataItemIndex; 
            } 
        }
 
        int IDataItemContainer.DisplayIndex {
            get {
                return 0;
            } 
        }
        #endregion 
 
        #region IDataBoundItemControl implementation
 
        DataKey IDataBoundItemControl.DataKey {
            get {
                return DataKey;
            } 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", 
            Justification = "The property is only used to genericly access the databound control's mode, and should only be accessed through the interface")]
        DataBoundControlMode IDataBoundItemControl.Mode { 
            get {
                switch (Mode) {
                    case FormViewMode.Edit:
                        return DataBoundControlMode.Edit; 
                    case FormViewMode.Insert:
                        return DataBoundControlMode.Insert; 
                    case FormViewMode.ReadOnly: 
                        return DataBoundControlMode.ReadOnly;
                    default: 
                        Debug.Fail("shouldn't get here!");
                        return DataBoundControlMode.ReadOnly;
                }
            } 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")] 
        string IDataBoundControl.DataSourceID {
            get { 
                return DataSourceID;
            }
            set {
                DataSourceID = value; 
            }
        } 
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")]
        IDataSource IDataBoundControl.DataSourceObject { 
            get {
                return DataSourceObject;
            }
        } 

        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")] 
        object IDataBoundControl.DataSource { 
            get {
                return DataSource; 
            }
            set {
                DataSource = value;
            } 
        }
 
        string[] IDataBoundControl.DataKeyNames { 
            get {
                return DataKeyNames; 
            }
            set {
                DataKeyNames = value;
            } 
        }
 
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")] 
        string IDataBoundControl.DataMember {
            get { 
                return DataMember;
            }
            set {
                DataMember = value; 
            }
        } 
 
        #endregion
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK