X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fvideo%2Ffont.cpp;h=c61ee431ec1df8c1e92f0324093c58d04c0c3251;hb=6f5f82abb84b33fd400c3b82a5e2be2a6cf8ce21;hp=90a319e5b19535920d09cd2dc694c2ec7840f6ea;hpb=df735aa09e4aee204c4004488276df236803f814;p=supertux.git diff --git a/src/video/font.cpp b/src/video/font.cpp index 90a319e5b..c61ee431e 100644 --- a/src/video/font.cpp +++ b/src/video/font.cpp @@ -1,7 +1,7 @@ -// $Id: font.cpp 2298 2005-03-30 12:01:02Z matzebraun $ -// +// $Id$ +// // SuperTux -// Copyright (C) 2004 Tobias Glaesser +// Copyright (C) 2006 Matthias Braun // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License @@ -12,56 +12,33 @@ // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA -// 02111-1307, USA. +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + #include #include #include #include -#include "lisp/parser.h" -#include "lisp/lisp.h" -#include "screen.h" -#include "font.h" -#include "drawing_context.h" +#include "lisp/parser.hpp" +#include "lisp/lisp.hpp" +#include "screen.hpp" +#include "font.hpp" +#include "drawing_context.hpp" +#include "log.hpp" -Font::Font(const std::string& file, FontType ntype, int nw, int nh, - int nshadowsize) - : chars(0), shadow_chars(0), type(ntype), w(nw), h(nh), - shadowsize(nshadowsize) +Font::Font(const std::string& file, const std::string& shadowfile, + int w, int h, int shadowsize) + : chars(0), shadow_chars(0), w(w), h(h), shadowsize(shadowsize) { - chars = new Surface(file, true); - - switch(type) { - case TEXT: - first_char = 32; - break; - case NUM: - first_char = 48; - break; - } - last_char = first_char + (chars->h / h) * 16; - if(last_char > 127 && last_char < 160) // we have left out some control chars at 128-159 - last_char += 32; - - // Load shadow font. - if(shadowsize > 0) { - SDL_Surface* conv = SDL_DisplayFormatAlpha(chars->impl->get_sdl_surface()); - int pixels = conv->w * conv->h; - SDL_LockSurface(conv); - for(int i = 0; i < pixels; ++i) { - Uint32 *p = (Uint32 *)conv->pixels + i; - *p = *p & conv->format->Amask; - } - SDL_UnlockSurface(conv); - SDL_SetAlpha(conv, SDL_SRCALPHA, 128); - shadow_chars = new Surface(conv, true); - SDL_FreeSurface(conv); - } + chars = new Surface(file); + shadow_chars = new Surface(shadowfile); + + first_char = 32; + char_count = ((int) chars->get_height() / h) * 16; } Font::~Font() @@ -88,7 +65,7 @@ Font::get_text_width(const std::string& text) const if(hl == 0) hl = text.size(); - for (uint i = 0; i < text.size(); i++) + for (unsigned int i = 0; i < text.size(); i++) if ((unsigned char) text[i] > 0xC2 && (unsigned char) text[i] < 0xC6) hl--; // control characters are a WASTE. @@ -118,9 +95,37 @@ Font::get_height() const return h; } +std::string +Font::wrap_to_width(const std::string& s, int max_width, std::string* overflow) const +{ + return wrap_to_chars(s, max_width / w, overflow); +} + +std::string +Font::wrap_to_chars(const std::string& s, int line_length, std::string* overflow) +{ + // if text is already smaller, return full text + if ((int)s.length() <= line_length) { + if (overflow) *overflow = ""; + return s; + } + + // if we can find a whitespace character to break at, return text up to this character + int i = line_length; + while ((i > 0) && (s[i] != ' ')) i--; + if (i > 0) { + if (overflow) *overflow = s.substr(i+1); + return s.substr(0, i); + } + + // FIXME: wrap at line_length, taking care of multibyte characters + if (overflow) *overflow = ""; + return s; +} + void Font::draw(const std::string& text, const Vector& pos_, FontAlignment alignment, - uint32_t drawing_effect, uint8_t alpha) const + DrawingEffect drawing_effect, float alpha) const { /* Cut lines changes into seperate strings, needed to support center/right text alignments with break lines. @@ -137,9 +142,12 @@ Font::draw(const std::string& text, const Vector& pos_, FontAlignment alignment, l = text.size(); done = true; } - + + if(l > sizeof(temp)-1) + l = sizeof(temp)-1; + temp[text.copy(temp, l - i, i)] = '\0'; - + // calculate X positions based on the alignment type Vector pos = Vector(pos_); if(alignment == CENTER_ALLIGN) @@ -155,8 +163,8 @@ Font::draw(const std::string& text, const Vector& pos_, FontAlignment alignment, } void -Font::draw_text(const std::string& text, const Vector& pos, - uint32_t drawing_effect, uint8_t alpha) const +Font::draw_text(const std::string& text, const Vector& pos, + DrawingEffect drawing_effect, float alpha) const { if(shadowsize > 0) draw_chars(shadow_chars, text, pos + Vector(shadowsize, shadowsize), @@ -165,58 +173,83 @@ Font::draw_text(const std::string& text, const Vector& pos, draw_chars(chars, text, pos, drawing_effect, alpha); } +namespace { + +/** + * returns true if this byte matches a bitmask of 10xx.xxxx, i.e. it is the 2nd, 3rd or 4th byte of a multibyte utf8 string + */ +bool has_multibyte_mark(unsigned char c) { + return ((c & 0300) == 0200); +} + +/** + * gets unicode character at byte position @a p of UTF-8 encoded @a text, then advances @a p to the next character. + * @throws std::runtime_error if decoding fails. + * See unicode standard section 3.10 table 3-5 and 3-6 for details. + */ +uint32_t decode_utf8(const std::string& text, size_t& p) +{ + uint32_t c1 = (unsigned char) text[p+0]; + + if (has_multibyte_mark(c1)) std::runtime_error("Malformed utf-8 sequence"); + + if ((c1 & 0200) == 0000) { + // 0xxx.xxxx: 1 byte sequence + p+=1; + return c1; + } + else if ((c1 & 0340) == 0300) { + // 110x.xxxx: 2 byte sequence + if(p+1 >= text.size()) throw std::range_error("Malformed utf-8 sequence"); + uint32_t c2 = (unsigned char) text[p+1]; + if (!has_multibyte_mark(c2)) throw std::runtime_error("Malformed utf-8 sequence"); + p+=2; + return (c1 & 0037) << 6 | (c2 & 0077); + } + else if ((c1 & 0360) == 0340) { + // 1110.xxxx: 3 byte sequence + if(p+2 >= text.size()) throw std::range_error("Malformed utf-8 sequence"); + uint32_t c2 = (unsigned char) text[p+1]; + uint32_t c3 = (unsigned char) text[p+2]; + if (!has_multibyte_mark(c2)) throw std::runtime_error("Malformed utf-8 sequence"); + if (!has_multibyte_mark(c3)) throw std::runtime_error("Malformed utf-8 sequence"); + p+=3; + return (c1 & 0017) << 12 | (c2 & 0077) << 6 | (c3 & 0077); + } + else if ((c1 & 0370) == 0360) { + // 1111.0xxx: 4 byte sequence + if(p+3 >= text.size()) throw std::range_error("Malformed utf-8 sequence"); + uint32_t c2 = (unsigned char) text[p+1]; + uint32_t c3 = (unsigned char) text[p+2]; + uint32_t c4 = (unsigned char) text[p+4]; + if (!has_multibyte_mark(c2)) throw std::runtime_error("Malformed utf-8 sequence"); + if (!has_multibyte_mark(c3)) throw std::runtime_error("Malformed utf-8 sequence"); + if (!has_multibyte_mark(c4)) throw std::runtime_error("Malformed utf-8 sequence"); + p+=4; + return (c1 & 0007) << 18 | (c2 & 0077) << 12 | (c3 & 0077) << 6 | (c4 & 0077); + } + throw std::runtime_error("Malformed utf-8 sequence"); +} + +} + void Font::draw_chars(Surface* pchars, const std::string& text, const Vector& pos, - uint32_t drawing_effect, uint8_t alpha) const + DrawingEffect drawing_effect, float alpha) const { - SurfaceImpl* impl = pchars->impl; - int utf8suppl = 0; - Vector p = pos; - for(size_t i = 0; i < text.size(); ++i) { - int c = (unsigned char) text[i]; - int d = 0; - if(c > 127 && c < 160) // correct for the 32 controlchars at 128-159 - c -= 32; - if (c > 0xC2 && text.size() == i+1) // string ends with control char - { - std::cerr << "String \"" << text << "\" is malformed.\n"; - return; + size_t i = 0; + while(i < text.size()) { + uint32_t c; + try { + c = decode_utf8(text, i); } - else - d = (unsigned char) text[i+1]; - - if (c == 0xC3 && d < 160) // first-byte identifier of U0080 ("C1 Control Characters and Latin-1 Supplement") - { // iso-8859-1 equiv character is capital A with tilde above, signified as "C3 83" in utf-8 - utf8suppl = 64; - continue; - } - else if (c == 0xC3 && d >= 160) // U0080 pt. 2 - { - utf8suppl = 32; - continue; + catch (std::runtime_error) { + log_debug << "Malformed utf-8 sequence beginning with " << *((uint32_t*)(text.c_str() + i)) << " found " << std::endl; + c = 0; + i++; } - else if (c == 0xC4 && d < 160) - { - utf8suppl = 128; - continue; - } - else if (c == 0xC4 && d >= 160) - { - utf8suppl = 96; - continue; - } - else if (c == 0xC5 && d < 160) // first-byte identifier of U0100 ("Latin Extended-A") - { // iso-8859-1 equiv character is capital A with ring above, signified as "C3 85" in utf-8 - utf8suppl = 192; - continue; - } - else if (c == 0xC5 && d >= 160) // first-byte identifier of U0100 ("Latin Extended-A") - { // iso-8859-1 equiv character is capital A with ring above, signified as "C3 85" in utf-8 - utf8suppl = 160; - continue; - } - // insert more clauses here once somebody will need them + ssize_t font_index; // a non-printable character? if(c == '\n') { @@ -224,19 +257,30 @@ Font::draw_chars(Surface* pchars, const std::string& text, const Vector& pos, p.y += h + 2; continue; } - if(c == ' ' || c < first_char || c > last_char) { + if(c == ' ') { p.x += w; continue; } - c += utf8suppl; - utf8suppl = 0; - - int index = c - first_char; - int source_x = (index % 16) * w; - int source_y = (index / 16) * h; + font_index = c - first_char; + // we don't have the control chars 0x80-0xa0 in the font + if(c >= 0x80) { + font_index -= 32; + if(c <= 0xa0) { + log_debug << "Unsupported utf-8 character '" << c << "' found" << std::endl; + font_index = 0; + } + } + + if(font_index < 0 || font_index >= (ssize_t) char_count) { + log_debug << "Unsupported utf-8 character found" << std::endl; + font_index = 0; + } - impl->draw_part(source_x, source_y, p.x, p.y, w, h, alpha, drawing_effect); + int source_x = (font_index % 16) * w; + int source_y = (font_index / 16) * h; + pchars->draw_part(source_x, source_y, p.x, p.y, w, h, alpha, + drawing_effect); p.x += w; } }