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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|