X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fvideo%2Ffont.cpp;h=5e844df008f83a5751d815fca0b8a8ccc4aca5e4;hb=6b50afc6cdd8d3555901b02ce12f15b5bac32aa8;hp=72c2ff43132744ca48a89003de6df8036475808f;hpb=5b7f9214cb929399f1a855ef5807018a9447d510;p=supertux.git diff --git a/src/video/font.cpp b/src/video/font.cpp index 72c2ff431..5e844df00 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,11 +12,11 @@ // 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 @@ -28,38 +28,17 @@ #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); + chars = new Surface(file); + shadow_chars = new Surface(shadowfile); - switch(type) { - case TEXT: - first_char = 32; - break; - case NUM: - first_char = 48; - break; - } - char_count = (chars->h / h) * 16; - - // 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); - } + first_char = 32; + char_count = ((int) chars->get_height() / h) * 16; } Font::~Font() @@ -86,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. @@ -116,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. @@ -135,6 +142,9 @@ 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'; @@ -154,7 +164,7 @@ 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 + DrawingEffect drawing_effect, float alpha) const { if(shadowsize > 0) draw_chars(shadow_chars, text, pos + Vector(shadowsize, shadowsize), @@ -163,59 +173,82 @@ Font::draw_text(const std::string& text, const Vector& pos, draw_chars(chars, text, pos, drawing_effect, alpha); } -/** decoding of a byte stream to a single unicode character. - * This should be correct for well formed utf-8 sequences but doesn't check for - * all forms of illegal sequences. - * (see unicode standard section 3.10 table 3-5 and 3-6 for details) +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) { - // 1 byte sequence - uint32_t c = (unsigned char) text[p++]; - if(c <= 0x7F) { - return c; - } - - // 2 byte sequence - if(p >= text.size()) - throw std::runtime_error("Malformed utf-8 sequence"); - uint32_t c2 = (unsigned char) text[p++]; - if(c <= 0xDF) { - if(c < 0xC2) - throw std::runtime_error("Malformed utf-8 sequence"); - return (c & 0x1F) << 6 | (c2 & 0x3F); + 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); } - - // 3 byte sequence - if(p >= text.size()) - throw std::runtime_error("Malformed utf-8 sequence"); - uint32_t c3 = (unsigned char) text[p++]; - if(c <= 0xEF) { - return (c & 0x0F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F); + 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); } - - // 4 byte sequence - if(p >= text.size()) - throw std::runtime_error("Malformed utf-8 sequence"); - uint32_t c4 = (unsigned char) text[p++]; - if(c <= 0xF4) { - return (c & 0x07) << 18 | (c2 & 0x3F) << 12 | (c3 & 0x3F) << 6 - | (c4 & 0x3F); + 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; - Vector p = pos; size_t i = 0; while(i < text.size()) { - uint32_t c = decode_utf8(text, i); + uint32_t c; + try { + c = decode_utf8(text, i); + } + catch (std::runtime_error) { + log_debug << "Malformed utf-8 sequence beginning with " << *((uint32_t*)(text.c_str() + i)) << " found " << std::endl; + c = 0; + i++; + } ssize_t font_index; // a non-printable character? @@ -234,23 +267,20 @@ Font::draw_chars(Surface* pchars, const std::string& text, const Vector& pos, if(c >= 0x80) { font_index -= 32; if(c <= 0xa0) { -#ifdef DEBUG - std::cout << "Unsupported utf-8 character '" << c << "' found\n"; -#endif + log_debug << "Unsupported utf-8 character '" << c << "' found" << std::endl; font_index = 0; } } if(font_index < 0 || font_index >= (ssize_t) char_count) { -#ifdef DEBUG - std::cout << "Unsupported utf-8 character found\n"; -#endif + log_debug << "Unsupported utf-8 character found" << std::endl; font_index = 0; } int source_x = (font_index % 16) * w; int source_y = (font_index / 16) * h; - impl->draw_part(source_x, source_y, p.x, p.y, w, h, alpha, drawing_effect); + pchars->draw_part(source_x, source_y, p.x, p.y, w, h, alpha, + drawing_effect); p.x += w; } }