Files
mono/mcs/class/referencesource/System.Web.DynamicData/DynamicData/DynamicControl.cs
T
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

436 lines
14 KiB
C#

namespace System.Web.DynamicData {
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Resources;
using System.Web.UI;
using System.Collections.Generic;
using System.Reflection;
using System.Web.UI.WebControls;
using System.Drawing;
using System.Diagnostics;
/// <summary>
/// Control used to render Dynamic Data driven UI
/// </summary>
[ToolboxBitmap(typeof(DynamicControl), "DynamicControl.bmp")]
public class DynamicControl : Control, IAttributeAccessor, IFieldTemplateHost, IFieldFormattingOptions {
private bool _customConvertEmptyStringToNullSet;
private bool _customApplyFormatInEditModeSet;
private MetaTable _table;
private IMetaTable _iMetaTable;
private IDictionary<string, string> _attributes;
private IMetaColumn _iMetaColumn;
private MetaColumn _column;
/// <summary>
/// </summary>
public DynamicControl() {
}
internal DynamicControl(IMetaTable table) {
_iMetaTable = table;
}
internal DynamicControl(IMetaColumn column) {
_iMetaColumn = column;
}
/// <param name="mode">The mode that the associated field template should be in (readonly, edit, insert)</param>
public DynamicControl(DataBoundControlMode mode) {
Mode = mode;
}
/// <summary>
/// The name of the column that this control handles
/// </summary>
[
Category("Data"),
DefaultValue(""),
ResourceDescription("DynamicControlFieldCommon_DataField")
]
public string DataField {
get {
object o = ViewState["DataField"];
return ((o == null) ? String.Empty : (string)o);
}
set {
if (!String.Equals(value, ViewState["DataField"])) {
ViewState["DataField"] = value;
}
}
}
/// <summary>
/// The MetaColumn that this control is working with
/// </summary>
[Browsable(false)]
public MetaColumn Column {
get {
return _column;
}
set {
_column = value;
_iMetaColumn = value;
}
}
/// <summary>
/// The UIHint used by this control to locate the proper field template
/// </summary>
[
Category("Behavior"),
DefaultValue(""),
ResourceDescription("DynamicControlFieldCommon_UIHint")
]
public virtual string UIHint {
get {
object o = ViewState["UIHint"];
return ((o == null) ? String.Empty : (string)o);
}
set {
ViewState["UIHint"] = value;
}
}
/// <summary>
/// Gets or sets the CSS class property of the DynamicControl
/// </summary>
[
Category("Appearance"),
DefaultValue(""),
CssClassProperty()
]
public virtual string CssClass {
get {
object o = ViewState["CssClass"];
return ((o == null) ? String.Empty : (string)o);
}
set {
ViewState["CssClass"] = value;
}
}
/// <summary>
/// The MetaTable that this control is associated with
/// </summary>
[Browsable(false)]
public virtual MetaTable Table {
get {
if (_table == null) {
_table = this.FindMetaTable();
if (_table == null) {
throw new Exception(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.DynamicControl_ControlNeedsToExistInADataControlUsingDynamicDataSource));
}
}
return _table;
}
}
private IMetaTable IMetaTable {
get {
return _iMetaTable ?? Table;
}
}
private IMetaColumn IMetaColumn {
get {
return _iMetaColumn;
}
set {
_iMetaColumn = value;
_column = value as MetaColumn;
}
}
/// <summary>
/// The rendering mode: readonly, edit or insert
/// </summary>
[
DefaultValue(DataBoundControlMode.ReadOnly),
Category("Behavior"),
ResourceDescription("DynamicField_Mode")
]
public DataBoundControlMode Mode {
get {
object o = ViewState["Mode"];
return ((o == null) ? DataBoundControlMode.ReadOnly : (DataBoundControlMode)o);
}
set {
ViewState["Mode"] = value;
}
}
/// <summary>
/// The validation group that the field template need to be in
/// </summary>
[
Category("Behavior"),
DefaultValue(""),
Themeable(false),
ResourceDescription("DynamicControlFieldCommon_ValidationGroup")
]
public virtual string ValidationGroup {
get {
object o = ViewState["ValidationGroup"];
return ((o == null) ? String.Empty : (string)o);
}
set {
ViewState["ValidationGroup"] = value;
}
}
internal Control CreateControl() {
Debug.Assert(FieldTemplate == null);
FieldTemplate = (Control)IMetaColumn.Model.FieldTemplateFactory.CreateFieldTemplate(Column, Mode, UIHint);
if (FieldTemplate != null) {
((IFieldTemplate)FieldTemplate).SetHost(this);
// If we got some extra attributes declared on the tag, assign them to the user control if it has matching properties
if (_attributes != null) {
var ucType = FieldTemplate.GetType();
foreach (var entry in _attributes) {
// Look for a public property by that name on th user control
var propInfo = ucType.GetProperty(entry.Key, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (propInfo != null) {
// Convert the value to the type of the property and set it
var value = PropertyConverter.ObjectFromString(propInfo.PropertyType, propInfo, entry.Value);
propInfo.SetValue(FieldTemplate, value, null);
}
}
}
// Give it the column name as its ID, unless there is already a control by that name
string id = GetControlIDFromColumnName(IMetaColumn.Name);
if (FindControl(id) == null)
FieldTemplate.ID = id;
}
return FieldTemplate;
}
/// <summary>
/// See base class documentation
/// </summary>
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers")]
protected override void OnInit(EventArgs e) {
base.OnInit(e);
// Don't do anything in Design mode
if (DesignMode)
return;
ResolveColumn();
FieldTemplate = CreateControl();
// Add it to the tree
if (FieldTemplate != null) {
Controls.Add(FieldTemplate);
}
}
/// <summary>
/// Renders the underlying field template control. If this DynamicControl's CssClass tag is defined,
/// the underlying control's output will be wrapped in a span tag with that css class applied.
/// </summary>
/// <param name="writer"></param>
protected override void Render(HtmlTextWriter writer) {
// In Design mode, simply render the string Databound. Ideally, we'd do something fancier
// that takes into account the type of the column. But at lesat, rendering *something* makes
// the design layout look reasonable
if (DesignMode) {
writer.Write(DynamicDataResources.DynamicControlDesignRender);
return;
}
// If there is a CSS class, output it in a span tag. Otherwise, don't use any extra tag.
if (!String.IsNullOrEmpty(CssClass)) {
writer.AddAttribute(HtmlTextWriterAttribute.Class, CssClass);
writer.RenderBeginTag(HtmlTextWriterTag.Span);
base.Render(writer);
writer.RenderEndTag();
}
else {
base.Render(writer);
}
}
internal void ResolveColumn() {
if (IMetaColumn == null) {
if (String.IsNullOrEmpty(DataField)) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.DynamicControl_ControlMustHaveDateFieldAttribute, GetType().Name, ID));
}
IMetaColumn = IMetaTable.GetColumn(DataField);
// Try to get them various settings from the model, unless they were explicitely
// specified on the control
if (String.IsNullOrEmpty(UIHint)) {
UIHint = IMetaColumn.UIHint;
}
if (String.IsNullOrEmpty(DataFormatString)) {
DataFormatString = IMetaColumn.DataFormatString;
}
if (String.IsNullOrEmpty(NullDisplayText)) {
NullDisplayText = IMetaColumn.NullDisplayText;
}
if (!_customConvertEmptyStringToNullSet) {
ConvertEmptyStringToNull = IMetaColumn.ConvertEmptyStringToNull;
}
if (!_customApplyFormatInEditModeSet) {
ApplyFormatInEditMode = IMetaColumn.ApplyFormatInEditMode;
}
if (ViewState["HtmlEncode"] == null) {
HtmlEncode = IMetaColumn.HtmlEncode;
}
}
}
/// <summary>
/// The Field Template that was created for this control
/// </summary>
[Browsable(false)]
public Control FieldTemplate { get; private set; }
internal static string GetControlIDFromColumnName(string columnName) {
return "__" + columnName;
}
internal void SetAttributes(IDictionary<string, string> attributes) {
_attributes = attributes;
}
#region IAttributeAccessor Members
/// <summary>
/// See IAttributeAccessor
/// </summary>
public string GetAttribute(string key) {
if (_attributes == null)
return String.Empty;
return _attributes[key];
}
/// <summary>
/// See IAttributeAccessor
/// </summary>
public void SetAttribute(string key, string value) {
if (_attributes == null) {
_attributes = new Dictionary<string, string>();
}
_attributes[key] = value;
}
#endregion
#region IFieldTemplateHost Members
IFieldFormattingOptions IFieldTemplateHost.FormattingOptions {
get { return this; }
}
#endregion
#region IFieldFormattingOptions Members
/// <summary>
/// See IFieldFormattingOptions
/// </summary>
[
Category("Behavior"),
DefaultValue(false),
ResourceDescription("DynamicControlFieldCommon_ConvertEmptyStringToNull")
]
public bool ConvertEmptyStringToNull {
get {
object o = ViewState["ConvertEmptyStringToNull"];
return (o == null ? false : (bool)o);
}
set {
_customConvertEmptyStringToNullSet = true;
ViewState["ConvertEmptyStringToNull"] = value;
}
}
/// <summary>
/// See IFieldFormattingOptions
/// </summary>
[
Category("Behavior"),
DefaultValue(false),
ResourceDescription("DynamicControlFieldCommon_ApplyFormatInEditMode")
]
public bool ApplyFormatInEditMode {
get {
object o = ViewState["ApplyFormatInEditMode"];
return (o == null ? false : (bool)o);
}
set {
_customApplyFormatInEditModeSet = true;
ViewState["ApplyFormatInEditMode"] = value;
}
}
/// <summary>
/// See IFieldFormattingOptions
/// </summary>
[
Category("Data"),
DefaultValue(""),
ResourceDescription("DynamicControlFieldCommon_DataFormatString")
]
public string DataFormatString {
get {
object o = ViewState["DataFormatString"];
return (o == null ? String.Empty : (string)o);
}
set {
ViewState["DataFormatString"] = value;
}
}
/// <summary>
/// See IFieldFormattingOptions
/// </summary>
[
Category("Behavior"),
DefaultValue(true),
ResourceDescription("DynamicControlFieldCommon_HtmlEncode")
]
public bool HtmlEncode {
get {
object o = ViewState["HtmlEncode"];
return (o == null ? true : (bool)o);
}
set {
ViewState["HtmlEncode"] = value;
}
}
/// <summary>
/// See IFieldFormattingOptions
/// </summary>
[
Category("Behavior"),
DefaultValue(""),
ResourceDescription("DynamicControlFieldCommon_NullDisplayText")
]
public string NullDisplayText {
get {
object o = ViewState["NullDisplayText"];
return (o == null ? String.Empty : (string)o);
}
set {
ViewState["NullDisplayText"] = value;
}
}
#endregion
}
}