Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebParts/PersonalizableAttribute.cs

@@ -0,0 +1,236 @@
+//------------------------------------------------------------------------------
+// <copyright file="PersonalizableAttribute.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls.WebParts {
+
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Reflection;
+    using System.Web;
+    using System.Web.Util;
+
+    /// <devdoc>
+    /// Used to mark a property as personalizable.
+    /// </devdoc>
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class PersonalizableAttribute : Attribute {
+
+        internal static readonly Type PersonalizableAttributeType = typeof(PersonalizableAttribute);
+
+        private static readonly IDictionary PersonalizableTypeTable = Hashtable.Synchronized(new Hashtable());
+
+        /// <devdoc>
+        /// Indicates that the property is not personalizable.
+        /// </devdoc>
+        public static readonly PersonalizableAttribute NotPersonalizable = new PersonalizableAttribute(false);
+
+        /// <devdoc>
+        /// Indicates that the property is personalizable.
+        /// </devdoc>
+        public static readonly PersonalizableAttribute Personalizable = new PersonalizableAttribute(true);
+
+        /// <devdoc>
+        /// Indicates that the property is personalizable and can be changed per user.
+        /// </devdoc>
+        public static readonly PersonalizableAttribute UserPersonalizable = new PersonalizableAttribute(PersonalizationScope.User);
+
+        /// <devdoc>
+        /// Indicates that the property is personalizable that can only be changed for all users.
+        /// </devdoc>
+        public static readonly PersonalizableAttribute SharedPersonalizable = new PersonalizableAttribute(PersonalizationScope.Shared);
+
+        /// <devdoc>
+        /// The default personalizable attribute for a property or type. The default
+        /// is to indicate that a property or type is not personalizable.
+        /// </devdoc>
+        public static readonly PersonalizableAttribute Default = NotPersonalizable;
+
+        private bool _isPersonalizable;
+        private bool _isSensitive;
+        private PersonalizationScope _scope;
+
+        /// <devdoc>
+        /// Initializes an instance of PersonalizableAttribute to indicate
+        /// a personalizable property.
+        /// By default personalized properties can be personalized per user.
+        /// </devdoc>
+        public PersonalizableAttribute() : this(true, PersonalizationScope.User, false) {
+        }
+
+        /// <devdoc>
+        /// Initializes an instance of PersonalizableAttribute with the
+        /// specified value.
+        /// </devdoc>
+        public PersonalizableAttribute(bool isPersonalizable) : this(isPersonalizable, PersonalizationScope.User, false) {
+        }
+
+        /// <devdoc>
+        /// Initializes an instance of PersonalizableAttribute to indicate
+        /// a personalizable property along with the specified personalization scope.
+        /// </devdoc>
+        public PersonalizableAttribute(PersonalizationScope scope) : this(true, scope, false) {
+        }
+
+        /// <devdoc>
+        /// Initializes an instance of PersonalizableAttribute to indicate
+        /// a personalizable property along with the specified personalization scope and sensitivity.
+        /// </devdoc>
+        public PersonalizableAttribute(PersonalizationScope scope, bool isSensitive) : this(true, scope, isSensitive) {
+        }
+
+        /// <internalonly/>
+        /// <devdoc>
+        /// Initializes an instance of PersonalizableAttribute with the specified values.
+        /// </devdoc>
+        private PersonalizableAttribute(bool isPersonalizable, PersonalizationScope scope, bool isSensitive) {
+            Debug.Assert((isPersonalizable == true || isSensitive == false), "Only Personalizable properties can be sensitive");
+            _isPersonalizable = isPersonalizable;
+            _isSensitive = isSensitive;
+            if (_isPersonalizable) {
+                _scope = scope;
+            }
+        }
+
+        /// <devdoc>
+        /// Whether the property or the type has been marked as personalizable.
+        /// </devdoc>
+        public bool IsPersonalizable {
+            get {
+                return _isPersonalizable;
+            }
+        }
+
+        /// <devdoc>
+        /// Whether the property or the type has been marked as sensitive.
+        /// </devdoc>
+        public bool IsSensitive {
+            get {
+                return _isSensitive;
+            }
+        }
+
+        /// <devdoc>
+        /// The personalization scope associated with the personalizable property.
+        /// This property only has meaning when IsPersonalizable is true.
+        /// </devdoc>
+        public PersonalizationScope Scope {
+            get {
+                return _scope;
+            }
+        }
+
+        /// <internalonly/>
+        public override bool Equals(object obj) {
+            if (obj == this) {
+                return true;
+            }
+
+            PersonalizableAttribute other = obj as PersonalizableAttribute;
+            if (other != null) {
+                return (other.IsPersonalizable == IsPersonalizable) &&
+                       (other.Scope == Scope) &&
+                       (other.IsSensitive == IsSensitive);
+            }
+
+            return false;
+        }
+
+        /// <internalonly/>
+        public override int GetHashCode() {
+            return HashCodeCombiner.CombineHashCodes(_isPersonalizable.GetHashCode(), _scope.GetHashCode(),
+                                                     _isSensitive.GetHashCode());
+        }
+
+        /// <devdoc>
+        /// Returns the list of personalizable properties as a collection of
+        /// PropertyInfos for the specified type.
+        /// </devdoc>
+        public static ICollection GetPersonalizableProperties(Type type) {
+            Debug.Assert(type != null);
+
+            PersonalizableTypeEntry typeEntry = (PersonalizableTypeEntry)PersonalizableTypeTable[type];
+            if (typeEntry == null) {
+                typeEntry = new PersonalizableTypeEntry(type);
+                PersonalizableTypeTable[type] = typeEntry;
+            }
+
+            return typeEntry.PropertyInfos;
+        }
+
+        /// <devdoc>
+        /// Returns the list of personalizable properties as a collection of
+        /// PropertyInfos for the specified type.
+        /// </devdoc>
+        internal static IDictionary GetPersonalizablePropertyEntries(Type type) {
+            Debug.Assert(type != null);
+
+            PersonalizableTypeEntry typeEntry = (PersonalizableTypeEntry)PersonalizableTypeTable[type];
+
+            if (typeEntry == null) {
+                typeEntry = new PersonalizableTypeEntry(type);
+                PersonalizableTypeTable[type] = typeEntry;
+            }
+
+            return typeEntry.PropertyEntries;
+        }
+
+        /// <devdoc>
+        /// </devdoc>
+        internal static IDictionary GetPersonalizablePropertyValues(Control control, PersonalizationScope scope, bool excludeSensitive) {
+            IDictionary propertyBag = null;
+
+            IDictionary propertyEntries = GetPersonalizablePropertyEntries(control.GetType());
+            if (propertyEntries.Count != 0) {
+                foreach (DictionaryEntry entry in propertyEntries) {
+                    string name = (string)entry.Key;
+                    PersonalizablePropertyEntry propEntry = (PersonalizablePropertyEntry)entry.Value;
+
+                    if (excludeSensitive && propEntry.IsSensitive) {
+                        continue;
+                    }
+                    if ((scope == PersonalizationScope.User) &&
+                        (propEntry.Scope == PersonalizationScope.Shared)) {
+                        continue;
+                    }
+
+                    if (propertyBag == null) {
+                        propertyBag = new HybridDictionary(propertyEntries.Count, /* caseInsensitive */ false);
+                    }
+
+                    object value = FastPropertyAccessor.GetProperty(control, name, control.DesignMode);
+
+                    propertyBag[name] = new Pair(propEntry.PropertyInfo, value);
+                }
+            }
+
+            if (propertyBag == null) {
+                propertyBag = new HybridDictionary(/* caseInsensitive */ false);
+            }
+            return propertyBag;
+        }
+
+        /// <internalonly/>
+        public override bool IsDefaultAttribute() {
+            return this.Equals(Default);
+        }
+
+        /// <internalonly/>
+        public override bool Match(object obj) {
+            if (obj == this) {
+                return true;
+            }
+
+            PersonalizableAttribute other = obj as PersonalizableAttribute;
+            if (other != null) {
+                return (other.IsPersonalizable == IsPersonalizable);
+            }
+
+            return false;
+        }
+    }
+}