CheckBoxList.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebControls / CheckBoxList.cs / 1 / CheckBoxList.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.Globalization;
    using System.Security.Permissions; 
    using System.Web;
    using System.Web.UI; 
 

    ///  
    /// Creates a group of  controls.
    /// 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    public class CheckBoxList : ListControl, IRepeatInfoUser, INamingContainer, IPostBackDataHandler
#if ORCAS 
        ,IItemPaginationInfo, IPaginationContainer 
#endif
    { 
        private CheckBox _controlToRepeat;
        private string _oldAccessKey;
        private bool _hasNotifiedOfChange;
        private bool _cachedRegisterEnabled; 
        private bool _cachedIsEnabled;
 
#if ORCAS 
        private int _offset;
        private int _itemCount = -1; 
        private int _previousOffset;
        private int _previousItemCount;
#endif
 

        ///  
        ///     
        ///       Initializes a new instance of the  class.
        ///     
        /// 
        public CheckBoxList() {
#if ORCAS
            _offset = 0; 
            _itemCount = -1;
            _previousOffset = 0; 
            _previousItemCount = -1; 
#endif
 
            _controlToRepeat = new CheckBox();
            _controlToRepeat.EnableViewState = false;

            // Whidbey 28457: We need to set a default numeric ID for the case 
            // of an empty checkbox list.  It is because the child CheckBox
            // always registers itself to Page as a PostBackData control and 
            // during postback it will invoke LoadPostData in this class and the 
            // method always assumes the ID is numeric.  This default ID setting
            // has been done in this way since V1. 
            _controlToRepeat.ID = "0";

            Controls.Add(_controlToRepeat);
        } 

 
        ///  
        ///    
        ///       Gets or sets 
        ///       the padding between each item.
        ///    
        /// 
        [ 
        WebCategory("Layout"),
        DefaultValue(-1), 
        WebSysDescription(SR.CheckBoxList_CellPadding) 
        ]
        public virtual int CellPadding { 
            get {
                if (ControlStyleCreated == false) {
                    return -1;
                } 
                return ((TableStyle)ControlStyle).CellPadding;
            } 
            set { 
                ((TableStyle)ControlStyle).CellPadding = value;
            } 
        }


        ///  
        ///    
        ///       Gets or sets 
        ///       the spacing between each item. 
        ///    
        ///  
        [
        WebCategory("Layout"),
        DefaultValue(-1),
        WebSysDescription(SR.CheckBoxList_CellSpacing) 
        ]
        public virtual int CellSpacing { 
            get { 
                if (ControlStyleCreated == false) {
                    return -1; 
                }
                return ((TableStyle)ControlStyle).CellSpacing;
            }
            set { 
                ((TableStyle)ControlStyle).CellSpacing = value;
            } 
        } 

        internal override bool IsMultiSelectInternal  { 
            get  {
                // a CheckBoxList is always multiselect.
                return true;
            } 
        }
 
 
        /// 
        ///    Gets or sets the number of columns to repeat. 
        /// 
        [
        WebCategory("Layout"),
        DefaultValue(0), 
        WebSysDescription(SR.CheckBoxList_RepeatColumns)
        ] 
        public virtual int RepeatColumns { 
            get {
                object o = ViewState["RepeatColumns"]; 
                return((o == null) ? 0 : (int)o);
            }
            set {
                if (value < 0) { 
                    throw new ArgumentOutOfRangeException("value");
                } 
                ViewState["RepeatColumns"] = value; 
            }
        } 


        /// 
        ///    Gets or sets a value that 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"];
                return((o == null) ? RepeatDirection.Vertical : (RepeatDirection)o); 
            } 
            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 
        ///    or layout.
        /// 
        [
        WebCategory("Layout"), 
        DefaultValue(RepeatLayout.Table),
        WebSysDescription(SR.WebControl_RepeatLayout) 
        ] 
        public virtual RepeatLayout RepeatLayout {
            get { 
                object o = ViewState["RepeatLayout"];
                return((o == null) ? RepeatLayout.Table : (RepeatLayout)o);
            }
            set { 
                if (value < RepeatLayout.Table || value > RepeatLayout.Flow) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                ViewState["RepeatLayout"] = value;
            } 
        }


        ///  
        ///    Gets or sets
        ///       the alignment of the text label associated with each checkbox. 
        ///  
        [
        WebCategory("Appearance"), 
        DefaultValue(TextAlign.Right),
        WebSysDescription(SR.WebControl_TextAlign)
        ]
        public virtual TextAlign TextAlign { 
            get {
                object align = ViewState["TextAlign"]; 
                return((align == null) ? TextAlign.Right : (TextAlign)align); 
            }
            set { 
                if (value < TextAlign.Left || value > TextAlign.Right) {
                    throw new ArgumentOutOfRangeException("value");
                }
                ViewState["TextAlign"] = value; 
            }
        } 
 

        ///  
        /// 
        ///    Creates a new control style object.
        /// 
        protected override Style CreateControlStyle() { 
            return new TableStyle(ViewState);
        } 
 

        ///  
        /// 
        /// Catches post data for each  in the list.
        /// 
        protected override Control FindControl(string id, int pathOffset) { 
            return this;
        } 
 
#if ORCAS
 
        /// 
        /// Loads the control state for those properties that should persist across postbacks
        ///   even when EnableViewState=false.
        ///  
        protected internal override void LoadControlState(object savedState) {
            Triplet state = (Triplet)savedState; 
            if (state != null && state.First != null) { 
                base.LoadControlState(state.First);
            } 
            else {
                base.LoadControlState(null);
            }
 
            if (state != null && state.Second != null && state.Third != null) {
                _previousOffset = (int)state.Second; 
                _previousItemCount = (int)state.Third; 
            }
            else { 
                _previousOffset = 0;
                _previousItemCount = -1;
            }
        } 
#endif
 
 
        /// 
        ///  
        /// Configures the  prior to rendering on the client.
        /// 
        protected internal override void OnPreRender(EventArgs e) {
            base.OnPreRender(e); 
            _controlToRepeat.AutoPostBack = AutoPostBack;
            _controlToRepeat.CausesValidation = CausesValidation; 
            _controlToRepeat.ValidationGroup = ValidationGroup; 

            if (Page != null) { 
                // ensure postback data for those checkboxes which get unchecked or are different from their default value
                for (int i=0; i < Items.Count; i++) {
                    _controlToRepeat.ID = i.ToString(NumberFormatInfo.InvariantInfo);
                    Page.RegisterRequiresPostBack(_controlToRepeat); 
                }
            } 
        } 

 
        /// 
        /// 
        ///    
        ///       Displays the  on the client. 
        ///    
        ///  
        protected internal override void Render(HtmlTextWriter writer) { 

#if ORCAS 
            // Don't render anything if the control is empty.
            // empty table is not xhtml compliant.
            if (VisibleItemCount == 0) {
                return; 
            }
#else 
            // Don't render anything if the control is empty. 
            // empty table is not xhtml compliant.
            if (Items.Count == 0 && !EnableLegacyRendering) { 
                return;
            }
#endif
 
            RepeatInfo repeatInfo = new RepeatInfo();
            Style style = (ControlStyleCreated ? ControlStyle : null); 
            short tabIndex = TabIndex; 
            bool undirtyTabIndex = false;
 
            // TabIndex here is special... it needs to be applied to the individual
            // checkboxes and not the outer control itself

            // Set the TextAlign property. 
            _controlToRepeat.TextAlign = TextAlign;
 
            // cache away the TabIndex property state 
            _controlToRepeat.TabIndex = tabIndex;
            if (tabIndex != 0) { 
                if (ViewState.IsItemDirty("TabIndex") == false) {
                    undirtyTabIndex = true;
                }
                TabIndex = 0; 
            }
 
            repeatInfo.RepeatColumns = RepeatColumns; 
            repeatInfo.RepeatDirection = RepeatDirection;
 
            // If the device does not support tables, use the flow layout to render
            if (!DesignMode && !Context.Request.Browser.Tables) {
                repeatInfo.RepeatLayout = RepeatLayout.Flow;
            } 
            else {
                repeatInfo.RepeatLayout = RepeatLayout; 
            } 

            if (repeatInfo.RepeatLayout == RepeatLayout.Flow) { 
                repeatInfo.EnableLegacyRendering = EnableLegacyRendering;
            }

            // VSWhidbey 373655 
            // Temporarily suppress AccessKey so base does not render it on the outside tag
            _oldAccessKey = AccessKey; 
            AccessKey = String.Empty; 

            repeatInfo.RenderRepeater(writer, (IRepeatInfoUser)this, style, this); 

            // restore the state of AccessKey property
            AccessKey = _oldAccessKey;
 
            // restore the state of the TabIndex property
            if (tabIndex != 0) { 
                TabIndex = tabIndex; 
            }
            if (undirtyTabIndex) { 
                ViewState.SetItemDirty("TabIndex", false);
            }
        }
 
#if ORCAS
 
        ///  
        /// 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 || _itemCount != -1) { 
                return new Triplet(baseState, _offset, _itemCount);
            } 
            return null; 
        }
 
        #region IItemPaginationInfo implementation

        int IItemPaginationInfo.FirstVisibleItemIndex {
            get { 
                return this.FirstVisibleItemIndex;
            } 
        } 

 
        protected int FirstVisibleItemIndex {
            get {
                return _offset;
            } 
        }
 
 
        /// 
        ///     
        ///       The number of items held by the container for pagination calculations.
        ///    
        /// 
        int IItemPaginationInfo.ItemCount { 
            get {
                return ItemCount; 
            } 
        }
 

        /// 
        ///    
        ///       The number of items held by the container for pagination calculations. 
        ///    
        ///  
        protected virtual int ItemCount { 
            get {
                EnsureDataBound(); 
                return Items.Count;
            }
        }
 

        ///  
        ///     
        ///       The weight for pagination calculations for each item of the container.
        ///       Returns a constant value of 100 for CheckBoxList. 
        ///    
        /// 
        int IItemPaginationInfo.ItemWeight {
            get { 
                return ItemWeight;
            } 
        } 

 
        /// 
        ///    
        ///       The weight for pagination calculations for each item of the container.
        ///       Returns a constant value of 100 for CheckBoxList. 
        ///    
        ///  
        protected virtual int ItemWeight { 
            get {
                return 100; 
            }
        }

 
        int IItemPaginationInfo.VisibleItemCount {
            get { 
                return this.VisibleItemCount; 
            }
        } 


        protected int VisibleItemCount {
            get { 
                if (_itemCount >= 0) {
                    return _itemCount; 
                } 
                else {
                    return ItemCount; 
                }
            }
        }
 

        ///  
        ///     
        ///       Indicates which child items of the container are visible on the current page.
        ///     
        /// 
        void IItemPaginationInfo.SetVisibleItems(int firstItem, int itemCount) {
            SetVisibleItems(firstItem, itemCount);
        } 

 
        ///  
        ///    
        ///       Indicates which child items of the container are visible on the current page. 
        ///    
        /// 
        protected virtual void SetVisibleItems(int firstItem, int itemCount) {
            _offset = firstItem; 
            _itemCount = itemCount;
            // This info will be saved into ControlState so that 
            // the list remembers which page it was on when treating postbacks 
        }
        #endregion 
#endif

        /// 
        ///  
        /// Processes posted data for the  control.
        ///  
        bool IPostBackDataHandler.LoadPostData(String postDataKey, NameValueCollection postCollection) { 
            return LoadPostData(postDataKey, postCollection);
        } 


        /// 
        ///  
        /// Processes posted data for the  control.
        ///  
        protected virtual bool LoadPostData(String postDataKey, NameValueCollection postCollection) { 
            if (IsEnabled == false) {
                // When a CheckBoxList is disabled, then there is no postback 
                // data for it. Any checked state information has been loaded
                // via view state.
                return false;
            } 

            string strIndex = postDataKey.Substring(UniqueID.Length + 1); 
            int index = Int32.Parse(strIndex, CultureInfo.InvariantCulture); 

            EnsureDataBound(); 

#if ORCAS
            // Do not maintain state from the form if the current page changed.
            if (_previousItemCount != -1 && (index < _previousOffset || index >= _previousOffset + _previousItemCount)) { 
                return false;
            } 
#endif 
            // Maintain state from the form
            if (index >= 0 && index < Items.Count) { 
                ListItem item = Items[index];
                if (item.Enabled == false) {
                    return false;
                } 

                bool newCheckState = (postCollection[postDataKey] != null); 
 
                if (item.Selected != newCheckState) {
                    item.Selected = newCheckState; 
                    // LoadPostData will be invoked for each CheckBox that changed
                    // Suppress multiple change notification and fire only ONE change event
                    if (!_hasNotifiedOfChange) {
                        _hasNotifiedOfChange = true; 
                        return true;
                    } 
                } 
            }
 
            return false;
        }

 
        /// 
        ///  
        /// Raises when posted data for a control has changed. 
        /// 
        void IPostBackDataHandler.RaisePostDataChangedEvent() { 
            RaisePostDataChangedEvent();
        }

 
        /// 
        ///  
        /// Raises when posted data for a control has changed. 
        /// 
        protected virtual void RaisePostDataChangedEvent() { 
            if (AutoPostBack && !Page.IsPostBackEventControlRegistered) {
                // VSWhidbey 204824
                Page.AutoPostBackControl = this;
 
                if (CausesValidation) {
                    Page.Validate(ValidationGroup); 
                } 
            }
            OnSelectedIndexChanged(EventArgs.Empty); 
        }


        ///  
        /// 
        ///  
        bool IRepeatInfoUser.HasFooter { 
            get {
                return HasFooter; 
            }
        }

 
        /// 
        ///  
        ///  
        protected virtual bool HasFooter {
            get { 
                return false;
            }
        }
 

        ///  
        ///  
        /// 
        bool IRepeatInfoUser.HasHeader { 
            get {
                return HasHeader;
            }
        } 

 
        ///  
        /// 
        ///  
        protected virtual bool HasHeader {
            get {
                return false;
            } 
        }
 
 
        /// 
        ///  
        /// 
        bool IRepeatInfoUser.HasSeparators {
            get {
                return HasSeparators; 
            }
        } 
 

        ///  
        /// 
        /// 
        protected virtual bool HasSeparators {
            get { 
                return false;
            } 
        } 

 
        /// 
        /// 
        /// 
        int IRepeatInfoUser.RepeatedItemCount { 
            get {
                return RepeatedItemCount; 
            } 
        }
 

        /// 
        /// 
        ///  
        protected virtual int RepeatedItemCount {
            get { 
#if ORCAS 
                // If the whole control is contained on a single page,
                // the count is the number of items. 
                if (VirtualStartPage == VirtualEndPage || _itemCount == -1) {
                    return (Items != null) ? Items.Count : 0;
                }
                return _itemCount; 
#else
                return (Items != null) ? Items.Count : 0; 
#endif 
            }
 
        }


        ///  
        /// 
        ///  
        Style IRepeatInfoUser.GetItemStyle(ListItemType itemType, int repeatIndex) { 
            return GetItemStyle(itemType, repeatIndex);
        } 


        protected virtual Style GetItemStyle(ListItemType itemType, int repeatIndex) {
            return null; 
        }
 
 
        /// 
        ///  
        /// Called by the RepeatInfo helper to render each item
        /// 
        void IRepeatInfoUser.RenderItem(ListItemType itemType, int repeatIndex, RepeatInfo repeatInfo, HtmlTextWriter writer) {
            RenderItem(itemType, repeatIndex, repeatInfo, writer); 
        }
 
 
        /// 
        ///  
        /// Called by the RepeatInfo helper to render each item
        /// 
        protected virtual void RenderItem(ListItemType itemType, int repeatIndex, RepeatInfo repeatInfo, HtmlTextWriter writer) {
            if (repeatIndex == 0) { 
                _cachedIsEnabled = IsEnabled;
                _cachedRegisterEnabled = (Page != null) && IsEnabled && (SaveSelectedIndicesViewState == false); 
            } 

 
#if ORCAS
            int repeatIndexOffset = repeatIndex + _offset;
#else
            int repeatIndexOffset = repeatIndex; 
#endif
 
            ListItem item = Items[repeatIndexOffset]; 

            // VSWhidbey 403433 Render expando attributes. 
            _controlToRepeat.Attributes.Clear();
            if (item.HasAttributes) {
                foreach (string key in item.Attributes.Keys) {
                    _controlToRepeat.Attributes[key] = item.Attributes[key]; 
                }
            } 
 
            _controlToRepeat.ID = repeatIndexOffset.ToString(NumberFormatInfo.InvariantInfo);
            _controlToRepeat.Text = item.Text; 
            _controlToRepeat.Checked = item.Selected;
            _controlToRepeat.Enabled = _cachedIsEnabled && item.Enabled;
            _controlToRepeat.AccessKey = _oldAccessKey;
 
            if (_cachedRegisterEnabled && _controlToRepeat.Enabled) {
                // Store a client-side array of enabled control, so we can re-enable them on 
                // postback (in case they are disabled client-side) 
                // Postback is needed when SelectedIndices is not saved in view state
                Page.RegisterEnabledControl(_controlToRepeat); 
            }

            _controlToRepeat.RenderControl(writer);
        } 

#if ORCAS 
 
        [
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual int MaximumWeight {
            get { 
                if (Page != null && Page.Form != null) {
                    return Page.Form.MaximumWeight; 
                } 
                return 0;
            } 
        }
#endif
    }
}

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