PropertyGridEditorPart.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebParts / PropertyGridEditorPart.cs / 1 / PropertyGridEditorPart.cs

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

namespace System.Web.UI.WebControls.WebParts { 
 
    using System;
    using System.Collections; 
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Drawing;
    using System.Globalization; 
    using System.Security.Permissions;
    using System.Web.UI; 
    using System.Web.UI.WebControls; 
    using System.Web.Util;
 
    using Debug = System.Diagnostics.Debug;
    using AttributeCollection = System.ComponentModel.AttributeCollection;

    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    public sealed class PropertyGridEditorPart : EditorPart {
 
        // Controls that accept user input to set property values (textboxes, dropdownlists, etc.) 
        // Should use this in addition to Controls collection, since Controls collection
        // can be modified by user code. 
        private ArrayList _editorControls;

        // Array of error messages associated with each editor control
        private string[] _errorMessages; 

        private static readonly Attribute[] FilterAttributes = 
            new Attribute[] { WebBrowsableAttribute.Yes }; 

        private static readonly WebPart designModeWebPart = new DesignModeWebPart(); 

        private static readonly UrlPropertyAttribute urlPropertyAttribute = new UrlPropertyAttribute();

        private const int TextBoxColumns = 30; 

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), Themeable(false)] 
        public override string DefaultButton { 
            get { return base.DefaultButton; }
            set { base.DefaultButton = value; } 
        }

        public override bool Display {
            get { 
                if (base.Display == false) {
                    return false; 
                } 

                object editableObject = GetEditableObject(); 
                if (editableObject != null) {
                    if (GetEditableProperties(editableObject, false).Count > 0) {
                        return true;
                    } 
                }
 
                return false; 
            }
        } 

        private ArrayList EditorControls {
            get {
                if (_editorControls == null) { 
                    _editorControls = new ArrayList();
                } 
                return _editorControls; 
            }
        } 

        private bool HasError {
            get {
                foreach (string errorMessage in _errorMessages) { 
                    if (errorMessage != null) {
                        return true; 
                    } 
                }
                return false; 
            }
        }

        [ 
        WebSysDefaultValue(SR.PropertyGridEditorPart_PartTitle),
        ] 
        public override string Title { 
            get {
                string s = (string)ViewState["Title"]; 
                return (s != null) ? s : SR.GetString(SR.PropertyGridEditorPart_PartTitle);
            }
            set {
                ViewState["Title"] = value; 
            }
        } 
 
        public override bool ApplyChanges() {
            object editableObject = GetEditableObject(); 

            Debug.Assert(editableObject != null);
            if (editableObject == null) {
                return true; 
            }
 
            EnsureChildControls(); 

            int count = Controls.Count; 
            Debug.Assert(count > 0);
            if (count == 0) {
                return true;
            } 

            PropertyDescriptorCollection properties = GetEditableProperties(editableObject, true); 
            for (int i=0; i < properties.Count; i++) { 
                PropertyDescriptor pd = properties[i];
                Control editorControl = (Control)EditorControls[i]; 
                try {
                    object value = GetEditorControlValue(editorControl, pd);
                    // If the property is a url, validate protocol (VSWhidbey 290418)
                    if (pd.Attributes.Matches(urlPropertyAttribute) && 
                        CrossSiteScriptingValidation.IsDangerousUrl(value.ToString())) {
 
                        _errorMessages[i] = SR.GetString(SR.EditorPart_ErrorBadUrl); 
                    }
                    else { 
                        try {
                            pd.SetValue(editableObject, value);
                        }
                        catch (Exception e) { 
                            _errorMessages[i] = CreateErrorMessage(e.Message);
                        } 
                    } 
                }
                catch { 
                    // If custom errors are enabled, we do not want to render the property type to the browser.
                    // (VSWhidbey 381646)
                    if (Context != null && Context.IsCustomErrorEnabled) {
                        _errorMessages[i] = SR.GetString(SR.EditorPart_ErrorConvertingProperty); 
                    }
                    else { 
                        _errorMessages[i] = SR.GetString( 
                            SR.EditorPart_ErrorConvertingPropertyWithType, pd.PropertyType.FullName);
                    } 
                }
            }

            return !HasError; 
        }
 
        // In the future, we may want to add Color, Date, etc. 
        private bool CanEditProperty(PropertyDescriptor property) {
            // Don't show readonly properties 
            if (property.IsReadOnly) {
                return false;
            }
 
            // Don't show Shared personalizable properties in User mode
            if (WebPartManager != null && 
                WebPartManager.Personalization != null && 
                WebPartManager.Personalization.Scope == PersonalizationScope.User) {
 
                AttributeCollection attributes = property.Attributes;
                if (attributes.Contains(PersonalizableAttribute.SharedPersonalizable)) {
                    return false;
                } 
            }
 
            // Only show properties that can be converted to/from string 
            return Util.CanConvertToFrom(property.Converter, typeof(string));
        } 

        protected internal override void CreateChildControls() {
            ControlCollection controls = Controls;
            controls.Clear(); 
            EditorControls.Clear();
 
            object editableObject = GetEditableObject(); 
            if (editableObject != null) {
                foreach (PropertyDescriptor pd in GetEditableProperties(editableObject, true)) { 
                    Control editorControl = CreateEditorControl(pd);
                    EditorControls.Add(editorControl);
                    Controls.Add(editorControl);
                } 
                _errorMessages = new string[EditorControls.Count];
            } 
 
            // We don't need viewstate enabled on our child controls.  Disable for perf.
            foreach (Control c in controls) { 
                c.EnableViewState = false;
            }
        }
 
        private Control CreateEditorControl(PropertyDescriptor pd) {
            Type propertyType = pd.PropertyType; 
            if (propertyType == typeof(bool)) { 
                return new CheckBox();
            } 
            else if (typeof(Enum).IsAssignableFrom(propertyType)) {
                DropDownList dropDownList = new DropDownList();
                ICollection standardValues = pd.Converter.GetStandardValues();
                foreach (object o in standardValues) { 
                    string text = pd.Converter.ConvertToString(o);
                    dropDownList.Items.Add(new ListItem(text)); 
                } 
                return dropDownList;
            } 
            else {
                TextBox textBox = new TextBox();
                textBox.Columns = TextBoxColumns;
                return textBox; 
            }
        } 
 
        private string GetDescription(PropertyDescriptor pd) {
            WebDescriptionAttribute attribute = (WebDescriptionAttribute)pd.Attributes[typeof(WebDescriptionAttribute)]; 
            if (attribute != null) {
                return attribute.Description;
            }
            else { 
                return null;
            } 
        } 

        private string GetDisplayName(PropertyDescriptor pd) { 
            WebDisplayNameAttribute attribute = (WebDisplayNameAttribute)pd.Attributes[typeof(WebDisplayNameAttribute)];
            if (attribute != null && !String.IsNullOrEmpty(attribute.DisplayName)) {
                return attribute.DisplayName;
            } 
            else {
                return pd.Name; 
            } 
        }
 
        private object GetEditableObject() {
            if (DesignMode) {
                return designModeWebPart;
            } 

            WebPart webPartToEdit = WebPartToEdit; 
            IWebEditable editable = webPartToEdit as IWebEditable; 

            if (editable != null) { 
                return editable.WebBrowsableObject;
            }
            return webPartToEdit;
        } 

        private PropertyDescriptorCollection GetEditableProperties(object editableObject, bool sort) { 
            Debug.Assert(editableObject != null); 

            PropertyDescriptorCollection propDescs = TypeDescriptor.GetProperties(editableObject, FilterAttributes); 
            if (sort) {
                propDescs = propDescs.Sort();
            }
 
            PropertyDescriptorCollection filteredPropDescs = new PropertyDescriptorCollection(null);
            foreach (PropertyDescriptor pd in propDescs) { 
                if (CanEditProperty(pd)) { 
                    filteredPropDescs.Add(pd);
                } 
            }

            return filteredPropDescs;
        } 

        private object GetEditorControlValue(Control editorControl, PropertyDescriptor pd) { 
            CheckBox checkBox = editorControl as CheckBox; 
            if (checkBox != null) {
                return checkBox.Checked; 
            }

            DropDownList dropDownList = editorControl as DropDownList;
            if (dropDownList != null) { 
                string value = dropDownList.SelectedValue;
                return pd.Converter.ConvertFromString(value); 
            } 

            TextBox textBox = (TextBox)editorControl; 
            return pd.Converter.ConvertFromString(textBox.Text);
        }

        protected internal override void OnPreRender(EventArgs e) { 
            base.OnPreRender(e);
 
            // We want to synchronize the EditorPart to the state of the WebPart on every page load, 
            // so we stay current if the WebPart changes in the background.
            if (Display && Visible && !HasError) { 
                SyncChanges();
            }
        }
 
        protected internal override void RenderContents(HtmlTextWriter writer) {
            if (Page != null) { 
                Page.VerifyRenderingInServerForm(this); 
            }
 
            // HACK: Need this for child controls to be created at design-time when control is inside template
            EnsureChildControls();

            string[] propertyDisplayNames = null; 
            string[] propertyDescriptions = null;
            object editableObject = GetEditableObject(); 
            if (editableObject != null) { 
                PropertyDescriptorCollection propDescs = GetEditableProperties(editableObject, true);
                propertyDisplayNames = new string[propDescs.Count]; 
                propertyDescriptions = new string[propDescs.Count];
                for (int i=0; i < propDescs.Count; i++) {
                    propertyDisplayNames[i] = GetDisplayName(propDescs[i]);
                    propertyDescriptions[i] = GetDescription(propDescs[i]); 
                }
            } 
 
            if (propertyDisplayNames != null) {
                WebControl[] editorControls = (WebControl[])EditorControls.ToArray(typeof(WebControl)); 
                Debug.Assert(propertyDisplayNames.Length == editorControls.Length && propertyDisplayNames.Length == _errorMessages.Length);
                RenderPropertyEditors(writer, propertyDisplayNames, propertyDescriptions, editorControls, _errorMessages);
            }
        } 

        public override void SyncChanges() { 
            object editableObject = GetEditableObject(); 

            Debug.Assert(editableObject != null); 
            if (editableObject != null) {
                EnsureChildControls();
                int count = 0;
                foreach (PropertyDescriptor pd in GetEditableProperties(editableObject, true)) { 
                    if (CanEditProperty(pd)) {
                        Control editorControl = (Control)EditorControls[count]; 
                        SyncChanges(editorControl, pd, editableObject); 
                        count++;
                    } 
                }
            }
        }
 
        private void SyncChanges(Control control, PropertyDescriptor pd, object instance) {
            Type propertyType = pd.PropertyType; 
            if (propertyType == typeof(bool)) { 
                CheckBox checkBox = (CheckBox)control;
                checkBox.Checked = (bool)pd.GetValue(instance); 
            }
            else if (typeof(Enum).IsAssignableFrom(propertyType)) {
                DropDownList dropDownList = (DropDownList)control;
                dropDownList.SelectedValue = pd.Converter.ConvertToString(pd.GetValue(instance)); 
            }
            else { 
                TextBox textBox = (TextBox)control; 
                textBox.Text = pd.Converter.ConvertToString(pd.GetValue(instance));
            } 
        }

        private sealed class DesignModeWebPart : WebPart {
            [ 
            WebBrowsable(),
            WebSysWebDisplayName(SR.PropertyGridEditorPart_DesignModeWebPart_BoolProperty) 
            ] 
            public bool BoolProperty {
                get { 
                    return false;
                }
                set {
                } 
            }
 
            [ 
            WebBrowsable(),
            WebSysWebDisplayName(SR.PropertyGridEditorPart_DesignModeWebPart_EnumProperty) 
            ]
            public SampleEnum EnumProperty {
                get {
                    return SampleEnum.EnumValue; 
                }
                set { 
                } 
            }
 
            [
            WebBrowsable(),
            WebSysWebDisplayName(SR.PropertyGridEditorPart_DesignModeWebPart_StringProperty)
            ] 
            public string StringProperty {
                get { 
                    return String.Empty; 
                }
                set { 
                }
            }

            public enum SampleEnum { 
                EnumValue
            } 
 
            /// 
            ///     WebDisplayNameAttribute marks a property, event, or extender with a 
            ///     DisplayName for the PropertyGridEditorPart.
            /// 
            private sealed class WebSysWebDisplayNameAttribute : WebDisplayNameAttribute {
 
                private bool replaced;
 
 
                /// 
                ///    Constructs a new sys DisplayName. 
                /// 
                internal WebSysWebDisplayNameAttribute(string DisplayName) : base(DisplayName) {
                }
 

                ///  
                ///    Retrieves the DisplayName text. 
                /// 
                public override string DisplayName { 
                    get {
                        if (!replaced) {
                            replaced = true;
                            DisplayNameValue = SR.GetString(base.DisplayName); 
                        }
                        return base.DisplayName; 
                    } 
                }
 
                public override object TypeId {
                    get {
                        return typeof(WebDisplayNameAttribute);
                    } 
                }
            } 
        } 
    }
}
                        

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