DataList.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

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

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

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.Collections; 
    using System.ComponentModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Web;
    using System.Web.UI; 
    using System.Web.Util;
 
    ///  
    ///    
    ///       Creates 
    ///       a control to display a data-bound list.
    ///    
    /// 
    [ 
    ControlValueProperty("SelectedValue"),
    Editor("System.Web.UI.Design.WebControls.DataListComponentEditor, " + AssemblyRef.SystemDesign, typeof(ComponentEditor)), 
    Designer("System.Web.UI.Design.WebControls.DataListDesigner, " + AssemblyRef.SystemDesign) 
    ]
    public class DataList : BaseDataList, INamingContainer, IRepeatInfoUser, IWizardSideBarListControl { 

        private static readonly object EventItemCreated = new object();
        private static readonly object EventItemDataBound = new object();
        private static readonly object EventItemCommand = new object(); 
        private static readonly object EventEditCommand = new object();
        private static readonly object EventUpdateCommand = new object(); 
        private static readonly object EventCancelCommand = new object(); 
        private static readonly object EventDeleteCommand = new object();
        private static readonly object EventWizardListItemDataBound = new object(); 


        /// 
        /// Specifies the  command. This field is constant. 
        /// 
        public const string SelectCommandName = "Select"; 
 
        /// 
        /// Specifies the  command. This field is constant 
        /// 
        public const string EditCommandName = "Edit";

        ///  
        /// Specifies the  command. This field is constant
        ///  
        public const string UpdateCommandName = "Update"; 

        ///  
        /// Specifies the  command. This field is constant
        /// 
        public const string CancelCommandName = "Cancel";
 
        /// 
        /// Specifies the  command. This field is constant 
        ///  
        public const string DeleteCommandName = "Delete";
 
        private TableItemStyle itemStyle;
        private TableItemStyle alternatingItemStyle;
        private TableItemStyle selectedItemStyle;
        private TableItemStyle editItemStyle; 
        private TableItemStyle separatorStyle;
        private TableItemStyle headerStyle; 
        private TableItemStyle footerStyle; 

        private ITemplate itemTemplate; 
        private ITemplate alternatingItemTemplate;
        private ITemplate selectedItemTemplate;
        private ITemplate editItemTemplate;
        private ITemplate separatorTemplate; 
        private ITemplate headerTemplate;
        private ITemplate footerTemplate; 
 
        private bool extractTemplateRows;
 
        private ArrayList itemsArray;
        private DataListItemCollection itemsCollection;

        private int offset; 
        private int visibleItemCount = -1;
 
        ///  
        ///    
        ///       Initializes a new instance of the  class. 
        ///    
        /// 
        public DataList() {
            offset = 0; 
            visibleItemCount = -1;
        } 
 

 
        /// 
        /// Gets the style properties for alternating items in the . This
        ///    property is read-only. 
        ///  
        [
        WebCategory("Styles"), 
        DefaultValue(null), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.DataList_AlternatingItemStyle)
        ]
        public virtual TableItemStyle AlternatingItemStyle { 
            get {
                if (alternatingItemStyle == null) { 
                    alternatingItemStyle = new TableItemStyle(); 
                    if (IsTrackingViewState)
                        ((IStateManager)alternatingItemStyle).TrackViewState(); 
                }
                return alternatingItemStyle;
            }
        } 

 
        ///  
        /// Indicates the template to use for alternating items in the .
        ///  
        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(DataListItem)),
        WebSysDescription(SR.DataList_AlternatingItemTemplate) 
        ] 
        public virtual ITemplate AlternatingItemTemplate {
            get { 
                return alternatingItemTemplate;
            }
            set {
                alternatingItemTemplate = value; 
            }
        } 
 

        ///  
        ///    Indicates the ordinal index of the item to be edited.
        /// 
        [
        WebCategory("Default"), 
        DefaultValue(-1),
        WebSysDescription(SR.DataList_EditItemIndex) 
        ] 
        public virtual int EditItemIndex {
            get { 
                object o = ViewState["EditItemIndex"];
                if (o != null) {
                    return (int)o;
                } 
                return -1;
            } 
            set { 
                if (value < -1) {
                    throw new ArgumentOutOfRangeException("value"); 
                }
                ViewState["EditItemIndex"] = value;
            }
        } 

 
        ///  
        ///    Indicates the style properties of the item to be edited.
        ///  
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.DataList_EditItemStyle) 
        ]
        public virtual TableItemStyle EditItemStyle { 
            get {
                if (editItemStyle == null) {
                    editItemStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)editItemStyle).TrackViewState();
                } 
                return editItemStyle; 
            }
        } 


        /// 
        /// Indicates the template to use for an item set in edit mode within the . 
        /// 
        [ 
        Browsable(false), 
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(DataListItem)),
        WebSysDescription(SR.DataList_EditItemTemplate)
        ]
        public virtual ITemplate EditItemTemplate { 
            get {
                return editItemTemplate; 
            } 
            set {
                editItemTemplate = value; 
            }
        }

 
        /// 
        ///    Indicates whether to extract template rows. 
        ///  
        [
        WebCategory("Layout"), 
        DefaultValue(false),
        WebSysDescription(SR.DataList_ExtractTemplateRows)
        ]
        public virtual bool ExtractTemplateRows { 
            get {
                object o = ViewState["ExtractTemplateRows"]; 
                if (o != null) 
                    return(bool)o;
                return false; 
            }
            set {
                ViewState["ExtractTemplateRows"] = value;
            } 
        }
 
 
        /// 
        ///    Gets the style properties of the footer item. 
        /// 
        [
        WebCategory("Styles"),
        DefaultValue(null), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.DataControls_FooterStyle)
        ] 
        public virtual TableItemStyle FooterStyle {
            get {
                if (footerStyle == null) {
                    footerStyle = new TableItemStyle(); 
                    if (IsTrackingViewState)
                        ((IStateManager)footerStyle).TrackViewState(); 
                } 
                return footerStyle;
            } 
        }


        ///  
        ///  Indicates the template to use for the footer in the .
        ///  
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(DataListItem)),
        WebSysDescription(SR.DataList_FooterTemplate)
        ] 
        public virtual ITemplate FooterTemplate {
            get { 
                return footerTemplate; 
            }
            set { 
                footerTemplate = value;
            }
        }
 

        ///  
        ///    Indicates a value that specifies the grid line style. 
        /// 
        [ 
        DefaultValue(GridLines.None)
        ]
        public override GridLines GridLines {
            get { 
                if (ControlStyleCreated == false) {
                    return GridLines.None; 
                } 
                return ((TableStyle)ControlStyle).GridLines;
            } 
            set {
                base.GridLines = value;
            }
        } 

 
        ///  
        ///    Gets the style properties of the header item.
        ///  
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.DataControls_HeaderStyle) 
        ]
        public virtual TableItemStyle HeaderStyle { 
            get {
                if (headerStyle == null) {
                    headerStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)headerStyle).TrackViewState();
                } 
                return headerStyle; 
            }
        } 


        /// 
        /// Indicates the template to use for the header in the . 
        /// 
        [ 
        Browsable(false), 
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(DataListItem)),
        WebSysDescription(SR.DataList_HeaderTemplate)
        ]
        public virtual ITemplate HeaderTemplate { 
            get {
                return headerTemplate; 
            } 
            set {
                headerTemplate = value; 
            }
        }

 
        /// 
        /// Gets a collection of  objects representing the individual 
        ///    items within the control. 
        /// 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.DataList_Items)
        ] 
        public virtual DataListItemCollection Items {
            get { 
                if (itemsCollection == null) { 
                    if (itemsArray == null) {
                        EnsureChildControls(); 
                    }
                    if (itemsArray == null) {
                        itemsArray = new ArrayList();
                    } 
                    itemsCollection = new DataListItemCollection(itemsArray);
                } 
                return itemsCollection; 
            }
        } 


        /// 
        ///    Indicates the style properties of the individual items. 
        /// 
        [ 
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.DataList_ItemStyle)
        ] 
        public virtual TableItemStyle ItemStyle {
            get { 
                if (itemStyle == null) { 
                    itemStyle = new TableItemStyle();
                    if (IsTrackingViewState) 
                        ((IStateManager)itemStyle).TrackViewState();
                }
                return itemStyle;
            } 
        }
 
 
        /// 
        /// Indicates the template to use for an item in the . 
        /// 
        [
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(DataListItem)), 
        WebSysDescription(SR.DataList_ItemTemplate), 
        SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
            Justification = "Interface denotes existence of property, not used for security.") 
        ]
        public virtual ITemplate ItemTemplate {
            get {
                return itemTemplate; 
            }
            set { 
                itemTemplate = value; 
            }
        } 


        /// 
        ///    Indicates the number of columns to repeat. 
        /// 
        [ 
        WebCategory("Layout"), 
        DefaultValue(0),
        WebSysDescription(SR.DataList_RepeatColumns) 
        ]
        public virtual int RepeatColumns {
            get {
                object o = ViewState["RepeatColumns"]; 
                if (o != null)
                    return(int)o; 
                return 0; 
            }
            set { 
                if (value < 0) {
                    throw new ArgumentOutOfRangeException("value");
                }
                ViewState["RepeatColumns"] = value; 
            }
        } 
 

        ///  
        ///    Indicates whether the control is displayed vertically or horizontally.
        /// 
        [
        WebCategory("Layout"), 
        DefaultValue(RepeatDirection.Vertical),
        WebSysDescription(SR.Item_RepeatDirection) 
        ] 
        public virtual RepeatDirection RepeatDirection {
            get { 
                object o = ViewState["RepeatDirection"];
                if (o != null)
                    return(RepeatDirection)o;
                return RepeatDirection.Vertical; 
            }
            set { 
                if (value < RepeatDirection.Horizontal || value > RepeatDirection.Vertical) { 
                    throw new ArgumentOutOfRangeException("value");
                } 
                ViewState["RepeatDirection"] = value;
            }
        }
 

        ///  
        ///    Gets or sets a value that indicates whether the control is displayed in table 
        ///       or flow layout.
        ///  
        [
        WebCategory("Layout"),
        DefaultValue(RepeatLayout.Table),
        WebSysDescription(SR.WebControl_RepeatLayout) 
        ]
        public virtual RepeatLayout RepeatLayout { 
            get { 
                object o = ViewState["RepeatLayout"];
                if (o != null) 
                    return(RepeatLayout)o;
                return RepeatLayout.Table;
            }
            set { 
                if ((value == RepeatLayout.UnorderedList) ||
                    (value == RepeatLayout.OrderedList)) { 
                        throw new ArgumentOutOfRangeException("value", SR.GetString(SR.DataList_LayoutNotSupported, value)); 
                }
 
                EnumerationRangeValidationUtil.ValidateRepeatLayout(value);
                ViewState["RepeatLayout"] = value;
            }
        } 

 
        ///  
        ///     Indicates the index of
        ///       the currently selected item. 
        /// 
        [
        Bindable(true),
        DefaultValue(-1), 
        WebSysDescription(SR.WebControl_SelectedIndex),
        SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces", 
            Justification = "Interface denotes existence of property, not used for security.") 
        ]
        public virtual int SelectedIndex { 
            get {
                object o = ViewState["SelectedIndex"];
                if (o != null) {
                    return (int)o; 
                }
                return -1; 
            } 
            set {
                if (value < -1) { 
                    throw new ArgumentOutOfRangeException("value");
                }
                int oldSelectedIndex = SelectedIndex;
                ViewState["SelectedIndex"] = value; 

                if (itemsArray != null) { 
                    DataListItem item; 

                    if ((oldSelectedIndex != -1) && (itemsArray.Count > oldSelectedIndex)) { 
                        item = (DataListItem)itemsArray[oldSelectedIndex];

                        if (item.ItemType != ListItemType.EditItem) {
                            ListItemType itemType = ListItemType.Item; 
                            if (oldSelectedIndex % 2 != 0)
                                itemType = ListItemType.AlternatingItem; 
                            item.SetItemType(itemType); 
                        }
                    } 
                    if ((value != -1) && (itemsArray.Count > value)) {
                        item = (DataListItem)itemsArray[value];
                        if (item.ItemType != ListItemType.EditItem)
                            item.SetItemType(ListItemType.SelectedItem); 
                    }
                } 
            } 
        }
 

        /// 
        /// Gets the selected item in the .
        ///  
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        WebSysDescription(SR.DataList_SelectedItem)
        ] 
        public virtual DataListItem SelectedItem {
            get {
                int index = SelectedIndex;
                DataListItem item = null; 

                if (index != -1) { 
                    item = Items[index]; 
                }
                return item; 
            }
        }

 
        /// 
        ///    Indicates the style properties of the currently 
        ///       selected item. 
        /// 
        [ 
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true), 
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.DataList_SelectedItemStyle) 
        ] 
        public virtual TableItemStyle SelectedItemStyle {
            get { 
                if (selectedItemStyle == null) {
                    selectedItemStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)selectedItemStyle).TrackViewState(); 
                }
                return selectedItemStyle; 
            } 
        }
 

        /// 
        /// Indicates the template to use for the currently selected item in the .
        ///  
        [
        Browsable(false), 
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(DataListItem)), 
        WebSysDescription(SR.DataList_SelectedItemTemplate)
        ]
        public virtual ITemplate SelectedItemTemplate {
            get { 
                return selectedItemTemplate;
            } 
            set { 
                selectedItemTemplate = value;
            } 
        }


        [ 
        Browsable(false)
        ] 
        public object SelectedValue { 
            get {
                if (DataKeyField.Length == 0) { 
                    throw new InvalidOperationException(SR.GetString(SR.DataList_DataKeyFieldMustBeSpecified, ID));
                }
                DataKeyCollection keys = DataKeys;
                int selectedIndex = SelectedIndex; 
                if (keys != null && selectedIndex < keys.Count && selectedIndex > -1) {
                    return keys[selectedIndex]; 
                } 
                return null;
            } 
        }


        ///  
        ///    Indicates the style properties of the separator between each item in the
        ///    . 
        ///  
        [
        WebCategory("Styles"), 
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty), 
        WebSysDescription(SR.DataList_SeparatorStyle)
        ] 
        public virtual TableItemStyle SeparatorStyle { 
            get {
                if (separatorStyle == null) { 
                    separatorStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)separatorStyle).TrackViewState();
                } 
                return separatorStyle;
            } 
        } 

 
        /// 
        /// Indicates the template to use for the separator in the .
        /// 
        [ 
        Browsable(false),
        DefaultValue(null), 
        PersistenceMode(PersistenceMode.InnerProperty), 
        TemplateContainer(typeof(DataListItem)),
        WebSysDescription(SR.DataList_SeparatorTemplate) 
        ]
        public virtual ITemplate SeparatorTemplate {
            get {
                return separatorTemplate; 
            }
            set { 
                separatorTemplate = value; 
            }
        } 


        /// 
        ///    Gets or sets a value that specifies whether the footer is displayed in the 
        ///    .
        ///  
        [ 
        WebCategory("Appearance"),
        DefaultValue(true), 
        WebSysDescription(SR.DataControls_ShowFooter)
        ]
        public virtual bool ShowFooter {
            get { 
                object o = ViewState["ShowFooter"];
                if (o != null) 
                    return(bool)o; 
                return true;
            } 
            set {
                ViewState["ShowFooter"] = value;
            }
        } 

 
        ///  
        /// Gets or sets a value that specifies whether the header is displayed in the.
        ///  
        [
        WebCategory("Appearance"),
        DefaultValue(true),
        WebSysDescription(SR.DataControls_ShowHeader) 
        ]
        public virtual bool ShowHeader { 
            get { 
                object o = ViewState["ShowHeader"];
                if (o != null) 
                    return(bool)o;
                return true;
            }
            set { 
                ViewState["ShowHeader"] = value;
            } 
        } 

        protected override HtmlTextWriterTag TagKey { 
            get {
                return RepeatLayout == RepeatLayout.Table?
                    HtmlTextWriterTag.Table : HtmlTextWriterTag.Span;
            } 
        }
 
 
        /// 
        /// Occurs when a control bubbles an event to the  with a 
        ///  property of .
        /// 
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataList_OnCancelCommand)
        ] 
        public event DataListCommandEventHandler CancelCommand { 
            add {
                Events.AddHandler(EventCancelCommand, value); 
            }
            remove {
                Events.RemoveHandler(EventCancelCommand, value);
            } 
        }
 
 
        /// 
        /// Occurs when a control bubbles an event to the  with a 
        ///  property of .
        /// 
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataList_OnDeleteCommand)
        ] 
        public event DataListCommandEventHandler DeleteCommand { 
            add {
                Events.AddHandler(EventDeleteCommand, value); 
            }
            remove {
                Events.RemoveHandler(EventDeleteCommand, value);
            } 
        }
 
 

        ///  
        /// Occurs when a control bubbles an event to the  with a
        ///  property of .
        /// 
        [ 
        WebCategory("Action"),
        WebSysDescription(SR.DataList_OnEditCommand) 
        ] 
        public event DataListCommandEventHandler EditCommand {
            add { 
                Events.AddHandler(EventEditCommand, value);
            }
            remove {
                Events.RemoveHandler(EventEditCommand, value); 
            }
        } 
 

        ///  
        /// Occurs when a control bubbles an event to the  not covered by
        /// , ,  or
        /// .
        ///  
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataList_OnItemCommand) 
        ]
        public event DataListCommandEventHandler ItemCommand { 
            add {
                Events.AddHandler(EventItemCommand, value);
            }
            remove { 
                Events.RemoveHandler(EventItemCommand, value);
            } 
        } 

 
        /// 
        ///    Occurs on the server when a control a created.
        /// 
        [ 
        WebCategory("Behavior"),
        WebSysDescription(SR.DataControls_OnItemCreated) 
        ] 
        public event DataListItemEventHandler ItemCreated {
            add { 
                Events.AddHandler(EventItemCreated, value);
            }
            remove {
                Events.RemoveHandler(EventItemCreated, value); 
            }
        } 
 

        ///  
        ///    Occurs when an item is data bound to the control.
        /// 
        [
        WebCategory("Behavior"), 
        WebSysDescription(SR.DataControls_OnItemDataBound)
        ] 
        public event DataListItemEventHandler ItemDataBound { 
            add {
                Events.AddHandler(EventItemDataBound, value); 
            }
            remove {
                Events.RemoveHandler(EventItemDataBound, value);
            } 
        }
 
 
        /// 
        /// Occurs when a control bubbles an event to the  with a 
        ///  property of .
        /// 
        [
        WebCategory("Action"), 
        WebSysDescription(SR.DataList_OnUpdateCommand)
        ] 
        public event DataListCommandEventHandler UpdateCommand { 
            add {
                Events.AddHandler(EventUpdateCommand, value); 
            }
            remove {
                Events.RemoveHandler(EventUpdateCommand, value);
            } 
        }
 
 
        /// 
        ///  
        /// 
        protected override void CreateControlHierarchy(bool useDataSource) {
            IEnumerable dataSource = null;
            int count = -1; 
            ArrayList keysArray = DataKeysArray;
 
            // cache this, so we don't need to go to the statebag each time 
            extractTemplateRows = this.ExtractTemplateRows;
 
            if (itemsArray != null) {
                itemsArray.Clear();
            }
            else { 
                itemsArray = new ArrayList();
            } 
 
            if (useDataSource == false) {
                // ViewState must have a non-null value for ItemCount because we check for 
                // this in CreateChildControls
                count = (int)ViewState[BaseDataList.ItemCountViewStateKey];
                if (count != -1) {
                    dataSource = new DummyDataSource(count); 
                    itemsArray.Capacity = count;
                } 
            } 
            else {
                keysArray.Clear(); 
                dataSource = GetData();

                ICollection collection = dataSource as ICollection;
                if (collection != null) { 
                    keysArray.Capacity = collection.Count;
                    itemsArray.Capacity = collection.Count; 
                } 
            }
 
            if (dataSource != null) {
                ControlCollection controls = Controls;
                DataListItem item;
                ListItemType itemType; 
                int index = 0;
 
                bool hasSeparators = (separatorTemplate != null); 
                int editItemIndex = EditItemIndex;
                int selectedItemIndex = SelectedIndex; 
                string keyField = DataKeyField;
                bool storeKeys = (useDataSource && (keyField.Length != 0));

                count = 0; 

                if (headerTemplate != null) { 
                    CreateItem(-1, ListItemType.Header, useDataSource, null); 
                }
 
                foreach (object dataItem in dataSource) {
                    if (storeKeys) {
                        object keyValue = DataBinder.GetPropertyValue(dataItem, keyField);
                        keysArray.Add(keyValue); 
                    }
 
                    itemType = ListItemType.Item; 
                    if (index == editItemIndex) {
                        itemType = ListItemType.EditItem; 
                    }
                    else if (index == selectedItemIndex) {
                        itemType = ListItemType.SelectedItem;
                    } 
                    else if (index % 2 != 0) {
                        itemType = ListItemType.AlternatingItem; 
                    } 

                    item = CreateItem(index, itemType, useDataSource, dataItem); 
                    itemsArray.Add(item);

                    if (hasSeparators) {
                        CreateItem(index, ListItemType.Separator, useDataSource, null); 
                    }
 
                    count++; 
                    index++;
                } 

                if (footerTemplate != null) {
                    CreateItem(-1, ListItemType.Footer, useDataSource, null);
                } 
            }
 
            if (useDataSource) { 
                // save the number of items contained in the DataList for use in round-trips
                ViewState[BaseDataList.ItemCountViewStateKey] = ((dataSource != null) ? count : -1); 
            }
        }

 
        /// 
        ///  
        ///  
        protected override Style CreateControlStyle() {
            TableStyle controlStyle = new TableStyle(); 

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

        ///  
        /// 
        private DataListItem CreateItem(int itemIndex, ListItemType itemType, bool dataBind, object dataItem) {
            DataListItem item = CreateItem(itemIndex, itemType);
            DataListItemEventArgs e = new DataListItemEventArgs(item); 

            InitializeItem(item); 
            if (dataBind) { 
                item.DataItem = dataItem;
            } 
            OnItemCreated(e);
            Controls.Add(item);

            if (dataBind) { 
                item.DataBind();
                OnItemDataBound(e); 
 
                item.DataItem = null;
            } 

            return item;
        }
 

        ///  
        ///  
        protected virtual DataListItem CreateItem(int itemIndex, ListItemType itemType) {
            return new DataListItem(itemIndex, itemType); 
        }


        private DataListItem GetItem(ListItemType itemType, int repeatIndex) { 
            DataListItem item = null;
 
            switch (itemType) { 
                case ListItemType.Header:
                    Debug.Assert(((IRepeatInfoUser)this).HasHeader); 
                    item = (DataListItem)Controls[0];
                    break;
                case ListItemType.Footer:
                    Debug.Assert(((IRepeatInfoUser)this).HasFooter); 
                    item = (DataListItem)Controls[Controls.Count - 1];
                    break; 
                case ListItemType.Separator: 
                    Debug.Assert(((IRepeatInfoUser)this).HasSeparators);
                    { 
                        int controlIndex = repeatIndex * 2 + 1;
                        if (headerTemplate != null) {
                            controlIndex++;
                        } 
                        item = (DataListItem)Controls[controlIndex];
                    } 
                    break; 
                case ListItemType.Item:
                case ListItemType.AlternatingItem: 
                case ListItemType.SelectedItem:
                case ListItemType.EditItem:
                    item = (DataListItem)itemsArray[repeatIndex];
                    break; 
            }
 
            return item; 
        }
 

        /// 
        /// 
        protected virtual void InitializeItem(DataListItem item) { 
            ITemplate contentTemplate = itemTemplate;
 
            switch (item.ItemType) { 
                case ListItemType.Header:
                    contentTemplate = headerTemplate; 
                    break;

                case ListItemType.Footer:
                    contentTemplate = footerTemplate; 
                    break;
 
                case ListItemType.AlternatingItem: 
                    if (alternatingItemTemplate != null) {
                        contentTemplate = alternatingItemTemplate; 
                    }
                    break;

                case ListItemType.SelectedItem: 
                    if (selectedItemTemplate != null) {
                        contentTemplate = selectedItemTemplate; 
                    } 
                    else {
                        if (item.ItemIndex % 2 != 0) 
                            goto case ListItemType.AlternatingItem;
                    }
                    break;
 
                case ListItemType.EditItem:
                    if (editItemTemplate != null) { 
                        contentTemplate = editItemTemplate; 
                    }
                    else { 
                        if (item.ItemIndex == SelectedIndex)
                            goto case ListItemType.SelectedItem;
                        else if (item.ItemIndex % 2 != 0)
                            goto case ListItemType.AlternatingItem; 
                    }
                    break; 
 
                case ListItemType.Separator:
                    contentTemplate = separatorTemplate; 
                    break;
            }

            if (contentTemplate != null) 
                contentTemplate.InstantiateIn(item);
        } 
 

        ///  
        /// 
        /// 
        protected override void LoadViewState(object savedState) {
            if (savedState != null) { 
                object[] myState = (object[])savedState;
 
                if (myState[0] != null) 
                    base.LoadViewState(myState[0]);
                if (myState[1] != null) 
                    ((IStateManager)ItemStyle).LoadViewState(myState[1]);
                if (myState[2] != null)
                    ((IStateManager)SelectedItemStyle).LoadViewState(myState[2]);
                if (myState[3] != null) 
                    ((IStateManager)AlternatingItemStyle).LoadViewState(myState[3]);
                if (myState[4] != null) 
                    ((IStateManager)EditItemStyle).LoadViewState(myState[4]); 
                if (myState[5] != null)
                    ((IStateManager)SeparatorStyle).LoadViewState(myState[5]); 
                if (myState[6] != null)
                    ((IStateManager)HeaderStyle).LoadViewState(myState[6]);
                if (myState[7] != null)
                    ((IStateManager)FooterStyle).LoadViewState(myState[7]); 
                if (myState[8] != null)
                    ((IStateManager)ControlStyle).LoadViewState(myState[8]); 
            } 
        }
 

        /// 
        /// 
        ///  
        protected override bool OnBubbleEvent(object source, EventArgs e) {
            bool handled = false; 
 
            if (e is DataListCommandEventArgs) {
                DataListCommandEventArgs dce = (DataListCommandEventArgs)e; 

                OnItemCommand(dce);
                handled = true;
 
                string command = dce.CommandName;
 
                if (StringUtil.EqualsIgnoreCase(command, DataList.SelectCommandName)) { 
                    SelectedIndex = dce.Item.ItemIndex;
                    OnSelectedIndexChanged(EventArgs.Empty); 
                }
                else if (StringUtil.EqualsIgnoreCase(command, DataList.EditCommandName)) {
                    OnEditCommand(dce);
                } 
                else if (StringUtil.EqualsIgnoreCase(command, DataList.DeleteCommandName)) {
                    OnDeleteCommand(dce); 
                } 
                else if (StringUtil.EqualsIgnoreCase(command, DataList.UpdateCommandName)) {
                    OnUpdateCommand(dce); 
                }
                else if (StringUtil.EqualsIgnoreCase(command, DataList.CancelCommandName)) {
                    OnCancelCommand(dce);
                } 
            }
 
            return handled; 
        }
 

        /// 
        /// Raises the event.
        ///  
        protected virtual void OnCancelCommand(DataListCommandEventArgs e) {
            DataListCommandEventHandler onCancelCommandHandler = (DataListCommandEventHandler)Events[EventCancelCommand]; 
            if (onCancelCommandHandler != null) onCancelCommandHandler(this, e); 
        }
 

        /// 
        /// Raises the event.
        ///  
        protected virtual void OnDeleteCommand(DataListCommandEventArgs e) {
            DataListCommandEventHandler onDeleteCommandHandler = (DataListCommandEventHandler)Events[EventDeleteCommand]; 
            if (onDeleteCommandHandler != null) onDeleteCommandHandler(this, e); 
        }
 

        /// 
        /// Raises the event.
        ///  
        protected virtual void OnEditCommand(DataListCommandEventArgs e) {
            DataListCommandEventHandler onEditCommandHandler = (DataListCommandEventHandler)Events[EventEditCommand]; 
            if (onEditCommandHandler != null) onEditCommandHandler(this, e); 
        }
 

        /// 
        /// DataList initialization.
        ///  
        protected internal override void OnInit(EventArgs e) {
            base.OnInit(e); 
            if (Page != null && DataKeyField.Length > 0) { 
                Page.RegisterRequiresViewStateEncryption();
            } 
        }


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


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


        ///  
        /// Raises the event.
        ///  
        protected virtual void OnItemDataBound(DataListItemEventArgs e) { 
            DataListItemEventHandler onItemDataBoundHandler = (DataListItemEventHandler)Events[EventItemDataBound];
            if (onItemDataBoundHandler != null) onItemDataBoundHandler(this, e); 

            // EventWizardListItemDataBound is a key for an internal event declared on IWizardSideBarListControl, which is
            // an interface that is meant to provide a facade to make ListView and DataList look the same. This handler
            // is meant to abstract away the differences between each controls ItemDataBound events. 
            var onWizardListItemDataBoundHandler = (EventHandler)Events[EventWizardListItemDataBound];
            if (onWizardListItemDataBoundHandler != null) { 
                var item = e.Item; 
                var wizardListEventArgs = new WizardSideBarListControlItemEventArgs(new WizardSideBarListControlItem(item.DataItem, item.ItemType, item.ItemIndex, item));
                onWizardListItemDataBoundHandler(this, wizardListEventArgs); 
            }
        }

 
        /// 
        /// Raises the event. 
        ///  
        protected virtual void OnUpdateCommand(DataListCommandEventArgs e) {
            DataListCommandEventHandler onUpdateCommandHandler = (DataListCommandEventHandler)Events[EventUpdateCommand]; 
            if (onUpdateCommandHandler != null) onUpdateCommandHandler(this, e);
        }

 
        /// 
        ///  
        ///  
        protected internal override void PrepareControlHierarchy() {
            ControlCollection controls = Controls; 
            int controlCount = controls.Count;

            if (controlCount == 0)
                return; 

            // the composite alternating item style, so we need to do just one 
            // merge style on the actual item 
            Style altItemStyle = null;
            if (alternatingItemStyle != null) { 
                altItemStyle = new TableItemStyle();
                altItemStyle.CopyFrom(itemStyle);
                altItemStyle.CopyFrom(alternatingItemStyle);
            } 
            else {
                altItemStyle = itemStyle; 
            } 

            Style compositeStyle; 

            for (int i = 0; i < controlCount; i++) {
                DataListItem item = (DataListItem)controls[i];
                compositeStyle = null; 

                switch (item.ItemType) { 
                    case ListItemType.Header: 
                        if (ShowHeader)
                            compositeStyle = headerStyle; 
                        break;

                    case ListItemType.Footer:
                        if (ShowFooter) 
                            compositeStyle = footerStyle;
                        break; 
 
                    case ListItemType.Separator:
                        compositeStyle = separatorStyle; 
                        break;

                    case ListItemType.Item:
                        compositeStyle = itemStyle; 
                        break;
 
                    case ListItemType.AlternatingItem: 
                        compositeStyle = altItemStyle;
                        break; 

                    case ListItemType.SelectedItem:
                        // When creating the control hierarchy we first check if the
                        // item is in edit mode, so we know this item cannot be in edit 
                        // mode. The only special characteristic of this item is that
                        // it is selected. 
                        { 
                            compositeStyle = new TableItemStyle();
 
                            if (item.ItemIndex % 2 != 0)
                                compositeStyle.CopyFrom(altItemStyle);
                            else
                                compositeStyle.CopyFrom(itemStyle); 
                            compositeStyle.CopyFrom(selectedItemStyle);
                        } 
                        break; 

                    case ListItemType.EditItem: 
                        // When creating the control hierarchy, we first check if the
                        // item is in edit mode. So an item may be selected too, and
                        // so both editItemStyle (more specific) and selectedItemStyle
                        // are applied. 
                        {
                            compositeStyle = new TableItemStyle(); 
 
                            if (item.ItemIndex % 2 != 0)
                                compositeStyle.CopyFrom(altItemStyle); 
                            else
                                compositeStyle.CopyFrom(itemStyle);
                            if (item.ItemIndex == SelectedIndex)
                                compositeStyle.CopyFrom(selectedItemStyle); 
                            compositeStyle.CopyFrom(editItemStyle);
                        } 
                        break; 
                }
 
                if (compositeStyle != null) {
                    // use the cached value of ExtractTemplateRows as it was at the time of
                    // control creation, so we don't do the wrong thing even if the
                    // user happened to change the property 

                    if (extractTemplateRows == false) { 
                        item.MergeStyle(compositeStyle); 
                    }
                    else { 
                        // apply the style on the TRs
                        IEnumerator controlEnum = item.Controls.GetEnumerator();

                        while (controlEnum.MoveNext()) { 
                            Control c = (Control)controlEnum.Current;
                            if (c is Table) { 
                                IEnumerator rowEnum = ((Table)c).Rows.GetEnumerator(); 

                                while (rowEnum.MoveNext()) { 
                                    //


                                    ((TableRow)rowEnum.Current).MergeStyle(compositeStyle); 
                                }
                                break; 
                            } 
                        }
                    } 
                }
            }
        }
 

        ///  
        ///  
        /// 
        protected internal override void RenderContents(HtmlTextWriter writer) { 
            if (Controls.Count == 0)
                return;

            RepeatInfo repeatInfo = new RepeatInfo(); 
            Table outerTable = null;
 
            // NOTE: This will end up creating the ControlStyle... Ideally we would 
            //       not create the style just for rendering, but turns out our default
            //       style isn't empty, and does have an effect on rendering, and must 
            //       therefore always be created
            Style style = ControlStyle;

            if (extractTemplateRows) { 
                // The table tags in the templates are stripped out and only the
                // 's and 's are assumed to come from the template itself. 
                // This is equivalent to a flow layout of 's in a single 
                // vertical column.
 
                repeatInfo.RepeatDirection = RepeatDirection.Vertical;
                repeatInfo.RepeatLayout = RepeatLayout.Flow;
                repeatInfo.RepeatColumns = 1;
 
                repeatInfo.OuterTableImplied = true;
                outerTable = new Table(); 
 
                // use ClientID (and not ID) since we want to render the fully qualified
                // ID even though the control will not be parented to the control hierarchy 
                outerTable.ID = ClientID;

                outerTable.CopyBaseAttributes(this);
                outerTable.Caption = Caption; 
                outerTable.CaptionAlign = CaptionAlign;
                outerTable.ApplyStyle(style); 
                outerTable.RenderBeginTag(writer); 
            }
            else { 
                repeatInfo.RepeatDirection = RepeatDirection;
                repeatInfo.RepeatLayout = RepeatLayout;
                repeatInfo.RepeatColumns = RepeatColumns;
                if (repeatInfo.RepeatLayout == RepeatLayout.Table) { 
                    repeatInfo.Caption = Caption;
                    repeatInfo.CaptionAlign = CaptionAlign; 
                    repeatInfo.UseAccessibleHeader = UseAccessibleHeader; 
                }
                else { 
                    repeatInfo.EnableLegacyRendering = EnableLegacyRendering;
                }
            }
 
            repeatInfo.RenderRepeater(writer, (IRepeatInfoUser)this, style, this);
            if (outerTable != null) 
                outerTable.RenderEndTag(writer); 
        }
 

        /// 
        /// 
        ///  
        protected override object SaveViewState() {
            object baseState = base.SaveViewState(); 
            object itemStyleState = (itemStyle != null) ? ((IStateManager)itemStyle).SaveViewState() : null; 
            object selectedItemStyleState = (selectedItemStyle != null) ? ((IStateManager)selectedItemStyle).SaveViewState() : null;
            object alternatingItemStyleState = (alternatingItemStyle != null) ? ((IStateManager)alternatingItemStyle).SaveViewState() : null; 
            object editItemStyleState = (editItemStyle != null) ? ((IStateManager)editItemStyle).SaveViewState() : null;
            object separatorStyleState = (separatorStyle != null) ? ((IStateManager)separatorStyle).SaveViewState() : null;
            object headerStyleState = (headerStyle != null) ? ((IStateManager)headerStyle).SaveViewState() : null;
            object footerStyleState = (footerStyle != null) ? ((IStateManager)footerStyle).SaveViewState() : null; 
            object controlState = ControlStyleCreated ? ((IStateManager)ControlStyle).SaveViewState() : null;
 
            object[] myState = new object[9]; 
            myState[0] = baseState;
            myState[1] = itemStyleState; 
            myState[2] = selectedItemStyleState;
            myState[3] = alternatingItemStyleState;
            myState[4] = editItemStyleState;
            myState[5] = separatorStyleState; 
            myState[6] = headerStyleState;
            myState[7] = footerStyleState; 
            myState[8] = controlState; 

            // note that we always have some state, atleast the ItemCount 
            return myState;
        }

 
        /// 
        ///  
        ///    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 (itemStyle != null) 
                ((IStateManager)itemStyle).TrackViewState();
            if (selectedItemStyle != null) 
                ((IStateManager)selectedItemStyle).TrackViewState(); 
            if (alternatingItemStyle != null)
                ((IStateManager)alternatingItemStyle).TrackViewState(); 
            if (editItemStyle != null)
                ((IStateManager)editItemStyle).TrackViewState();
            if (separatorStyle != null)
                ((IStateManager)separatorStyle).TrackViewState(); 
            if (headerStyle != null)
                ((IStateManager)headerStyle).TrackViewState(); 
            if (footerStyle != null) 
                ((IStateManager)footerStyle).TrackViewState();
            if (ControlStyleCreated) 
                ((IStateManager)ControlStyle).TrackViewState();
        }

 
        /// 
        ///  
        ///  
        bool IRepeatInfoUser.HasFooter {
            get { 
                return ShowFooter && (footerTemplate != null);
            }
        }
 

        ///  
        ///  
        /// 
        bool IRepeatInfoUser.HasHeader { 
            get {
                return ShowHeader && (headerTemplate != null);
            }
        } 

 
        ///  
        /// 
        ///  
        bool IRepeatInfoUser.HasSeparators {
            get {
                return (separatorTemplate != null);
            } 
        }
 
 
        /// 
        ///  
        /// 
        int IRepeatInfoUser.RepeatedItemCount {
            get {
                if (visibleItemCount == -1) { 
                    return itemsArray != null ? itemsArray.Count : 0;
                } 
                return visibleItemCount; 
            }
        } 



 
        /// 
        ///  
        ///  
        Style IRepeatInfoUser.GetItemStyle(ListItemType itemType, int repeatIndex) {
            DataListItem item = GetItem(itemType, repeatIndex); 

            if ((item != null) && item.ControlStyleCreated) {
                return item.ControlStyle;
            } 
            return null;
        } 
 

        ///  
        /// 
        /// 
        void IRepeatInfoUser.RenderItem(ListItemType itemType, int repeatIndex, RepeatInfo repeatInfo, HtmlTextWriter writer) {
            DataListItem item = GetItem(itemType, repeatIndex + offset); 

            if (item != null) { 
                item.RenderItem(writer, extractTemplateRows, repeatInfo.RepeatLayout == RepeatLayout.Table); 
            }
        } 

        #region IWizardSideBarListControl implementation

        IEnumerable IWizardSideBarListControl.Items { 
            get { return Items; }
        } 
 
        event CommandEventHandler IWizardSideBarListControl.ItemCommand {
            add { 
                ItemCommand += new DataListCommandEventHandler(value);
            }
            remove {
                ItemCommand -= new DataListCommandEventHandler(value); 
            }
        } 
 
        event EventHandler IWizardSideBarListControl.ItemDataBound {
            add { 
                Events.AddHandler(EventWizardListItemDataBound , value);
            }
            remove {
                Events.RemoveHandler(EventWizardListItemDataBound, 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