mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
431 lines
16 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|