344 lines
12 KiB
C#
344 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="CheckBoxField.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
|
|
/// <devdoc>
|
|
/// <para>Creates a field bounded to a data field in a <see cref='System.Web.UI.WebControls.DataBoundControl'/>.</para>
|
|
/// </devdoc>
|
|
public class CheckBoxField : BoundField {
|
|
|
|
private bool _suppressPropertyThrows = false;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of a <see cref='System.Web.UI.WebControls.CheckBoxField'/> class.</para>
|
|
/// </devdoc>
|
|
public CheckBoxField() {
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para> Indicates whether to apply the DataFormatString in edit mode</para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never)
|
|
]
|
|
public override bool ApplyFormatInEditMode {
|
|
get {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "ApplyFormatInEditMode"));
|
|
}
|
|
return false;
|
|
}
|
|
set {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "ApplyFormatInEditMode"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Gets or sets the field name from the data model bound to this field.
|
|
/// Overridden to change the type converter attribute.</para>
|
|
/// </devdoc>
|
|
[
|
|
TypeConverter("System.Web.UI.Design.DataSourceBooleanViewSchemaConverter, " + AssemblyRef.SystemDesign),
|
|
]
|
|
public override string DataField {
|
|
get {
|
|
return base.DataField;
|
|
}
|
|
set {
|
|
base.DataField = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or sets the display format of data in this
|
|
/// field.</para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never)
|
|
]
|
|
public override string DataFormatString {
|
|
get {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "DataFormatString"));
|
|
}
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "DataFormatString"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or sets a property indicating whether data should be HtmlEncoded when it is displayed to the user.</para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never)
|
|
]
|
|
public override bool HtmlEncode {
|
|
get {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "HtmlEncode"));
|
|
}
|
|
return false;
|
|
}
|
|
set {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "HtmlEncode"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never)
|
|
]
|
|
public override bool HtmlEncodeFormatString {
|
|
get {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "HtmlEncodeFormatString"));
|
|
}
|
|
return false;
|
|
}
|
|
set {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "HtmlEncodeFormatString"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or sets the property that determines what text is displayed if the value
|
|
/// of the field is null.</para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never)
|
|
]
|
|
public override string NullDisplayText {
|
|
get {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "NullDisplayText"));
|
|
}
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "NullDisplayText"));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override bool SupportsHtmlEncode {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or sets the CheckBox's Text property in this
|
|
/// field.</para>
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.CheckBoxField_Text)
|
|
]
|
|
public virtual string Text {
|
|
get {
|
|
object o = ViewState["Text"];
|
|
if (o != null)
|
|
return (string)o;
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
if (!String.Equals(value, ViewState["Text"])) {
|
|
ViewState["Text"] = value;
|
|
OnFieldChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or sets the property that determines whether the BoundField treats empty string as
|
|
/// null when the field values are extracted.</para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
EditorBrowsable(EditorBrowsableState.Never)
|
|
]
|
|
public override bool ConvertEmptyStringToNull {
|
|
get {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "ConvertEmptyStringToNull"));
|
|
}
|
|
return false;
|
|
}
|
|
set {
|
|
if (!_suppressPropertyThrows) {
|
|
throw new NotSupportedException(SR.GetString(SR.CheckBoxField_NotSupported, "ConvertEmptyStringToNull"));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void CopyProperties(DataControlField newField) {
|
|
((CheckBoxField)newField).Text = Text;
|
|
_suppressPropertyThrows = true;
|
|
((CheckBoxField)newField)._suppressPropertyThrows = true;
|
|
base.CopyProperties(newField);
|
|
_suppressPropertyThrows = false;
|
|
((CheckBoxField)newField)._suppressPropertyThrows = false;
|
|
}
|
|
|
|
protected override DataControlField CreateField() {
|
|
return new CheckBoxField();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Extracts the value(s) from the given cell and puts the value(s) into a dictionary. Indicate includeReadOnly
|
|
/// to have readonly fields' values inserted into the dictionary.
|
|
/// </devdoc>
|
|
public override void ExtractValuesFromCell(IOrderedDictionary dictionary, DataControlFieldCell cell, DataControlRowState rowState, bool includeReadOnly) {
|
|
Control childControl = null;
|
|
string dataField = DataField;
|
|
object value = null;
|
|
|
|
if (cell.Controls.Count > 0) {
|
|
childControl = cell.Controls[0];
|
|
|
|
CheckBox checkBox = childControl as CheckBox;
|
|
if (checkBox != null) {
|
|
if (includeReadOnly || checkBox.Enabled) {
|
|
value = checkBox.Checked;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (value != null) {
|
|
if (dictionary.Contains(dataField)) {
|
|
dictionary[dataField] = value;
|
|
}
|
|
else {
|
|
dictionary.Add(dataField, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Returns a value to be used for design-time rendering
|
|
/// </devdoc>
|
|
protected override object GetDesignTimeValue() {
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Initializes a cell in the DataControlField.</para>
|
|
/// </devdoc>
|
|
protected override void InitializeDataCell(DataControlFieldCell cell, DataControlRowState rowState) {
|
|
CheckBox childControl = null;
|
|
CheckBox boundControl = null;
|
|
|
|
if (((rowState & DataControlRowState.Edit) != 0 && ReadOnly == false) || (rowState & DataControlRowState.Insert) != 0) {
|
|
//
|
|
CheckBox editor = new CheckBox();
|
|
editor.ToolTip = HeaderText;
|
|
childControl = editor;
|
|
|
|
if (DataField.Length != 0 && (rowState & DataControlRowState.Edit) != 0) {
|
|
boundControl = editor;
|
|
}
|
|
}
|
|
else if (DataField.Length != 0) {
|
|
CheckBox editor = new CheckBox();
|
|
editor.Text = Text;
|
|
editor.Enabled = false;
|
|
childControl = editor;
|
|
boundControl = editor;
|
|
}
|
|
|
|
if (childControl != null) {
|
|
cell.Controls.Add(childControl);
|
|
}
|
|
|
|
if (boundControl != null && Visible) {
|
|
boundControl.DataBinding += new EventHandler(this.OnDataBindField);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Performs databinding the given field with data from the data source.
|
|
/// </devdoc>
|
|
protected override void OnDataBindField(object sender, EventArgs e) {
|
|
Control boundControl = (Control)sender;
|
|
Control controlContainer = boundControl.NamingContainer;
|
|
|
|
|
|
object data = GetValue(controlContainer);
|
|
|
|
if (!(boundControl is CheckBox)) {
|
|
throw new HttpException(SR.GetString(SR.CheckBoxField_WrongControlType, DataField));
|
|
}
|
|
if (DataBinder.IsNull(data)) {
|
|
((CheckBox)boundControl).Checked = false;
|
|
}
|
|
else {
|
|
if (data is Boolean) {
|
|
((CheckBox)boundControl).Checked = (Boolean)data;
|
|
}
|
|
else {
|
|
try {
|
|
((CheckBox)boundControl).Checked = Boolean.Parse(data.ToString());
|
|
}
|
|
catch (FormatException fe) {
|
|
throw new HttpException(SR.GetString(SR.CheckBoxField_CouldntParseAsBoolean, DataField), fe);
|
|
}
|
|
}
|
|
}
|
|
((CheckBox)boundControl).Text = Text;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Override with an empty body if the field's controls all support callback.
|
|
/// Otherwise, override and throw a useful error message about why the field can't support callbacks.</para>
|
|
/// </devdoc>
|
|
public override void ValidateSupportsCallback() {
|
|
}
|
|
}
|
|
}
|
|
|