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
1366 lines
44 KiB
C#
1366 lines
44 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HtmlMobileTextWriter.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Web;
|
|
using System.Web.Mobile;
|
|
using System.Web.UI;
|
|
using System.Web.UI.MobileControls;
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.Security.Permissions;
|
|
|
|
#if COMPILING_FOR_SHIPPED_SOURCE
|
|
namespace System.Web.UI.MobileControls.ShippedAdapterSource
|
|
#else
|
|
namespace System.Web.UI.MobileControls.Adapters
|
|
#endif
|
|
|
|
{
|
|
|
|
/*
|
|
* HtmlMobileTextWriter class.
|
|
*/
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter"]/*' />
|
|
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
|
|
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
public class HtmlMobileTextWriter : MobileTextWriter
|
|
{
|
|
private bool _shouldEnsureStyle = true;
|
|
|
|
// mobile device type constants (should be defined somewhere else eventually)
|
|
internal WriterState _currentState;
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.HtmlMobileTextWriter"]/*' />
|
|
public HtmlMobileTextWriter(TextWriter writer, MobileCapabilities device)
|
|
: base(writer, device)
|
|
{
|
|
RenderBold = device.SupportsBold;
|
|
RenderItalic = device.SupportsItalic;
|
|
RenderFontSize = device.SupportsFontSize;
|
|
RenderFontName = device.SupportsFontName;
|
|
RenderFontColor = device.SupportsFontColor;
|
|
RenderBodyColor = device.SupportsBodyColor;
|
|
RenderDivAlign = device.SupportsDivAlign;
|
|
RenderDivNoWrap = device.SupportsDivNoWrap;
|
|
RequiresNoBreakInFormatting = device.RequiresNoBreakInFormatting;
|
|
_currentState = new WriterState(this);
|
|
}
|
|
|
|
/*
|
|
* the following TextWriter methods are overridden to
|
|
* first call EnsureStyle before delegating to the base
|
|
* class implementation
|
|
*/
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteBeginTag"]/*' />
|
|
public override void WriteBeginTag(String tag)
|
|
{
|
|
EnsureStyle();
|
|
base.WriteBeginTag(tag);
|
|
}
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteFullBeginTag"]/*' />
|
|
public override void WriteFullBeginTag(String tag)
|
|
{
|
|
EnsureStyle();
|
|
base.WriteFullBeginTag(tag);
|
|
}
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.Write"]/*' />
|
|
public override void Write(char c)
|
|
{
|
|
EnsureStyle();
|
|
base.Write(c);
|
|
}
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.Write1"]/*' />
|
|
public override void Write(String text)
|
|
{
|
|
EnsureStyle();
|
|
base.Write(text);
|
|
}
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteEncodedText"]/*' />
|
|
public override void WriteEncodedText(String text)
|
|
{
|
|
EnsureStyle();
|
|
if(Device["supportsCharacterEntityEncoding"] != "false") {
|
|
base.WriteEncodedText(text);
|
|
return;
|
|
}
|
|
if (null == text || text.Length == 0) {
|
|
return;
|
|
}
|
|
|
|
int length = text.Length;
|
|
int start = -1;
|
|
for(int pos = 0; pos < length; pos++) {
|
|
int ch = text[pos];
|
|
if(ch > 160 && ch < 256) {
|
|
if(start != -1) {
|
|
base.WriteEncodedText(text.Substring(start, pos - start));
|
|
start = -1;
|
|
}
|
|
base.Write(text[pos]);
|
|
}
|
|
else {
|
|
if(start == -1) {
|
|
start = pos;
|
|
}
|
|
}
|
|
}
|
|
if(start != -1) {
|
|
if(start == 0) {
|
|
base.WriteEncodedText(text);
|
|
}
|
|
else {
|
|
base.WriteEncodedText(text.Substring(start, length - start));
|
|
}
|
|
}
|
|
}
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteLine"]/*' />
|
|
public override void WriteLine(String text)
|
|
{
|
|
EnsureStyle();
|
|
base.WriteLine(text);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteBreak"]/*' />
|
|
public new void WriteBreak()
|
|
{
|
|
//Do not EnsureStyle for the break
|
|
base.WriteLine("<br>");
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.EnterLayout"]/*' />
|
|
public override void EnterLayout(Style style)
|
|
{
|
|
WriterStyle writerStyle = new WriterStyle(style);
|
|
writerStyle.Format = false;
|
|
EnterStyle(writerStyle);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.ExitLayout"]/*' />
|
|
public override void ExitLayout(Style style, bool breakAfter)
|
|
{
|
|
ExitStyle(style, breakAfter);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.ExitLayout1"]/*' />
|
|
public override void ExitLayout(Style style)
|
|
{
|
|
ExitStyle(style, false);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.MarkStyleContext"]/*' />
|
|
protected internal void MarkStyleContext()
|
|
{
|
|
_shouldEnsureStyle = true;
|
|
_currentState.MarkStyleContext();
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.UnMarkStyleContext"]/*' />
|
|
protected internal void UnMarkStyleContext()
|
|
{
|
|
_shouldEnsureStyle = true;
|
|
_currentState.UnMarkStyleContext();
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.EnterFormat"]/*' />
|
|
public override void EnterFormat(Style style)
|
|
{
|
|
WriterStyle writerStyle = new WriterStyle(style);
|
|
writerStyle.Layout = false;
|
|
EnterStyle(writerStyle);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.ExitFormat"]/*' />
|
|
public override void ExitFormat(Style style)
|
|
{
|
|
ExitStyle(style);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.ExitFormat1"]/*' />
|
|
public override void ExitFormat(Style style, bool breakAfter)
|
|
{
|
|
ExitStyle(style, breakAfter);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.BeginStyleContext"]/*' />
|
|
public void BeginStyleContext()
|
|
{
|
|
if(_currentState.BreakPending)
|
|
{
|
|
WriteBreak();
|
|
_currentState.BreakPending = false;
|
|
}
|
|
_currentState.PushState();
|
|
EnterStyle(new WriterStyle());
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.EndStyleContext"]/*' />
|
|
public void EndStyleContext()
|
|
{
|
|
if(_currentState.BreakPending)
|
|
{
|
|
WriteBreak();
|
|
_currentState.BreakPending = false;
|
|
}
|
|
_currentState.PopState();
|
|
_currentState.Pop();
|
|
_currentState.Transition(new WriterStyle());
|
|
}
|
|
|
|
/* all calls to Enter... converge to this */
|
|
private void EnterStyle(WriterStyle style)
|
|
{
|
|
_currentState.Push(style);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.EnterStyle"]/*' />
|
|
public new void EnterStyle(Style style)
|
|
{
|
|
EnterStyle(new WriterStyle(style));
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.ExitStyle"]/*' />
|
|
public new void ExitStyle(Style style)
|
|
{
|
|
ExitStyle(style, false);
|
|
|
|
}
|
|
|
|
internal bool ShouldEnsureStyle
|
|
{
|
|
get
|
|
{
|
|
return _shouldEnsureStyle;
|
|
}
|
|
set
|
|
{
|
|
_shouldEnsureStyle = value;
|
|
}
|
|
}
|
|
|
|
/*
|
|
all calls to Exit... converge to this
|
|
*/
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.ExitStyle1"]/*' />
|
|
public void ExitStyle(Style style, bool breakAfter)
|
|
{
|
|
_currentState.Pop();
|
|
if((_currentState.BreakPending) && (_currentState.Count > 0))
|
|
{
|
|
EnsureStyle();
|
|
}
|
|
_currentState.BreakPending = breakAfter;
|
|
if((_currentState.Count == 0) || (RequiresNoBreakInFormatting))
|
|
{
|
|
_currentState.Transition(new WriterStyle());
|
|
}
|
|
InputWritten = false;
|
|
}
|
|
|
|
internal bool _inputWritten = false;
|
|
internal bool InputWritten
|
|
{
|
|
get { return _inputWritten; }
|
|
set { _inputWritten = value; }
|
|
}
|
|
|
|
internal void EnsureStyle()
|
|
{
|
|
if (_shouldEnsureStyle)
|
|
{
|
|
if(_currentState.Count > 0)
|
|
{
|
|
_currentState.Transition(_currentState.Peek());
|
|
}
|
|
_shouldEnsureStyle = false;
|
|
}
|
|
if(BeforeFirstControlWritten)
|
|
{
|
|
BeforeFirstControlWritten = false;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteText"]/*' />
|
|
public void WriteText(String text, bool encodeText)
|
|
{
|
|
if(text != null && text.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
EnsureStyle();
|
|
if (encodeText)
|
|
{
|
|
WriteEncodedText(text);
|
|
}
|
|
else
|
|
{
|
|
Write(text);
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteUrlParameter"]/*' />
|
|
public void WriteUrlParameter(String name, String value)
|
|
{
|
|
WriteEncodedUrlParameter(name);
|
|
Write("=");
|
|
WriteEncodedUrlParameter(value);
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.WriteHiddenField"]/*' />
|
|
public void WriteHiddenField(String name, String value)
|
|
{
|
|
WriteBeginTag("input");
|
|
WriteAttribute("type", "hidden");
|
|
WriteAttribute("name", name);
|
|
WriteAttribute("value", value, true);
|
|
Write(">\r\n");
|
|
}
|
|
|
|
|
|
// AUI 2285
|
|
private bool _beforeFirstControlWritten = true;
|
|
internal bool BeforeFirstControlWritten
|
|
{
|
|
get
|
|
{
|
|
return _beforeFirstControlWritten;
|
|
}
|
|
|
|
set
|
|
{
|
|
_beforeFirstControlWritten = value;
|
|
}
|
|
}
|
|
|
|
private bool _maintainState = true;
|
|
|
|
internal bool MaintainState
|
|
{
|
|
get
|
|
{
|
|
return _maintainState;
|
|
}
|
|
set
|
|
{
|
|
_maintainState = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderBold"]/*' />
|
|
protected internal bool RenderBold
|
|
{
|
|
get
|
|
{
|
|
return _renderBold;
|
|
}
|
|
set
|
|
{
|
|
_renderBold = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderItalic"]/*' />
|
|
protected internal bool RenderItalic
|
|
{
|
|
get
|
|
{
|
|
return _renderItalic;
|
|
}
|
|
set
|
|
{
|
|
_renderItalic = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderFontSize"]/*' />
|
|
protected internal bool RenderFontSize
|
|
{
|
|
get
|
|
{
|
|
return _renderFontSize;
|
|
}
|
|
set
|
|
{
|
|
_renderFontSize = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderFontName"]/*' />
|
|
protected internal bool RenderFontName
|
|
{
|
|
get
|
|
{
|
|
return _renderFontName;
|
|
}
|
|
|
|
set
|
|
{
|
|
_renderFontName = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderFontColor"]/*' />
|
|
protected internal bool RenderFontColor
|
|
{
|
|
get
|
|
{
|
|
return _renderFontColor;
|
|
}
|
|
set
|
|
{
|
|
_renderFontColor = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderBodyColor"]/*' />
|
|
protected internal bool RenderBodyColor
|
|
{
|
|
get
|
|
{
|
|
return _renderBodyColor;
|
|
}
|
|
set
|
|
{
|
|
_renderBodyColor = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderDivAlign"]/*' />
|
|
protected internal bool RenderDivAlign
|
|
{
|
|
get
|
|
{
|
|
return _renderDivAlign;
|
|
}
|
|
set
|
|
{
|
|
_renderDivAlign = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RenderDivNoWrap"]/*' />
|
|
protected internal bool RenderDivNoWrap
|
|
{
|
|
get
|
|
{
|
|
return _renderDivNoWrap;
|
|
}
|
|
set
|
|
{
|
|
_renderDivNoWrap = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HtmlMobileTextWriter.uex' path='docs/doc[@for="HtmlMobileTextWriter.RequiresNoBreakInFormatting"]/*' />
|
|
protected internal bool RequiresNoBreakInFormatting
|
|
{
|
|
get
|
|
{
|
|
return _requiresNoBreakInFormatting;
|
|
}
|
|
set
|
|
{
|
|
_requiresNoBreakInFormatting = value;
|
|
}
|
|
}
|
|
|
|
private bool _renderBold = true;
|
|
private bool _renderItalic = true;
|
|
private bool _renderFontSize = true;
|
|
private bool _renderFontName = true;
|
|
private bool _renderFontColor = true;
|
|
private bool _renderBodyColor = true;
|
|
private bool _renderDivAlign = true;
|
|
private bool _renderDivNoWrap = false;
|
|
private bool _requiresNoBreakInFormatting = false;
|
|
}
|
|
|
|
/*
|
|
* the WriterStyle class is used to store and
|
|
* control state for rendering format and layout
|
|
*/
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class WriterStyle
|
|
{
|
|
private Wrapping _wrapping;
|
|
private Alignment _alignment;
|
|
private String _fontName;
|
|
private Color _fontColor;
|
|
private FontSize _fontSize;
|
|
private bool _bold;
|
|
private bool _italic;
|
|
|
|
private bool _format;
|
|
private bool _layout;
|
|
|
|
internal WriterStyle()
|
|
{
|
|
_wrapping = Wrapping.Wrap;
|
|
_alignment = Alignment.Left;
|
|
_fontName = String.Empty;
|
|
_fontColor = Color.Empty;
|
|
_fontSize = FontSize.Normal;
|
|
_bold = false;
|
|
_italic = false;
|
|
|
|
_format = true;
|
|
_layout = true;
|
|
}
|
|
|
|
internal WriterStyle(Style style)
|
|
{
|
|
Debug.Assert(style != null, "writer style is null");
|
|
_alignment = (Alignment) style[Style.AlignmentKey, true];
|
|
if(_alignment == Alignment.NotSet)
|
|
{
|
|
_alignment = Alignment.Left;
|
|
}
|
|
_wrapping = (Wrapping) style[Style.WrappingKey, true];
|
|
if(_wrapping == Wrapping.NotSet)
|
|
{
|
|
_wrapping = Wrapping.Wrap;
|
|
}
|
|
|
|
_fontSize = (FontSize) style[Style.FontSizeKey , true];
|
|
if(_fontSize == FontSize.NotSet)
|
|
{
|
|
_fontSize = FontSize.Normal;
|
|
}
|
|
_fontName = (String) style[Style.FontNameKey , true];
|
|
_fontColor = (Color) style[Style.ForeColorKey, true];
|
|
|
|
_bold = ((BooleanOption) style[Style.BoldKey, true] == BooleanOption.True);
|
|
_italic = ((BooleanOption) style[Style.ItalicKey, true] == BooleanOption.True);
|
|
|
|
_format = true;
|
|
_layout = true;
|
|
|
|
}
|
|
|
|
|
|
internal bool Format
|
|
{
|
|
get { return _format; }
|
|
set { _format = value; }
|
|
}
|
|
|
|
internal bool Layout
|
|
{
|
|
get { return _layout; }
|
|
set { _layout = value; }
|
|
}
|
|
|
|
internal Wrapping Wrapping
|
|
{
|
|
get { return _wrapping; }
|
|
set { _wrapping = value; }
|
|
}
|
|
internal Alignment Alignment
|
|
{
|
|
get { return _alignment; }
|
|
set { _alignment = value; }
|
|
}
|
|
internal String FontName
|
|
{
|
|
get { return _fontName; }
|
|
set { _fontName = value; }
|
|
}
|
|
internal Color FontColor
|
|
{
|
|
get { return _fontColor; }
|
|
set { _fontColor = value; }
|
|
}
|
|
internal FontSize FontSize
|
|
{
|
|
get { return _fontSize; }
|
|
set { _fontSize = value; }
|
|
}
|
|
internal bool Bold
|
|
{
|
|
get { return _bold; }
|
|
set { _bold = value; }
|
|
}
|
|
internal bool Italic
|
|
{
|
|
get { return _italic; }
|
|
set { _italic = value; }
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The StyleTag class is extended for specific tags
|
|
*/
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal abstract class StyleTag
|
|
{
|
|
private int _level = -1;
|
|
|
|
#if UNUSED_CODE
|
|
internal StyleTag()
|
|
{
|
|
}
|
|
#endif
|
|
|
|
internal StyleTag(int level)
|
|
{
|
|
_level = level;
|
|
}
|
|
|
|
internal virtual int Level
|
|
{
|
|
get
|
|
{
|
|
return _level;
|
|
}
|
|
set
|
|
{
|
|
_level = value;
|
|
}
|
|
}
|
|
|
|
internal abstract void CloseTag(WriterState state);
|
|
}
|
|
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class BoldStyleTag : StyleTag
|
|
{
|
|
internal BoldStyleTag(int level) : base(level)
|
|
{
|
|
}
|
|
|
|
internal override void CloseTag(WriterState state)
|
|
{
|
|
state.Writer.WriteEndTag("b");
|
|
state.Current.Bold = false;
|
|
}
|
|
}
|
|
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class ItalicStyleTag : StyleTag
|
|
{
|
|
internal ItalicStyleTag(int level) : base(level)
|
|
{
|
|
}
|
|
|
|
internal override void CloseTag(WriterState state)
|
|
{
|
|
state.Writer.WriteEndTag("i");
|
|
state.Current.Italic = false;
|
|
}
|
|
}
|
|
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class FontStyleTag : StyleTag
|
|
{
|
|
private String _name;
|
|
private Color _color;
|
|
private FontSize _size;
|
|
|
|
internal FontStyleTag(int level) : base(level)
|
|
{
|
|
_name = String.Empty;
|
|
_color = Color.Empty;
|
|
_size = FontSize.Normal;
|
|
}
|
|
|
|
#if UNUSED_CODE
|
|
internal FontStyleTag(int level, String name, Color color, FontSize size) : base(level)
|
|
{
|
|
Name = _name;
|
|
Color = color;
|
|
FontSize = size;
|
|
}
|
|
#endif
|
|
|
|
internal String Name
|
|
{
|
|
get { return _name; }
|
|
set { _name = value; }
|
|
}
|
|
internal Color Color
|
|
{
|
|
get { return _color; }
|
|
set { _color = value; }
|
|
}
|
|
internal FontSize FontSize
|
|
{
|
|
get { return _size; }
|
|
set { _size = value; }
|
|
}
|
|
|
|
internal override void CloseTag(WriterState state)
|
|
{
|
|
state.Writer.WriteEndTag("font");
|
|
//reset FontLevel and rebuild state info
|
|
state.FontLevel = -1;
|
|
state.Current.FontColor = Color.Empty;
|
|
state.Current.FontName = String.Empty;
|
|
state.Current.FontSize = FontSize.Normal;
|
|
|
|
//reset the FontLevel
|
|
Stack tmpStack = new Stack();
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tmpStack.Push(o);
|
|
if(o is FontStyleTag)
|
|
{
|
|
state.FontLevel = ((FontStyleTag)o).Level;
|
|
break;
|
|
}
|
|
}
|
|
|
|
while(tmpStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tmpStack.Pop());
|
|
}
|
|
|
|
//there is a font tag in the stack
|
|
if(state.FontLevel > -1)
|
|
{
|
|
if(Color != Color.Empty)
|
|
{
|
|
//reset font color to something further down the stack
|
|
Stack tempStack = new Stack();
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tempStack.Push(o);
|
|
if(o is FontStyleTag)
|
|
{
|
|
if(((FontStyleTag)o).Color != Color.Empty)
|
|
{
|
|
state.Current.FontColor = ((FontStyleTag)o).Color;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while(tempStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tempStack.Pop());
|
|
}
|
|
}
|
|
if(Name == null || Name.Length > 0)
|
|
{
|
|
//reset font name to something futher down the stack
|
|
Stack tempStack = new Stack();
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tempStack.Push(o);
|
|
if(o is FontStyleTag)
|
|
{
|
|
String name = ((FontStyleTag)o).Name;
|
|
if(name == null || name.Length > 0)
|
|
{
|
|
state.Current.FontName = name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while(tempStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tempStack.Pop());
|
|
}
|
|
}
|
|
//reset font size to something further down the stack
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tmpStack.Push(o);
|
|
if (o is FontStyleTag)
|
|
{
|
|
if(((FontStyleTag)o).FontSize != FontSize.Normal)
|
|
{
|
|
state.Current.FontSize = ((FontStyleTag)o).FontSize;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while(tmpStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tmpStack.Pop());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class DivStyleTag : StyleTag
|
|
{
|
|
private Wrapping _wrapping;
|
|
private Alignment _alignment;
|
|
private bool _alignWritten;
|
|
internal DivStyleTag(int level) : base(level)
|
|
{
|
|
_wrapping = Wrapping.Wrap;
|
|
_alignment = Alignment.Left;
|
|
_alignWritten = false;
|
|
}
|
|
|
|
internal Wrapping Wrapping
|
|
{
|
|
get { return _wrapping; }
|
|
set { _wrapping = value; }
|
|
}
|
|
internal Alignment Alignment
|
|
{
|
|
get { return _alignment; }
|
|
set { _alignment = value; }
|
|
}
|
|
internal bool AlignmentWritten
|
|
{
|
|
get { return _alignWritten; }
|
|
set { _alignWritten = value; }
|
|
}
|
|
|
|
internal override void CloseTag(WriterState state)
|
|
{
|
|
state.Writer.WriteEndTag("div");
|
|
state.BreakPending = false;
|
|
|
|
//reset current div info and rebuild
|
|
state.DivLevel = -1;
|
|
state.Current.Alignment = Alignment.Left;
|
|
state.Current.Wrapping = Wrapping.Wrap;
|
|
Stack tempStack = new Stack();
|
|
//reset alignment : ideally these resets could be combined
|
|
//in practice, the number of items on the stack is small
|
|
//so it may be comparable
|
|
|
|
|
|
//reset wrapping
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tempStack.Push(o);
|
|
if(o is DivStyleTag)
|
|
{
|
|
if(((DivStyleTag)o).Wrapping == Wrapping.NoWrap)
|
|
{
|
|
state.Current.Wrapping = Wrapping.NoWrap;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while(tempStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tempStack.Pop());
|
|
}
|
|
|
|
//reset alignment
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tempStack.Push(o);
|
|
if(o is DivStyleTag)
|
|
{
|
|
if(((DivStyleTag)o).Alignment != Alignment.NotSet)
|
|
{
|
|
state.Current.Alignment = ((DivStyleTag)o).Alignment;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while(tempStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tempStack.Pop());
|
|
}
|
|
|
|
//reset divLevel
|
|
while(state.TagsWritten.Count > 0)
|
|
{
|
|
Object o = state.TagsWritten.Pop();
|
|
tempStack.Push(o);
|
|
if(o is DivStyleTag)
|
|
{
|
|
state.DivLevel = ((DivStyleTag)o).Level;
|
|
break;
|
|
}
|
|
}
|
|
while(tempStack.Count > 0)
|
|
{
|
|
state.TagsWritten.Push(tempStack.Pop());
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* the StyleStack class maintains WriterStyle objects
|
|
* pushed on the stack from Enter[Style/Format/Layout]
|
|
* and removed using Exit[Style/Format/Layout]
|
|
*/
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class StyleStack
|
|
{
|
|
private HtmlMobileTextWriter _writer;
|
|
private Stack _stack;
|
|
|
|
protected StyleStack(HtmlMobileTextWriter writer)
|
|
{
|
|
_writer = writer;
|
|
_stack = new Stack();
|
|
}
|
|
|
|
internal void Push(WriterStyle style)
|
|
{
|
|
_stack.Push(style);
|
|
_writer.ShouldEnsureStyle = true;
|
|
}
|
|
|
|
internal WriterStyle Pop()
|
|
{
|
|
_writer.ShouldEnsureStyle = true;
|
|
return (WriterStyle)_stack.Pop();
|
|
}
|
|
|
|
internal WriterStyle Peek()
|
|
{
|
|
if(_stack.Count == 0)
|
|
{
|
|
return new WriterStyle(); //retrieves default values
|
|
}
|
|
return (WriterStyle)_stack.Peek();
|
|
}
|
|
|
|
internal int Count
|
|
{
|
|
get
|
|
{
|
|
return _stack.Count;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* the WriterState tracks what styles have been entered, what tags have been written
|
|
and controls transitions from the current state to a desired state
|
|
*/
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class WriterState : StyleStack
|
|
{
|
|
private bool _inTransition = false; //prevent recursion
|
|
private Stack _stack; //stack of WriterStyle objects
|
|
private Stack _tagsWritten; //stack of StyleTag objects for written tags
|
|
private bool _breakPending = false; //track if we owe a <br>
|
|
|
|
private WriterStyle _current; //the current style
|
|
private HtmlMobileTextWriter _writer; //the output stream
|
|
|
|
private int _fontLevel = -1;
|
|
private int _divLevel = -1;
|
|
|
|
private int _mark = 0;
|
|
|
|
internal WriterState(HtmlMobileTextWriter writer) : base(writer)
|
|
{
|
|
_writer = writer;
|
|
_stack = new Stack();
|
|
_current = new WriterStyle();
|
|
_tagsWritten = new Stack();
|
|
}
|
|
|
|
internal WriterStyle Current
|
|
{
|
|
get
|
|
{
|
|
return _current;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Pushes the current WriterStyle and tagsWritten stack for later use,
|
|
starts using a new default WriterStyle
|
|
*/
|
|
internal void PushState()
|
|
{
|
|
_writer.ShouldEnsureStyle = true;
|
|
_stack.Push(_current);
|
|
_current = new WriterStyle();
|
|
_stack.Push(_tagsWritten);
|
|
_tagsWritten = new Stack();
|
|
_stack.Push(BreakPending);
|
|
BreakPending = false;
|
|
|
|
}
|
|
|
|
internal int FontLevel
|
|
{
|
|
get { return _fontLevel; }
|
|
set { _fontLevel = value; }
|
|
}
|
|
|
|
internal int DivLevel
|
|
{
|
|
get { return _divLevel; }
|
|
set { _divLevel = value; }
|
|
}
|
|
|
|
/*
|
|
Pops the last WriterStyle pushed and makes it current
|
|
and restores the tagsWritten stack
|
|
*/
|
|
internal WriterStyle PopState()
|
|
{
|
|
_writer.ShouldEnsureStyle = true;
|
|
BreakPending = (bool)_stack.Pop();
|
|
//close all open tags
|
|
while(_tagsWritten.Count > 0)
|
|
{
|
|
CloseTag();
|
|
}
|
|
_tagsWritten = (Stack)_stack.Pop();
|
|
_current = (WriterStyle)_stack.Pop();
|
|
return _current;
|
|
}
|
|
|
|
/*
|
|
BreakPending property accessor
|
|
*/
|
|
internal bool BreakPending
|
|
{
|
|
get { return _breakPending; }
|
|
set { _breakPending = value; }
|
|
}
|
|
|
|
internal HtmlTextWriter Writer
|
|
{
|
|
get
|
|
{
|
|
return _writer;
|
|
}
|
|
}
|
|
|
|
internal Stack TagsWritten
|
|
{
|
|
get
|
|
{
|
|
return _tagsWritten;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
pop a tag from the stack of StyleTags,
|
|
adjust state accordingly
|
|
*/
|
|
internal void CloseTag()
|
|
{
|
|
StyleTag tag = (StyleTag)_tagsWritten.Pop();
|
|
tag.CloseTag(this);
|
|
}
|
|
|
|
internal void MarkStyleContext()
|
|
{
|
|
_mark = _tagsWritten.Count;
|
|
}
|
|
|
|
internal void UnMarkStyleContext()
|
|
{
|
|
while(_tagsWritten.Count > _mark)
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
private bool FontChange(WriterStyle newStyle)
|
|
{
|
|
return (
|
|
(( _current.FontColor != newStyle.FontColor ) && (_writer.RenderFontColor)) ||
|
|
(( _current.FontSize != newStyle.FontSize ) && (_writer.RenderFontSize)) ||
|
|
(( _current.FontName != newStyle.FontName ) && (_writer.RenderFontName))
|
|
);
|
|
}
|
|
|
|
private bool DivChange(WriterStyle newStyle)
|
|
{
|
|
return (
|
|
(newStyle.Layout) &&
|
|
(((newStyle.Wrapping != _current.Wrapping) && (_writer.RenderDivNoWrap)) ||
|
|
((newStyle.Alignment != _current.Alignment) && (_writer.RenderDivAlign)) )
|
|
);
|
|
}
|
|
|
|
internal void Transition(WriterStyle newStyle)
|
|
{
|
|
Transition(newStyle, true);
|
|
}
|
|
|
|
private const String _pocketPC = "Pocket IE";
|
|
|
|
internal void Transition(WriterStyle newStyle, bool captureOutput)
|
|
{
|
|
HtmlMobileTextWriter tempWriter = _writer;
|
|
try
|
|
{
|
|
if(!captureOutput)
|
|
{
|
|
tempWriter = _writer;
|
|
_writer = new HtmlMobileTextWriter(
|
|
new HtmlTextWriter(new StringWriter(CultureInfo.InvariantCulture)), tempWriter.Device);
|
|
}
|
|
|
|
if(_inTransition)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
_inTransition = true;
|
|
}
|
|
|
|
if(Count == 0)
|
|
{
|
|
while(_tagsWritten.Count > 0)
|
|
{
|
|
CloseTag();
|
|
}
|
|
_inTransition= false;
|
|
return;
|
|
}
|
|
|
|
//close italic if target format !italic
|
|
if(( _current.Italic && !newStyle.Italic ) && (_writer.RenderItalic))
|
|
{
|
|
while(_current.Italic)
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
//close bold if target format !bold
|
|
if(( _current.Bold && !newStyle.Bold ) && (_writer.RenderBold))
|
|
{
|
|
while(_current.Bold)
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
//if the target FontColor is Color.Empty, then we need to
|
|
//close all open color tags
|
|
if(
|
|
(newStyle.FontColor == Color.Empty) &&
|
|
(_current.FontColor != Color.Empty) &&
|
|
(_writer.RenderFontColor) )
|
|
{
|
|
while(_current.FontColor != Color.Empty)
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
//if the target FontName is String.Empty, then we need to
|
|
//close all open name tags
|
|
if(
|
|
(newStyle.FontName != null && newStyle.FontName.Length == 0) &&
|
|
(_current.FontName == null || _current.FontName.Length > 0) &&
|
|
(_writer.RenderFontName) )
|
|
{
|
|
while(_current.FontName == null || _current.FontName.Length > 0)
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
//close the font if it is of the same or a later generation
|
|
//and differs
|
|
|
|
bool newFont = FontChange(newStyle);
|
|
|
|
if(newFont)
|
|
{
|
|
while( FontLevel >= Count )
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
//if the new wrapping is Wrap, and the current is NoWrap
|
|
//the outer NoWrap must be removed
|
|
if(
|
|
(newStyle.Wrapping == Wrapping.Wrap) &&
|
|
(_current.Wrapping == Wrapping.NoWrap) &&
|
|
(_writer.RenderDivNoWrap) )
|
|
{
|
|
while(_current.Wrapping != Wrapping.Wrap)
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
//if the alignment differs for the same generation, close any divs at this level
|
|
if(( newStyle.Alignment != _current.Alignment ) && ( _writer.RenderDivAlign))
|
|
{
|
|
while( DivLevel >= Count )
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
//determine if we will be opening a div before writing any break
|
|
bool newDiv = DivChange(newStyle);
|
|
|
|
//an opening div will function as a logical break
|
|
if((BreakPending) && (!(newDiv)))
|
|
{
|
|
((HtmlMobileTextWriter)_writer).WriteBreak();
|
|
BreakPending = false;
|
|
}
|
|
|
|
if(newDiv)
|
|
{
|
|
while(_current.Bold || _current.Italic || (FontLevel == Count))
|
|
{
|
|
CloseTag();
|
|
}
|
|
}
|
|
|
|
newFont = FontChange(newStyle);
|
|
newDiv = DivChange(newStyle);
|
|
|
|
//open div
|
|
if(newDiv && newStyle.Layout)
|
|
{
|
|
DivStyleTag div = new DivStyleTag(Count);
|
|
BreakPending = false;
|
|
if(
|
|
((_writer.BeforeFirstControlWritten) || (_writer.InputWritten)) &&
|
|
(_writer.Device.Type == _pocketPC) &&
|
|
(_writer.Device.MinorVersion == 0) &&
|
|
(_writer.Device.MajorVersion == 4) &&
|
|
(newStyle.Alignment != _current.Alignment) )
|
|
{
|
|
_writer.WriteBreak();
|
|
_writer.InputWritten = false;
|
|
}
|
|
|
|
|
|
_writer.WriteBeginTag("div");
|
|
DivLevel = Count;
|
|
|
|
if(newStyle.Wrapping == Wrapping.NoWrap)
|
|
{
|
|
if(_writer.RenderDivNoWrap)
|
|
{
|
|
_writer.Write(" nowrap");
|
|
}
|
|
div.Wrapping = Wrapping.NoWrap;
|
|
_current.Wrapping = Wrapping.NoWrap;
|
|
}
|
|
else
|
|
{
|
|
div.Wrapping = Wrapping.Wrap;
|
|
_current.Wrapping = Wrapping.Wrap;
|
|
}
|
|
|
|
if(newStyle.Alignment != _current.Alignment)
|
|
{
|
|
if(_writer.RenderDivAlign)
|
|
{
|
|
_writer.WriteAttribute(
|
|
"align",
|
|
Enum.GetName(typeof(Alignment), newStyle.Alignment));
|
|
}
|
|
_current.Alignment = newStyle.Alignment;
|
|
div.Alignment = newStyle.Alignment;
|
|
div.AlignmentWritten = true;
|
|
}
|
|
_tagsWritten.Push(div);
|
|
_writer.Write(">");
|
|
}
|
|
|
|
//open font
|
|
if(newFont && newStyle.Format)
|
|
{
|
|
FontStyleTag fontTag = new FontStyleTag(Count);
|
|
_writer.WriteBeginTag("font");
|
|
if(_current.FontSize != newStyle.FontSize)
|
|
{
|
|
String relativeSize;
|
|
if(newStyle.FontSize == FontSize.Large)
|
|
{
|
|
relativeSize = (
|
|
((HtmlMobileTextWriter)_writer).Device.Type == _pocketPC) ? "+2" : "+1";
|
|
_current.FontSize = FontSize.Large;
|
|
fontTag.FontSize = FontSize.Large;
|
|
}
|
|
else if(newStyle.FontSize == FontSize.Small)
|
|
{
|
|
relativeSize = "-1";
|
|
_current.FontSize = FontSize.Small;
|
|
fontTag.FontSize = FontSize.Small;
|
|
}
|
|
else //(newStyle.FontSize == FontSize.Normal)
|
|
{
|
|
relativeSize = "+0";
|
|
_current.FontSize = FontSize.Normal;
|
|
fontTag.FontSize = FontSize.Normal;
|
|
}
|
|
if(_writer.RenderFontSize)
|
|
{
|
|
_writer.WriteAttribute("size", relativeSize);
|
|
}
|
|
}
|
|
|
|
if(_current.FontColor != newStyle.FontColor)
|
|
{
|
|
if(_writer.RenderFontColor)
|
|
{
|
|
_writer.WriteAttribute(
|
|
"color",
|
|
ColorTranslator.ToHtml(newStyle.FontColor));
|
|
}
|
|
_current.FontColor = newStyle.FontColor;
|
|
fontTag.Color = newStyle.FontColor;
|
|
}
|
|
if(_current.FontName != newStyle.FontName)
|
|
{
|
|
if(_writer.RenderFontName)
|
|
{
|
|
_writer.WriteAttribute("face", newStyle.FontName);
|
|
}
|
|
_current.FontName = newStyle.FontName;
|
|
fontTag.Name = newStyle.FontName;
|
|
}
|
|
_writer.Write(">");
|
|
_tagsWritten.Push(fontTag);
|
|
FontLevel = Count;
|
|
}
|
|
|
|
//open bold
|
|
if(newStyle.Format)
|
|
{
|
|
if( newStyle.Bold && !_current.Bold && _writer.RenderBold )
|
|
{
|
|
_writer.WriteFullBeginTag("b");
|
|
_current.Bold = true;
|
|
_tagsWritten.Push(new BoldStyleTag(Count));
|
|
}
|
|
|
|
//open italic
|
|
if( newStyle.Italic && !_current.Italic && _writer.RenderItalic )
|
|
{
|
|
_writer.WriteFullBeginTag("i");
|
|
_current.Italic = true;
|
|
_tagsWritten.Push(new ItalicStyleTag(Count));
|
|
}
|
|
}
|
|
_inTransition = false;
|
|
}
|
|
finally
|
|
{
|
|
_writer = tempWriter;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|