Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebControls/listitem.cs

@@ -0,0 +1,419 @@
+//------------------------------------------------------------------------------
+// <copyright file="listitem.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+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;
+
+    /// <devdoc>
+    /// <para>Interacts with the parser to build a <see cref='System.Web.UI.WebControls.ListItem'/> control.</para>
+    /// </devdoc>
+    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;
+        }
+    }
+
+
+    /// <devdoc>
+    ///    <para>Constructs a list item control and defines
+    ///       its properties. This class cannot be inherited.</para>
+    /// </devdoc>
+    [
+    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;
+
+
+        /// <devdoc>
+        /// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.ListItem'/> class.</para>
+        /// </devdoc>
+        public ListItem() : this(null, null) {
+        }
+
+
+        /// <devdoc>
+        /// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.ListItem'/> class with the specified text data.</para>
+        /// </devdoc>
+        public ListItem(string text) : this(text, null) {
+        }
+
+
+        /// <devdoc>
+        /// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.ListItem'/> class with the specified text data.</para>
+        /// </devdoc>
+        public ListItem(string text, string value) : this(text, value, true)  {
+        }
+
+
+        /// <devdoc>
+        /// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.ListItem'/> class with the
+        ///    specified text and value data.</para>
+        /// </devdoc>
+        public ListItem(string text, string value, bool enabled) {
+            this.text = text;
+            this.value = value;
+            this.enabled = enabled;
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets the collection of attribute name/value pairs expressed on the list item
+        ///       control but not supported by the control's strongly typed properties.</para>
+        /// </devdoc>
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
+        ]
+        public AttributeCollection Attributes {
+            get {
+                if (_attributes == null)
+                    _attributes = new AttributeCollection(new StateBag(true));
+
+                return _attributes;
+            }
+        }
+
+
+        /// <devdoc>
+        ///  Internal property used to manage dirty state of ListItem.
+        /// </devdoc>
+        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;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Specifies a value indicating whether the
+        ///       item is selected.</para>
+        /// </devdoc>
+        [
+        DefaultValue(false),
+        TypeConverter(typeof(MinimizableAttributeTypeConverter))
+        ]
+        public bool Selected {
+            get {
+                return selected;
+            }
+            set {
+                selected = value;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets or sets the display text of the list
+        ///       item control.</para>
+        /// </devdoc>
+        [
+        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;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets or sets the value content of the list item control.</para>
+        /// </devdoc>
+        [
+        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;
+            }
+        }
+
+
+        /// <internalonly/>
+        public override int GetHashCode() {
+            return HashCodeCombiner.CombineHashCodes(Value.GetHashCode(), Text.GetHashCode());
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// </devdoc>
+        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;
+        }
+
+
+        /// <devdoc>
+        /// <para>Creates a <see cref='System.Web.UI.WebControls.ListItem'/> from the specified string.</para>
+        /// </devdoc>
+        public static ListItem FromString(string s) {
+            return new ListItem(s);
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// </devdoc>
+        public override string ToString() {
+            return this.Text;
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// Return true if tracking state changes.
+        /// Method of private interface, IStateManager.
+        /// </devdoc>
+        bool IStateManager.IsTrackingViewState {
+            get {
+                return marked;
+            }
+        }
+
+
+        /// <internalonly/>
+        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;
+            }
+        }
+
+
+        /// <internalonly/>
+        void IStateManager.TrackViewState() {
+            TrackViewState();
+        }
+
+        internal void TrackViewState() {
+            marked = true;
+        }
+
+        internal void RenderAttributes(HtmlTextWriter writer) {
+            if (_attributes != null) {
+                _attributes.AddAttributes(writer);
+            }
+        }
+
+
+        /// <internalonly/>
+        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;
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// Returns the attribute value of the list item control
+        /// having the specified attribute name.
+        /// </devdoc>
+        string IAttributeAccessor.GetAttribute(string name) {
+            return Attributes[name];
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// <para>Sets an attribute of the list
+        /// item control with the specified name and value.</para>
+        /// </devdoc>
+        void IAttributeAccessor.SetAttribute(string name, string value) {
+            Attributes[name] = value;
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// <para> Allows the <see cref='System.Web.UI.WebControls.ListItem.Text'/>
+        /// property to be persisted as inner content.</para>
+        /// </devdoc>
+        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)));
+                }
+            }
+        }
+
+
+        /// <devdoc>
+        /// 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.
+        /// </devdoc>
+        private void ResetText() {
+            Text = null;
+        }
+
+
+        /// <devdoc>
+        /// 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.
+        /// </devdoc>
+        private void ResetValue() {
+            Value = null;
+        }
+
+
+        /// <devdoc>
+        /// 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.
+        /// </devdoc>
+        private bool ShouldSerializeText() {
+            return (text != null) && (text.Length != 0);
+        }
+
+
+        /// <devdoc>
+        /// 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.
+        /// </devdoc>
+        private bool ShouldSerializeValue() {
+            return (value != null) && (value.Length != 0);
+        }
+    }
+}