X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Ftext.c;h=59c2ba3a6e9fa585e11d2ae7dcb2a64393314dc9;hb=1786288765edb99711ec0eb06520969879d62cc2;hp=1a5dcefe2a543122fef6521c260b0d863065ff2f;hpb=14089dac2cbe56e563863e1e5adb8847944fd262;p=rocksndiamonds.git diff --git a/src/libgame/text.c b/src/libgame/text.c index 1a5dcefe..59c2ba3a 100644 --- a/src/libgame/text.c +++ b/src/libgame/text.c @@ -1,7 +1,7 @@ /*********************************************************** * Artsoft Retro-Game Library * *----------------------------------------------------------* -* (c) 1994-2002 Artsoft Entertainment * +* (c) 1994-2006 Artsoft Entertainment * * Holger Schemel * * Detmolder Strasse 189 * * 33604 Bielefeld * @@ -15,55 +15,22 @@ #include #include "text.h" +#include "misc.h" /* ========================================================================= */ /* font functions */ /* ========================================================================= */ -#define NUM_FONTS 2 -#define NUM_FONT_COLORS 4 -#define NUM_FONT_CHARS (FONT_LINES_PER_FONT * FONT_CHARS_PER_LINE) - -static GC tile_clip_gc = None; -static Pixmap tile_clipmask[NUM_FONTS][NUM_FONT_COLORS][NUM_FONT_CHARS]; - -static struct -{ - Bitmap **bitmap; - int xsize, ysize; -} font_info[NUM_FONTS] = -{ - { &font.bitmap_big, FONT1_XSIZE, FONT1_YSIZE }, - { &font.bitmap_medium, FONT6_XSIZE, FONT6_YSIZE } -}; +#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND) +static GC font_clip_gc = None; static void InitFontClipmasks() { -#if defined(TARGET_X11_NATIVE) - static boolean clipmasks_initialized = FALSE; - boolean fonts_initialized = TRUE; XGCValues clip_gc_values; unsigned long clip_gc_valuemask; GC copy_clipmask_gc; - int i, j, k; - - for (i=0; idrawable, + font_clip_gc = XCreateGC(display, window->drawable, clip_gc_valuemask, &clip_gc_values); /* create graphic context structures needed for clipping */ clip_gc_values.graphics_exposures = False; clip_gc_valuemask = GCGraphicsExposures; - copy_clipmask_gc = XCreateGC(display, (*font_info[0].bitmap)->clip_mask, + copy_clipmask_gc = XCreateGC(display, + gfx.font_bitmap_info[0].bitmap->clip_mask, clip_gc_valuemask, &clip_gc_values); /* create only those clipping Pixmaps we really need */ - for (i=0; iclip_mask; - int xpos = k % FONT_CHARS_PER_LINE; - int ypos = k / FONT_CHARS_PER_LINE; - int xsize = font_info[i].xsize; - int ysize = font_info[i].ysize; - int src_x = xsize * xpos; - int src_y = ysize * (ypos + j * FONT_LINES_PER_FONT); - - tile_clipmask[i][j][k] = - XCreatePixmap(display, window->drawable, xsize, ysize, 1); - - XCopyArea(display, src_pixmap, tile_clipmask[i][j][k], copy_clipmask_gc, - src_x, src_y, xsize, ysize, 0, 0); + if (gfx.font_bitmap_info[i].bitmap == NULL) + continue; + + gfx.font_bitmap_info[i].clip_mask = + checked_calloc(gfx.font_bitmap_info[i].num_chars * sizeof(Pixmap)); + + for (j = 0; j < gfx.font_bitmap_info[i].num_chars; j++) + { + Bitmap *src_bitmap = gfx.font_bitmap_info[i].bitmap; + Pixmap src_pixmap = src_bitmap->clip_mask; + int xpos = j % gfx.font_bitmap_info[i].num_chars_per_line; + int ypos = j / gfx.font_bitmap_info[i].num_chars_per_line; + int width = gfx.font_bitmap_info[i].width; + int height = gfx.font_bitmap_info[i].height; + int src_x = gfx.font_bitmap_info[i].src_x + xpos * width; + int src_y = gfx.font_bitmap_info[i].src_y + ypos * height; + + gfx.font_bitmap_info[i].clip_mask[j] = + XCreatePixmap(display, window->drawable, width, height, 1); + + XCopyArea(display, src_pixmap, gfx.font_bitmap_info[i].clip_mask[j], + copy_clipmask_gc, src_x, src_y, width, height, 0, 0); + } } XFreeGC(display, copy_clipmask_gc); +} + +static void FreeFontClipmasks() +{ + int i, j; - clipmasks_initialized = TRUE; + if (gfx.num_fonts == 0 || gfx.font_bitmap_info[0].bitmap == NULL) + return; -#endif /* TARGET_X11_NATIVE */ + for (i = 0; i < gfx.num_fonts; i++) + { + if (gfx.font_bitmap_info[i].clip_mask) + { + for (j = 0; j < gfx.font_bitmap_info[i].num_chars; j++) + XFreePixmap(display, gfx.font_bitmap_info[i].clip_mask[j]); + free(gfx.font_bitmap_info[i].clip_mask); + } + + gfx.font_bitmap_info[i].clip_mask = NULL; + gfx.font_bitmap_info[i].num_chars = 0; + } + + if (font_clip_gc) + XFreeGC(display, font_clip_gc); + font_clip_gc = None; } +#endif /* TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND */ -void InitFontInfo(Bitmap *bitmap_initial, - Bitmap *bitmap_big, Bitmap *bitmap_medium, - Bitmap *bitmap_small, Bitmap *bitmap_tile) +void InitFontInfo(struct FontBitmapInfo *font_bitmap_info, int num_fonts, + int (*select_font_function)(int)) { - font.bitmap_initial = bitmap_initial; - font.bitmap_big = bitmap_big; - font.bitmap_medium = bitmap_medium; - font.bitmap_small = bitmap_small; - font.bitmap_tile = bitmap_tile; + gfx.num_fonts = num_fonts; + gfx.font_bitmap_info = font_bitmap_info; + gfx.select_font_function = select_font_function; +#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND) InitFontClipmasks(); +#endif +} + +void FreeFontInfo(struct FontBitmapInfo *font_bitmap_info) +{ + if (font_bitmap_info == NULL) + return; + +#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND) + FreeFontClipmasks(); +#endif + + free(font_bitmap_info); +} + +struct FontBitmapInfo *getFontBitmapInfo(int font_nr) +{ + int font_bitmap_id = gfx.select_font_function(font_nr); + + return &gfx.font_bitmap_info[font_bitmap_id]; +} + +int getFontWidth(int font_nr) +{ + int font_bitmap_id = gfx.select_font_function(font_nr); + + return gfx.font_bitmap_info[font_bitmap_id].width; } -int getFontWidth(int font_size, int font_type) +int getFontHeight(int font_nr) { - return (font_type == FC_SPECIAL1 ? FONT3_XSIZE : - font_type == FC_SPECIAL2 ? FONT4_XSIZE : - font_type == FC_SPECIAL3 ? FONT5_XSIZE : - font_size == FS_BIG ? FONT1_XSIZE : - font_size == FS_MEDIUM ? FONT6_XSIZE : - font_size == FS_SMALL ? FONT2_XSIZE : - FONT2_XSIZE); + int font_bitmap_id = gfx.select_font_function(font_nr); + + return gfx.font_bitmap_info[font_bitmap_id].height; } -int getFontHeight(int font_size, int font_type) +int getTextWidth(char *text, int font_nr) { - return (font_type == FC_SPECIAL1 ? FONT3_YSIZE : - font_type == FC_SPECIAL2 ? FONT4_YSIZE : - font_type == FC_SPECIAL3 ? FONT5_YSIZE : - font_size == FS_BIG ? FONT1_YSIZE : - font_size == FS_MEDIUM ? FONT6_YSIZE : - font_size == FS_SMALL ? FONT2_YSIZE : - FONT2_YSIZE); + return (text != NULL ? strlen(text) * getFontWidth(font_nr) : 0); } -void DrawInitText(char *text, int ypos, int color) +static char getFontCharPosition(int font_nr, char c) { - if (window && font.bitmap_initial) + int font_bitmap_id = gfx.select_font_function(font_nr); + struct FontBitmapInfo *font = &gfx.font_bitmap_info[font_bitmap_id]; + boolean default_font = (font->num_chars == DEFAULT_NUM_CHARS_PER_FONT); + int font_pos = c - 32; + + /* map some special characters to their ascii values in default font */ + if (default_font) + font_pos = MAP_FONT_ASCII(c) - 32; + + /* this allows dynamic special characters together with special font */ + if (font_pos < 0 || font_pos >= font->num_chars) + font_pos = 0; + + return font_pos; +} + +void getFontCharSource(int font_nr, char c, Bitmap **bitmap, int *x, int *y) +{ + int font_bitmap_id = gfx.select_font_function(font_nr); + struct FontBitmapInfo *font = &gfx.font_bitmap_info[font_bitmap_id]; + int font_pos = getFontCharPosition(font_nr, c); + + *bitmap = font->bitmap; + *x = font->src_x + (font_pos % font->num_chars_per_line) * font->width; + *y = font->src_y + (font_pos / font->num_chars_per_line) * font->height; +} + +void DrawInitText(char *text, int ypos, int font_nr) +{ + if (window && + gfx.num_fonts > 0 && + gfx.font_bitmap_info[font_nr].bitmap != NULL) { - ClearRectangle(window, 0, ypos, video.width, FONT2_YSIZE); - DrawTextExt(window, (video.width - strlen(text) * FONT2_XSIZE)/2, - ypos, text, FS_INITIAL, color, FONT_OPAQUE); + ClearRectangle(window, 0, ypos, video.width, getFontHeight(font_nr)); + DrawTextExt(window, (video.width - getTextWidth(text, font_nr)) / 2, ypos, + text, font_nr, BLIT_OPAQUE); FlushDisplay(); } } -void DrawTextFCentered(int y, int font_type, char *format, ...) +void DrawTextF(int x, int y, int font_nr, char *format, ...) { char buffer[MAX_OUTPUT_LINESIZE + 1]; - int font_width = getFontWidth(FS_SMALL, font_type); va_list ap; va_start(ap, format); vsprintf(buffer, format, ap); va_end(ap); - DrawText(gfx.sx + (gfx.sxsize - strlen(buffer) * font_width) / 2, - gfx.sy + y, buffer, FS_SMALL, font_type); + if (strlen(buffer) > MAX_OUTPUT_LINESIZE) + Error(ERR_EXIT, "string too long in DrawTextF() -- aborting"); + + DrawText(gfx.sx + x, gfx.sy + y, buffer, font_nr); } -void DrawTextF(int x, int y, int font_type, char *format, ...) +void DrawTextFCentered(int y, int font_nr, char *format, ...) { char buffer[MAX_OUTPUT_LINESIZE + 1]; va_list ap; @@ -178,17 +222,44 @@ void DrawTextF(int x, int y, int font_type, char *format, ...) vsprintf(buffer, format, ap); va_end(ap); - DrawText(gfx.sx + x, gfx.sy + y, buffer, FS_SMALL, font_type); + if (strlen(buffer) > MAX_OUTPUT_LINESIZE) + Error(ERR_EXIT, "string too long in DrawTextFCentered() -- aborting"); + + DrawText(gfx.sx + (gfx.sxsize - getTextWidth(buffer, font_nr)) / 2, + gfx.sy + y, buffer, font_nr); +} + +void DrawTextS(int x, int y, int font_nr, char *text) +{ + DrawText(gfx.sx + x, gfx.sy + y, text, font_nr); +} + +void DrawTextSCentered(int y, int font_nr, char *text) +{ + DrawText(gfx.sx + (gfx.sxsize - getTextWidth(text, font_nr)) / 2, + gfx.sy + y, text, font_nr); +} + +void DrawTextSAligned(int x, int y, char *text, int font_nr, int align) +{ + DrawText(gfx.sx + ALIGNED_XPOS(x, getTextWidth(text, font_nr), align), + gfx.sx + y, text, font_nr); +} + +void DrawTextAligned(int x, int y, char *text, int font_nr, int align) +{ + DrawText(ALIGNED_XPOS(x, getTextWidth(text, font_nr), align), + y, text, font_nr); } -void DrawText(int x, int y, char *text, int font_size, int font_type) +void DrawText(int x, int y, char *text, int font_nr) { - int mask_mode = FONT_OPAQUE; + int mask_mode = BLIT_OPAQUE; if (DrawingOnBackground(x, y)) - mask_mode = FONT_MASKED; + mask_mode = BLIT_ON_BACKGROUND; - DrawTextExt(drawto, x, y, text, font_size, font_type, mask_mode); + DrawTextExt(drawto, x, y, text, font_nr, mask_mode); if (x < gfx.dx) redraw_mask |= REDRAW_FIELD; @@ -196,131 +267,327 @@ void DrawText(int x, int y, char *text, int font_size, int font_type) redraw_mask |= REDRAW_DOOR_1; } -void DrawTextExt(DrawBuffer *bitmap, int x, int y, char *text, - int font_size, int font_type, int mask_mode) +void DrawTextExt(DrawBuffer *dst_bitmap, int dst_x, int dst_y, char *text, + int font_nr, int mask_mode) { - Bitmap *font_bitmap; - int font_width, font_height, font_starty; - boolean print_inverse = FALSE; - - if (font_size != FS_BIG && font_size != FS_MEDIUM && font_size != FS_SMALL) - font_size = FS_INITIAL; - if (font_type < FC_RED || font_type > FC_SPECIAL3) - font_type = FC_RED; - - font_width = getFontWidth(font_size, font_type); - font_height = getFontHeight(font_size, font_type); - - font_bitmap = (font_type == FC_SPECIAL2 ? font.bitmap_tile : - font_size == FS_BIG ? font.bitmap_big : - font_size == FS_MEDIUM ? font.bitmap_medium : - font_size == FS_SMALL ? font.bitmap_small : - font.bitmap_initial); - - if (font_bitmap == NULL) + int font_bitmap_id = gfx.select_font_function(font_nr); + struct FontBitmapInfo *font = &gfx.font_bitmap_info[font_bitmap_id]; + int font_width = getFontWidth(font_nr); + int font_height = getFontHeight(font_nr); +#if 0 + int border_1 = gfx.sx + gfx.sxsize; + int border_2 = gfx.dx + gfx.dxsize; + int dst_x_start = dst_x; +#endif + Bitmap *src_bitmap; + int src_x, src_y; + char *text_ptr = text; + + if (font->bitmap == NULL) return; - if (font_type == FC_SPECIAL2) - font_starty = (font_size == FS_BIG ? 0 : FONT1_YSIZE) * 5; - else - font_starty = (font_type * (font_size == FS_BIG ? FONT1_YSIZE : - font_size == FS_MEDIUM ? FONT6_YSIZE : - font_size == FS_SMALL ? FONT2_YSIZE : - FONT2_YSIZE) * - FONT_LINES_PER_FONT); + /* skip text to be printed outside the window (left/right will be clipped) */ + if (dst_y < 0 || dst_y + font_height > video.height) + return; - if (font_type == FC_SPECIAL3) - font_starty -= FONT2_YSIZE * FONT_LINES_PER_FONT; + /* add offset for drawing font characters */ + dst_x += font->draw_xoffset; + dst_y += font->draw_yoffset; - while (*text) + while (*text_ptr) { - char c = *text++; + char c = *text_ptr++; + + if (c == '\n') + c = ' '; /* print space instaed of newline */ - if (c == '~' && font_size == FS_SMALL) + getFontCharSource(font_nr, c, &src_bitmap, &src_x, &src_y); + + /* clip text at the left side of the window */ + if (dst_x < 0) { - print_inverse = TRUE; + dst_x += font_width; + continue; } - if (c >= 'a' && c <= 'z') - c = 'A' + (c - 'a'); - else if (c == 'ä' || c == 'Ä') - c = 91; - else if (c == 'ö' || c == 'Ö') - c = 92; - else if (c == 'ü' || c == 'Ü') - c = 93; - else if (c == '[' || c == ']') /* map to normal braces */ - c = (c == '[' ? '(' : ')'); - else if (c == '\\') /* bad luck ... */ - c = '/'; - - if ((c >= 32 && c <= 95) || c == '°' || c == '´' || c == '|') + /* clip text at the right side of the window */ +#if 1 + if (dst_x + font_width > video.width) + break; +#else + /* (this does not work well when trying to print text to whole screen) */ + if ((dst_x_start < border_1 && dst_x + font_width > border_1) || + (dst_x_start < border_2 && dst_x + font_width > border_2)) + break; +#endif + + if (mask_mode == BLIT_INVERSE) /* special mode for text gadgets */ { - int src_x = ((c - 32) % FONT_CHARS_PER_LINE) * font_width; - int src_y = ((c - 32) / FONT_CHARS_PER_LINE) * font_height + font_starty; - int dest_x = x, dest_y = y; + /* first step: draw solid colored rectangle (use "cursor" character) */ + if (strlen(text) == 1) /* only one char inverted => draw cursor */ + { + Bitmap *cursor_bitmap; + int cursor_x, cursor_y; + + getFontCharSource(font_nr, FONT_ASCII_CURSOR, &cursor_bitmap, + &cursor_x, &cursor_y); - if (c == '°' || c == '´' || c == '|') /* map '°' and 'TM' signs */ + BlitBitmap(cursor_bitmap, dst_bitmap, cursor_x, cursor_y, + font_width, font_height, dst_x, dst_y); + } + +#if defined(TARGET_SDL) + /* second step: draw masked inverted character */ + SDLCopyInverseMasked(src_bitmap, dst_bitmap, src_x, src_y, + font_width, font_height, dst_x, dst_y); +#else + /* second step: draw masked black rectangle (use "space" character) */ + SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, + dst_x - src_x, dst_y - src_y); + BlitBitmapMasked(src_bitmap, dst_bitmap, 0, 0, + font_width, font_height, dst_x, dst_y); +#endif + } + else if (mask_mode == BLIT_MASKED || mask_mode == BLIT_ON_BACKGROUND) + { + if (mask_mode == BLIT_ON_BACKGROUND) { - if (font_type == FC_SPECIAL2) - { - src_x = (c == '°' ? 1 : c == '´' ? 2 : 3) * font_width; - src_y = 4 * font_height; - } - else - { - src_x = FONT_CHARS_PER_LINE * font_width; - src_y = (c == '°' ? 1 : c == '´' ? 2 : 3) * font_height +font_starty; - } + /* clear font character background */ + ClearRectangleOnBackground(dst_bitmap, dst_x, dst_y, + font_width, font_height); } - if (print_inverse) /* special mode for text gadgets */ +#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND) + /* use special font tile clipmasks */ { - /* first step: draw solid colored rectangle (use "cursor" character) */ - BlitBitmap(font_bitmap, bitmap, FONT_CHARS_PER_LINE * font_width, - 3 * font_height + font_starty, - font_width, font_height, x, y); - - /* second step: draw masked black rectangle (use "space" character) */ - SetClipOrigin(font_bitmap, font_bitmap->stored_clip_gc, - dest_x - src_x, dest_y - src_y); - BlitBitmapMasked(font_bitmap, bitmap, - 0, 0, font_width, font_height, dest_x, dest_y); + int font_pos = getFontCharPosition(font_nr, c); + + SetClipMask(src_bitmap, font_clip_gc, font->clip_mask[font_pos]); + SetClipOrigin(src_bitmap, font_clip_gc, dst_x, dst_y); } - else if (mask_mode == FONT_MASKED) +#else + SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc, + dst_x - src_x, dst_y - src_y); +#endif + + BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, + font_width, font_height, dst_x, dst_y); + } + else /* normal, non-masked font blitting */ + { + BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, + font_width, font_height, dst_x, dst_y); + } + + dst_x += font_width; + } +} + +void DrawTextToTextArea(int x, int y, char *text, int font_nr, int line_length, + int area_xsize, int area_ysize, int mask_mode) +{ + int area_line = 0; + int font_height = getFontHeight(font_nr); + + if (text == NULL) + return; + + while (*text && area_line < area_ysize) + { + char buffer[MAX_OUTPUT_LINESIZE + 1]; + int i; + + for (i = 0; i < line_length && *text; i++) + if ((buffer[i] = *text++) == '\n') + break; + buffer[MIN(i, area_xsize)] = '\0'; + + DrawTextExt(drawto, x, y + area_line * font_height, buffer, font_nr, + mask_mode); + + area_line++; + } + + redraw_mask |= REDRAW_FIELD; +} + +boolean RenderLineToBuffer(char **src_buffer_ptr, char *dst_buffer, + int *dst_buffer_len, boolean last_line_was_empty, + int line_length) +{ + char *text_ptr = *src_buffer_ptr; + char *buffer = dst_buffer; + int buffer_len = *dst_buffer_len; + boolean buffer_filled = FALSE; + + while (*text_ptr) + { + char *word_ptr; + int word_len; + + /* skip leading whitespaces */ + while (*text_ptr == ' ' || *text_ptr == '\t') + text_ptr++; + + word_ptr = text_ptr; + word_len = 0; + + /* look for end of next word */ + while (*word_ptr != ' ' && *word_ptr != '\t' && *word_ptr != '\0') + { + word_ptr++; + word_len++; + } + + if (word_len == 0) + { + continue; + } + else if (*text_ptr == '\n') /* special case: force empty line */ + { + if (buffer_len == 0) + text_ptr++; + + /* prevent printing of multiple empty lines */ + if (buffer_len > 0 || !last_line_was_empty) + buffer_filled = TRUE; + } + else if (word_len < line_length - buffer_len) + { + /* word fits into text buffer -- add word */ + + if (buffer_len > 0) + buffer[buffer_len++] = ' '; + + strncpy(&buffer[buffer_len], text_ptr, word_len); + buffer_len += word_len; + buffer[buffer_len] = '\0'; + text_ptr += word_len; + } + else if (buffer_len > 0) + { + /* not enough space left for word in text buffer -- print buffer */ + + buffer_filled = TRUE; + } + else + { + /* word does not fit at all into empty text buffer -- cut word */ + + strncpy(buffer, text_ptr, line_length); + buffer[line_length] = '\0'; + text_ptr += line_length; + buffer_filled = TRUE; + } + + if (buffer_filled) + break; + } + + *src_buffer_ptr = text_ptr; + *dst_buffer_len = buffer_len; + + return buffer_filled; +} + +void DrawTextWrapped(int x, int y, char *text, int font_nr, int line_length, + int max_lines) +{ + char *text_ptr = text; + char buffer[line_length + 1]; + int buffer_len; + int current_line = 0; + int font_height = getFontHeight(font_nr); + + while (*text_ptr && current_line < max_lines) + { + buffer[0] = '\0'; + buffer_len = 0; + + RenderLineToBuffer(&text_ptr, buffer, &buffer_len, TRUE, line_length); + + DrawText(x, y + current_line * font_height, buffer, font_nr); + current_line++; + } +} + +int DrawTextFromFile(int x, int y, char *filename, int font_nr, + int line_length, int max_lines) +{ + int font_height = getFontHeight(font_nr); + char line[MAX_LINE_LEN]; + char buffer[line_length + 1]; + int buffer_len; + int current_line = 0; + FILE *file; + + if (current_line >= max_lines) + return 0; + + if (filename == NULL) + return 0; + + if (!(file = fopen(filename, MODE_READ))) + return 0; + + buffer[0] = '\0'; + buffer_len = 0; + + while (!feof(file) && current_line < max_lines) + { + char *line_ptr; + boolean last_line_was_empty = TRUE; + + /* read next line of input file */ + if (!fgets(line, MAX_LINE_LEN, file)) + break; + + /* skip comments (lines directly beginning with '#') */ + if (line[0] == '#') + continue; + + /* cut trailing newline from input line */ + for (line_ptr = line; *line_ptr; line_ptr++) + { + if (*line_ptr == '\n' || *line_ptr == '\r') { - /* clear font character background */ - BlitBitmap(gfx.background_bitmap, bitmap, - dest_x - gfx.real_sx, dest_y - gfx.real_sy, - font_width, font_height, dest_x, dest_y); - - /* use special font tile clipmasks, if available */ - if (font_size == FS_BIG || font_size == FS_MEDIUM) - { - int font_nr = (font_size == FS_BIG ? 0 : 1); - int font_char = (c >= 32 && c <= 95 ? c - 32 : 0); - - SetClipMask(font_bitmap, tile_clip_gc, - tile_clipmask[font_nr][font_type][font_char]); - SetClipOrigin(font_bitmap, tile_clip_gc, dest_x, dest_y); - } - else - { - SetClipOrigin(font_bitmap, font_bitmap->stored_clip_gc, - dest_x - src_x, dest_y - src_y); - } - - BlitBitmapMasked(font_bitmap, bitmap, src_x, src_y, - font_width, font_height, dest_x, dest_y); + *line_ptr = '\0'; + break; } - else /* normal, non-masked font blitting */ + } + + if (strlen(line) == 0) /* special case: force empty line */ + strcpy(line, "\n"); + + line_ptr = line; + + while (*line_ptr && current_line < max_lines) + { + boolean buffer_filled = RenderLineToBuffer(&line_ptr, + buffer, &buffer_len, + last_line_was_empty, + line_length); + if (buffer_filled) { - BlitBitmap(font_bitmap, bitmap, src_x, src_y, - font_width, font_height, dest_x, dest_y); + DrawText(x, y + current_line * font_height, buffer, font_nr); + current_line++; + + last_line_was_empty = (buffer_len == 0); + + buffer[0] = '\0'; + buffer_len = 0; } } + } + + fclose(file); - x += font_width; + if (buffer_len > 0 && current_line < max_lines) + { + DrawText(x, y + current_line * font_height, buffer, font_nr); + current_line++; } + + return current_line; }