We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

The fixed TTF_RenderUTF8_Blended_Wrapped() function

file_2492.txt (text/plain), 9.49 KB, created by George Wu on 2014-04-12 06:29:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: George Wu

Created: 2014-04-12 06:29:24 UTC

Size: 9.49 KB

patch

obsolete

>// utilGetGlyphWidth(Uint16 ch, TTF_Font *font, c_glyph *glyph);
>
>SDL_Surface *TTF_RenderUTF8_Blended_Wrapped(TTF_Font *font,
>                                    const char *text, SDL_Color fg, Uint32 wrapLength)
>{
>    SDL_bool first;
>    int xstart;
>    int width, height;
>    SDL_Surface *textbuf;
>    Uint32 alpha;
>    Uint32 pixel;
>    Uint8 *src;
>    Uint32 *dst;
>    Uint32 *dst_check;
>    int row, col;
>    c_glyph *glyph;
>    FT_Error error;
>    FT_Long use_kerning;
>    FT_UInt prev_index = 0;
>    const int lineSpace = 2;
>    int line, numLines, rowSize;
>    char *str, **strLines;
>    size_t textlen;
>
>    TTF_CHECKPOINTER(text, NULL);
>
>    /* Get the dimensions of the text surface */
>    if ( (TTF_SizeUTF8(font, text, &width, &height) < 0) || !width ) {
>        TTF_SetError("Text has zero width");
>        return(NULL);
>    }
>
>    numLines = 1;
>    str = NULL;
>    strLines = NULL;
>    if ( wrapLength > 0 && *text ) {
>        const char *wrapDelims = " \t\r\n";
>        int w, h;
>        int line = 0;
>        char *spot, *tok, *next_tok, *end;
>        char delim;
>        size_t str_len = SDL_strlen(text);
>		Uint16 ch, lastCh = 0;
>		// Width of current lexeme
>		int curw = 0;
>		char *lastDelimPos;
>		
>		str = text;
>		lastDelimPos = str;
>        numLines = 0;
>		width = 0;
>		w = 0;
>		strLines = (char **)SDL_realloc(strLines, (numLines + 1) * sizeof(char *));
>		strLines[numLines++] = str;
>
>		while (str_len > 0 && (ch = UTF8_getch(&str, &str_len)))
>		{
>			error = Find_Glyph(font, ch, CACHED_METRICS | CACHED_PIXMAP);
>			if (error)
>			{
>				TTF_SetFTError("Couldn't find glyph", error);
>				return NULL;
>			}
>
>			glyph = font->current;
>
>
>			// This is weird...
>			// Since SDL does not support character greater than 0xdf (see UTF8_getch()),
>			// all the characters we draw are in the two-bytes area.
>			// However, my experiments shows that characters greater than 0x7f always has
>			// a length of three bytes.
>			if (IS_CHAR_MULTIBYTE(ch))
>			{
>				lastDelimPos = str - 3;
>				//w += glyph->advance;
>				//curw = glyph->advance;
>				w += utilGetGlyphWidth(ch, font, glyph);
>				curw += utilGetGlyphWidth(ch, font, glyph);
>				if (w > wrapLength)
>				{
>					if (lastDelimPos == text)
>					{
>						// ERROR: Font size too large
>						// Fixme: When font size is too large, the right way to solve it is
>						// extend width and outputs only part of the surface
>						TTF_SetError("Font size to large");
>						return NULL;
>					}
>					else
>					{
>						// Fall back
>						//w -= glyph->advance + glyph->minx;
>						w -= utilGetGlyphWidth(ch, font, glyph);
>						str = lastDelimPos;
>						width = w > width ? w : width;
>						w = 0;
>						strLines = (char **)SDL_realloc(strLines, (numLines + 1) * sizeof(char *));
>						strLines[numLines++] = str;
>					}
>				}
>				else
>				{
>					width = w > width ? w : width;
>				}
>			}
>			else
>			{
>				if (CharacterIsDelimiter((char)ch, wrapDelims))
>				{
>					//w += glyph->advance;
>					w += utilGetGlyphWidth(ch, font, glyph);
>					lastDelimPos = str;
>					curw = 0;
>				}
>				else
>				{
>					//w += glyph->advance;
>					w += utilGetGlyphWidth(ch, font, glyph);
>					if (w > wrapLength)
>					{
>						// For example:
>						// Thisisalonglonglongstring
>						// *************************
>						// Correct layout:
>						// -----------
>						// Thisisalong
>						// longlongstr
>						// ing
>						//w -= glyph->advance;
>						w -= utilGetGlyphWidth(ch, font, glyph);
>						width = w > width ? w : width;
>						w = 0;
>						//if (curw + glyph->advance > wrapLength)
>						if (curw + utilGetGlyphWidth(ch, font, glyph) > wrapLength)
>						{
>							// Force line change
>							str -= 1;
>							lastDelimPos = str;
>							strLines = (char **)SDL_realloc(strLines, (numLines + 1) * sizeof(char *));
>							strLines[numLines++] = str;
>						}
>						else
>						{
>							// Break at lastDelimPos
>							if (lastDelimPos == text)
>							{
>								// ERROR: Font size too large
>								// Fixme: When font size is too large, the right way to solve it is
>								// extend width and outputs only part of the surface
>								TTF_SetError("Font size too large");
>								return NULL;
>							}
>							else
>							{
>								str = lastDelimPos;
>								strLines = (char **)SDL_realloc(strLines, (numLines + 1) * sizeof(char *));
>								strLines[numLines++] = str;
>							}
>						}
>						curw = 0;
>					}
>					else
>					{
>						//curw += glyph->advance;
>						curw += utilGetGlyphWidth(ch, font, glyph);
>						width = w > width ? w : width;
>					}
>				}
>			}
>
>			str_len = SDL_strlen(str);
>		}
>    }
>
>	if (width <= 0) width = 1;
>
>    /* Create the target surface */
>    textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE,
>            (numLines > 1) ? wrapLength : width,
>            height * numLines + (lineSpace * (numLines - 1)),
>            32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
>    if ( textbuf == NULL ) {
>        if ( strLines ) {
>            SDL_free(strLines);
>			// Since in the new version, str is only a clone of text,
>			// there is no need to free it anymore.
>            //SDL_stack_free(str);
>        }
>        return(NULL);
>    }
>
>    rowSize = textbuf->pitch/4 * height;
>
>    /* Adding bound checking to avoid all kinds of memory corruption errors
>     that may occur. */
>    dst_check = (Uint32*)textbuf->pixels + textbuf->pitch/4 * textbuf->h;
>
>    /* check kerning */
>    use_kerning = FT_HAS_KERNING( font->face ) && font->kerning;
>
>    /* Load and render each character */
>    pixel = (fg.r<<16)|(fg.g<<8)|fg.b;
>    SDL_FillRect(textbuf, NULL, pixel); /* Initialize with fg and 0 alpha */
>
>	if ( strLines )
>    for ( line = 0; line < numLines; line++ ) {
>        if ( strLines ) {
>            text = strLines[line];
>        }
>        textlen = SDL_strlen(text);
>        first = SDL_TRUE;
>        xstart = 0;
>        while ( textlen > 0 ) {
>            Uint16 c = UTF8_getch(&text, &textlen);
>            if ( c == UNICODE_BOM_NATIVE || c == UNICODE_BOM_SWAPPED ) {
>                continue;
>            }
>			// We need to check if the character we are drawing is the start of next line.
>			// If so, we have to move to the next line to avoid re-rendering rest of current
>			// line.
>			if (IS_CHAR_MULTIBYTE(c))
>			{
>				if (line < numLines - 1 && text - 3 == strLines[line + 1])
>				{
>					text -= 3;
>					break;
>				}
>			}
>			else
>			{
>				if (line < numLines - 1 && text - 1 == strLines[line + 1])
>				{
>					text -= 1;
>					break;
>				}
>			}
>
>            error = Find_Glyph(font, c, CACHED_METRICS|CACHED_PIXMAP);
>            if ( error ) {
>                TTF_SetFTError("Couldn't find glyph", error);
>                SDL_FreeSurface( textbuf );
>                return NULL;
>            }
>            glyph = font->current;
>            /* Ensure the width of the pixmap is correct. On some cases,
>             * freetype may report a larger pixmap than possible.*/
>            width = glyph->pixmap.width;
>            if ( font->outline <= 0 && width > glyph->maxx - glyph->minx ) {
>                width = glyph->maxx - glyph->minx;
>            }
>            /* do kerning, if possible AC-Patch */
>            if ( use_kerning && prev_index && glyph->index ) {
>                FT_Vector delta;
>                FT_Get_Kerning( font->face, prev_index, glyph->index, ft_kerning_default, &delta );
>                xstart += delta.x >> 6;
>            }
>
>            /* Compensate for the wrap around bug with negative minx's */
>            if ( first && (glyph->minx < 0) ) {
>                xstart -= glyph->minx;
>            }
>            first = SDL_FALSE;
>
>            for ( row = 0; row < glyph->pixmap.rows; ++row ) {
>                /* Make sure we don't go either over, or under the
>                 * limit */
>                if ( row+glyph->yoffset < 0 ) {
>                    continue;
>                }
>                if ( row+glyph->yoffset >= textbuf->h ) {
>                    continue;
>                }
>                dst =  ((Uint32*)textbuf->pixels + rowSize * line) +
>                (row+glyph->yoffset) * textbuf->pitch/4 +
>                xstart + glyph->minx;
>
>                /* Added code to adjust src pointer for pixmaps to
>                 * account for pitch.
>                 * */
>                src = (Uint8*) (glyph->pixmap.buffer + glyph->pixmap.pitch * row);
>                for ( col = width; col>0 && dst < dst_check; --col) {
>                    alpha = *src++;
>                    *dst++ |= pixel | (alpha << 24);
>                }
>            }
>
>            xstart += glyph->advance;
>            if ( TTF_HANDLE_STYLE_BOLD(font) ) {
>                xstart += font->glyph_overhang;
>            }
>            prev_index = glyph->index;
>        }
>
>        /* Handle the underline style */
>        if ( TTF_HANDLE_STYLE_UNDERLINE(font) ) {
>            row = TTF_underline_top_row(font);
>			int curline;
>			for (curline = 0; curline < numLines; curline++)
>			{
>				TTF_drawLine_Blended(font, textbuf, row * (curline + 1), pixel);
>			}
>        }
>
>        /* Handle the strikethrough style */
>        if ( TTF_HANDLE_STYLE_STRIKETHROUGH(font) ) {
>            row = TTF_strikethrough_top_row(font);
>            TTF_drawLine_Blended(font, textbuf, row, pixel);
>        }
>    }
>
>    if ( strLines ) {
>        SDL_free(strLines);
>		// Since in the new version, str is only a clone of text,
>		// there is no need to free it anymore.
>        //SDL_stack_free(str);
>    }
>    return(textbuf);
>}

Actions: View

Attachments on bug 2492: 1616

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.