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
736 lines
27 KiB
C#
736 lines
27 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="Html32TextWriter.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI {
|
|
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Web.UI.WebControls; //
|
|
using System.Security.Permissions;
|
|
using System.Web.Util;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public class Html32TextWriter : HtmlTextWriter {
|
|
|
|
private const int NOTHING = 0x0000;
|
|
private const int FONT_AROUND_CONTENT = 0x0001;
|
|
private const int FONT_AROUND_TAG = 0x0002;
|
|
private const int TABLE_ATTRIBUTES = 0x0004;
|
|
private const int TABLE_AROUND_CONTENT = 0x0008;
|
|
private const int FONT_PROPAGATE = 0x0010;
|
|
private const int FONT_CONSUME = 0x0020;
|
|
private const int SUPPORTS_HEIGHT_WIDTH = 0x0040;
|
|
private const int SUPPORTS_BORDER = 0x0080;
|
|
private const int SUPPORTS_NOWRAP = 0x0100;
|
|
|
|
private StringBuilder _afterContent;
|
|
private StringBuilder _afterTag;
|
|
private StringBuilder _beforeContent;
|
|
private StringBuilder _beforeTag;
|
|
private string _fontColor;
|
|
private string _fontFace;
|
|
private string _fontSize;
|
|
//
|
|
|
|
private Stack _fontStack;
|
|
private bool _shouldPerformDivTableSubstitution;
|
|
private bool _renderFontTag;
|
|
private bool _supportsBold = true;
|
|
private bool _supportsItalic = true;
|
|
private int _tagSupports;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public Html32TextWriter(TextWriter writer) : this(writer, DefaultTabString) {
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public Html32TextWriter(TextWriter writer, string tabString) : base(writer, tabString) {
|
|
// The initial capacities should be set up such that they are at least twice what
|
|
// we expect for the maximum content we're going to stuff in into the builder.
|
|
// This gives the best perf when using the Length property to reset the builder.
|
|
|
|
_beforeTag = new StringBuilder(256);
|
|
_beforeContent = new StringBuilder(256);
|
|
_afterContent = new StringBuilder(128);
|
|
_afterTag = new StringBuilder(128);
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected Stack FontStack {
|
|
get {
|
|
if (_fontStack == null) {
|
|
_fontStack = new Stack(3);
|
|
}
|
|
return _fontStack;
|
|
}
|
|
}
|
|
|
|
internal override bool RenderDivAroundHiddenInputs {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool ShouldPerformDivTableSubstitution {
|
|
get {
|
|
return _shouldPerformDivTableSubstitution;
|
|
}
|
|
set {
|
|
_shouldPerformDivTableSubstitution = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public bool SupportsBold {
|
|
get {
|
|
return _supportsBold;
|
|
}
|
|
set {
|
|
_supportsBold = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public bool SupportsItalic {
|
|
get {
|
|
return _supportsItalic;
|
|
}
|
|
set {
|
|
_supportsItalic = value;
|
|
}
|
|
}
|
|
|
|
private void AppendFontTag(StringBuilder sbBegin,StringBuilder sbEnd) {
|
|
AppendFontTag(_fontFace, _fontColor, _fontSize, sbBegin, sbEnd);
|
|
}
|
|
|
|
private void AppendFontTag(string fontFace, string fontColor, string fontSize, StringBuilder sbBegin,StringBuilder sbEnd) {
|
|
// append font begin tag
|
|
sbBegin.Append(TagLeftChar);
|
|
sbBegin.Append("font");
|
|
if (fontFace != null) {
|
|
sbBegin.Append(" face");
|
|
sbBegin.Append(EqualsDoubleQuoteString);
|
|
sbBegin.Append(fontFace);
|
|
sbBegin.Append(DoubleQuoteChar);
|
|
}
|
|
if (fontColor != null) {
|
|
sbBegin.Append(" color=");
|
|
sbBegin.Append(DoubleQuoteChar);
|
|
sbBegin.Append(fontColor);
|
|
sbBegin.Append(DoubleQuoteChar);
|
|
}
|
|
if (fontSize != null) {
|
|
sbBegin.Append(" size=");
|
|
sbBegin.Append(DoubleQuoteChar);
|
|
sbBegin.Append(fontSize);
|
|
sbBegin.Append(DoubleQuoteChar);
|
|
}
|
|
sbBegin.Append(TagRightChar);
|
|
|
|
// insert font end tag
|
|
sbEnd.Insert(0,EndTagLeftChars + "font" + TagRightChar);
|
|
}
|
|
|
|
private void AppendOtherTag(string tag) {
|
|
if (Supports(FONT_AROUND_CONTENT))
|
|
AppendOtherTag(tag,_beforeContent,_afterContent);
|
|
else
|
|
AppendOtherTag(tag,_beforeTag,_afterTag);
|
|
}
|
|
|
|
private void AppendOtherTag(string tag,StringBuilder sbBegin,StringBuilder sbEnd) {
|
|
// append begin tag
|
|
sbBegin.Append(TagLeftChar);
|
|
sbBegin.Append(tag);
|
|
sbBegin.Append(TagRightChar);
|
|
|
|
// insert end tag
|
|
sbEnd.Insert(0,EndTagLeftChars + tag + TagRightChar);
|
|
}
|
|
|
|
private void AppendOtherTag(string tag, object[] attribs, StringBuilder sbBegin, StringBuilder sbEnd) {
|
|
// append begin tag
|
|
sbBegin.Append(TagLeftChar);
|
|
sbBegin.Append(tag);
|
|
for (int i = 0; i < attribs.Length; i++) {
|
|
sbBegin.Append(SpaceChar);
|
|
sbBegin.Append(((string[])attribs[i])[0]);
|
|
sbBegin.Append(EqualsDoubleQuoteString);
|
|
sbBegin.Append(((string[])attribs[i])[1]);
|
|
sbBegin.Append(DoubleQuoteChar);
|
|
}
|
|
sbBegin.Append(TagRightChar);
|
|
|
|
// insert end tag
|
|
sbEnd.Insert(0,EndTagLeftChars + tag + TagRightChar);
|
|
}
|
|
|
|
private void ConsumeFont(StringBuilder sbBegin, StringBuilder sbEnd) {
|
|
|
|
if (FontStack.Count > 0) {
|
|
|
|
string fontFace = null;
|
|
string fontColor = null;
|
|
string fontSize = null;
|
|
bool underline = false;
|
|
bool italic = false;
|
|
bool bold = false;
|
|
bool strikeout = false;
|
|
|
|
IEnumerator e = FontStack.GetEnumerator();
|
|
while(e.MoveNext()) {
|
|
FontStackItem fontInfo = (FontStackItem) e.Current;
|
|
if (fontFace == null) {
|
|
fontFace = fontInfo.name;
|
|
}
|
|
if (fontColor == null) {
|
|
fontColor = fontInfo.color;
|
|
}
|
|
if (fontSize == null) {
|
|
fontSize = fontInfo.size;
|
|
}
|
|
if (!underline) {
|
|
underline = fontInfo.underline;
|
|
}
|
|
if (!italic) {
|
|
italic = fontInfo.italic;
|
|
}
|
|
if (!bold) {
|
|
bold = fontInfo.bold;
|
|
}
|
|
if (!strikeout) {
|
|
strikeout = fontInfo.strikeout;
|
|
}
|
|
}
|
|
|
|
if ((fontFace != null) || (fontColor != null) || (fontSize != null)) {
|
|
AppendFontTag(fontFace, fontColor, fontSize, sbBegin, sbEnd);
|
|
}
|
|
if (underline) {
|
|
AppendOtherTag("u", sbBegin, sbEnd);
|
|
}
|
|
if (italic && SupportsItalic) {
|
|
AppendOtherTag("i", sbBegin, sbEnd);
|
|
}
|
|
if (bold && SupportsBold) {
|
|
AppendOtherTag("b", sbBegin, sbEnd);
|
|
}
|
|
if (strikeout) {
|
|
AppendOtherTag("strike", sbBegin, sbEnd);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private string ConvertToHtmlFontSize(string value) {
|
|
FontUnit fu = new FontUnit(value, CultureInfo.InvariantCulture);
|
|
if ((int)(fu.Type) > 3)
|
|
return((int)(fu.Type)-3).ToString(CultureInfo.InvariantCulture);
|
|
|
|
if (fu.Type == FontSize.AsUnit) {
|
|
if (fu.Unit.Type == UnitType.Point) {
|
|
if (fu.Unit.Value <= 8)
|
|
return "1";
|
|
else if (fu.Unit.Value <= 10)
|
|
return "2";
|
|
else if (fu.Unit.Value <= 12)
|
|
return "3";
|
|
else if (fu.Unit.Value <= 14)
|
|
return "4";
|
|
else if (fu.Unit.Value <= 18)
|
|
return "5";
|
|
else if (fu.Unit.Value <= 24)
|
|
return "6";
|
|
else
|
|
return "7";
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private string ConvertToHtmlSize(string value) {
|
|
Unit u = new Unit(value, CultureInfo.InvariantCulture);
|
|
if (u.Type == UnitType.Pixel) {
|
|
return u.Value.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
if (u.Type == UnitType.Percentage) {
|
|
return value;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override bool OnStyleAttributeRender(string name,string value, HtmlTextWriterStyle key) {
|
|
|
|
string s;
|
|
if (Supports(FONT_AROUND_CONTENT)) {
|
|
// tag supports downlevel fonts
|
|
switch (key) {
|
|
case HtmlTextWriterStyle.FontFamily:
|
|
_fontFace = value;
|
|
_renderFontTag = true;
|
|
break;
|
|
case HtmlTextWriterStyle.Color:
|
|
_fontColor = value;
|
|
_renderFontTag = true;
|
|
break;
|
|
case HtmlTextWriterStyle.FontSize:
|
|
_fontSize = ConvertToHtmlFontSize(value);
|
|
if (_fontSize != null)
|
|
_renderFontTag = true;
|
|
break;
|
|
case HtmlTextWriterStyle.FontWeight:
|
|
if (StringUtil.EqualsIgnoreCase(value, "bold") && SupportsBold) {
|
|
AppendOtherTag("b");
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.FontStyle:
|
|
if (!StringUtil.EqualsIgnoreCase(value, "normal") && SupportsItalic) {
|
|
AppendOtherTag("i");
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.TextDecoration:
|
|
s = value.ToLower(CultureInfo.InvariantCulture);
|
|
if (s.IndexOf("underline", StringComparison.Ordinal) != -1) {
|
|
AppendOtherTag("u");
|
|
}
|
|
if (s.IndexOf("line-through", StringComparison.Ordinal) != -1) {
|
|
AppendOtherTag("strike");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if (Supports(FONT_PROPAGATE)) {
|
|
FontStackItem font = (FontStackItem)FontStack.Peek();
|
|
|
|
switch (key) {
|
|
case HtmlTextWriterStyle.FontFamily:
|
|
font.name = value;
|
|
break;
|
|
case HtmlTextWriterStyle.Color:
|
|
font.color = value;
|
|
break;
|
|
case HtmlTextWriterStyle.FontSize:
|
|
font.size = ConvertToHtmlFontSize(value);
|
|
break;
|
|
case HtmlTextWriterStyle.FontWeight:
|
|
if (StringUtil.EqualsIgnoreCase(value, "bold")) {
|
|
font.bold = true;
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.FontStyle:
|
|
if (!StringUtil.EqualsIgnoreCase(value, "normal")) {
|
|
font.italic = true;
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.TextDecoration:
|
|
s = value.ToLower(CultureInfo.InvariantCulture);
|
|
if (s.IndexOf("underline", StringComparison.Ordinal) != -1) {
|
|
font.underline = true;
|
|
}
|
|
if (s.IndexOf("line-through", StringComparison.Ordinal) != -1) {
|
|
font.strikeout = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Supports(SUPPORTS_BORDER) && key == HtmlTextWriterStyle.BorderWidth) {
|
|
s = ConvertToHtmlSize(value);
|
|
if (s != null)
|
|
AddAttribute(HtmlTextWriterAttribute.Border,s);
|
|
}
|
|
|
|
if (Supports(SUPPORTS_NOWRAP) && key == HtmlTextWriterStyle.WhiteSpace) {
|
|
AddAttribute(HtmlTextWriterAttribute.Nowrap, value);
|
|
}
|
|
|
|
if (Supports(SUPPORTS_HEIGHT_WIDTH)) {
|
|
switch (key) {
|
|
case HtmlTextWriterStyle.Height :
|
|
s = ConvertToHtmlSize(value);
|
|
if (s != null)
|
|
AddAttribute(HtmlTextWriterAttribute.Height,s);
|
|
break;
|
|
case HtmlTextWriterStyle.Width :
|
|
s = ConvertToHtmlSize(value);
|
|
if (s != null)
|
|
AddAttribute(HtmlTextWriterAttribute.Width,s);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Supports(TABLE_ATTRIBUTES) || Supports(TABLE_AROUND_CONTENT)) {
|
|
// tag supports downlevel table attributes
|
|
switch (key) {
|
|
case HtmlTextWriterStyle.BorderColor:
|
|
switch (TagKey) {
|
|
case HtmlTextWriterTag.Div:
|
|
if (ShouldPerformDivTableSubstitution) {
|
|
AddAttribute(HtmlTextWriterAttribute.Bordercolor, value);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.BackgroundColor :
|
|
switch (TagKey) {
|
|
case HtmlTextWriterTag.Table :
|
|
case HtmlTextWriterTag.Tr :
|
|
case HtmlTextWriterTag.Td :
|
|
case HtmlTextWriterTag.Th :
|
|
case HtmlTextWriterTag.Body :
|
|
AddAttribute(HtmlTextWriterAttribute.Bgcolor,value);
|
|
break;
|
|
// div->table substitution.
|
|
case HtmlTextWriterTag.Div:
|
|
if (ShouldPerformDivTableSubstitution) {
|
|
AddAttribute(HtmlTextWriterAttribute.Bgcolor,value);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.BackgroundImage :
|
|
switch (TagKey) {
|
|
case HtmlTextWriterTag.Table :
|
|
case HtmlTextWriterTag.Td :
|
|
case HtmlTextWriterTag.Th :
|
|
case HtmlTextWriterTag.Body :
|
|
// strip url(...) from value
|
|
if (StringUtil.StringStartsWith(value, "url("))
|
|
value = value.Substring(4,value.Length-5);
|
|
AddAttribute(HtmlTextWriterAttribute.Background,value);
|
|
break;
|
|
// div->table substitution.
|
|
case HtmlTextWriterTag.Div:
|
|
if (ShouldPerformDivTableSubstitution) {
|
|
if (StringUtil.StringStartsWith(value, "url("))
|
|
value = value.Substring(4,value.Length-5);
|
|
AddAttribute(HtmlTextWriterAttribute.Background,value);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (key) {
|
|
case HtmlTextWriterStyle.ListStyleType:
|
|
switch (value) {
|
|
case "decimal":
|
|
AddAttribute(HtmlTextWriterAttribute.Type, "1");
|
|
break;
|
|
case "lower-alpha":
|
|
AddAttribute(HtmlTextWriterAttribute.Type, "a");
|
|
break;
|
|
case "upper-alpha":
|
|
AddAttribute(HtmlTextWriterAttribute.Type, "A");
|
|
break;
|
|
case "lower-roman":
|
|
AddAttribute(HtmlTextWriterAttribute.Type, "i");
|
|
break;
|
|
case "upper-roman":
|
|
AddAttribute(HtmlTextWriterAttribute.Type, "I");
|
|
break;
|
|
case "disc":
|
|
case "circle":
|
|
case "square":
|
|
AddAttribute(HtmlTextWriterAttribute.Type, value);
|
|
break;
|
|
default:
|
|
AddAttribute(HtmlTextWriterAttribute.Type, "disc");
|
|
Debug.Assert(false, "Invalid BulletStyle for HTML32.");
|
|
break;
|
|
}
|
|
break;
|
|
case HtmlTextWriterStyle.TextAlign:
|
|
AddAttribute(HtmlTextWriterAttribute.Align, value);
|
|
break;
|
|
case HtmlTextWriterStyle.VerticalAlign:
|
|
AddAttribute(HtmlTextWriterAttribute.Valign, value);
|
|
break;
|
|
// Netscape 4.72 can properly handle the Display style attribute, so allow it
|
|
// to be rendered.
|
|
case HtmlTextWriterStyle.Display:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override bool OnTagRender(string name, HtmlTextWriterTag key) {
|
|
// handle any tags that do not work downlevel
|
|
|
|
SetTagSupports();
|
|
if (Supports(FONT_PROPAGATE)) {
|
|
FontStack.Push(new FontStackItem());
|
|
}
|
|
|
|
// div->table substitution.
|
|
// Make tag look like a table. This must be done after we establish tag support.
|
|
if (key == HtmlTextWriterTag.Div && ShouldPerformDivTableSubstitution) {
|
|
TagKey = HtmlTextWriterTag.Table;
|
|
}
|
|
|
|
return base.OnTagRender(name,key);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override string GetTagName(HtmlTextWriterTag tagKey) {
|
|
// div->table substitution.
|
|
if (tagKey == HtmlTextWriterTag.Div && ShouldPerformDivTableSubstitution) {
|
|
return "table";
|
|
}
|
|
return base.GetTagName(tagKey);
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public override void RenderBeginTag(HtmlTextWriterTag tagKey) {
|
|
// flush string buffers to build new tag
|
|
_beforeTag.Length = 0;
|
|
_beforeContent.Length = 0;
|
|
_afterContent.Length = 0;
|
|
_afterTag.Length = 0;
|
|
|
|
_renderFontTag = false;
|
|
_fontFace = null;
|
|
_fontColor = null;
|
|
_fontSize = null;
|
|
|
|
// div->table substitution.
|
|
if (ShouldPerformDivTableSubstitution) {
|
|
if (tagKey == HtmlTextWriterTag.Div) {
|
|
AppendOtherTag("tr", _beforeContent, _afterContent);
|
|
|
|
string alignment;
|
|
if (IsAttributeDefined(HtmlTextWriterAttribute.Align, out alignment)) {
|
|
string[] attribs = new string[] { GetAttributeName(HtmlTextWriterAttribute.Align), alignment};
|
|
|
|
AppendOtherTag("td", new object[]{ attribs}, _beforeContent, _afterContent);
|
|
}
|
|
else {
|
|
AppendOtherTag("td", _beforeContent, _afterContent);
|
|
}
|
|
if (!IsAttributeDefined(HtmlTextWriterAttribute.Cellpadding)) {
|
|
AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
|
|
}
|
|
if (!IsAttributeDefined(HtmlTextWriterAttribute.Cellspacing)) {
|
|
AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
|
|
}
|
|
if (!IsStyleAttributeDefined(HtmlTextWriterStyle.BorderWidth)) {
|
|
AddAttribute(HtmlTextWriterAttribute.Border, "0");
|
|
}
|
|
if (!IsStyleAttributeDefined(HtmlTextWriterStyle.Width)) {
|
|
AddAttribute(HtmlTextWriterAttribute.Width, "100%");
|
|
}
|
|
}
|
|
}
|
|
|
|
base.RenderBeginTag(tagKey);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override string RenderBeforeTag() {
|
|
if (_renderFontTag && Supports(FONT_AROUND_TAG))
|
|
AppendFontTag(_beforeTag,_afterTag);
|
|
|
|
if (_beforeTag.Length > 0)
|
|
return(_beforeTag.ToString());
|
|
|
|
return base.RenderBeforeTag();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override string RenderBeforeContent() {
|
|
|
|
if (Supports(FONT_CONSUME)) {
|
|
ConsumeFont(_beforeContent, _afterContent);
|
|
}
|
|
else if (_renderFontTag && Supports(FONT_AROUND_CONTENT)) {
|
|
AppendFontTag(_beforeContent,_afterContent);
|
|
}
|
|
|
|
if (_beforeContent.Length > 0)
|
|
return(_beforeContent.ToString());
|
|
|
|
return base.RenderBeforeContent();
|
|
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override string RenderAfterContent() {
|
|
if (_afterContent.Length > 0)
|
|
return(_afterContent.ToString());
|
|
|
|
return base.RenderAfterContent();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override string RenderAfterTag() {
|
|
if (_afterTag.Length > 0)
|
|
return(_afterTag.ToString());
|
|
|
|
return base.RenderAfterTag();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public override void RenderEndTag() {
|
|
base.RenderEndTag();
|
|
|
|
SetTagSupports();
|
|
if (Supports(FONT_PROPAGATE)) {
|
|
FontStack.Pop();
|
|
}
|
|
}
|
|
|
|
private void SetTagSupports() {
|
|
// determine what downlevel tag supports
|
|
_tagSupports = NOTHING;
|
|
switch (TagKey) {
|
|
case HtmlTextWriterTag.A :
|
|
case HtmlTextWriterTag.Label :
|
|
case HtmlTextWriterTag.P :
|
|
case HtmlTextWriterTag.Span :
|
|
_tagSupports |= FONT_AROUND_CONTENT;
|
|
break;
|
|
case HtmlTextWriterTag.Li:
|
|
_tagSupports |= FONT_AROUND_CONTENT | FONT_CONSUME;
|
|
break;
|
|
case HtmlTextWriterTag.Div :
|
|
_tagSupports |= FONT_AROUND_CONTENT | FONT_PROPAGATE;
|
|
break;
|
|
case HtmlTextWriterTag.Ul:
|
|
case HtmlTextWriterTag.Ol:
|
|
case HtmlTextWriterTag.Table:
|
|
case HtmlTextWriterTag.Tr:
|
|
_tagSupports |= FONT_PROPAGATE;
|
|
break;
|
|
case HtmlTextWriterTag.Td :
|
|
case HtmlTextWriterTag.Th :
|
|
_tagSupports |= FONT_PROPAGATE | FONT_CONSUME;
|
|
break;
|
|
case HtmlTextWriterTag.Input :
|
|
_tagSupports |= SUPPORTS_BORDER;
|
|
break;
|
|
}
|
|
|
|
switch (TagKey) {
|
|
// div->table substitution.
|
|
case HtmlTextWriterTag.Div:
|
|
if (ShouldPerformDivTableSubstitution) {
|
|
_tagSupports |= SUPPORTS_HEIGHT_WIDTH | SUPPORTS_BORDER;
|
|
}
|
|
_tagSupports |= SUPPORTS_NOWRAP;
|
|
break;
|
|
case HtmlTextWriterTag.Img:
|
|
_tagSupports |= SUPPORTS_HEIGHT_WIDTH | SUPPORTS_BORDER;
|
|
break;
|
|
case HtmlTextWriterTag.Table:
|
|
_tagSupports |= SUPPORTS_HEIGHT_WIDTH;
|
|
break;
|
|
case HtmlTextWriterTag.Th:
|
|
case HtmlTextWriterTag.Td:
|
|
_tagSupports |= SUPPORTS_NOWRAP | SUPPORTS_HEIGHT_WIDTH;
|
|
break;
|
|
}
|
|
|
|
//switch (TagKey) {
|
|
// case HtmlTextWriterTag.INPUT :
|
|
// _tagSupports |= FONT_AROUND_TAG;
|
|
// break;
|
|
//}
|
|
|
|
switch (TagKey) {
|
|
case HtmlTextWriterTag.Table :
|
|
case HtmlTextWriterTag.Tr :
|
|
case HtmlTextWriterTag.Td :
|
|
case HtmlTextWriterTag.Th :
|
|
case HtmlTextWriterTag.Body :
|
|
_tagSupports |= TABLE_ATTRIBUTES;
|
|
break;
|
|
}
|
|
switch (TagKey) {
|
|
// div->table substitution.
|
|
case HtmlTextWriterTag.Div :
|
|
if (ShouldPerformDivTableSubstitution) {
|
|
_tagSupports |= TABLE_AROUND_CONTENT;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool Supports(int flag) {
|
|
return(_tagSupports & flag) == flag;
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Contains information about a font placed on the stack of font information.
|
|
/// </devdoc>
|
|
private sealed class FontStackItem {
|
|
public string name;
|
|
public string color;
|
|
public string size;
|
|
public bool bold;
|
|
public bool italic;
|
|
public bool underline;
|
|
public bool strikeout;
|
|
}
|
|
}
|
|
}
|