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
1007 lines
34 KiB
C#
1007 lines
34 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HtmlSelect.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.HtmlControls {
|
|
using System.Runtime.Serialization.Formatters;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Data;
|
|
using System.Web;
|
|
using System.Web.Util;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
using System.Globalization;
|
|
using Debug=System.Web.Util.Debug;
|
|
using System.Security.Permissions;
|
|
|
|
public class HtmlSelectBuilder : ControlBuilder {
|
|
|
|
|
|
public override Type GetChildControlType(string tagName, IDictionary attribs) {
|
|
if (StringUtil.EqualsIgnoreCase(tagName, "option"))
|
|
return typeof(ListItem);
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
public override bool AllowWhitespaceLiterals() {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// The <see langword='HtmlSelect'/>
|
|
/// class defines the methods, properties, and events for the
|
|
/// HtmlSelect control. This class allows programmatic access to the HTML
|
|
/// <select> element on the server.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultEvent("ServerChange"),
|
|
ValidationProperty("Value"),
|
|
ControlBuilderAttribute(typeof(HtmlSelectBuilder)),
|
|
SupportsEventValidation,
|
|
]
|
|
public class HtmlSelect : HtmlContainerControl, IPostBackDataHandler, IParserAccessor {
|
|
|
|
private static readonly object EventServerChange = new object();
|
|
|
|
internal const string DataBoundViewStateKey = "_!DataBound";
|
|
|
|
private object dataSource;
|
|
private ListItemCollection items;
|
|
private int cachedSelectedIndex;
|
|
|
|
private bool _requiresDataBinding;
|
|
private bool _inited;
|
|
private bool _throwOnDataPropertyChange;
|
|
|
|
private DataSourceView _currentView;
|
|
private bool _currentViewIsFromDataSourceID;
|
|
private bool _currentViewValid;
|
|
private bool _pagePreLoadFired;
|
|
|
|
/*
|
|
* Creates an intrinsic Html SELECT control.
|
|
*/
|
|
|
|
public HtmlSelect() : base("select") {
|
|
cachedSelectedIndex = -1;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.HtmlSelect_DataMember)
|
|
]
|
|
public virtual string DataMember {
|
|
get {
|
|
object o = ViewState["DataMember"];
|
|
if (o != null)
|
|
return (string)o;
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
Attributes["DataMember"] = MapStringAttributeToString(value);
|
|
OnDataPropertyChanged();
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the data source to databind the list values
|
|
/// in the <see langword='HtmlSelect'/> control against. This provides data to
|
|
/// populate the select list with items.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
DefaultValue(null),
|
|
WebSysDescription(SR.BaseDataBoundControl_DataSource),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public virtual object DataSource {
|
|
get {
|
|
return dataSource;
|
|
}
|
|
set {
|
|
if ((value == null) || (value is IListSource) || (value is IEnumerable)) {
|
|
dataSource = value;
|
|
OnDataPropertyChanged();
|
|
}
|
|
else {
|
|
throw new ArgumentException(SR.GetString(SR.Invalid_DataSource_Type, ID));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// The ID of the DataControl that this control should use to retrieve
|
|
/// its data source. When the control is bound to a DataControl, it
|
|
/// can retrieve a data source instance on-demand, and thereby attempt
|
|
/// to work in auto-DataBind mode.
|
|
/// </summary>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.BaseDataBoundControl_DataSourceID),
|
|
]
|
|
public virtual string DataSourceID {
|
|
get {
|
|
object o = ViewState["DataSourceID"];
|
|
if (o != null) {
|
|
return (string)o;
|
|
}
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
ViewState["DataSourceID"] = value;
|
|
OnDataPropertyChanged();
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets the field in the data source that provides
|
|
/// the text for an option entry in the HtmlSelect control.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.HtmlSelect_DataTextField)
|
|
]
|
|
public virtual string DataTextField {
|
|
get {
|
|
string s = Attributes["DataTextField"];
|
|
return((s == null) ? String.Empty : s);
|
|
}
|
|
set {
|
|
Attributes["DataTextField"] = MapStringAttributeToString(value);
|
|
if (_inited) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets the field in the data source that provides
|
|
/// the option item value for the <see langword='HtmlSelect'/>
|
|
/// control.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.HtmlSelect_DataValueField)
|
|
]
|
|
public virtual string DataValueField {
|
|
get {
|
|
string s = Attributes["DataValueField"];
|
|
return((s == null) ? String.Empty : s);
|
|
}
|
|
set {
|
|
Attributes["DataValueField"] = MapStringAttributeToString(value);
|
|
if (_inited) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public override string InnerHtml {
|
|
get {
|
|
throw new NotSupportedException(SR.GetString(SR.InnerHtml_not_supported, this.GetType().Name));
|
|
}
|
|
set {
|
|
throw new NotSupportedException(SR.GetString(SR.InnerHtml_not_supported, this.GetType().Name));
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public override string InnerText {
|
|
get {
|
|
throw new NotSupportedException(SR.GetString(SR.InnerText_not_supported, this.GetType().Name));
|
|
}
|
|
set {
|
|
throw new NotSupportedException(SR.GetString(SR.InnerText_not_supported, this.GetType().Name));
|
|
}
|
|
}
|
|
|
|
|
|
protected bool IsBoundUsingDataSourceID {
|
|
get {
|
|
return (DataSourceID.Length > 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* A collection containing the list of items.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets the list of option items in an <see langword='HtmlSelect'/> control.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
public ListItemCollection Items {
|
|
get {
|
|
if (items == null) {
|
|
items = new ListItemCollection();
|
|
if (IsTrackingViewState)
|
|
((IStateManager)items).TrackViewState();
|
|
}
|
|
return items;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Multi-select property.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets a value indicating whether multiple option items can be selected
|
|
/// from the list.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(""),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool Multiple {
|
|
get {
|
|
string s = Attributes["multiple"];
|
|
return((s != null) ? (s.Equals("multiple")) : false);
|
|
}
|
|
|
|
set {
|
|
if (value)
|
|
Attributes["multiple"] = "multiple";
|
|
else
|
|
Attributes["multiple"] = null;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Name property.
|
|
*/
|
|
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(""),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public string Name {
|
|
get {
|
|
return UniqueID;
|
|
//string s = Attributes["name"];
|
|
//return ((s != null) ? s : "");
|
|
}
|
|
set {
|
|
//Attributes["name"] = MapStringAttributeToString(value);
|
|
}
|
|
}
|
|
|
|
// Value that gets rendered for the Name attribute
|
|
internal string RenderedNameAttribute {
|
|
get {
|
|
return Name;
|
|
//string name = Name;
|
|
//if (name.Length == 0)
|
|
// return UniqueID;
|
|
|
|
//return name;
|
|
}
|
|
}
|
|
|
|
|
|
protected bool RequiresDataBinding {
|
|
get {
|
|
return _requiresDataBinding;
|
|
}
|
|
set {
|
|
_requiresDataBinding = value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The index of the selected item.
|
|
* Returns the first selected item if list is multi-select.
|
|
* Returns -1 if there is no selected item.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets the ordinal index of the selected option item in an
|
|
/// <see langword='HtmlSelect'/> control. If multiple items are selected, this
|
|
/// property holds the index of the first item selected in the list.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
HtmlControlPersistable(false),
|
|
]
|
|
public virtual int SelectedIndex {
|
|
get {
|
|
for (int i=0; i < Items.Count; i++) {
|
|
if (Items[i].Selected)
|
|
return i;
|
|
}
|
|
if (Size <= 1 && !Multiple) {
|
|
// SELECT as a dropdown must have a selection
|
|
if (Items.Count > 0)
|
|
Items[0].Selected = true;
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
set {
|
|
// if we have no items, save the selectedindex
|
|
// for later databinding
|
|
if (Items.Count == 0) {
|
|
cachedSelectedIndex = value;
|
|
}
|
|
else {
|
|
if (value < -1 || value >= Items.Count) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
ClearSelection();
|
|
if (value >= 0)
|
|
Items[value].Selected = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* SelectedIndices property.
|
|
* Protected property for getting array of selected indices.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected virtual int[] SelectedIndices {
|
|
get {
|
|
int n = 0;
|
|
int[] temp = new int[3];
|
|
for (int i=0; i < Items.Count; i++) {
|
|
if (Items[i].Selected == true) {
|
|
if (n == temp.Length) {
|
|
int[] t = new int[n+n];
|
|
temp.CopyTo(t,0);
|
|
temp = t;
|
|
}
|
|
temp[n++] = i;
|
|
}
|
|
}
|
|
int[] selectedIndices = new int[n];
|
|
Array.Copy(temp,0,selectedIndices,0,n);
|
|
return selectedIndices;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The size of the list.
|
|
* A size of 1 displays a dropdown list.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets the number of option items visible in the browser at a time. A
|
|
/// value greater that one will typically cause browsers to display a scrolling
|
|
/// list.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public int Size {
|
|
get {
|
|
string s = Attributes["size"];
|
|
return((s != null) ? Int32.Parse(s, CultureInfo.InvariantCulture) : -1);
|
|
}
|
|
|
|
set {
|
|
Attributes["size"] = MapIntegerAttributeToString(value);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Value property.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets the current item selected in the <see langword='HtmlSelect'/>
|
|
/// control.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public string Value {
|
|
get {
|
|
int i = SelectedIndex;
|
|
return(i < 0 || i >= Items.Count) ? String.Empty : Items[i].Value;
|
|
}
|
|
|
|
set {
|
|
int i = Items.FindByValueInternal(value, true);
|
|
if (i >= 0)
|
|
SelectedIndex = i;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Occurs when an <see langword='HtmlSelect'/> control is changed on the
|
|
/// server.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.HtmlSelect_OnServerChange)
|
|
]
|
|
public event EventHandler ServerChange {
|
|
add {
|
|
Events.AddHandler(EventServerChange, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventServerChange, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
protected override void AddParsedSubObject(object obj) {
|
|
if (obj is ListItem)
|
|
Items.Add((ListItem)obj);
|
|
else
|
|
throw new HttpException(SR.GetString(SR.Cannot_Have_Children_Of_Type, "HtmlSelect", obj.GetType().Name));
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected virtual void ClearSelection() {
|
|
for (int i=0; i < Items.Count; i++)
|
|
Items[i].Selected = false;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Connects this data bound control to the appropriate DataSourceView
|
|
/// and hooks up the appropriate event listener for the
|
|
/// DataSourceViewChanged event. The return value is the new view (if
|
|
/// any) that was connected to. An exception is thrown if there is
|
|
/// a problem finding the requested view or data source.
|
|
/// </devdoc>
|
|
private DataSourceView ConnectToDataSourceView() {
|
|
if (_currentViewValid && !DesignMode) {
|
|
// If the current view is correct, there is no need to reconnect
|
|
return _currentView;
|
|
}
|
|
|
|
// Disconnect from old view, if necessary
|
|
if ((_currentView != null) && (_currentViewIsFromDataSourceID)) {
|
|
// We only care about this event if we are bound through the DataSourceID property
|
|
_currentView.DataSourceViewChanged -= new EventHandler(OnDataSourceViewChanged);
|
|
}
|
|
|
|
// Connect to new view
|
|
IDataSource ds = null;
|
|
string dataSourceID = DataSourceID;
|
|
|
|
if (dataSourceID.Length != 0) {
|
|
// Try to find a DataSource control with the ID specified in DataSourceID
|
|
Control control = DataBoundControlHelper.FindControl(this, dataSourceID);
|
|
if (control == null) {
|
|
throw new HttpException(SR.GetString(SR.DataControl_DataSourceDoesntExist, ID, dataSourceID));
|
|
}
|
|
ds = control as IDataSource;
|
|
if (ds == null) {
|
|
throw new HttpException(SR.GetString(SR.DataControl_DataSourceIDMustBeDataControl, ID, dataSourceID));
|
|
}
|
|
}
|
|
|
|
if (ds == null) {
|
|
// DataSource control was not found, construct a temporary data source to wrap the data
|
|
ds = new ReadOnlyDataSource(DataSource, DataMember);
|
|
}
|
|
else {
|
|
// Ensure that both DataSourceID as well as DataSource are not set at the same time
|
|
if (DataSource != null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.DataControl_MultipleDataSources, ID));
|
|
}
|
|
}
|
|
|
|
// IDataSource was found, extract the appropriate view and return it
|
|
DataSourceView newView = ds.GetView(DataMember);
|
|
if (newView == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.DataControl_ViewNotFound, ID));
|
|
}
|
|
|
|
_currentViewIsFromDataSourceID = IsBoundUsingDataSourceID;
|
|
_currentView = newView;
|
|
if ((_currentView != null) && (_currentViewIsFromDataSourceID)) {
|
|
// We only care about this event if we are bound through the DataSourceID property
|
|
_currentView.DataSourceViewChanged += new EventHandler(OnDataSourceViewChanged);
|
|
}
|
|
_currentViewValid = true;
|
|
|
|
return _currentView;
|
|
}
|
|
|
|
|
|
protected override ControlCollection CreateControlCollection() {
|
|
return new EmptyControlCollection(this);
|
|
}
|
|
|
|
|
|
protected void EnsureDataBound() {
|
|
try {
|
|
_throwOnDataPropertyChange = true;
|
|
if (RequiresDataBinding && DataSourceID.Length > 0) {
|
|
DataBind();
|
|
}
|
|
}
|
|
finally{
|
|
_throwOnDataPropertyChange = false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Returns an IEnumerable that is the DataSource, which either came
|
|
/// from the DataSource property or from the control bound via the
|
|
/// DataSourceID property.
|
|
/// </devdoc>
|
|
protected virtual IEnumerable GetData() {
|
|
DataSourceView view = ConnectToDataSourceView();
|
|
|
|
Debug.Assert(_currentViewValid);
|
|
|
|
if (view != null) {
|
|
return view.ExecuteSelect(DataSourceSelectArguments.Empty);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Override to load items and selected indices.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected override void LoadViewState(object savedState) {
|
|
if (savedState != null) {
|
|
Triplet statetriplet = (Triplet)savedState;
|
|
base.LoadViewState(statetriplet.First);
|
|
|
|
// restore state of items
|
|
((IStateManager)Items).LoadViewState(statetriplet.Second);
|
|
|
|
// restore selected indices
|
|
object selectedIndices = statetriplet.Third;
|
|
if (selectedIndices != null)
|
|
Select((int[])selectedIndices);
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected override void OnDataBinding(EventArgs e) {
|
|
base.OnDataBinding(e);
|
|
|
|
// create items using the datasource
|
|
IEnumerable dataSource = GetData();
|
|
|
|
// create items using the datasource
|
|
if (dataSource != null) {
|
|
bool fieldsSpecified = false;
|
|
string textField = DataTextField;
|
|
string valueField = DataValueField;
|
|
|
|
Items.Clear();
|
|
ICollection collection = dataSource as ICollection;
|
|
if (collection != null) {
|
|
Items.Capacity = collection.Count;
|
|
}
|
|
|
|
if ((textField.Length != 0) || (valueField.Length != 0))
|
|
fieldsSpecified = true;
|
|
|
|
foreach (object dataItem in dataSource) {
|
|
ListItem item = new ListItem();
|
|
|
|
if (fieldsSpecified) {
|
|
if (textField.Length > 0) {
|
|
item.Text = DataBinder.GetPropertyValue(dataItem,textField,null);
|
|
}
|
|
if (valueField.Length > 0) {
|
|
item.Value = DataBinder.GetPropertyValue(dataItem,valueField,null);
|
|
}
|
|
}
|
|
else {
|
|
item.Text = item.Value = dataItem.ToString();
|
|
}
|
|
|
|
Items.Add(item);
|
|
}
|
|
}
|
|
// try to apply the cached SelectedIndex now
|
|
if (cachedSelectedIndex != -1) {
|
|
SelectedIndex = cachedSelectedIndex;
|
|
cachedSelectedIndex = -1;
|
|
}
|
|
ViewState[DataBoundViewStateKey] = true;
|
|
RequiresDataBinding = false;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This method is called when DataMember, DataSource, or DataSourceID is changed.
|
|
/// </devdoc>
|
|
protected virtual void OnDataPropertyChanged() {
|
|
if (_throwOnDataPropertyChange) {
|
|
throw new HttpException(SR.GetString(SR.DataBoundControl_InvalidDataPropertyChange, ID));
|
|
}
|
|
|
|
if (_inited) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
_currentViewValid = false;
|
|
}
|
|
|
|
|
|
protected virtual void OnDataSourceViewChanged(object sender, EventArgs e) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
|
|
|
|
protected internal override void OnInit(EventArgs e) {
|
|
base.OnInit(e);
|
|
|
|
if (Page != null) {
|
|
Page.PreLoad += new EventHandler(this.OnPagePreLoad);
|
|
if (!IsViewStateEnabled && Page.IsPostBack) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
protected internal override void OnLoad(EventArgs e) {
|
|
_inited = true; // just in case we were added to the page after PreLoad
|
|
ConnectToDataSourceView();
|
|
if (Page != null && !_pagePreLoadFired && ViewState[DataBoundViewStateKey] == null) {
|
|
// If the control was added after PagePreLoad, we still need to databind it because it missed its
|
|
// first change in PagePreLoad. If this control was created by a call to a parent control's DataBind
|
|
// in Page_Load (with is relatively common), this control will already have been databound even
|
|
// though pagePreLoad never fired and the page isn't a postback.
|
|
if (!Page.IsPostBack) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
|
|
// If the control was added to the page after page.PreLoad, we'll never get the event and we'll
|
|
// never databind the control. So if we're catching up and Load happens but PreLoad never happened,
|
|
// call DataBind. This may make the control get databound twice if the user called DataBind on the control
|
|
// directly in Page.OnLoad, but better to bind twice than never to bind at all.
|
|
else if (IsViewStateEnabled) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
}
|
|
|
|
base.OnLoad(e);
|
|
}
|
|
|
|
private void OnPagePreLoad(object sender, EventArgs e) {
|
|
_inited = true;
|
|
|
|
if (Page != null) {
|
|
Page.PreLoad -= new EventHandler(this.OnPagePreLoad);
|
|
|
|
// Setting RequiresDataBinding to true in OnLoad is too late because the OnLoad page event
|
|
// happens before the control.OnLoad method gets called. So a page_load handler on the page
|
|
// that calls DataBind won't prevent DataBind from getting called again in PreRender.
|
|
if (!Page.IsPostBack) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
// If this is a postback and viewstate is enabled, but we have never bound the control
|
|
// before, it is probably because its visibility was changed in the postback. In this
|
|
// case, we need to bind the control or it will never appear. This is a common scenario
|
|
// for Wizard and MultiView.
|
|
if (Page.IsPostBack && IsViewStateEnabled && ViewState[DataBoundViewStateKey] == null) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
}
|
|
_pagePreLoadFired = true;
|
|
}
|
|
|
|
/*
|
|
* This method is invoked just prior to rendering.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected internal override void OnPreRender(EventArgs e) {
|
|
base.OnPreRender(e);
|
|
|
|
// An Html SELECT does not post when nothing is selected.
|
|
if (Page != null && !Disabled) {
|
|
if (Size > 1) {
|
|
Page.RegisterRequiresPostBack(this);
|
|
}
|
|
|
|
Page.RegisterEnabledControl(this);
|
|
}
|
|
|
|
EnsureDataBound();
|
|
}
|
|
|
|
/*
|
|
* Method used to raise the OnServerChange event.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Raised
|
|
/// on the server when the <see langword='HtmlSelect'/> control list values
|
|
/// change between postback requests.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected virtual void OnServerChange(EventArgs e) {
|
|
EventHandler handler = (EventHandler)Events[EventServerChange];
|
|
if (handler != null) handler(this, e);
|
|
}
|
|
|
|
/*
|
|
* Override to prevent SelectedIndex from being rendered as an attribute.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected override void RenderAttributes(HtmlTextWriter writer) {
|
|
if (Page != null) {
|
|
Page.ClientScript.RegisterForEventValidation(RenderedNameAttribute);
|
|
}
|
|
|
|
writer.WriteAttribute("name", RenderedNameAttribute);
|
|
Attributes.Remove("name");
|
|
|
|
Attributes.Remove("DataValueField");
|
|
Attributes.Remove("DataTextField");
|
|
Attributes.Remove("DataMember");
|
|
Attributes.Remove("DataSourceID");
|
|
base.RenderAttributes(writer);
|
|
}
|
|
|
|
/*
|
|
* Render the Items in the list.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected internal override void RenderChildren(HtmlTextWriter writer) {
|
|
bool selected = false;
|
|
bool isSingle = !Multiple;
|
|
|
|
writer.WriteLine();
|
|
writer.Indent++;
|
|
ListItemCollection liCollection = Items;
|
|
int n = liCollection.Count;
|
|
if (n > 0) {
|
|
for (int i=0; i < n; i++) {
|
|
ListItem li = liCollection[i];
|
|
writer.WriteBeginTag("option");
|
|
if (li.Selected) {
|
|
if (isSingle)
|
|
{
|
|
if (selected)
|
|
throw new HttpException(SR.GetString(SR.HtmlSelect_Cant_Multiselect_In_Single_Mode));
|
|
selected=true;
|
|
}
|
|
writer.WriteAttribute("selected", "selected");
|
|
}
|
|
|
|
writer.WriteAttribute("value", li.Value, true /*fEncode*/);
|
|
|
|
// This is to fix the case where the user puts one of these
|
|
// three values in the AttributeCollection. Removing them
|
|
// at least is better than rendering them twice.
|
|
li.Attributes.Remove("text");
|
|
li.Attributes.Remove("value");
|
|
li.Attributes.Remove("selected");
|
|
|
|
li.Attributes.Render(writer);
|
|
writer.Write(HtmlTextWriter.TagRightChar);
|
|
HttpUtility.HtmlEncode(li.Text, writer);
|
|
writer.WriteEndTag("option");
|
|
writer.WriteLine();
|
|
}
|
|
}
|
|
writer.Indent--;
|
|
}
|
|
|
|
/*
|
|
* Save selected indices and modified Items.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected override object SaveViewState() {
|
|
|
|
object baseState = base.SaveViewState();
|
|
object items = ((IStateManager)Items).SaveViewState();
|
|
object selectedindices = null;
|
|
|
|
// only save selection if handler is registered,
|
|
// we are disabled, or we are not visible
|
|
// since selection is always posted back otherwise
|
|
if (Events[EventServerChange] != null || Disabled || !Visible)
|
|
selectedindices = SelectedIndices;
|
|
|
|
if (selectedindices != null || items != null || baseState != null)
|
|
return new Triplet(baseState, items, selectedindices);
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected virtual void Select(int[] selectedIndices) {
|
|
ClearSelection();
|
|
for (int i=0; i < selectedIndices.Length; i++) {
|
|
int n = selectedIndices[i];
|
|
if (n >= 0 && n < Items.Count)
|
|
Items[n].Selected = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* TrackState
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected override void TrackViewState() {
|
|
base.TrackViewState();
|
|
((IStateManager)Items).TrackViewState();
|
|
}
|
|
|
|
|
|
/*
|
|
* Method of IPostBackDataHandler interface to process posted data.
|
|
* SelectList processes a newly posted value.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
bool IPostBackDataHandler.LoadPostData(string postDataKey, NameValueCollection postCollection) {
|
|
return LoadPostData(postDataKey, postCollection);
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected virtual bool LoadPostData(string postDataKey, NameValueCollection postCollection) {
|
|
string[] selectedItems = postCollection.GetValues(postDataKey);
|
|
bool selectionChanged = false;
|
|
|
|
if (selectedItems != null) {
|
|
if (!Multiple) {
|
|
int n = Items.FindByValueInternal(selectedItems[0], false);
|
|
if (SelectedIndex != n) {
|
|
SelectedIndex = n;
|
|
selectionChanged = true;
|
|
}
|
|
}
|
|
else { // multiple selection
|
|
int count = selectedItems.Length;
|
|
int[] oldSelectedIndices = SelectedIndices;
|
|
int[] newSelectedIndices = new int[count];
|
|
for (int i=0; i < count; i++) {
|
|
// create array of new indices from posted values
|
|
newSelectedIndices[i] = Items.FindByValueInternal(selectedItems[i], false);
|
|
}
|
|
|
|
if (oldSelectedIndices.Length == count) {
|
|
// check new indices against old indices
|
|
// assumes selected values are posted in order
|
|
for (int i=0; i < count; i++) {
|
|
if (newSelectedIndices[i] != oldSelectedIndices[i]) {
|
|
selectionChanged = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// indices must have changed if count is different
|
|
selectionChanged = true;
|
|
}
|
|
|
|
if (selectionChanged) {
|
|
// select new indices
|
|
Select(newSelectedIndices);
|
|
}
|
|
}
|
|
}
|
|
else { // no items selected
|
|
if (SelectedIndex != -1) {
|
|
SelectedIndex = -1;
|
|
selectionChanged = true;
|
|
}
|
|
}
|
|
|
|
if (selectionChanged) {
|
|
ValidateEvent(postDataKey);
|
|
}
|
|
|
|
return selectionChanged;
|
|
}
|
|
|
|
/*
|
|
* Method of IPostBackDataHandler interface which is invoked whenever posted data
|
|
* for a control has changed. SelectList fires an OnServerChange event.
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
void IPostBackDataHandler.RaisePostDataChangedEvent() {
|
|
RaisePostDataChangedEvent();
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected virtual void RaisePostDataChangedEvent() {
|
|
OnServerChange(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|