/// <summary>
/// append the text string \a text to the RenderedString \a rs.
/// </summary>
/// <param name="rs"></param>
/// <param name="text"></param>
private void AppendRenderedText(RenderedString rs, string text)
{
var cpos = 0;
// split the given string into lines based upon the newline character
while (text.Length > cpos)
{
// find next newline
var nlpos = text.IndexOf("\n", cpos);
// calculate length of this substring
var len = ((nlpos != -1) ? nlpos : text.Length) - cpos;
// construct new text component and append it.
var rtc = new RenderedStringTextComponent(text.Substring(cpos, len), d_fontName);
rtc.SetPadding(d_padding);
rtc.SetColours(new ColourRect(d_colours));
rtc.SetVerticalFormatting(d_vertAlignment);
rtc.SetAspectLock(d_aspectLock);
rs.AppendComponent(rtc);
// break line if needed
if (nlpos != -1)
{
rs.AppendLineBreak();
}
// advance current position. +1 to skip the \n char
cpos += len + 1;
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public RenderedString Clone()
{
var rs = new RenderedString();
rs.CloneComponentList(d_components);
rs.CloneTrackInfoList(d_lines);
return(rs);
}
private void HandleWindow(RenderedString rs, string value)
{
var rwc = new RenderedStringWidgetComponent(value);
rwc.SetPadding(d_padding);
rwc.SetVerticalFormatting(d_vertAlignment);
rwc.SetAspectLock(d_aspectLock);
rs.AppendComponent(rwc);
}
/// <summary>
/// helper to set up an appropriate FormattedRenderedString
/// </summary>
/// <param name="window"></param>
/// <param name="renderedString"></param>
protected void SetupStringFormatter(Window window, RenderedString renderedString)
{
var horzFormatting = _horzFormatting.Get(window);
// no formatting change
if (horzFormatting == _lastHorizontalFormatting)
{
_formattedRenderedString.SetRenderedString(renderedString);
return;
}
_lastHorizontalFormatting = horzFormatting;
switch (horzFormatting)
{
case HorizontalTextFormatting.LeftAligned:
_formattedRenderedString = new LeftAlignedRenderedString(renderedString);
break;
case HorizontalTextFormatting.CentreAligned:
_formattedRenderedString = new CentredRenderedString(renderedString);
break;
case HorizontalTextFormatting.RightAligned:
_formattedRenderedString = new RightAlignedRenderedString(renderedString);
break;
case HorizontalTextFormatting.Justified:
_formattedRenderedString = new JustifiedRenderedString(renderedString);
break;
case HorizontalTextFormatting.WordWrapLeftAligned:
_formattedRenderedString =
new RenderedStringWordWrapper <LeftAlignedRenderedString>(renderedString);
//new RenderedStringWordWrapper<LeftAlignedRenderedString>(rendered_string, rs => new LeftAlignedRenderedString(rs));
break;
case HorizontalTextFormatting.WordWrapCentreAligned:
_formattedRenderedString =
new RenderedStringWordWrapper <CentredRenderedString>(renderedString);
//new RenderedStringWordWrapper<CentredRenderedString>(rendered_string, rs => new CentredRenderedString(rs));
break;
case HorizontalTextFormatting.WordWrapRightAligned:
_formattedRenderedString =
new RenderedStringWordWrapper <RightAlignedRenderedString>(renderedString);
//new RenderedStringWordWrapper<RightAlignedRenderedString>(rendered_string, rs => new RightAlignedRenderedString(rs));
break;
case HorizontalTextFormatting.WordWrapJustified:
_formattedRenderedString =
new RenderedStringWordWrapper <JustifiedRenderedString>(renderedString);
//new RenderedStringWordWrapper<JustifiedRenderedString>(rendered_string, rs => new JustifiedRenderedString(rs));
break;
}
}
private void HandleImage(RenderedString rs, string value)
{
var ric = new RenderedStringImageComponent(PropertyHelper.FromString <Image>(value));
ric.SetPadding(d_padding);
ric.SetColours(d_colours);
ric.SetVerticalFormatting(d_vertAlignment);
ric.SetSize(d_imageSize);
ric.SetAspectLock(d_aspectLock);
rs.AppendComponent(ric);
}
// TODO: Destructor.
// TODO: ~RenderedStringWordWrapper(){DeleteFormatters();}
// implementation of base interface
// TODO: specialised version of format used with Justified text
public override void Format(Window refWnd, Sizef areaSize)
{
DeleteFormatters();
var lstring = new RenderedString();
var rstring = new RenderedString(d_renderedString);
T frs;
for (var line = 0; line < rstring.GetLineCount(); ++line)
{
float rsWidth;
while ((rsWidth = rstring.GetPixelSize(refWnd, line).Width) > 0)
{
// skip line if no wrapping occurs
if (rsWidth <= areaSize.Width)
{
break;
}
// split rstring at width into lstring and remaining rstring
rstring.Split(refWnd, line, areaSize.Width, lstring);
//frs = _constructor(new RenderedString(lstring));
frs = new T();
frs.SetRenderedString(new RenderedString(lstring));
frs.Format(refWnd, areaSize);
Lines.Add(frs);
line = 0;
}
}
// last line.
//frs = _constructor(new RenderedString(rstring));
frs = new T();
frs.SetRenderedString(new RenderedString(rstring));
frs.Format(refWnd, areaSize);
Lines.Add(frs);
}
private void HandleVertAlignment(RenderedString rs, string value)
{
if (value == TopAlignedValueName)
{
d_vertAlignment = VerticalFormatting.TopAligned;
}
else if (value == BottomAlignedValueName)
{
d_vertAlignment = VerticalFormatting.BottomAligned;
}
else if (value == CentreAlignedValueName)
{
d_vertAlignment = VerticalFormatting.CentreAligned;
}
else if (value == StretchAlignedValueName)
{
d_vertAlignment = VerticalFormatting.Stretched;
}
else
{
System.GetSingleton().Logger.LogEvent("BasicRenderedStringParser::handleVertAlignment: unknown " +
"vertical alignment '" + value + "'. Ignoring!");
}
}
/// <summary>
/// Process the control string \a ctrl_str.
/// </summary>
/// <param name="rs"></param>
/// <param name="ctrlStr"></param>
private void ProcessControlString(RenderedString rs, string ctrlStr)
{
// all our default strings are of the form <var> = <val>
// so do a quick check for the = char and abort if it's not there.
if (-1 == ctrlStr.IndexOf("="))
{
System.GetSingleton().Logger.LogEvent(
"BasicRenderedStringParser.ProcessControlString: unable to make " +
"sense of control string '" + ctrlStr + "'. Ignoring!");
return;
}
//char var_buf[128];
//char val_buf[128];
//sscanf(ctrl_str.c_str(), " %127[^ =] = '%127[^']", var_buf, val_buf);
//const String var_str(var_buf);
//const String val_str(val_buf);
var values = ctrlStr.Split('=');
var varStr = values[0];
var valStr = values[1].Trim('\'');
// look up handler function and
// despatch handler, or log error
if (_tagHandlers.ContainsKey(varStr))
{
_tagHandlers[varStr](rs, valStr);
}
else
{
System.GetSingleton().Logger.LogEvent("BasicRenderedStringParser::processControlString: unknown " +
"control variable '" + varStr + "'. Ignoring!");
}
}
private void HandleImageHeight(RenderedString rs, string value)
{
d_imageSize.Height = Single.Parse(value);
}
/// <summary>
/// split the string in line \a line as close to \a split_point as possible.
/// <para>
/// The RenderedString \a left will receive the left portion of the split,
/// while the right portion of the split will remain in this RenderedString.
/// </para>
/// </summary>
/// <param name="refWnd"></param>
/// <param name="line">
/// The line number on which the split is to occur.
/// </param>
/// <param name="splitPoint">
/// float value specifying the pixel location where the split should occur.
/// The actual split will occur as close to this point as possible, though
/// preferring a shorter 'left' portion when the split can not be made
/// exactly at the requested point.
/// </param>
/// <param name="left">
/// RenderedString object that will receieve the left portion of the split.
/// Any existing content in the RenderedString is replaced.
/// </param>
/// <exception cref="InvalidRequestException">
/// thrown if \a line is out of range.
/// </exception>
public void Split(Window refWnd, int line, float splitPoint, RenderedString left)
{
// FIXME: This function is big and nasty; it breaks all the rules for a
// 'good' function and desperately needs some refactoring work done to it.
// On the plus side, it does seem to work though ;)
if (line >= GetLineCount())
{
throw new InvalidRequestException("line number specified is invalid.");
}
left.ClearComponents();
if (d_components.Count == 0)
{
return;
}
// move all components in lines prior to the line being split to the left
if (line > 0)
{
// calculate size of range
var sz = d_lines[line - 1].First + d_lines[line - 1].Second;
//// range start
//ComponentList::iterator cb = d_components.begin();
//// range end (exclusive)
//ComponentList::iterator ce = cb + sz;
//// copy components to left side
//left.d_components.assign(cb, ce);
//// erase components from this side.
//d_components.erase(cb, ce);
for (int i = 0; i < sz; i++)
{
left.d_components.Add(d_components[0]);
d_components.RemoveAt(0);
}
//LineList::iterator lb = d_lines.begin();
//LineList::iterator le = lb + line;
//// copy lines to left side
//left.d_lines.assign(lb, le);
//// erase lines from this side
//d_lines.erase(lb, le);
for (int i = 0; i < line; i++)
{
left.d_lines.Add(d_lines[0]);
d_lines.RemoveAt(0);
}
}
// find the component where the requested split point lies.
var partialExtent = 0f;
var idx = 0;
var lastComponent = d_lines[0].Second;
for (; idx < lastComponent; ++idx)
{
partialExtent += d_components[idx].GetPixelSize(refWnd).Width;
if (splitPoint <= partialExtent)
{
break;
}
}
// case where split point is past the end
if (idx >= lastComponent)
{
// transfer this line's components to the 'left' string.
//
// calculate size of range
var sz = d_lines[0].Second;
//// range start
//ComponentList::iterator cb = d_components.begin();
//// range end (exclusive)
//ComponentList::iterator ce = cb + sz;
//// copy components to left side
//left.d_components.insert(left.d_components.end(), cb, ce);
//// erase components from this side.
//d_components.erase(cb, ce);
for (int i = 0; i < sz; i++)
{
left.d_components.Add(d_components[0]);
d_components.RemoveAt(0);
}
// copy line info to left side
left.d_lines.Add(d_lines[0]);
// erase line from this side
d_lines.RemoveAt(0);
// fix up lines in this object
for (int comp = 0, i = 0; i < d_lines.Count; ++i)
{
d_lines[i].First = comp;
comp += d_lines[i].Second;
}
return;
}
left.AppendLineBreak();
var leftLine = left.GetLineCount() - 1;
// Everything up to 'idx' is xfered to 'left'
for (var i = 0; i < idx; ++i)
{
left.d_components.Add(d_components[0]);
d_components.RemoveAt(0);
++left.d_lines[leftLine].Second;
--d_lines[0].Second;
}
// now to split item 'idx' putting half in left and leaving half in this.
RenderedStringComponent c = d_components[0];
if (c.CanSplit())
{
var lc = c.Split(refWnd, splitPoint - (partialExtent - c.GetPixelSize(refWnd).Width), idx == 0);
if (lc != null)
{
left.d_components.Add(lc);
++left.d_lines[leftLine].Second;
}
}
// can't split, if component width is >= split_point xfer the whole
// component to it's own line in the left part (FIX #306)
else if (c.GetPixelSize(refWnd).Width >= splitPoint)
{
left.AppendLineBreak();
left.d_components.Add(d_components[0]);
d_components.RemoveAt(0);
++left.d_lines[leftLine + 1].Second;
--d_lines[0].Second;
}
// fix up lines in this object
for (int comp = 0, i = 0; i < d_lines.Count; ++i)
{
d_lines[i].First = comp;
comp += d_lines[i].Second;
}
}
public RightAlignedRenderedString(RenderedString @string)
: base(@string)
{
}
protected FormattedRenderedString(RenderedString @string)
{
d_renderedString = @string;
}
private void HandlePadding(RenderedString rs, string value)
{
d_padding = PropertyHelper.FromString <Rectf>(value);
}
private void HandleFont(RenderedString rs, string value)
{
d_fontName = value;
}
private void HandleColour(RenderedString rs, string value)
{
d_colours.SetColours(PropertyHelper.FromString <Colour>(value));
}
public LeftAlignedRenderedString(RenderedString @string)
: base(@string)
{
}
/// <summary>
/// set the RenderedString.
/// </summary>
/// <param name="string"></param>
public void SetRenderedString(RenderedString @string)
{
d_renderedString = @string;
}
private void HandleBottomPadding(RenderedString rs, string value)
{
d_padding.d_max.Y = Single.Parse(value);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="string"></param>
public CentredRenderedString(RenderedString @string)
: base(@string)
{
}
private void HandleLeftPadding(RenderedString rs, string value)
{
d_padding.d_min.X = Single.Parse(value);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="string"></param>
/// <param name="constructor"></param>
public RenderedStringWordWrapper(RenderedString @string /*, Func<RenderedString, T> constructor*/)
: base(@string)
{
//_constructor = constructor;
}
private void HandleRightPadding(RenderedString rs, string value)
{
d_padding.d_max.X = Single.Parse(value);
}
private void HandleAspectLock(RenderedString rs, string value)
{
d_aspectLock = Boolean.Parse(value);
}
private void HandleImageSize(RenderedString rs, string value)
{
d_imageSize = PropertyHelper.FromString <Sizef>(value);
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
public RenderedString(RenderedString other)
{
CloneComponentList(other.d_components);
CloneTrackInfoList(other.d_lines);
}
private void HandleImageWidth(RenderedString rs, string value)
{
d_imageSize.Width = Single.Parse(value);
}
public JustifiedRenderedString(RenderedString @string)
: base(@string)
{
}
public RenderedString Parse(string inputString, Font initialFont, ColourRect initialColours)
{
if (inputString == null)
{
inputString = String.Empty;
}
// first-time initialisation (due to issues with static creation order)
if (!d_initialised)
{
InitialiseTagHandlers();
}
InitialiseDefaultState();
// maybe override initial font.
if (initialFont != null)
{
d_fontName = initialFont.GetName();
}
// maybe override initial colours.
if (initialColours != null)
{
d_colours = new ColourRect(initialColours);
}
var rs = new RenderedString();
var currSection = new StringBuilder();
var tagString = new StringBuilder();
for (int inputIter = 0; inputIter < inputString.Length;)
{
var foundTag = ParseSection(inputString, ref inputIter, inputString.Length, '[', currSection);
AppendRenderedText(rs, currSection.ToString());
if (!foundTag)
{
return(rs);
}
if (!ParseSection(inputString, ref inputIter, inputString.Length, ']', tagString))
{
System.GetSingleton().Logger.LogEvent(
"BasicRenderedStringParser.Parse: Ignoring unterminated tag : [" + tagString);
return(rs);
}
ProcessControlString(rs, tagString.ToString());
}
//for (String::const_iterator input_iter(input_string.begin());
// input_iter != input_string.end();
// /* no-op*/)
//{
// const bool found_tag = parse_section(input_iter, input_string.end(), '[', curr_section);
// appendRenderedText(rs, curr_section);
// if (!found_tag)
// return rs;
// if (!parse_section(input_iter, input_string.end(), ']', tag_string))
// {
// Logger::getSingleton().logEvent(
// "BasicRenderedStringParser::parse: Ignoring unterminated tag : [" +
// tag_string);
// return rs;
// }
// processControlString(rs, tag_string);
//}
return(rs);
}
