std::string del_tags(const std::string& text){
std::vector<std::string> lines = utils::split(text, '\n', 0);
std::vector<std::string>::iterator line;
for(line = lines.begin(); line != lines.end(); ++line) {
std::string::const_iterator i1 = line->begin(),
i2 = line->end();
*line = std::string(parse_markup(i1,i2,NULL,NULL,NULL),i2);
}
return utils::join(lines, "\n");
}
std::string del_tags(const std::string& text){
int ignore_int;
SDL_Color ignore_color;
std::vector<std::string> lines = utils::split(text, '\n', 0);
std::vector<std::string>::iterator line;
for(line = lines.begin(); line != lines.end(); ++line) {
std::string::const_iterator i1 = line->begin(),
i2 = line->end();
*line = std::string(parse_markup(i1,i2,&ignore_int,&ignore_color,&ignore_int),i2);
}
return utils::join(lines, '\n');
}
SDL_Rect draw_text(surface dst, const SDL_Rect& area, int size,
const SDL_Color& color, const std::string& txt,
int x, int y, bool use_tooltips, int style)
{
// Make sure there's always at least a space,
// so we can ensure that we can return a rectangle for height
static const std::string blank_text(" ");
const std::string& text = txt.empty() ? blank_text : txt;
SDL_Rect res;
res.x = x;
res.y = y;
res.w = 0;
res.h = 0;
std::string::const_iterator i1 = text.begin();
std::string::const_iterator i2 = std::find(i1,text.end(),'\n');
for(;;) {
SDL_Color col = color;
int sz = size;
int text_style = style;
i1 = parse_markup(i1,i2,&sz,&col,&text_style);
if(i1 != i2) {
std::string new_string = utils::unescape(std::string(i1, i2));
const SDL_Rect rect = draw_text_line(dst, area, sz, col, new_string, x, y, use_tooltips, text_style);
if(rect.w > res.w) {
res.w = rect.w;
}
res.h += rect.h;
y += rect.h;
}
if(i2 == text.end()) {
break;
}
i1 = i2+1;
i2 = std::find(i1,text.end(),'\n');
}
return res;
}
static surface render_text(const std::string& text, int fontsize, const SDL_Color& colour, int style, bool use_markup)
{
// we keep blank lines and spaces (may be wanted for indentation)
const std::vector<std::string> lines = utils::split(text, '\n', 0);
std::vector<std::vector<surface> > surfaces;
surfaces.reserve(lines.size());
size_t width = 0, height = 0;
for(std::vector< std::string >::const_iterator ln = lines.begin(), ln_end = lines.end(); ln != ln_end; ++ln) {
int sz = fontsize;
int text_style = style;
std::string::const_iterator after_markup = use_markup ?
parse_markup(ln->begin(), ln->end(), &sz, NULL, &text_style) : ln->begin();
text_surface txt_surf(sz, colour, text_style);
if (after_markup == ln->end() && (ln+1 != ln_end || lines.begin()+1 == ln_end)) {
// we replace empty line by a space (to have a line height)
// except for the last line if we have several
txt_surf.set_text(" ");
} else if (after_markup == ln->begin()) {
// simple case, no markup to skip
txt_surf.set_text(*ln);
} else {
const std::string line(after_markup,ln->end());
txt_surf.set_text(line);
}
const text_surface& cached_surf = text_cache::find(txt_surf);
const std::vector<surface>&res = cached_surf.get_surfaces();
if (!res.empty()) {
surfaces.push_back(res);
width = std::max<size_t>(cached_surf.width(), width);
height += cached_surf.height();
}
}
if (surfaces.empty()) {
return surface();
} else if (surfaces.size() == 1 && surfaces.front().size() == 1) {
surface surf = surfaces.front().front();
SDL_SetAlpha(surf, SDL_SRCALPHA | SDL_RLEACCEL, SDL_ALPHA_OPAQUE);
return surf;
} else {
surface res(create_compatible_surface(surfaces.front().front(),width,height));
if (res.null())
return res;
size_t ypos = 0;
for(std::vector< std::vector<surface> >::const_iterator i = surfaces.begin(),
i_end = surfaces.end(); i != i_end; ++i) {
size_t xpos = 0;
size_t height = 0;
for(std::vector<surface>::const_iterator j = i->begin(),
j_end = i->end(); j != j_end; ++j) {
SDL_SetAlpha(*j, 0, 0); // direct blit without alpha blending
SDL_Rect dstrect = {xpos, ypos, 0, 0};
SDL_BlitSurface(*j, NULL, res, &dstrect);
xpos += (*j)->w;
height = std::max<size_t>((*j)->h, height);
}
ypos += height;
}
return res;
}
}
std::string word_wrap_text(const std::string& unwrapped_text, int font_size,
int max_width, int max_height, int max_lines, bool partial_line)
{
VALIDATE(max_width > 0, _("The maximum text width is less than 1."));
utf8::iterator ch(unwrapped_text);
std::string current_word;
std::string current_line;
size_t line_width = 0;
size_t current_height = 0;
bool line_break = false;
bool first = true;
bool start_of_line = true;
std::string wrapped_text;
std::string format_string;
SDL_Color color;
int font_sz = font_size;
int style = TTF_STYLE_NORMAL;
utf8::iterator end = utf8::iterator::end(unwrapped_text);
while(1) {
if(start_of_line) {
line_width = 0;
format_string.clear();
while(ch != end && *ch < static_cast<ucs4::char_t>(0x100)
&& is_format_char(*ch) && !ch.next_is_end()) {
format_string.append(ch.substr().first, ch.substr().second);
++ch;
}
// We need to parse the special format characters
// to give the proper font_size and style to line_size()
font_sz = font_size;
style = TTF_STYLE_NORMAL;
parse_markup(format_string.begin(),format_string.end(),&font_sz,&color,&style);
current_line.clear();
start_of_line = false;
}
// If there is no current word, get one
if(current_word.empty() && ch == end) {
break;
} else if(current_word.empty()) {
if(*ch == ' ' || *ch == '\n') {
current_word = *ch;
++ch;
} else {
ucs4::char_t previous = 0;
for(;ch != utf8::iterator::end(unwrapped_text) &&
*ch != ' ' && *ch != '\n'; ++ch) {
if(!current_word.empty() &&
break_before(*ch) &&
!no_break_after(previous))
break;
if(!current_word.empty() &&
break_after(previous) &&
!no_break_before(*ch))
break;
current_word.append(ch.substr().first, ch.substr().second);
previous = *ch;
}
}
}
if(current_word == "\n") {
line_break = true;
current_word.clear();
start_of_line = true;
} else {
const size_t word_width = line_size(current_word, font_sz, style).w;
line_width += word_width;
if(static_cast<long>(line_width) > max_width) {
if (!partial_line && static_cast<long>(word_width) > max_width) {
cut_word(current_line,
current_word, font_sz, style, max_width);
}
if(current_word == " ")
current_word = "";
line_break = true;
} else {
current_line += current_word;
current_word = "";
}
}
if(line_break || (current_word.empty() && ch == end)) {
SDL_Rect size = line_size(current_line, font_sz, style);
if(max_height > 0 && current_height + size.h >= size_t(max_height)) {
return wrapped_text;
}
if(!first) {
wrapped_text += '\n';
}
wrapped_text += format_string + current_line;
current_line.clear();
line_width = 0;
current_height += size.h;
line_break = false;
first = false;
if(--max_lines == 0) {
return wrapped_text;
}
}
}
return wrapped_text;
}
