Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

431 lines
16 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="PropertyGridEditorPart.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.Diagnostics;
using System.Drawing;
using System.Globalization;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Util;
using Debug = System.Diagnostics.Debug;
using AttributeCollection = System.ComponentModel.AttributeCollection;
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
}
/// <devdoc>
/// WebDisplayNameAttribute marks a property, event, or extender with a
/// DisplayName for the PropertyGridEditorPart.
/// </devdoc>
private sealed class WebSysWebDisplayNameAttribute : WebDisplayNameAttribute {
private bool replaced;
/// <devdoc>
/// <para>Constructs a new sys DisplayName.</para>
/// </devdoc>
internal WebSysWebDisplayNameAttribute(string DisplayName) : base(DisplayName) {
}
/// <devdoc>
/// <para>Retrieves the DisplayName text.</para>
/// </devdoc>
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);
}
}
}
}
}
}