mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
660 lines
26 KiB
C#
660 lines
26 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="RepeatInfo.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
|
|
using System;
|
|
using System.Globalization;
|
|
using System.Web;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
|
|
/// <devdoc>
|
|
/// <para>Defines the information used to render a list of items using
|
|
/// a <see cref='System.Web.UI.WebControls.Repeater'/>.</para>
|
|
/// </devdoc>
|
|
public sealed class RepeatInfo {
|
|
|
|
private RepeatDirection repeatDirection;
|
|
private RepeatLayout repeatLayout;
|
|
private int repeatColumns;
|
|
private string caption;
|
|
private TableCaptionAlign captionAlign;
|
|
private bool useAccessibleHeader;
|
|
private bool outerTableImplied;
|
|
private bool enableLegacyRendering;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.RepeatInfo'/> class. This class is not
|
|
/// inheritable.</para>
|
|
/// </devdoc>
|
|
public RepeatInfo() {
|
|
repeatDirection = RepeatDirection.Vertical;
|
|
repeatLayout = RepeatLayout.Table;
|
|
repeatColumns = 0;
|
|
outerTableImplied = false;
|
|
}
|
|
|
|
|
|
public string Caption {
|
|
get {
|
|
return (caption == null) ? String.Empty : caption;
|
|
}
|
|
set {
|
|
caption = value;
|
|
}
|
|
}
|
|
|
|
|
|
public TableCaptionAlign CaptionAlign {
|
|
get {
|
|
return captionAlign;
|
|
}
|
|
set {
|
|
if ((value < TableCaptionAlign.NotSet) ||
|
|
(value > TableCaptionAlign.Right)) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
captionAlign = value;
|
|
}
|
|
}
|
|
|
|
// DevDiv 33149: A backward compat. switch for Everett rendering
|
|
internal bool EnableLegacyRendering {
|
|
get {
|
|
return enableLegacyRendering;
|
|
}
|
|
set {
|
|
enableLegacyRendering = value;
|
|
}
|
|
}
|
|
|
|
private bool IsListLayout {
|
|
get {
|
|
return
|
|
(RepeatLayout == RepeatLayout.UnorderedList) ||
|
|
(RepeatLayout == RepeatLayout.OrderedList);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Indicates whether an outer table is implied
|
|
/// for the items.
|
|
/// </devdoc>
|
|
public bool OuterTableImplied {
|
|
get {
|
|
return outerTableImplied;
|
|
}
|
|
set {
|
|
outerTableImplied = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Indicates the column count of items.</para>
|
|
/// </devdoc>
|
|
public int RepeatColumns {
|
|
get {
|
|
return repeatColumns;
|
|
}
|
|
set {
|
|
repeatColumns = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Indicates the direction of flow of items.</para>
|
|
/// </devdoc>
|
|
public RepeatDirection RepeatDirection {
|
|
get {
|
|
return repeatDirection;
|
|
}
|
|
set {
|
|
if (value < RepeatDirection.Horizontal || value > RepeatDirection.Vertical) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
repeatDirection = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Indicates the layout of items.
|
|
/// </devdoc>
|
|
public RepeatLayout RepeatLayout {
|
|
get {
|
|
return repeatLayout;
|
|
}
|
|
set {
|
|
EnumerationRangeValidationUtil.ValidateRepeatLayout(value);
|
|
repeatLayout = value;
|
|
}
|
|
}
|
|
|
|
|
|
public bool UseAccessibleHeader {
|
|
get {
|
|
return useAccessibleHeader;
|
|
}
|
|
set {
|
|
useAccessibleHeader = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
private void RenderHorizontalRepeater(HtmlTextWriter writer, IRepeatInfoUser user, Style controlStyle, WebControl baseControl) {
|
|
Debug.Assert(outerTableImplied == false, "Cannot use outer implied table with Horizontal layout");
|
|
|
|
int itemCount = user.RepeatedItemCount;
|
|
|
|
int totalColumns = repeatColumns;
|
|
int currentColumn = 0;
|
|
|
|
if (totalColumns == 0) {
|
|
// 0 implies a complete horizontal repetition without any
|
|
// column count constraints
|
|
totalColumns = itemCount;
|
|
}
|
|
|
|
WebControl outerControl = null;
|
|
bool tableLayout = false;
|
|
|
|
switch (repeatLayout) {
|
|
case RepeatLayout.Table:
|
|
outerControl = new Table();
|
|
if (Caption.Length != 0) {
|
|
((Table)outerControl).Caption = Caption;
|
|
((Table)outerControl).CaptionAlign = CaptionAlign;
|
|
}
|
|
tableLayout = true;
|
|
break;
|
|
case RepeatLayout.Flow:
|
|
outerControl = new WebControl(HtmlTextWriterTag.Span);
|
|
break;
|
|
}
|
|
|
|
bool separators = user.HasSeparators;
|
|
|
|
// use ClientID (and not ID) since we want to render out the fully qualified client id
|
|
// even though this outer control will not be parented to the control hierarchy
|
|
outerControl.ID = baseControl.ClientID;
|
|
|
|
outerControl.CopyBaseAttributes(baseControl);
|
|
outerControl.ApplyStyle(controlStyle);
|
|
outerControl.RenderBeginTag(writer);
|
|
|
|
if (user.HasHeader) {
|
|
if (tableLayout) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
|
|
// add attributes to render for TD/TH
|
|
if ((totalColumns != 1) || separators) {
|
|
int columnSpan = totalColumns;
|
|
if (separators)
|
|
columnSpan += totalColumns;
|
|
writer.AddAttribute(HtmlTextWriterAttribute.Colspan, columnSpan.ToString(NumberFormatInfo.InvariantInfo));
|
|
}
|
|
if (useAccessibleHeader) {
|
|
writer.AddAttribute(HtmlTextWriterAttribute.Scope, "col");
|
|
}
|
|
|
|
// add style attributes to render for TD/TH
|
|
Style style = user.GetItemStyle(ListItemType.Header, -1);
|
|
if (style != null) {
|
|
style.AddAttributesToRender(writer);
|
|
}
|
|
|
|
// render begin tag
|
|
if (useAccessibleHeader) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Th);
|
|
}
|
|
else {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
}
|
|
user.RenderItem(ListItemType.Header, -1, this, writer);
|
|
if (tableLayout) {
|
|
// render end tags TD/TH and TR
|
|
writer.RenderEndTag();
|
|
writer.RenderEndTag();
|
|
}
|
|
else {
|
|
if (totalColumns < itemCount) {
|
|
// we have multiple rows, so have a break between the header and first row.
|
|
if (EnableLegacyRendering) {
|
|
writer.WriteObsoleteBreak();
|
|
}
|
|
else {
|
|
writer.WriteBreak();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < itemCount; i++) {
|
|
if (tableLayout && (currentColumn == 0)) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
}
|
|
|
|
if (tableLayout) {
|
|
// add style attributes to render for TD
|
|
Style style = user.GetItemStyle(ListItemType.Item, i);
|
|
if (style != null)
|
|
style.AddAttributesToRender(writer);
|
|
// render begin tag for TD
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
user.RenderItem(ListItemType.Item, i, this, writer);
|
|
if (tableLayout) {
|
|
// render end tag for TD
|
|
writer.RenderEndTag();
|
|
}
|
|
if (separators && (i != (itemCount - 1))) {
|
|
if (tableLayout) {
|
|
Style style = user.GetItemStyle(ListItemType.Separator, i);
|
|
if (style != null)
|
|
style.AddAttributesToRender(writer);
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
user.RenderItem(ListItemType.Separator, i, this, writer);
|
|
if (tableLayout)
|
|
writer.RenderEndTag();
|
|
}
|
|
|
|
currentColumn++;
|
|
|
|
// on the last line, fill in the rest of the empty spots with <td/>s.
|
|
// If there were separators, we need twice as many plus one to accomodate for
|
|
// the last item not having a separator after it.
|
|
if (tableLayout && i == itemCount - 1) {
|
|
int unfilledColumns = totalColumns - currentColumn;
|
|
if (separators == true) {
|
|
int unfilledColumnsWithSeparators = (unfilledColumns * 2) + 1;
|
|
if (unfilledColumnsWithSeparators > unfilledColumns) {
|
|
unfilledColumns = unfilledColumnsWithSeparators;
|
|
}
|
|
}
|
|
for (int k = 0; k < unfilledColumns; k++) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
writer.RenderEndTag();
|
|
}
|
|
}
|
|
|
|
if ((currentColumn == totalColumns) || (i == itemCount - 1)) {
|
|
if (tableLayout) {
|
|
// End tag for TR
|
|
writer.RenderEndTag();
|
|
}
|
|
else {
|
|
// write out the <br> after rows when there are multiple rows
|
|
if (totalColumns < itemCount) {
|
|
if (EnableLegacyRendering) {
|
|
writer.WriteObsoleteBreak();
|
|
}
|
|
else {
|
|
writer.WriteBreak();
|
|
}
|
|
}
|
|
}
|
|
|
|
currentColumn = 0;
|
|
}
|
|
}
|
|
|
|
if (user.HasFooter) {
|
|
if (tableLayout) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
|
|
if ((totalColumns != 1) || separators) {
|
|
// add attributes to render for TD
|
|
int columnSpan = totalColumns;
|
|
if (separators)
|
|
columnSpan += totalColumns;
|
|
writer.AddAttribute(HtmlTextWriterAttribute.Colspan, columnSpan.ToString(NumberFormatInfo.InvariantInfo));
|
|
}
|
|
// add style attributes to render for TD
|
|
Style style = user.GetItemStyle(ListItemType.Footer, -1);
|
|
if (style != null)
|
|
style.AddAttributesToRender(writer);
|
|
// render begin tag for TD
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
user.RenderItem(ListItemType.Footer, -1, this, writer);
|
|
if (tableLayout) {
|
|
// render end tag for TR and TD
|
|
writer.RenderEndTag();
|
|
writer.RenderEndTag();
|
|
}
|
|
}
|
|
|
|
outerControl.RenderEndTag(writer);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Renders the Repeater with the specified
|
|
/// information.</para>
|
|
/// </devdoc>
|
|
public void RenderRepeater(HtmlTextWriter writer, IRepeatInfoUser user, Style controlStyle, WebControl baseControl) {
|
|
if (IsListLayout) {
|
|
if (user.HasFooter || user.HasHeader || user.HasSeparators) {
|
|
throw new InvalidOperationException(SR.GetString(SR.RepeatInfo_ListLayoutDoesNotSupportHeaderFooterSeparator));
|
|
}
|
|
if (RepeatDirection != RepeatDirection.Vertical) {
|
|
throw new InvalidOperationException(SR.GetString(SR.RepeatInfo_ListLayoutOnlySupportsVerticalLayout));
|
|
}
|
|
if ((RepeatColumns != 0) && (RepeatColumns != 1)) {
|
|
throw new InvalidOperationException(SR.GetString(SR.RepeatInfo_ListLayoutDoesNotSupportMultipleColumn));
|
|
}
|
|
if (OuterTableImplied) {
|
|
throw new InvalidOperationException(SR.GetString(SR.RepeatInfo_ListLayoutDoesNotSupportImpliedOuterTable));
|
|
}
|
|
}
|
|
|
|
if (repeatDirection == RepeatDirection.Vertical) {
|
|
RenderVerticalRepeater(writer, user, controlStyle, baseControl);
|
|
}
|
|
else {
|
|
RenderHorizontalRepeater(writer, user, controlStyle, baseControl);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
private void RenderVerticalRepeater(HtmlTextWriter writer, IRepeatInfoUser user, Style controlStyle, WebControl baseControl) {
|
|
int itemCount = user.RepeatedItemCount;
|
|
int totalColumns;
|
|
int totalRows;
|
|
int filledColumns;
|
|
|
|
// List Layout Constraint --> Columns = 0 or 1
|
|
if ((repeatColumns == 0) || (repeatColumns == 1)) {
|
|
// A RepeatColumns of 0 implies a completely vertical repetition in
|
|
// a single column. This is same as repeatColumns of 1.
|
|
totalColumns = 1;
|
|
filledColumns = 1;
|
|
totalRows = itemCount;
|
|
}
|
|
else {
|
|
totalColumns = repeatColumns;
|
|
totalRows = (int)((itemCount + repeatColumns - 1) / repeatColumns);
|
|
|
|
if ((totalRows == 0) && (itemCount != 0)) {
|
|
// if repeatColumns is a huge number like Int32.MaxValue, then the
|
|
// calculation above essentially reduces down to 0
|
|
totalRows = 1;
|
|
}
|
|
|
|
filledColumns = itemCount % totalColumns;
|
|
if (filledColumns == 0) {
|
|
filledColumns = totalColumns;
|
|
}
|
|
}
|
|
|
|
|
|
WebControl outerControl = null;
|
|
bool tableLayout = false;
|
|
|
|
// List Layout Constraint --> OuterTableImplied = false
|
|
// List Layout Constraint --> tableLayout = false
|
|
if (!outerTableImplied) {
|
|
switch (repeatLayout) {
|
|
case RepeatLayout.Table:
|
|
outerControl = new Table();
|
|
if (Caption.Length != 0) {
|
|
((Table)outerControl).Caption = Caption;
|
|
((Table)outerControl).CaptionAlign = CaptionAlign;
|
|
}
|
|
tableLayout = true;
|
|
break;
|
|
case RepeatLayout.Flow:
|
|
outerControl = new WebControl(HtmlTextWriterTag.Span);
|
|
break;
|
|
case RepeatLayout.UnorderedList:
|
|
outerControl = new WebControl(HtmlTextWriterTag.Ul);
|
|
break;
|
|
case RepeatLayout.OrderedList:
|
|
outerControl = new WebControl(HtmlTextWriterTag.Ol);
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool separators = user.HasSeparators;
|
|
// List Layout Constraint --> separators = false
|
|
|
|
if (outerControl != null) {
|
|
// use ClientID (and not ID) since we want to render out the fully qualified client id
|
|
// even though this outer control will not be parented to the control hierarchy
|
|
outerControl.ID = baseControl.ClientID;
|
|
|
|
outerControl.CopyBaseAttributes(baseControl);
|
|
outerControl.ApplyStyle(controlStyle);
|
|
outerControl.RenderBeginTag(writer);
|
|
}
|
|
|
|
// List Layout Constraint --> HasHeader = false
|
|
if (user.HasHeader) {
|
|
if (tableLayout) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
|
|
// add attributes to render for TH
|
|
if (totalColumns != 1) {
|
|
int columnSpan = totalColumns;
|
|
if (separators)
|
|
columnSpan += totalColumns;
|
|
writer.AddAttribute(HtmlTextWriterAttribute.Colspan, columnSpan.ToString(NumberFormatInfo.InvariantInfo));
|
|
}
|
|
if (useAccessibleHeader) {
|
|
writer.AddAttribute(HtmlTextWriterAttribute.Scope, "col");
|
|
}
|
|
|
|
// add style attributes to render for TD/TH
|
|
Style style = user.GetItemStyle(ListItemType.Header, -1);
|
|
if (style != null) {
|
|
style.AddAttributesToRender(writer);
|
|
}
|
|
|
|
// render begin tag for TD/TH
|
|
if (useAccessibleHeader) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Th);
|
|
}
|
|
else {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
}
|
|
user.RenderItem(ListItemType.Header, -1, this, writer);
|
|
if (tableLayout) {
|
|
// render end tags TD/TH and TR
|
|
writer.RenderEndTag();
|
|
writer.RenderEndTag();
|
|
}
|
|
else if (!outerTableImplied) {
|
|
if (EnableLegacyRendering) {
|
|
writer.WriteObsoleteBreak();
|
|
}
|
|
else {
|
|
writer.WriteBreak();
|
|
}
|
|
}
|
|
}
|
|
|
|
int itemCounter = 0;
|
|
|
|
for (int currentRow = 0; currentRow < totalRows; currentRow++) {
|
|
// List Layout Constraint --> tableLayout = false
|
|
if (tableLayout) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
}
|
|
|
|
int itemIndex = currentRow;
|
|
|
|
for (int currentCol = 0; currentCol < totalColumns; currentCol++) {
|
|
if (itemCounter >= itemCount) {
|
|
// done rendering all items, so break out of the loop now...
|
|
// we might end up here, in unfilled columns attempting to re-render items that
|
|
// have already been rendered on the next column in a prior row.
|
|
break;
|
|
}
|
|
|
|
if (currentCol != 0) {
|
|
itemIndex += totalRows;
|
|
|
|
// if the previous column (currentColumn - 1) was not a filled column, i.e.,
|
|
// it had one less item (the maximum possible), then subtract 1 from the item index.
|
|
if ((currentCol - 1) >= filledColumns) {
|
|
itemIndex--;
|
|
}
|
|
}
|
|
|
|
|
|
if (itemIndex >= itemCount)
|
|
continue;
|
|
|
|
itemCounter++;
|
|
|
|
// List Layout Constraint --> tableLayout = false
|
|
if (tableLayout) {
|
|
// add style attributes to render for TD
|
|
Style style = user.GetItemStyle(ListItemType.Item, itemIndex);
|
|
if (style != null)
|
|
style.AddAttributesToRender(writer);
|
|
// render begin tag for TD
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
|
|
if (IsListLayout) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Li);
|
|
}
|
|
|
|
user.RenderItem(ListItemType.Item, itemIndex, this, writer);
|
|
|
|
if (IsListLayout) {
|
|
writer.RenderEndTag();
|
|
writer.WriteLine();
|
|
}
|
|
|
|
// List Layout Constraint --> tableLayout = false
|
|
if (tableLayout) {
|
|
// render end tag for TD
|
|
writer.RenderEndTag();
|
|
}
|
|
|
|
// List Layout Constraint --> separators = false
|
|
if (separators) {
|
|
if (itemIndex != (itemCount - 1)) {
|
|
if (totalColumns == 1) {
|
|
if (tableLayout) {
|
|
writer.RenderEndTag();
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
}
|
|
else {
|
|
if (!outerTableImplied) {
|
|
if (EnableLegacyRendering) {
|
|
writer.WriteObsoleteBreak();
|
|
}
|
|
else {
|
|
writer.WriteBreak();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tableLayout) {
|
|
Style style = user.GetItemStyle(ListItemType.Separator, itemIndex);
|
|
if (style != null)
|
|
style.AddAttributesToRender(writer);
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
if (itemIndex < itemCount)
|
|
user.RenderItem(ListItemType.Separator, itemIndex, this, writer);
|
|
if (tableLayout)
|
|
writer.RenderEndTag();
|
|
}
|
|
else {
|
|
// if we're on the last filled line and separators are specified, add another <td/>
|
|
// to accomodate for the lack of a separator on the last item. If there's only one
|
|
// column, though, separators will get their own row anyways.
|
|
if (tableLayout && totalColumns > 1) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
writer.RenderEndTag();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// on the last line, fill in the remaining empty slots with <td/>s. We need twice as many
|
|
// if there were separators.
|
|
// List Layout Constraint --> tableLayout = false
|
|
if (tableLayout) {
|
|
if (currentRow == totalRows - 1) {
|
|
int unfilledColumns = totalColumns - filledColumns;
|
|
if (separators) {
|
|
int unfilledColumnsWithSeparators = unfilledColumns * 2;
|
|
if (unfilledColumnsWithSeparators >= unfilledColumns) {
|
|
unfilledColumns = unfilledColumnsWithSeparators;
|
|
}
|
|
}
|
|
if (unfilledColumns != 0) {
|
|
for (int i = 0; i < unfilledColumns; i++) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
writer.RenderEndTag();
|
|
}
|
|
}
|
|
}
|
|
writer.RenderEndTag();
|
|
}
|
|
else {
|
|
if (((currentRow != totalRows - 1) || user.HasFooter) &&
|
|
(!outerTableImplied) && (!IsListLayout)) {
|
|
|
|
if (EnableLegacyRendering) {
|
|
writer.WriteObsoleteBreak();
|
|
}
|
|
else {
|
|
writer.WriteBreak();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// List Layout Constraint --> HasFooter = false
|
|
if (user.HasFooter) {
|
|
if (tableLayout) {
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
|
|
// add attributes to render for TD
|
|
if (totalColumns != 1) {
|
|
int columnSpan = totalColumns;
|
|
if (separators)
|
|
columnSpan += totalColumns;
|
|
writer.AddAttribute(HtmlTextWriterAttribute.Colspan, columnSpan.ToString(NumberFormatInfo.InvariantInfo));
|
|
}
|
|
// add style attributes to render for TD
|
|
Style style = user.GetItemStyle(ListItemType.Footer, -1);
|
|
if (style != null)
|
|
style.AddAttributesToRender(writer);
|
|
// render begin tag for TD
|
|
writer.RenderBeginTag(HtmlTextWriterTag.Td);
|
|
}
|
|
user.RenderItem(ListItemType.Footer, -1, this, writer);
|
|
if (tableLayout) {
|
|
// render end tag for TR and TD
|
|
writer.RenderEndTag();
|
|
writer.RenderEndTag();
|
|
}
|
|
}
|
|
|
|
if (outerControl != null)
|
|
outerControl.RenderEndTag(writer);
|
|
}
|
|
}
|
|
}
|
|
|