listitem.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 / listitem.cs / 1305376 / listitem.cs

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

namespace System.Web.UI.WebControls { 
 
    using System;
    using System.Collections; 
    using System.ComponentModel;
    using System.Globalization;
    using AttributeCollection = System.Web.UI.AttributeCollection;
    using System.Web.Util; 

    ///  
    /// Interacts with the parser to build a  control. 
    /// 
    public class ListItemControlBuilder : ControlBuilder { 


        public override bool AllowWhitespaceLiterals() {
            return false; 
        }
 
 
        public override bool HtmlDecodeLiterals() {
            // ListItem text gets rendered as an encoded attribute value. 

            // At parse time text specified as an attribute gets decoded, and so text specified as a
            // literal needs to go through the same process.
 
            return true;
        } 
    } 

 
    /// 
    ///    Constructs a list item control and defines
    ///       its properties. This class cannot be inherited.
    ///  
    [
    ControlBuilderAttribute(typeof(ListItemControlBuilder)), 
    TypeConverterAttribute(typeof(ExpandableObjectConverter)), 
    ParseChildren(true, "Text"),
    ] 
    public sealed class ListItem : IStateManager, IParserAccessor, IAttributeAccessor {

        private bool selected;
        private bool marked; 
        private bool textisdirty;
        private bool valueisdirty; 
        private bool enabled; 
        private bool enabledisdirty;
 
        private string text;
        private string value;
        private AttributeCollection _attributes;
 

        ///  
        /// Initializes a new instance of the  class. 
        /// 
        public ListItem() : this(null, null) { 
        }


        ///  
        /// Initializes a new instance of the  class with the specified text data.
        ///  
        public ListItem(string text) : this(text, null) { 
        }
 

        /// 
        /// Initializes a new instance of the  class with the specified text data.
        ///  
        public ListItem(string text, string value) : this(text, value, true)  {
        } 
 

        ///  
        /// Initializes a new instance of the  class with the
        ///    specified text and value data.
        /// 
        public ListItem(string text, string value, bool enabled) { 
            this.text = text;
            this.value = value; 
            this.enabled = enabled; 
        }
 

        /// 
        ///    Gets the collection of attribute name/value pairs expressed on the list item
        ///       control but not supported by the control's strongly typed properties. 
        /// 
        [ 
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ] 
        public AttributeCollection Attributes {
            get {
                if (_attributes == null)
                    _attributes = new AttributeCollection(new StateBag(true)); 

                return _attributes; 
            } 
        }
 

        /// 
        ///  Internal property used to manage dirty state of ListItem.
        ///  
        internal bool Dirty {
            get { 
                return (textisdirty || valueisdirty || enabledisdirty); 
            }
            set { 
                textisdirty = value;
                valueisdirty = value;
                enabledisdirty = value;
            } 
        }
 
 
        [
        DefaultValue(true) 
        ]
        public bool Enabled  {
            get  {
                return enabled; 
            }
            set  { 
                enabled = value; 
                if (((IStateManager)this).IsTrackingViewState)
                    enabledisdirty = true; 
            }
        }

        internal bool HasAttributes { 
            get {
                return _attributes != null && _attributes.Count > 0; 
            } 
        }
 

        /// 
        ///    Specifies a value indicating whether the
        ///       item is selected. 
        /// 
        [ 
        DefaultValue(false), 
        TypeConverter(typeof(MinimizableAttributeTypeConverter))
        ] 
        public bool Selected {
            get {
                return selected;
            } 
            set {
                selected = value; 
            } 
        }
 

        /// 
        ///    Gets or sets the display text of the list
        ///       item control. 
        /// 
        [ 
        Localizable(true), 
        DefaultValue(""),
        PersistenceMode(PersistenceMode.EncodedInnerDefaultProperty) 
        ]
        public string Text {
            get {
                if (text != null) 
                    return text;
                if (value != null) 
                    return value; 
                return String.Empty;
            } 
            set {
                text = value;
                if (((IStateManager)this).IsTrackingViewState)
                    textisdirty = true; 
            }
        } 
 

        ///  
        ///    Gets or sets the value content of the list item control.
        /// 
        [
        Localizable(true), 
        DefaultValue("")
        ] 
        public string Value { 
            get {
                if (value != null) 
                    return value;
                if (text != null)
                    return text;
                return String.Empty; 
            }
            set { 
                this.value = value; 
                if (((IStateManager)this).IsTrackingViewState)
                    valueisdirty =true; 
            }
        }

 
        /// 
        public override int GetHashCode() { 
            return HashCodeCombiner.CombineHashCodes(Value.GetHashCode(), Text.GetHashCode()); 
        }
 

        /// 
        /// 
        ///  
        public override bool Equals(object o) {
            ListItem other = o as ListItem; 
 
            if (other != null) {
                return Value.Equals(other.Value) && Text.Equals(other.Text); 
            }
            return false;
        }
 

        ///  
        /// Creates a  from the specified string. 
        /// 
        public static ListItem FromString(string s) { 
            return new ListItem(s);
        }

 
        /// 
        ///  
        ///  
        public override string ToString() {
            return this.Text; 
        }


        ///  
        /// 
        /// Return true if tracking state changes. 
        /// Method of private interface, IStateManager. 
        /// 
        bool IStateManager.IsTrackingViewState { 
            get {
                return marked;
            }
        } 

 
        ///  
        void IStateManager.LoadViewState(object state) {
            LoadViewState(state); 
        }

        internal void LoadViewState(object state) {
            if (state != null) { 
                if (state is Triplet)  {
                    Triplet t = (Triplet) state; 
                    if (t.First != null) { 
                        Text = (string) t.First;
                    } 
                    if (t.Second != null)  {
                        Value = (string) t.Second;
                    }
                    if (t.Third != null)  { 
                        try  {
                            Enabled = (bool) t.Third; 
                        } 
                        catch {
                        } 
                    }
                }
                else if (state is Pair) {
                    Pair p = (Pair) state; 
                    if (p.First != null)
                        Text = (string) p.First; 
                    Value = (string) p.Second; 
                }
                else 
                    Text = (string) state;
            }
        }
 

        ///  
        void IStateManager.TrackViewState() { 
            TrackViewState();
        } 

        internal void TrackViewState() {
            marked = true;
        } 

        internal void RenderAttributes(HtmlTextWriter writer) { 
            if (_attributes != null) { 
                _attributes.AddAttributes(writer);
            } 
        }


        ///  
        object IStateManager.SaveViewState() {
            return SaveViewState(); 
        } 

        internal object SaveViewState() { 
            string text = null;
            string value = null;

            if(textisdirty)  { 
                text = Text;
            } 
            if(valueisdirty)  { 
                value = Value;
            } 
            if(enabledisdirty)  {
                return new Triplet(text, value, Enabled);
            }
            else if(valueisdirty)  { 
                return new Pair(text, value);
            } 
            else if(textisdirty)  { 
                return text;
            } 

            return null;
        }
 

        ///  
        ///  
        /// Returns the attribute value of the list item control
        /// having the specified attribute name. 
        /// 
        string IAttributeAccessor.GetAttribute(string name) {
            return Attributes[name];
        } 

 
        ///  
        /// 
        /// Sets an attribute of the list 
        /// item control with the specified name and value.
        /// 
        void IAttributeAccessor.SetAttribute(string name, string value) {
            Attributes[name] = value; 
        }
 
 
        /// 
        ///  
        ///  Allows the 
        /// property to be persisted as inner content.
        /// 
        void IParserAccessor.AddParsedSubObject(object obj) { 
            if (obj is LiteralControl) {
                Text = ((LiteralControl)obj).Text; 
            } 
            else {
                if (obj is DataBoundLiteralControl) { 
                    throw new HttpException(SR.GetString(SR.Control_Cannot_Databind, "ListItem"));
                }
                else {
                    throw new HttpException(SR.GetString(SR.Cannot_Have_Children_Of_Type, "ListItem", obj.GetType().Name.ToString(CultureInfo.InvariantCulture))); 
                }
            } 
        } 

 
        /// 
        /// Do not change the signature or remove this method. It is called via reflection
        /// to support correct serialization behavior for Text and Value which are
        /// implemented as dependent properties. 
        /// 
        private void ResetText() { 
            Text = null; 
        }
 

        /// 
        /// Do not change the signature or remove this method. It is called via reflection
        /// to support correct serialization behavior for Text and Value which are 
        /// implemented as dependent properties.
        ///  
        private void ResetValue() { 
            Value = null;
        } 


        /// 
        /// Do not change the signature or remove this method. It is called via reflection 
        /// to support correct serialization behavior for Text and Value which are
        /// implemented as dependent properties. 
        ///  
        private bool ShouldSerializeText() {
            return (text != null) && (text.Length != 0); 
        }


        ///  
        /// Do not change the signature or remove this method. It is called via reflection
        /// to support correct serialization behavior for Text and Value which are 
        /// implemented as dependent properties. 
        /// 
        private bool ShouldSerializeValue() { 
            return (value != null) && (value.Length != 0);
        }
    }
} 

// 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