Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / FormView.cs / 1305376 / FormView.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Web.UI.WebControls.Adapters;
using System.Web.Util;
///
///
/// Displays a data record from a data source in a table layout. The data source
/// is any object that implements IEnumerable or IListSource, which includes ADO.NET data,
/// arrays, ArrayLists, DataSourceControl, etc.
///
///
[
Designer("System.Web.UI.Design.WebControls.FormViewDesigner, " + AssemblyRef.SystemDesign),
ControlValueProperty("SelectedValue"),
DefaultEvent("PageIndexChanging"),
SupportsEventValidation
]
[DataKeyProperty("DataKey")]
public class FormView : CompositeDataBoundControl, IDataItemContainer, IPostBackEventHandler,
IPostBackContainer, IDataBoundItemControl, IRenderOuterTableControl {
private static readonly object EventPageIndexChanged = new object();
private static readonly object EventPageIndexChanging = new object();
private static readonly object EventItemCommand = new object();
private static readonly object EventItemCreated = new object();
private static readonly object EventItemDeleted = new object();
private static readonly object EventItemDeleting = new object();
private static readonly object EventItemInserting = new object();
private static readonly object EventItemInserted = new object();
private static readonly object EventItemUpdating = new object();
private static readonly object EventItemUpdated = new object();
private static readonly object EventModeChanged = new object();
private static readonly object EventModeChanging = new object();
private ITemplate _itemTemplate;
private ITemplate _editItemTemplate;
private ITemplate _insertItemTemplate;
private ITemplate _headerTemplate;
private ITemplate _footerTemplate;
private ITemplate _pagerTemplate;
private ITemplate _emptyDataTemplate;
private TableItemStyle _rowStyle;
private TableItemStyle _headerStyle;
private TableItemStyle _footerStyle;
private TableItemStyle _editRowStyle;
private TableItemStyle _insertRowStyle;
private TableItemStyle _emptyDataRowStyle;
private FormViewRow _bottomPagerRow;
private FormViewRow _footerRow;
private FormViewRow _headerRow;
private FormViewRow _topPagerRow;
private FormViewRow _row;
private TableItemStyle _pagerStyle;
private PagerSettings _pagerSettings;
private int _pageCount;
private object _dataItem;
private int _dataItemIndex;
private OrderedDictionary _boundFieldValues;
private DataKey _dataKey;
private OrderedDictionary _keyTable;
private string[] _dataKeyNames;
private int _pageIndex;
private FormViewMode _defaultMode = FormViewMode.ReadOnly;
private FormViewMode _mode;
private bool _modeSet;
private bool _useServerPaging;
private string _modelValidationGroup;
private IOrderedDictionary _deleteKeys;
private IOrderedDictionary _deleteValues;
private IOrderedDictionary _insertValues;
private IOrderedDictionary _updateKeys;
private IOrderedDictionary _updateOldValues;
private IOrderedDictionary _updateNewValues;
///
/// Gets or sets a value that indicates whether paging is allowed.
///
[
WebCategory("Paging"),
DefaultValue(false),
WebSysDescription(SR.FormView_AllowPaging)
]
public virtual bool AllowPaging {
get {
object o = ViewState["AllowPaging"];
if (o != null)
return (bool)o;
return false;
}
set {
bool oldValue = AllowPaging;
if (value != oldValue) {
ViewState["AllowPaging"] = value;
if (Initialized) {
RequiresDataBinding = true;
}
}
}
}
///
/// Gets or sets the URL of an image to display in the
/// background of the
///
[
WebCategory("Appearance"),
DefaultValue(""),
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
UrlProperty(),
WebSysDescription(SR.WebControl_BackImageUrl)
]
public virtual string BackImageUrl {
get {
if (ControlStyleCreated == false) {
return String.Empty;
}
return ((TableStyle)ControlStyle).BackImageUrl;
}
set {
((TableStyle)ControlStyle).BackImageUrl = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public virtual FormViewRow BottomPagerRow {
get {
if (_bottomPagerRow == null) {
EnsureChildControls();
}
return _bottomPagerRow;
}
}
private IOrderedDictionary BoundFieldValues {
get {
if (_boundFieldValues == null) {
int capacity = 25;
_boundFieldValues = new OrderedDictionary(capacity);
}
return _boundFieldValues;
}
}
[
Localizable(true),
DefaultValue(""),
WebCategory("Accessibility"),
WebSysDescription(SR.DataControls_Caption)
]
public virtual string Caption {
get {
string s = (string)ViewState["Caption"];
return (s != null) ? s : String.Empty;
}
set {
ViewState["Caption"] = value;
}
}
[
DefaultValue(TableCaptionAlign.NotSet),
WebCategory("Accessibility"),
WebSysDescription(SR.WebControl_CaptionAlign)
]
public virtual TableCaptionAlign CaptionAlign {
get {
object o = ViewState["CaptionAlign"];
return (o != null) ? (TableCaptionAlign)o : TableCaptionAlign.NotSet;
}
set {
if ((value < TableCaptionAlign.NotSet) ||
(value > TableCaptionAlign.Right)) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["CaptionAlign"] = value;
}
}
///
/// Indicates the amount of space between cells.
///
[
WebCategory("Layout"),
DefaultValue(-1),
WebSysDescription(SR.FormView_CellPadding)
]
public virtual int CellPadding {
get {
if (ControlStyleCreated == false) {
return -1;
}
return ((TableStyle)ControlStyle).CellPadding;
}
set {
((TableStyle)ControlStyle).CellPadding = value;
}
}
///
/// Gets or sets the amount of space between the contents of
/// a cell and the cell's border.
///
[
WebCategory("Layout"),
DefaultValue(0),
WebSysDescription(SR.FormView_CellSpacing)
]
public virtual int CellSpacing {
get {
if (ControlStyleCreated == false) {
return 0;
}
return ((TableStyle)ControlStyle).CellSpacing;
}
set {
((TableStyle)ControlStyle).CellSpacing = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public FormViewMode CurrentMode {
get {
return Mode;
}
}
// implement this publicly so DataBinder.Eval(container.DataItem, "x") still works.
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public virtual object DataItem {
get {
if (CurrentMode == FormViewMode.Insert) {
return null;
}
return _dataItem;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public int DataItemCount {
get {
return PageCount;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public virtual int DataItemIndex {
get {
if (CurrentMode == FormViewMode.Insert) {
return -1;
}
return _dataItemIndex;
}
}
[
DefaultValue(null),
Editor("System.Web.UI.Design.WebControls.DataFieldEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
TypeConverterAttribute(typeof(StringArrayConverter)),
WebCategory("Data"),
WebSysDescription(SR.DataControls_DataKeyNames)
]
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;
}
_keyTable = null;
if (Initialized) {
RequiresDataBinding = true;
}
}
}
}
// This version doesn't clone the array
private string[] DataKeyNamesInternal {
get {
object o = _dataKeyNames;
if (o != null) {
return (string[])o;
}
return new string[0];
}
}
///
///
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
WebSysDescription(SR.FormView_DataKey)
]
public virtual DataKey DataKey {
get {
if (_dataKey == null) {
_dataKey = new DataKey(KeyTable);
}
return _dataKey;
}
}
[
WebCategory("Behavior"),
DefaultValue(FormViewMode.ReadOnly),
WebSysDescription(SR.View_DefaultMode)
]
public virtual FormViewMode DefaultMode {
get {
return _defaultMode;
}
set {
if (value < FormViewMode.ReadOnly || value > FormViewMode.Insert) {
throw new ArgumentOutOfRangeException("value");
}
_defaultMode = value;
}
}
///
/// Indicates the template to use for an item set in edit mode within the FormView.
/// This template is also used for Insert if no InsertItemTemplate is defined.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
WebSysDescription(SR.FormView_EditItemTemplate)
]
public virtual ITemplate EditItemTemplate {
get {
return _editItemTemplate;
}
set {
_editItemTemplate = value;
}
}
///
/// Indicates the style properties of each row when in edit mode.
///
[
WebCategory("Styles"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.View_EditRowStyle)
]
public TableItemStyle EditRowStyle {
get {
if (_editRowStyle == null) {
_editRowStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_editRowStyle).TrackViewState();
}
return _editRowStyle;
}
}
///
/// Indicates the style properties of null rows.
///
[
WebCategory("Styles"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.View_EmptyDataRowStyle)
]
public TableItemStyle EmptyDataRowStyle {
get {
if (_emptyDataRowStyle == null) {
_emptyDataRowStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_emptyDataRowStyle).TrackViewState();
}
return _emptyDataRowStyle;
}
}
///
/// Indicates the template to use when no records are returned from the datasource within the FormView.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView)),
WebSysDescription(SR.View_EmptyDataTemplate)
]
public virtual ITemplate EmptyDataTemplate {
get {
return _emptyDataTemplate;
}
set {
_emptyDataTemplate = value;
}
}
///
/// The header text displayed if no EmptyDataTemplate is defined.
///
[
Localizable(true),
WebCategory("Appearance"),
DefaultValue(""),
WebSysDescription(SR.View_EmptyDataText),
]
public virtual String EmptyDataText {
get {
object o = ViewState["EmptyDataText"];
if (o != null) {
return (string)o;
}
return String.Empty;
}
set {
ViewState["EmptyDataText"] = value;
}
}
[
WebCategory("Behavior"),
DefaultValue(true),
WebSysDescription(SR.DataBoundControl_EnableModelValidation)
]
public virtual bool EnableModelValidation {
get {
object o = ViewState["EnableModelValidation"];
if (o != null) {
return (bool)o;
}
return true;
}
set {
ViewState["EnableModelValidation"] = value;
}
}
[
WebCategory("Layout"),
DefaultValue(true),
WebSysDescription(SR.FormView_RenderOuterTable),
SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
Justification = "Interface denotes existence of property, not used for security.")
]
public virtual bool RenderOuterTable {
get {
object o = ViewState["RenderOuterTable"];
return (o != null) ? (bool)o : true;
}
set {
ViewState["RenderOuterTable"] = value;
}
}
private int FirstDisplayedPageIndex {
get {
object o = ViewState["FirstDisplayedPageIndex"];
if (o != null) {
return (int)o;
}
return -1;
}
set {
ViewState["FirstDisplayedPageIndex"] = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public virtual FormViewRow FooterRow {
get {
if (_footerRow == null) {
EnsureChildControls();
}
return _footerRow;
}
}
///
/// Indicates the style properties of the footer row.
///
[
WebCategory("Styles"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.FormView_FooterStyle)
]
public TableItemStyle FooterStyle {
get {
if (_footerStyle == null) {
_footerStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_footerStyle).TrackViewState();
}
return _footerStyle;
}
}
///
/// Indicates the template to use for a footer item within the FormView.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView)),
WebSysDescription(SR.FormView_FooterTemplate)
]
public virtual ITemplate FooterTemplate {
get {
return _footerTemplate;
}
set {
_footerTemplate = value;
}
}
///
/// The header text displayed if no FooterTemplate is defined.
///
[
Localizable(true),
WebCategory("Appearance"),
DefaultValue(""),
WebSysDescription(SR.View_FooterText),
]
public virtual String FooterText {
get {
object o = ViewState["FooterText"];
if (o != null) {
return (string)o;
}
return String.Empty;
}
set {
ViewState["FooterText"] = value;
}
}
///
/// Gets or sets a value that specifies the grid line style.
///
[
WebCategory("Appearance"),
DefaultValue(GridLines.None),
WebSysDescription(SR.DataControls_GridLines)
]
public virtual GridLines GridLines {
get {
if (ControlStyleCreated == false) {
return GridLines.None;
}
return ((TableStyle)ControlStyle).GridLines;
}
set {
((TableStyle)ControlStyle).GridLines = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public virtual FormViewRow HeaderRow {
get {
if (_headerRow == null) {
EnsureChildControls();
}
return _headerRow;
}
}
///
/// Indicates the style properties of the header row.
///
[
WebCategory("Styles"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.WebControl_HeaderStyle)
]
public TableItemStyle HeaderStyle {
get {
if (_headerStyle == null) {
_headerStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_headerStyle).TrackViewState();
}
return _headerStyle;
}
}
///
/// Indicates the template to use for a header item within the FormView.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView)),
WebSysDescription(SR.WebControl_HeaderTemplate)
]
public virtual ITemplate HeaderTemplate {
get {
return _headerTemplate;
}
set {
_headerTemplate = value;
}
}
///
/// The header text displayed if no HeaderTemplate is defined.
///
[
Localizable(true),
WebCategory("Appearance"),
DefaultValue(""),
WebSysDescription(SR.View_HeaderText),
]
public virtual String HeaderText {
get {
object o = ViewState["HeaderText"];
if (o != null) {
return (string)o;
}
return String.Empty;
}
set {
ViewState["HeaderText"] = value;
}
}
///
/// Gets or sets a value that specifies the alignment of a rows with respect
/// surrounding text.
///
[
Category("Layout"),
DefaultValue(HorizontalAlign.NotSet),
WebSysDescription(SR.WebControl_HorizontalAlign)
]
public virtual HorizontalAlign HorizontalAlign {
get {
if (ControlStyleCreated == false) {
return HorizontalAlign.NotSet;
}
return ((TableStyle)ControlStyle).HorizontalAlign;
}
set {
((TableStyle)ControlStyle).HorizontalAlign = value;
}
}
///
/// Indicates the template to use for an item set in insert mode within the FormView.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
WebSysDescription(SR.FormView_InsertItemTemplate)
]
public virtual ITemplate InsertItemTemplate {
get {
return _insertItemTemplate;
}
set {
_insertItemTemplate = value;
}
}
///
/// Indicates the style properties of each row when in insert mode.
///
[
WebCategory("Styles"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.View_InsertRowStyle)
]
public TableItemStyle InsertRowStyle {
get {
if (_insertRowStyle == null) {
_insertRowStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_insertRowStyle).TrackViewState();
}
return _insertRowStyle;
}
}
///
/// Indicates the template to use for an item within the FormView.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView), BindingDirection.TwoWay),
WebSysDescription(SR.View_InsertRowStyle)
]
public virtual ITemplate ItemTemplate {
get {
return _itemTemplate;
}
set {
_itemTemplate = value;
}
}
private OrderedDictionary KeyTable {
get {
if (_keyTable == null) {
_keyTable = new OrderedDictionary(DataKeyNamesInternal.Length);
}
return _keyTable;
}
}
private FormViewMode Mode {
get {
// if the mode wasn't explicitly set by LoadControlState or by the user, the mode is the DefaultMode.
if (!_modeSet || DesignMode) {
_mode = DefaultMode;
_modeSet = true;
}
return _mode;
}
set {
if (value < FormViewMode.ReadOnly || value > FormViewMode.Insert) {
throw new ArgumentOutOfRangeException("value");
}
_modeSet = true;
if (_mode != value) {
_mode = value;
if (Initialized) {
RequiresDataBinding = true;
}
}
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public virtual int PageCount {
get {
return _pageCount;
}
}
///
/// Gets or sets the index of the currently displayed record.
/// This property echos the public one so that we can set PageIndex to -1
/// internally when we switch to insert mode, but users should never do that.
///
private int PageIndexInternal {
get {
return _pageIndex;
}
set {
int currentPageIndex = PageIndexInternal;
if (value != currentPageIndex) {
_pageIndex = value;
if (Initialized) {
RequiresDataBinding = true;
}
}
}
}
///
/// Gets or sets the index of the currently displayed record.
///
[
Bindable(true),
DefaultValue(0),
WebCategory("Data"),
WebSysDescription(SR.FormView_PageIndex)
]
public virtual int PageIndex {
get {
// if we're in design mode, we don't want a change to the mode to set the PageIndex to -1.
if (Mode == FormViewMode.Insert && !DesignMode) {
return -1;
}
return PageIndexInternal;
}
set {
// since we don't know at property set time how many DataItems we'll have,
// don't throw if we're above PageCount
if (value < -1) {
throw new ArgumentOutOfRangeException("value");
}
if (value >= 0) {
PageIndexInternal = value;
}
}
}
///
/// Gets the settings of the pager buttons for the
///
///
[
WebCategory("Paging"),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.GridView_PagerSettings)
]
public virtual PagerSettings PagerSettings {
get {
if (_pagerSettings == null) {
_pagerSettings = new PagerSettings();
if (IsTrackingViewState) {
((IStateManager)_pagerSettings).TrackViewState();
}
_pagerSettings.PropertyChanged += new EventHandler(OnPagerPropertyChanged);
}
return _pagerSettings;
}
}
///
/// Gets the style properties of the pager rows for the
///
///
[
WebCategory("Styles"),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.WebControl_PagerStyle)
]
public TableItemStyle PagerStyle {
get {
if (_pagerStyle == null) {
_pagerStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_pagerStyle).TrackViewState();
}
return _pagerStyle;
}
}
///
/// Indicates the template to use for a pager item within the FormView.
///
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(FormView)),
WebSysDescription(SR.View_PagerTemplate)
]
public virtual ITemplate PagerTemplate {
get {
return _pagerTemplate;
}
set {
_pagerTemplate = value;
}
}
///
/// Gets a collection of
///
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
WebSysDescription(SR.FormView_Rows)
]
public virtual FormViewRow Row {
get {
if (_row == null) {
EnsureChildControls();
}
return _row;
}
}
///
/// Indicates the style properties of each row.
///
[
WebCategory("Styles"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebSysDescription(SR.View_RowStyle)
]
public TableItemStyle RowStyle {
get {
if (_rowStyle == null) {
_rowStyle = new TableItemStyle();
if (IsTrackingViewState)
((IStateManager)_rowStyle).TrackViewState();
}
return _rowStyle;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public object SelectedValue {
get {
return DataKey.Value;
}
}
protected override HtmlTextWriterTag TagKey {
get {
return HtmlTextWriterTag.Table;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
]
public virtual FormViewRow TopPagerRow {
get {
if (_topPagerRow == null) {
EnsureChildControls();
}
return _topPagerRow;
}
}
///
/// Occurs when the FormView PageIndex has been changed.
///
[
WebCategory("Action"),
WebSysDescription(SR.FormView_OnPageIndexChanged)
]
public event EventHandler PageIndexChanged {
add {
Events.AddHandler(EventPageIndexChanged, value);
}
remove {
Events.RemoveHandler(EventPageIndexChanged, value);
}
}
///
/// Occurs when the FormView PageIndex is changing.
///
[
WebCategory("Action"),
WebSysDescription(SR.FormView_OnPageIndexChanging)
]
public event FormViewPageEventHandler PageIndexChanging {
add {
Events.AddHandler(EventPageIndexChanging, value);
}
remove {
Events.RemoveHandler(EventPageIndexChanging, value);
}
}
///
/// Occurs when a command is issued from the FormView.
///
[
WebCategory("Action"),
WebSysDescription(SR.FormView_OnItemCommand)
]
public event FormViewCommandEventHandler ItemCommand {
add {
Events.AddHandler(EventItemCommand, value);
}
remove {
Events.RemoveHandler(EventItemCommand, value);
}
}
///
/// Occurs when a row is created.
///
[
WebCategory("Behavior"),
WebSysDescription(SR.FormView_OnItemCreated)
]
public event EventHandler ItemCreated {
add {
Events.AddHandler(EventItemCreated, value);
}
remove {
Events.RemoveHandler(EventItemCreated, value);
}
}
///
/// Occurs when the FormView item has been deleted.
///
[
WebCategory("Action"),
WebSysDescription(SR.DataControls_OnItemDeleted)
]
public event FormViewDeletedEventHandler ItemDeleted {
add {
Events.AddHandler(EventItemDeleted, value);
}
remove {
Events.RemoveHandler(EventItemDeleted, value);
}
}
///
/// Occurs when the FormView item is being deleted.
///
[
WebCategory("Action"),
WebSysDescription(SR.DataControls_OnItemDeleting)
]
public event FormViewDeleteEventHandler ItemDeleting {
add {
Events.AddHandler(EventItemDeleting, value);
}
remove {
Events.RemoveHandler(EventItemDeleting, value);
}
}
///
/// Occurs when the FormView item has been inserted.
///
[
WebCategory("Action"),
WebSysDescription(SR.DataControls_OnItemInserted)
]
public event FormViewInsertedEventHandler ItemInserted {
add {
Events.AddHandler(EventItemInserted, value);
}
remove {
Events.RemoveHandler(EventItemInserted, value);
}
}
///
/// Occurs when the FormView item is being inserted.
///
[
WebCategory("Action"),
WebSysDescription(SR.DataControls_OnItemInserting)
]
public event FormViewInsertEventHandler ItemInserting {
add {
Events.AddHandler(EventItemInserting, value);
}
remove {
Events.RemoveHandler(EventItemInserting, value);
}
}
///
/// Occurs when the FormView item has been updated.
///
[
WebCategory("Action"),
WebSysDescription(SR.DataControls_OnItemUpdated)
]
public event FormViewUpdatedEventHandler ItemUpdated {
add {
Events.AddHandler(EventItemUpdated, value);
}
remove {
Events.RemoveHandler(EventItemUpdated, value);
}
}
///
/// Occurs when the FormView item is being updated.
///
[
WebCategory("Action"),
WebSysDescription(SR.DataControls_OnItemUpdating)
]
public event FormViewUpdateEventHandler ItemUpdating {
add {
Events.AddHandler(EventItemUpdating, value);
}
remove {
Events.RemoveHandler(EventItemUpdating, value);
}
}
///
/// Occurs when the ViewMode has changed.
///
[
WebCategory("Action"),
WebSysDescription(SR.FormView_OnModeChanged)
]
public event EventHandler ModeChanged {
add {
Events.AddHandler(EventModeChanged, value);
}
remove {
Events.RemoveHandler(EventModeChanged, value);
}
}
///
/// Occurs when the ViewMode is changing.
///
[
WebCategory("Action"),
WebSysDescription(SR.FormView_OnModeChanging)
]
public event FormViewModeEventHandler ModeChanging {
add {
Events.AddHandler(EventModeChanging, value);
}
remove {
Events.RemoveHandler(EventModeChanging, value);
}
}
public void ChangeMode(FormViewMode newMode) {
Mode = newMode;
}
///
/// Creates the control hierarchy that is used to render the FormView.
/// This is called whenever a control hierarchy is needed and the
/// ChildControlsCreated property is false.
/// The implementation assumes that all the children in the controls
/// collection have already been cleared.
///
protected override int CreateChildControls(IEnumerable dataSource, bool dataBinding) {
PagedDataSource pagedDataSource = null;
int itemIndex = PageIndex;
bool allowPaging = AllowPaging;
int itemCount = 0;
FormViewMode mode = Mode;
// if we're in design mode, PageIndex doesn't return -1
if (DesignMode && mode == FormViewMode.Insert) {
itemIndex = -1;
}
if (dataBinding) {
DataSourceView view = GetData();
DataSourceSelectArguments arguments = SelectArguments;
if (view == null) {
throw new HttpException(SR.GetString(SR.DataBoundControl_NullView, ID));
}
if (mode != FormViewMode.Insert) {
if (allowPaging && !view.CanPage) {
if (dataSource != null && !(dataSource is ICollection)) {
arguments.StartRowIndex = itemIndex;
arguments.MaximumRows = 1;
// 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) {
if (view.CanRetrieveTotalRowCount) {
pagedDataSource = CreateServerPagedDataSource(arguments.TotalRowCount);
} else {
ICollection dataSourceCollection = dataSource as ICollection;
if (dataSourceCollection == null) {
throw new HttpException(SR.GetString(SR.DataBoundControl_NeedICollectionOrTotalRowCount, GetType().Name));
}
pagedDataSource = CreateServerPagedDataSource(checked(PageIndex + dataSourceCollection.Count));
}
} else {
pagedDataSource = CreatePagedDataSource();
}
}
} else {
pagedDataSource = CreatePagedDataSource();
}
if (mode != FormViewMode.Insert) {
pagedDataSource.DataSource = dataSource;
}
IEnumerator dataSourceEnumerator = null;
OrderedDictionary keyTable = KeyTable;
if (dataBinding == false) {
dataSourceEnumerator = dataSource.GetEnumerator();
ICollection collection = dataSource as ICollection;
if (collection == null) {
throw new HttpException(SR.GetString(SR.DataControls_DataSourceMustBeCollectionWhenNotDataBinding));
}
itemCount = collection.Count;
} else {
keyTable.Clear();
if (dataSource != null) {
if (mode != FormViewMode.Insert) {
ICollection collection = dataSource as ICollection;
if ((collection == null) && (pagedDataSource.IsPagingEnabled && !pagedDataSource.IsServerPagingEnabled)) {
throw new HttpException(SR.GetString(SR.FormView_DataSourceMustBeCollection, ID));
}
if (pagedDataSource.IsPagingEnabled) {
itemCount = pagedDataSource.DataSourceCount;
} else if (collection != null) {
itemCount = collection.Count;
}
}
dataSourceEnumerator = dataSource.GetEnumerator();
}
}
Table table = CreateTable();
TableRowCollection rows = table.Rows;
bool moveNextSucceeded = false;
object lastItem = null;
Controls.Add(table);
if (dataSourceEnumerator != null) {
moveNextSucceeded = dataSourceEnumerator.MoveNext(); // goto the first item
}
// if there are no items, only add the tablerow if there's a null template or null text
if (!moveNextSucceeded && mode != FormViewMode.Insert) {
if (EmptyDataText.Length > 0 || _emptyDataTemplate != null) {
_row = CreateRow(0, DataControlRowType.EmptyDataRow, DataControlRowState.Normal, rows, null);
}
itemCount = 0;
} else {
int currentItemIndex = 0;
if (!_useServerPaging) {
// skip over the first records that are before the page we're showing
for (; currentItemIndex < itemIndex; currentItemIndex++) {
lastItem = dataSourceEnumerator.Current;
moveNextSucceeded = dataSourceEnumerator.MoveNext();
if (!moveNextSucceeded) {
_pageIndex = currentItemIndex;
pagedDataSource.CurrentPageIndex = currentItemIndex;
itemIndex = currentItemIndex;
break; // never throw if the PageIndex is out of range: just fix up PageIndex and goto the last item.
}
}
}
if (moveNextSucceeded) {
_dataItem = dataSourceEnumerator.Current;
} else {
_dataItem = lastItem; // if we broke out of the above loop, the current item will be invalid
}
// If we're not using server paging and this isn't a collection, or server paging doesn't return a page count, our _pageCount isn't accurate.
// Loop through the rest of the enumeration to figure out how many items are in it.
if ((!_useServerPaging && !(dataSource is ICollection)) || (_useServerPaging && itemCount < 0)) {
itemCount = currentItemIndex;
while (moveNextSucceeded) {
itemCount++;
moveNextSucceeded = dataSourceEnumerator.MoveNext();
}
}
_dataItemIndex = currentItemIndex;
bool singlePage = itemCount <= 1 && !_useServerPaging; // hide pagers if there's only one item
if (allowPaging && PagerSettings.Visible && _pagerSettings.IsPagerOnTop && mode != FormViewMode.Insert && !singlePage) {
// top pager
_topPagerRow = CreateRow(itemIndex, DataControlRowType.Pager, DataControlRowState.Normal, rows, pagedDataSource);
}
_headerRow = CreateRow(itemIndex, DataControlRowType.Header, DataControlRowState.Normal, rows, null);
if (_headerTemplate == null && HeaderText.Length == 0) {
_headerRow.Visible = false;
}
_row = CreateDataRow(dataBinding, rows, _dataItem);
if (itemIndex >= 0) {
string[] keyFields = DataKeyNamesInternal;
if (dataBinding && (keyFields.Length != 0)) {
foreach (string keyName in keyFields) {
object keyValue = DataBinder.GetPropertyValue(_dataItem, keyName);
keyTable.Add(keyName, keyValue);
}
_dataKey = new DataKey(keyTable);
}
}
_footerRow = CreateRow(itemIndex, DataControlRowType.Footer, DataControlRowState.Normal, rows, null);
if (_footerTemplate == null && FooterText.Length == 0) {
_footerRow.Visible = false;
}
if (allowPaging && PagerSettings.Visible && _pagerSettings.IsPagerOnBottom && mode != FormViewMode.Insert && !singlePage) {
// bottom pager
_bottomPagerRow = CreateRow(itemIndex, DataControlRowType.Pager, DataControlRowState.Normal, rows, pagedDataSource);
}
}
_pageCount = itemCount;
OnItemCreated(EventArgs.Empty);
if (dataBinding) {
DataBind(false);
}
return itemCount;
}
///
/// Creates new control style.
///
protected override Style CreateControlStyle() {
TableStyle controlStyle = new TableStyle();
// initialize defaults that are different from TableStyle
controlStyle.CellSpacing = 0;
return controlStyle;
}
private FormViewRow CreateDataRow(bool dataBinding, TableRowCollection rows, object dataItem) {
ITemplate modeTemplate = null;
switch (Mode) {
case FormViewMode.Edit:
modeTemplate = _editItemTemplate;
break;
case FormViewMode.Insert:
if (_insertItemTemplate != null) {
modeTemplate = _insertItemTemplate;
} else {
modeTemplate = _editItemTemplate;
}
break;
case FormViewMode.ReadOnly:
modeTemplate = _itemTemplate;
break;
}
if (modeTemplate != null) {
return CreateDataRowFromTemplates(dataBinding, rows);
}
return null;
}
private FormViewRow CreateDataRowFromTemplates(bool dataBinding, TableRowCollection rows) {
DataControlRowState rowState = DataControlRowState.Normal;
int itemIndex = PageIndex;
FormViewMode mode = Mode;
rowState = DataControlRowState.Normal;
if (mode == FormViewMode.Edit)
rowState |= DataControlRowState.Edit;
else if (mode == FormViewMode.Insert)
rowState |= DataControlRowState.Insert;
return CreateRow(PageIndex, DataControlRowType.DataRow, rowState, rows, null);
}
protected override DataSourceSelectArguments CreateDataSourceSelectArguments() {
DataSourceSelectArguments arguments = new DataSourceSelectArguments();
DataSourceView view = GetData();
_useServerPaging = AllowPaging && view.CanPage;
// decide if we should use server-side paging
if (_useServerPaging) {
arguments.StartRowIndex = PageIndex;
if (view.CanRetrieveTotalRowCount) {
arguments.RetrieveTotalRowCount = true;
arguments.MaximumRows = 1;
} else {
arguments.MaximumRows = -1;
}
}
return arguments;
}
///
/// Creates the pager for NextPrev and NextPrev with First and Last styles
///
private void CreateNextPrevPager(TableRow row, PagedDataSource pagedDataSource, bool addFirstLastPageButtons) {
PagerSettings pagerSettings = PagerSettings;
string prevPageImageUrl = pagerSettings.PreviousPageImageUrl;
string nextPageImageUrl = pagerSettings.NextPageImageUrl;
bool isFirstPage = pagedDataSource.IsFirstPage;
bool isLastPage = pagedDataSource.IsLastPage;
if (addFirstLastPageButtons && !isFirstPage) {
string firstPageImageUrl = pagerSettings.FirstPageImageUrl;
TableCell cell = new TableCell();
row.Cells.Add(cell);
IButtonControl firstButton;
if (firstPageImageUrl.Length > 0) {
firstButton = new DataControlImageButton(this);
((ImageButton)firstButton).ImageUrl = firstPageImageUrl;
((ImageButton)firstButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.FirstPageText);
} else {
firstButton = new DataControlPagerLinkButton(this);
((DataControlPagerLinkButton)firstButton).Text = pagerSettings.FirstPageText;
}
firstButton.CommandName = DataControlCommands.PageCommandName;
firstButton.CommandArgument = DataControlCommands.FirstPageCommandArgument;
cell.Controls.Add((Control)firstButton);
}
if (!isFirstPage) {
IButtonControl prevButton;
TableCell cell = new TableCell();
row.Cells.Add(cell);
if (prevPageImageUrl.Length > 0) {
prevButton = new DataControlImageButton(this);
((ImageButton)prevButton).ImageUrl = prevPageImageUrl;
((ImageButton)prevButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.PreviousPageText);
} else {
prevButton = new DataControlPagerLinkButton(this);
((DataControlPagerLinkButton)prevButton).Text = pagerSettings.PreviousPageText;
}
prevButton.CommandName = DataControlCommands.PageCommandName;
prevButton.CommandArgument = DataControlCommands.PreviousPageCommandArgument;
cell.Controls.Add((Control)prevButton);
}
if (!isLastPage) {
IButtonControl nextButton;
TableCell cell = new TableCell();
row.Cells.Add(cell);
if (nextPageImageUrl.Length > 0) {
nextButton = new DataControlImageButton(this);
((ImageButton)nextButton).ImageUrl = nextPageImageUrl;
((ImageButton)nextButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.NextPageText);
} else {
nextButton = new DataControlPagerLinkButton(this);
((DataControlPagerLinkButton)nextButton).Text = pagerSettings.NextPageText;
}
nextButton.CommandName = DataControlCommands.PageCommandName;
nextButton.CommandArgument = DataControlCommands.NextPageCommandArgument;
cell.Controls.Add((Control)nextButton);
}
if (addFirstLastPageButtons && !isLastPage) {
string lastPageImageUrl = pagerSettings.LastPageImageUrl;
IButtonControl lastButton;
TableCell cell = new TableCell();
row.Cells.Add(cell);
if (lastPageImageUrl.Length > 0) {
lastButton = new DataControlImageButton(this);
((ImageButton)lastButton).ImageUrl = lastPageImageUrl;
((ImageButton)lastButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.LastPageText);
} else {
lastButton = new DataControlPagerLinkButton(this);
((DataControlPagerLinkButton)lastButton).Text = pagerSettings.LastPageText;
}
lastButton.CommandName = DataControlCommands.PageCommandName;
lastButton.CommandArgument = DataControlCommands.LastPageCommandArgument;
cell.Controls.Add((Control)lastButton);
}
}
///
/// Creates the pager for NextPrev and NextPrev with First and Last styles
///
private void CreateNumericPager(TableRow row, PagedDataSource pagedDataSource, bool addFirstLastPageButtons) {
PagerSettings pagerSettings = PagerSettings;
int pages = pagedDataSource.PageCount;
int currentPage = pagedDataSource.CurrentPageIndex + 1;
int pageSetSize = pagerSettings.PageButtonCount;
int pagesShown = pageSetSize;
int firstDisplayedPage = FirstDisplayedPageIndex + 1; // first page displayed on last postback
// ensure the number of pages we show isn't more than the number of pages that do exist
if (pages < pagesShown)
pagesShown = pages;
// initialize to the first page set, i.e., pages 1 through number of pages shown
int firstPage = 1;
int lastPage = pagesShown;
if (currentPage > lastPage) {
// The current page is not in the first page set, then we need to slide the
// range of pages shown by adjusting firstPage and lastPage
int currentPageSet = (currentPage - 1) / pageSetSize;
bool currentPageInLastDisplayRange = currentPage - firstDisplayedPage >= 0 && currentPage - firstDisplayedPage < pageSetSize;
if (firstDisplayedPage > 0 && currentPageInLastDisplayRange) {
firstPage = firstDisplayedPage;
} else {
firstPage = currentPageSet * pageSetSize + 1;
}
lastPage = firstPage + pageSetSize - 1;
// now bring back lastPage into the range if its exceeded the number of pages
if (lastPage > pages)
lastPage = pages;
// if theres room to show more pages from the previous page set, then adjust
// the first page accordingly
if (lastPage - firstPage + 1 < pageSetSize) {
firstPage = Math.Max(1, lastPage - pageSetSize + 1);
}
FirstDisplayedPageIndex = firstPage - 1;
}
LinkButton button;
if (addFirstLastPageButtons && currentPage != 1 && firstPage != 1) {
string firstPageImageUrl = pagerSettings.FirstPageImageUrl;
IButtonControl firstButton;
TableCell cell = new TableCell();
row.Cells.Add(cell);
if (firstPageImageUrl.Length > 0) {
firstButton = new DataControlImageButton(this);
((ImageButton)firstButton).ImageUrl = firstPageImageUrl;
((ImageButton)firstButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.FirstPageText);
} else {
firstButton = new DataControlPagerLinkButton(this);
((DataControlPagerLinkButton)firstButton).Text = pagerSettings.FirstPageText;
}
firstButton.CommandName = DataControlCommands.PageCommandName;
firstButton.CommandArgument = DataControlCommands.FirstPageCommandArgument;
cell.Controls.Add((Control)firstButton);
}
if (firstPage != 1) {
TableCell cell = new TableCell();
row.Cells.Add(cell);
button = new DataControlPagerLinkButton(this);
button.Text = "...";
button.CommandName = DataControlCommands.PageCommandName;
button.CommandArgument = (firstPage - 1).ToString(NumberFormatInfo.InvariantInfo);
cell.Controls.Add(button);
}
for (int i = firstPage; i <= lastPage; i++) {
TableCell cell = new TableCell();
row.Cells.Add(cell);
string pageString = (i).ToString(NumberFormatInfo.InvariantInfo);
if (i == currentPage) {
Label label = new Label();
label.Text = pageString;
cell.Controls.Add(label);
} else {
button = new DataControlPagerLinkButton(this);
button.Text = pageString;
button.CommandName = DataControlCommands.PageCommandName;
button.CommandArgument = pageString;
cell.Controls.Add(button);
}
}
if (pages > lastPage) {
TableCell cell = new TableCell();
row.Cells.Add(cell);
button = new DataControlPagerLinkButton(this);
button.Text = "...";
button.CommandName = DataControlCommands.PageCommandName;
button.CommandArgument = (lastPage + 1).ToString(NumberFormatInfo.InvariantInfo);
cell.Controls.Add(button);
}
bool isLastPageShown = lastPage == pages;
if (addFirstLastPageButtons && currentPage != pages && !isLastPageShown) {
string lastPageImageUrl = pagerSettings.LastPageImageUrl;
TableCell cell = new TableCell();
row.Cells.Add(cell);
IButtonControl lastButton;
if (lastPageImageUrl.Length > 0) {
lastButton = new DataControlImageButton(this);
((ImageButton)lastButton).ImageUrl = lastPageImageUrl;
((ImageButton)lastButton).AlternateText = HttpUtility.HtmlDecode(pagerSettings.LastPageText);
} else {
lastButton = new DataControlPagerLinkButton(this);
((DataControlPagerLinkButton)lastButton).Text = pagerSettings.LastPageText;
}
lastButton.CommandName = DataControlCommands.PageCommandName;
lastButton.CommandArgument = DataControlCommands.LastPageCommandArgument;
cell.Controls.Add((Control)lastButton);
}
}
private PagedDataSource CreatePagedDataSource() {
PagedDataSource pagedDataSource = new PagedDataSource();
pagedDataSource.CurrentPageIndex = PageIndex;
pagedDataSource.PageSize = 1;
pagedDataSource.AllowPaging = AllowPaging;
pagedDataSource.AllowCustomPaging = false;
pagedDataSource.AllowServerPaging = false;
pagedDataSource.VirtualCount = 0;
return pagedDataSource;
}
private PagedDataSource CreateServerPagedDataSource(int totalRowCount) {
PagedDataSource pagedDataSource = new PagedDataSource();
pagedDataSource.CurrentPageIndex = PageIndex;
pagedDataSource.PageSize = 1;
pagedDataSource.AllowPaging = AllowPaging;
pagedDataSource.AllowCustomPaging = false;
pagedDataSource.AllowServerPaging = true;
pagedDataSource.VirtualCount = totalRowCount;
return pagedDataSource;
}
private FormViewRow CreateRow(int itemIndex, DataControlRowType rowType, DataControlRowState rowState, TableRowCollection rows, PagedDataSource pagedDataSource) {
FormViewRow row = CreateRow(itemIndex, rowType, rowState);
row.RenderTemplateContainer = RenderOuterTable;
rows.Add(row);
if (rowType != DataControlRowType.Pager) {
InitializeRow(row);
} else {
InitializePager(row, pagedDataSource);
}
return row;
}
///
/// [To be supplied.]
///
protected virtual FormViewRow CreateRow(int itemIndex, DataControlRowType rowType, DataControlRowState rowState) {
if (rowType == DataControlRowType.Pager) {
return new FormViewPagerRow(itemIndex, rowType, rowState);
}
return new FormViewRow(itemIndex, rowType, rowState);
}
///
/// Creates a new ChildTable, which is the containing table
///
protected virtual Table CreateTable() {
return new ChildTable(String.IsNullOrEmpty(ID) ? null : ClientID);
}
/// Data bound controls should override PerformDataBinding instead
/// of DataBind. If DataBind if overridden, the OnDataBinding and OnDataBound events will
/// fire in the wrong order. However, for backwards compat on ListControl and AdRotator, we
/// can't seal this method. It is sealed on all new BaseDataBoundControl-derived controls.
public override sealed void DataBind() {
base.DataBind();
}
public virtual void DeleteItem() {
// 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(String.Empty);
}
///
/// Override EnsureDataBound because we don't want to databind when we're in insert mode
///
protected override void EnsureDataBound() {
if (RequiresDataBinding && Mode == FormViewMode.Insert) {
OnDataBinding(EventArgs.Empty);
RequiresDataBinding = false;
MarkAsDataBound();
if (AdapterInternal != null) {
DataBoundControlAdapter dataBoundControlAdapter = AdapterInternal as DataBoundControlAdapter;
if (dataBoundControlAdapter != null) {
dataBoundControlAdapter.PerformDataBinding(null);
} else {
PerformDataBinding(null);
}
} else {
PerformDataBinding(null);
}
OnDataBound(EventArgs.Empty);
} else {
base.EnsureDataBound();
}
}
protected virtual void ExtractRowValues(IOrderedDictionary fieldValues, bool includeKeys) {
if (fieldValues == null) {
Debug.Assert(false, "FormView::ExtractRowValues- must hand in a valid reference to an IDictionary.");
return;
}
DataBoundControlHelper.ExtractValuesFromBindableControls(fieldValues, this);
IBindableTemplate bindableTemplate = null;
if (Mode == FormViewMode.ReadOnly && ItemTemplate != null) {
bindableTemplate = ItemTemplate as IBindableTemplate;
} else if ((Mode == FormViewMode.Edit || (Mode == FormViewMode.Insert && InsertItemTemplate == null)) && EditItemTemplate != null) {
bindableTemplate = EditItemTemplate as IBindableTemplate;
} else if (Mode == FormViewMode.Insert && InsertItemTemplate != null) {
bindableTemplate = InsertItemTemplate as IBindableTemplate;
}
string[] dataKeyNames = DataKeyNamesInternal;
if (bindableTemplate != null) {
FormView container = this;
if (container != null && bindableTemplate != null) {
foreach (DictionaryEntry entry in bindableTemplate.ExtractValues(container)) {
if (!includeKeys && Array.IndexOf(dataKeyNames, entry.Key) != -1) {
continue;
}
fieldValues[entry.Key] = entry.Value;
}
}
}
return;
}
private void HandleCancel() {
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
FormViewModeEventArgs e = new FormViewModeEventArgs(DefaultMode, true);
OnModeChanging(e);
if (e.Cancel) {
return;
}
if (isBoundToDataSourceControl) {
Mode = e.NewMode;
OnModeChanged(EventArgs.Empty);
}
RequiresDataBinding = true;
}
private void HandleDelete(string commandArg) {
int pageIndex = PageIndex;
if (pageIndex < 0) { // don't attempt to delete in Insert mode
return;
}
DataSourceView view = null;
int itemIndex = PageIndex;
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
if (isBoundToDataSourceControl) {
view = GetData();
if (view == null) {
throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
}
}
FormViewDeleteEventArgs e = new FormViewDeleteEventArgs(itemIndex);
ExtractRowValues(e.Values, false/*includeKeys*/);
foreach (DictionaryEntry entry in DataKey.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;
}
if (isBoundToDataSourceControl) {
_deleteKeys = e.Keys;
_deleteValues = e.Values;
view.Delete(e.Keys, e.Values, HandleDeleteCallback);
}
}
private bool HandleDeleteCallback(int affectedRows, Exception ex) {
int pageIndex = PageIndex;
FormViewDeletedEventArgs fea = new FormViewDeletedEventArgs(affectedRows, ex);
fea.SetKeys(_deleteKeys);
fea.SetValues(_deleteValues);
OnItemDeleted(fea);
_deleteKeys = null;
_deleteValues = null;
if (ex != null && !fea.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;
}
}
if (pageIndex == _pageCount - 1) {
HandlePage(pageIndex - 1);
}
RequiresDataBinding = true;
return true;
}
private void HandleEdit() {
if (PageIndex < 0) {
return;
}
FormViewModeEventArgs e = new FormViewModeEventArgs(FormViewMode.Edit, false);
OnModeChanging(e);
if (e.Cancel) {
return;
}
if (IsBoundUsingDataSourceID) {
Mode = e.NewMode;
OnModeChanged(EventArgs.Empty);
}
RequiresDataBinding = true;
}
private bool HandleEvent(EventArgs e, bool causesValidation, string validationGroup) {
bool handled = false;
ResetModelValidationGroup(causesValidation, validationGroup);
FormViewCommandEventArgs dce = e as FormViewCommandEventArgs;
if (dce != null) {
OnItemCommand(dce);
handled = true;
string command = dce.CommandName;
int newItemIndex = PageIndex;
if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.PageCommandName)) {
string itemIndexArg = (string)dce.CommandArgument;
if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.NextPageCommandArgument)) {
newItemIndex++;
} else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.PreviousPageCommandArgument)) {
newItemIndex--;
} else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.FirstPageCommandArgument)) {
newItemIndex = 0;
} else if (StringUtil.EqualsIgnoreCase(itemIndexArg, DataControlCommands.LastPageCommandArgument)) {
newItemIndex = PageCount - 1;
} else {
// argument is page number, and page index is 1 less than that
newItemIndex = Convert.ToInt32(itemIndexArg, CultureInfo.InvariantCulture) - 1;
}
HandlePage(newItemIndex);
} else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.EditCommandName)) {
HandleEdit();
} else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.UpdateCommandName)) {
HandleUpdate((string)dce.CommandArgument, causesValidation);
} else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.CancelCommandName)) {
HandleCancel();
} else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.DeleteCommandName)) {
HandleDelete((string)dce.CommandArgument);
} else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.InsertCommandName)) {
HandleInsert((string)dce.CommandArgument, causesValidation);
} else if (StringUtil.EqualsIgnoreCase(command, DataControlCommands.NewCommandName)) {
HandleNew();
} else {
// unhandled event should be bubbled up here. (DevDiv Bugs 161011)
handled = HandleCommand(command);
}
}
return handled;
}
private bool HandleCommand(string commandName) {
DataSourceView view = null;
if (IsBoundUsingDataSourceID) {
view = GetData();
if (view == null) {
throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
}
}
else {
// This feature is only for data sources
return false;
}
if (!view.CanExecute(commandName)) {
return false;
}
OrderedDictionary values = new OrderedDictionary();
OrderedDictionary keys = new OrderedDictionary();
ExtractRowValues(values, false /*includeKey*/);
foreach (DictionaryEntry entry in DataKey.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;
}
}
RequiresDataBinding = true;
return true;
}
private void HandleInsert(string commandArg, bool causesValidation) {
if (causesValidation && Page != null && !Page.IsValid) {
return;
}
if (Mode != FormViewMode.Insert) {
throw new HttpException(SR.GetString(SR.DetailsViewFormView_ControlMustBeInInsertMode, "FormView", ID));
}
DataSourceView view = null;
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
if (isBoundToDataSourceControl) {
view = GetData();
if (view == null) {
throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
}
}
FormViewInsertEventArgs e = new FormViewInsertEventArgs(commandArg);
ExtractRowValues(e.Values, 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) {
FormViewInsertedEventArgs fea = new FormViewInsertedEventArgs(affectedRows, ex);
fea.SetValues(_insertValues);
OnItemInserted(fea);
_insertValues = null;
if (ex != null && !fea.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;
}
fea.KeepInInsertMode = true;
}
if (!fea.KeepInInsertMode) {
FormViewModeEventArgs eMode = new FormViewModeEventArgs(DefaultMode, false);
OnModeChanging(eMode);
if (!eMode.Cancel) {
Mode = eMode.NewMode;
OnModeChanged(EventArgs.Empty);
RequiresDataBinding = true;
}
}
return true;
}
private void HandleNew() {
FormViewModeEventArgs e = new FormViewModeEventArgs(FormViewMode.Insert, false);
OnModeChanging(e);
if (e.Cancel) {
return;
}
if (IsBoundUsingDataSourceID) {
Mode = e.NewMode;
OnModeChanged(EventArgs.Empty);
}
RequiresDataBinding = true;
}
private void HandlePage(int newPage) {
if (!AllowPaging) {
return;
}
if (PageIndex < 0) {
return;
}
FormViewPageEventArgs e = new FormViewPageEventArgs(newPage);
OnPageIndexChanging(e);
if (e.Cancel) {
return;
}
if (e.NewPageIndex > -1) {
// if the requested page is out of range and we're already on the last page, don't rebind
if ((e.NewPageIndex >= PageCount && _pageIndex == PageCount - 1)) {
return;
}
// DevDiv Bugs 188830: Don't clear key table if the page is out of range, since control won't be rebound.
_keyTable = null;
_pageIndex = e.NewPageIndex;
}
else {
return;
}
OnPageIndexChanged(EventArgs.Empty);
RequiresDataBinding = true;
}
private void HandleUpdate(string commandArg, bool causesValidation) {
if (causesValidation && Page != null && !Page.IsValid) {
return;
}
if (Mode != FormViewMode.Edit) {
throw new HttpException(SR.GetString(SR.DetailsViewFormView_ControlMustBeInEditMode, "FormView", ID));
}
if (PageIndex < 0) {
return;
}
DataSourceView view = null;
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
if (isBoundToDataSourceControl) {
view = GetData();
if (view == null) {
throw new HttpException(SR.GetString(SR.View_DataSourceReturnedNullView, ID));
}
}
FormViewUpdateEventArgs e = new FormViewUpdateEventArgs(commandArg);
foreach (DictionaryEntry entry in BoundFieldValues) {
e.OldValues.Add(entry.Key, entry.Value);
}
ExtractRowValues(e.NewValues, true/*includeKeys*/);
foreach (DictionaryEntry entry in DataKey.Values) {
e.Keys.Add(entry.Key, entry.Value);
}
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) {
FormViewUpdatedEventArgs fea = new FormViewUpdatedEventArgs(affectedRows, ex);
fea.SetOldValues(_updateOldValues);
fea.SetNewValues(_updateNewValues);
fea.SetKeys(_updateKeys);
OnItemUpdated(fea);
_updateKeys = null;
_updateOldValues = null;
_updateNewValues = null;
if (ex != null && !fea.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;
}
fea.KeepInEditMode = true;
}
if (!fea.KeepInEditMode) {
FormViewModeEventArgs eMode = new FormViewModeEventArgs(DefaultMode, false);
OnModeChanging(eMode);
if (!eMode.Cancel) {
Mode = eMode.NewMode;
OnModeChanged(EventArgs.Empty);
RequiresDataBinding = true;
}
}
return true;
}
///
///
/// Creates a FormViewRow that contains the paging UI.
/// The paging UI is a navigation bar that is a built into a single TableCell that
/// spans across all fields of the FormView.
///
///
protected virtual void InitializePager(FormViewRow row, PagedDataSource pagedDataSource) {
TableCell cell = new TableCell();
PagerSettings pagerSettings = PagerSettings;
if (_pagerTemplate != null) {
_pagerTemplate.InstantiateIn(cell);
} else {
PagerTable pagerTable = new PagerTable();
TableRow pagerTableRow = new TableRow();
cell.Controls.Add(pagerTable);
pagerTable.Rows.Add(pagerTableRow);
switch (pagerSettings.Mode) {
case PagerButtons.NextPrevious:
CreateNextPrevPager(pagerTableRow, pagedDataSource, false);
break;
case PagerButtons.Numeric:
CreateNumericPager(pagerTableRow, pagedDataSource, false);
break;
case PagerButtons.NextPreviousFirstLast:
CreateNextPrevPager(pagerTableRow, pagedDataSource, true);
break;
case PagerButtons.NumericFirstLast:
CreateNumericPager(pagerTableRow, pagedDataSource, true);
break;
}
}
cell.ColumnSpan = 2;
row.Cells.Add(cell);
}
///
/// [To be supplied.]
///
protected virtual void InitializeRow(FormViewRow row) {
TableCellCollection cells = row.Cells;
TableCell contentCell = new TableCell();
ITemplate contentTemplate = _itemTemplate;
int itemIndex = row.ItemIndex;
DataControlRowState rowState = row.RowState;
switch (row.RowType) {
case DataControlRowType.DataRow:
contentCell.ColumnSpan = 2;
if (((rowState & DataControlRowState.Edit) != 0) && _editItemTemplate != null) {
contentTemplate = _editItemTemplate;
}
if ((rowState & DataControlRowState.Insert) != 0) {
if (_insertItemTemplate != null) {
contentTemplate = _insertItemTemplate;
} else {
contentTemplate = _editItemTemplate;
}
}
break;
case DataControlRowType.Header:
contentTemplate = _headerTemplate;
contentCell.ColumnSpan = 2;
string headerText = HeaderText;
if (_headerTemplate == null && headerText.Length > 0) {
contentCell.Text = headerText;
}
break;
case DataControlRowType.Footer:
contentTemplate = _footerTemplate;
contentCell.ColumnSpan = 2;
string footerText = FooterText;
if (_footerTemplate == null && footerText.Length > 0) {
contentCell.Text = footerText;
}
break;
case DataControlRowType.EmptyDataRow:
contentTemplate = _emptyDataTemplate;
string emptyDataText = EmptyDataText;
if (_emptyDataTemplate == null && emptyDataText.Length > 0) {
contentCell.Text = emptyDataText;
}
break;
}
if (contentTemplate != null) {
contentTemplate.InstantiateIn(contentCell);
}
cells.Add(contentCell);
}
public virtual void InsertItem(bool causesValidation) {
ResetModelValidationGroup(causesValidation, String.Empty);
HandleInsert(String.Empty, causesValidation);
}
///
/// Determines if the specified data type can be bound to.
///
public virtual bool IsBindableType(Type type) {
// NOTE: No one ever calls this function, but we have to keep it for back compat
// since it's public.
return DataBoundControlHelper.IsBindableType(type);
}
///
/// Loads the control state for those properties that should persist across postbacks
/// even when EnableViewState=false.
///
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.
_pageIndex = 0;
_defaultMode = FormViewMode.ReadOnly;
_dataKeyNames = new string[0];
_pageCount = 0;
object[] state = savedState as object[];
if (state != null) {
base.LoadControlState(state[0]);
if (state[1] != null) {
_pageIndex = (int)state[1];
}
if (state[2] != null) {
_defaultMode = (FormViewMode)state[2];
}
// if Mode isn't saved, it should be restored to DefaultMode. That will happen in Mode's getter,
// since the persistance state hasn't been loaded yet.
if (state[3] != null) {
Mode = (FormViewMode)state[3];
}
if (state[4] != null) {
_dataKeyNames = (string[])state[4];
}
if (state[5] != null) {
KeyTable.Clear();
OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)KeyTable, (ArrayList)state[5]);
}
if (state[6] != null) {
_pageCount = (int)state[6];
}
} else {
base.LoadControlState(null);
}
}
///
/// Loads a saved state of the
///
protected override void LoadViewState(object savedState) {
if (savedState != null) {
object[] myState = (object[])savedState;
base.LoadViewState(myState[0]);
if (myState[1] != null)
((IStateManager)PagerStyle).LoadViewState(myState[1]);
if (myState[2] != null)
((IStateManager)HeaderStyle).LoadViewState(myState[2]);
if (myState[3] != null)
((IStateManager)FooterStyle).LoadViewState(myState[3]);
if (myState[4] != null)
((IStateManager)RowStyle).LoadViewState(myState[4]);
if (myState[5] != null)
((IStateManager)EditRowStyle).LoadViewState(myState[5]);
if (myState[6] != null)
((IStateManager)InsertRowStyle).LoadViewState(myState[6]);
if (myState[7] != null)
OrderedDictionaryStateHelper.LoadViewState((OrderedDictionary)BoundFieldValues, (ArrayList)myState[7]);
if (myState[8] != null)
((IStateManager)PagerSettings).LoadViewState(myState[8]);
if (myState[9] != null)
((IStateManager)ControlStyle).LoadViewState(myState[9]);
} else {
base.LoadViewState(null);
}
}
protected internal virtual string ModifiedOuterTableStylePropertyName() {
// Verify that table specific and basic style properties are not not set (not different than their defaults).
if (!String.IsNullOrEmpty(BackImageUrl)) {
return "BackImageUrl";
}
if (CellPadding != -1) {
return "CellPadding";
}
if (CellSpacing != 0) {
return "CellSpacing";
}
if (GridLines != GridLines.None) {
return "GridLines";
}
if (HorizontalAlign != HorizontalAlign.NotSet) {
return "HorizontalAlign";
}
// Font styles.
if (Font.Bold ||
Font.Italic ||
!String.IsNullOrEmpty(Font.Name) ||
(Font.Names.Length != 0) ||
Font.Overline ||
(Font.Size != FontUnit.Empty) ||
Font.Strikeout ||
Font.Underline) {
return "Font";
}
return LoginUtil.ModifiedOuterTableBasicStylePropertyName(this);
}
///
///
protected override bool OnBubbleEvent(object source, EventArgs e) {
bool causesValidation = false;
string validationGroup = String.Empty;
FormViewCommandEventArgs fvcea = e as FormViewCommandEventArgs;
if (fvcea != null) {
IButtonControl button = fvcea.CommandSource as IButtonControl;
if (button != null) {
causesValidation = button.CausesValidation;
validationGroup = button.ValidationGroup;
}
}
return HandleEvent(e, causesValidation, validationGroup);
}
///
/// Raises the
///
protected virtual void OnPageIndexChanged(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventPageIndexChanged];
if (handler != null) handler(this, e);
}
///
/// Raises the
///
protected virtual void OnPageIndexChanging(FormViewPageEventArgs e) {
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
FormViewPageEventHandler handler = (FormViewPageEventHandler)Events[EventPageIndexChanging];
if (handler != null) {
handler(this, e);
} else {
if (isBoundToDataSourceControl == false && e.Cancel == false) {
throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "PageIndexChanging"));
}
}
}
///
/// FormView initialization.
///
protected internal override void OnInit(EventArgs e) {
base.OnInit(e);
if (Page != null) {
if (DataKeyNames.Length > 0) {
Page.RegisterRequiresViewStateEncryption();
}
Page.RegisterRequiresControlState(this);
}
}
///
/// Raises the
///
protected virtual void OnItemCommand(FormViewCommandEventArgs e) {
FormViewCommandEventHandler handler = (FormViewCommandEventHandler)Events[EventItemCommand];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
protected virtual void OnItemCreated(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventItemCreated];
if (handler != null) {
handler(this, e);
}
}
///
/// Raises the
///
protected virtual void OnItemDeleted(FormViewDeletedEventArgs e) {
FormViewDeletedEventHandler handler = (FormViewDeletedEventHandler)Events[EventItemDeleted];
if (handler != null) handler(this, e);
}
///
/// Raises the
///
protected virtual void OnItemDeleting(FormViewDeleteEventArgs e) {
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
FormViewDeleteEventHandler handler = (FormViewDeleteEventHandler)Events[EventItemDeleting];
if (handler != null) {
handler(this, e);
} else {
if (isBoundToDataSourceControl == false && e.Cancel == false) {
throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemDeleting"));
}
}
}
///
/// Raises the
///
protected virtual void OnItemInserted(FormViewInsertedEventArgs e) {
FormViewInsertedEventHandler handler = (FormViewInsertedEventHandler)Events[EventItemInserted];
if (handler != null) handler(this, e);
}
///
/// Raises the
///
protected virtual void OnItemInserting(FormViewInsertEventArgs e) {
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
FormViewInsertEventHandler handler = (FormViewInsertEventHandler)Events[EventItemInserting];
if (handler != null) {
handler(this, e);
} else {
if (isBoundToDataSourceControl == false && e.Cancel == false) {
throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemInserting"));
}
}
}
///
/// Raises the
///
protected virtual void OnItemUpdated(FormViewUpdatedEventArgs e) {
FormViewUpdatedEventHandler handler = (FormViewUpdatedEventHandler)Events[EventItemUpdated];
if (handler != null) handler(this, e);
}
///
/// Raises the
///
protected virtual void OnItemUpdating(FormViewUpdateEventArgs e) {
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
FormViewUpdateEventHandler handler = (FormViewUpdateEventHandler)Events[EventItemUpdating];
if (handler != null) {
handler(this, e);
} else {
if (isBoundToDataSourceControl == false && e.Cancel == false) {
throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ItemUpdating"));
}
}
}
///
/// Raises the
///
protected virtual void OnModeChanged(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventModeChanged];
if (handler != null) handler(this, e);
}
///
/// Raises the
///
protected virtual void OnModeChanging(FormViewModeEventArgs e) {
bool isBoundToDataSourceControl = IsBoundUsingDataSourceID;
FormViewModeEventHandler handler = (FormViewModeEventHandler)Events[EventModeChanging];
if (handler != null) {
handler(this, e);
} else {
if (isBoundToDataSourceControl == false && e.Cancel == false) {
throw new HttpException(SR.GetString(SR.FormView_UnhandledEvent, ID, "ModeChanging"));
}
}
}
private void OnPagerPropertyChanged(object sender, EventArgs e) {
if (Initialized) {
RequiresDataBinding = true;
}
}
private bool PageIsValidAfterModelException() {
if (_modelValidationGroup == null) {
return true;
}
Page.Validate(_modelValidationGroup);
return Page.IsValid;
}
protected internal override void PerformDataBinding(IEnumerable data) {
base.PerformDataBinding(data);
if (IsBoundUsingDataSourceID && Mode == FormViewMode.Edit && IsViewStateEnabled) {
ExtractRowValues(BoundFieldValues, false/*includeKeys*/);
}
}
///
///
protected internal virtual void PrepareControlHierarchy() {
if (Controls.Count < 1) {
return;
}
Debug.Assert(Controls[0] is Table);
Table childTable = (Table)Controls[0];
childTable.CopyBaseAttributes(this);
if (ControlStyleCreated && !ControlStyle.IsEmpty) {
childTable.ApplyStyle(ControlStyle);
} else {
// Since we didn't create a ControlStyle yet, the default
// settings for the default style of the control need to be applied
// to the child table control directly
//
childTable.GridLines = GridLines.None;
childTable.CellSpacing = 0;
}
childTable.Caption = Caption;
childTable.CaptionAlign = CaptionAlign;
Style compositeStyle;
TableRowCollection rows = childTable.Rows;
foreach (FormViewRow row in rows) {
compositeStyle = new TableItemStyle();
DataControlRowState rowState = row.RowState;
DataControlRowType rowType = row.RowType;
switch (rowType) {
case DataControlRowType.Header:
compositeStyle = _headerStyle;
break;
case DataControlRowType.Footer:
compositeStyle = _footerStyle;
break;
case DataControlRowType.DataRow:
compositeStyle.CopyFrom(_rowStyle);
if ((rowState & DataControlRowState.Edit) != 0) {
compositeStyle.CopyFrom(_editRowStyle);
}
if ((rowState & DataControlRowState.Insert) != 0) {
if (_insertRowStyle != null) {
compositeStyle.CopyFrom(_insertRowStyle);
} else {
compositeStyle.CopyFrom(_editRowStyle);
}
}
break;
case DataControlRowType.Pager:
compositeStyle = _pagerStyle;
break;
case DataControlRowType.EmptyDataRow:
compositeStyle = _emptyDataRowStyle;
break;
}
if (compositeStyle != null && row.Visible) {
row.MergeStyle(compositeStyle);
}
}
}
protected virtual void RaisePostBackEvent(string eventArgument) {
ValidateEvent(UniqueID, eventArgument);
int separatorIndex = eventArgument.IndexOf('$');
if (separatorIndex < 0) {
return;
}
CommandEventArgs cea = new CommandEventArgs(eventArgument.Substring(0, separatorIndex), eventArgument.Substring(separatorIndex + 1));
FormViewCommandEventArgs dvcea = new FormViewCommandEventArgs(this, cea);
HandleEvent(dvcea, false, String.Empty);
}
///
/// Displays the control on the client.
///
protected internal override void Render(HtmlTextWriter writer) {
if (Page != null) {
Page.VerifyRenderingInServerForm(this);
}
if (RenderOuterTable) {
PrepareControlHierarchy();
RenderContents(writer);
} else {
string propertyName = ModifiedOuterTableStylePropertyName();
if (!string.IsNullOrEmpty(propertyName)) {
throw new InvalidOperationException(SR.GetString(SR.IRenderOuterTableControl_CannotSetStyleWhenDisableRenderOuterTable,
propertyName, GetType().Name, ID));
}
if (Controls.Count > 0) {
//render the children of the inner table
Controls[0].RenderChildren(writer);
}
}
}
private void ResetModelValidationGroup(bool causesValidation, string validationGroup) {
_modelValidationGroup = null;
if (causesValidation && Page != null) {
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 ||
_pageIndex != 0 ||
_mode != _defaultMode ||
_defaultMode != FormViewMode.ReadOnly ||
(_dataKeyNames != null && _dataKeyNames.Length > 0) ||
(_keyTable != null && _keyTable.Count > 0) ||
_pageCount != 0) {
object[] state = new object[7];
object pageIndexState = null;
object modeState = null;
object defaultModeState = null;
object keyNamesState = null;
object keyTableState = null;
object pageCountState = null;
if (_pageIndex != 0) {
pageIndexState = _pageIndex;
}
if (_defaultMode != FormViewMode.ReadOnly) {
defaultModeState = (int)_defaultMode;
}
// Only save the mode if it's different from the DefaultMode. Otherwise, the Mode
// getter will restore it to the DefaultMode value.
if (_mode != _defaultMode && _modeSet) {
modeState = (int)_mode;
}
if (_dataKeyNames != null && _dataKeyNames.Length > 0) {
keyNamesState = _dataKeyNames;
}
if (_keyTable != null) {
keyTableState = OrderedDictionaryStateHelper.SaveViewState(_keyTable);
}
if (_pageCount != 0) {
pageCountState = _pageCount;
}
state[0] = baseState;
state[1] = pageIndexState;
state[2] = defaultModeState;
state[3] = modeState;
state[4] = keyNamesState;
state[5] = keyTableState;
state[6] = pageCountState;
return state;
}
return true; // return a dummy that ensures LoadControlState gets called but minimizes persisted size.
}
///
/// Saves the current state of the
///
protected override object SaveViewState() {
object baseState = base.SaveViewState();
object pagerStyleState = (_pagerStyle != null) ? ((IStateManager)_pagerStyle).SaveViewState() : null;
object headerStyleState = (_headerStyle != null) ? ((IStateManager)_headerStyle).SaveViewState() : null;
object footerStyleState = (_footerStyle != null) ? ((IStateManager)_footerStyle).SaveViewState() : null;
object rowStyleState = (_rowStyle != null) ? ((IStateManager)_rowStyle).SaveViewState() : null;
object editRowStyleState = (_editRowStyle != null) ? ((IStateManager)_editRowStyle).SaveViewState() : null;
object insertRowStyleState = (_insertRowStyle != null) ? ((IStateManager)_insertRowStyle).SaveViewState() : null;
object boundFieldValuesState = (_boundFieldValues != null) ? OrderedDictionaryStateHelper.SaveViewState(_boundFieldValues) : null;
object pagerSettingsState = (_pagerSettings != null) ? ((IStateManager)_pagerSettings).SaveViewState() : null;
object controlState = ControlStyleCreated ? ((IStateManager)ControlStyle).SaveViewState() : null;
object[] myState = new object[10];
myState[0] = baseState;
myState[1] = pagerStyleState;
myState[2] = headerStyleState;
myState[3] = footerStyleState;
myState[4] = rowStyleState;
myState[5] = editRowStyleState;
myState[6] = insertRowStyleState;
myState[7] = boundFieldValuesState;
myState[8] = pagerSettingsState;
myState[9] = controlState;
// note that we always have some state, atleast the RowCount
return myState;
}
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
Justification = "A property already exists. This method does additional work.")]
public void SetPageIndex(int index) {
HandlePage(index);
}
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 HttpException(SR.GetString(SR.DataBoundControl_DataSourceDoesntSupportPaging));
}
///
/// Marks the starting point to begin tracking and saving changes to the
/// control as part of the control viewstate.
///
protected override void TrackViewState() {
base.TrackViewState();
if (_pagerStyle != null)
((IStateManager)_pagerStyle).TrackViewState();
if (_headerStyle != null)
((IStateManager)_headerStyle).TrackViewState();
if (_footerStyle != null)
((IStateManager)_footerStyle).TrackViewState();
if (_rowStyle != null)
((IStateManager)_rowStyle).TrackViewState();
if (_editRowStyle != null)
((IStateManager)_editRowStyle).TrackViewState();
if (_insertRowStyle != null)
((IStateManager)_insertRowStyle).TrackViewState();
if (_pagerSettings != null)
((IStateManager)_pagerSettings).TrackViewState();
if (ControlStyleCreated)
((IStateManager)ControlStyle).TrackViewState();
}
public virtual void UpdateItem(bool causesValidation) {
ResetModelValidationGroup(causesValidation, String.Empty);
HandleUpdate(String.Empty, causesValidation);
}
#region IPostBackContainer implementation
PostBackOptions IPostBackContainer.GetPostBackOptions(IButtonControl buttonControl) {
if (buttonControl == null) {
throw new ArgumentNullException("buttonControl");
}
if (buttonControl.CausesValidation) {
throw new InvalidOperationException(SR.GetString(SR.CannotUseParentPostBackWhenValidating, this.GetType().Name, ID));
}
PostBackOptions options = new PostBackOptions(this, buttonControl.CommandName + "$" + buttonControl.CommandArgument);
options.RequiresJavaScriptProtocol = true;
return options;
}
#endregion
#region IPostBackEventHandler implementation
void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) {
RaisePostBackEvent(eventArgument);
}
#endregion
#region IDataItemContainer implementation
int IDataItemContainer.DataItemIndex {
get {
return DataItemIndex;
}
}
int IDataItemContainer.DisplayIndex {
get {
return 0;
}
}
#endregion
#region IDataBoundItemControl implementation
DataKey IDataBoundItemControl.DataKey {
get {
return DataKey;
}
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes",
Justification = "The property is only used to genericly access the databound control's mode, and should only be accessed through the interface")]
DataBoundControlMode IDataBoundItemControl.Mode {
get {
switch (Mode) {
case FormViewMode.Edit:
return DataBoundControlMode.Edit;
case FormViewMode.Insert:
return DataBoundControlMode.Insert;
case FormViewMode.ReadOnly:
return DataBoundControlMode.ReadOnly;
default:
Debug.Fail("shouldn't get here!");
return DataBoundControlMode.ReadOnly;
}
}
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")]
string IDataBoundControl.DataSourceID {
get {
return DataSourceID;
}
set {
DataSourceID = value;
}
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")]
IDataSource IDataBoundControl.DataSourceObject {
get {
return DataSourceObject;
}
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")]
object IDataBoundControl.DataSource {
get {
return DataSource;
}
set {
DataSource = value;
}
}
string[] IDataBoundControl.DataKeyNames {
get {
return DataKeyNames;
}
set {
DataKeyNames = value;
}
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The property is accessible through the DataBoundControl")]
string IDataBoundControl.DataMember {
get {
return DataMember;
}
set {
DataMember = 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
- TrackingMemoryStreamFactory.cs
- RawStylusInputCustomData.cs
- Byte.cs
- EndpointAddressProcessor.cs
- SessionEndedEventArgs.cs
- CqlParser.cs
- TextLine.cs
- GeneralTransform3D.cs
- LineSegment.cs
- Int32Storage.cs
- EndpointDiscoveryBehavior.cs
- GestureRecognizer.cs
- IChannel.cs
- VScrollBar.cs
- TreeNodeCollection.cs
- DataGridViewRowPrePaintEventArgs.cs
- GorillaCodec.cs
- ReadOnlyDictionary.cs
- ValidationEventArgs.cs
- EntityContainerEmitter.cs
- Visual3D.cs
- NamedPipeWorkerProcess.cs
- XPathNavigatorReader.cs
- BufferedGraphicsManager.cs
- _SSPIWrapper.cs
- UrlAuthFailedErrorFormatter.cs
- ChannelCacheDefaults.cs
- MsmqHostedTransportConfiguration.cs
- SHA1Managed.cs
- TimeSpan.cs
- ScriptingRoleServiceSection.cs
- EnterpriseServicesHelper.cs
- InfoCardRSAOAEPKeyExchangeDeformatter.cs
- HttpFileCollection.cs
- ElasticEase.cs
- AttributeQuery.cs
- PropertySet.cs
- XmlSchemaImport.cs
- TextWriterEngine.cs
- ReadOnlyDictionary.cs
- XmlDocumentSerializer.cs
- ApplicationProxyInternal.cs
- Slider.cs
- XmlHierarchicalEnumerable.cs
- OperationInfo.cs
- HealthMonitoringSectionHelper.cs
- QueryException.cs
- OptimalBreakSession.cs
- EventLogSession.cs
- QilPatternFactory.cs
- DesignerDeviceConfig.cs
- Selection.cs
- CommandExpr.cs
- GridViewRowCollection.cs
- DataGridViewSelectedColumnCollection.cs
- EventlogProvider.cs
- PriorityBinding.cs
- Light.cs
- ToolStripRenderEventArgs.cs
- Floater.cs
- Rect3D.cs
- XmlSerializerSection.cs
- SqlDataSourceParameterParser.cs
- ResourcePool.cs
- TextTreeNode.cs
- AdCreatedEventArgs.cs
- DocComment.cs
- ReadOnlyAttribute.cs
- DataGridViewCellParsingEventArgs.cs
- SmiTypedGetterSetter.cs
- UIHelper.cs
- SplayTreeNode.cs
- XhtmlTextWriter.cs
- Renderer.cs
- CatalogZone.cs
- WebPartConnectionsCloseVerb.cs
- SelectionEditingBehavior.cs
- AttachedPropertyBrowsableForTypeAttribute.cs
- FlowDocumentPageViewerAutomationPeer.cs
- ScrollableControl.cs
- DataGridViewRowCancelEventArgs.cs
- _TransmitFileOverlappedAsyncResult.cs
- RegexReplacement.cs
- SqlUtil.cs
- FilterException.cs
- MenuItemCollection.cs
- PageVisual.cs
- VScrollBar.cs
- OrCondition.cs
- HwndSubclass.cs
- IResourceProvider.cs
- TypeDescriptionProviderAttribute.cs
- ToolBar.cs
- ConfigurationElement.cs
- SQLSingle.cs
- Cell.cs
- String.cs
- CollectionChangedEventManager.cs
- LinqDataSourceView.cs
- Trace.cs