mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 01:41:17 -10:00
* add new resources: PageWithAdapter.aspx for PageTest and PageAdapterTest. TestCapability.browser for AppBrowsersTest. * NunitWebResources/adapters.browser, NunitWebResources/AppBrowsersTest.browser: modified to support testing reference nodes with captures, and adapters. * NunitWeb/NunitWeb/WebTest.cs: ensure that, during AppDomain unload, no new requests are sent to the app host and any pending requests are completed before the the unload occurs. Also added WebTest.AppUnloaded event that tests can use to wait for the app to unload (e.g. after touching Global.asax), and WebTest.CleanApp() which can be called to restart the app with the a skeleton directory structure. Tests which add files that could effect other tests (e.g. App_Browsers/*.browser files) should call WebTest.CleanApp() during TearDown to return the app to a pristine environment. ++ Test/mainsoft/MainsoftWebTest/ChangeLog (working copy) * HtmlAgilityPack/AssemblyInfo.cs: made assembly delay signed so that tests can access System.Web internals now that System.Web is InternalsVisibleTo this assembly. ++ Test/System.Web/ChangeLog (working copy) * AppBrowsersTest.cs: added. Includes tests for Control.Adapter, Control.ResolveAdapter, Control.TagWriter, and Control.CreateHtmlTextWriter, when using App_Browsers/*.browser files. AppBrowsersTest is currently tagged [Ignore], pending a fix for bug #351878. * HttpRuntimeTest.cs: added. Includes test for HttpRuntime.UnloadAppDomain(). Marked [Ignore], pending a fix for bug #351878. ++ Test/System.Web.UI.Adapters/ChangeLog (revision 0) * PageAdapterTest.cs: added tests for PageAdapter. * ControlAdapterTest.cs (ConfigCapabilitiesNotCalled): added test to ensure that HttpCapabilitiesBase.ConfigCapabilities() is not called during normal page processing if no files are in App_Browsers. * ControlAdapterTest.cs: added tests for ControlAdapter. ++ Test/System.Web.UI/ChangeLog (working copy) * PageTest.cs: add tests for using a PageAdapter. * ControlTest.cs: moved commented out ResolveAdapter_1 test to ../System.Web/AppBrowsersTest.cs. Fixed typo in test name. Added Customcontroladapter.Adapter property for use by AppBrowsersTest. ++ Test/System.Web.UI.WebControls.Adapters/ChangeLog (revision 0) * MenuAdapterTest.cs: added * WebControlAdapterTest.cs, HierarchicalDataBoundControlAdapterTest.cs, DataBoundControlAdapterTest.cs, HideDisabledControlAdapterTest.cs: added ++ Test/System.Web.UI.WebControls/ChangeLog (working copy) * MenuTest.cs (Menu_RenderStaticItems): added tests to check that result was the same when using the base MenuAdapter as when using no adapter. * MenuTest.cs (Menu_RenderStaticItemsWithAdapter): added test to ensure that MenuAdapter.RenderItem() is called. * HierarchicalDataBoundControlTest.cs, WebControlTest.cs, DataBoundControlTest.cs: added test for use of ControlAdapters when present. * WebControl.cs: added test for IsEnabled. ++ System.Web/ChangeLog (working copy) * HttpApplicationFactory.cs: Added support for detecting App_Browsers/*.browser files and using them to determine capabilities. Also restart the app if the App_Browsers, App_Code, or App_GlobalResources directories are created. * BrowserCapabilities.cs (TagWriter): get value via internal virtual GetTagWriter() method, which is overridden in nBrowser.Result. * HttpRequest.cs (BrowserMightHaveSpecialWriter, BrowserMightHaveAdapters): internal properties added to allow Page and Control methods to avoid accessing Request.Browser to get browser-specific HtmlTextWriters or ControlAdapters. Those things only exist when there are App_Browsers files. ++ System.Web.UI.Adapters/ChangeLog (working copy) * ControlAdapter.cs: made control field internal so derived internal classes can access it without using base.Control which can involved several typecasts. * PageAdapter.cs: implemented all members. * ControlAdapter.cs: implemented all members. * PageAdapter.cs, ControlAdapter.cs: add MonoTODO's. ++ System.Web.UI/ChangeLog (working copy) * Page.cs (SavePageControlState, LoadPageControlState): save/load adapter state in 2.0 profile. * Page.cs (CreateHtmlTextWriter): call Browser.CreateHtmlTextWriter() in 2.0 profile. * Page.cs (RenderPage): call CreateHtmlTextWriter() to get the writer in 2.0 profile. * Page.cs (DeterminePostBackMode, InitOutputCache, RenderClientScriptFormDeclaration, InternalProcessRequest, PageStatePersister): added support for PageAdapters. * Control.cs (Adapter, ResolveAdapter): implemented. Adapter calls ResolveAdapter and remembers result. ResolveAdapter checks for adapters of the Type hierarchy until it finds one. * Control.cs (SaveViewStateRecursive, LoadViewStateRecursive): save/load adapter state in 2.0 profile. * HtmlTextWriter.cs (BeginRender, EndRender): added empty virtual methods required by 2.0 profile. These are called by corresponding methods of System.Web.UI.Adapters.ControlAdapter. * Page.cs, Control.cs: don't access Request.Browser if it couldn't have any adapters/writers because there are no files in App_Browsers/. ++ Assembly/ChangeLog (working copy) * AssemblyInfo.cs: made InternalsVisibleTo System.Web.test_net_2_0.dll to support ControlAdapterTest.ConfigCapabilitiesNotCalled(). ++ ChangeLog (working copy) * System.Web_test.dll.sources: added System.Web.UI.WebControls.Adapters/MenuAdapterTest.cs System.Web.UI.WebControls.Adapters/WebControlAdapterTest.cs System.Web.UI.WebControls.Adapters/HierarchicalDataBoundControlAdapterTest.cs System.Web.UI.WebControls.Adapters/DataBoundControlAdapterTest.cs System.Web.UI.WebControls.Adapters/HideDisabledControlAdapterTest.cs System.Web.UI.Adapters/PageAdapterTest.cs System.Web.UI.Adapters/ControlAdapterTest.cs * Makefile (RESOURCE_FILES_2): added System.Web.Configuration_2.0/RandomRoboBotKeywords.txt * Makefile (TEST_RESOURCE_FILES): added Test/mainsoft/NunitWebResources/PageWithAdapter.aspx * System.Web.dll.sources: added System.Web.Configuration_2.0/CapabilitiesBuild.cs System.Web.Configuration_2.0/CapabilitiesChecksum.cs System.Web.Configuration_2.0/CapabilitiesResult.cs System.Web.Configuration_2.0/ICapabilitiesProcess.cs System.Web.Configuration_2.0/nBrowser/Result.cs System.Web.Configuration_2.0/nBrowser/NodeTypes.cs System.Web.Configuration_2.0/nBrowser/Identification.cs System.Web.Configuration_2.0/nBrowser/File.cs System.Web.Configuration_2.0/nBrowser/Build.cs System.Web.Configuration_2.0/nBrowser/Node.cs System.Web.Configuration_2.0/nBrowser/Exception.cs ++ System.Web.UI.WebControls.Adapters/ChangeLog (working copy) * WebControlAdapter.cs, HierarchicalDataBoundControlAdapter.cs, DataBoundControlAdapter.cs: changed to use ControlAdapter.control instead of using base.Control or using a new control field. * MenuAdapter.cs: added internal constructor that takes a Menu parameter. The constructor is used when writing unit tests. * MenuAdapter.cs (OnInit, OnPreRender, RenderBeginTag, RenderContents, RenderEndTag): delegate to base instead of Control. * MenuAdapter.cs (LoadAdapterControlState, SaveAdapterControlState, RaisePostBackEvent, RenderItem): implemented. * WebControlAdapter.cs (RenderContents): changed to call control.RenderContents() instead of control.Render(). * WebControlAdapter.cs, HierarchicalDataBoundControlAdapter.cs, DataBoundControlAdapter.cs, HideDisabledControlAdapter.cs: added internal constructor that takes a parameter of the corresponding Control type. The construct is used when writing unit tests. ++ System.Web.Configuration_2.0/ChangeLog (working copy) * nBrowser/Result.cs, nBrowser/NodeTypes.cs, nBrowser/Identification.cs, nBrowser/File.cs, nBrowser/Build.cs, nBrowser/Node.cs, nBrowser/Exception.cs: added. The code under nBrowser handles *.browser files. It is based on Owen "Ocean" Brady's code, with the following changes and improvements. Replaced Result.Adapter property with AdapterTypeMap property which maps control Type to adapter Type. Added Result.MarkupTextWriter property. Added overrides for Result.GetAdapters and Result.GetTagWriter to return MarkupTextWriter and AdapterTypeMap, resp. Changed tree building algorithm to not depend on nodes with id="Default" and to inject defaultBrowser nodes as parents of regular nodes with the same ids. Changed Node.cs to use Item instead of Add when adding a capability or sample header, so that values get replaced instead of appended. Added support for reference nodes (ie. nodes with refID="someID"). * CapabilitiesResult.cs: load RandomRoboBotKeywords.txt resource using the correct name. * RandomRoboBotKeywords.txt: added * HttpCapabilitiesBase.cs (CreateHtmlWriter, Adapters): Added support for *.browsers. Adapters property calls internal virtual GetAdapters() method which is overrided in nBrowser.Result returned by nBrowser code. CreateHtmlWriter uses type specified by TagWriter property. ++ System.Web.UI.WebControls/ChangeLog (working copy) * DetailsView.cs, ListControl.cs, DataBoundControl.cs, FormView.cs, HierarchicalDataBoundControl.cs, WebControl.cs: added support for using ControlAdapters when present. * WebControl.cs: fixed implementation of IsEnabled to match documentation. * Menu.cs (RenderMenuBody): call Adapter.RenderItem() instead of RenderMenuItem() if an adapter is present. MenuAdapter.RenderItem() calls back to new Menu.RenderItem() internal method which calls RenderMenuItem() with the appropriate parameters. ++ System.Web.Configuration/ChangeLog (working copy) * HttpCapabilitiesBase.cs: changed to use nBrowser for *.browser support. Also added internal GetConfigCapabilities_called flag used by ControlAdapterTest.ConfigCapabilitiesNotCalled() to test that GetConfigCapabilities() is not called during normal page processing when there are no files in App_Browsers/. svn path=/trunk/mcs/; revision=97824
1978 lines
61 KiB
C#
1978 lines
61 KiB
C#
//
|
|
// System.Web.UI.WebControls.DetailsView.cs
|
|
//
|
|
// Authors:
|
|
// Lluis Sanchez Gual ([email protected])
|
|
//
|
|
// (C) 2005 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
#if NET_2_0
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Web.UI;
|
|
using System.Security.Permissions;
|
|
using System.Text;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
|
|
namespace System.Web.UI.WebControls
|
|
{
|
|
[SupportsEventValidation]
|
|
[ToolboxDataAttribute ("<{0}:DetailsView runat=\"server\" Width=\"125px\" Height=\"50px\"></{0}:DetailsView>")]
|
|
[DesignerAttribute ("System.Web.UI.Design.WebControls.DetailsViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
|
|
[ControlValuePropertyAttribute ("SelectedValue")]
|
|
[DefaultEventAttribute ("PageIndexChanging")]
|
|
[AspNetHostingPermissionAttribute (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
|
[AspNetHostingPermissionAttribute (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
|
public class DetailsView: CompositeDataBoundControl, ICallbackEventHandler, ICallbackContainer, IDataItemContainer, INamingContainer, IPostBackEventHandler, IPostBackContainer
|
|
{
|
|
object dataItem;
|
|
|
|
Table table;
|
|
DetailsViewRowCollection rows;
|
|
DetailsViewRow headerRow;
|
|
DetailsViewRow footerRow;
|
|
DetailsViewRow bottomPagerRow;
|
|
DetailsViewRow topPagerRow;
|
|
|
|
IOrderedDictionary currentEditRowKeys;
|
|
IOrderedDictionary currentEditNewValues;
|
|
IOrderedDictionary currentEditOldValues;
|
|
|
|
ITemplate pagerTemplate;
|
|
ITemplate emptyDataTemplate;
|
|
ITemplate headerTemplate;
|
|
ITemplate footerTemplate;
|
|
|
|
PropertyDescriptor[] cachedKeyProperties;
|
|
readonly string[] emptyKeys = new string[0];
|
|
readonly string unhandledEventExceptionMessage = "The DetailsView '{0}' fired event {1} which wasn't handled.";
|
|
|
|
// View state
|
|
DataControlFieldCollection columns;
|
|
PagerSettings pagerSettings;
|
|
|
|
TableItemStyle alternatingRowStyle;
|
|
TableItemStyle editRowStyle;
|
|
TableItemStyle insertRowStyle;
|
|
TableItemStyle emptyDataRowStyle;
|
|
TableItemStyle footerStyle;
|
|
TableItemStyle headerStyle;
|
|
TableItemStyle pagerStyle;
|
|
TableItemStyle rowStyle;
|
|
TableItemStyle commandRowStyle;
|
|
TableItemStyle fieldHeaderStyle;
|
|
|
|
IOrderedDictionary _keyTable;
|
|
DataKey key;
|
|
DataKey oldEditValues;
|
|
AutoGeneratedFieldProperties[] autoFieldProperties;
|
|
|
|
private static readonly object PageIndexChangedEvent = new object();
|
|
private static readonly object PageIndexChangingEvent = new object();
|
|
private static readonly object ItemCommandEvent = new object();
|
|
private static readonly object ItemCreatedEvent = new object();
|
|
private static readonly object ItemDeletedEvent = new object();
|
|
private static readonly object ItemDeletingEvent = new object();
|
|
private static readonly object ItemInsertedEvent = new object();
|
|
private static readonly object ItemInsertingEvent = new object();
|
|
private static readonly object ModeChangingEvent = new object();
|
|
private static readonly object ModeChangedEvent = new object();
|
|
private static readonly object ItemUpdatedEvent = new object();
|
|
private static readonly object ItemUpdatingEvent = new object();
|
|
|
|
// Control state
|
|
int pageIndex;
|
|
DetailsViewMode currentMode = DetailsViewMode.ReadOnly;
|
|
bool hasCurrentMode;
|
|
int pageCount;
|
|
|
|
public DetailsView ()
|
|
{
|
|
rows = new DetailsViewRowCollection (new ArrayList ());
|
|
}
|
|
|
|
public event EventHandler PageIndexChanged {
|
|
add { Events.AddHandler (PageIndexChangedEvent, value); }
|
|
remove { Events.RemoveHandler (PageIndexChangedEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewPageEventHandler PageIndexChanging {
|
|
add { Events.AddHandler (PageIndexChangingEvent, value); }
|
|
remove { Events.RemoveHandler (PageIndexChangingEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewCommandEventHandler ItemCommand {
|
|
add { Events.AddHandler (ItemCommandEvent, value); }
|
|
remove { Events.RemoveHandler (ItemCommandEvent, value); }
|
|
}
|
|
|
|
public event EventHandler ItemCreated {
|
|
add { Events.AddHandler (ItemCreatedEvent, value); }
|
|
remove { Events.RemoveHandler (ItemCreatedEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewDeletedEventHandler ItemDeleted {
|
|
add { Events.AddHandler (ItemDeletedEvent, value); }
|
|
remove { Events.RemoveHandler (ItemDeletedEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewDeleteEventHandler ItemDeleting {
|
|
add { Events.AddHandler (ItemDeletingEvent, value); }
|
|
remove { Events.RemoveHandler (ItemDeletingEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewInsertedEventHandler ItemInserted {
|
|
add { Events.AddHandler (ItemInsertedEvent, value); }
|
|
remove { Events.RemoveHandler (ItemInsertedEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewInsertEventHandler ItemInserting {
|
|
add { Events.AddHandler (ItemInsertingEvent, value); }
|
|
remove { Events.RemoveHandler (ItemInsertingEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewModeEventHandler ModeChanging {
|
|
add { Events.AddHandler (ModeChangingEvent, value); }
|
|
remove { Events.RemoveHandler (ModeChangingEvent, value); }
|
|
}
|
|
|
|
public event EventHandler ModeChanged {
|
|
add { Events.AddHandler (ModeChangedEvent, value); }
|
|
remove { Events.RemoveHandler (ModeChangedEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewUpdatedEventHandler ItemUpdated {
|
|
add { Events.AddHandler (ItemUpdatedEvent, value); }
|
|
remove { Events.RemoveHandler (ItemUpdatedEvent, value); }
|
|
}
|
|
|
|
public event DetailsViewUpdateEventHandler ItemUpdating {
|
|
add { Events.AddHandler (ItemUpdatingEvent, value); }
|
|
remove { Events.RemoveHandler (ItemUpdatingEvent, value); }
|
|
}
|
|
|
|
protected virtual void OnPageIndexChanged (EventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
EventHandler eh = (EventHandler) Events [PageIndexChangedEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnPageIndexChanging (DetailsViewPageEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewPageEventHandler eh = (DetailsViewPageEventHandler) Events [PageIndexChangingEvent];
|
|
if (eh != null) {
|
|
eh (this, e);
|
|
return;
|
|
}
|
|
}
|
|
if (!IsBoundUsingDataSourceID)
|
|
throw new HttpException (String.Format (unhandledEventExceptionMessage, ID, "PageIndexChanging"));
|
|
}
|
|
|
|
protected virtual void OnItemCommand (DetailsViewCommandEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewCommandEventHandler eh = (DetailsViewCommandEventHandler) Events [ItemCommandEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnItemCreated (EventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
EventHandler eh = (EventHandler) Events [ItemCreatedEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnItemDeleted (DetailsViewDeletedEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewDeletedEventHandler eh = (DetailsViewDeletedEventHandler) Events [ItemDeletedEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnItemInserted (DetailsViewInsertedEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewInsertedEventHandler eh = (DetailsViewInsertedEventHandler) Events [ItemInsertedEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnItemInserting (DetailsViewInsertEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewInsertEventHandler eh = (DetailsViewInsertEventHandler) Events [ItemInsertingEvent];
|
|
if (eh != null) {
|
|
eh (this, e);
|
|
return;
|
|
}
|
|
}
|
|
if (!IsBoundUsingDataSourceID)
|
|
throw new HttpException (String.Format (unhandledEventExceptionMessage, ID, "ItemInserting"));
|
|
}
|
|
|
|
protected virtual void OnItemDeleting (DetailsViewDeleteEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewDeleteEventHandler eh = (DetailsViewDeleteEventHandler) Events [ItemDeletingEvent];
|
|
if (eh != null) {
|
|
eh (this, e);
|
|
return;
|
|
}
|
|
}
|
|
if (!IsBoundUsingDataSourceID)
|
|
throw new HttpException (String.Format (unhandledEventExceptionMessage, ID, "ItemDeleting"));
|
|
}
|
|
|
|
protected virtual void OnModeChanged (EventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
EventHandler eh = (EventHandler) Events [ModeChangedEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnModeChanging (DetailsViewModeEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewModeEventHandler eh = (DetailsViewModeEventHandler) Events [ModeChangingEvent];
|
|
if (eh != null) {
|
|
eh (this, e);
|
|
return;
|
|
}
|
|
}
|
|
if (!IsBoundUsingDataSourceID)
|
|
throw new HttpException (String.Format (unhandledEventExceptionMessage, ID, "ModeChanging"));
|
|
}
|
|
|
|
protected virtual void OnItemUpdated (DetailsViewUpdatedEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewUpdatedEventHandler eh = (DetailsViewUpdatedEventHandler) Events [ItemUpdatedEvent];
|
|
if (eh != null) eh (this, e);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnItemUpdating (DetailsViewUpdateEventArgs e)
|
|
{
|
|
if (Events != null) {
|
|
DetailsViewUpdateEventHandler eh = (DetailsViewUpdateEventHandler) Events [ItemUpdatingEvent];
|
|
if (eh != null) {
|
|
eh (this, e);
|
|
return;
|
|
}
|
|
}
|
|
if (!IsBoundUsingDataSourceID)
|
|
throw new HttpException (String.Format (unhandledEventExceptionMessage, ID, "ItemUpdating"));
|
|
}
|
|
|
|
|
|
[WebCategoryAttribute ("Paging")]
|
|
[DefaultValueAttribute (false)]
|
|
public virtual bool AllowPaging {
|
|
get {
|
|
object ob = ViewState ["AllowPaging"];
|
|
if (ob != null) return (bool) ob;
|
|
return false;
|
|
}
|
|
set {
|
|
ViewState ["AllowPaging"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[DefaultValueAttribute (null)]
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public TableItemStyle AlternatingRowStyle {
|
|
get {
|
|
if (alternatingRowStyle == null) {
|
|
alternatingRowStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
alternatingRowStyle.TrackViewState();
|
|
}
|
|
return alternatingRowStyle;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Behavior")]
|
|
[DefaultValueAttribute (false)]
|
|
public virtual bool AutoGenerateEditButton {
|
|
get {
|
|
object ob = ViewState ["AutoGenerateEditButton"];
|
|
if (ob != null) return (bool) ob;
|
|
return false;
|
|
}
|
|
set {
|
|
ViewState ["AutoGenerateEditButton"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Behavior")]
|
|
[DefaultValueAttribute (false)]
|
|
public virtual bool AutoGenerateDeleteButton {
|
|
get {
|
|
object ob = ViewState ["AutoGenerateDeleteButton"];
|
|
if (ob != null) return (bool) ob;
|
|
return false;
|
|
}
|
|
set {
|
|
ViewState ["AutoGenerateDeleteButton"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Behavior")]
|
|
[DefaultValueAttribute (false)]
|
|
public virtual bool AutoGenerateInsertButton {
|
|
get {
|
|
object ob = ViewState ["AutoGenerateInsertButton"];
|
|
if (ob != null) return (bool) ob;
|
|
return false;
|
|
}
|
|
set {
|
|
ViewState ["AutoGenerateInsertButton"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Behavior")]
|
|
[DefaultValueAttribute (true)]
|
|
public virtual bool AutoGenerateRows {
|
|
get {
|
|
object ob = ViewState ["AutoGenerateRows"];
|
|
if (ob != null) return (bool) ob;
|
|
return true;
|
|
}
|
|
set {
|
|
ViewState ["AutoGenerateRows"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[UrlPropertyAttribute]
|
|
[WebCategoryAttribute ("Appearance")]
|
|
[DefaultValueAttribute ("")]
|
|
[EditorAttribute ("System.Web.UI.Design.ImageUrlEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
public virtual string BackImageUrl {
|
|
get {
|
|
if (ControlStyleCreated)
|
|
return ((TableStyle) ControlStyle).BackImageUrl;
|
|
return String.Empty;
|
|
}
|
|
set {
|
|
((TableStyle) ControlStyle).BackImageUrl = value;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual DetailsViewRow BottomPagerRow {
|
|
get {
|
|
EnsureChildControls ();
|
|
return bottomPagerRow;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Accessibility")]
|
|
[DefaultValueAttribute ("")]
|
|
[LocalizableAttribute (true)]
|
|
public virtual string Caption {
|
|
get {
|
|
object ob = ViewState ["Caption"];
|
|
if (ob != null) return (string) ob;
|
|
return string.Empty;
|
|
}
|
|
set {
|
|
ViewState ["Caption"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Accessibility")]
|
|
[DefaultValueAttribute (TableCaptionAlign.NotSet)]
|
|
public virtual TableCaptionAlign CaptionAlign
|
|
{
|
|
get {
|
|
object o = ViewState ["CaptionAlign"];
|
|
if(o != null) return (TableCaptionAlign) o;
|
|
return TableCaptionAlign.NotSet;
|
|
}
|
|
set {
|
|
ViewState ["CaptionAlign"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Layout")]
|
|
[DefaultValueAttribute (-1)]
|
|
public virtual int CellPadding
|
|
{
|
|
get {
|
|
if (ControlStyleCreated)
|
|
return ((TableStyle) ControlStyle).CellPadding;
|
|
return -1;
|
|
}
|
|
set {
|
|
((TableStyle) ControlStyle).CellPadding = value;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Layout")]
|
|
[DefaultValueAttribute (0)]
|
|
public virtual int CellSpacing
|
|
{
|
|
get {
|
|
if (ControlStyleCreated)
|
|
return ((TableStyle) ControlStyle).CellSpacing;
|
|
return 0;
|
|
}
|
|
set {
|
|
((TableStyle) ControlStyle).CellSpacing = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValueAttribute (null)]
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public TableItemStyle CommandRowStyle {
|
|
get {
|
|
if (commandRowStyle == null) {
|
|
commandRowStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
commandRowStyle.TrackViewState();
|
|
}
|
|
return commandRowStyle;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public DetailsViewMode CurrentMode {
|
|
get {
|
|
return hasCurrentMode ? currentMode : DefaultMode;
|
|
}
|
|
private set {
|
|
hasCurrentMode = true;
|
|
currentMode = value;
|
|
}
|
|
}
|
|
|
|
DetailsViewMode defaultMode = DetailsViewMode.ReadOnly;
|
|
[DefaultValueAttribute (DetailsViewMode.ReadOnly)]
|
|
[WebCategoryAttribute ("Behavior")]
|
|
public virtual DetailsViewMode DefaultMode {
|
|
get {
|
|
return defaultMode;
|
|
}
|
|
set {
|
|
defaultMode = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[EditorAttribute ("System.Web.UI.Design.WebControls.DataControlFieldTypeEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
[MergablePropertyAttribute (false)]
|
|
[PersistenceModeAttribute (PersistenceMode.InnerProperty)]
|
|
[DefaultValueAttribute (null)]
|
|
[WebCategoryAttribute ("Misc")]
|
|
public virtual DataControlFieldCollection Fields {
|
|
get {
|
|
if (columns == null) {
|
|
columns = new DataControlFieldCollection ();
|
|
columns.FieldsChanged += new EventHandler (OnFieldsChanged);
|
|
if (IsTrackingViewState)
|
|
((IStateManager)columns).TrackViewState ();
|
|
}
|
|
return columns;
|
|
}
|
|
}
|
|
|
|
string[] dataKeyNames = null;
|
|
|
|
[DefaultValueAttribute (null)]
|
|
[WebCategoryAttribute ("Data")]
|
|
[TypeConverter (typeof(StringArrayConverter))]
|
|
[EditorAttribute ("System.Web.UI.Design.WebControls.DataFieldEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
public virtual string[] DataKeyNames
|
|
{
|
|
get {
|
|
if (dataKeyNames == null)
|
|
return emptyKeys;
|
|
else
|
|
return dataKeyNames;
|
|
}
|
|
set {
|
|
dataKeyNames = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
IOrderedDictionary KeyTable {
|
|
get {
|
|
if (_keyTable == null) {
|
|
_keyTable = new OrderedDictionary (DataKeyNames.Length);
|
|
}
|
|
return _keyTable;
|
|
}
|
|
}
|
|
|
|
[BrowsableAttribute (false)]
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
public virtual DataKey DataKey {
|
|
get {
|
|
if (key == null) {
|
|
key = new DataKey (KeyTable);
|
|
}
|
|
return key;
|
|
}
|
|
}
|
|
|
|
DataKey OldEditValues {
|
|
get {
|
|
if (oldEditValues == null) {
|
|
oldEditValues = new DataKey (new OrderedDictionary ());
|
|
}
|
|
return oldEditValues;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
[DefaultValueAttribute (null)]
|
|
public TableItemStyle EditRowStyle {
|
|
get {
|
|
if (editRowStyle == null) {
|
|
editRowStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
editRowStyle.TrackViewState();
|
|
}
|
|
return editRowStyle;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
[DefaultValueAttribute (null)]
|
|
public TableItemStyle EmptyDataRowStyle {
|
|
get {
|
|
if (emptyDataRowStyle == null) {
|
|
emptyDataRowStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
emptyDataRowStyle.TrackViewState();
|
|
}
|
|
return emptyDataRowStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue (null)]
|
|
[TemplateContainer (typeof(DetailsView), BindingDirection.OneWay)]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[Browsable (false)]
|
|
public virtual ITemplate EmptyDataTemplate {
|
|
get { return emptyDataTemplate; }
|
|
set { emptyDataTemplate = value; }
|
|
}
|
|
|
|
[LocalizableAttribute (true)]
|
|
[WebCategoryAttribute ("Appearance")]
|
|
[DefaultValueAttribute ("")]
|
|
public virtual string EmptyDataText {
|
|
get {
|
|
object ob = ViewState ["EmptyDataText"];
|
|
if (ob != null) return (string) ob;
|
|
return string.Empty;
|
|
}
|
|
set {
|
|
ViewState ["EmptyDataText"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Behavior")]
|
|
[DefaultValueAttribute (false)]
|
|
public virtual bool EnablePagingCallbacks {
|
|
get {
|
|
object ob = ViewState ["EnablePagingCallbacks"];
|
|
if (ob != null) return (bool) ob;
|
|
return false;
|
|
}
|
|
set {
|
|
ViewState ["EnablePagingCallbacks"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DefaultValue (null)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public TableItemStyle FieldHeaderStyle {
|
|
get {
|
|
if (fieldHeaderStyle == null) {
|
|
fieldHeaderStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
fieldHeaderStyle.TrackViewState();
|
|
}
|
|
return fieldHeaderStyle;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual DetailsViewRow FooterRow {
|
|
get {
|
|
EnsureChildControls ();
|
|
return footerRow;
|
|
}
|
|
}
|
|
|
|
[DefaultValue (null)]
|
|
[TemplateContainer (typeof(DetailsView), BindingDirection.OneWay)]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[Browsable (false)]
|
|
public virtual ITemplate FooterTemplate {
|
|
get { return footerTemplate; }
|
|
set { footerTemplate = value; }
|
|
}
|
|
|
|
[LocalizableAttribute (true)]
|
|
[WebCategoryAttribute ("Appearance")]
|
|
[DefaultValueAttribute ("")]
|
|
public virtual string FooterText {
|
|
get {
|
|
object ob = ViewState ["FooterText"];
|
|
if (ob != null) return (string) ob;
|
|
return string.Empty;
|
|
}
|
|
set {
|
|
ViewState ["FooterText"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DefaultValue (null)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public TableItemStyle FooterStyle {
|
|
get {
|
|
if (footerStyle == null) {
|
|
footerStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
footerStyle.TrackViewState();
|
|
}
|
|
return footerStyle;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Appearance")]
|
|
[DefaultValueAttribute (GridLines.Both)]
|
|
public virtual GridLines GridLines {
|
|
get {
|
|
if (ControlStyleCreated)
|
|
return ((TableStyle) ControlStyle).GridLines;
|
|
return GridLines.Both;
|
|
}
|
|
set {
|
|
((TableStyle) ControlStyle).GridLines = value;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual DetailsViewRow HeaderRow {
|
|
get {
|
|
EnsureChildControls ();
|
|
return headerRow;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DefaultValue (null)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public TableItemStyle HeaderStyle {
|
|
get {
|
|
if (headerStyle == null) {
|
|
headerStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
headerStyle.TrackViewState();
|
|
}
|
|
return headerStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue (null)]
|
|
[TemplateContainer (typeof(DetailsView), BindingDirection.OneWay)]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[Browsable (false)]
|
|
public virtual ITemplate HeaderTemplate {
|
|
get { return headerTemplate; }
|
|
set { headerTemplate = value; }
|
|
}
|
|
|
|
[LocalizableAttribute (true)]
|
|
[WebCategoryAttribute ("Appearance")]
|
|
[DefaultValueAttribute ("")]
|
|
public virtual string HeaderText {
|
|
get {
|
|
object ob = ViewState ["HeaderText"];
|
|
if (ob != null) return (string) ob;
|
|
return string.Empty;
|
|
}
|
|
set {
|
|
ViewState ["HeaderText"] = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[Category ("Layout")]
|
|
[DefaultValueAttribute (HorizontalAlign.NotSet)]
|
|
public virtual HorizontalAlign HorizontalAlign {
|
|
get {
|
|
if (ControlStyleCreated)
|
|
return ((TableStyle) ControlStyle).HorizontalAlign;
|
|
return HorizontalAlign.NotSet;
|
|
}
|
|
set {
|
|
((TableStyle) ControlStyle).HorizontalAlign = value;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
[DefaultValueAttribute (null)]
|
|
public TableItemStyle InsertRowStyle {
|
|
get {
|
|
if (insertRowStyle == null) {
|
|
insertRowStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
insertRowStyle.TrackViewState();
|
|
}
|
|
return insertRowStyle;
|
|
}
|
|
}
|
|
|
|
[BrowsableAttribute (false)]
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
public virtual int PageCount {
|
|
get {
|
|
return pageCount;
|
|
}
|
|
private set {
|
|
pageCount = value;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Paging")]
|
|
[BindableAttribute (true, BindingDirection.OneWay)]
|
|
[DefaultValueAttribute (0)]
|
|
public virtual int PageIndex {
|
|
get {
|
|
if (CurrentMode == DetailsViewMode.Insert)
|
|
return -1;
|
|
return pageIndex;
|
|
}
|
|
set {
|
|
if (value < -1)
|
|
throw new ArgumentOutOfRangeException ("PageIndex must be non-negative");
|
|
if (pageIndex == value || value == -1)
|
|
return;
|
|
pageIndex = value;
|
|
RequireBinding ();
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Paging")]
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Content)]
|
|
[NotifyParentPropertyAttribute (true)]
|
|
[PersistenceModeAttribute (PersistenceMode.InnerProperty)]
|
|
public virtual PagerSettings PagerSettings {
|
|
get {
|
|
if (pagerSettings == null) {
|
|
pagerSettings = new PagerSettings (this);
|
|
if (IsTrackingViewState)
|
|
((IStateManager)pagerSettings).TrackViewState ();
|
|
}
|
|
return pagerSettings;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public TableItemStyle PagerStyle {
|
|
get {
|
|
if (pagerStyle == null) {
|
|
pagerStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
pagerStyle.TrackViewState();
|
|
}
|
|
return pagerStyle;
|
|
}
|
|
}
|
|
|
|
|
|
[DefaultValue (null)]
|
|
[TemplateContainer (typeof (DetailsView), BindingDirection.OneWay)]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[Browsable (false)]
|
|
public virtual ITemplate PagerTemplate {
|
|
get { return pagerTemplate; }
|
|
set { pagerTemplate = value; }
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual DetailsViewRowCollection Rows {
|
|
get {
|
|
EnsureChildControls ();
|
|
return rows;
|
|
}
|
|
}
|
|
|
|
[WebCategoryAttribute ("Styles")]
|
|
[PersistenceMode (PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
[DefaultValue (null)]
|
|
public TableItemStyle RowStyle {
|
|
get {
|
|
if (rowStyle == null) {
|
|
rowStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
rowStyle.TrackViewState();
|
|
}
|
|
return rowStyle;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public object SelectedValue {
|
|
get { return DataKey.Value; }
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual DetailsViewRow TopPagerRow {
|
|
get {
|
|
EnsureChildControls ();
|
|
return topPagerRow;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual object DataItem {
|
|
get {
|
|
return dataItem;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public int DataItemCount {
|
|
get { return PageCount; }
|
|
}
|
|
|
|
[DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility.Hidden)]
|
|
[BrowsableAttribute (false)]
|
|
public virtual int DataItemIndex {
|
|
get { return PageIndex; }
|
|
}
|
|
|
|
int IDataItemContainer.DisplayIndex {
|
|
get { return PageIndex; }
|
|
}
|
|
|
|
int IDataItemContainer.DataItemIndex {
|
|
get { return DataItemIndex; }
|
|
}
|
|
|
|
public virtual bool IsBindableType (Type type)
|
|
{
|
|
return type.IsPrimitive || type == typeof (string) || type == typeof (DateTime) || type == typeof (Guid) || type == typeof (Decimal);
|
|
}
|
|
|
|
protected override DataSourceSelectArguments CreateDataSourceSelectArguments ()
|
|
{
|
|
DataSourceSelectArguments arg = new DataSourceSelectArguments ();
|
|
DataSourceView view = GetData ();
|
|
if (AllowPaging && view.CanPage) {
|
|
arg.StartRowIndex = PageIndex;
|
|
if (view.CanRetrieveTotalRowCount) {
|
|
arg.RetrieveTotalRowCount = true;
|
|
arg.MaximumRows = 1;
|
|
}
|
|
else {
|
|
arg.MaximumRows = -1;
|
|
}
|
|
}
|
|
return arg;
|
|
}
|
|
|
|
protected virtual ICollection CreateFieldSet (object dataItem, bool useDataSource)
|
|
{
|
|
ArrayList fields = new ArrayList ();
|
|
|
|
if (AutoGenerateRows) {
|
|
if (useDataSource) {
|
|
if (dataItem != null)
|
|
fields.AddRange (CreateAutoGeneratedRows (dataItem));
|
|
} else {
|
|
if (autoFieldProperties != null) {
|
|
foreach (AutoGeneratedFieldProperties props in autoFieldProperties)
|
|
fields.Add (CreateAutoGeneratedRow (props));
|
|
}
|
|
}
|
|
}
|
|
|
|
fields.AddRange (Fields);
|
|
|
|
if (AutoGenerateEditButton || AutoGenerateDeleteButton || AutoGenerateInsertButton) {
|
|
CommandField field = new CommandField ();
|
|
field.ShowEditButton = AutoGenerateEditButton;
|
|
field.ShowDeleteButton = AutoGenerateDeleteButton;
|
|
field.ShowInsertButton = AutoGenerateInsertButton;
|
|
fields.Add (field);
|
|
}
|
|
|
|
return fields;
|
|
}
|
|
|
|
protected virtual ICollection CreateAutoGeneratedRows (object dataItem)
|
|
{
|
|
if (dataItem == null)
|
|
return null;
|
|
|
|
ArrayList list = new ArrayList ();
|
|
autoFieldProperties = CreateAutoFieldProperties (dataItem);
|
|
foreach (AutoGeneratedFieldProperties props in autoFieldProperties)
|
|
list.Add (CreateAutoGeneratedRow (props));
|
|
return list;
|
|
}
|
|
|
|
protected virtual AutoGeneratedField CreateAutoGeneratedRow (AutoGeneratedFieldProperties fieldProperties)
|
|
{
|
|
return new AutoGeneratedField (fieldProperties);
|
|
}
|
|
|
|
AutoGeneratedFieldProperties[] CreateAutoFieldProperties (object dataItem)
|
|
{
|
|
if (IsBindableType (dataItem.GetType ()))
|
|
{
|
|
AutoGeneratedFieldProperties field = new AutoGeneratedFieldProperties ();
|
|
((IStateManager) field).TrackViewState ();
|
|
field.Name = "Item";
|
|
field.DataField = BoundField.ThisExpression;
|
|
field.Type = dataItem.GetType ();
|
|
return new AutoGeneratedFieldProperties [] { field };
|
|
}
|
|
|
|
PropertyDescriptorCollection props = TypeDescriptor.GetProperties (dataItem, false);
|
|
|
|
if (props != null && props.Count > 0) {
|
|
ArrayList retVal = new ArrayList ();
|
|
foreach (PropertyDescriptor current in props) {
|
|
if (IsBindableType (current.PropertyType)) {
|
|
AutoGeneratedFieldProperties field = new AutoGeneratedFieldProperties ();
|
|
((IStateManager) field).TrackViewState ();
|
|
field.Name = current.Name;
|
|
field.DataField = current.Name;
|
|
for (int i = 0; i < DataKeyNames.Length; i++) {
|
|
if (string.Compare (DataKeyNames [i], current.Name, StringComparison.InvariantCultureIgnoreCase) == 0) {
|
|
field.IsReadOnly = true;
|
|
break;
|
|
}
|
|
}
|
|
field.Type = current.PropertyType;
|
|
retVal.Add (field);
|
|
}
|
|
}
|
|
if (retVal.Count > 0)
|
|
return (AutoGeneratedFieldProperties []) retVal.ToArray (typeof (AutoGeneratedFieldProperties));
|
|
}
|
|
throw new HttpException (String.Format ("DetailsView with id '{0}' did not have any properties or attributes from which to generate fields. Ensure that your data source has content.", ID));
|
|
}
|
|
|
|
protected virtual DetailsViewRow CreateRow (int rowIndex, DataControlRowType rowType, DataControlRowState rowState)
|
|
{
|
|
DetailsViewRow row;
|
|
if (rowType == DataControlRowType.Pager)
|
|
row = new DetailsViewPagerRow (rowIndex, rowType, rowState);
|
|
else
|
|
row = new DetailsViewRow (rowIndex, rowType, rowState);
|
|
return row;
|
|
}
|
|
|
|
void RequireBinding ()
|
|
{
|
|
if (Initialized) {
|
|
RequiresDataBinding = true;
|
|
}
|
|
}
|
|
|
|
protected virtual Table CreateTable ()
|
|
{
|
|
return new ContainedTable (this);
|
|
}
|
|
|
|
protected override Style CreateControlStyle ()
|
|
{
|
|
TableStyle style = new TableStyle ();
|
|
style.GridLines = GridLines.Both;
|
|
style.CellSpacing = 0;
|
|
return style;
|
|
}
|
|
|
|
protected override int CreateChildControls (IEnumerable data, bool dataBinding)
|
|
{
|
|
PagedDataSource dataSource = new PagedDataSource ();
|
|
dataSource.DataSource = CurrentMode != DetailsViewMode.Insert ? data : null;
|
|
dataSource.AllowPaging = AllowPaging;
|
|
dataSource.PageSize = 1;
|
|
dataSource.CurrentPageIndex = PageIndex;
|
|
|
|
if (dataBinding && CurrentMode != DetailsViewMode.Insert) {
|
|
DataSourceView view = GetData ();
|
|
if (view != null && view.CanPage) {
|
|
dataSource.AllowServerPaging = true;
|
|
if (SelectArguments.RetrieveTotalRowCount)
|
|
dataSource.VirtualCount = SelectArguments.TotalRowCount;
|
|
}
|
|
}
|
|
|
|
bool showPager = AllowPaging && (dataSource.PageCount > 1);
|
|
|
|
Controls.Clear ();
|
|
table = CreateTable ();
|
|
Controls.Add (table);
|
|
headerRow = null;
|
|
footerRow = null;
|
|
topPagerRow = null;
|
|
bottomPagerRow = null;
|
|
ArrayList list = new ArrayList ();
|
|
|
|
// Gets the current data item
|
|
|
|
if (AllowPaging) {
|
|
PageCount = dataSource.DataSourceCount;
|
|
if (PageIndex >= PageCount && PageCount > 0) {
|
|
pageIndex = dataSource.CurrentPageIndex = PageCount - 1;
|
|
}
|
|
if (dataSource.DataSource != null) {
|
|
IEnumerator e = dataSource.GetEnumerator ();
|
|
if (e.MoveNext ())
|
|
dataItem = e.Current;
|
|
}
|
|
}
|
|
else {
|
|
int page = 0;
|
|
object lastItem = null;
|
|
if (dataSource.DataSource != null) {
|
|
IEnumerator e = dataSource.GetEnumerator ();
|
|
for (; e.MoveNext (); page++) {
|
|
lastItem = e.Current;
|
|
if (page == PageIndex)
|
|
dataItem = e.Current;
|
|
}
|
|
}
|
|
PageCount = page;
|
|
if (PageIndex >= PageCount && PageCount > 0) {
|
|
pageIndex = PageCount - 1;
|
|
dataItem = lastItem;
|
|
}
|
|
}
|
|
|
|
if (PageCount == 0 && CurrentMode != DetailsViewMode.Insert) {
|
|
DetailsViewRow row = CreateEmptyRow ();
|
|
if (row != null) {
|
|
table.Rows.Add (row);
|
|
list.Add (row);
|
|
}
|
|
}
|
|
else {
|
|
|
|
// Creates the set of fields to show
|
|
|
|
ICollection fieldCollection = CreateFieldSet (dataItem, dataBinding && dataItem != null);
|
|
DataControlField [] fields = new DataControlField [fieldCollection.Count];
|
|
fieldCollection.CopyTo (fields, 0);
|
|
|
|
foreach (DataControlField field in fields) {
|
|
field.Initialize (false, this);
|
|
if (EnablePagingCallbacks)
|
|
field.ValidateSupportsCallback ();
|
|
}
|
|
|
|
// Main table creation
|
|
|
|
headerRow = CreateRow (-1, DataControlRowType.Header, DataControlRowState.Normal);
|
|
DataControlFieldCell headerCell = new DataControlFieldCell (null);
|
|
headerCell.ColumnSpan = 2;
|
|
if (headerTemplate != null)
|
|
headerTemplate.InstantiateIn (headerCell);
|
|
else if (!String.IsNullOrEmpty (HeaderText))
|
|
headerCell.Text = HeaderText;
|
|
else
|
|
headerRow.Visible = false;
|
|
headerRow.Cells.Add (headerCell);
|
|
table.Rows.Add (headerRow);
|
|
|
|
if (showPager && PagerSettings.Position == PagerPosition.Top ||
|
|
PagerSettings.Position == PagerPosition.TopAndBottom) {
|
|
topPagerRow = CreateRow (-1, DataControlRowType.Pager, DataControlRowState.Normal);
|
|
InitializePager (topPagerRow, dataSource);
|
|
table.Rows.Add (topPagerRow);
|
|
}
|
|
|
|
foreach (DataControlField field in fields) {
|
|
DataControlRowState rstate = GetRowState (list.Count);
|
|
DetailsViewRow row = CreateRow (PageIndex, DataControlRowType.DataRow, rstate);
|
|
InitializeRow (row, field);
|
|
table.Rows.Add (row);
|
|
list.Add (row);
|
|
}
|
|
|
|
footerRow = CreateRow (-1, DataControlRowType.Footer, DataControlRowState.Normal);
|
|
DataControlFieldCell footerCell = new DataControlFieldCell (null);
|
|
footerCell.ColumnSpan = 2;
|
|
if (footerTemplate != null)
|
|
footerTemplate.InstantiateIn (footerCell);
|
|
else if (!String.IsNullOrEmpty (FooterText))
|
|
footerCell.Text = FooterText;
|
|
else
|
|
footerRow.Visible = false;
|
|
footerRow.Cells.Add (footerCell);
|
|
table.Rows.Add (footerRow);
|
|
|
|
if (showPager && PagerSettings.Position == PagerPosition.Bottom ||
|
|
PagerSettings.Position == PagerPosition.TopAndBottom) {
|
|
bottomPagerRow = CreateRow (-1, DataControlRowType.Pager, DataControlRowState.Normal);
|
|
InitializePager (bottomPagerRow, dataSource);
|
|
table.Rows.Add (bottomPagerRow);
|
|
}
|
|
}
|
|
|
|
rows = new DetailsViewRowCollection (list);
|
|
|
|
if (dataBinding)
|
|
DataBind (false);
|
|
|
|
OnItemCreated (EventArgs.Empty);
|
|
|
|
return PageCount;
|
|
}
|
|
|
|
protected override void EnsureDataBound ()
|
|
{
|
|
if (CurrentMode == DetailsViewMode.Insert) {
|
|
if (RequiresDataBinding) {
|
|
OnDataBinding (EventArgs.Empty);
|
|
RequiresDataBinding = false;
|
|
InternalPerformDataBinding (null);
|
|
MarkAsDataBound ();
|
|
OnDataBound (EventArgs.Empty);
|
|
}
|
|
}
|
|
else
|
|
base.EnsureDataBound ();
|
|
}
|
|
|
|
DataControlRowState GetRowState (int index)
|
|
{
|
|
DataControlRowState rstate = (index % 2) == 0 ? DataControlRowState.Normal : DataControlRowState.Alternate;
|
|
if (CurrentMode == DetailsViewMode.Edit) rstate |= DataControlRowState.Edit;
|
|
else if (CurrentMode == DetailsViewMode.Insert) rstate |= DataControlRowState.Insert;
|
|
return rstate;
|
|
}
|
|
|
|
protected virtual void InitializePager (DetailsViewRow row, PagedDataSource dataSource)
|
|
{
|
|
TableCell cell = new TableCell ();
|
|
cell.ColumnSpan = 2;
|
|
|
|
if (pagerTemplate != null)
|
|
pagerTemplate.InstantiateIn (cell);
|
|
else
|
|
cell.Controls.Add (PagerSettings.CreatePagerControl (dataSource.CurrentPageIndex, dataSource.PageCount));
|
|
|
|
row.Cells.Add (cell);
|
|
}
|
|
|
|
DetailsViewRow CreateEmptyRow ()
|
|
{
|
|
TableCell cell = new TableCell ();
|
|
|
|
if (emptyDataTemplate != null)
|
|
emptyDataTemplate.InstantiateIn (cell);
|
|
else if (!String.IsNullOrEmpty (EmptyDataText))
|
|
cell.Text = EmptyDataText;
|
|
else
|
|
return null;
|
|
|
|
DetailsViewRow row = CreateRow (-1, DataControlRowType.EmptyDataRow, DataControlRowState.Normal);
|
|
row.Cells.Add (cell);
|
|
return row;
|
|
}
|
|
|
|
protected virtual void InitializeRow (DetailsViewRow row, DataControlField field)
|
|
{
|
|
if (!field.Visible) {
|
|
row.Visible = false;
|
|
return;
|
|
}
|
|
|
|
row.ContainingField = field;
|
|
DataControlFieldCell cell;
|
|
|
|
if (field.ShowHeader) {
|
|
cell = new DataControlFieldCell (field);
|
|
row.Cells.Add (cell);
|
|
field.InitializeCell (cell, DataControlCellType.Header, row.RowState, row.RowIndex);
|
|
}
|
|
|
|
cell = new DataControlFieldCell (field);
|
|
if (!field.ShowHeader)
|
|
cell.ColumnSpan = 2;
|
|
row.Cells.Add (cell);
|
|
field.InitializeCell (cell, DataControlCellType.DataCell, row.RowState, row.RowIndex);
|
|
|
|
if (CurrentMode == DetailsViewMode.Insert && !field.InsertVisible)
|
|
row.Visible = false;
|
|
}
|
|
|
|
void FillRowDataKey (object dataItem)
|
|
{
|
|
KeyTable.Clear ();
|
|
|
|
if (cachedKeyProperties == null) {
|
|
PropertyDescriptorCollection props = TypeDescriptor.GetProperties (dataItem);
|
|
cachedKeyProperties = new PropertyDescriptor [DataKeyNames.Length];
|
|
for (int n=0; n<DataKeyNames.Length; n++) {
|
|
PropertyDescriptor p = props.Find (DataKeyNames [n], true);
|
|
if (p == null)
|
|
throw new InvalidOperationException ("Property '" + DataKeyNames[n] + "' not found in object of type " + dataItem.GetType());
|
|
cachedKeyProperties [n] = p;
|
|
}
|
|
}
|
|
|
|
foreach (PropertyDescriptor p in cachedKeyProperties)
|
|
KeyTable [p.Name] = p.GetValue (dataItem);
|
|
}
|
|
|
|
IOrderedDictionary GetRowValues (bool includeReadOnlyFields, bool includePrimaryKey)
|
|
{
|
|
OrderedDictionary dic = new OrderedDictionary ();
|
|
ExtractRowValues (dic, includeReadOnlyFields, includePrimaryKey);
|
|
return dic;
|
|
}
|
|
|
|
protected virtual void ExtractRowValues (IOrderedDictionary fieldValues, bool includeReadOnlyFields, bool includePrimaryKey)
|
|
{
|
|
foreach (DetailsViewRow row in Rows) {
|
|
if (row.Cells.Count < 1) continue;
|
|
DataControlFieldCell c = row.Cells[row.Cells.Count-1] as DataControlFieldCell;
|
|
if (c != null)
|
|
c.ContainingField.ExtractValuesFromCell (fieldValues, c, row.RowState, includeReadOnlyFields);
|
|
}
|
|
if (!includePrimaryKey && DataKeyNames != null)
|
|
foreach (string key in DataKeyNames)
|
|
fieldValues.Remove (key);
|
|
}
|
|
|
|
protected override HtmlTextWriterTag TagKey {
|
|
get {
|
|
if (EnablePagingCallbacks)
|
|
return HtmlTextWriterTag.Div;
|
|
else
|
|
return HtmlTextWriterTag.Table;
|
|
}
|
|
}
|
|
|
|
public sealed override void DataBind ()
|
|
{
|
|
cachedKeyProperties = null;
|
|
base.DataBind ();
|
|
|
|
if (dataItem != null) {
|
|
if (CurrentMode == DetailsViewMode.Edit)
|
|
oldEditValues = new DataKey (GetRowValues (false, true));
|
|
FillRowDataKey (dataItem);
|
|
key = new DataKey (KeyTable);
|
|
}
|
|
}
|
|
|
|
protected internal override void PerformDataBinding (IEnumerable data)
|
|
{
|
|
base.PerformDataBinding (data);
|
|
}
|
|
|
|
protected internal virtual void PrepareControlHierarchy ()
|
|
{
|
|
if (table == null)
|
|
return;
|
|
|
|
table.Caption = Caption;
|
|
table.CaptionAlign = CaptionAlign;
|
|
|
|
foreach (DetailsViewRow row in table.Rows) {
|
|
switch (row.RowType) {
|
|
case DataControlRowType.Header:
|
|
if (headerStyle != null && !headerStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (headerStyle);
|
|
break;
|
|
case DataControlRowType.Footer:
|
|
if (footerStyle != null && !footerStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (footerStyle);
|
|
break;
|
|
case DataControlRowType.Pager:
|
|
if (pagerStyle != null && !pagerStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (pagerStyle);
|
|
break;
|
|
case DataControlRowType.EmptyDataRow:
|
|
if (emptyDataRowStyle != null && !emptyDataRowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (emptyDataRowStyle);
|
|
break;
|
|
case DataControlRowType.DataRow:
|
|
if (rowStyle != null && !rowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (rowStyle);
|
|
if ((row.RowState & DataControlRowState.Alternate) != 0 && alternatingRowStyle != null && !alternatingRowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (alternatingRowStyle);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (row.ContainingField is CommandField) {
|
|
if (commandRowStyle != null && !commandRowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (commandRowStyle);
|
|
}
|
|
else {
|
|
if ((row.RowState & DataControlRowState.Edit) != 0 && editRowStyle != null && !editRowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (editRowStyle);
|
|
if ((row.RowState & DataControlRowState.Insert) != 0) {
|
|
if (insertRowStyle != null && !insertRowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (insertRowStyle);
|
|
else if (editRowStyle != null && !editRowStyle.IsEmpty)
|
|
row.ControlStyle.CopyFrom (editRowStyle);
|
|
}
|
|
}
|
|
|
|
for (int n = 0; n < row.Cells.Count; n++) {
|
|
DataControlFieldCell fcell = row.Cells [n] as DataControlFieldCell;
|
|
if (fcell != null && fcell.ContainingField != null) {
|
|
DataControlField field = fcell.ContainingField;
|
|
if (n == 0 && field.ShowHeader) {
|
|
if (fieldHeaderStyle != null && !fieldHeaderStyle.IsEmpty)
|
|
fcell.ControlStyle.CopyFrom (fieldHeaderStyle);
|
|
if (field.HeaderStyleCreated && !field.HeaderStyle.IsEmpty)
|
|
fcell.ControlStyle.CopyFrom (field.HeaderStyle);
|
|
}
|
|
else {
|
|
if (field.ControlStyleCreated && !field.ControlStyle.IsEmpty)
|
|
foreach (Control c in fcell.Controls) {
|
|
WebControl wc = c as WebControl;
|
|
if (wc != null)
|
|
wc.ControlStyle.MergeWith (field.ControlStyle);
|
|
}
|
|
if (field.ItemStyleCreated && !field.ItemStyle.IsEmpty)
|
|
fcell.ControlStyle.CopyFrom (field.ItemStyle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected internal override void OnInit (EventArgs e)
|
|
{
|
|
Page.RegisterRequiresControlState (this);
|
|
base.OnInit (e);
|
|
}
|
|
|
|
void OnFieldsChanged (object sender, EventArgs args)
|
|
{
|
|
RequireBinding ();
|
|
}
|
|
|
|
protected override void OnDataSourceViewChanged (object sender, EventArgs e)
|
|
{
|
|
base.OnDataSourceViewChanged (sender, e);
|
|
RequireBinding ();
|
|
}
|
|
|
|
protected override bool OnBubbleEvent (object source, EventArgs e)
|
|
{
|
|
DetailsViewCommandEventArgs args = e as DetailsViewCommandEventArgs;
|
|
if (args != null) {
|
|
bool causesValidation = false;
|
|
IButtonControl button = args.CommandSource as IButtonControl;
|
|
if (button != null && button.CausesValidation) {
|
|
Page.Validate (button.ValidationGroup);
|
|
causesValidation = true;
|
|
}
|
|
ProcessCommand (args, causesValidation);
|
|
return true;
|
|
}
|
|
return base.OnBubbleEvent (source, e);
|
|
}
|
|
|
|
void ProcessCommand (DetailsViewCommandEventArgs args, bool causesValidation) {
|
|
OnItemCommand (args);
|
|
ProcessEvent (args.CommandName, args.CommandArgument as string, causesValidation);
|
|
}
|
|
|
|
void IPostBackEventHandler.RaisePostBackEvent (string eventArgument)
|
|
{
|
|
RaisePostBackEvent (eventArgument);
|
|
}
|
|
|
|
// TODO: This is prolly obsolete
|
|
protected virtual void RaisePostBackEvent (string eventArgument)
|
|
{
|
|
int i = eventArgument.IndexOf ('$');
|
|
CommandEventArgs arg;
|
|
if (i != -1)
|
|
arg = new CommandEventArgs (eventArgument.Substring (0, i), eventArgument.Substring (i + 1));
|
|
else
|
|
arg = new CommandEventArgs (eventArgument, null);
|
|
ProcessCommand (new DetailsViewCommandEventArgs (this, arg), false);
|
|
}
|
|
|
|
void ProcessEvent (string eventName, string param, bool causesValidation)
|
|
{
|
|
switch (eventName)
|
|
{
|
|
case DataControlCommands.PageCommandName:
|
|
int newIndex = -1;
|
|
switch (param) {
|
|
case DataControlCommands.FirstPageCommandArgument:
|
|
newIndex = 0;
|
|
break;
|
|
case DataControlCommands.LastPageCommandArgument:
|
|
newIndex = PageCount - 1;
|
|
break;
|
|
case DataControlCommands.NextPageCommandArgument:
|
|
newIndex = PageIndex + 1;
|
|
break;
|
|
case DataControlCommands.PreviousPageCommandArgument:
|
|
newIndex = PageIndex - 1;
|
|
break;
|
|
default:
|
|
int paramIndex = 0;
|
|
int.TryParse (param, out paramIndex);
|
|
newIndex = paramIndex - 1;
|
|
break;
|
|
}
|
|
ShowPage (newIndex);
|
|
break;
|
|
|
|
case DataControlCommands.FirstPageCommandArgument:
|
|
ShowPage (0);
|
|
break;
|
|
|
|
case DataControlCommands.LastPageCommandArgument:
|
|
ShowPage (PageCount - 1);
|
|
break;
|
|
|
|
case DataControlCommands.NextPageCommandArgument:
|
|
if (PageIndex < PageCount - 1)
|
|
ShowPage (PageIndex + 1);
|
|
break;
|
|
|
|
case DataControlCommands.PreviousPageCommandArgument:
|
|
if (PageIndex > 0)
|
|
ShowPage (PageIndex - 1);
|
|
break;
|
|
|
|
case DataControlCommands.EditCommandName:
|
|
ProcessChangeMode (DetailsViewMode.Edit);
|
|
break;
|
|
|
|
case DataControlCommands.NewCommandName:
|
|
ProcessChangeMode (DetailsViewMode.Insert);
|
|
break;
|
|
|
|
case DataControlCommands.UpdateCommandName:
|
|
UpdateItem (param, causesValidation);
|
|
break;
|
|
|
|
case DataControlCommands.CancelCommandName:
|
|
CancelEdit ();
|
|
break;
|
|
|
|
case DataControlCommands.DeleteCommandName:
|
|
DeleteItem ();
|
|
break;
|
|
|
|
case DataControlCommands.InsertCommandName:
|
|
InsertItem (causesValidation);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ShowPage (int newIndex)
|
|
{
|
|
DetailsViewPageEventArgs args = new DetailsViewPageEventArgs (newIndex);
|
|
OnPageIndexChanging (args);
|
|
|
|
if (args.Cancel || !IsBoundUsingDataSourceID)
|
|
return;
|
|
|
|
if (args.NewPageIndex < 0 || args.NewPageIndex >= PageCount)
|
|
return;
|
|
EndRowEdit (false);
|
|
PageIndex = args.NewPageIndex;
|
|
OnPageIndexChanged (EventArgs.Empty);
|
|
}
|
|
|
|
public void ChangeMode (DetailsViewMode newMode)
|
|
{
|
|
CurrentMode = newMode;
|
|
RequireBinding ();
|
|
}
|
|
|
|
void ProcessChangeMode (DetailsViewMode newMode)
|
|
{
|
|
DetailsViewModeEventArgs args = new DetailsViewModeEventArgs (newMode, false);
|
|
OnModeChanging (args);
|
|
|
|
if (args.Cancel || !IsBoundUsingDataSourceID)
|
|
return;
|
|
|
|
ChangeMode (args.NewMode);
|
|
|
|
OnModeChanged (EventArgs.Empty);
|
|
}
|
|
|
|
void CancelEdit ()
|
|
{
|
|
DetailsViewModeEventArgs args = new DetailsViewModeEventArgs (DetailsViewMode.ReadOnly, true);
|
|
OnModeChanging (args);
|
|
|
|
if (args.Cancel || !IsBoundUsingDataSourceID)
|
|
return;
|
|
|
|
EndRowEdit ();
|
|
}
|
|
|
|
public virtual void UpdateItem (bool causesValidation)
|
|
{
|
|
UpdateItem (null, causesValidation);
|
|
}
|
|
|
|
void UpdateItem (string param, bool causesValidation)
|
|
{
|
|
if (causesValidation && Page != null && !Page.IsValid)
|
|
return;
|
|
|
|
if (CurrentMode != DetailsViewMode.Edit) throw new HttpException ();
|
|
|
|
currentEditOldValues = OldEditValues.Values;
|
|
|
|
currentEditRowKeys = DataKey.Values;
|
|
currentEditNewValues = GetRowValues (false, false);
|
|
|
|
DetailsViewUpdateEventArgs args = new DetailsViewUpdateEventArgs (param, currentEditRowKeys, currentEditOldValues, currentEditNewValues);
|
|
OnItemUpdating (args);
|
|
|
|
if (args.Cancel || !IsBoundUsingDataSourceID)
|
|
return;
|
|
|
|
DataSourceView view = GetData ();
|
|
if (view == null)
|
|
throw new HttpException ("The DataSourceView associated to data bound control was null");
|
|
view.Update (currentEditRowKeys, currentEditNewValues, currentEditOldValues, new DataSourceViewOperationCallback (UpdateCallback));
|
|
}
|
|
|
|
bool UpdateCallback (int recordsAffected, Exception exception)
|
|
{
|
|
DetailsViewUpdatedEventArgs dargs = new DetailsViewUpdatedEventArgs (recordsAffected, exception, currentEditRowKeys, currentEditOldValues, currentEditNewValues);
|
|
OnItemUpdated (dargs);
|
|
|
|
if (!dargs.KeepInEditMode)
|
|
EndRowEdit ();
|
|
|
|
return dargs.ExceptionHandled;
|
|
}
|
|
|
|
public virtual void InsertItem (bool causesValidation)
|
|
{
|
|
InsertItem (null, causesValidation);
|
|
}
|
|
|
|
void InsertItem (string param, bool causesValidation)
|
|
{
|
|
if (causesValidation && Page != null && !Page.IsValid)
|
|
return;
|
|
|
|
if (CurrentMode != DetailsViewMode.Insert) throw new HttpException ();
|
|
|
|
currentEditNewValues = GetRowValues (false, true);
|
|
DetailsViewInsertEventArgs args = new DetailsViewInsertEventArgs (param, currentEditNewValues);
|
|
OnItemInserting (args);
|
|
|
|
if (args.Cancel || !IsBoundUsingDataSourceID)
|
|
return;
|
|
|
|
DataSourceView view = GetData ();
|
|
if (view == null)
|
|
throw new HttpException ("The DataSourceView associated to data bound control was null");
|
|
view.Insert (currentEditNewValues, new DataSourceViewOperationCallback (InsertCallback));
|
|
}
|
|
|
|
bool InsertCallback (int recordsAffected, Exception exception)
|
|
{
|
|
DetailsViewInsertedEventArgs dargs = new DetailsViewInsertedEventArgs (recordsAffected, exception, currentEditNewValues);
|
|
OnItemInserted (dargs);
|
|
|
|
if (!dargs.KeepInInsertMode)
|
|
EndRowEdit ();
|
|
|
|
return dargs.ExceptionHandled;
|
|
}
|
|
|
|
public virtual void DeleteItem ()
|
|
{
|
|
currentEditRowKeys = DataKey.Values;
|
|
currentEditNewValues = GetRowValues (true, false);
|
|
|
|
DetailsViewDeleteEventArgs args = new DetailsViewDeleteEventArgs (PageIndex, currentEditRowKeys, currentEditNewValues);
|
|
OnItemDeleting (args);
|
|
|
|
if (args.Cancel || !IsBoundUsingDataSourceID)
|
|
return;
|
|
|
|
DataSourceView view = GetData ();
|
|
if (view != null)
|
|
view.Delete (currentEditRowKeys, currentEditNewValues, new DataSourceViewOperationCallback (DeleteCallback));
|
|
else {
|
|
DetailsViewDeletedEventArgs dargs = new DetailsViewDeletedEventArgs (0, null, currentEditRowKeys, currentEditNewValues);
|
|
OnItemDeleted (dargs);
|
|
}
|
|
if (PageIndex > 0 && PageIndex == PageCount - 1)
|
|
PageIndex --;
|
|
RequireBinding ();
|
|
}
|
|
|
|
bool DeleteCallback (int recordsAffected, Exception exception)
|
|
{
|
|
DetailsViewDeletedEventArgs dargs = new DetailsViewDeletedEventArgs (recordsAffected, exception, currentEditRowKeys, currentEditNewValues);
|
|
OnItemDeleted (dargs);
|
|
return dargs.ExceptionHandled;
|
|
}
|
|
|
|
void EndRowEdit ()
|
|
{
|
|
EndRowEdit (true);
|
|
}
|
|
|
|
void EndRowEdit (bool switchToDefaultMode) {
|
|
if (switchToDefaultMode)
|
|
ChangeMode (DefaultMode);
|
|
oldEditValues = new DataKey (new OrderedDictionary ());
|
|
currentEditRowKeys = null;
|
|
currentEditOldValues = null;
|
|
currentEditNewValues = null;
|
|
RequireBinding ();
|
|
}
|
|
|
|
protected internal override void LoadControlState (object ob)
|
|
{
|
|
if (ob == null) return;
|
|
object[] state = (object[]) ob;
|
|
base.LoadControlState (state[0]);
|
|
pageIndex = (int) state[1];
|
|
pageCount = (int) state[2];
|
|
CurrentMode = (DetailsViewMode) state[3];
|
|
dataKeyNames = (string[]) state[4];
|
|
defaultMode = (DetailsViewMode) state[5];
|
|
if (state [6] != null)
|
|
((IStateManager) DataKey).LoadViewState (state [6]);
|
|
if (state [7] != null)
|
|
((IStateManager) OldEditValues).LoadViewState (state [7]);
|
|
}
|
|
|
|
protected internal override object SaveControlState ()
|
|
{
|
|
object bstate = base.SaveControlState ();
|
|
return new object[] {
|
|
bstate,
|
|
pageIndex,
|
|
pageCount,
|
|
CurrentMode,
|
|
dataKeyNames,
|
|
defaultMode,
|
|
(key == null ? null : ((IStateManager)key).SaveViewState()),
|
|
(oldEditValues == null ? null : ((IStateManager) oldEditValues).SaveViewState ())
|
|
};
|
|
}
|
|
|
|
protected override void TrackViewState()
|
|
{
|
|
base.TrackViewState();
|
|
if (columns != null) ((IStateManager)columns).TrackViewState();
|
|
if (pagerSettings != null) ((IStateManager)pagerSettings).TrackViewState();
|
|
if (alternatingRowStyle != null) ((IStateManager)alternatingRowStyle).TrackViewState();
|
|
if (footerStyle != null) ((IStateManager)footerStyle).TrackViewState();
|
|
if (headerStyle != null) ((IStateManager)headerStyle).TrackViewState();
|
|
if (pagerStyle != null) ((IStateManager)pagerStyle).TrackViewState();
|
|
if (rowStyle != null) ((IStateManager)rowStyle).TrackViewState();
|
|
if (editRowStyle != null) ((IStateManager)editRowStyle).TrackViewState();
|
|
if (insertRowStyle != null) ((IStateManager)insertRowStyle).TrackViewState();
|
|
if (emptyDataRowStyle != null) ((IStateManager)emptyDataRowStyle).TrackViewState();
|
|
if (key != null) ((IStateManager)key).TrackViewState();
|
|
if (autoFieldProperties != null) {
|
|
foreach (IStateManager sm in autoFieldProperties)
|
|
sm.TrackViewState ();
|
|
}
|
|
if (ControlStyleCreated)
|
|
ControlStyle.TrackViewState ();
|
|
}
|
|
|
|
protected override object SaveViewState()
|
|
{
|
|
object[] states = new object [13];
|
|
states[0] = base.SaveViewState();
|
|
states[1] = (columns == null ? null : ((IStateManager)columns).SaveViewState());
|
|
states[2] = (pagerSettings == null ? null : ((IStateManager)pagerSettings).SaveViewState());
|
|
states[3] = (alternatingRowStyle == null ? null : ((IStateManager)alternatingRowStyle).SaveViewState());
|
|
states[4] = (footerStyle == null ? null : ((IStateManager)footerStyle).SaveViewState());
|
|
states[5] = (headerStyle == null ? null : ((IStateManager)headerStyle).SaveViewState());
|
|
states[6] = (pagerStyle == null ? null : ((IStateManager)pagerStyle).SaveViewState());
|
|
states[7] = (rowStyle == null ? null : ((IStateManager)rowStyle).SaveViewState());
|
|
states[8] = (insertRowStyle == null ? null : ((IStateManager)insertRowStyle).SaveViewState());
|
|
states[9] = (editRowStyle == null ? null : ((IStateManager)editRowStyle).SaveViewState());
|
|
states[10] = (emptyDataRowStyle == null ? null : ((IStateManager)emptyDataRowStyle).SaveViewState());
|
|
|
|
if (autoFieldProperties != null) {
|
|
object[] data = new object [autoFieldProperties.Length];
|
|
bool allNull = true;
|
|
for (int n=0; n<data.Length; n++) {
|
|
data [n] = ((IStateManager)autoFieldProperties [n]).SaveViewState ();
|
|
if (data [n] != null) allNull = false;
|
|
}
|
|
if (!allNull) states [11] = data;
|
|
}
|
|
if (ControlStyleCreated)
|
|
states [12] = ControlStyle.SaveViewState ();
|
|
|
|
for (int i = states.Length - 1; i >= 0; i--) {
|
|
if (states [i] != null)
|
|
return states;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void LoadViewState (object savedState)
|
|
{
|
|
if (savedState == null) {
|
|
base.LoadViewState (null);
|
|
return;
|
|
}
|
|
|
|
object [] states = (object []) savedState;
|
|
|
|
if (states[11] != null) {
|
|
object[] data = (object[]) states [11];
|
|
autoFieldProperties = new AutoGeneratedFieldProperties [data.Length];
|
|
for (int n=0; n<data.Length; n++) {
|
|
IStateManager p = new AutoGeneratedFieldProperties ();
|
|
p.TrackViewState ();
|
|
p.LoadViewState (data [n]);
|
|
autoFieldProperties [n] = (AutoGeneratedFieldProperties) p;
|
|
}
|
|
}
|
|
|
|
base.LoadViewState (states[0]);
|
|
|
|
if (states[1] != null) ((IStateManager)Fields).LoadViewState (states[1]);
|
|
if (states[2] != null) ((IStateManager)PagerSettings).LoadViewState (states[2]);
|
|
if (states[3] != null) ((IStateManager)AlternatingRowStyle).LoadViewState (states[3]);
|
|
if (states[4] != null) ((IStateManager)FooterStyle).LoadViewState (states[4]);
|
|
if (states[5] != null) ((IStateManager)HeaderStyle).LoadViewState (states[5]);
|
|
if (states[6] != null) ((IStateManager)PagerStyle).LoadViewState (states[6]);
|
|
if (states[7] != null) ((IStateManager)RowStyle).LoadViewState (states[7]);
|
|
if (states[8] != null) ((IStateManager)InsertRowStyle).LoadViewState (states[8]);
|
|
if (states[9] != null) ((IStateManager)EditRowStyle).LoadViewState (states[9]);
|
|
if (states[10] != null) ((IStateManager)EmptyDataRowStyle).LoadViewState (states[10]);
|
|
if (states [12] != null)
|
|
ControlStyle.LoadViewState (states [12]);
|
|
}
|
|
|
|
void ICallbackEventHandler.RaiseCallbackEvent (string eventArgs)
|
|
{
|
|
RaiseCallbackEvent (eventArgs);
|
|
}
|
|
|
|
protected virtual void RaiseCallbackEvent (string eventArgs)
|
|
{
|
|
string[] clientData = eventArgs.Split ('|');
|
|
PageIndex = int.Parse (clientData[0]);
|
|
|
|
RaisePostBackEvent (clientData[1]);
|
|
DataBind ();
|
|
}
|
|
|
|
string ICallbackEventHandler.GetCallbackResult ()
|
|
{
|
|
return GetCallbackResult ();
|
|
}
|
|
|
|
protected virtual string GetCallbackResult ()
|
|
{
|
|
PrepareControlHierarchy ();
|
|
|
|
StringWriter sw = new StringWriter ();
|
|
sw.Write (PageIndex.ToString () + '|');
|
|
|
|
HtmlTextWriter writer = new HtmlTextWriter (sw);
|
|
RenderGrid (writer);
|
|
return sw.ToString ();
|
|
}
|
|
|
|
protected virtual string GetCallbackScript (IButtonControl buttonControl, string argument)
|
|
{
|
|
if (EnablePagingCallbacks)
|
|
return "javascript:DetailsView_ClientEvent (\"" + ClientID + "\",\"" + buttonControl.CommandName + "$" + buttonControl.CommandArgument + "\"); return false;";
|
|
else
|
|
return null;
|
|
}
|
|
|
|
string ICallbackContainer.GetCallbackScript (IButtonControl control, string argument)
|
|
{
|
|
return GetCallbackScript (control, argument);
|
|
}
|
|
|
|
protected override void OnPagePreLoad (object sender, EventArgs e)
|
|
{
|
|
base.OnPagePreLoad (sender, e);
|
|
|
|
if (Page.IsPostBack && EnablePagingCallbacks) {
|
|
int page;
|
|
if (int.TryParse (Page.Request.Form [ClientID + "_Page"], out page))
|
|
PageIndex = page;
|
|
}
|
|
}
|
|
|
|
const string onPreRenderScript = @"var {0} = new Object ();
|
|
{0}.pageIndex = {1};
|
|
{0}.uid = {2};
|
|
{0}.form = {3};
|
|
";
|
|
|
|
protected internal override void OnPreRender (EventArgs e)
|
|
{
|
|
base.OnPreRender (e);
|
|
|
|
if (EnablePagingCallbacks)
|
|
{
|
|
if (!Page.ClientScript.IsClientScriptIncludeRegistered (typeof(DetailsView), "DetailsView.js")) {
|
|
string url = Page.ClientScript.GetWebResourceUrl (typeof(DetailsView), "DetailsView.js");
|
|
Page.ClientScript.RegisterClientScriptInclude (typeof(DetailsView), "DetailsView.js", url);
|
|
}
|
|
Page.ClientScript.RegisterHiddenField (ClientID + "_Page", PageIndex.ToString ());
|
|
|
|
string cgrid = ClientID + "_data";
|
|
string script = String.Format (onPreRenderScript,
|
|
cgrid,
|
|
ClientScriptManager.GetScriptLiteral (PageIndex),
|
|
ClientScriptManager.GetScriptLiteral (UniqueID),
|
|
Page.theForm);
|
|
|
|
Page.ClientScript.RegisterStartupScript (typeof(TreeView), this.UniqueID, script, true);
|
|
|
|
// Make sure the basic script infrastructure is rendered
|
|
Page.ClientScript.GetCallbackEventReference (this, "null", "", "null");
|
|
Page.ClientScript.GetPostBackClientHyperlink (this, "");
|
|
}
|
|
}
|
|
|
|
protected internal override void Render (HtmlTextWriter writer)
|
|
{
|
|
PrepareControlHierarchy ();
|
|
|
|
if (EnablePagingCallbacks)
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Id, ClientID + "_div");
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Div);
|
|
|
|
RenderGrid (writer);
|
|
|
|
writer.RenderEndTag ();
|
|
}
|
|
|
|
void RenderGrid (HtmlTextWriter writer)
|
|
{
|
|
if (table == null)
|
|
return;
|
|
|
|
table.Render (writer);
|
|
}
|
|
|
|
PostBackOptions IPostBackContainer.GetPostBackOptions(IButtonControl control)
|
|
{
|
|
if (control == null)
|
|
throw new ArgumentNullException ("control");
|
|
|
|
if (control.CausesValidation)
|
|
throw new InvalidOperationException ("A button that causes validation in DetailsView '" + ID + "' is attempting to use the container GridView as the post back target. The button should either turn off validation or use itself as the post back container.");
|
|
|
|
PostBackOptions options = new PostBackOptions (this);
|
|
options.Argument = control.CommandName + "$" + control.CommandArgument;
|
|
options.RequiresJavaScriptProtocol = true;
|
|
|
|
return options;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|