Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,248 @@
+//------------------------------------------------------------------------------
+// <copyright file="Content.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls {
+
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Linq;
+    using System.Security.Permissions;
+    using System.Web.UI;
+    using System.Web.Util;
+
+    // ContentBuilder is a builder for content control but acts like a template builder.
+    // Designertime it will create the <asp:Content> as a control, but a template
+    // builder at runtime. ContentBuilder only works if the parent builder is a
+    // MasterPageBuilder, otherwise this builder is simply ignored.
+    internal class ContentBuilderInternal: TemplateBuilder {
+
+        private const string _contentPlaceHolderIDPropName = "ContentPlaceHolderID";
+        // This can be an array for now since the set is small so lookup perf is not an issue
+        private static string[] attributesToPreserve = new[] { "ClientIDMode", "ViewStateMode" };
+
+        private string _contentPlaceHolder;
+        private string _contentPlaceHolderFilter;
+
+
+        /// <devdoc>
+        /// </devdoc>
+        public override Type BindingContainerType {
+            get {
+                return typeof(Control);
+            }
+        }
+
+        internal string ContentPlaceHolderFilter {
+            get {
+                return _contentPlaceHolderFilter;
+            }
+        }
+
+        internal string ContentPlaceHolder {
+            get {
+                return _contentPlaceHolder;
+            }
+        }
+
+        // To return the content control for designtime support
+        public override object BuildObject() {
+            
+            if (InDesigner)
+                return BuildObjectInternal();
+
+            return base.BuildObject();
+        }
+
+        public override void InstantiateIn(Control container) {
+            base.InstantiateIn(container);
+
+            // Set all the children's TemplateControl properties to the owning page,
+            // to prevent them from incorrectly resolving to the Master page (VSWhidbey 602525)
+            HttpContext context = HttpContext.Current;
+            if (context != null) {
+                TemplateControl templateControl = context.TemplateControl;
+
+                if (templateControl != null && templateControl.NoCompile) {
+                    foreach (Control child in container.Controls) {
+                        child.TemplateControl = templateControl;
+                    }
+                }
+            }
+        }
+
+        public override void Init(TemplateParser parser, ControlBuilder parentBuilder,
+                                  Type type, string tagName, string ID, IDictionary attribs) {
+            
+            Dictionary<string, string> preservedAttributes = new Dictionary<string, string>();
+
+            ParsedAttributeCollection parsedAttributes = ConvertDictionaryToParsedAttributeCollection(attribs);
+            foreach (FilteredAttributeDictionary filteredAttributes in parsedAttributes.GetFilteredAttributeDictionaries()) {
+                string filter = filteredAttributes.Filter;
+                foreach (DictionaryEntry entry in filteredAttributes) {
+                    string key = (string)entry.Key;
+                    if (StringUtil.EqualsIgnoreCase(key, _contentPlaceHolderIDPropName)) {
+                        if (_contentPlaceHolder != null) {
+                            throw new HttpException(SR.GetString(SR.Content_only_one_contentPlaceHolderID_allowed));
+                        }
+
+                        _contentPlaceHolder = entry.Value.ToString();
+                        _contentPlaceHolderFilter = filter;
+                    }
+                    else if (attributesToPreserve.Contains(key, StringComparer.OrdinalIgnoreCase)) {
+                        // Save the attribute if it is in our list
+                        preservedAttributes[key] = entry.Value.ToString();
+                    }
+                }
+            }
+
+            if (!parser.FInDesigner) {
+                if (_contentPlaceHolder == null)
+                    throw new HttpException(SR.GetString(SR.Control_Missing_Attribute, _contentPlaceHolderIDPropName, type.Name));
+
+                attribs.Clear();
+                // Add the preserevd attributes back to the control
+                foreach (var pair in preservedAttributes) {
+                    attribs[pair.Key] = pair.Value;
+                }
+            }
+
+            base.Init(parser, parentBuilder, type, tagName, ID, attribs);
+        }
+
+        internal override void SetParentBuilder(ControlBuilder parentBuilder) {
+            if (!InDesigner && !(parentBuilder is FileLevelPageControlBuilder)) {
+                throw new HttpException(SR.GetString(SR.Content_allowed_in_top_level_only));
+            }
+
+            base.SetParentBuilder(parentBuilder);
+        }
+    }
+
+    // Factory used to efficiently create builder instances
+    internal class ContentBuilderInternalFactory: IWebObjectFactory {
+        object IWebObjectFactory.CreateInstance() {
+            return new ContentBuilderInternal();
+        }
+    }
+
+    /* This control represents the ITemplate property on the content page that will be applied
+       to the MasterPage template property. The ContentPlaceHolderID is never assigned at runtime. */
+
+    [
+    ControlBuilderAttribute(typeof(ContentBuilderInternal)),
+    ]
+    [Designer("System.Web.UI.Design.WebControls.ContentDesigner, " + AssemblyRef.SystemDesign)]
+    [ToolboxItem(false)]
+    public class Content : Control, INonBindingContainer {
+        private string _contentPlaceHolderID;
+
+
+        [
+        DefaultValue(""),
+        IDReferenceProperty(typeof(ContentPlaceHolder)),
+        Themeable(false),
+        WebCategory("Behavior"),
+        WebSysDescription(SR.Content_ContentPlaceHolderID),
+        ]
+        public string ContentPlaceHolderID {
+            get {
+                if (_contentPlaceHolderID == null) {
+                    return String.Empty;
+                }
+                return _contentPlaceHolderID;
+            }
+            set {
+                if (!DesignMode)
+                    throw new NotSupportedException(SR.GetString(SR.Property_Set_Not_Supported, "ContentPlaceHolderID", this.GetType().ToString()));
+
+                _contentPlaceHolderID = value;
+            }
+        }
+
+        #region hide these events in the designer since they will not be invoked.
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public new event EventHandler DataBinding {
+            add {
+                base.DataBinding += value;
+            }
+            remove {
+                base.DataBinding -= value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public new event EventHandler Disposed {
+            add {
+                base.Disposed += value;
+            }
+            remove {
+                base.Disposed -= value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public new event EventHandler Init {
+            add {
+                base.Init += value;
+            }
+            remove {
+                base.Init -= value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public new event EventHandler Load {
+            add {
+                base.Load += value;
+            }
+            remove {
+                base.Load -= value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public new event EventHandler PreRender {
+            add {
+                base.PreRender += value;
+            }
+            remove {
+                base.PreRender -= value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public new event EventHandler Unload {
+            add {
+                base.Unload += value;
+            }
+            remove {
+                base.Unload -= value;
+            }
+        }
+        #endregion
+    }
+}