Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,353 @@
+//------------------------------------------------------------------------------
+// <copyright file="GenericWebPart.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls.WebParts {
+
+    using System;
+    using System.Collections;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Web.UI;
+    using System.Web.UI.WebControls;
+    using System.Web.Util;
+
+    /// <devdoc>
+    /// A WebPart that can wrap any other generic server control, and provide it
+    /// with "WebPart-ness."
+    /// 1. Implements several properties if not set on the WebPart by looking for an
+    /// attribute on the contained control.
+    /// 2. Implement IWebEditable to allow the PropertyGridEditorPart to tunnel-in
+    /// and browse the contained control.
+    /// </devdoc>
+    [
+    ToolboxItem(false)
+    ]
+    public class GenericWebPart : WebPart {
+
+        internal const string IDPrefix = "gwp";
+        private Control _childControl;
+        private IWebPart _childIWebPart;
+        private string _subtitle;
+
+        /// <devdoc>
+        /// Intializes an instance of GenericWebPart with the control it is to wrap.
+        /// </devdoc>
+        protected internal GenericWebPart(Control control) {
+            if (control == null) {
+                throw new ArgumentNullException("control");
+            }
+            if (control is WebPart) {
+                throw new ArgumentException(SR.GetString(SR.GenericWebPart_CannotWrapWebPart), "control");
+            }
+            if (control is BasePartialCachingControl) {
+                throw new ArgumentException(SR.GetString(SR.GenericWebPart_CannotWrapOutputCachedControl), "control");
+            }
+            if (String.IsNullOrEmpty(control.ID)) {
+                throw new ArgumentException(SR.GetString(SR.GenericWebPart_NoID, control.GetType().FullName));
+            }
+
+            ID = IDPrefix + control.ID;
+            _childControl = control;
+            _childIWebPart = _childControl as IWebPart;
+            CopyChildAttributes();
+        }
+
+        public override string CatalogIconImageUrl {
+            get {
+                if (_childIWebPart != null) {
+                    return _childIWebPart.CatalogIconImageUrl;
+                }
+                else {
+                    return base.CatalogIconImageUrl;
+                }
+            }
+            set {
+                if (_childIWebPart != null) {
+                    _childIWebPart.CatalogIconImageUrl = value;
+                }
+                else {
+                    base.CatalogIconImageUrl = value;
+                }
+            }
+        }
+
+        public Control ChildControl {
+            get {
+                Debug.Assert(_childControl != null, "ChildControl cannot be null.");
+                return _childControl;
+            }
+        }
+
+        public override string Description {
+            get {
+                if (_childIWebPart != null) {
+                    return _childIWebPart.Description;
+                }
+                else {
+                    return base.Description;
+                }
+            }
+            set {
+                if (_childIWebPart != null) {
+                    _childIWebPart.Description = value;
+                }
+                else {
+                    base.Description = value;
+                }
+            }
+        }
+
+        public override Unit Height {
+            get {
+                WebControl c = ChildControl as WebControl;
+                if (c != null) {
+                    return c.Height;
+                }
+                else {
+                    return base.Height;
+                }
+            }
+            set {
+                WebControl c = ChildControl as WebControl;
+                if (c != null) {
+                    c.Height = value;
+                }
+                else {
+                    base.Height = value;
+                }
+            }
+        }
+
+        // Seal the ID property so we can set it in the constructor without an FxCop violation.
+        public sealed override string ID {
+            get {
+                return base.ID;
+            }
+            set {
+                base.ID = value;
+            }
+        }
+
+        public override string Subtitle {
+            get {
+                if (_childIWebPart != null) {
+                    return _childIWebPart.Subtitle;
+                }
+                else {
+                    return (_subtitle != null ? _subtitle : String.Empty);
+                }
+            }
+        }
+
+        public override string Title {
+            get {
+                if (_childIWebPart != null) {
+                    return _childIWebPart.Title;
+                }
+                else {
+                    return base.Title;
+                }
+            }
+            set {
+                if (_childIWebPart != null) {
+                    _childIWebPart.Title = value;
+                }
+                else {
+                    base.Title = value;
+                }
+            }
+        }
+
+        public override string TitleIconImageUrl {
+            get {
+                if (_childIWebPart != null) {
+                    return _childIWebPart.TitleIconImageUrl;
+                }
+                else {
+                    return base.TitleIconImageUrl;
+                }
+            }
+            set {
+                if (_childIWebPart != null) {
+                    _childIWebPart.TitleIconImageUrl = value;
+                }
+                else {
+                    base.TitleIconImageUrl = value;
+                }
+            }
+        }
+
+        public override string TitleUrl {
+            get {
+                if (_childIWebPart != null) {
+                    return _childIWebPart.TitleUrl;
+                }
+                else {
+                    return base.TitleUrl;
+                }
+            }
+            set {
+                if (_childIWebPart != null) {
+                    _childIWebPart.TitleUrl = value;
+                }
+                else {
+                    base.TitleUrl = value;
+                }
+            }
+        }
+
+        public override WebPartVerbCollection Verbs {
+            get {
+                if (ChildControl != null) {
+                    IWebActionable webActionableChildControl = ChildControl as IWebActionable;
+                    if (webActionableChildControl != null) {
+                        return new WebPartVerbCollection(base.Verbs, webActionableChildControl.Verbs);
+                    }
+                }
+                return base.Verbs;
+            }
+        }
+
+        public override object WebBrowsableObject {
+            get {
+                IWebEditable webEditableChildControl = ChildControl as IWebEditable;
+                if (webEditableChildControl != null) {
+                    return webEditableChildControl.WebBrowsableObject;
+                }
+                else {
+                    return ChildControl;
+                }
+            }
+        }
+
+        public override Unit Width {
+            get {
+                WebControl c = ChildControl as WebControl;
+                if (c != null) {
+                    return c.Width;
+                }
+                else {
+                    return base.Width;
+                }
+            }
+            set {
+                WebControl c = ChildControl as WebControl;
+                if (c != null) {
+                    c.Width = value;
+                }
+                else {
+                    base.Width = value;
+                }
+            }
+        }
+
+        private void CopyChildAttributes() {
+            // Copy the attribute values from the ChildControl to the GenericWebPart properties.
+            IAttributeAccessor childAttributeAccessor = ChildControl as IAttributeAccessor;
+            if (childAttributeAccessor != null) {
+                base.AuthorizationFilter = childAttributeAccessor.GetAttribute("AuthorizationFilter");
+                base.CatalogIconImageUrl = childAttributeAccessor.GetAttribute("CatalogIconImageUrl");
+                base.Description = childAttributeAccessor.GetAttribute("Description");
+
+                string exportMode = childAttributeAccessor.GetAttribute("ExportMode");
+                if (exportMode != null) {
+                    base.ExportMode = (WebPartExportMode)(Util.GetEnumAttribute(
+                        "ExportMode", exportMode, typeof(WebPartExportMode)));
+                }
+
+                // Don't need to check base.Subtitle, since we always want to use the Subtitle on the
+                // ChildControl if it is present.  Also, the property is not settable on WebPart, so we
+                // know that base.Subtitle will always be String.Empty.
+                _subtitle = childAttributeAccessor.GetAttribute("Subtitle");
+
+                base.Title = childAttributeAccessor.GetAttribute("Title");
+                base.TitleIconImageUrl = childAttributeAccessor.GetAttribute("TitleIconImageUrl");
+                base.TitleUrl = childAttributeAccessor.GetAttribute("TitleUrl");
+            }
+
+            // Remove all the attributes from the ChildControl, whether or not they were copied
+            // to the GenericWebPart property.  We want to remove the attributes so they are not
+            // rendered on the ChildControl.  (VSWhidbey 313674)
+            WebControl childWebControl = ChildControl as WebControl;
+            if (childWebControl != null) {
+                // If the ChildControl is a WebControl, we want to completely remove the attributes.
+                childWebControl.Attributes.Remove("AuthorizationFilter");
+                childWebControl.Attributes.Remove("CatalogIconImageUrl");
+                childWebControl.Attributes.Remove("Description");
+                childWebControl.Attributes.Remove("ExportMode");
+                childWebControl.Attributes.Remove("Subtitle");
+                childWebControl.Attributes.Remove("Title");
+                childWebControl.Attributes.Remove("TitleIconImageUrl");
+                childWebControl.Attributes.Remove("TitleUrl");
+            }
+            else if (childAttributeAccessor != null) {
+                // If the ChildControl is not a WebControl, we cannot remove the attributes, so we set
+                // them to null instead.
+                childAttributeAccessor.SetAttribute("AuthorizationFilter", null);
+                childAttributeAccessor.SetAttribute("CatalogIconImageUrl", null);
+                childAttributeAccessor.SetAttribute("Description", null);
+                childAttributeAccessor.SetAttribute("ExportMode", null);
+                childAttributeAccessor.SetAttribute("Subtitle", null);
+                childAttributeAccessor.SetAttribute("Title", null);
+                childAttributeAccessor.SetAttribute("TitleIconImageUrl", null);
+                childAttributeAccessor.SetAttribute("TitleUrl", null);
+            }
+        }
+
+        protected internal override void CreateChildControls() {
+            ((GenericWebPartControlCollection)Controls).AddGenericControl(ChildControl);
+        }
+
+        protected override ControlCollection CreateControlCollection() {
+            return new GenericWebPartControlCollection(this);
+        }
+
+        public override EditorPartCollection CreateEditorParts() {
+            IWebEditable webEditableChildControl = ChildControl as IWebEditable;
+            if (webEditableChildControl != null) {
+                return new EditorPartCollection(base.CreateEditorParts(), webEditableChildControl.CreateEditorParts());
+            }
+            else {
+                return base.CreateEditorParts();
+            }
+        }
+
+        protected internal override void Render(HtmlTextWriter writer) {
+            // Copied from CompositeControl.Render()
+            if (DesignMode) {
+                EnsureChildControls();
+            }
+
+            RenderContents(writer);
+        }
+
+        private sealed class GenericWebPartControlCollection : ControlCollection {
+            public GenericWebPartControlCollection(GenericWebPart owner) : base(owner) {
+                SetCollectionReadOnly(SR.GenericWebPart_CannotModify);
+            }
+
+            /// <devdoc>
+            /// Allows adding the generic control to be wrapped.
+            /// </devdoc>
+            public void AddGenericControl(Control control) {
+                string originalError = SetCollectionReadOnly(null);
+                // Extra try-catch block to prevent elevation of privilege attack via exception filter
+                try {
+                    try {
+                        Clear();
+                        Add(control);
+                    }
+                    finally {
+                        SetCollectionReadOnly(originalError);
+                    }
+                }
+                catch {
+                    throw;
+                }
+            }
+        }
+    }
+}