Files
mono/mcs/class/referencesource/System.Web/UI/WebControls/TextBox.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

724 lines
26 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="TextBox.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Drawing.Design;
using System.Globalization;
using System.Web;
using System.Web.UI;
using System.Web.Util;
/// <devdoc>
/// <para>Interacts with the parser to build a <see cref='System.Web.UI.WebControls.TextBox'/> control.</para>
/// </devdoc>
public class TextBoxControlBuilder : ControlBuilder {
/// <internalonly/>
/// <devdoc>
/// Specifies whether white space literals are allowed.
/// </devdoc>
public override bool AllowWhitespaceLiterals() {
return false;
}
public override bool HtmlDecodeLiterals() {
// TextBox text gets rendered as an encoded attribute value or encoded content.
// At parse time text specified as an attribute gets decoded, and so text specified as a
// literal needs to go through the same process.
return true;
}
}
/// <devdoc>
/// <para>Constructs a text box and defines its properties.</para>
/// </devdoc>
[
ControlBuilderAttribute(typeof(TextBoxControlBuilder)),
ControlValueProperty("Text"),
DataBindingHandler("System.Web.UI.Design.TextDataBindingHandler, " + AssemblyRef.SystemDesign),
DefaultProperty("Text"),
ValidationProperty("Text"),
DefaultEvent("TextChanged"),
Designer("System.Web.UI.Design.WebControls.PreviewControlDesigner, " + AssemblyRef.SystemDesign),
ParseChildren(true, "Text"),
SupportsEventValidation,
]
public class TextBox : WebControl, IPostBackDataHandler, IEditableTextControl {
private static readonly object EventTextChanged = new Object();
private const string _textBoxKeyHandlerCall = "if (WebForm_TextBoxKeyHandler(event) == false) return false;";
private const int DefaultMutliLineRows = 2;
private const int DefaultMutliLineColumns = 20;
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.TextBox'/> class.</para>
/// </devdoc>
public TextBox() : base(HtmlTextWriterTag.Input) {
}
[
DefaultValue(AutoCompleteType.None),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.TextBox_AutoCompleteType)
]
public virtual AutoCompleteType AutoCompleteType {
get {
object obj = ViewState["AutoCompleteType"];
return (obj == null) ? AutoCompleteType.None : (AutoCompleteType) obj;
}
set {
if (value < AutoCompleteType.None || value > AutoCompleteType.Enabled) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["AutoCompleteType"] = value;
}
}
/// <devdoc>
/// <para>Gets or sets a value indicating whether an automatic
/// postback to the server will occur whenever the user changes the
/// content of the text box.</para>
/// </devdoc>
[
DefaultValue(false),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.TextBox_AutoPostBack),
]
public virtual bool AutoPostBack {
get {
object b = ViewState["AutoPostBack"];
return((b == null) ? false : (bool)b);
}
set {
ViewState["AutoPostBack"] = value;
}
}
[
DefaultValue(false),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.AutoPostBackControl_CausesValidation)
]
public virtual bool CausesValidation {
get {
object b = ViewState["CausesValidation"];
return((b == null) ? false : (bool)b);
}
set {
ViewState["CausesValidation"] = value;
}
}
/// <devdoc>
/// <para>Gets or sets the display
/// width of the text box in characters.</para>
/// </devdoc>
[
WebCategory("Appearance"),
DefaultValue(0),
WebSysDescription(SR.TextBox_Columns)
]
public virtual int Columns {
get {
object o = ViewState["Columns"];
return((o == null) ? 0 : (int)o);
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("Columns", SR.GetString(SR.TextBox_InvalidColumns));
}
ViewState["Columns"] = value;
}
}
/// <devdoc>
/// <para>Gets or sets the maximum number of characters allowed in the text box.</para>
/// </devdoc>
[
DefaultValue(0),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.TextBox_MaxLength),
]
public virtual int MaxLength {
get {
object o = ViewState["MaxLength"];
return((o == null) ? 0 : (int)o);
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["MaxLength"] = value;
}
}
/// <devdoc>
/// <para>
/// Gets or sets the behavior mode of the text box.</para>
/// </devdoc>
[
DefaultValue(TextBoxMode.SingleLine),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.TextBox_TextMode)
]
public virtual TextBoxMode TextMode {
get {
object mode = ViewState["Mode"];
return((mode == null) ? TextBoxMode.SingleLine : (TextBoxMode)mode);
}
set {
if (value < TextBoxMode.SingleLine || value > TextBoxMode.Week) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["Mode"] = value;
}
}
/// <devdoc>
/// <para>Whether the textbox is in read-only mode.</para>
/// </devdoc>
[
Bindable(true),
DefaultValue(false),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.TextBox_ReadOnly)
]
public virtual bool ReadOnly {
get {
object o = ViewState["ReadOnly"];
return((o == null) ? false : (bool)o);
}
set {
ViewState["ReadOnly"] = value;
}
}
/// <devdoc>
/// <para> Gets or sets the display height of a multiline text box.</para>
/// </devdoc>
[
DefaultValue(0),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.TextBox_Rows)
]
public virtual int Rows {
get {
object o = ViewState["Rows"];
return((o == null) ? 0 : (int)o);
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("Rows", SR.GetString(SR.TextBox_InvalidRows));
}
ViewState["Rows"] = value;
}
}
/// <devdoc>
/// Determines whether the Text must be stored in view state, to
/// optimize the size of the saved state.
/// </devdoc>
private bool SaveTextViewState {
get {
//
// Must be saved when
// 1. There is a registered event handler for SelectedIndexChanged
// 2. Control is not enabled or visible, because the browser's post data will not include this control
// 3. The instance is a derived instance, which might be overriding the OnTextChanged method
if (TextMode == TextBoxMode.Password) {
return false;
}
if ((Events[EventTextChanged] != null) ||
(IsEnabled == false) ||
(Visible == false) ||
(ReadOnly) ||
(this.GetType() != typeof(TextBox))) {
return true;
}
return false;
}
}
/// <devdoc>
/// <para>A protected property. Gets the HTML tag
/// for the text box control.</para>
/// </devdoc>
protected override HtmlTextWriterTag TagKey {
get {
if (TextMode == TextBoxMode.MultiLine)
return HtmlTextWriterTag.Textarea;
else
return HtmlTextWriterTag.Input;
}
}
/// <devdoc>
/// <para> Gets
/// or sets the text content of the text box.</para>
/// </devdoc>
[
Localizable(true),
Bindable(true, BindingDirection.TwoWay),
WebCategory("Appearance"),
DefaultValue(""),
WebSysDescription(SR.TextBox_Text),
PersistenceMode(PersistenceMode.EncodedInnerDefaultProperty),
Editor("System.ComponentModel.Design.MultilineStringEditor," + AssemblyRef.SystemDesign, typeof(UITypeEditor))
]
public virtual string Text {
get {
string s = (string)ViewState["Text"];
return((s == null) ? String.Empty : s);
}
set {
ViewState["Text"] = value;
}
}
[
WebCategory("Behavior"),
Themeable(false),
DefaultValue(""),
WebSysDescription(SR.PostBackControl_ValidationGroup)
]
public virtual string ValidationGroup {
get {
string s = (string)ViewState["ValidationGroup"];
return((s == null) ? string.Empty : s);
}
set {
ViewState["ValidationGroup"] = value;
}
}
/// <devdoc>
/// Gets or sets a value indicating whether the
/// text content wraps within the text box.
/// </devdoc>
[
WebCategory("Layout"),
DefaultValue(true),
WebSysDescription(SR.TextBox_Wrap)
]
public virtual bool Wrap {
get {
object b = ViewState["Wrap"];
return((b == null) ? true : (bool)b);
}
set {
ViewState["Wrap"] = value;
}
}
// internal for unit testing
internal virtual bool SupportsVCard {
get {
return Context != null && Context.Request.Browser["supportsVCard"] == "true";
}
}
/// <devdoc>
/// <para>Occurs when the content of the text box is
/// changed upon server postback.</para>
/// </devdoc>
[
WebCategory("Action"),
WebSysDescription(SR.TextBox_OnTextChanged)
]
public event EventHandler TextChanged {
add {
Events.AddHandler(EventTextChanged, value);
}
remove {
Events.RemoveHandler(EventTextChanged, value);
}
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected override void AddAttributesToRender(HtmlTextWriter writer) {
// Make sure we are in a form tag with runat=server.
Page page = Page;
if (page != null) {
page.VerifyRenderingInServerForm(this);
}
string uniqueID = UniqueID;
if (uniqueID != null) {
writer.AddAttribute(HtmlTextWriterAttribute.Name, uniqueID);
}
TextBoxMode mode = TextMode;
if (mode == TextBoxMode.MultiLine) {
// MultiLine renders as textarea
int rows = Rows;
int columns = Columns;
bool adapterRenderZeroRowCol = false;
if (!EnableLegacyRendering) {
// VSWhidbey 497755
if (rows == 0) {
rows = DefaultMutliLineRows;
}
if (columns == 0) {
columns = DefaultMutliLineColumns;
}
}
if (rows > 0 || adapterRenderZeroRowCol) {
writer.AddAttribute(HtmlTextWriterAttribute.Rows, rows.ToString(NumberFormatInfo.InvariantInfo));
}
if (columns > 0 || adapterRenderZeroRowCol) {
writer.AddAttribute(HtmlTextWriterAttribute.Cols, columns.ToString(NumberFormatInfo.InvariantInfo));
}
if (!Wrap) {
writer.AddAttribute(HtmlTextWriterAttribute.Wrap,"off");
}
}
else {
// Everything else renders as input
if (mode != TextBoxMode.SingleLine || String.IsNullOrEmpty(Attributes["type"])) {
// If the developer specified a custom type (like an HTML 5 type), use that type instead of "text".
// The call to base.AddAttributesToRender at the end of this method will add the custom type if specified.
writer.AddAttribute(HtmlTextWriterAttribute.Type, GetTypeAttributeValue(mode));
}
AutoCompleteType autoCompleteType = AutoCompleteType;
if (mode == TextBoxMode.SingleLine &&
autoCompleteType != AutoCompleteType.None &&
autoCompleteType != AutoCompleteType.Enabled &&
autoCompleteType != AutoCompleteType.Disabled &&
SupportsVCard) {
// Renders the vcard_name attribute so that client browsers can support autocomplete
string name = GetVCardAttributeValue(autoCompleteType);
writer.AddAttribute(HtmlTextWriterAttribute.VCardName, name);
}
if (autoCompleteType == AutoCompleteType.Disabled &&
(RenderingCompatibility >= VersionUtil.Framework45 || mode >= TextBoxMode.Color || (SupportsVCard && mode == TextBoxMode.SingleLine))) {
// Only render autocomplete="off" when one of the following is true
// - 4.5 or higher rendering compat is being used
// - any of the new HTML5 modes are being used
// - browser supports vCard AND mode is SingleLine (this is the legacy pre-4.5 behavior)
writer.AddAttribute(HtmlTextWriterAttribute.AutoComplete, "off");
}
if (autoCompleteType == AutoCompleteType.Enabled) {
// Since Enabled is a new value in .NET 4.5 we don't need back-compat switches
writer.AddAttribute(HtmlTextWriterAttribute.AutoComplete, "on");
}
if (mode != TextBoxMode.Password) {
// only render value if we're not a password
string s = Text;
if (s.Length > 0) {
writer.AddAttribute(HtmlTextWriterAttribute.Value, s);
}
}
int n = MaxLength;
if (n > 0) {
writer.AddAttribute(HtmlTextWriterAttribute.Maxlength, n.ToString(NumberFormatInfo.InvariantInfo));
}
n = Columns;
if (n > 0) {
writer.AddAttribute(HtmlTextWriterAttribute.Size, n.ToString(NumberFormatInfo.InvariantInfo));
}
}
if (ReadOnly) {
writer.AddAttribute(HtmlTextWriterAttribute.ReadOnly, "readonly");
}
if (AutoPostBack && (page != null) && page.ClientSupportsJavaScript) {
string onChange = null;
if (HasAttributes) {
onChange = Attributes["onchange"];
if (onChange != null) {
onChange = Util.EnsureEndWithSemiColon(onChange);
Attributes.Remove("onchange");
}
}
PostBackOptions options = new PostBackOptions(this, String.Empty);
// ASURT 98368
// Need to merge the autopostback script with the user script
if (CausesValidation) {
options.PerformValidation = true;
options.ValidationGroup = ValidationGroup;
}
if (page.Form != null) {
options.AutoPostBack = true;
}
onChange = Util.MergeScript(onChange, page.ClientScript.GetPostBackEventReference(options, true));
writer.AddAttribute(HtmlTextWriterAttribute.Onchange, onChange);
// VSWhidbey 482068: Enter key should be preserved in mult-line
// textbox so the textBoxKeyHandlerCall should not be hooked up
if (mode != TextBoxMode.MultiLine) {
string onKeyPress = _textBoxKeyHandlerCall;
if (HasAttributes) {
string userOnKeyPress = Attributes["onkeypress"];
if (userOnKeyPress != null) {
onKeyPress += userOnKeyPress;
Attributes.Remove("onkeypress");
}
}
writer.AddAttribute("onkeypress", onKeyPress);
}
if (EnableLegacyRendering) {
writer.AddAttribute("language", "javascript", false);
}
}
else if (page != null) {
page.ClientScript.RegisterForEventValidation(this.UniqueID, String.Empty);
}
if (Enabled && !IsEnabled && SupportsDisabledAttribute) {
// We need to do the cascade effect on the server, because the browser
// only renders as disabled, but doesn't disable the functionality.
writer.AddAttribute(HtmlTextWriterAttribute.Disabled, "disabled");
}
base.AddAttributesToRender(writer);
}
/// <internalonly/>
/// <devdoc>
/// Overridden to only allow literal controls to be added as Text property.
/// </devdoc>
protected override void AddParsedSubObject(object obj) {
if (obj is LiteralControl) {
Text = ((LiteralControl)obj).Text;
}
else {
throw new HttpException(SR.GetString(SR.Cannot_Have_Children_Of_Type, "TextBox", obj.GetType().Name.ToString(CultureInfo.InvariantCulture)));
}
}
internal static string GetTypeAttributeValue(TextBoxMode mode) {
switch (mode) {
case TextBoxMode.SingleLine: return "text";
case TextBoxMode.Password: return "password";
case TextBoxMode.Color: return "color";
case TextBoxMode.Date: return "date";
case TextBoxMode.DateTime: return "datetime";
case TextBoxMode.DateTimeLocal: return "datetime-local";
case TextBoxMode.Email: return "email";
case TextBoxMode.Month: return "month";
case TextBoxMode.Number: return "number";
case TextBoxMode.Range: return "range";
case TextBoxMode.Search: return "search";
case TextBoxMode.Phone: return "tel";
case TextBoxMode.Time: return "time";
case TextBoxMode.Url: return "url";
case TextBoxMode.Week: return "week";
case TextBoxMode.MultiLine:
// falling through on purpose
default:
// the default case could only happen if
// - someone forces an out-of-range value as a TextBoxMode and passes it in
// - a new TextBoxMode value gets added, in which case it should be handled as an explicit case above
throw new InvalidOperationException();
}
}
internal static string GetVCardAttributeValue(AutoCompleteType type) {
switch (type) {
case AutoCompleteType.None:
case AutoCompleteType.Disabled:
case AutoCompleteType.Enabled:
// should not happen
throw new InvalidOperationException();
case AutoCompleteType.Search:
return "search";
case AutoCompleteType.HomeCountryRegion:
return "HomeCountry";
case AutoCompleteType.BusinessCountryRegion:
return "BusinessCountry";
default:
string result = Enum.Format(typeof(AutoCompleteType), type, "G");
// Business and Home properties need to be prefixed with "."
if (result.StartsWith("Business", StringComparison.Ordinal)) {
result = result.Insert(8, ".");
}
else if (result.StartsWith("Home", StringComparison.Ordinal)) {
result = result.Insert(4, ".");
}
return "vCard." + result;
}
}
/// <internalonly/>
protected internal override void OnPreRender(EventArgs e) {
base.OnPreRender(e);
Page page = Page;
if ((page != null) && IsEnabled) {
if (SaveTextViewState == false) {
// Store a client-side array of enabled control, so we can re-enable them on
// postback (in case they are disabled client-side)
// Postback is needed when view state for the Text property is disabled
page.RegisterEnabledControl(this);
}
if (AutoPostBack) {
page.RegisterWebFormsScript();
page.RegisterPostBackScript();
page.RegisterFocusScript();
}
}
}
/// <internalonly/>
/// <devdoc>
/// <para>Loads the posted text box content if it is different
/// from the last posting.</para>
/// </devdoc>
bool IPostBackDataHandler.LoadPostData(string postDataKey, NameValueCollection postCollection) {
return LoadPostData(postDataKey, postCollection);
}
/// <internalonly/>
/// <devdoc>
/// <para>Loads the posted text box content if it is different
/// from the last posting.</para>
/// </devdoc>
protected virtual bool LoadPostData(string postDataKey, NameValueCollection postCollection) {
ValidateEvent(postDataKey);
string current = Text;
string postData = postCollection[postDataKey];
// VSWhidbey 442850: Everett had current.Equals(postData), and it is
// equivalent to the option StringComparison.Ordinal in Whidbey
if (!ReadOnly && !current.Equals(postData, StringComparison.Ordinal)) {
Text = postData;
return true;
}
return false;
}
/// <devdoc>
/// <para> Raises the <see langword='TextChanged'/> event.</para>
/// </devdoc>
protected virtual void OnTextChanged(EventArgs e) {
EventHandler onChangeHandler = (EventHandler)Events[EventTextChanged];
if (onChangeHandler != null) onChangeHandler(this,e);
}
/// <internalonly/>
/// <devdoc>
/// <para>Invokes the <see cref='System.Web.UI.WebControls.TextBox.OnTextChanged'/> method
/// whenever posted data for the text box has changed.</para>
/// </devdoc>
void IPostBackDataHandler.RaisePostDataChangedEvent() {
RaisePostDataChangedEvent();
}
/// <internalonly/>
/// <devdoc>
/// <para>Invokes the <see cref='System.Web.UI.WebControls.TextBox.OnTextChanged'/> method
/// whenever posted data for the text box has changed.</para>
/// </devdoc>
protected virtual void RaisePostDataChangedEvent() {
if (AutoPostBack && !Page.IsPostBackEventControlRegistered) {
// VSWhidbey 204824
Page.AutoPostBackControl = this;
if (CausesValidation) {
Page.Validate(ValidationGroup);
}
}
OnTextChanged(EventArgs.Empty);
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected internal override void Render(HtmlTextWriter writer) {
RenderBeginTag(writer);
//Dev10 Bug 483896: Original TextBox rendering in MultiLine mode suffers from the
//problem of losing the first newline. We fixed this bug by always rendering a newline
//before rendering the value of the Text property.
if (TextMode == TextBoxMode.MultiLine) {
//Dev11 Bug 437709 fix: We do not want to encode the extra new line that we are
//rendering. However we are doing this only for 4.5 or later frameworks for back-compat.
if (RenderingCompatibility >= VersionUtil.Framework45) {
writer.Write(System.Environment.NewLine);
HttpUtility.HtmlEncode(Text, writer);
}
else {
HttpUtility.HtmlEncode(System.Environment.NewLine + Text, writer);
}
}
RenderEndTag(writer);
}
protected override object SaveViewState() {
if (SaveTextViewState == false) {
ViewState.SetItemDirty("Text", false);
}
return base.SaveViewState();
}
}
}