GenericWebPart.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebParts / GenericWebPart.cs / 1 / GenericWebPart.cs
                        

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

namespace System.Web.UI.WebControls.WebParts { 
 
    using System;
    using System.Collections; 
    using System.ComponentModel;
    using System.Globalization;
    using System.Security.Permissions;
    using System.Web.UI; 
    using System.Web.UI.WebControls;
    using System.Web.Util; 
 
    /// 
    /// 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.
    ///  
    [ 
    ToolboxItem(false)
    ] 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class GenericWebPart : WebPart {
 
        internal const string IDPrefix = "gwp";
        private Control _childControl; 
        private IWebPart _childIWebPart; 
        private string _subtitle;
 
        /// 
        /// Intializes an instance of GenericWebPart with the control it is to wrap.
        /// 
        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); 
            }
 
            /// 
            /// Allows adding the generic control to be wrapped.
            /// 
            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;
                } 
            }
        }
    }
}

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