void
xps_measure_font_glyph(fz_context *ctx, xps_document *doc, fz_font *font, int gid, xps_glyph_metrics *mtx)
{
int mask = FT_LOAD_NO_SCALE | FT_LOAD_IGNORE_TRANSFORM;
FT_Face face = font->ft_face;
FT_Fixed hadv = 0, vadv = 0;
fz_lock(ctx, FZ_LOCK_FREETYPE);
FT_Get_Advance(face, gid, mask, &hadv);
FT_Get_Advance(face, gid, mask | FT_LOAD_VERTICAL_LAYOUT, &vadv);
fz_unlock(ctx, FZ_LOCK_FREETYPE);
mtx->hadv = hadv / (float)face->units_per_EM;
mtx->vadv = vadv / (float)face->units_per_EM;
mtx->vorg = face->ascender / (float) face->units_per_EM;
}
FT_ULong
af_shaper_get_elem( AF_StyleMetrics metrics,
void* buf_,
unsigned int idx,
FT_Long* advance,
FT_Long* y_offset )
{
FT_Face face = metrics->globals->face;
FT_ULong glyph_index = *(FT_ULong*)buf_;
FT_UNUSED( idx );
if ( advance )
FT_Get_Advance( face,
glyph_index,
FT_LOAD_NO_SCALE |
FT_LOAD_NO_HINTING |
FT_LOAD_IGNORE_TRANSFORM,
advance );
if ( y_offset )
*y_offset = 0;
return glyph_index;
}
float MinikinFontFreeType::GetHorizontalAdvance(uint32_t glyph_id,
const MinikinPaint &paint) const {
FT_Set_Pixel_Sizes(mTypeface, 0, paint.size);
FT_UInt32 flags = FT_LOAD_DEFAULT; // TODO: respect hinting settings
FT_Fixed advance;
FT_Get_Advance(mTypeface, glyph_id, flags, &advance);
return advance * (1.0 / 65536);
}
void calculate_extents(box* b, hb_glyph_info_t glyph_info, hb_glyph_position_t glyph_pos, FT_Face ft_face, double point_size, hb_direction_t direction) {
FT_Error error = FT_Load_Glyph(ft_face, glyph_info.codepoint, FT_LOAD_NO_SCALE);
if (error) return;
FT_Glyph glyph;
error = FT_Get_Glyph(ft_face->glyph, &glyph);
if (error) return;
FT_BBox ft_bbox;
FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_UNSCALED, &ft_bbox);
FT_Fixed advance;
FT_Get_Advance(ft_face, glyph_info.codepoint, FT_LOAD_NO_SCALE, &advance);
const FT_Glyph_Metrics *ftmetrics = &ft_face->glyph->metrics;
b->width = advance * point_size / ft_face->units_per_EM;
if (direction == HB_DIRECTION_TTB) {
FT_Get_Advance(ft_face, glyph_info.codepoint, FT_LOAD_NO_SCALE | FT_LOAD_VERTICAL_LAYOUT, &advance);
b->height = advance * point_size / ft_face->units_per_EM;
b->depth = 0;
} else {
b->height = ft_bbox.yMax * point_size / ft_face->units_per_EM;
b->depth = -ft_bbox.yMin * point_size / ft_face->units_per_EM;
}
FT_Done_Glyph(glyph);
}
static FT_Fixed
_get_glyph_advance(FT_Face face, FT_UInt gid, bool vertical)
{
FT_Error error;
FT_Fixed advance;
int flags = FT_LOAD_NO_SCALE;
if (vertical)
flags |= FT_LOAD_VERTICAL_LAYOUT;
error = FT_Get_Advance(face, gid, flags, &advance);
if (error)
advance = 0;
else
advance = advance;
/* FreeType's vertical metrics grows downward */
if (vertical)
advance = -advance;
return advance;
}
static int SFGetAdvance(SFStringRecord *record, SFFontRef sfFont, int recordIndex, int glyphIndex) {
#ifdef SF_IOS_CG
int adv;
#else
FT_Fixed adv;
#endif
SFGlyph glyph = record->charRecord[recordIndex].gRec[glyphIndex].glyph;
if (record->charRecord[recordIndex].gRec[glyphIndex].glyphProp & gpAdvance) {
return record->charRecord[recordIndex].gRec[glyphIndex].advance;
}
#ifdef SF_IOS_CG
CGFontGetGlyphAdvances(SFFontGetCGFont(sfFont), &glyph, 1, &adv);
#else
FT_Get_Advance(SFFontGetFTFace(sfFont), glyph, FT_LOAD_NO_SCALE, &adv);
#endif
record->charRecord[recordIndex].gRec[glyphIndex].advance = adv;
record->charRecord[recordIndex].gRec[glyphIndex].glyphProp |= gpAdvance;
return adv;
}
static void
fz_text_extract_span(fz_context *ctx, fz_text_span **last, fz_text *text, fz_matrix ctm, fz_point *pen)
{
fz_font *font = text->font;
FT_Face face = font->ft_face;
fz_matrix tm = text->trm;
fz_matrix trm;
float size;
float adv;
fz_rect rect;
fz_point dir, ndir;
fz_point delta, ndelta;
float dist, dot;
float ascender = 1;
float descender = 0;
int multi;
int i, err;
if (text->len == 0)
return;
fz_lock(ctx, FZ_LOCK_FREETYPE);
if (font->ft_face)
{
err = FT_Set_Char_Size(font->ft_face, 64, 64, 72, 72);
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;
}
rect = fz_empty_rect;
if (text->wmode == 0)
{
dir.x = 1;
dir.y = 0;
}
else
{
dir.x = 0;
dir.y = 1;
}
tm.e = 0;
tm.f = 0;
trm = fz_concat(tm, ctm);
dir = fz_transform_vector(trm, dir);
dist = sqrtf(dir.x * dir.x + dir.y * dir.y);
ndir.x = dir.x / dist;
ndir.y = dir.y / dist;
size = fz_matrix_expansion(trm);
multi = 1;
for (i = 0; i < text->len; i++)
{
if (text->items[i].gid < 0)
{
fz_add_text_char(ctx, last, font, size, text->wmode, text->items[i].ucs, fz_round_rect(rect));
multi ++;
fz_divide_text_chars(last, multi, fz_round_rect(rect));
continue;
}
multi = 1;
/* Calculate new pen location and delta */
tm.e = text->items[i].x;
tm.f = text->items[i].y;
trm = fz_concat(tm, ctm);
delta.x = pen->x - trm.e;
delta.y = pen->y - trm.f;
if (pen->x == -1 && pen->y == -1)
delta.x = delta.y = 0;
dist = sqrtf(delta.x * delta.x + delta.y * delta.y);
/* Add space and newlines based on pen movement */
if (dist > 0)
{
ndelta.x = delta.x / dist;
ndelta.y = delta.y / dist;
dot = ndelta.x * ndir.x + ndelta.y * ndir.y;
if (dist > size * LINE_DIST)
{
fz_add_text_newline(ctx, last, font, size, text->wmode);
}
else if (fabsf(dot) > 0.95f && dist > size * SPACE_DIST)
{
if ((*last)->len > 0 && (*last)->text[(*last)->len - 1].c != ' ')
{
fz_rect spacerect;
spacerect.x0 = -0.2f;
spacerect.y0 = 0;
spacerect.x1 = 0;
spacerect.y1 = 1;
spacerect = fz_transform_rect(trm, spacerect);
fz_add_text_char(ctx, last, font, size, text->wmode, ' ', fz_round_rect(spacerect));
}
}
}
/* Calculate bounding box and new pen position based on font metrics */
if (font->ft_face)
{
FT_Fixed ftadv = 0;
int mask = FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING | FT_LOAD_IGNORE_TRANSFORM;
/* TODO: freetype returns broken vertical metrics */
/* if (text->wmode) mask |= FT_LOAD_VERTICAL_LAYOUT; */
FT_Get_Advance(font->ft_face, text->items[i].gid, mask, &ftadv);
adv = ftadv / 65536.0f;
rect.x0 = 0;
rect.y0 = descender;
rect.x1 = adv;
rect.y1 = ascender;
}
else
{
adv = font->t3widths[text->items[i].gid];
rect.x0 = 0;
rect.y0 = descender;
rect.x1 = adv;
rect.y1 = ascender;
}
rect = fz_transform_rect(trm, rect);
pen->x = trm.e + dir.x * adv;
pen->y = trm.f + dir.y * adv;
fz_add_text_char(ctx, last, font, size, text->wmode, text->items[i].ucs, fz_round_rect(rect));
}
fz_unlock(ctx, FZ_LOCK_FREETYPE);
}
static void
fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, const fz_matrix *ctm, fz_text_style *style)
{
fz_point *pen = &dev->point;
fz_font *font = text->font;
FT_Face face = font->ft_face;
fz_matrix tm = text->trm;
fz_matrix trm;
float size;
float adv;
fz_rect rect;
fz_point dir, ndir;
fz_point delta, ndelta;
float dist, dot;
float ascender = 1;
float descender = 0;
int multi;
int i, j, err;
if (text->len == 0)
return;
if (font->ft_face)
{
fz_lock(ctx, FZ_LOCK_FREETYPE);
err = FT_Set_Char_Size(font->ft_face, 64, 64, 72, 72);
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 if (font->t3procs && !fz_is_empty_rect(&font->bbox))
{
ascender = font->bbox.y1;
descender = font->bbox.y0;
}
rect = fz_empty_rect;
/* SumatraPDF: TODO: make this depend on the per-glyph displacement vector */
if (text->wmode == 0)
{
dir.x = 1;
dir.y = 0;
}
else
{
dir.x = 0;
dir.y = 1;
}
tm.e = 0;
tm.f = 0;
fz_concat(&trm, &tm, ctm);
fz_transform_vector(&dir, &trm);
dist = sqrtf(dir.x * dir.x + dir.y * dir.y);
ndir.x = dir.x / dist;
ndir.y = dir.y / dist;
size = fz_matrix_expansion(&trm);
for (i = 0; i < text->len; i++)
{
/* Calculate new pen location and delta */
tm.e = text->items[i].x;
tm.f = text->items[i].y;
fz_concat(&trm, &tm, ctm);
delta.x = pen->x - trm.e;
delta.y = pen->y - trm.f;
if (pen->x == -1 && pen->y == -1)
delta.x = delta.y = 0;
dist = sqrtf(delta.x * delta.x + delta.y * delta.y);
/* Add space and newlines based on pen movement */
if (dist > 0)
{
/* SumatraPDF: don't add spaces for large overlapping glyphs */
fz_text_span *last = &dev->cur_span;
if (last->len == 0 && dev->cur_line.len > 0)
last = &dev->cur_line.spans[dev->cur_line.len - 1];
ndelta.x = delta.x / dist;
ndelta.y = delta.y / dist;
dot = ndelta.x * ndir.x + ndelta.y * ndir.y;
/* SumatraPDF: don't merge multiple lines into one */
if (dist > size * LINE_DIST && hypotf(delta.y * ndir.x, delta.x * ndir.y) > size * 0.5f)
{
fz_flush_text_line(ctx, dev, style);
dev->lastchar = ' ';
}
else
/* SumatraPDF: use 0.95f instead of 0.9995f for slightly better results */
if (fabsf(dot) > 0.95f && dist > size * SPACE_DIST && dist < size * SPACE_MAX_DIST)
{
if (dev->lastchar != ' ' &&
/* SumatraPDF: don't add spaces before spaces or for large overlapping glyphs */
text->items[i].ucs != ' ' && !fz_maps_into_rect(trm, last->text[last->len - 1].bbox))
{
fz_rect spacerect;
spacerect.x0 = -0.2f;
spacerect.y0 = descender;
spacerect.x1 = 0;
spacerect.y1 = ascender;
fz_transform_rect(&spacerect, &trm);
fz_add_text_char(ctx, dev, style, ' ', spacerect);
dev->lastchar = ' ';
}
}
else if (dist > size * LINE_DIST)
{
fz_flush_text_line(ctx, dev, style);
dev->lastchar = ' ';
}
}
/* Calculate bounding box and new pen position based on font metrics */
if (font->ft_face)
{
FT_Fixed ftadv = 0;
int mask = FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING | FT_LOAD_IGNORE_TRANSFORM;
/* TODO: freetype returns broken vertical metrics */
/* if (text->wmode) mask |= FT_LOAD_VERTICAL_LAYOUT; */
fz_lock(ctx, FZ_LOCK_FREETYPE);
err = FT_Set_Char_Size(font->ft_face, 64, 64, 72, 72);
if (err)
fz_warn(ctx, "freetype set character size: %s", ft_error_string(err));
FT_Get_Advance(font->ft_face, text->items[i].gid, mask, &ftadv);
adv = ftadv / 65536.0f;
fz_unlock(ctx, FZ_LOCK_FREETYPE);
rect.x0 = 0;
rect.y0 = descender;
rect.x1 = adv;
rect.y1 = ascender;
}
/* SumatraPDF: TODO: this check might no longer be needed */
else if (text->items[i].gid < 256)
{
adv = font->t3widths[text->items[i].gid];
rect.x0 = 0;
rect.y0 = descender;
rect.x1 = adv;
rect.y1 = ascender;
}
fz_transform_rect(&rect, &trm);
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=1839 */
if (font->ft_face)
{
fz_rect bbox;
fz_bound_glyph(ctx, font, text->items[i].gid, &trm, &bbox);
rect.y0 = fz_min(rect.y0, bbox.y0);
rect.y1 = fz_max(rect.y1, bbox.y1);
}
pen->x = trm.e + dir.x * adv;
pen->y = trm.f + dir.y * adv;
/* Check for one glyph to many char mapping */
for (j = i + 1; j < text->len; j++)
if (text->items[j].gid >= 0)
break;
multi = j - i;
if (multi == 1)
{
fz_add_text_char(ctx, dev, style, text->items[i].ucs, rect);
}
else
{
for (j = 0; j < multi; j++)
{
fz_rect part = fz_split_bbox(rect, j, multi);
fz_add_text_char(ctx, dev, style, text->items[i + j].ucs, part);
}
i += j - 1;
}
dev->lastchar = text->items[i].ucs;
}
}
