Files
mono/mcs/class/System.Web.Mobile/System.Web.UI.MobileControls.Adapters/WriterState.cs
T
Gaurav Vaish 157ce6cced 2003-09-29 Gaurav Vaish <gvaish_mono AT lycos.com>
* HtmlMobileTextWriter.cs
                        : Added several Style related methods,
                          and also some Write methods.
* MobileTextWriter.cs   : Device { get; }          - Implemented
* StyleStack.cs, WriterState.cs, WriterStyle.cs, StyleTag.cs
                        : (Private / Internal) Helper classes.

svn path=/trunk/mcs/; revision=18402
2003-09-29 17:45:34 +00:00

283 lines
5.3 KiB
C#

/**
* Project : Mono
* Namespace : System.Web.UI.MobileControls.Adapters
* Class : WriterState
* Author : Gaurav Vaish
*
* Copyright : 2003 with Gaurav Vaish, and with
* Ximian Inc
*/
using System;
using System.IO;
using System.Collections;
using System.Drawing;
using System.Web.Mobile;
namespace System.Web.UI.MobileControls.Adapters
{
class WriterState : StyleStack
{
// stack of tagswritten and writerstyles
private Stack stack = new Stack();
private Stack tagsWritten = new Stack();
private WriterStyle current = new WriterStyle();
private HtmlMobileTextWriter writer;
private bool isInTransition = false;
private bool isBreakPending = false;
private int fontLevel = -1;
private int divLevel = -1;
private int mark = 0;
public WriterState(HtmlMobileTextWriter writer) : base(writer)
{
this.writer = writer;
}
public bool IsBreakPending
{
get
{
return this.isBreakPending;
}
set
{
this.isBreakPending = value;
}
}
public int FontLevel
{
get
{
return this.fontLevel;
}
set
{
this.fontLevel = value;
}
}
public int DivLevel
{
get
{
return this.divLevel;
}
set
{
this.divLevel = value;
}
}
public WriterStyle Current
{
get
{
return this.current;
}
}
// The tags that have been written.
public Stack TagsWritten
{
get
{
return this.tagsWritten;
}
}
public HtmlTextWriter Writer
{
get
{
return this.writer;
}
}
public void MarkStyleContext()
{
this.mark = this.tagsWritten.Count;
}
public void UnmarkStyleContext()
{
while(tagsWritten.Count > mark)
CloseTag();
}
public WriterStyle PopState()
{
writer.ShouldEnsureStyle = true;
IsBreakPending = (bool) stack.Pop();
while(tagsWritten.Count > 0)
CloseTag();
tagsWritten = (Stack)stack.Pop();
current = (WriterStyle)stack.Pop();
return current;
}
public void PushState()
{
writer.ShouldEnsureStyle = true;
stack.Push(current);
stack.Push(tagsWritten);
stack.Push(IsBreakPending);
current = new WriterStyle();
tagsWritten = new Stack();
IsBreakPending = false;
}
public void CloseTag()
{
StyleTag tag = tagsWritten.Pop() as StyleTag;
if(tag != null)
tag.CloseTag(this);
}
public void Transition(WriterStyle style)
{
Transition(style, true);
}
[MonoTODO]
public void Transition(WriterStyle style, bool captureOutput)
{
HtmlMobileTextWriter tempWriter = this.writer;
try
{
if(!captureOutput && !isInTransition)
{
this.writer = new HtmlMobileTextWriter(
new HtmlTextWriter(
new StringWriter()),
tempWriter.Device);
isInTransition = true;
if(Count > 0)
{
while(Count > 0)
{
CloseTag();
}
isInTransition = false;
} else
{
if(current.Italic && writer.RenderItalic)
{
while(current.Italic)
{
CloseTag();
}
}
if(current.Bold && writer.RenderBold)
{
while(current.Bold)
{
CloseTag();
}
}
if(current.FontColor != Color.Empty && writer.RenderFontColor)
{
while(current.FontColor != Color.Empty)
{
CloseTag();
}
}
if(current.FontName != String.Empty && writer.RenderFontName)
{
while(current.FontName != String.Empty)
{
CloseTag();
}
}
if(FontChange(style))
{
while(FontLevel > Count)
{
CloseTag();
}
}
if(current.Wrapping == Wrapping.NoWrap && writer.RenderDivNoWrap)
{
while(current.Wrapping == Wrapping.NoWrap)
{
CloseTag();
}
}
if(current.Alignment != Alignment.NotSet && writer.RenderDivAlign)
{
while(DivLevel > Count)
{
CloseTag();
}
}
bool dc = DivChange(style);
if(IsBreakPending && !dc)
{
writer.WriteBreak();
IsBreakPending = false;
}
if(dc)
{
while(FontLevel > Count)
{
if(current.Bold || current.Italic)
CloseTag();
}
}
bool fc = FontChange(style);
dc = DivChange(style);
if(dc)
{
throw new NotImplementedException();
//DivStyleTag
// Actually Render
}
if(fc)
{
throw new NotImplementedException();
// Actually Render
}
// Push Bold, Italic etc in current Stack
isInTransition = false;
throw new NotImplementedException();
}
}
} finally
{
this.writer = tempWriter;
}
}
private bool DivChange(WriterStyle newStyle)
{
bool retVal = false;
if(newStyle.Layout)
{
if((current.Wrapping != newStyle.Wrapping
&& writer.RenderDivNoWrap) ||
(current.Alignment != newStyle.Alignment
&& writer.RenderDivAlign))
retVal = true;
}
return retVal;
}
private bool FontChange(WriterStyle newStyle)
{
bool retVal = false;
if( (current.FontColor != newStyle.FontColor
&& writer.RenderFontColor) ||
(current.FontSize != newStyle.FontSize
&& writer.RenderFontSize) ||
(current.FontName != newStyle.FontName
&& writer.RenderFontName))
retVal = true;
return retVal;
}
}
}