Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Extensions / UI / WebControls / ListView.cs / 1407647 / ListView.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Web;
using System.Web.Resources;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
namespace System.Web.UI.WebControls {
[DefaultProperty("SelectedValue")]
[Designer("System.Web.UI.Design.WebControls.ListViewDesigner, " + AssemblyRef.SystemWebExtensionsDesign)]
[ControlValueProperty("SelectedValue")]
[DefaultEvent("SelectedIndexChanged")]
[SupportsEventValidation]
[ToolboxBitmap(typeof(ListView), "ListView.bmp")]
[DataKeyProperty("SelectedPersistedDataKey")]
public class ListView : DataBoundControl, INamingContainer, IPageableItemContainer, IPersistedSelector, IDataKeysControl, IDataBoundListControl, IWizardSideBarListControl {
internal const string ItemCountViewStateKey = "_!ItemCount";
private ITemplate _itemTemplate;
private ITemplate _editItemTemplate;
private ITemplate _insertItemTemplate;
private ITemplate _layoutTemplate;
private ITemplate _selectedItemTemplate;
private ITemplate _groupTemplate;
private ITemplate _itemSeparatorTemplate;
private ITemplate _groupSeparatorTemplate;
private ITemplate _emptyItemTemplate;
private ITemplate _emptyDataTemplate;
private ITemplate _alternatingItemTemplate;
private static readonly object EventTotalRowCountAvailable = new object();
private static readonly object EventPagePropertiesChanged = new object();
private static readonly object EventPagePropertiesChanging = new object();
private static readonly object EventItemCanceling = new object();
private static readonly object EventItemCommand = new object();
private static readonly object EventItemCreated = new object();
private static readonly object EventItemDataBound = new object();
private static readonly object EventItemDeleted = new object();
private static readonly object EventItemDeleting = new object();
private static readonly object EventItemEditing = new object();
private static readonly object EventItemInserted = new object();
private static readonly object EventItemInserting = new object();
private static readonly object EventItemUpdated = new object();
private static readonly object EventItemUpdating = new object();
private static readonly object EventLayoutCreated = new object();
private static readonly object EventSelectedIndexChanging = new object();
private static readonly object EventSelectedIndexChanged = new object();
private static readonly object EventSorted = new object();
private static readonly object EventSorting = new object();
private static readonly object EventWizardListItemDataBound = new object();
private bool _performingSelect;
private int _editIndex = -1;
private int _selectedIndex = -1;
private int _groupItemCount = 1;
private string _modelValidationGroup;
private string _sortExpression = String.Empty;
private SortDirection _sortDirection = SortDirection.Ascending;
private int _startRowIndex = 0;
private int _maximumRows = -1;
private int _totalRowCount = -1;
private IList _itemList;
private ListViewItem _insertItem;
private string[] _dataKeyNames;
private string[] _clientIDRowSuffix;
private DataKeyArray _dataKeyArray;
private ArrayList _dataKeysArrayList;
private DataKeyArray _clientIDRowSuffixArray;
private ArrayList _clientIDRowSuffixArrayList;
private OrderedDictionary _boundFieldValues;
private DataKey _persistedDataKey;
private int _deletedItemIndex;
private IOrderedDictionary _deleteKeys;
private IOrderedDictionary _deleteValues;
private IOrderedDictionary _insertValues;
private IOrderedDictionary _updateKeys;
private IOrderedDictionary _updateOldValues;
private IOrderedDictionary _updateNewValues;
private int _autoIDIndex = 0;
private const string _automaticIDPrefix = "ctrl";
private bool _instantiatedEmptyDataTemplate = false;
// Keep track of where we instantiated templates when we're not using grouping
private int _noGroupsOriginalIndexOfItemPlaceholderInContainer = -1;
private int _noGroupsItemCreatedCount;
private Control _noGroupsItemPlaceholderContainer;
// Keep track of where we instantiated templates when we're using grouping
private int _groupsOriginalIndexOfGroupPlaceholderInContainer = -1;
private int _groupsItemCreatedCount;
private Control _groupsGroupPlaceholderContainer;
public ListView() {
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override string AccessKey {
get {
return base.AccessKey;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewDataItem), BindingDirection.TwoWay),
ResourceDescription("ListView_AlternatingItemTemplate")
]
public virtual ITemplate AlternatingItemTemplate {
get {
return _alternatingItemTemplate;
}
set {
_alternatingItemTemplate = value;
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override Color BackColor {
get {
return base.BackColor;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override Color BorderColor {
get {
return base.BorderColor;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override Unit BorderWidth {
get {
return base.BorderWidth;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override BorderStyle BorderStyle {
get {
return base.BorderStyle;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
private IOrderedDictionary BoundFieldValues {
get {
if (_boundFieldValues == null) {
_boundFieldValues = new OrderedDictionary();
}
return _boundFieldValues;
}
}
public override ControlCollection Controls {
get {
EnsureChildControls();
return base.Controls;
}
}
///
/// Gets or sets the property that determines whether the control treats empty string as
/// null when the item values are extracted.
///
[
Category("Behavior"),
DefaultValue(true),
ResourceDescription("ListView_ConvertEmptyStringToNull"),
]
public virtual bool ConvertEmptyStringToNull {
get {
object o = ViewState["ConvertEmptyStringToNull"];
if (o != null) {
return (bool)o;
}
return true;
}
set {
ViewState["ConvertEmptyStringToNull"] = value;
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never),
CssClassPropertyAttribute
]
public override string CssClass {
get {
return base.CssClass;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
///
/// An array of ordered dictionaries that represents each key
///
private ArrayList DataKeysArrayList {
get {
if (_dataKeysArrayList == null) {
_dataKeysArrayList = new ArrayList();
}
return _dataKeysArrayList;
}
}
private ArrayList ClientIDRowSuffixArrayList {
get {
if (_clientIDRowSuffixArrayList == null) {
_clientIDRowSuffixArrayList = new ArrayList();
}
return _clientIDRowSuffixArrayList;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResourceDescription("ListView_DataKeys")
]
public virtual DataKeyArray DataKeys {
get {
if (_dataKeyArray == null) {
_dataKeyArray = new DataKeyArray(this.DataKeysArrayList);
if (IsTrackingViewState)
((IStateManager)_dataKeyArray).TrackViewState();
}
return _dataKeyArray;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID"),
]
public DataKeyArray ClientIDRowSuffixDataKeys {
get {
if (_clientIDRowSuffixArray == null) {
_clientIDRowSuffixArray = new DataKeyArray(this.ClientIDRowSuffixArrayList);
}
return _clientIDRowSuffixArray;
}
}
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.DataFieldEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
Category("Data"),
ResourceDescription("ListView_DataKeyNames"),
SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays",
Justification = "Required by ASP.NET parser."),
TypeConverterAttribute(typeof(StringArrayConverter)),
]
public virtual string[] DataKeyNames {
get {
object o = _dataKeyNames;
if (o != null) {
return (string[])((string[])o).Clone();
}
return new string[0];
}
set {
if (!DataBoundControlHelper.CompareStringArrays(value, DataKeyNamesInternal)) {
if (value != null) {
_dataKeyNames = (string[])value.Clone();
}
else {
_dataKeyNames = null;
}
ClearDataKeys();
SetRequiresDataBindingIfInitialized();
}
}
}
// This version doesn't clone the array
private string[] DataKeyNamesInternal {
get {
object o = _dataKeyNames;
if (o != null) {
return (string[])o;
}
return new string[0];
}
}
[
Category("Default"),
DefaultValue(-1),
ResourceDescription("ListView_EditIndex")
]
public virtual int EditIndex {
get {
return _editIndex;
}
set {
if (value < -1) {
throw new ArgumentOutOfRangeException("value");
}
if (value != _editIndex) {
if (value == -1) {
BoundFieldValues.Clear();
}
_editIndex = value;
SetRequiresDataBindingIfInitialized();
}
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResourceDescription("ListView_EditItem")
]
public virtual ListViewItem EditItem {
get {
if (_editIndex > -1 && _editIndex < Items.Count) {
return Items[_editIndex];
}
return null;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewDataItem), BindingDirection.TwoWay),
ResourceDescription("ListView_EditItemTemplate"),
]
public virtual ITemplate EditItemTemplate {
get {
return _editItemTemplate;
}
set {
_editItemTemplate = value;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListView)),
ResourceDescription("ListView_EmptyDataTemplate"),
]
public virtual ITemplate EmptyDataTemplate {
get {
return _emptyDataTemplate;
}
set {
_emptyDataTemplate = value;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewItem)),
ResourceDescription("ListView_EmptyItemTemplate"),
]
public virtual ITemplate EmptyItemTemplate {
get {
return _emptyItemTemplate;
}
set {
_emptyItemTemplate = value;
}
}
[
WebCategory("Behavior"),
DefaultValue(true),
ResourceDescription("ListView_EnableModelValidation")
]
public virtual bool EnableModelValidation {
get {
object o = ViewState["EnableModelValidation"];
if (o != null) {
return (bool)o;
}
return true;
}
set {
ViewState["EnableModelValidation"] = value;
}
}
[
WebCategory("Behavior"),
DefaultValue(false),
ResourceDescription("ListView_EnablePersistedSelection")
]
public virtual bool EnablePersistedSelection {
get {
object o = ViewState["EnablePersistedSelection"];
if (o != null) {
return (bool)o;
}
return false;
}
set {
ViewState["EnablePersistedSelection"] = value;
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override FontInfo Font {
get {
return base.Font;
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override Color ForeColor {
get {
return base.ForeColor;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
[
DefaultValue("groupPlaceholder"),
Category("Behavior"),
ResourceDescription("ListView_GroupPlaceholderID"),
SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID")
]
public virtual String GroupPlaceholderID {
get {
object o = ViewState["GroupPlaceholderID"];
if (o != null) {
return (String)o;
}
return "groupPlaceholder";
}
set {
if (String.IsNullOrEmpty(value)) {
throw new ArgumentOutOfRangeException("value", String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_ContainerNameMustNotBeEmpty, "GroupPlaceholderID"));
}
ViewState["GroupPlaceholderID"] = value;
}
}
[
Category("Default"),
DefaultValue(1),
ResourceDescription("ListView_GroupItemCount"),
]
public virtual int GroupItemCount {
get {
return _groupItemCount;
}
set {
if (value < 1) {
throw new ArgumentOutOfRangeException("value");
}
_groupItemCount = value;
SetRequiresDataBindingIfInitialized();
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewItem)),
ResourceDescription("ListView_GroupSeparatorTemplate"),
]
public virtual ITemplate GroupSeparatorTemplate {
get {
return _groupSeparatorTemplate;
}
set {
_groupSeparatorTemplate = value;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewItem)),
ResourceDescription("ListView_GroupTemplate"),
]
public virtual ITemplate GroupTemplate {
get {
return _groupTemplate;
}
set {
_groupTemplate = value;
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override Unit Height {
get {
return base.Height;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResourceDescription("ListView_InsertItem")
]
public virtual ListViewItem InsertItem {
get {
return _insertItem;
}
}
[
Category("Default"),
DefaultValue(InsertItemPosition.None),
ResourceDescription("ListView_InsertItemPosition")
]
public virtual InsertItemPosition InsertItemPosition {
get {
object o = ViewState["InsertItemPosition"];
if (o != null) {
return (InsertItemPosition)o;
}
return InsertItemPosition.None;
}
set {
if (InsertItemPosition != value) {
ViewState["InsertItemPosition"] = value;
SetRequiresDataBindingIfInitialized();
}
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewItem), BindingDirection.TwoWay),
ResourceDescription("ListView_InsertItemTemplate"),
]
public virtual ITemplate InsertItemTemplate {
get {
return _insertItemTemplate;
}
set {
_insertItemTemplate = value;
}
}
[
DefaultValue("itemPlaceholder"),
Category("Behavior"),
ResourceDescription("ListView_ItemPlaceholderID"),
SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID")
]
public virtual String ItemPlaceholderID {
get {
object o = ViewState["ItemPlaceholderID"];
if (o != null) {
return (String)o;
}
return "itemPlaceholder";
}
set {
if (String.IsNullOrEmpty(value)) {
throw new ArgumentOutOfRangeException("value", String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_ContainerNameMustNotBeEmpty, "ItemPlaceholderID"));
}
ViewState["ItemPlaceholderID"] = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResourceDescription("ListView_Items")
]
public virtual IList Items {
get {
if (_itemList == null) {
_itemList = new List();
}
return _itemList;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewItem)),
ResourceDescription("ListView_ItemSeparatorTemplate"),
]
public virtual ITemplate ItemSeparatorTemplate {
get {
return _itemSeparatorTemplate;
}
set {
_itemSeparatorTemplate = value;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewDataItem), BindingDirection.TwoWay),
ResourceDescription("ListView_ItemTemplate"),
SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
Justification = "Interface denotes existence of property, not used for security.")
]
public virtual ITemplate ItemTemplate {
get {
return _itemTemplate;
}
set {
_itemTemplate = value;
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListView)),
ResourceDescription("ListView_LayoutTemplate"),
]
public virtual ITemplate LayoutTemplate {
get {
return _layoutTemplate;
}
set {
_layoutTemplate = value;
}
}
[
DefaultValue(null),
TypeConverterAttribute(typeof(StringArrayConverter)),
WebCategory("Data"),
]
public virtual string[] ClientIDRowSuffix {
get {
object o = _clientIDRowSuffix;
if (o != null) {
return (string[])((string[])o).Clone();
}
return new string[0];
}
set {
if (!DataBoundControlHelper.CompareStringArrays(value, ClientIDRowSuffixInternal)) {
if (value != null) {
_clientIDRowSuffix = (string[])value.Clone();
}
else {
_clientIDRowSuffix = null;
}
_clientIDRowSuffixArrayList = null;
if (Initialized) {
RequiresDataBinding = true;
}
}
}
}
private string[] ClientIDRowSuffixInternal {
get {
object o = _clientIDRowSuffix;
if (o != null) {
return (string[])o;
}
return new string[0];
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public virtual DataKey SelectedDataKey {
get {
if (DataKeyNamesInternal == null || DataKeyNamesInternal.Length == 0) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_DataKeyNamesMustBeSpecified, ID));
}
DataKeyArray keys = DataKeys;
int selectedIndex = SelectedIndex;
if (keys != null && selectedIndex < keys.Count && selectedIndex > -1) {
return keys[selectedIndex];
}
return null;
}
}
[
Category("Default"),
DefaultValue(-1),
ResourceDescription("ListView_SelectedIndex"),
SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
Justification = "Interface denotes existence of property, not used for security.")
]
public virtual int SelectedIndex {
get {
return _selectedIndex;
}
set {
if (value < -1) {
throw new ArgumentOutOfRangeException("value");
}
if (value != _selectedIndex) {
// update the virtual selection to use the new selection
_selectedIndex = value;
if (EnablePersistedSelection && (DataKeyNamesInternal.Length > 0)) {
SelectedPersistedDataKey = SelectedDataKey;
}
// we're going to rebind here for a new template
SetRequiresDataBindingIfInitialized();
}
}
}
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(ListViewDataItem), BindingDirection.TwoWay),
ResourceDescription("ListView_SelectedItemTemplate"),
]
public virtual ITemplate SelectedItemTemplate {
get {
return _selectedItemTemplate;
}
set {
_selectedItemTemplate = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public object SelectedValue {
get {
DataKey selectedDataKey = SelectedDataKey;
if (selectedDataKey != null) {
return SelectedDataKey.Value;
}
return null;
}
}
[
Browsable(false),
DefaultValue(SortDirection.Ascending),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
PersistenceMode(PersistenceMode.InnerProperty),
ResourceDescription("ListView_SortDirection"),
ResourceCategory("Sorting"),
]
public virtual SortDirection SortDirection {
get {
return SortDirectionInternal;
}
}
///
/// Internal member for setting sort direction
///
private SortDirection SortDirectionInternal {
get {
return _sortDirection;
}
set {
if (value < SortDirection.Ascending || value > SortDirection.Descending) {
throw new ArgumentOutOfRangeException("value");
}
if (_sortDirection != value) {
_sortDirection = value;
SetRequiresDataBindingIfInitialized();
}
}
}
///
/// Gets a value that specifies the current column being sorted on in the
///
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
ResourceDescription("ListView_SortExpression"),
ResourceCategory("Sorting"),
]
public virtual string SortExpression {
get {
return SortExpressionInternal;
}
}
///
/// Internal member for setting sort expression
///
private string SortExpressionInternal {
get {
return _sortExpression;
}
set {
if (_sortExpression != value) {
_sortExpression = value;
SetRequiresDataBindingIfInitialized();
}
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override short TabIndex {
get {
return base.TabIndex;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override string ToolTip {
get {
return base.ToolTip;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
[
Browsable(false)
]
public virtual DataKey SelectedPersistedDataKey {
get {
return _persistedDataKey;
}
set {
_persistedDataKey = value;
if (IsTrackingViewState && (_persistedDataKey != null)) {
((IStateManager)_persistedDataKey).TrackViewState();
}
}
}
// Override style properties and throw from setter, and set Browsable(false).
// Don't throw from getters because designer calls getters through reflection.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
EditorBrowsable(EditorBrowsableState.Never)
]
public override Unit Width {
get {
return base.Width;
}
set {
throw new NotSupportedException(AtlasWeb.ListView_StylePropertiesNotSupported);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemDeleted")
]
public event EventHandler ItemDeleted {
add {
Events.AddHandler(EventItemDeleted, value);
}
remove {
Events.RemoveHandler(EventItemDeleted, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemInserted")
]
public event EventHandler ItemInserted {
add {
Events.AddHandler(EventItemInserted, value);
}
remove {
Events.RemoveHandler(EventItemInserted, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemUpdated")
]
public event EventHandler ItemUpdated {
add {
Events.AddHandler(EventItemUpdated, value);
}
remove {
Events.RemoveHandler(EventItemUpdated, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemCanceling")
]
public event EventHandler ItemCanceling {
add {
Events.AddHandler(EventItemCanceling, value);
}
remove {
Events.RemoveHandler(EventItemCanceling, value);
}
}
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemCommand")
]
public event EventHandler ItemCommand {
add {
Events.AddHandler(EventItemCommand, value);
}
remove {
Events.RemoveHandler(EventItemCommand, value);
}
}
///
/// Occurs on the server when a control a created.
///
[
Category("Behavior"),
ResourceDescription("ListView_OnItemCreated")
]
public event EventHandler ItemCreated {
add {
Events.AddHandler(EventItemCreated, value);
}
remove {
Events.RemoveHandler(EventItemCreated, value);
}
}
///
/// Occurs when an Item is data bound to the control.
///
[
Category("Data"),
ResourceDescription("ListView_OnItemDataBound")
]
public event EventHandler ItemDataBound {
add {
Events.AddHandler(EventItemDataBound, value);
}
remove {
Events.RemoveHandler(EventItemDataBound, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemDeleting")
]
public event EventHandler ItemDeleting {
add {
Events.AddHandler(EventItemDeleting, value);
}
remove {
Events.RemoveHandler(EventItemDeleting, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemEditing")
]
public event EventHandler ItemEditing {
add {
Events.AddHandler(EventItemEditing, value);
}
remove {
Events.RemoveHandler(EventItemEditing, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemInserting")
]
public event EventHandler ItemInserting {
add {
Events.AddHandler(EventItemInserting, value);
}
remove {
Events.RemoveHandler(EventItemInserting, value);
}
}
///
/// Occurs when a control bubbles an event to the
///
[
Category("Action"),
ResourceDescription("ListView_OnItemUpdating")
]
public event EventHandler ItemUpdating {
add {
Events.AddHandler(EventItemUpdating, value);
}
remove {
Events.RemoveHandler(EventItemUpdating, value);
}
}
///
/// Occurs on the server when a control layout is created.
///
[
Category("Behavior"),
ResourceDescription("ListView_OnLayoutCreated")
]
public event EventHandler LayoutCreated {
add {
Events.AddHandler(EventLayoutCreated, value);
}
remove {
Events.RemoveHandler(EventLayoutCreated, value);
}
}
///
/// Occurs on the server when the page properties have changed.
///
[
Category("Behavior"),
ResourceDescription("ListView_OnPagePropertiesChanged")
]
public event EventHandler PagePropertiesChanged {
add {
Events.AddHandler(EventPagePropertiesChanged, value);
}
remove {
Events.RemoveHandler(EventPagePropertiesChanged, value);
}
}
///
/// Occurs on the server when the page properties are changing.
///
[
Category("Behavior"),
ResourceDescription("ListView_OnPagePropertiesChanging")
]
public event EventHandler PagePropertiesChanging {
add {
Events.AddHandler(EventPagePropertiesChanging, value);
}
remove {
Events.RemoveHandler(EventPagePropertiesChanging, value);
}
}
///
/// Occurs when an Item on the list is selected.
///
[
Category("Action"),
ResourceDescription("ListView_OnSelectedIndexChanged")
]
public event EventHandler SelectedIndexChanged {
add {
Events.AddHandler(EventSelectedIndexChanged, value);
}
remove {
Events.RemoveHandler(EventSelectedIndexChanged, value);
}
}
///
/// Occurs when an Item on the list is selected.
///
[
Category("Action"),
ResourceDescription("ListView_OnSelectedIndexChanging")
]
public event EventHandler SelectedIndexChanging {
add {
Events.AddHandler(EventSelectedIndexChanging, value);
}
remove {
Events.RemoveHandler(EventSelectedIndexChanging, value);
}
}
///
/// Occurs when a field is sorted.
///
[
Category("Action"),
ResourceDescription("ListView_OnSorted")
]
public event EventHandler Sorted {
add {
Events.AddHandler(EventSorted, value);
}
remove {
Events.RemoveHandler(EventSorted, value);
}
}
///
/// Occurs when a field is sorting.
///
[
Category("Action"),
ResourceDescription("ListView_OnSorting")
]
public event EventHandler Sorting {
add {
Events.AddHandler(EventSorting, value);
}
remove {
Events.RemoveHandler(EventSorting, value);
}
}
protected virtual void AddControlToContainer(Control control, Control container, int addLocation) {
// The ListView packages up everything in the ItemTemplate in a ListViewDataItem or ListViewItem.
// The ListViewItem is being added to the control tree. Since ListViewItems can't be children of HtmlTables or
// HtmlTableRows, we put them in a derived HtmlTable or HtmlTableRow, which just renders out its children.
// Since ListViewItems don't have any rendering, only the child HtmlTableRow or HtmlTableCell will be rendered.
if (container is HtmlTable) {
ListViewTableRow listViewTableRow = new ListViewTableRow();
container.Controls.AddAt(addLocation, listViewTableRow);
listViewTableRow.Controls.Add(control);
}
else {
if (container is HtmlTableRow) {
ListViewTableCell listViewTableCell = new ListViewTableCell();
container.Controls.AddAt(addLocation, listViewTableCell);
listViewTableCell.Controls.Add(control);
}
else {
container.Controls.AddAt(addLocation, control);
}
}
}
private void AutoIDControl(Control control) {
// We have to do our own auto-id'ing because we create the LayoutTemplate, add controls
// to the item or group container, then clear those controls out when we bind again.
// Because the item or group container isn't necessarily a naming container, clearing
// out its controls collection doesn't reset the auto-id counter and you get new ids.
// On postback, controls that have post data won't be found because their generated
// ids won't match the prior ones. By creating our own auto-id'ing, we don't get
// Control's auto-id, and we can reset the auto id index when we remove all items from
// the item or group container.
control.ID = _automaticIDPrefix + _autoIDIndex++.ToString(CultureInfo.InvariantCulture);
}
private void ClearDataKeys() {
_dataKeysArrayList = null;
}
///
/// Overriden by DataBoundControl to determine if the control should
/// recreate its control hierarchy based on values in view state.
/// If the control hierarchy should be created, i.e. view state does
/// exist, it calls CreateChildControls with a dummy (empty) data source
/// which is usable for enumeration purposes only.
///
protected internal override void CreateChildControls() {
object controlCount = ViewState[ItemCountViewStateKey];
if (controlCount == null && RequiresDataBinding) {
EnsureDataBound();
}
if (controlCount != null && ((int)controlCount) != -1) {
object[] dummyDataSource = new object[(int)controlCount];
CreateChildControls(dummyDataSource, false);
ClearChildViewState();
}
}
///
/// Performs the work of creating the control hierarchy based on a data source.
/// When dataBinding is true, the specified data source contains real
/// data, and the data is supposed to be pushed into the UI.
/// When dataBinding is false, the specified data source is a dummy data
/// source, that allows enumerating the right number of items, but the items
/// themselves are null and do not contain data. In this case, the recreated
/// control hierarchy reinitializes its state from view state.
/// It enables a DataBoundControl to encapsulate the logic of creating its
/// control hierarchy in both modes into a single code path.
///
///
/// The data source to be used to enumerate items.
///
///
/// Whether the method has been called from DataBind or not.
///
///
/// The number of items created based on the data source. Put another way, its
/// the number of items enumerated from the data source.
///
protected virtual int CreateChildControls(IEnumerable dataSource, bool dataBinding) {
ListViewPagedDataSource pagedDataSource = null;
// Create the LayoutTemplate so the pager control in it can set page properties.
// We'll only create the layout template once.
EnsureLayoutTemplate();
RemoveItems();
// if we should render the insert item, make a dummy empty datasource and go through
// the regular code path.
if (dataSource == null && InsertItemPosition != InsertItemPosition.None) {
dataSource = new object[0];
}
bool usePaging = (_startRowIndex > 0 || _maximumRows > 0);
if (dataBinding) {
DataSourceView view = GetData();
DataSourceSelectArguments arguments = SelectArguments;
if (view == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NullView, ID));
}
bool useServerPaging = view.CanPage && usePaging;
if (!view.CanPage && useServerPaging) {
if (dataSource != null && !(dataSource is ICollection)) {
arguments.StartRowIndex = _startRowIndex;
arguments.MaximumRows = _maximumRows;
// This should throw an exception saying the data source can't page.
// We do this because the data source can provide a better error message than we can.
view.Select(arguments, SelectCallback);
}
}
if (useServerPaging) {
int totalRowCount;
if (view.CanRetrieveTotalRowCount) {
totalRowCount = arguments.TotalRowCount;
}
else {
ICollection dataSourceCollection = dataSource as ICollection;
if (dataSourceCollection == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NeedICollectionOrTotalRowCount, GetType().Name));
}
totalRowCount = checked(_startRowIndex + dataSourceCollection.Count);
}
pagedDataSource = CreateServerPagedDataSource(totalRowCount);
}
else {
pagedDataSource = CreatePagedDataSource();
}
}
else {
pagedDataSource = CreatePagedDataSource();
}
ArrayList keyArray = DataKeysArrayList;
ArrayList suffixArray = ClientIDRowSuffixArrayList;
_dataKeyArray = null;
_clientIDRowSuffixArray = null;
ICollection collection = dataSource as ICollection;
if (dataBinding) {
keyArray.Clear();
suffixArray.Clear();
if ((dataSource != null) && (collection == null) && !pagedDataSource.IsServerPagingEnabled && usePaging) {
// If we got to here, it's because the data source view said it could page, but then returned
// something that wasn't an ICollection. Probably a data source control author error.
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_Missing_VirtualItemCount, ID));
}
}
else {
if (collection == null) {
throw new InvalidOperationException(AtlasWeb.ListView_DataSourceMustBeCollectionWhenNotDataBinding);
}
}
if (dataSource != null) {
pagedDataSource.DataSource = dataSource;
if (dataBinding && usePaging) {
keyArray.Capacity = pagedDataSource.DataSourceCount;
suffixArray.Capacity = pagedDataSource.DataSourceCount;
}
if (_groupTemplate != null) {
_itemList = CreateItemsInGroups(pagedDataSource, dataBinding, InsertItemPosition, keyArray);
if (dataBinding && ClientIDRowSuffixInternal != null && ClientIDRowSuffixInternal.Length != 0) {
CreateSuffixArrayList(pagedDataSource, suffixArray);
}
}
else {
if (GroupItemCount != 1) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_GroupItemCountNoGroupTemplate, ID, GroupPlaceholderID));
}
_itemList = CreateItemsWithoutGroups(pagedDataSource, dataBinding, InsertItemPosition, keyArray);
if(dataBinding && ClientIDRowSuffixInternal != null && ClientIDRowSuffixInternal.Length != 0) {
CreateSuffixArrayList(pagedDataSource, suffixArray);
}
}
_totalRowCount = usePaging ? pagedDataSource.DataSourceCount : _itemList.Count;
OnTotalRowCountAvailable(new PageEventArgs(_startRowIndex, _maximumRows, _totalRowCount));
if (_itemList.Count == 0) {
if (InsertItemPosition == InsertItemPosition.None) {
// remove the layout template
Controls.Clear();
CreateEmptyDataItem();
}
}
}
else {
// remove the layout template
Controls.Clear();
CreateEmptyDataItem();
}
return _totalRowCount;
}
// Style properties won't be honored on ListView, so throw if someone tries to set any style properties
protected override Style CreateControlStyle() {
// The designer reflects on properties at design time. Don't throw then.
if (!DesignMode) {
throw new NotSupportedException(AtlasWeb.ListView_StyleNotSupported);
}
return base.CreateControlStyle();
}
protected override DataSourceSelectArguments CreateDataSourceSelectArguments() {
DataSourceSelectArguments arguments = new DataSourceSelectArguments();
DataSourceView view = GetData();
bool useServerPaging = view.CanPage;
string sortExpression = SortExpressionInternal;
if (SortDirectionInternal == SortDirection.Descending && !String.IsNullOrEmpty(sortExpression)) {
sortExpression += " DESC";
}
arguments.SortExpression = sortExpression;
// decide if we should use server-side paging
if (useServerPaging) {
if (view.CanRetrieveTotalRowCount) {
arguments.RetrieveTotalRowCount = true;
arguments.MaximumRows = _maximumRows;
}
else {
arguments.MaximumRows = -1;
}
arguments.StartRowIndex = _startRowIndex;
}
return arguments;
}
protected virtual void CreateEmptyDataItem() {
if (_emptyDataTemplate != null) {
_instantiatedEmptyDataTemplate = true;
ListViewItem item = CreateItem(ListViewItemType.EmptyItem);
AutoIDControl(item);
InstantiateEmptyDataTemplate(item);
OnItemCreated(new ListViewItemEventArgs(item));
AddControlToContainer(item, this, 0);
}
}
protected virtual ListViewItem CreateEmptyItem() {
if (_emptyItemTemplate != null) {
ListViewItem emptyItem = CreateItem(ListViewItemType.EmptyItem);
AutoIDControl(emptyItem);
InstantiateEmptyItemTemplate(emptyItem);
OnItemCreated(new ListViewItemEventArgs(emptyItem));
return emptyItem;
}
return null;
}
protected virtual ListViewItem CreateInsertItem() {
if (InsertItemTemplate == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_InsertTemplateRequired, ID));
}
ListViewItem item = CreateItem(ListViewItemType.InsertItem);
AutoIDControl(item);
InstantiateInsertItemTemplate(item);
OnItemCreated(new ListViewItemEventArgs(item));
return item;
}
protected virtual ListViewItem CreateItem(ListViewItemType itemType) {
ListViewItem item = new ListViewItem(itemType);
if (itemType == ListViewItemType.InsertItem) {
_insertItem = item;
}
return item;
}
protected virtual ListViewDataItem CreateDataItem(int dataItemIndex, int displayIndex) {
return new ListViewDataItem(dataItemIndex, displayIndex);
}
protected virtual IList CreateItemsWithoutGroups(ListViewPagedDataSource dataSource, bool dataBinding, InsertItemPosition insertPosition, ArrayList keyArray) {
// If this is the first time we're creating the control items, we need
// to locate the itemPlaceholder container.
// If this is a scenario where we are recreating control items, we already
// have the cached itemPlaceholder container.
if (_noGroupsOriginalIndexOfItemPlaceholderInContainer == -1) {
_noGroupsItemPlaceholderContainer = GetPreparedContainerInfo(this, true, out _noGroupsOriginalIndexOfItemPlaceholderInContainer);
}
// We need to keep track of where we're inserting items and how many items we have
// inserted so that if we need to remove them we know what to do.
int itemInsertLocation = _noGroupsOriginalIndexOfItemPlaceholderInContainer;
List items = new List();
int itemIndex = 0;
int dataItemIndex = 0;
if (insertPosition == InsertItemPosition.FirstItem) {
ListViewItem insertItem = CreateInsertItem();
AddControlToContainer(insertItem, _noGroupsItemPlaceholderContainer, itemInsertLocation);
insertItem.DataBind();
itemInsertLocation++;
itemIndex++;
}
// Reset the selected index if we have a persisted datakey so we
// can figure out what index to select based on the key
ResetPersistedSelectedIndex();
foreach (object o in dataSource) {
if (itemIndex != 0 && _itemSeparatorTemplate != null) {
ListViewContainer itemSeparatorContainer = new ListViewContainer();
AutoIDControl(itemSeparatorContainer);
InstantiateItemSeparatorTemplate(itemSeparatorContainer);
AddControlToContainer(itemSeparatorContainer, _noGroupsItemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
}
ListViewDataItem item = CreateDataItem(dataItemIndex + dataSource.StartRowIndex, dataItemIndex);
AutoIDControl(item);
if (dataBinding) {
item.DataItem = o;
OrderedDictionary keyTable = new OrderedDictionary(DataKeyNamesInternal.Length);
foreach (string keyName in DataKeyNamesInternal) {
object keyValue = DataBinder.GetPropertyValue(o, keyName);
keyTable.Add(keyName, keyValue);
}
if (keyArray.Count == dataItemIndex) {
keyArray.Add(new DataKey(keyTable, DataKeyNamesInternal));
}
else {
keyArray[dataItemIndex] = new DataKey(keyTable, DataKeyNamesInternal);
}
}
// If persisted selection is enabled and we have a data key then compare it to get the selected index
if (EnablePersistedSelection) {
if (dataItemIndex < keyArray.Count) {
DataKey currentKey = (DataKey)keyArray[dataItemIndex];
SetPersistedDataKey(dataItemIndex, currentKey);
}
}
InstantiateItemTemplate(item, dataItemIndex);
OnItemCreated(new ListViewItemEventArgs(item));
AddControlToContainer(item, _noGroupsItemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
items.Add(item);
if (dataBinding) {
item.DataBind();
OnItemDataBound(new ListViewItemEventArgs(item));
item.DataItem = null;
}
dataItemIndex++;
itemIndex++;
}
if (insertPosition == InsertItemPosition.LastItem) {
if (_itemSeparatorTemplate != null) {
ListViewContainer itemSeparatorContainer = new ListViewContainer();
AutoIDControl(itemSeparatorContainer);
InstantiateItemSeparatorTemplate(itemSeparatorContainer);
AddControlToContainer(itemSeparatorContainer, _noGroupsItemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
}
ListViewItem insertItem = CreateInsertItem();
AddControlToContainer(insertItem, _noGroupsItemPlaceholderContainer, itemInsertLocation);
insertItem.DataBind();
itemInsertLocation++;
itemIndex++;
}
_noGroupsItemCreatedCount = itemInsertLocation - _noGroupsOriginalIndexOfItemPlaceholderInContainer;
return items;
}
private void ResetPersistedSelectedIndex() {
// If there is already a persisted DataKey then we should reset
// the selected index so that we pick a selected index base on
// a row that matches the DataKey if any
if (EnablePersistedSelection && (_persistedDataKey != null)) {
_selectedIndex = -1;
}
}
private void SetPersistedDataKey(int dataItemIndex, DataKey currentKey) {
if (_persistedDataKey == null) {
// If there is no persisted DataKey then set it to the DataKey at the
// the selected index
if (_selectedIndex == dataItemIndex) {
_persistedDataKey = currentKey;
}
}
else if (_persistedDataKey.Equals(currentKey)) {
// Persist the selection by picking the selected index where DataKeys match
_selectedIndex = dataItemIndex;
}
}
protected virtual IList CreateItemsInGroups(ListViewPagedDataSource dataSource, bool dataBinding, InsertItemPosition insertPosition, ArrayList keyArray) {
// If this is the first time we're creating the control items, we need
// to locate the groupPlaceholder container.
// If this is a scenario where we are recreating control items, we already
// have the cached groupPlaceholder container.
if (_groupsOriginalIndexOfGroupPlaceholderInContainer == -1) {
_groupsGroupPlaceholderContainer = GetPreparedContainerInfo(this, false, out _groupsOriginalIndexOfGroupPlaceholderInContainer);
}
int groupInsertLocation = _groupsOriginalIndexOfGroupPlaceholderInContainer;
_groupsItemCreatedCount = 0;
int itemInsertLocation = 0;
Control itemPlaceholderContainer = null;
// Reset the selected index if we have a persisted datakey so we
// can figure out what index to select based on the key
ResetPersistedSelectedIndex();
List items = new List();
int itemIndex = 0;
int dataItemIndex = 0;
if (insertPosition == InsertItemPosition.FirstItem) {
ListViewContainer groupContainer = new ListViewContainer();
AutoIDControl(groupContainer);
InstantiateGroupTemplate(groupContainer);
AddControlToContainer(groupContainer, _groupsGroupPlaceholderContainer, groupInsertLocation);
groupInsertLocation++;
itemPlaceholderContainer = GetPreparedContainerInfo(groupContainer, true, out itemInsertLocation);
ListViewItem insertItem = CreateInsertItem();
AddControlToContainer(insertItem, itemPlaceholderContainer, itemInsertLocation);
insertItem.DataBind();
itemInsertLocation++;
itemIndex++;
}
foreach (object o in dataSource) {
if (itemIndex % _groupItemCount == 0) {
if (itemIndex != 0 && _groupSeparatorTemplate != null) {
ListViewContainer groupSeparatorContainer = new ListViewContainer();
AutoIDControl(groupSeparatorContainer);
InstantiateGroupSeparatorTemplate(groupSeparatorContainer);
AddControlToContainer(groupSeparatorContainer, _groupsGroupPlaceholderContainer, groupInsertLocation);
groupInsertLocation++;
}
ListViewContainer groupContainer = new ListViewContainer();
AutoIDControl(groupContainer);
InstantiateGroupTemplate(groupContainer);
AddControlToContainer(groupContainer, _groupsGroupPlaceholderContainer, groupInsertLocation);
groupInsertLocation++;
itemPlaceholderContainer = GetPreparedContainerInfo(groupContainer, true, out itemInsertLocation);
}
ListViewDataItem item = CreateDataItem(dataItemIndex + StartRowIndex, dataItemIndex);
if (dataBinding) {
item.DataItem = o;
OrderedDictionary keyTable = new OrderedDictionary(DataKeyNamesInternal.Length);
foreach (string keyName in DataKeyNamesInternal) {
object keyValue = DataBinder.GetPropertyValue(o, keyName);
keyTable.Add(keyName, keyValue);
}
if (keyArray.Count == dataItemIndex) {
keyArray.Add(new DataKey(keyTable, DataKeyNamesInternal));
}
else {
keyArray[dataItemIndex] = new DataKey(keyTable, DataKeyNamesInternal);
}
}
// If persisted selection is enabled and we have a data key then compare it to get the selected index
if (EnablePersistedSelection) {
if (dataItemIndex < keyArray.Count) {
DataKey currentKey = (DataKey)keyArray[dataItemIndex];
SetPersistedDataKey(dataItemIndex, currentKey);
}
}
InstantiateItemTemplate(item, dataItemIndex);
OnItemCreated(new ListViewItemEventArgs(item));
if (itemIndex % _groupItemCount != 0 && _itemSeparatorTemplate != null) {
ListViewContainer itemSeparatorContainer = new ListViewContainer();
InstantiateItemSeparatorTemplate(itemSeparatorContainer);
AddControlToContainer(itemSeparatorContainer, itemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
}
AddControlToContainer(item, itemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
items.Add(item);
if (dataBinding) {
item.DataBind();
OnItemDataBound(new ListViewItemEventArgs(item));
item.DataItem = null;
}
itemIndex++;
dataItemIndex++;
}
if (insertPosition == InsertItemPosition.LastItem) {
if (itemIndex % _groupItemCount == 0) {
// start a new group
if (itemIndex != 0 && _groupSeparatorTemplate != null) {
ListViewContainer groupSeparatorContainer = new ListViewContainer();
AutoIDControl(groupSeparatorContainer);
InstantiateGroupSeparatorTemplate(groupSeparatorContainer);
AddControlToContainer(groupSeparatorContainer, _groupsGroupPlaceholderContainer, groupInsertLocation);
groupInsertLocation++;
}
ListViewContainer groupContainer = new ListViewContainer();
AutoIDControl(groupContainer);
InstantiateGroupTemplate(groupContainer);
AddControlToContainer(groupContainer, _groupsGroupPlaceholderContainer, groupInsertLocation);
groupInsertLocation++;
itemPlaceholderContainer = GetPreparedContainerInfo(groupContainer, true, out itemInsertLocation);
}
// use the existing group
if (itemIndex % _groupItemCount != 0 && _itemSeparatorTemplate != null) {
ListViewContainer itemSeparatorContainer = new ListViewContainer();
InstantiateItemSeparatorTemplate(itemSeparatorContainer);
AddControlToContainer(itemSeparatorContainer, itemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
}
ListViewItem insertItem = CreateInsertItem();
AddControlToContainer(insertItem, itemPlaceholderContainer, itemInsertLocation);
insertItem.DataBind();
itemInsertLocation++;
itemIndex++;
}
// fill in the rest of the items if there's an emptyItemTemplate
if (_emptyItemTemplate != null) {
while (itemIndex % _groupItemCount != 0) {
if (_itemSeparatorTemplate != null) {
ListViewContainer itemSeparatorContainer = new ListViewContainer();
InstantiateItemSeparatorTemplate(itemSeparatorContainer);
AddControlToContainer(itemSeparatorContainer, itemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
}
ListViewItem emptyItem = CreateEmptyItem();
AddControlToContainer(emptyItem, itemPlaceholderContainer, itemInsertLocation);
itemInsertLocation++;
itemIndex++;
}
}
_groupsItemCreatedCount = groupInsertLocation - _groupsOriginalIndexOfGroupPlaceholderInContainer;
return items;
}
protected virtual void CreateSuffixArrayList(ListViewPagedDataSource dataSource, ArrayList suffixArray) {
int dataItemIndex = 0;
foreach (object o in dataSource) {
OrderedDictionary suffixTable = new OrderedDictionary(ClientIDRowSuffixInternal.Length);
foreach (string suffixName in ClientIDRowSuffixInternal) {
object suffixValue = DataBinder.GetPropertyValue(o, suffixName);
suffixTable.Add(suffixName, suffixValue);
}
if (suffixArray.Count == dataItemIndex) {
suffixArray.Add(new DataKey(suffixTable, ClientIDRowSuffixInternal));
}
else {
suffixArray[dataItemIndex] = new DataKey(suffixTable, ClientIDRowSuffixInternal);
}
dataItemIndex++;
}
}
protected virtual void CreateLayoutTemplate() {
// Reset data concerning where things are in the layout template since we're about to recreate it
_noGroupsOriginalIndexOfItemPlaceholderInContainer = -1;
_noGroupsItemCreatedCount = 0;
_noGroupsItemPlaceholderContainer = null;
_groupsOriginalIndexOfGroupPlaceholderInContainer = -1;
_groupsItemCreatedCount = 0;
_groupsGroupPlaceholderContainer = null;
Control containerControl = new Control();
if (_layoutTemplate != null) {
_layoutTemplate.InstantiateIn(containerControl);
Controls.Add(containerControl);
}
OnLayoutCreated(new EventArgs());
}
private ListViewPagedDataSource CreatePagedDataSource() {
ListViewPagedDataSource pagedDataSource = new ListViewPagedDataSource();
pagedDataSource.StartRowIndex = _startRowIndex;
pagedDataSource.MaximumRows = _maximumRows;
pagedDataSource.AllowServerPaging = false;
pagedDataSource.TotalRowCount = 0;
return pagedDataSource;
}
private ListViewPagedDataSource CreateServerPagedDataSource(int totalRowCount) {
ListViewPagedDataSource pagedDataSource = new ListViewPagedDataSource();
pagedDataSource.StartRowIndex = _startRowIndex;
pagedDataSource.MaximumRows = _maximumRows;
pagedDataSource.AllowServerPaging = true;
pagedDataSource.TotalRowCount = totalRowCount;
return pagedDataSource;
}
public virtual void DeleteItem(int itemIndex) {
// use EnableModelVadliation as the causesValdiation param because the hosting page should not
// be validated unless model validation is going to be used
ResetModelValidationGroup(EnableModelValidation, String.Empty);
HandleDelete(null, itemIndex);
}
protected virtual void EnsureLayoutTemplate() {
if (this.Controls.Count == 0 || _instantiatedEmptyDataTemplate) {
Controls.Clear();
CreateLayoutTemplate();
}
}
public virtual void ExtractItemValues(IOrderedDictionary itemValues, ListViewItem item, bool includePrimaryKey) {
if (itemValues == null) {
throw new ArgumentNullException("itemValues");
}
DataBoundControlHelper.ExtractValuesFromBindableControls(itemValues, item);
IBindableTemplate bindableTemplate = null;
if (item.ItemType == ListViewItemType.DataItem) {
ListViewDataItem dataItem = item as ListViewDataItem;
if (dataItem == null) {
throw new InvalidOperationException(AtlasWeb.ListView_ItemsNotDataItems);
}
if (dataItem.DisplayIndex == EditIndex) {
bindableTemplate = EditItemTemplate as IBindableTemplate;
}
else if (dataItem.DisplayIndex == SelectedIndex) {
bindableTemplate = SelectedItemTemplate as IBindableTemplate;
}
else if (dataItem.DisplayIndex % 2 == 1 && AlternatingItemTemplate != null) {
bindableTemplate = AlternatingItemTemplate as IBindableTemplate;
}
else {
bindableTemplate = ItemTemplate as IBindableTemplate;
}
}
else if (item.ItemType == ListViewItemType.InsertItem) {
if (InsertItemTemplate != null) {
bindableTemplate = InsertItemTemplate as IBindableTemplate;
}
}
if (bindableTemplate != null) {
OrderedDictionary newValues = new OrderedDictionary();
bool convertEmptyStringToNull = ConvertEmptyStringToNull;
foreach (DictionaryEntry entry in bindableTemplate.ExtractValues(item)) {
object value = entry.Value;
if (convertEmptyStringToNull && value is string && ((string)value).Length == 0) {
newValues[entry.Key] = null;
}
else {
newValues[entry.Key] = value;
}
}
foreach (DictionaryEntry entry in newValues) {
if (includePrimaryKey || (Array.IndexOf(DataKeyNamesInternal, entry.Key) == -1)) {
itemValues[entry.Key] = entry.Value;
}
}
}
}
[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID")]
protected virtual Control FindPlaceholder(string containerID, Control container) {
return container.FindControl(containerID);
}
private DataPager FindDataPager(Control control) {
foreach (Control c in control.Controls) {
DataPager pager = c as DataPager;
if (pager != null) {
return pager;
}
}
foreach (Control c in control.Controls) {
if (c is IPageableItemContainer) {
// Exit out if we've ventured into another ListView or pageable container, since that is the likely
// target of any embedded pagers.
return null;
}
DataPager pager = FindDataPager(c);
if (pager != null) {
return pager;
}
}
return null;
}
private int GetItemIndex(ListViewItem item, string commandArgument) {
if (item != null) {
ListViewDataItem dataItem = item as ListViewDataItem;
if (dataItem != null) {
return dataItem.DisplayIndex;
}
return -1;
}
return Convert.ToInt32(commandArgument, CultureInfo.InvariantCulture);
}
private Control GetPreparedContainerInfo(Control outerContainer, bool isItem, out int placeholderIndex) {
// This function locates the ItemPlaceholder for a given container and prepares
// it for child controls. Strategy:
// - Locate ItemPlaceholder
// - If it's not found and the user defined a layout template throw
// - If it's not found and the user didn't define a layout/group template, add a default placeholder with the placeholder ID
// - Store the placeholder's container and the placeholder's location in the container
// - Remove the ItemPlaceholder
string placeholderID = isItem ? ItemPlaceholderID : GroupPlaceholderID;
Control placeholder = FindPlaceholder(placeholderID, outerContainer);
if (placeholder == null) {
//add a default placeholder
if (_layoutTemplate == null) {
placeholder = new PlaceHolder();
placeholder.ID = placeholderID;
}
if (isItem) {
//throw if the user defined a layout/group template and didn't specify an item placeholder
if ((_layoutTemplate != null) || (_groupTemplate != null)) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NoItemPlaceholder, ID, ItemPlaceholderID));
}
}
else {
//throw if the user defined a layout template and didn't specify an group placeholder
if (_layoutTemplate != null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NoGroupPlaceholder, ID, GroupPlaceholderID));
}
}
Controls.Add(placeholder);
}
// Save the information about where we found the itemPlaceholder because
// in RemoveItems() we need to know where to delete whatever we create.
// This only applies to certain usages of this function.
Control placeholderContainer = placeholder.Parent;
placeholderIndex = placeholderContainer.Controls.IndexOf(placeholder);
// Remove the item placeholder since we're going to be
// adding real items starting at the index where it used to be.
placeholderContainer.Controls.Remove(placeholder);
return placeholderContainer;
}
private void HandleCancel(int itemIndex) {
ListViewCancelMode cancelMode = ListViewCancelMode.CancelingInsert;
if (itemIndex == EditIndex && itemIndex >= 0) {
cancelMode = ListViewCancelMode.CancelingEdit;
}
else if (itemIndex != -1) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidCancel);
}
ListViewCancelEventArgs e = new ListViewCancelEventArgs(itemIndex, cancelMode);
OnItemCanceling(e);
if (e.Cancel) {
return;
}
if (IsBoundUsingDataSourceID) {
if (e.CancelMode == ListViewCancelMode.CancelingEdit) {
EditIndex = -1;
}
else {
// cancel on an insert is simply "redatabind to clear"?
}
}
RequiresDataBinding = true;
}
private void HandleDelete(ListViewItem item, int itemIndex) {
ListViewDataItem dataItem = item as ListViewDataItem;
if (itemIndex < 0 && dataItem == null) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidDelete);
}
DataSourceView view = null;
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
if (isBoundToDataSourceControl) {
view = GetData();
if (view == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NullView, ID));
}
}
if (item == null && itemIndex < Items.Count) {
item = Items[itemIndex];
}
ListViewDeleteEventArgs e = new ListViewDeleteEventArgs(itemIndex);
if (item != null) {
ExtractItemValues(e.Values, item, false/*includePrimaryKey*/);
}
if (DataKeys.Count > itemIndex) {
foreach (DictionaryEntry entry in DataKeys[itemIndex].Values) {
e.Keys.Add(entry.Key, entry.Value);
if (e.Values.Contains(entry.Key)) {
e.Values.Remove(entry.Key);
}
}
}
OnItemDeleting(e);
if (e.Cancel) {
return;
}
_deletedItemIndex = itemIndex;
if (isBoundToDataSourceControl) {
_deleteKeys = e.Keys;
_deleteValues = e.Values;
view.Delete(e.Keys, e.Values, HandleDeleteCallback);
}
}
private bool HandleDeleteCallback(int affectedRows, Exception ex) {
ListViewDeletedEventArgs e = new ListViewDeletedEventArgs(affectedRows, ex);
e.SetKeys(_deleteKeys);
e.SetValues(_deleteValues);
OnItemDeleted(e);
_deleteKeys = null;
_deleteValues = null;
if (ex != null && !e.ExceptionHandled) {
// If there is no validator in the validation group that could make sense
// of the error, return false to proceed with standard exception handling.
// But if there is one, we want to let it display its error instead of throwing.
if (PageIsValidAfterModelException()) {
return false;
}
}
EditIndex = -1;
if (affectedRows > 0) {
// Patch up the selected index if we deleted the last item on the last page.
if ((_totalRowCount > 0) &&
(_deletedItemIndex == SelectedIndex) &&
(_deletedItemIndex + _startRowIndex == _totalRowCount)) {
SelectedIndex--;
}
}
_deletedItemIndex = -1;
RequiresDataBinding = true;
return true;
}
private void HandleEdit(int itemIndex) {
if (itemIndex < 0) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidEdit);
}
ListViewEditEventArgs e = new ListViewEditEventArgs(itemIndex);
OnItemEditing(e);
if (e.Cancel) {
return;
}
EditIndex = e.NewEditIndex;
RequiresDataBinding = true;
}
private bool HandleEvent(EventArgs e, bool causesValidation, string validationGroup) {
bool handled = false;
ResetModelValidationGroup(causesValidation, validationGroup);
ListViewCommandEventArgs dce = e as ListViewCommandEventArgs;
if (dce != null) {
OnItemCommand(dce);
handled = true;
string command = dce.CommandName;
if (String.Equals(command, DataControlCommands.SelectCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleSelect(GetItemIndex(dce.Item, (string)dce.CommandArgument));
}
else if (String.Equals(command, DataControlCommands.SortCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleSort((string)dce.CommandArgument);
}
else if (String.Equals(command, DataControlCommands.EditCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleEdit(GetItemIndex(dce.Item, (string)dce.CommandArgument));
}
else if (String.Equals(command, DataControlCommands.CancelCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleCancel(GetItemIndex(dce.Item, (string)dce.CommandArgument));
}
else if (String.Equals(command, DataControlCommands.UpdateCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleUpdate(dce.Item, GetItemIndex(dce.Item, (string)dce.CommandArgument), causesValidation);
}
else if (String.Equals(command, DataControlCommands.DeleteCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleDelete(dce.Item, GetItemIndex(dce.Item, (string)dce.CommandArgument));
}
else if (String.Equals(command, DataControlCommands.InsertCommandName, StringComparison.OrdinalIgnoreCase)) {
HandleInsert(dce.Item, causesValidation);
}
else {
handled = HandleCommand(dce.Item, GetItemIndex(dce.Item, (string)dce.CommandArgument), command);
}
}
return handled;
}
private bool HandleCommand(ListViewItem item, int itemIndex, string commandName) {
DataSourceView view = null;
if (IsBoundUsingDataSourceID) {
view = GetData();
if (view == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NullView, ID));
}
}
else {
return false;
}
if (!view.CanExecute(commandName)) {
return false;
}
ListViewDataItem dataItem = item as ListViewDataItem;
if (itemIndex < 0 && dataItem == null) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidCommand);
}
OrderedDictionary values = new OrderedDictionary();
OrderedDictionary keys = new OrderedDictionary();
if (item != null) {
ExtractItemValues(values, item, false /*includePrimaryKey*/);
}
if (DataKeys.Count > itemIndex) {
foreach (DictionaryEntry entry in DataKeys[itemIndex].Values) {
keys.Add(entry.Key, entry.Value);
if (values.Contains(entry.Key)) {
values.Remove(entry.Key);
}
}
}
view.ExecuteCommand(commandName, keys, values, HandleCommandCallback);
return true;
}
private bool HandleCommandCallback(int affectedRows, Exception ex) {
if (ex != null) {
// If there is no validator in the validation group that could make sense
// of the error, return false to proceed with standard exception handling.
// But if there is one, we want to let it display its error instead of throwing.
if (PageIsValidAfterModelException()) {
return false;
}
}
EditIndex = -1;
RequiresDataBinding = true;
return true;
}
private void HandleInsert(ListViewItem item, bool causesValidation) {
if (item != null && item.ItemType != ListViewItemType.InsertItem) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidInsert);
}
if (causesValidation && Page != null && !Page.IsValid) {
return;
}
if (item == null) {
item = _insertItem;
}
if (item == null) {
throw new InvalidOperationException(AtlasWeb.ListView_NoInsertItem);
}
DataSourceView view = null;
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
if (isBoundToDataSourceControl) {
view = GetData();
if (view == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NullView, ID));
}
}
ListViewInsertEventArgs e = new ListViewInsertEventArgs(item);
ExtractItemValues(e.Values, item, true/*includeKeys*/);
OnItemInserting(e);
if (e.Cancel) {
return;
}
if (isBoundToDataSourceControl) {
_insertValues = e.Values;
view.Insert(e.Values, HandleInsertCallback);
}
}
private bool HandleInsertCallback(int affectedRows, Exception ex) {
ListViewInsertedEventArgs e = new ListViewInsertedEventArgs(affectedRows, ex);
e.SetValues(_insertValues);
OnItemInserted(e);
_insertValues = null;
if (ex != null && !e.ExceptionHandled) {
// If there is no validator in the validation group that could make sense
// of the error, return false to proceed with standard exception handling.
// But if there is one, we want to let it display its error instead of throwing.
if (PageIsValidAfterModelException()) {
return false;
}
e.KeepInInsertMode = true;
}
if (!e.KeepInInsertMode) {
RequiresDataBinding = true;
}
return true;
}
private void HandleSelect(int itemIndex) {
if (itemIndex < 0) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidSelect);
}
ListViewSelectEventArgs e = new ListViewSelectEventArgs(itemIndex);
OnSelectedIndexChanging(e);
if (e.Cancel) {
return;
}
SelectedIndex = e.NewSelectedIndex;
OnSelectedIndexChanged(EventArgs.Empty);
RequiresDataBinding = true;
}
private void HandleSort(string sortExpression) {
SortDirection futureSortDirection = SortDirection.Ascending;
if ((SortExpressionInternal == sortExpression) && (SortDirectionInternal == SortDirection.Ascending)) {
// switch direction
futureSortDirection = SortDirection.Descending;
}
HandleSort(sortExpression, futureSortDirection);
}
private void HandleSort(string sortExpression, SortDirection sortDirection) {
ListViewSortEventArgs e = new ListViewSortEventArgs(sortExpression, sortDirection);
OnSorting(e);
if (e.Cancel) {
return;
}
if (IsBoundUsingDataSourceID) {
ClearDataKeys();
DataSourceView view = GetData();
if (view == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NullView, ID));
}
EditIndex = -1;
SortExpressionInternal = e.SortExpression;
SortDirectionInternal = e.SortDirection;
_startRowIndex = 0;
}
OnSorted(EventArgs.Empty);
RequiresDataBinding = true;
}
private void HandleUpdate(ListViewItem item, int itemIndex, bool causesValidation) {
ListViewDataItem dataItem = item as ListViewDataItem;
if (itemIndex < 0 && dataItem == null) {
throw new InvalidOperationException(AtlasWeb.ListView_InvalidUpdate);
}
if (causesValidation && Page != null && !Page.IsValid) {
return;
}
DataSourceView view = null;
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
if (isBoundToDataSourceControl) {
view = GetData();
if (view == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_NullView, ID));
}
}
ListViewUpdateEventArgs e = new ListViewUpdateEventArgs(itemIndex);
foreach (DictionaryEntry entry in BoundFieldValues) {
e.OldValues.Add(entry.Key, entry.Value);
}
if (DataKeys.Count > itemIndex) {
foreach (DictionaryEntry entry in DataKeys[itemIndex].Values) {
e.Keys.Add(entry.Key, entry.Value);
}
}
if (dataItem == null && Items.Count > itemIndex) {
dataItem = Items[itemIndex];
}
if (dataItem != null) {
ExtractItemValues(e.NewValues, dataItem, true/*includePrimaryKey*/);
}
OnItemUpdating(e);
if (e.Cancel) {
return;
}
if (isBoundToDataSourceControl) {
_updateKeys = e.Keys;
_updateOldValues = e.OldValues;
_updateNewValues = e.NewValues;
view.Update(e.Keys, e.NewValues, e.OldValues, HandleUpdateCallback);
}
}
private bool HandleUpdateCallback(int affectedRows, Exception ex) {
ListViewUpdatedEventArgs e = new ListViewUpdatedEventArgs(affectedRows, ex);
e.SetKeys(_updateKeys);
e.SetOldValues(_updateOldValues);
e.SetNewValues(_updateNewValues);
OnItemUpdated(e);
_updateKeys = null;
_updateOldValues = null;
_updateNewValues = null;
if (ex != null && !e.ExceptionHandled) {
// If there is no validator in the validation group that could make sense
// of the error, return false to proceed with standard exception handling.
// But if there is one, we want to let it display its error instead of throwing.
if (PageIsValidAfterModelException()) {
return false;
}
e.KeepInEditMode = true;
}
// We need to databind here event if no records were affected because
// changing the EditIndex required a rebind. The event args give the programmer
// the chance to cancel the bind so the edits aren't lost.
if (!e.KeepInEditMode) {
EditIndex = -1;
RequiresDataBinding = true;
}
return true;
}
public virtual void InsertNewItem(bool causesValidation) {
ResetModelValidationGroup(causesValidation, String.Empty);
HandleInsert(null, causesValidation);
}
protected virtual void InstantiateEmptyDataTemplate(Control container) {
if (_emptyDataTemplate != null) {
_emptyDataTemplate.InstantiateIn(container);
}
}
protected virtual void InstantiateEmptyItemTemplate(Control container) {
if (_emptyItemTemplate != null) {
_emptyItemTemplate.InstantiateIn(container);
}
}
protected virtual void InstantiateGroupTemplate(Control container) {
if (_groupTemplate != null) {
_groupTemplate.InstantiateIn(container);
}
}
protected virtual void InstantiateGroupSeparatorTemplate(Control container) {
if (_groupSeparatorTemplate != null) {
_groupSeparatorTemplate.InstantiateIn(container);
}
}
protected virtual void InstantiateInsertItemTemplate(Control container) {
if (_insertItemTemplate != null) {
_insertItemTemplate.InstantiateIn(container);
}
}
protected virtual void InstantiateItemSeparatorTemplate(Control container) {
if (_itemSeparatorTemplate != null) {
_itemSeparatorTemplate.InstantiateIn(container);
}
}
protected virtual void InstantiateItemTemplate(Control container, int displayIndex) {
ITemplate contentTemplate = _itemTemplate;
if (contentTemplate == null) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_ItemTemplateRequired, ID));
}
if (displayIndex % 2 == 1 && _alternatingItemTemplate != null) {
contentTemplate = _alternatingItemTemplate;
}
if (displayIndex == _selectedIndex && _selectedItemTemplate != null) {
contentTemplate = _selectedItemTemplate;
}
if (displayIndex == _editIndex && _editItemTemplate != null) {
contentTemplate = _editItemTemplate;
}
contentTemplate.InstantiateIn(container);
}
protected internal override void LoadControlState(object savedState) {
// Any properties that could have been set in the persistance need to be
// restored to their defaults if they're not in ControlState, or they will
// be restored to their persisted state instead of their empty state.
_startRowIndex = 0;
_maximumRows = -1;
_editIndex = -1;
_selectedIndex = -1;
_groupItemCount = 1;
_sortExpression = String.Empty;
_sortDirection = SortDirection.Ascending;
_dataKeyNames = new string[0];
object[] state = savedState as object[];
if (state != null) {
base.LoadControlState(state[0]);
if (state[1] != null) {
_editIndex = (int)state[1];
}
if (state[2] != null) {
_selectedIndex = (int)state[2];
}
if (state[3] != null) {
_groupItemCount = (int)state[3];
}
if (state[4] != null) {
_sortExpression = (string)state[4];
}
if (state[5] != null) {
_sortDirection = (SortDirection)state[5];
}
if (state[6] != null) {
_dataKeyNames = (string[])state[6];
}
if (state[7] != null) {
LoadDataKeysState(state[7]);
}
if (state[8] != null) {
_totalRowCount = (int)state[8];
}
if (state[9] != null) {
if ((_dataKeyNames != null) && (_dataKeyNames.Length > 0)) {
_persistedDataKey = new DataKey(new OrderedDictionary(_dataKeyNames.Length), _dataKeyNames);
((IStateManager)_persistedDataKey).LoadViewState(state[9]);
}
}
if (state[10] != null) {
_clientIDRowSuffix = (string[])state[10];
}
if (state[11] != null) {
LoadClientIDRowSuffixDataKeysState(state[11]);
}
if (state[12] != null) {
_startRowIndex = (int)state[12];
}
if (state[13] != null) {
_maximumRows = (int)state[13];
}
}
else {
base.LoadControlState(null);
}
// DataPager handles the TotalRowCountAvailable event in order to create its pager fields. Normally this
// is fired from CreateChildControls, but when ViewState is disabled this is not getting called until after
// postback data has been handled. In this case the event will be fired using the control count from the
// last request so that the pager fields can be initialized.
if (!IsViewStateEnabled) {
OnTotalRowCountAvailable(new PageEventArgs(_startRowIndex, _maximumRows, _totalRowCount));
}
}
private void LoadDataKeysState(object state) {
if (state != null) {
object[] dataKeysState = (object[])state;
string[] dataKeyNames = DataKeyNamesInternal;
int dataKeyNamesLength = dataKeyNames.Length;
ClearDataKeys();
for (int i = 0; i < dataKeysState.Length; i++) {
DataKeysArrayList.Add(new DataKey(new OrderedDictionary(dataKeyNamesLength), dataKeyNames));
((IStateManager)DataKeysArrayList[i]).LoadViewState(dataKeysState[i]);
}
}
}
protected override void LoadViewState(object savedState) {
if (savedState != null) {
object[] state = (object[])savedState;
base.LoadViewState(state[0]);
if (state[1] != null) {
OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)BoundFieldValues, (ArrayList)state[1]);
}
}
else {
base.LoadViewState(savedState);
}
}
private void LoadClientIDRowSuffixDataKeysState(object state) {
if (state != null) {
object[] ClientIDRowSuffixDataKeysState = (object[])state;
string[] ClientIDRowSuffix = ClientIDRowSuffixInternal;
int ClientIDRowSuffixLength = ClientIDRowSuffix.Length;
_clientIDRowSuffixArrayList = null;
for (int i = 0; i < ClientIDRowSuffixDataKeysState.Length; i++) {
ClientIDRowSuffixArrayList.Add(new DataKey(new OrderedDictionary(ClientIDRowSuffixLength), ClientIDRowSuffix));
((IStateManager)ClientIDRowSuffixArrayList[i]).LoadViewState(ClientIDRowSuffixDataKeysState[i]);
}
}
}
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "1#")]
protected override bool OnBubbleEvent(object source, EventArgs e) {
bool causesValidation = false;
string validationGroup = String.Empty;
ListViewCommandEventArgs commandEventArgs = e as ListViewCommandEventArgs;
// todo: rethink this. Should everything in the layout template be bubbled
// up as a ListViewCommand?
if (commandEventArgs == null && e is CommandEventArgs) {
// Use a new EmptyItem ListViewItem here so when HandleEvent tries to parse out the data item index,
// the user gets a nice message about how this button should be in a data item.
commandEventArgs = new ListViewCommandEventArgs(new ListViewItem(ListViewItemType.EmptyItem), source, (CommandEventArgs)e);
}
if (commandEventArgs != null) {
IButtonControl button = commandEventArgs.CommandSource as IButtonControl;
if (button != null) {
causesValidation = button.CausesValidation;
validationGroup = button.ValidationGroup;
}
}
return HandleEvent(commandEventArgs, causesValidation, validationGroup);
}
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected internal override void OnInit(EventArgs e) {
base.OnInit(e);
if (Page != null) {
if (DataKeyNames.Length > 0) {
Page.RegisterRequiresViewStateEncryption();
}
Page.RegisterRequiresControlState(this);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemCanceling(ListViewCancelEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemCanceling];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "ItemCanceling"));
}
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemCommand(ListViewCommandEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemCommand];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemCreated(ListViewItemEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemCreated];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemDataBound(ListViewItemEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemDataBound];
if (handler != null) {
handler(this, e);
}
// EventWizardListItemDataBound is a key for an internal event declared on IWizardSideBarListControl, which is
// an interface that is meant to provide a facade to make ListView and DataList look the same. This handler
// is meant to abstract away the differences between each controls ItemDataBound events.
var wizardListHandler = (EventHandler)Events[EventWizardListItemDataBound];
if (wizardListHandler != null) {
var item = e.Item;
var wizardListEventArgs = new WizardSideBarListControlItemEventArgs(new WizardSideBarListControlItem(item.DataItem, ListItemType.Item, item.DataItemIndex, item));
wizardListHandler(this, wizardListEventArgs);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemDeleted(ListViewDeletedEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemDeleted];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemDeleting(ListViewDeleteEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemDeleting];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "ItemDeleting"));
}
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemEditing(ListViewEditEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemEditing];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "ItemEditing"));
}
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemInserted(ListViewInsertedEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemInserted];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemInserting(ListViewInsertEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemInserting];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "ItemInserting"));
}
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemUpdated(ListViewUpdatedEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemUpdated];
if (handler != null) handler(this, e);
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnItemUpdating(ListViewUpdateEventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemUpdating];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "ItemUpdating"));
}
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnLayoutCreated(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventLayoutCreated];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnPagePropertiesChanged(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventPagePropertiesChanged];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnPagePropertiesChanging(PagePropertiesChangingEventArgs e) {
EventHandler handler = (EventHandler)Events[EventPagePropertiesChanging];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnTotalRowCountAvailable(PageEventArgs e) {
EventHandler handler = (EventHandler)Events[EventTotalRowCountAvailable];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnSelectedIndexChanged(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventSelectedIndexChanged];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnSelectedIndexChanging(ListViewSelectEventArgs e) {
EventHandler handler = (EventHandler)Events[EventSelectedIndexChanging];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "SelectedIndexChanging"));
}
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnSorted(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventSorted];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnSorting(ListViewSortEventArgs e) {
EventHandler handler = (EventHandler)Events[EventSorting];
if (handler != null) {
handler(this, e);
}
else {
if (IsBoundUsingDataSourceID == false && e.Cancel == false) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_UnhandledEvent, ID, "Sorting"));
}
}
}
private bool PageIsValidAfterModelException() {
if (_modelValidationGroup == null) {
return true;
}
Page.Validate(_modelValidationGroup);
return Page.IsValid;
}
///
/// Overriden by DataBoundControl to use its properties to determine the real
/// data source that the control should bind to. It then clears the existing
/// control hierarchy, and calls createChildControls to create a new control
/// hierarchy based on the resolved data source.
/// The implementation resolves various data source related properties to
/// arrive at the appropriate IEnumerable implementation to use as the real
/// data source.
/// When resolving data sources, the DataSourceControlID takes highest precedence.
/// In this mode, DataMember is used to access the appropriate list from the
/// DataControl.
/// If DataSourceControlID is not set, the value of the DataSource property is used.
/// In this second alternative, DataMember is used to extract the appropriate
/// list if the control has been handed an IListSource as a data source.
///
protected internal override void PerformDataBinding(IEnumerable data) {
base.PerformDataBinding(data);
TrackViewState();
int controlCount = CreateChildControls(data, true);
ChildControlsCreated = true;
ViewState[ItemCountViewStateKey] = controlCount;
int editIndex = EditIndex;
if (IsBoundUsingDataSourceID && editIndex != -1 && editIndex < Items.Count && IsViewStateEnabled) {
BoundFieldValues.Clear();
ExtractItemValues(BoundFieldValues, Items[editIndex], false/*includePrimaryKey*/);
}
if (EnablePersistedSelection) {
string[] keyNames = DataKeyNamesInternal;
//we can't have persisted selection without having at least one key name
if ((keyNames == null) || (keyNames.Length == 0)) {
throw new InvalidOperationException(AtlasWeb.ListView_PersistedSelectionRequiresDataKeysNames);
}
}
}
protected override void PerformSelect() {
if (_performingSelect) {
// Guard against databinding twice if we're currently databinding.
// This happens when the ListView is nested within a databound control, and the call
// To EnsureLayoutTemplate triggers a recursive DataBind.
return;
}
try {
_performingSelect = true;
// If there is a DataPager in the layout template, we need the ListView's paging properties
// to be set before we go to the datasource
EnsureLayoutTemplate();
if (DesignMode) {
// Try to find a pager that will control the paging on this control.
// In design mode, an embedded pager will not have a designer but will
// be the runtime control itself. We want the max rows so the ListView
// renders with the right page size.
DataPager pager = FindDataPager(this);
if (pager != null) {
_maximumRows = pager.PageSize;
}
}
base.PerformSelect();
}
finally {
_performingSelect = false;
}
}
protected virtual void RemoveItems() {
if (_groupTemplate != null) {
// If we're in grouped mode, delete all the items created in CreateItemsInGroups().
if (_groupsItemCreatedCount > 0) {
for (int i = 0; i < _groupsItemCreatedCount; i++) {
_groupsGroupPlaceholderContainer.Controls.RemoveAt(_groupsOriginalIndexOfGroupPlaceholderInContainer);
}
_groupsItemCreatedCount = 0;
}
}
else {
// If we're not in grouped mode, delete all the items
// created in CreateItemsWithoutGroups().
if (_noGroupsItemCreatedCount > 0) {
for (int i = 0; i < _noGroupsItemCreatedCount; i++) {
_noGroupsItemPlaceholderContainer.Controls.RemoveAt(_noGroupsOriginalIndexOfItemPlaceholderInContainer);
}
_noGroupsItemCreatedCount = 0;
}
}
_autoIDIndex = 0;
}
protected internal override void Render(HtmlTextWriter writer) {
// Render only the contents. We don't want a rendered span tag around the control.
RenderContents(writer);
}
private void ResetModelValidationGroup(bool causesValidation, string validationGroup) {
_modelValidationGroup = null;
if (causesValidation) {
Page.Validate(validationGroup);
if (EnableModelValidation) {
_modelValidationGroup = validationGroup;
}
}
}
///
/// Saves the control state for those properties that should persist across postbacks
/// even when EnableViewState=false.
///
protected internal override object SaveControlState() {
object baseState = base.SaveControlState();
if (baseState != null ||
_startRowIndex > 0 ||
_maximumRows != -1 ||
_editIndex != -1 ||
_selectedIndex != -1 ||
_groupItemCount != 1 ||
(_sortExpression != null && _sortExpression.Length != 0) ||
_sortDirection != SortDirection.Ascending ||
_totalRowCount != -1 ||
(_dataKeyNames != null && _dataKeyNames.Length != 0) ||
(_dataKeysArrayList != null && _dataKeysArrayList.Count > 0)) {
object[] state = new object[14];
state[0] = baseState;
state[1] = (_editIndex == -1) ? null : (object)_editIndex;
state[2] = (_selectedIndex == -1) ? null : (object)_selectedIndex;
state[3] = (_groupItemCount == 1) ? null : (object)_groupItemCount;
state[4] = (_sortExpression == null || _sortExpression.Length == 0) ? null : (object)_sortExpression;
state[5] = (_sortDirection == SortDirection.Ascending) ? null : (object)((int)_sortDirection);
state[6] = (_dataKeyNames == null || _dataKeyNames.Length == 0) ? null : (object)_dataKeyNames;
state[7] = SaveDataKeysState();
state[8] = (_totalRowCount == -1) ? null : (object)_totalRowCount;
state[9] = (_persistedDataKey == null) ? null :
((IStateManager)_persistedDataKey).SaveViewState();
state[10] = (_clientIDRowSuffix == null || _clientIDRowSuffix.Length == 0) ? null : (object)_clientIDRowSuffix;
state[11] = SaveClientIDRowSuffixDataKeysState();
state[12] = _startRowIndex;
state[13] = _maximumRows;
return state;
}
return true; // return a dummy that ensures LoadControlState gets called but minimizes persisted size.
}
private object SaveDataKeysState() {
object keyState = new object();
int dataKeyCount = 0;
if (_dataKeysArrayList != null && _dataKeysArrayList.Count > 0) {
dataKeyCount = _dataKeysArrayList.Count;
keyState = new object[dataKeyCount];
for (int i = 0; i < dataKeyCount; i++) {
((object[])keyState)[i] = ((IStateManager)_dataKeysArrayList[i]).SaveViewState();
}
}
return (_dataKeysArrayList == null || dataKeyCount == 0) ? null : keyState;
}
protected override object SaveViewState() {
object baseState = base.SaveViewState();
object boundFieldValuesState = (_boundFieldValues != null) ? OrderedDictionaryStateHelper.SaveViewState(_boundFieldValues) : null;
object[] state = new object[2];
state[0] = baseState;
state[1] = boundFieldValuesState;
return state;
}
private object SaveClientIDRowSuffixDataKeysState() {
object keyState = new object();
int dataKeyCount = 0;
if (_clientIDRowSuffixArrayList != null && _clientIDRowSuffixArrayList.Count > 0) {
dataKeyCount = _clientIDRowSuffixArrayList.Count;
keyState = new object[dataKeyCount];
for (int i = 0; i < dataKeyCount; i++) {
((object[])keyState)[i] = ((IStateManager)_clientIDRowSuffixArrayList[i]).SaveViewState();
}
}
return (_clientIDRowSuffixArrayList == null || dataKeyCount == 0) ? null : keyState;
}
private void SelectCallback(IEnumerable data) {
// The data source should have thrown. If we're here, it didn't. We'll throw for it
// with a generic message.
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.ListView_DataSourceDoesntSupportPaging, DataSourceID));
}
private void SetRequiresDataBindingIfInitialized() {
if (Initialized) {
RequiresDataBinding = true;
}
}
public virtual void Sort(string sortExpression, SortDirection sortDirection) {
HandleSort(sortExpression, sortDirection);
}
public virtual void UpdateItem(int itemIndex, bool causesValidation) {
ResetModelValidationGroup(causesValidation, String.Empty);
HandleUpdate(null, itemIndex, causesValidation);
}
#region IPageableItemContainer
int IPageableItemContainer.StartRowIndex {
get {
return StartRowIndex;
}
}
// Overridable version
protected virtual int StartRowIndex {
get {
return _startRowIndex;
}
}
int IPageableItemContainer.MaximumRows {
get {
return MaximumRows;
}
}
// Overridable version
protected virtual int MaximumRows {
get {
return _maximumRows;
}
}
void IPageableItemContainer.SetPageProperties(int startRowIndex, int maximumRows, bool databind) {
SetPageProperties(startRowIndex, maximumRows, databind);
}
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
Justification = "A property already exists. This method does additional work.")]
public void SelectItem(int rowIndex) {
HandleSelect(rowIndex);
}
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
Justification = "A property already exists. This method does additional work.")]
public void SetEditItem(int rowIndex) {
HandleEdit(rowIndex);
}
// Overridable version
[SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "databind",
Justification = "Cannot change to 'dataBind' as would break binary compatibility with legacy code.")]
protected virtual void SetPageProperties(int startRowIndex, int maximumRows, bool databind) {
if (maximumRows < 1) {
throw new ArgumentOutOfRangeException("maximumRows");
}
if (startRowIndex < 0) {
throw new ArgumentOutOfRangeException("startRowIndex");
}
if (_startRowIndex != startRowIndex || _maximumRows != maximumRows) {
PagePropertiesChangingEventArgs args = new PagePropertiesChangingEventArgs(startRowIndex, maximumRows);
if (databind) {
// This event is cancellable, and its properties aren't settable, because changing them would
// create a strange disconnect between the pager and the ListView. You have to set
// these properties on the pager if you want to change them. This is a notification event.
OnPagePropertiesChanging(args);
}
_startRowIndex = args.StartRowIndex;
_maximumRows = args.MaximumRows;
if (databind) {
OnPagePropertiesChanged(EventArgs.Empty);
}
}
if (databind) {
RequiresDataBinding = true;
}
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes",
Justification = "Unlikely that a derived type would re-implement this event.")]
event EventHandler IPageableItemContainer.TotalRowCountAvailable {
add {
Events.AddHandler(EventTotalRowCountAvailable, value);
}
remove {
Events.RemoveHandler(EventTotalRowCountAvailable, value);
}
}
#endregion IPageableItemContainer
#region IPersistedSelector implementation
DataKey IPersistedSelector.DataKey {
get {
return SelectedPersistedDataKey;
}
set {
SelectedPersistedDataKey = value;
}
}
#endregion
#region IDataKeysControl implementation
DataKeyArray IDataKeysControl.ClientIDRowSuffixDataKeys {
get {
return ClientIDRowSuffixDataKeys;
}
}
#endregion
#region IDataBoundListControl implementation
DataKeyArray IDataBoundListControl.DataKeys {
get {
return DataKeys;
}
}
DataKey IDataBoundListControl.SelectedDataKey {
get {
return SelectedDataKey;
}
}
int IDataBoundListControl.SelectedIndex {
get {
return SelectedIndex;
}
set {
SelectedIndex = value;
}
}
string[] IDataBoundListControl.ClientIDRowSuffix {
get {
return ClientIDRowSuffix;
}
set {
ClientIDRowSuffix = value;
}
}
bool IDataBoundListControl.EnablePersistedSelection {
get {
return EnablePersistedSelection;
}
set {
EnablePersistedSelection = value;
}
}
string IDataBoundControl.DataSourceID {
get {
return DataSourceID;
}
set {
DataSourceID = value;
}
}
IDataSource IDataBoundControl.DataSourceObject {
get {
return DataSourceObject;
}
}
object IDataBoundControl.DataSource {
get {
return DataSource;
}
set {
DataSource = value;
}
}
string[] IDataBoundControl.DataKeyNames {
get {
return DataKeyNames;
}
set {
DataKeyNames = value;
}
}
string IDataBoundControl.DataMember {
get {
return DataMember;
}
set {
DataMember = value;
}
}
#endregion
#region IWizardSideBarListControl implementation
IEnumerable IWizardSideBarListControl.Items {
get { return Items; }
}
event CommandEventHandler IWizardSideBarListControl.ItemCommand {
add {
ItemCommand += new EventHandler(value);
}
remove {
ItemCommand -= new EventHandler(value);
}
}
event EventHandler IWizardSideBarListControl.ItemDataBound {
add {
Events.AddHandler(EventWizardListItemDataBound, value);
}
remove {
Events.RemoveHandler(EventWizardListItemDataBound, value);
}
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AesCryptoServiceProvider.cs
- TokenBasedSetEnumerator.cs
- PersonalizationAdministration.cs
- HttpModuleCollection.cs
- ClaimComparer.cs
- StateMachineWorkflow.cs
- fixedPageContentExtractor.cs
- InputScopeManager.cs
- BidOverLoads.cs
- EllipticalNodeOperations.cs
- TemplatePropertyEntry.cs
- StreamWriter.cs
- DataContract.cs
- DataSetUtil.cs
- SqlInfoMessageEvent.cs
- Encoding.cs
- Font.cs
- EventLogLink.cs
- ModuleConfigurationInfo.cs
- CurrencyWrapper.cs
- SqlRewriteScalarSubqueries.cs
- StructuralObject.cs
- IsolatedStorageException.cs
- SamlAuthorizationDecisionStatement.cs
- FrameworkContentElement.cs
- ConnectionManagementElement.cs
- Size3D.cs
- AncestorChangedEventArgs.cs
- RelatedCurrencyManager.cs
- CellQuery.cs
- FrameworkPropertyMetadata.cs
- XmlTextEncoder.cs
- ProfessionalColors.cs
- WebBrowserHelper.cs
- ExpressionBuilder.cs
- SqlClientPermission.cs
- ObjectListField.cs
- RectConverter.cs
- SchemaElementDecl.cs
- CellQuery.cs
- _ProxyChain.cs
- TreeViewItem.cs
- Span.cs
- CurrentChangedEventManager.cs
- BindingSource.cs
- DataList.cs
- VisualTreeUtils.cs
- SecurityHelper.cs
- Object.cs
- BrowserCapabilitiesFactoryBase.cs
- UnsafeNativeMethods.cs
- ValidatingCollection.cs
- VisualCollection.cs
- AccessViolationException.cs
- AdCreatedEventArgs.cs
- ExpressionDumper.cs
- ToolStripGrip.cs
- DayRenderEvent.cs
- panel.cs
- AddInDeploymentState.cs
- ActivityBindForm.cs
- MergeFilterQuery.cs
- ServiceHttpModule.cs
- SqlInfoMessageEvent.cs
- CqlParserHelpers.cs
- SearchExpression.cs
- LinqDataSourceSelectEventArgs.cs
- StorageEntityTypeMapping.cs
- QilInvoke.cs
- DecoderFallbackWithFailureFlag.cs
- HtmlSelectionListAdapter.cs
- TreeNode.cs
- WeakReference.cs
- DesignerDeviceConfig.cs
- PerformanceCounterPermissionAttribute.cs
- CheckBoxFlatAdapter.cs
- VisualTarget.cs
- TimeManager.cs
- SqlGenericUtil.cs
- PingReply.cs
- DynamicFilterExpression.cs
- CommandLibraryHelper.cs
- AlternateViewCollection.cs
- Variant.cs
- ObjectAnimationUsingKeyFrames.cs
- SiteMapNodeItemEventArgs.cs
- CryptoKeySecurity.cs
- TreeBuilderBamlTranslator.cs
- _BasicClient.cs
- SqlReorderer.cs
- SqlBulkCopyColumnMapping.cs
- TableCellCollection.cs
- KeyValueConfigurationCollection.cs
- Mutex.cs
- WebZone.cs
- Int32Rect.cs
- TextEmbeddedObject.cs
- GregorianCalendar.cs
- MultiBindingExpression.cs
- DataGridLinkButton.cs