//----------------------------------------------------------------------------//
void BasicRenderedStringParser::appendRenderedText(RenderedString& rs,
const String& text) const
{
size_t cpos = 0;
// split the given string into lines based upon the newline character
while (text.length() > cpos)
{
// find next newline
const size_t nlpos = text.find('\n', cpos);
// calculate length of this substring
const size_t len =
((nlpos != String::npos) ? nlpos : text.length()) - cpos;
// construct new text component and append it.
RenderedStringTextComponent rtc(text.substr(cpos, len), d_fontName);
rtc.setPadding(d_padding);
rtc.setColours(d_colours);
rtc.setVerticalFormatting(d_vertAlignment);
rtc.setAspectLock(d_aspectLock);
rs.appendComponent(rtc);
// break line if needed
if (nlpos != String::npos)
rs.appendLineBreak();
// advance current position. +1 to skip the \n char
cpos += len + 1;
}
}
//----------------------------------------------------------------------------//
RenderedString DefaultRenderedStringParser::parse(
const String& input_string,
const Font* initial_font,
const ColourRect* initial_colours)
{
RenderedString rs;
size_t epos, spos = 0;
while ((epos = input_string.find('\n', spos)) != String::npos)
{
appendSubstring(rs, input_string.substr(spos, epos - spos),
initial_font, initial_colours);
rs.appendLineBreak();
// set new start position (skipping the previous \n we found)
spos = epos + 1;
}
if (spos < input_string.length())
appendSubstring(rs, input_string.substr(spos),
initial_font, initial_colours);
return rs;
}
//----------------------------------------------------------------------------//
RenderedString DefaultRenderedStringParser::parse(
const String& input_string,
Font* initial_font,
const ColourRect* initial_colours)
{
RenderedString rs;
RenderedStringTextComponent rstc(input_string, initial_font);
if (initial_colours)
rstc.setColours(*initial_colours);
rs.appendComponent(rstc);
return rs;
}
//----------------------------------------------------------------------------//
void BasicRenderedStringParser::handleWindow(RenderedString& rs, const String& value)
{
RenderedStringWidgetComponent rwc(value);
rwc.setPadding(d_padding);
rwc.setVerticalFormatting(d_vertAlignment);
rwc.setAspectLock(d_aspectLock);
rs.appendComponent(rwc);
}
//----------------------------------------------------------------------------//
void BasicRenderedStringParser::handleImage(RenderedString& rs, const String& value)
{
RenderedStringImageComponent ric(
PropertyHelper<Image*>::fromString(value));
ric.setPadding(d_padding);
ric.setColours(d_colours);
ric.setVerticalFormatting(d_vertAlignment);
ric.setSize(d_imageSize);
ric.setAspectLock(d_aspectLock);
rs.appendComponent(ric);
}
//----------------------------------------------------------------------------//
void appendSubstring(RenderedString& rs,
const String& string,
const Font* initial_font,
const ColourRect* initial_colours)
{
RenderedStringTextComponent rstc(string, initial_font);
if (initial_colours)
rstc.setColours(*initial_colours);
rs.appendComponent(rstc);
}
//----------------------------------------------------------------------------//
void RenderedString::split(const size_t line, float split_point,
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())
CEGUI_THROW(InvalidRequestException("RenderedString::split: "
"line number specified is invalid."));
left.clearComponents();
if (d_components.empty())
return;
// move all components in lines prior to the line being split to the left
if (line > 0)
{
// calculate size of range
const size_t 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);
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);
}
// find the component where the requested split point lies.
float partial_extent = 0;
size_t idx = 0;
const size_t last_component = d_lines[0].second;
for (; idx < last_component; ++idx)
{
partial_extent += d_components[idx]->getPixelSize().d_width;
if (split_point <= partial_extent)
break;
}
// case where split point is past the end
if (idx >= last_component)
{
// transfer this line's components to the 'left' string.
//
// calculate size of range
const size_t 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);
// copy line info to left side
left.d_lines.push_back(d_lines[0]);
// erase line from this side
d_lines.erase(d_lines.begin());
// fix up lines in this object
for (size_t comp = 0, i = 0; i < d_lines.size(); ++i)
{
d_lines[i].first = comp;
comp += d_lines[i].second;
}
return;
}
left.appendLineBreak();
const size_t left_line = left.getLineCount() - 1;
// Everything up to 'idx' is xfered to 'left'
for (size_t i = 0; i < idx; ++i)
{
left.d_components.push_back(d_components[0]);
d_components.erase(d_components.begin());
++left.d_lines[left_line].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())
{
RenderedStringComponent* lc =
c->split(split_point - (partial_extent - c->getPixelSize().d_width),
idx == 0);
if (lc)
{
left.d_components.push_back(lc);
++left.d_lines[left_line].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().d_width >= split_point)
{
left.appendLineBreak();
left.d_components.push_back(d_components[0]);
d_components.erase(d_components.begin());
++left.d_lines[left_line + 1].second;
--d_lines[0].second;
}
// fix up lines in this object
for (size_t comp = 0, i = 0; i < d_lines.size(); ++i)
{
d_lines[i].first = comp;
comp += d_lines[i].second;
}
}
