diff options
Diffstat (limited to 'pdf/pdf_font.c')
-rw-r--r-- | pdf/pdf_font.c | 628 |
1 files changed, 314 insertions, 314 deletions
diff --git a/pdf/pdf_font.c b/pdf/pdf_font.c index 75bc141f..60d6e824 100644 --- a/pdf/pdf_font.c +++ b/pdf/pdf_font.c @@ -5,34 +5,34 @@ #include FT_FREETYPE_H #include FT_XFREE86_H -static char *basefontnames[14][7] = +static char *base_font_names[14][7] = { - { "Courier", "CourierNew", "CourierNewPSMT", nil }, + { "Courier", "CourierNew", "CourierNewPSMT", NULL }, { "Courier-Bold", "CourierNew,Bold", "Courier,Bold", - "CourierNewPS-BoldMT", "CourierNew-Bold", nil }, + "CourierNewPS-BoldMT", "CourierNew-Bold", NULL }, { "Courier-Oblique", "CourierNew,Italic", "Courier,Italic", - "CourierNewPS-ItalicMT", "CourierNew-Italic", nil }, + "CourierNewPS-ItalicMT", "CourierNew-Italic", NULL }, { "Courier-BoldOblique", "CourierNew,BoldItalic", "Courier,BoldItalic", - "CourierNewPS-BoldItalicMT", "CourierNew-BoldItalic", nil }, - { "Helvetica", "ArialMT", "Arial", nil }, + "CourierNewPS-BoldItalicMT", "CourierNew-BoldItalic", NULL }, + { "Helvetica", "ArialMT", "Arial", NULL }, { "Helvetica-Bold", "Arial-BoldMT", "Arial,Bold", "Arial-Bold", - "Helvetica,Bold", nil }, + "Helvetica,Bold", NULL }, { "Helvetica-Oblique", "Arial-ItalicMT", "Arial,Italic", "Arial-Italic", - "Helvetica,Italic", "Helvetica-Italic", nil }, + "Helvetica,Italic", "Helvetica-Italic", NULL }, { "Helvetica-BoldOblique", "Arial-BoldItalicMT", "Arial,BoldItalic", "Arial-BoldItalic", - "Helvetica,BoldItalic", "Helvetica-BoldItalic", nil }, + "Helvetica,BoldItalic", "Helvetica-BoldItalic", NULL }, { "Times-Roman", "TimesNewRomanPSMT", "TimesNewRoman", - "TimesNewRomanPS", nil }, + "TimesNewRomanPS", NULL }, { "Times-Bold", "TimesNewRomanPS-BoldMT", "TimesNewRoman,Bold", - "TimesNewRomanPS-Bold", "TimesNewRoman-Bold", nil }, + "TimesNewRomanPS-Bold", "TimesNewRoman-Bold", NULL }, { "Times-Italic", "TimesNewRomanPS-ItalicMT", "TimesNewRoman,Italic", - "TimesNewRomanPS-Italic", "TimesNewRoman-Italic", nil }, + "TimesNewRomanPS-Italic", "TimesNewRoman-Italic", NULL }, { "Times-BoldItalic", "TimesNewRomanPS-BoldItalicMT", "TimesNewRoman,BoldItalic", "TimesNewRomanPS-BoldItalic", - "TimesNewRoman-BoldItalic", nil }, - { "Symbol", nil }, - { "ZapfDingbats", nil } + "TimesNewRoman-BoldItalic", NULL }, + { "Symbol", NULL }, + { "ZapfDingbats", NULL } }; static int isdynalab(char *name) @@ -48,7 +48,7 @@ static int isdynalab(char *name) return 0; } -static int strcmpignorespace(char *a, char *b) +static int strcmp_ignore_space(char *a, char *b) { while (1) { @@ -67,13 +67,13 @@ static int strcmpignorespace(char *a, char *b) } } -static char *cleanfontname(char *fontname) +static char *clean_font_name(char *fontname) { int i, k; for (i = 0; i < 14; i++) - for (k = 0; basefontnames[i][k]; k++) - if (!strcmpignorespace(basefontnames[i][k], fontname)) - return basefontnames[i][0]; + for (k = 0; base_font_names[i][k]; k++) + if (!strcmp_ignore_space(base_font_names[i][k], fontname)) + return base_font_names[i][0]; return fontname; } @@ -83,10 +83,10 @@ static char *cleanfontname(char *fontname) enum { UNKNOWN, TYPE1, TRUETYPE }; -static int ftkind(FT_Face face) +static int ft_kind(FT_Face face) { const char *kind = FT_Get_X11_Font_Format(face); - pdf_logfont("ft font format %s\n", kind); + pdf_log_font("ft font format %s\n", kind); if (!strcmp(kind, "TrueType")) return TRUETYPE; if (!strcmp(kind, "Type 1")) @@ -98,7 +98,7 @@ static int ftkind(FT_Face face) return UNKNOWN; } -static int ftcharindex(FT_Face face, int cid) +static int ft_char_index(FT_Face face, int cid) { int gid = FT_Get_Char_Index(face, cid); if (gid == 0) @@ -106,53 +106,53 @@ static int ftcharindex(FT_Face face, int cid) return gid; } -static inline int ftcidtogid(pdf_fontdesc *fontdesc, int cid) +static inline int ft_cid_to_gid(pdf_font_desc *fontdesc, int cid) { - if (fontdesc->tottfcmap) + if (fontdesc->to_ttf_cmap) { - cid = pdf_lookupcmap(fontdesc->tottfcmap, cid); - return ftcharindex(fontdesc->font->ftface, cid); + cid = pdf_lookup_cmap(fontdesc->to_ttf_cmap, cid); + return ft_char_index(fontdesc->font->ft_face, cid); } - if (fontdesc->cidtogid) - return fontdesc->cidtogid[cid]; + if (fontdesc->cid_to_gid) + return fontdesc->cid_to_gid[cid]; return cid; } int -pdf_fontcidtogid(pdf_fontdesc *fontdesc, int cid) +pdf_font_cid_to_gid(pdf_font_desc *fontdesc, int cid) { - if (fontdesc->font->ftface) - return ftcidtogid(fontdesc, cid); + if (fontdesc->font->ft_face) + return ft_cid_to_gid(fontdesc, cid); return cid; } -static int ftwidth(pdf_fontdesc *fontdesc, int cid) +static int ft_width(pdf_font_desc *fontdesc, int cid) { int gid, fterr; - gid = ftcidtogid(fontdesc, cid); + gid = ft_cid_to_gid(fontdesc, cid); - fterr = FT_Load_Glyph(fontdesc->font->ftface, gid, + fterr = FT_Load_Glyph(fontdesc->font->ft_face, gid, FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM); if (fterr) { - fz_warn("freetype load glyph (gid %d): %s", gid, ft_errorstring(fterr)); + fz_warn("freetype load glyph (gid %d): %s", gid, ft_error_string(fterr)); return 0; } - return ((FT_Face)fontdesc->font->ftface)->glyph->advance.x; + return ((FT_Face)fontdesc->font->ft_face)->glyph->advance.x; } /* * Basic encoding tables */ -static int mrecode(char *name) +static int mre_code(char *name) { int i; for (i = 0; i < 256; i++) - if (pdf_macroman[i] && !strcmp(name, pdf_macroman[i])) + if (pdf_mac_roman[i] && !strcmp(name, pdf_mac_roman[i])) return i; return -1; } @@ -161,69 +161,69 @@ static int mrecode(char *name) * Create and destroy */ -pdf_fontdesc * -pdf_keepfont(pdf_fontdesc *fontdesc) +pdf_font_desc * +pdf_keep_font(pdf_font_desc *fontdesc) { fontdesc->refs ++; return fontdesc; } void -pdf_dropfont(pdf_fontdesc *fontdesc) +pdf_drop_font(pdf_font_desc *fontdesc) { if (fontdesc && --fontdesc->refs == 0) { if (fontdesc->font) - fz_dropfont(fontdesc->font); + fz_drop_font(fontdesc->font); if (fontdesc->encoding) - pdf_dropcmap(fontdesc->encoding); - if (fontdesc->tottfcmap) - pdf_dropcmap(fontdesc->tottfcmap); - if (fontdesc->tounicode) - pdf_dropcmap(fontdesc->tounicode); - fz_free(fontdesc->cidtogid); - fz_free(fontdesc->cidtoucs); + pdf_drop_cmap(fontdesc->encoding); + if (fontdesc->to_ttf_cmap) + pdf_drop_cmap(fontdesc->to_ttf_cmap); + if (fontdesc->to_unicode) + pdf_drop_cmap(fontdesc->to_unicode); + fz_free(fontdesc->cid_to_gid); + fz_free(fontdesc->cid_to_ucs); fz_free(fontdesc->hmtx); fz_free(fontdesc->vmtx); fz_free(fontdesc); } } -pdf_fontdesc * -pdf_newfontdesc(void) +pdf_font_desc * +pdf_new_font_desc(void) { - pdf_fontdesc *fontdesc; + pdf_font_desc *fontdesc; - fontdesc = fz_malloc(sizeof(pdf_fontdesc)); + fontdesc = fz_malloc(sizeof(pdf_font_desc)); fontdesc->refs = 1; - fontdesc->font = nil; + fontdesc->font = NULL; fontdesc->flags = 0; - fontdesc->italicangle = 0; + fontdesc->italic_angle = 0; fontdesc->ascent = 0; fontdesc->descent = 0; - fontdesc->capheight = 0; - fontdesc->xheight = 0; - fontdesc->missingwidth = 0; + fontdesc->cap_height = 0; + fontdesc->x_height = 0; + fontdesc->missing_width = 0; - fontdesc->encoding = nil; - fontdesc->tottfcmap = nil; - fontdesc->ncidtogid = 0; - fontdesc->cidtogid = nil; + fontdesc->encoding = NULL; + fontdesc->to_ttf_cmap = NULL; + fontdesc->cid_to_gid_len = 0; + fontdesc->cid_to_gid = NULL; - fontdesc->tounicode = nil; - fontdesc->ncidtoucs = 0; - fontdesc->cidtoucs = nil; + fontdesc->to_unicode = NULL; + fontdesc->cid_to_ucs_len = 0; + fontdesc->cid_to_ucs = NULL; fontdesc->wmode = 0; - fontdesc->hmtxcap = 0; - fontdesc->vmtxcap = 0; - fontdesc->nhmtx = 0; - fontdesc->nvmtx = 0; - fontdesc->hmtx = nil; - fontdesc->vmtx = nil; + fontdesc->hmtx_cap = 0; + fontdesc->vmtx_cap = 0; + fontdesc->hmtx_len = 0; + fontdesc->vmtx_len = 0; + fontdesc->hmtx = NULL; + fontdesc->vmtx = NULL; fontdesc->dhmtx.lo = 0x0000; fontdesc->dhmtx.hi = 0xFFFF; @@ -245,14 +245,14 @@ pdf_newfontdesc(void) */ static fz_error -loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) +load_simple_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict) { fz_error error; fz_obj *descriptor; fz_obj *encoding; fz_obj *widths; - unsigned short *etable = nil; - pdf_fontdesc *fontdesc; + unsigned short *etable = NULL; + pdf_font_desc *fontdesc; FT_Face face; FT_CharMap cmap; int kind; @@ -265,31 +265,31 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) int i, k, n; int fterr; - basefont = fz_toname(fz_dictgets(dict, "BaseFont")); - fontname = cleanfontname(basefont); + basefont = fz_to_name(fz_dict_gets(dict, "BaseFont")); + fontname = clean_font_name(basefont); /* Load font file */ - fontdesc = pdf_newfontdesc(); + fontdesc = pdf_new_font_desc(); - pdf_logfont("load simple font (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), fontdesc); - pdf_logfont("basefont %s -> %s\n", basefont, fontname); + pdf_log_font("load simple font (%d %d R) ptr=%p {\n", fz_to_num(dict), fz_to_gen(dict), fontdesc); + pdf_log_font("basefont %s -> %s\n", basefont, fontname); - descriptor = fz_dictgets(dict, "FontDescriptor"); + descriptor = fz_dict_gets(dict, "FontDescriptor"); if (descriptor) - error = pdf_loadfontdescriptor(fontdesc, xref, descriptor, nil, basefont); + error = pdf_load_font_descriptor(fontdesc, xref, descriptor, NULL, basefont); else - error = pdf_loadbuiltinfont(fontdesc, fontname); + error = pdf_load_builtin_font(fontdesc, fontname); if (error) goto cleanup; /* Some chinese documents mistakenly consider WinAnsiEncoding to be codepage 936 */ if (!*fontdesc->font->name && - !fz_dictgets(dict, "ToUnicode") && - !strcmp(fz_toname(fz_dictgets(dict, "Encoding")), "WinAnsiEncoding") && - fz_toint(fz_dictgets(descriptor, "Flags")) == 4) + !fz_dict_gets(dict, "ToUnicode") && + !strcmp(fz_to_name(fz_dict_gets(dict, "Encoding")), "WinAnsiEncoding") && + fz_to_int(fz_dict_gets(descriptor, "Flags")) == 4) { - /* note: without the comma, pdf_loadfontdescriptor would prefer /FontName over /BaseFont */ + /* note: without the comma, pdf_load_font_descriptor would prefer /FontName over /BaseFont */ char *cp936fonts[] = { "\xCB\xCE\xCC\xE5", "SimSun,Regular", "\xBA\xDA\xCC\xE5", "SimHei,Regular", @@ -304,34 +304,34 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) if (cp936fonts[i]) { fz_warn("workaround for S22PDF lying about chinese font encodings"); - pdf_dropfont(fontdesc); - fontdesc = pdf_newfontdesc(); - error = pdf_loadfontdescriptor(fontdesc, xref, descriptor, "Adobe-GB1", cp936fonts[i+1]); - error |= pdf_loadsystemcmap(&fontdesc->encoding, "GBK-EUC-H"); - error |= pdf_loadsystemcmap(&fontdesc->tounicode, "Adobe-GB1-UCS2"); - error |= pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-GB1-UCS2"); + pdf_drop_font(fontdesc); + fontdesc = pdf_new_font_desc(); + error = pdf_load_font_descriptor(fontdesc, xref, descriptor, "Adobe-GB1", cp936fonts[i+1]); + error |= pdf_load_system_cmap(&fontdesc->encoding, "GBK-EUC-H"); + error |= pdf_load_system_cmap(&fontdesc->to_unicode, "Adobe-GB1-UCS2"); + error |= pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-GB1-UCS2"); if (error) return fz_rethrow(error, "cannot load font"); - face = fontdesc->font->ftface; - kind = ftkind(face); + face = fontdesc->font->ft_face; + kind = ft_kind(face); goto skip_encoding; } } - face = fontdesc->font->ftface; - kind = ftkind(face); + face = fontdesc->font->ft_face; + kind = ft_kind(face); /* Encoding */ - pdf_logfont("ft name '%s' '%s'\n", face->family_name, face->style_name); + pdf_log_font("ft name '%s' '%s'\n", face->family_name, face->style_name); symbolic = fontdesc->flags & 4; if (face->num_charmaps > 0) cmap = face->charmaps[0]; else - cmap = nil; + cmap = NULL; for (i = 0; i < face->num_charmaps; i++) { @@ -356,7 +356,7 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) { fterr = FT_Set_Charmap(face, cmap); if (fterr) - fz_warn("freetype could not set cmap: %s", ft_errorstring(fterr)); + fz_warn("freetype could not set cmap: %s", ft_error_string(fterr)); } else fz_warn("freetype could not find any cmaps"); @@ -364,38 +364,38 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) etable = fz_calloc(256, sizeof(unsigned short)); for (i = 0; i < 256; i++) { - estrings[i] = nil; + estrings[i] = NULL; etable[i] = 0; } - encoding = fz_dictgets(dict, "Encoding"); + encoding = fz_dict_gets(dict, "Encoding"); if (encoding) { - if (fz_isname(encoding)) - pdf_loadencoding(estrings, fz_toname(encoding)); + if (fz_is_name(encoding)) + pdf_load_encoding(estrings, fz_to_name(encoding)); - if (fz_isdict(encoding)) + if (fz_is_dict(encoding)) { fz_obj *base, *diff, *item; - base = fz_dictgets(encoding, "BaseEncoding"); - if (fz_isname(base)) - pdf_loadencoding(estrings, fz_toname(base)); + base = fz_dict_gets(encoding, "BaseEncoding"); + if (fz_is_name(base)) + pdf_load_encoding(estrings, fz_to_name(base)); else if (!fontdesc->isembedded && !symbolic) - pdf_loadencoding(estrings, "StandardEncoding"); + pdf_load_encoding(estrings, "StandardEncoding"); - diff = fz_dictgets(encoding, "Differences"); - if (fz_isarray(diff)) + diff = fz_dict_gets(encoding, "Differences"); + if (fz_is_array(diff)) { - n = fz_arraylen(diff); + n = fz_array_len(diff); k = 0; for (i = 0; i < n; i++) { - item = fz_arrayget(diff, i); - if (fz_isint(item)) - k = fz_toint(item); - if (fz_isname(item)) - estrings[k++] = fz_toname(item); + item = fz_array_get(diff, i); + if (fz_is_int(item)) + k = fz_to_int(item); + if (fz_is_name(item)) + estrings[k++] = fz_to_name(item); if (k < 0) k = 0; if (k > 255) k = 255; } @@ -405,12 +405,12 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) /* start with the builtin encoding */ for (i = 0; i < 256; i++) - etable[i] = ftcharindex(face, i); + etable[i] = ft_char_index(face, i); /* encode by glyph name where we can */ if (kind == TYPE1) { - pdf_logfont("encode type1/cff by strings\n"); + pdf_log_font("encode type1/cff by strings\n"); for (i = 0; i < 256; i++) { if (estrings[i]) @@ -418,8 +418,8 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) etable[i] = FT_Get_Name_Index(face, estrings[i]); if (etable[i] == 0) { - int aglcode = pdf_lookupagl(estrings[i]); - char **aglnames = pdf_lookupaglnames(aglcode); + int aglcode = pdf_lookup_agl(estrings[i]); + char **aglnames = pdf_lookup_agl_names(aglcode); while (*aglnames) { etable[i] = FT_Get_Name_Index(face, *aglnames); @@ -438,16 +438,16 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) /* Unicode cmap */ if (!symbolic && face->charmap && face->charmap->platform_id == 3) { - pdf_logfont("encode truetype via unicode\n"); + pdf_log_font("encode truetype via unicode\n"); for (i = 0; i < 256; i++) { if (estrings[i]) { - int aglcode = pdf_lookupagl(estrings[i]); + int aglcode = pdf_lookup_agl(estrings[i]); if (!aglcode) etable[i] = FT_Get_Name_Index(face, estrings[i]); else - etable[i] = ftcharindex(face, aglcode); + etable[i] = ft_char_index(face, aglcode); } } } @@ -455,16 +455,16 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) /* MacRoman cmap */ else if (!symbolic && face->charmap && face->charmap->platform_id == 1) { - pdf_logfont("encode truetype via macroman\n"); + pdf_log_font("encode truetype via macroman\n"); for (i = 0; i < 256; i++) { if (estrings[i]) { - k = mrecode(estrings[i]); + k = mre_code(estrings[i]); if (k <= 0) etable[i] = FT_Get_Name_Index(face, estrings[i]); else - etable[i] = ftcharindex(face, k); + etable[i] = ft_char_index(face, k); } } } @@ -472,14 +472,14 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) /* Symbolic cmap */ else { - pdf_logfont("encode truetype symbolic\n"); + pdf_log_font("encode truetype symbolic\n"); for (i = 0; i < 256; i++) { if (estrings[i]) { etable[i] = FT_Get_Name_Index(face, estrings[i]); if (etable[i] == 0) - etable[i] = ftcharindex(face, i); + etable[i] = ft_char_index(face, i); } } } @@ -494,71 +494,71 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) { fterr = FT_Get_Glyph_Name(face, etable[i], ebuffer[i], 32); if (fterr) - fz_warn("freetype get glyph name (gid %d): %s", etable[i], ft_errorstring(fterr)); + fz_warn("freetype get glyph name (gid %d): %s", etable[i], ft_error_string(fterr)); if (ebuffer[i][0]) estrings[i] = ebuffer[i]; } else { - estrings[i] = (char*) pdf_winansi[i]; /* discard const */ + estrings[i] = (char*) pdf_win_ansi[i]; /* discard const */ } } } - fontdesc->encoding = pdf_newidentitycmap(0, 1); - fontdesc->ncidtogid = 256; - fontdesc->cidtogid = etable; + fontdesc->encoding = pdf_new_identity_cmap(0, 1); + fontdesc->cid_to_gid_len = 256; + fontdesc->cid_to_gid = etable; - error = pdf_loadtounicode(fontdesc, xref, estrings, nil, fz_dictgets(dict, "ToUnicode")); + error = pdf_load_to_unicode(fontdesc, xref, estrings, NULL, fz_dict_gets(dict, "ToUnicode")); if (error) - fz_catch(error, "cannot load tounicode"); + fz_catch(error, "cannot load to_unicode"); skip_encoding: /* Widths */ - pdf_setdefaulthmtx(fontdesc, fontdesc->missingwidth); + pdf_set_default_hmtx(fontdesc, fontdesc->missing_width); - widths = fz_dictgets(dict, "Widths"); + widths = fz_dict_gets(dict, "Widths"); if (widths) { int first, last; - first = fz_toint(fz_dictgets(dict, "FirstChar")); - last = fz_toint(fz_dictgets(dict, "LastChar")); + first = fz_to_int(fz_dict_gets(dict, "FirstChar")); + last = fz_to_int(fz_dict_gets(dict, "LastChar")); if (first < 0 || last > 255 || first > last) first = last = 0; for (i = 0; i < last - first + 1; i++) { - int wid = fz_toint(fz_arrayget(widths, i)); - pdf_addhmtx(fontdesc, i + first, i + first, wid); + int wid = fz_to_int(fz_array_get(widths, i)); + pdf_add_hmtx(fontdesc, i + first, i + first, wid); } } else { fterr = FT_Set_Char_Size(face, 1000, 1000, 72, 72); if (fterr) - fz_warn("freetype set character size: %s", ft_errorstring(fterr)); + fz_warn("freetype set character size: %s", ft_error_string(fterr)); for (i = 0; i < 256; i++) { - pdf_addhmtx(fontdesc, i, i, ftwidth(fontdesc, i)); + pdf_add_hmtx(fontdesc, i, i, ft_width(fontdesc, i)); } } - pdf_endhmtx(fontdesc); + pdf_end_hmtx(fontdesc); - pdf_logfont("}\n"); + pdf_log_font("}\n"); *fontdescp = fontdesc; return fz_okay; cleanup: - if (etable != fontdesc->cidtogid) + if (etable != fontdesc->cid_to_gid) fz_free(etable); - pdf_dropfont(fontdesc); - return fz_rethrow(error, "cannot load simple font (%d %d R)", fz_tonum(dict), fz_togen(dict)); + pdf_drop_font(fontdesc); + return fz_rethrow(error, "cannot load simple font (%d %d R)", fz_to_num(dict), fz_to_gen(dict)); } /* @@ -566,12 +566,12 @@ cleanup: */ static fz_error -loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *encoding, fz_obj *tounicode) +load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_unicode) { fz_error error; fz_obj *widths; fz_obj *descriptor; - pdf_fontdesc *fontdesc; + pdf_font_desc *fontdesc; FT_Face face; int kind; char collection[256]; @@ -582,78 +582,78 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco /* Get font name and CID collection */ - basefont = fz_toname(fz_dictgets(dict, "BaseFont")); + basefont = fz_to_name(fz_dict_gets(dict, "BaseFont")); { fz_obj *cidinfo; char tmpstr[64]; int tmplen; - cidinfo = fz_dictgets(dict, "CIDSystemInfo"); + cidinfo = fz_dict_gets(dict, "CIDSystemInfo"); if (!cidinfo) return fz_throw("cid font is missing info"); - obj = fz_dictgets(cidinfo, "Registry"); - tmplen = MIN(sizeof tmpstr - 1, fz_tostrlen(obj)); - memcpy(tmpstr, fz_tostrbuf(obj), tmplen); + obj = fz_dict_gets(cidinfo, "Registry"); + tmplen = MIN(sizeof tmpstr - 1, fz_to_str_len(obj)); + memcpy(tmpstr, fz_to_str_buf(obj), tmplen); tmpstr[tmplen] = '\0'; fz_strlcpy(collection, tmpstr, sizeof collection); fz_strlcat(collection, "-", sizeof collection); - obj = fz_dictgets(cidinfo, "Ordering"); - tmplen = MIN(sizeof tmpstr - 1, fz_tostrlen(obj)); - memcpy(tmpstr, fz_tostrbuf(obj), tmplen); + obj = fz_dict_gets(cidinfo, "Ordering"); + tmplen = MIN(sizeof tmpstr - 1, fz_to_str_len(obj)); + memcpy(tmpstr, fz_to_str_buf(obj), tmplen); tmpstr[tmplen] = '\0'; fz_strlcat(collection, tmpstr, sizeof collection); } /* Load font file */ - fontdesc = pdf_newfontdesc(); + fontdesc = pdf_new_font_desc(); - pdf_logfont("load cid font (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), fontdesc); - pdf_logfont("basefont %s\n", basefont); - pdf_logfont("collection %s\n", collection); + pdf_log_font("load cid font (%d %d R) ptr=%p {\n", fz_to_num(dict), fz_to_gen(dict), fontdesc); + pdf_log_font("basefont %s\n", basefont); + pdf_log_font("collection %s\n", collection); - descriptor = fz_dictgets(dict, "FontDescriptor"); + descriptor = fz_dict_gets(dict, "FontDescriptor"); if (descriptor) - error = pdf_loadfontdescriptor(fontdesc, xref, descriptor, collection, basefont); + error = pdf_load_font_descriptor(fontdesc, xref, descriptor, collection, basefont); else error = fz_throw("syntaxerror: missing font descriptor"); if (error) goto cleanup; - face = fontdesc->font->ftface; - kind = ftkind(face); + face = fontdesc->font->ft_face; + kind = ft_kind(face); /* Check for DynaLab fonts that must use hinting */ if (kind == TRUETYPE) { if (FT_IS_TRICKY(face) || isdynalab(fontdesc->font->name)) { - fontdesc->font->fthint = 1; - pdf_logfont("forced hinting for dynalab font\n"); + fontdesc->font->ft_hint = 1; + pdf_log_font("forced hinting for dynalab font\n"); } } /* Encoding */ error = fz_okay; - if (fz_isname(encoding)) + if (fz_is_name(encoding)) { - pdf_logfont("encoding /%s\n", fz_toname(encoding)); - if (!strcmp(fz_toname(encoding), "Identity-H")) - fontdesc->encoding = pdf_newidentitycmap(0, 2); - else if (!strcmp(fz_toname(encoding), "Identity-V")) - fontdesc->encoding = pdf_newidentitycmap(1, 2); + pdf_log_font("encoding /%s\n", fz_to_name(encoding)); + if (!strcmp(fz_to_name(encoding), "Identity-H")) + fontdesc->encoding = pdf_new_identity_cmap(0, 2); + else if (!strcmp(fz_to_name(encoding), "Identity-V")) + fontdesc->encoding = pdf_new_identity_cmap(1, 2); else - error = pdf_loadsystemcmap(&fontdesc->encoding, fz_toname(encoding)); + error = pdf_load_system_cmap(&fontdesc->encoding, fz_to_name(encoding)); } - else if (fz_isindirect(encoding)) + else if (fz_is_indirect(encoding)) { - pdf_logfont("encoding %d %d R\n", fz_tonum(encoding), fz_togen(encoding)); - error = pdf_loadembeddedcmap(&fontdesc->encoding, xref, encoding); + pdf_log_font("encoding %d %d R\n", fz_to_num(encoding), fz_to_gen(encoding)); + error = pdf_load_embedded_cmap(&fontdesc->encoding, xref, encoding); } else { @@ -662,56 +662,56 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco if (error) goto cleanup; - pdf_setfontwmode(fontdesc, pdf_getwmode(fontdesc->encoding)); - pdf_logfont("wmode %d\n", pdf_getwmode(fontdesc->encoding)); + pdf_set_font_wmode(fontdesc, pdf_get_wmode(fontdesc->encoding)); + pdf_log_font("wmode %d\n", pdf_get_wmode(fontdesc->encoding)); if (kind == TRUETYPE) { fz_obj *cidtogidmap; - cidtogidmap = fz_dictgets(dict, "CIDToGIDMap"); - if (fz_isindirect(cidtogidmap)) + cidtogidmap = fz_dict_gets(dict, "CIDToGIDMap"); + if (fz_is_indirect(cidtogidmap)) { fz_buffer *buf; - pdf_logfont("cidtogidmap stream\n"); + pdf_log_font("cidtogidmap stream\n"); - error = pdf_loadstream(&buf, xref, fz_tonum(cidtogidmap), fz_togen(cidtogidmap)); + error = pdf_load_stream(&buf, xref, fz_to_num(cidtogidmap), fz_to_gen(cidtogidmap)); if (error) goto cleanup; - fontdesc->ncidtogid = (buf->len) / 2; - fontdesc->cidtogid = fz_calloc(fontdesc->ncidtogid, sizeof(unsigned short)); - for (i = 0; i < fontdesc->ncidtogid; i++) - fontdesc->cidtogid[i] = (buf->data[i * 2] << 8) + buf->data[i * 2 + 1]; + fontdesc->cid_to_gid_len = (buf->len) / 2; + fontdesc->cid_to_gid = fz_calloc(fontdesc->cid_to_gid_len, sizeof(unsigned short)); + for (i = 0; i < fontdesc->cid_to_gid_len; i++) + fontdesc->cid_to_gid[i] = (buf->data[i * 2] << 8) + buf->data[i * 2 + 1]; - fz_dropbuffer(buf); + fz_drop_buffer(buf); } /* if truetype font is external, cidtogidmap should not be identity */ /* so we map from cid to unicode and then map that through the (3 1) */ /* unicode cmap to get a glyph id */ - else if (fontdesc->font->ftsubstitute) + else if (fontdesc->font->ft_substitute) { - pdf_logfont("emulate ttf cidfont\n"); + pdf_log_font("emulate ttf cidfont\n"); fterr = FT_Select_Charmap(face, ft_encoding_unicode); if (fterr) { - error = fz_throw("fonterror: no unicode cmap when emulating CID font: %s", ft_errorstring(fterr)); + error = fz_throw("fonterror: no unicode cmap when emulating CID font: %s", ft_error_string(fterr)); goto cleanup; } if (!strcmp(collection, "Adobe-CNS1")) - error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-CNS1-UCS2"); + error = pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-CNS1-UCS2"); else if (!strcmp(collection, "Adobe-GB1")) - error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-GB1-UCS2"); + error = pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-GB1-UCS2"); else if (!strcmp(collection, "Adobe-Japan1")) - error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Japan1-UCS2"); + error = pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-Japan1-UCS2"); else if (!strcmp(collection, "Adobe-Japan2")) - error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Japan2-UCS2"); + error = pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-Japan2-UCS2"); else if (!strcmp(collection, "Adobe-Korea1")) - error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Korea1-UCS2"); + error = pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-Korea1-UCS2"); else error = fz_okay; @@ -723,137 +723,137 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco } } - error = pdf_loadtounicode(fontdesc, xref, nil, collection, tounicode); + error = pdf_load_to_unicode(fontdesc, xref, NULL, collection, to_unicode); if (error) - fz_catch(error, "cannot load tounicode"); + fz_catch(error, "cannot load to_unicode"); /* Horizontal */ dw = 1000; - obj = fz_dictgets(dict, "DW"); + obj = fz_dict_gets(dict, "DW"); if (obj) - dw = fz_toint(obj); - pdf_setdefaulthmtx(fontdesc, dw); + dw = fz_to_int(obj); + pdf_set_default_hmtx(fontdesc, dw); - widths = fz_dictgets(dict, "W"); + widths = fz_dict_gets(dict, "W"); if (widths) { int c0, c1, w; - for (i = 0; i < fz_arraylen(widths); ) + for (i = 0; i < fz_array_len(widths); ) { - c0 = fz_toint(fz_arrayget(widths, i)); - obj = fz_arrayget(widths, i + 1); - if (fz_isarray(obj)) + c0 = fz_to_int(fz_array_get(widths, i)); + obj = fz_array_get(widths, i + 1); + if (fz_is_array(obj)) { - for (k = 0; k < fz_arraylen(obj); k++) + for (k = 0; k < fz_array_len(obj); k++) { - w = fz_toint(fz_arrayget(obj, k)); - pdf_addhmtx(fontdesc, c0 + k, c0 + k, w); + w = fz_to_int(fz_array_get(obj, k)); + pdf_add_hmtx(fontdesc, c0 + k, c0 + k, w); } i += 2; } else { - c1 = fz_toint(obj); - w = fz_toint(fz_arrayget(widths, i + 2)); - pdf_addhmtx(fontdesc, c0, c1, w); + c1 = fz_to_int(obj); + w = fz_to_int(fz_array_get(widths, i + 2)); + pdf_add_hmtx(fontdesc, c0, c1, w); i += 3; } } } - pdf_endhmtx(fontdesc); + pdf_end_hmtx(fontdesc); /* Vertical */ - if (pdf_getwmode(fontdesc->encoding) == 1) + if (pdf_get_wmode(fontdesc->encoding) == 1) { int dw2y = 880; int dw2w = -1000; - obj = fz_dictgets(dict, "DW2"); + obj = fz_dict_gets(dict, "DW2"); if (obj) { - dw2y = fz_toint(fz_arrayget(obj, 0)); - dw2w = fz_toint(fz_arrayget(obj, 1)); + dw2y = fz_to_int(fz_array_get(obj, 0)); + dw2w = fz_to_int(fz_array_get(obj, 1)); } - pdf_setdefaultvmtx(fontdesc, dw2y, dw2w); + pdf_set_default_vmtx(fontdesc, dw2y, dw2w); - widths = fz_dictgets(dict, "W2"); + widths = fz_dict_gets(dict, "W2"); if (widths) { int c0, c1, w, x, y; - for (i = 0; i < fz_arraylen(widths); ) + for (i = 0; i < fz_array_len(widths); ) { - c0 = fz_toint(fz_arrayget(widths, i)); - obj = fz_arrayget(widths, i + 1); - if (fz_isarray(obj)) + c0 = fz_to_int(fz_array_get(widths, i)); + obj = fz_array_get(widths, i + 1); + if (fz_is_array(obj)) { - for (k = 0; k * 3 < fz_arraylen(obj); k ++) + for (k = 0; k * 3 < fz_array_len(obj); k ++) { - w = fz_toint(fz_arrayget(obj, k * 3 + 0)); - x = fz_toint(fz_arrayget(obj, k * 3 + 1)); - y = fz_toint(fz_arrayget(obj, k * 3 + 2)); - pdf_addvmtx(fontdesc, c0 + k, c0 + k, x, y, w); + w = fz_to_int(fz_array_get(obj, k * 3 + 0)); + x = fz_to_int(fz_array_get(obj, k * 3 + 1)); + y = fz_to_int(fz_array_get(obj, k * 3 + 2)); + pdf_add_vmtx(fontdesc, c0 + k, c0 + k, x, y, w); } i += 2; } else { - c1 = fz_toint(obj); - w = fz_toint(fz_arrayget(widths, i + 2)); - x = fz_toint(fz_arrayget(widths, i + 3)); - y = fz_toint(fz_arrayget(widths, i + 4)); - pdf_addvmtx(fontdesc, c0, c1, x, y, w); + c1 = fz_to_int(obj); + w = fz_to_int(fz_array_get(widths, i + 2)); + x = fz_to_int(fz_array_get(widths, i + 3)); + y = fz_to_int(fz_array_get(widths, i + 4)); + pdf_add_vmtx(fontdesc, c0, c1, x, y, w); i += 5; } } } - pdf_endvmtx(fontdesc); + pdf_end_vmtx(fontdesc); } - pdf_logfont("}\n"); + pdf_log_font("}\n"); *fontdescp = fontdesc; return fz_okay; cleanup: - pdf_dropfont(fontdesc); - return fz_rethrow(error, "cannot load cid font (%d %d R)", fz_tonum(dict), fz_togen(dict)); + pdf_drop_font(fontdesc); + return fz_rethrow(error, "cannot load cid font (%d %d R)", fz_to_num(dict), fz_to_gen(dict)); } static fz_error -loadtype0(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) +load_type0_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict) { fz_error error; fz_obj *dfonts; fz_obj *dfont; fz_obj *subtype; fz_obj *encoding; - fz_obj *tounicode; + fz_obj *to_unicode; - dfonts = fz_dictgets(dict, "DescendantFonts"); + dfonts = fz_dict_gets(dict, "DescendantFonts"); if (!dfonts) return fz_throw("cid font is missing descendant fonts"); - dfont = fz_arrayget(dfonts, 0); + dfont = fz_array_get(dfonts, 0); - subtype = fz_dictgets(dfont, "Subtype"); - encoding = fz_dictgets(dict, "Encoding"); - tounicode = fz_dictgets(dict, "ToUnicode"); + subtype = fz_dict_gets(dfont, "Subtype"); + encoding = fz_dict_gets(dict, "Encoding"); + to_unicode = fz_dict_gets(dict, "ToUnicode"); - if (fz_isname(subtype) && !strcmp(fz_toname(subtype), "CIDFontType0")) - error = loadcidfont(fontdescp, xref, dfont, encoding, tounicode); - else if (fz_isname(subtype) && !strcmp(fz_toname(subtype), "CIDFontType2")) - error = loadcidfont(fontdescp, xref, dfont, encoding, tounicode); + if (fz_is_name(subtype) && !strcmp(fz_to_name(subtype), "CIDFontType0")) + error = load_cid_font(fontdescp, xref, dfont, encoding, to_unicode); + else if (fz_is_name(subtype) && !strcmp(fz_to_name(subtype), "CIDFontType2")) + error = load_cid_font(fontdescp, xref, dfont, encoding, to_unicode); else error = fz_throw("syntaxerror: unknown cid font type"); if (error) - return fz_rethrow(error, "cannot load descendant font (%d %d R)", fz_tonum(dfont), fz_togen(dfont)); + return fz_rethrow(error, "cannot load descendant font (%d %d R)", fz_to_num(dfont), fz_to_gen(dfont)); return fz_okay; } @@ -863,170 +863,170 @@ loadtype0(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict) */ fz_error -pdf_loadfontdescriptor(pdf_fontdesc *fontdesc, pdf_xref *xref, fz_obj *dict, char *collection, char *basefont) +pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_xref *xref, fz_obj *dict, char *collection, char *basefont) { fz_error error; fz_obj *obj1, *obj2, *obj3, *obj; char *fontname; char *origname; - pdf_logfont("load fontdescriptor {\n"); + pdf_log_font("load fontdescriptor {\n"); if (!strchr(basefont, ',') || strchr(basefont, '+')) - origname = fz_toname(fz_dictgets(dict, "FontName")); + origname = fz_to_name(fz_dict_gets(dict, "FontName")); else origname = basefont; - fontname = cleanfontname(origname); + fontname = clean_font_name(origname); - pdf_logfont("fontname %s -> %s\n", origname, fontname); + pdf_log_font("fontname %s -> %s\n", origname, fontname); - fontdesc->flags = fz_toint(fz_dictgets(dict, "Flags")); - fontdesc->italicangle = fz_toreal(fz_dictgets(dict, "ItalicAngle")); - fontdesc->ascent = fz_toreal(fz_dictgets(dict, "Ascent")); - fontdesc->descent = fz_toreal(fz_dictgets(dict, "Descent")); - fontdesc->capheight = fz_toreal(fz_dictgets(dict, "CapHeight")); - fontdesc->xheight = fz_toreal(fz_dictgets(dict, "XHeight")); - fontdesc->missingwidth = fz_toreal(fz_dictgets(dict, "MissingWidth")); + fontdesc->flags = fz_to_int(fz_dict_gets(dict, "Flags")); + fontdesc->italic_angle = fz_to_real(fz_dict_gets(dict, "ItalicAngle")); + fontdesc->ascent = fz_to_real(fz_dict_gets(dict, "Ascent")); + fontdesc->descent = fz_to_real(fz_dict_gets(dict, "Descent")); + fontdesc->cap_height = fz_to_real(fz_dict_gets(dict, "CapHeight")); + fontdesc->x_height = fz_to_real(fz_dict_gets(dict, "XHeight")); + fontdesc->missing_width = fz_to_real(fz_dict_gets(dict, "MissingWidth")); - pdf_logfont("flags %d\n", fontdesc->flags); + pdf_log_font("flags %d\n", fontdesc->flags); - obj1 = fz_dictgets(dict, "FontFile"); - obj2 = fz_dictgets(dict, "FontFile2"); - obj3 = fz_dictgets(dict, "FontFile3"); + obj1 = fz_dict_gets(dict, "FontFile"); + obj2 = fz_dict_gets(dict, "FontFile2"); + obj3 = fz_dict_gets(dict, "FontFile3"); obj = obj1 ? obj1 : obj2 ? obj2 : obj3; if (getenv("NOFONT")) - obj = nil; + obj = NULL; - if (fz_isindirect(obj)) + if (fz_is_indirect(obj)) { - error = pdf_loadembeddedfont(fontdesc, xref, obj); + error = pdf_load_embedded_font(fontdesc, xref, obj); if (error) { fz_catch(error, "ignored error when loading embedded font, attempting to load system font"); if (origname != fontname) - error = pdf_loadbuiltinfont(fontdesc, fontname); + error = pdf_load_builtin_font(fontdesc, fontname); else - error = pdf_loadsystemfont(fontdesc, fontname, collection); + error = pdf_load_system_font(fontdesc, fontname, collection); if (error) - return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_tonum(dict), fz_togen(dict)); + return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict)); } } else { if (origname != fontname) - error = pdf_loadbuiltinfont(fontdesc, fontname); + error = pdf_load_builtin_font(fontdesc, fontname); else - error = pdf_loadsystemfont(fontdesc, fontname, collection); + error = pdf_load_system_font(fontdesc, fontname, collection); if (error) - return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_tonum(dict), fz_togen(dict)); + return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict)); } fz_strlcpy(fontdesc->font->name, fontname, sizeof fontdesc->font->name); - pdf_logfont("}\n"); + pdf_log_font("}\n"); return fz_okay; } static void -pdf_makewidthtable(pdf_fontdesc *fontdesc) +pdf_make_width_table(pdf_font_desc *fontdesc) { fz_font *font = fontdesc->font; int i, k, cid, gid; - font->widthcount = 0; - for (i = 0; i < fontdesc->nhmtx; i++) + font->width_count = 0; + for (i = 0; i < fontdesc->hmtx_len; i++) { for (k = fontdesc->hmtx[i].lo; k <= fontdesc->hmtx[i].hi; k++) { - cid = pdf_lookupcmap(fontdesc->encoding, k); - gid = pdf_fontcidtogid(fontdesc, cid); - if (gid > font->widthcount) - font->widthcount = gid; + cid = pdf_lookup_cmap(fontdesc->encoding, k); + gid = pdf_font_cid_to_gid(fontdesc, cid); + if (gid > font->width_count) + font->width_count = gid; } } - font->widthcount ++; + font->width_count ++; - font->widthtable = fz_calloc(font->widthcount, sizeof(int)); - memset(font->widthtable, 0, sizeof(int) * font->widthcount); + font->width_table = fz_calloc(font->width_count, sizeof(int)); + memset(font->width_table, 0, sizeof(int) * font->width_count); - for (i = 0; i < fontdesc->nhmtx; i++) + for (i = 0; i < fontdesc->hmtx_len; i++) { for (k = fontdesc->hmtx[i].lo; k <= fontdesc->hmtx[i].hi; k++) { - cid = pdf_lookupcmap(fontdesc->encoding, k); - gid = pdf_fontcidtogid(fontdesc, cid); - if (gid >= 0 && gid < font->widthcount) - font->widthtable[gid] = fontdesc->hmtx[i].w; + cid = pdf_lookup_cmap(fontdesc->encoding, k); + gid = pdf_font_cid_to_gid(fontdesc, cid); + if (gid >= 0 && gid < font->width_count) + font->width_table[gid] = fontdesc->hmtx[i].w; } } } fz_error -pdf_loadfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict) +pdf_load_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict) { fz_error error; char *subtype; fz_obj *dfonts; fz_obj *charprocs; - if ((*fontdescp = pdf_finditem(xref->store, pdf_dropfont, dict))) + if ((*fontdescp = pdf_find_item(xref->store, pdf_drop_font, dict))) { - pdf_keepfont(*fontdescp); + pdf_keep_font(*fontdescp); return fz_okay; } - subtype = fz_toname(fz_dictgets(dict, "Subtype")); - dfonts = fz_dictgets(dict, "DescendantFonts"); - charprocs = fz_dictgets(dict, "CharProcs"); + subtype = fz_to_name(fz_dict_gets(dict, "Subtype")); + dfonts = fz_dict_gets(dict, "DescendantFonts"); + charprocs = fz_dict_gets(dict, "CharProcs"); if (subtype && !strcmp(subtype, "Type0")) - error = loadtype0(fontdescp, xref, dict); + error = load_type0_font(fontdescp, xref, dict); else if (subtype && !strcmp(subtype, "Type1")) - error = loadsimplefont(fontdescp, xref, dict); + error = load_simple_font(fontdescp, xref, dict); else if (subtype && !strcmp(subtype, "MMType1")) - error = loadsimplefont(fontdescp, xref, dict); + error = load_simple_font(fontdescp, xref, dict); else if (subtype && !strcmp(subtype, "TrueType")) - error = loadsimplefont(fontdescp, xref, dict); + error = load_simple_font(fontdescp, xref, dict); else if (subtype && !strcmp(subtype, "Type3")) - error = pdf_loadtype3font(fontdescp, xref, rdb, dict); + error = pdf_load_type3_font(fontdescp, xref, rdb, dict); else if (charprocs) { fz_warn("unknown font format, guessing type3."); - error = pdf_loadtype3font(fontdescp, xref, rdb, dict); + error = pdf_load_type3_font(fontdescp, xref, rdb, dict); } else if (dfonts) { fz_warn("unknown font format, guessing type0."); - error = loadtype0(fontdescp, xref, dict); + error = load_type0_font(fontdescp, xref, dict); } else { fz_warn("unknown font format, guessing type1 or truetype."); - error = loadsimplefont(fontdescp, xref, dict); + error = load_simple_font(fontdescp, xref, dict); } if (error) - return fz_rethrow(error, "cannot load font (%d %d R)", fz_tonum(dict), fz_togen(dict)); + return fz_rethrow(error, "cannot load font (%d %d R)", fz_to_num(dict), fz_to_gen(dict)); /* Save the widths to stretch non-CJK substitute fonts */ - if ((*fontdescp)->font->ftsubstitute && !(*fontdescp)->tottfcmap) - pdf_makewidthtable(*fontdescp); + if ((*fontdescp)->font->ft_substitute && !(*fontdescp)->to_ttf_cmap) + pdf_make_width_table(*fontdescp); - pdf_storeitem(xref->store, pdf_keepfont, pdf_dropfont, dict, *fontdescp); + pdf_store_item(xref->store, pdf_keep_font, pdf_drop_font, dict, *fontdescp); return fz_okay; } void -pdf_debugfont(pdf_fontdesc *fontdesc) +pdf_debug_font(pdf_font_desc *fontdesc) { int i; printf("fontdesc {\n"); - if (fontdesc->font->ftface) + if (fontdesc->font->ft_face) printf("\tfreetype font\n"); if (fontdesc->font->t3procs) printf("\ttype3 font\n"); @@ -1035,7 +1035,7 @@ pdf_debugfont(pdf_fontdesc *fontdesc) printf("\tDW %d\n", fontdesc->dhmtx.w); printf("\tW {\n"); - for (i = 0; i < fontdesc->nhmtx; i++) + for (i = 0; i < fontdesc->hmtx_len; i++) printf("\t\t<%04x> <%04x> %d\n", fontdesc->hmtx[i].lo, fontdesc->hmtx[i].hi, fontdesc->hmtx[i].w); printf("\t}\n"); @@ -1044,7 +1044,7 @@ pdf_debugfont(pdf_fontdesc *fontdesc) { printf("\tDW2 [%d %d]\n", fontdesc->dvmtx.y, fontdesc->dvmtx.w); printf("\tW2 {\n"); - for (i = 0; i < fontdesc->nvmtx; i++) + for (i = 0; i < fontdesc->vmtx_len; i++) printf("\t\t<%04x> <%04x> %d %d %d\n", fontdesc->vmtx[i].lo, fontdesc->vmtx[i].hi, fontdesc->vmtx[i].x, fontdesc->vmtx[i].y, fontdesc->vmtx[i].w); printf("\t}\n"); |