fz_glyph *

fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix *trm, const fz_matrix *ctm, const fz_stroke_state *stroke, const fz_irect *scissor)

{

{

fz_matrix subpix_trm;

unsigned char qe, qf;

fz_pixmap *

fz_render_stroked_glyph_pixmap(fz_context *ctx, fz_font *font, int gid, fz_matrix *trm, const fz_matrix *ctm, const fz_stroke_state *stroke, const fz_irect *scissor)

{

{

fz_matrix subpix_trm;

unsigned char qe, qf;

int do_cache, locked, caching;

fz_glyph_cache_entry *entry;

unsigned hash;

fz_var(locked);

fz_var(caching);

}

else

{

return NULL;

subpix_scissor.x0 = scissor->x0 - floorf(ctm->e);

subpix_scissor.y0 = scissor->y0 - floorf(ctm->f);

fz_try(ctx)

{

{

val = fz_render_ft_glyph(ctx, font, gid, &subpix_ctm, key.aa);

}

{

/* We drop the glyphcache here, and execute the t3

* glyph code. The danger here is that some other

/* If we throw an exception whilst caching,

* just ignore the exception and carry on. */

caching = 1;

{

/* We had to unlock. Someone else might

* have rendered in the meantime */

unsigned char qe, qf;

fz_matrix subpix_ctm;

float size = fz_subpixel_adjust(ctx, ctm, &subpix_ctm, &qe, &qf);

if (size <= MAX_GLYPH_SIZE)

{

}

else

{

return NULL;

}

fz_try(ctx)

{

{

val = fz_render_ft_glyph_pixmap(ctx, font, gid, &subpix_ctm, fz_text_aa_level(ctx));

}

{

val = fz_render_t3_glyph_pixmap(ctx, font, gid, &subpix_ctm, NULL, scissor);

}

#include "mupdf/fitz.h"

#include <ft2build.h>

#include "hb.h"

#include "hb-ft.h"

fz_strlcpy(font->name, "(null)", sizeof font->name);

font->ft_face = NULL;

font->t3matrix = fz_identity;

font->t3resources = NULL;

font->glyph_count = glyph_count;

if (use_glyph_bbox && glyph_count <= MAX_BBOX_TABLE_SIZE)

{

font->bbox_table = fz_malloc_array(ctx, glyph_count, sizeof(fz_rect));

fz_free(ctx, font->bbox_table);

fz_free(ctx, font->width_table);

fz_free(ctx, font->advance_cache);

{

hb_lock(ctx);

hb_unlock(ctx);

}

fz_free(ctx, font);

font->bbox.y0 = -1;

font->bbox.x1 = 2;

font->bbox.y1 = 2;

}

else

{

(float) face->bbox.xMax / face->units_per_EM,

(float) face->bbox.yMax / face->units_per_EM);

if (FT_IS_SFNT(face))

{

os2 = FT_Get_Sfnt_Table(face, FT_SFNT_OS2);

if (os2)

FT_Sfnt_Table_Info(face, 0, NULL, &n);

for (i = 0; i < n; ++i)

{

FT_Sfnt_Table_Info(face, i, &tag, &size);

if (tag == TTAG_GDEF || tag == TTAG_GPOS || tag == TTAG_GSUB)

}

}

fz_adjust_ft_glyph_width(fz_context *ctx, fz_font *font, int gid, fz_matrix *trm)

{

/* Fudge the font matrix to stretch the glyph if we've substituted the font. */

{

FT_Fixed adv;

float subw;

fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);

fz_pre_shear(&local_trm, SHEAR, 0);

/*

goto retry_unhinted;

}

}

{

/*

Enable hinting, but keep the huge char size so that

}

}

{

FT_Outline_Embolden(&face->glyph->outline, strength * 64);

FT_Outline_Translate(&face->glyph->outline, -strength * 32, -strength * 32);

fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);

fz_pre_shear(&local_trm, SHEAR, 0);

m.xx = local_trm.a * 64; /* should be 65536 */

fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);

fz_pre_shear(&local_trm, SHEAR, 0);

m.xx = local_trm.a * 65536;

v.x = local_trm.e * 65536;

v.y = local_trm.f * 65536;

{

ft_flags = FT_LOAD_NO_BITMAP;

}

return bounds;

}

{

FT_Outline_Embolden(&face->glyph->outline, strength * scale);

FT_Outline_Translate(&face->glyph->outline, -strength * 0.5 * scale, -strength * 0.5 * scale);

fz_adjust_ft_glyph_width(ctx, font, gid, &local_trm);

fz_pre_shear(&local_trm, SHEAR, 0);

fz_lock(ctx, FZ_LOCK_FREETYPE);

{

ft_flags = FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM;

fterr = FT_Set_Char_Size(face, scale, scale, 72, 72);

return NULL;

}

{

FT_Outline_Embolden(&face->glyph->outline, strength * scale);

FT_Outline_Translate(&face->glyph->outline, -strength * 0.5 * scale, -strength * 0.5 * scale);

font->bbox_table[gid] = d1_rect;

fz_transform_rect(&font->bbox_table[gid], &font->t3matrix);

{

/* Either the font bbox is invalid, or the d1_rect returned is

* incompatible with it. Either way, don't trust the d1 rect

if (font->ft_face)

{

fz_printf(ctx, out, "\tfreetype face %p\n", font->ft_face);

fz_printf(ctx, out, "\tsubstitute font\n");

}

if (script == 0)

script = ucdn_get_script(unicode);

if (font)

{

gid = fz_encode_character(ctx, font, unicode);

return *out_font = user_font, 0;

}

fz_stext_extract(fz_context *ctx, fz_stext_device *dev, fz_text_span *span, const fz_matrix *ctm, fz_stext_style *style)

{

fz_font *font = span->font;

fz_matrix tm = span->trm;

fz_matrix trm;

float adv;

if (style->wmode == 0)

{

{

fz_lock(ctx, FZ_LOCK_FREETYPE);

if (err)

fz_warn(ctx, "freetype set character size: %s", ft_error_string(err));

ascender = (float)face->ascender / face->units_per_EM;

descender = (float)face->descender / face->units_per_EM;

fz_unlock(ctx, FZ_LOCK_FREETYPE);

}

{

}

}

else

{

}

style->ascender = ascender;

style->descender = descender;

static int font_is_bold(fz_font *font)

{

if (face && (face->style_flags & FT_STYLE_FLAG_BOLD))

return 1;

return 1;

return 0;

}

static int font_is_italic(fz_font *font)

{

if (face && (face->style_flags & FT_STYLE_FLAG_ITALIC))

return 1;

return 1;

return 0;

}

static void

fz_print_style(fz_context *ctx, fz_output *out, fz_stext_style *style)

{

fz_printf(ctx, out, "span.s%d{font-family:\"%s\";font-size:%gpt;",

style->id, s, style->size);

if (font_is_italic(style->font))

{

fz_stext_block *block = page->blocks[block_n].u.text;

fz_stext_line *line;

fz_printf(ctx, out, "<block bbox=\"%g %g %g %g\">\n",

block->bbox.x0, block->bbox.y0, block->bbox.x1, block->bbox.y1);

for (span = line->first_span; span; span = span->next)

{

fz_stext_style *style = NULL;

int char_num;

for (char_num = 0; char_num < span->len; char_num++)

{

fz_printf(ctx, out, "</span>\n");

}

style = ch->style;

fz_printf(ctx, out, "<span bbox=\"%g %g %g %g\" font=\"%s\" size=\"%g\">\n",

span->bbox.x0, span->bbox.y0, span->bbox.x1, span->bbox.y1,

s, style->size);

fz_printf(ctx, out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"",

local_trm.a, local_trm.b, local_trm.c, local_trm.d, local_trm.e, local_trm.f);

fz_printf(ctx, out, " font-size=\"%g\"", size);

/* Leading (and repeated) whitespace presents a problem for SVG

* text, so elide it here. */

fz_trace_text_span(fz_context *ctx, fz_output *out, fz_text_span *span)

{

int i;

fz_printf(ctx, out, " trm=\"%g %g %g %g\">\n", span->trm.a, span->trm.b, span->trm.c, span->trm.d);

for (i = 0; i < span->len; i++)

{