/* * << Haru Free PDF Library >> -- hpdf_font.c * * URL: http://libharu.org * * Copyright (c) 1999-2006 Takeshi Kanno * Copyright (c) 2007-2009 Antony Dovgal * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. * It is provided "as is" without express or implied warranty. * */ #include "hpdf_conf.h" #include "hpdf_utils.h" #include "hpdf.h" #ifdef LIBHPDF_ENABLE_BIDI # include "fribidi.h" #endif static const HPDF_UINT8 MINBYTES[] = { 1, 1, 2, 4, 2, 4, }; static HPDF_UTFBytes_Func BYTES_FNS[] = { NULL, HPDF_UTF8Bytes, HPDF_UTF16BEBytes, HPDF_UTF32BEBytes, HPDF_UTF16LEBytes, HPDF_UTF32LEBytes, }; static HPDF_UTFToUcs4_Func TOUCS4_FNS[] = { NULL, HPDF_UTF8ToUcs4, HPDF_UTF16BEToUcs4, HPDF_UTF32BEToUcs4, HPDF_UTF16LEToUcs4, HPDF_UTF32LEToUcs4, }; static HPDF_Ucs4ToUTF_Func UCS4TO_FNS[] = { NULL, HPDF_Ucs4ToUTF8, HPDF_Ucs4ToUTF16BE, HPDF_Ucs4ToUTF32BE, HPDF_Ucs4ToUTF16LE, HPDF_Ucs4ToUTF32LE, }; static HPDF_BOOL IsCIDText (HPDF_Font font, HPDF_UINT index); static HPDF_UINT MeasureTextCache (HPDF_Font font, HPDF_REAL line_width, HPDF_REAL font_size, HPDF_REAL char_space, HPDF_REAL word_space, HPDF_INT options, HPDF_UINT cache_begin, HPDF_TextLineWidth *width); static HPDF_BOOL CanBreakAfter (HPDF_UCS4 b); static HPDF_BOOL CanBreakBefore (HPDF_UCS4 b); static HPDF_UINT GetUncovertedBytes (HPDF_Font font, const char *text, HPDF_UINT cache_begin, HPDF_TextLineWidth *width); static HPDF_CharEnc GetSourceCharEnc (HPDF_Font font); static void SetReliefFontIndex (HPDF_Font font); HPDF_EXPORT(HPDF_TextWidth) HPDF_Font_TextWidth (HPDF_Font font, const HPDF_BYTE *text, HPDF_UINT len) { HPDF_TextWidth tw = {0, 0, 0, 0}; HPDF_FontAttr attr; HPDF_PTRACE ((" HPDF_Font_TextWidth\n")); if (!HPDF_Font_Validate(font)) return tw; if (len > HPDF_LIMIT_MAX_STRING_LEN) { HPDF_RaiseError (font->error, HPDF_STRING_OUT_OF_RANGE, 0); return tw; } attr = (HPDF_FontAttr)font->attr; if (!attr->char_width_fn) { HPDF_SetError (font->error, HPDF_INVALID_OBJECT, 0); return tw; } if (text) { HPDF_Font_CheckBiDi (font, HPDF_FALSE); if (HPDF_Font_ConvertText (font, 0, (const char *)text, len) != HPDF_OK) return tw; } else if (attr->tw_cache.width) { return attr->tw_cache; } attr->tw_cache = HPDF_Font_TextCacheWidth (font, HPDF_FALSE, 0, attr->text_cache_len); return attr->tw_cache; } HPDF_TextWidth HPDF_Font_TextCacheWidth (HPDF_Font font, HPDF_BOOL ignore_flags, HPDF_UINT cache_begin, HPDF_UINT cache_end) { HPDF_TextWidth tw = {0, 0, 0, 0}; HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; const HPDF_BYTE *text = attr->text_cache; HPDF_BYTE *pirf = attr->text_cache + (attr->text_cache_allocated / 2); HPDF_BYTE irf; HPDF_UCS4 b = 0; HPDF_UINT i, bytes; HPDF_PTRACE ((" HPDF_Font_TextCacheWidth\n")); for (i = cache_begin; i < cache_end; i += bytes) { HPDF_UINT cw; irf = pirf[i] & HPDF_RELIEF_FONT_INDEX_MASK; cw = attr->char_width_fn (font, HPDF_TRUE, irf, text+i, &bytes, &b); if (!ignore_flags && (pirf[i] & HPDF_INTERLINEAR_ANNOTATION)) continue; tw.width += cw; tw.numchars++; if (b == 0x20 && bytes == 1 && !IsCIDText (font, irf)) { tw.numwords++; tw.numspace++; } } /* 2006.08.19 add. */ if (b == 0x20 && bytes == 1 && !IsCIDText (font, irf)) ; /* do nothing. */ else tw.numwords++; return tw; } HPDF_EXPORT(HPDF_UINT) HPDF_Font_MeasureText (HPDF_Font font, const HPDF_BYTE *text, HPDF_UINT len, HPDF_REAL width, HPDF_REAL font_size, HPDF_REAL char_space, HPDF_REAL word_space, HPDF_INT options, HPDF_REAL *real_width) { HPDF_TextLineWidth tlw; HPDF_UINT lines; HPDF_PTRACE ((" HPDF_Font_MeasureText\n")); lines = HPDF_Font_MeasureTextLines (font, (const char *)text, len, width, font_size, char_space, word_space, options, &tlw, 1); if (!lines) return 0; if (real_width) *real_width = tlw.width; return tlw.linebytes; } HPDF_EXPORT(HPDF_UINT) HPDF_Font_MeasureTextLines (HPDF_Font font, const char *text, HPDF_UINT len, HPDF_REAL line_width, HPDF_REAL font_size, HPDF_REAL char_space, HPDF_REAL word_space, HPDF_INT options, HPDF_TextLineWidth *width, HPDF_UINT max_lines) { HPDF_FontAttr attr; HPDF_UINT line, begin, cvt_len; HPDF_REAL margin; HPDF_PTRACE ((" HPDF_Font_MeasureTextLines\n")); if (!HPDF_Font_Validate(font) || !text || !width) return 0; if (len > HPDF_LIMIT_MAX_STRING_LEN) { HPDF_RaiseError (font->error, HPDF_STRING_OUT_OF_RANGE, 0); return 0; } attr = (HPDF_FontAttr)font->attr; if (!attr->char_width_fn) { HPDF_RaiseError (font->error, HPDF_INVALID_OBJECT, 0); return 0; } margin = 1.25F; /* margin 25% */ do { /* estimate result length and convert only the length+margin */ HPDF_UINT cache_begin, cache_end; HPDF_REAL w = 0; if (!attr->width_per_byte) /* expect average width is missing_width/2 */ attr->width_per_byte = (HPDF_REAL)attr->fontdef->missing_width / 2 / MINBYTES[GetSourceCharEnc (font)]; cvt_len = (HPDF_UINT)(line_width * max_lines / font_size * 1000 * margin / attr->width_per_byte); if (len < cvt_len) cvt_len = len; if (HPDF_Font_ConvertText (font, HPDF_CONVERT_HOLD_CHARACTERS, text, cvt_len) != HPDF_OK) return 0; for (begin = 0, cache_begin = 0, line = 0; line < max_lines && begin < cvt_len && !(line && (width[line - 1].flags & HPDF_TLW_PAGE_BREAK)); line++) { MeasureTextCache (font, line_width, font_size, char_space, word_space, options, cache_begin, width + line); w += width[line].width; if (line_width < width[line].width) width[line].flags |= HPDF_TLW_SHORTEN; cache_end = cache_begin + width[line].linebytes; GetUncovertedBytes (font, text + begin, cache_begin, width + line); begin += width[line].linebytes; cache_begin = cache_end; } if (8 < begin) /* ignore too short sample */ attr->width_per_byte = w / font_size * 1000 / begin; margin += 0.25F; /* margin +25% */ } while (cvt_len <= begin + 4 && cvt_len < len); /* while misestimate */ return line; } static HPDF_UINT MeasureTextCache (HPDF_Font font, HPDF_REAL line_width, HPDF_REAL font_size, HPDF_REAL char_space, HPDF_REAL word_space, HPDF_INT options, HPDF_UINT cache_begin, HPDF_TextLineWidth *width) { HPDF_FontAttr attr; HPDF_REAL w; HPDF_REAL v; HPDF_UINT nch, nsp, ntt; HPDF_UINT len, tmp_len, i; HPDF_BOOL can_break = HPDF_FALSE; HPDF_BYTE *text; HPDF_BYTE *pirf; HPDF_REAL hyphen_w = 0; HPDF_UINT bytes; HPDF_UINT tw; HPDF_PTRACE ((" MeasureTextEx\n")); attr = (HPDF_FontAttr)font->attr; text = attr->text_cache + cache_begin; pirf = attr->text_cache + cache_begin + (attr->text_cache_allocated / 2); len = attr->text_cache_len - cache_begin; HPDF_MemSet (width, 0, sizeof *width); tmp_len = 0; nch = nsp = ntt = 0; tw = 0; w = v = 0; for (i = 0; i < len; i += bytes) { HPDF_REAL tmp_w; HPDF_UCS4 b; HPDF_BYTE irf; HPDF_INT cw; irf = pirf[i] & HPDF_RELIEF_FONT_INDEX_MASK; cw = attr->char_width_fn (font, HPDF_TRUE, irf, text+i, &bytes, &b); if (pirf[i] & HPDF_INTERLINEAR_ANNOTATION) continue; if (HPDF_IS_WHITE_SPACE(b) || b == 0x200B /* ZWSP */) { width->linebytes = i + bytes; width->numbytes = i; width->numchars = nch; width->numspaces = nsp; width->numtatweels = ntt; width->charswidth = tw; width->width = w; if (b == 0x0A || b == 0x0D) return (width->flags |= HPDF_TLW_PRAGRAPH_BREAK); if (b == 0x0C) return (width->flags |= HPDF_TLW_PAGE_BREAK); if (line_width < w) return (width->flags |= HPDF_TLW_WORD_WRAP); if (b != 0x20) { /* TAB, ZWSP */ continue; } else if (bytes == 1 && !IsCIDText (font, irf)) { nsp++; w += word_space; } } else if (b == 0xAD) { /* SHY */ tmp_w = 0; if (options & HPDF_MEASURE_WORD_WRAP) { if (!hyphen_w) { HPDF_BYTE hyphen[8] = {'-'}; if (attr->encoder->charenc != HPDF_CHARENC_UNSUPPORTED) UCS4TO_FNS[attr->encoder->charenc] (hyphen, '-'); cw = attr->char_width_fn (font, HPDF_TRUE, 0, hyphen, 0, 0); hyphen_w = (HPDF_REAL)cw * font_size / 1000; hyphen_w += char_space; } tmp_w = hyphen_w; if (line_width < v + tmp_w || (!(options & HPDF_MEASURE_CAN_SHORTEN) && line_width < w + tmp_w)) return (width->flags |= HPDF_TLW_WORD_WRAP); } width->linebytes = i + bytes; width->numbytes = i + bytes; width->numchars = nch; width->numspaces = nsp; width->numtatweels = ntt; width->charswidth = tw + cw; width->width = w + tmp_w; if (line_width < w + tmp_w) return (width->flags |= (HPDF_TLW_WORD_WRAP | HPDF_TLW_HYPHENATION)); continue; } else if ((b <= 0x001F) || (0x007F <= b && b <= 0x009F) || (0x200C <= b && b <= 0x200F) || (0x202A <= b && b <= 0x202E) || (0xFE00 <= b && b <= 0xFE0F) || (0xFEFF == b) || (0xFFF0 <= b && b <= 0xFFFF)) { /* control codes */ continue; } else if (!(options & HPDF_MEASURE_WORD_WRAP) || (!(pirf[i] & HPDF_INTERLINEAR_ANNOTATED) && can_break && CanBreakBefore (b))) { width->linebytes = i; width->numbytes = i; width->numchars = nch; width->numspaces = nsp; width->numtatweels = ntt; width->charswidth = tw; width->width = w; if (line_width < w) return width->flags; } if ((options & HPDF_MEASURE_WORD_WRAP) && (attr->type == HPDF_FONT_TYPE0_CID || attr->type == HPDF_FONT_TYPE0_TT)) can_break = CanBreakAfter (b); tmp_w = (HPDF_REAL)cw * font_size / 1000; if (b == 0x0640) { /* Arabic tatweel */ ntt++; if (options & HPDF_MEASURE_IGNORE_TATWEEL) { width->flags |= HPDF_TLW_IGNORE_TATWEEL; } else { nch++; tw += cw; w += tmp_w; if (0 < i) w += char_space; } } else { nch++; tw += cw; w += tmp_w; v += tmp_w; if (0 < i) w += char_space; } if (line_width < v || (!(options & HPDF_MEASURE_CAN_SHORTEN) && line_width < w)) return (width->flags |= HPDF_TLW_WORD_WRAP); } /* all of text can be put in the specified width */ width->linebytes = i; width->numbytes = i; width->numchars = nch; width->numspaces = nsp; width->numtatweels = ntt; width->charswidth = tw; width->width = w; return width->flags; } static HPDF_BOOL CanBreakAfter (HPDF_UCS4 b) { return ((0x03000 <= b && b <= 0x03007) || (0x03008 <= b && b <= 0x0301B && (b & 1)) || (0x0301C == b) || (0x0301E <= b && b <= 0x09FFF) || (0x0AC00 <= b && b <= 0x0D7AF) || (0x0F900 <= b && b <= 0x0FAFF) || (0x20000 <= b && b <= 0x2FFFF)); } static HPDF_BOOL CanBreakBefore (HPDF_UCS4 b) { if (0x030A1 <= b && b <= 0x030F6) b -= 0x030A1 - 0x03041; else if (0x0FF01 <= b && b <= 0x0FF5E) b -= 0x0FF01 - 0x00021; return !(('!' == b) || (')' == b) || (',' == b) || ('-' == b) || ('.' == b) || (':' == b) || (';' == b) || ('=' == b) || ('?' == b) || (']' == b) || ('}' == b) || (0x03001 <= b && b <= 0x03005) || (0x03008 <= b && b <= 0x0301B && (b & 1)) || (0x0301F == b) || (0x03031 <= b && b <= 0x03035) || (0x03041 <= b && b <= 0x0304A && (b & 1)) || (0x03063 == b) || (0x03083 == b) || (0x03085 == b) || (0x03087 == b) || (0x0308E == b) || (0x03095 == b) || (0x03096 == b) || (0x03099 <= b && b <= 0x0309E) || (0x030FB <= b && b <= 0x030FE) || (0x0FF60 == b) || (0x0FF61 == b) || (0x0FF63 <= b && b <= 0x0FF65) || (0x0FF66 <= b && b <= 0x0FF70) || (0x0FF9E == b) || (0x0FF9F == b)); } HPDF_EXPORT(const char*) HPDF_Font_GetFontName (HPDF_Font font) { HPDF_FontAttr attr; HPDF_PTRACE((" HPDF_Font_GetFontName\n")); if (!HPDF_Font_Validate(font)) return NULL; attr = (HPDF_FontAttr)font->attr; return attr->fontdef->base_font; } HPDF_EXPORT(const char*) HPDF_Font_GetEncodingName (HPDF_Font font) { HPDF_FontAttr attr; HPDF_PTRACE((" HPDF_Font_GetEncodingName\n")); if (!HPDF_Font_Validate(font)) return NULL; attr = (HPDF_FontAttr)font->attr; return attr->encoder->name; } HPDF_EXPORT(HPDF_INT) HPDF_Font_GetUnicodeWidth (HPDF_Font font, HPDF_UNICODE code) { HPDF_PTRACE((" HPDF_Font_GetUnicodeWidth\n")); return HPDF_Font_GetUcs4Width (font, code); } HPDF_EXPORT(HPDF_INT) HPDF_Font_GetUcs4Width (HPDF_Font font, HPDF_UCS4 ucs4) { HPDF_FontAttr attr; HPDF_FontDef fontdef; HPDF_PTRACE((" HPDF_Font_GetUcs4Width\n")); if (!HPDF_Font_Validate(font)) return 0; if (!(font = HPDF_Font_GetReliefFont (font, ucs4, NULL))) return 0; attr = (HPDF_FontAttr)font->attr; fontdef = attr->fontdef; if (fontdef->type == HPDF_FONTDEF_TYPE_TYPE1) { return HPDF_Type1FontDef_GetWidth (fontdef, ucs4); } else if (fontdef->type == HPDF_FONTDEF_TYPE_TRUETYPE) { return HPDF_TTFontDef_GetCharWidth (fontdef, ucs4); } else if (fontdef->type == HPDF_FONTDEF_TYPE_CID) { HPDF_CID cid = HPDF_CMapEncoder_ToCID(attr->encoder, ucs4); if (0 < cid) return HPDF_CIDFontDef_GetCIDWidth (fontdef, cid); } HPDF_PTRACE((" HPDF_Font_GetUcs4Width not found (0x%08X)\n", ucs4)); return 0; } HPDF_EXPORT(HPDF_INT) HPDF_Font_GetCharWidth (HPDF_Font font, const char *text, HPDF_UINT *bytes, HPDF_UCS4 *ucs4) { HPDF_FontAttr attr; HPDF_PTRACE((" HPDF_Font_GetCharWidth\n")); if (!HPDF_Font_Validate(font) || !text) return 0; attr = (HPDF_FontAttr)font->attr; return attr->char_width_fn (font, HPDF_FALSE, 0, text, bytes, ucs4); } HPDF_EXPORT(HPDF_Box) HPDF_Font_GetBBox (HPDF_Font font) { HPDF_Box bbox = {0, 0, 0, 0}; HPDF_PTRACE((" HPDF_Font_GetBBox\n")); if (HPDF_Font_Validate(font)) return ((HPDF_FontAttr)font->attr)->fontdef->font_bbox; return bbox; } HPDF_EXPORT(HPDF_INT) HPDF_Font_GetAscent (HPDF_Font font) { HPDF_PTRACE((" HPDF_Font_GetAscent\n")); if (HPDF_Font_Validate(font)) return ((HPDF_FontAttr)font->attr)->fontdef->ascent; return 0; } HPDF_EXPORT(HPDF_INT) HPDF_Font_GetDescent (HPDF_Font font) { HPDF_PTRACE((" HPDF_Font_GetDescent\n")); if (HPDF_Font_Validate(font)) return ((HPDF_FontAttr)font->attr)->fontdef->descent; return 0; } HPDF_EXPORT(HPDF_UINT) HPDF_Font_GetXHeight (HPDF_Font font) { HPDF_PTRACE((" HPDF_Font_GetXHeight\n")); if (HPDF_Font_Validate(font)) return ((HPDF_FontAttr)font->attr)->fontdef->x_height; return 0; } HPDF_EXPORT(HPDF_UINT) HPDF_Font_GetCapHeight (HPDF_Font font) { HPDF_PTRACE((" HPDF_Font_GetCapHeight\n")); if (HPDF_Font_Validate(font)) return ((HPDF_FontAttr)font->attr)->fontdef->cap_height; return 0; } HPDF_BOOL HPDF_Font_Validate (HPDF_Font font) { HPDF_PTRACE((" HPDF_Font_Validate\n")); if (!font || !font->attr || font->header.obj_class != (HPDF_OSUBCLASS_FONT | HPDF_OCLASS_DICT)) return HPDF_FALSE; return HPDF_TRUE; } static HPDF_CharEnc GetSourceCharEnc (HPDF_Font font) { HPDF_FontAttr attr; HPDF_List list; HPDF_Converter converter; HPDF_CharEnc charenc; HPDF_PTRACE ((" GetSourceCharEnc\n")); attr = (HPDF_FontAttr)font->attr; list = attr->converters_list[attr->converters_index]; if (list && list->count) { converter = (HPDF_Converter)HPDF_List_ItemAt (list, list->count - 1); charenc = converter->src_charenc; } else { if (!attr->text_cache) HPDF_NormalizeCharEnc (&attr->encoder->charenc); charenc = attr->encoder->charenc; } return charenc; } HPDF_UINT HPDF_Font_StrLen (HPDF_Font font, const char *s, HPDF_INT maxlen) { HPDF_INT i, min, len; HPDF_PTRACE ((" HPDF_Font_StrLen\n")); if (!s) return 0; min = MINBYTES[GetSourceCharEnc (font)]; len = 0; while (maxlen < 0 || len < maxlen) { for (i = 0; i < min && s[i] == 0; i++) ; if (i == min) break; s += min; len += min; } return (HPDF_UINT)len; } #ifdef LIBHPDF_ENABLE_BIDI typedef struct _HPDF_ConverterBiDi_Rec *HPDF_ConverterBiDi; typedef struct _HPDF_ConverterBiDi_Rec { HPDF_Converter_Rec hdr; HPDF_ConverterBiDi_Param_Rec *par; HPDF_Alloc_Func alloc_fn; HPDF_Free_Func free_fn; HPDF_UINT dst_tatweels; HPDF_UINT src_tatweels; } HPDF_ConverterBiDi_Rec; static void BiDi_FreeArrays (HPDF_ConverterBiDi bidi) { if (bidi->par->bidi_types) bidi->free_fn (bidi->par->bidi_types); if (bidi->par->ar_props) bidi->free_fn (bidi->par->ar_props); if (bidi->par->embedding_levels) bidi->free_fn (bidi->par->embedding_levels); if (bidi->par->positions_L_to_V) bidi->free_fn (bidi->par->positions_L_to_V); if (bidi->par->positions_V_to_L) bidi->free_fn (bidi->par->positions_V_to_L); bidi->par->bidi_types = NULL; bidi->par->ar_props = NULL; bidi->par->embedding_levels = NULL; bidi->par->positions_L_to_V = NULL; bidi->par->positions_V_to_L = NULL; bidi->par->max_chars = 0; } static HPDF_UINT HPDF_STDCALL BiDi (HPDF_Converter converter, HPDF_UINT32 flags, const HPDF_BYTE *src, HPDF_UINT src_bytes, HPDF_BYTE *dst) { HPDF_ConverterBiDi bidi = (HPDF_ConverterBiDi)converter; const HPDF_UCS4 *s = (const HPDF_UCS4 *)src; HPDF_UINT len = src_bytes / sizeof (HPDF_UCS4); HPDF_UCS4 *d = (HPDF_UCS4 *)dst; if (bidi->par->max_chars < len) { HPDF_UINT32 max_chars = bidi->par->max_chars; if (!max_chars) max_chars = HPDF_TEXT_DEFAULT_LEN / sizeof (HPDF_UCS4); while (max_chars < len) max_chars *= 2; BiDi_FreeArrays (bidi); bidi->par->bidi_types = bidi->alloc_fn (max_chars * sizeof bidi->par->bidi_types[0]); bidi->par->ar_props = bidi->alloc_fn (max_chars * sizeof bidi->par->ar_props[0]); bidi->par->embedding_levels = bidi->alloc_fn (max_chars * sizeof bidi->par->embedding_levels[0]); bidi->par->positions_L_to_V = bidi->alloc_fn (max_chars * sizeof bidi->par->positions_L_to_V[0]); bidi->par->positions_V_to_L = bidi->alloc_fn (max_chars * sizeof bidi->par->positions_V_to_L[0]); if (!bidi->par->bidi_types || !bidi->par->ar_props || !bidi->par->embedding_levels || !bidi->par->positions_L_to_V || !bidi->par->positions_V_to_L) return 0; bidi->par->max_chars = max_chars; } fribidi_get_bidi_types (s, len, (FriBidiCharType *)bidi->par->bidi_types); fribidi_get_par_embedding_levels ((FriBidiCharType *)bidi->par->bidi_types, len, (FriBidiParType *)&bidi->par->base_dir, bidi->par->embedding_levels); HPDF_MemCpy (dst, src, src_bytes); /* Arabic joining */ fribidi_get_joining_types (s, len, bidi->par->ar_props); fribidi_join_arabic ((FriBidiCharType *)bidi->par->bidi_types, len, bidi->par->embedding_levels, bidi->par->ar_props); fribidi_shape ((FRIBIDI_FLAGS_DEFAULT | FRIBIDI_FLAGS_ARABIC), bidi->par->embedding_levels, len, bidi->par->ar_props, d); if (!(flags & HPDF_CONVERT_HOLD_CHARACTERS)) { HPDF_UINT i; for (i = 0; i < len; i++) bidi->par->positions_V_to_L[i] = i; fribidi_reorder_line ((FRIBIDI_FLAGS_DEFAULT | FRIBIDI_FLAGS_ARABIC), (FriBidiCharType *)bidi->par->bidi_types, len, 0, (FriBidiParType)bidi->par->base_dir, bidi->par->embedding_levels, d, bidi->par->positions_V_to_L); if (bidi->dst_tatweels < bidi->src_tatweels) { s = d; for (i = 0; i < len; i++) { if (!bidi->src_tatweels || *s != 0x0640) { *d++ = *s++; } else { HPDF_UINT ntt = bidi->dst_tatweels / bidi->src_tatweels; s++; bidi->src_tatweels--; while (ntt-- && bidi->dst_tatweels) { *d++ = 0x0640; bidi->dst_tatweels--; } } } len = (HPDF_UINT)(d - (HPDF_UCS4 *)dst); } else if (bidi->src_tatweels < bidi->dst_tatweels) { s = d + len; len += bidi->dst_tatweels - bidi->src_tatweels; d += len; while ((HPDF_UCS4 *)dst < d) { if (!bidi->src_tatweels || s[-1] != 0x0640) { *--d = *--s; } else { HPDF_UINT ntt = bidi->dst_tatweels / bidi->src_tatweels; --s; bidi->src_tatweels--; while (ntt-- && bidi->dst_tatweels && (HPDF_UCS4 *)dst < d) { *--d = 0x0640; bidi->dst_tatweels--; } } } } } bidi->src_tatweels = bidi->dst_tatweels = 0; bidi->hdr.chars_factor = 1; return len * sizeof (HPDF_UCS4); } static void HPDF_STDCALL BiDi_Delete (HPDF_Converter converter, HPDF_Free_Func free_fn) { HPDF_ConverterBiDi bidi = (HPDF_ConverterBiDi)converter; HPDF_PTRACE((" BiDi_Delete\n")); BiDi_FreeArrays (bidi); free_fn (bidi); } static HPDF_Converter HPDF_STDCALL BiDi_New (HPDF_Alloc_Func alloc_fn, HPDF_Free_Func free_fn, void *param) { HPDF_ConverterBiDi_Param_Rec *par; HPDF_ConverterBiDi bidi; HPDF_UINT size; HPDF_PTRACE((" BiDi_New\n")); par = (HPDF_ConverterBiDi_Param_Rec *)param; bidi = 0; size = sizeof *bidi; if (!par) size += sizeof *par; bidi = (HPDF_ConverterBiDi)alloc_fn (size); if (!bidi) return NULL; HPDF_MemSet (bidi, 0, size); if (par) { HPDF_MemSet (par, 0, sizeof *par); bidi->par = par; } else { bidi->par = (HPDF_ConverterBiDi_Param_Rec *)(bidi + 1); } bidi->hdr.convert_fn = BiDi; bidi->hdr.delete_fn = BiDi_Delete; bidi->hdr.src_charenc = HPDF_CHARENC_UCS4; bidi->hdr.dst_charenc = HPDF_CHARENC_UCS4; bidi->hdr.bytes_factor = 1; bidi->hdr.chars_factor = 1; bidi->par->base_dir = 0x111; /* Letter strong RTL */ bidi->alloc_fn = alloc_fn; bidi->free_fn = free_fn; return &bidi->hdr; } #endif /* LIBHPDF_ENABLE_BIDI */ static HPDF_UINT HPDF_STDCALL EncConv (HPDF_Converter converter, HPDF_UINT32 flags, const HPDF_BYTE *src, HPDF_UINT src_bytes, HPDF_BYTE *dst) { HPDF_UINT dst_bytes, bytes, i; HPDF_UCS4 ucs4; HPDF_UTFBytes_Func bytes_fn = BYTES_FNS[converter->src_charenc]; HPDF_UTFToUcs4_Func toucs4_fn = TOUCS4_FNS[converter->src_charenc]; HPDF_Ucs4ToUTF_Func ucs4to_fn = UCS4TO_FNS[converter->dst_charenc]; HPDF_UNUSED (flags); dst_bytes = 0; i = 0; while (i < src_bytes) { bytes = bytes_fn (src + i); if (src_bytes < i + bytes) break; ucs4 = toucs4_fn (src + i, bytes); i += bytes; dst_bytes += ucs4to_fn (dst + dst_bytes, ucs4); } return dst_bytes; } static HPDF_UINT HPDF_STDCALL Swap16 (HPDF_Converter converter, HPDF_UINT32 flags, const HPDF_BYTE *src, HPDF_UINT src_bytes, HPDF_BYTE *dst) { HPDF_INT i; HPDF_UNUSED (converter); HPDF_UNUSED (flags); for (i = 0; i < (HPDF_INT)src_bytes - 1; i += 2) { dst[i + 0] = src[i + 1]; dst[i + 1] = src[i + 0]; } return src_bytes; } static HPDF_UINT HPDF_STDCALL Swap32 (HPDF_Converter converter, HPDF_UINT32 flags, const HPDF_BYTE *src, HPDF_UINT src_bytes, HPDF_BYTE *dst) { HPDF_INT i; HPDF_UNUSED (converter); HPDF_UNUSED (flags); for (i = 0; i < (HPDF_INT)src_bytes - 3; i += 4) { dst[i + 0] = src[i + 3]; dst[i + 1] = src[i + 2]; dst[i + 2] = src[i + 1]; dst[i + 3] = src[i + 0]; } return src_bytes; } static HPDF_Converter_Convert_Func ENCCONV_FNS[6][6] = { /* dst: UTF8 UTF16BE UTF32BE UTF16LE UTF32LE */ { NULL, NULL, NULL, NULL, NULL, NULL, }, /* src: */ { NULL, NULL, EncConv, EncConv, EncConv, EncConv, }, /* UTF8 */ { NULL, EncConv, NULL, EncConv, Swap16, EncConv, }, /* UTF16BE */ { NULL, EncConv, EncConv, NULL, EncConv, Swap32, }, /* UTF32BE */ { NULL, EncConv, Swap16, EncConv, NULL, EncConv, }, /* UTF16LE */ { NULL, EncConv, EncConv, Swap32, EncConv, NULL, }, /* UTF32LE */ }; static const HPDF_UINT8 ENCCONV_FCTS[6][6] = { /* dst: UTF8 UTF16BE UTF32BE UTF16LE UTF32LE */ { 1, 1, 1, 1, 1, 1, }, /* src: */ { 1, 1, 2, 4, 2, 4, }, /* UTF8 */ { 1, 2, 1, 2, 1, 2, }, /* UTF16BE */ { 1, 1, 1, 1, 1, 1, }, /* UTF32BE */ { 1, 2, 1, 2, 1, 2, }, /* UTF16LE */ { 1, 1, 1, 1, 1, 1, }, /* UTF32LE */ }; static struct _HPDF_BuiltInConverter_Rec { char name[8]; HPDF_Converter_New_Func new_fn; } BUILTIN[] = { #ifdef LIBHPDF_ENABLE_BIDI { "BiDi", BiDi_New, }, #endif { "", NULL, }, }; typedef struct _HPDF_ConverterEnc_Param_Rec { HPDF_CharEnc src_charenc; HPDF_CharEnc dst_charenc; } HPDF_ConverterEnc_Param_Rec; static void HPDF_STDCALL EncConv_Delete (HPDF_Converter converter, HPDF_Free_Func free_fn) { HPDF_PTRACE((" EncConv_Delete\n")); free_fn (converter); } static HPDF_Converter HPDF_STDCALL EncConv_New (HPDF_Alloc_Func alloc_fn, HPDF_Free_Func free_fn, void *param) { HPDF_Converter converter; const HPDF_ConverterEnc_Param_Rec *par; HPDF_PTRACE((" EncConv_New\n")); if (!(converter = (HPDF_Converter)alloc_fn (sizeof (HPDF_Converter_Rec)))) return NULL; par = (const HPDF_ConverterEnc_Param_Rec *)param; converter->convert_fn = ENCCONV_FNS[par->src_charenc][par->dst_charenc]; converter->delete_fn = EncConv_Delete; converter->src_charenc = par->src_charenc; converter->dst_charenc = par->dst_charenc; converter->bytes_factor = ENCCONV_FCTS[par->src_charenc][par->dst_charenc]; converter->chars_factor = 1; return converter; } HPDF_EXPORT(HPDF_STATUS) HPDF_Font_SelectConverters (HPDF_Font font, HPDF_INT index) { HPDF_FontAttr attr; HPDF_PTRACE((" HPDF_Font_SelectConverters\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; if (index < 0) index = 0; else if (HPDF_MAX_CONVERTERS < index) index = HPDF_MAX_CONVERTERS; attr = (HPDF_FontAttr)font->attr; attr->converters_index = index; return HPDF_OK; } HPDF_EXPORT(HPDF_STATUS) HPDF_Font_SetCharacterEncoding (HPDF_Font font, HPDF_CharEnc charenc) { HPDF_ConverterEnc_Param_Rec param; HPDF_STATUS ret; HPDF_PTRACE((" HPDF_Font_SetCharacterEncoding\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; HPDF_NormalizeCharEnc (&charenc); param.src_charenc = charenc; param.dst_charenc = GetSourceCharEnc (font); if (param.src_charenc == HPDF_CHARENC_UNSUPPORTED || param.dst_charenc == HPDF_CHARENC_UNSUPPORTED) return HPDF_RaiseError (font->error, HPDF_NOT_UTF_ENCODING, 0); if (param.src_charenc == param.dst_charenc) return HPDF_OK; ret = HPDF_Font_PushConverter (font, EncConv_New, ¶m); return ret; } HPDF_EXPORT(HPDF_STATUS) HPDF_Font_PushConverter (HPDF_Font font, HPDF_Converter_New_Func new_fn, void *param) { HPDF_FontAttr attr; HPDF_List list; HPDF_Converter converter; HPDF_STATUS ret; HPDF_PTRACE((" HPDF_Font_PushConverter\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; attr = (HPDF_FontAttr)font->attr; list = attr->converters_list[attr->converters_index]; if (!list) { list = HPDF_List_New (font->mmgr, HPDF_DEF_ITEMS_PER_BLOCK); if (!list) return HPDF_CheckError (font->error); attr->converters_list[attr->converters_index] = list; } converter = new_fn (font->mmgr->alloc_fn, font->mmgr->free_fn, param); if (!converter) return HPDF_RaiseError (font->error, HPDF_FAILD_TO_NEW_CONVERTER, 0); HPDF_NormalizeCharEnc (&converter->src_charenc); HPDF_NormalizeCharEnc (&converter->dst_charenc); if ((ret = HPDF_Font_SetCharacterEncoding (font, converter->dst_charenc)) != HPDF_OK) { converter->delete_fn (converter, font->mmgr->free_fn); return ret; } if ((ret = HPDF_List_Add (list, converter)) != HPDF_OK) { converter->delete_fn (converter, font->mmgr->free_fn); return HPDF_RaiseError (font->error, ret, 0); } return HPDF_OK; } HPDF_EXPORT(HPDF_STATUS) HPDF_Font_PushBuiltInConverter (HPDF_Font font, const char *name, void *param) { HPDF_UINT i; HPDF_PTRACE((" HPDF_Font_PushBuiltInConverter\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; for (i = 0; BUILTIN[i].name[0]; i++) if (HPDF_StrCmp (name, BUILTIN[i].name) == 0) break; if (!BUILTIN[i].name[0]) return HPDF_RaiseError (font->error, HPDF_CONVERTER_NOT_FOUND, 0); return HPDF_Font_PushConverter (font, BUILTIN[i].new_fn, param); } void HPDF_Font_FreeConvertersListAll (HPDF_Font font) { HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; HPDF_INT i, j; HPDF_PTRACE((" HPDF_Font_FreeConvertersListAll\n")); if (!attr) return; if (attr->text_cache) HPDF_FreeMem (font->mmgr, attr->text_cache); attr->text_cache = NULL; attr->text_cache_len = 0; attr->text_cache_allocated = 0; HPDF_MemSet (&attr->tw_cache, 0, sizeof attr->tw_cache); for (i = 0; i <= HPDF_MAX_CONVERTERS; i++) { HPDF_List list = attr->converters_list[i]; if (!list) continue; for (j = list->count - 1; 0 <= j; --j) { HPDF_Converter converter; converter = (HPDF_Converter)HPDF_List_ItemAt (list, j); converter->delete_fn (converter, font->mmgr->free_fn); } HPDF_List_Free (list); attr->converters_list[i] = NULL; } } HPDF_STATUS HPDF_Font_ConvertText (HPDF_Font font, HPDF_UINT32 flags, const char *text, HPDF_UINT len) { HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; HPDF_List list; HPDF_Converter converter; HPDF_UINT bytes_factor, chars_factor, allocated, i; HPDF_BYTE *dst; HPDF_PTRACE((" HPDF_Font_ConvertText\n")); if (!text) return HPDF_OK; if (!len) len = HPDF_Font_StrLen(font, text, HPDF_LIMIT_MAX_STRING_LEN + 1); if (!attr->text_cache) HPDF_NormalizeCharEnc (&attr->encoder->charenc); attr->text_cache_len = 0; HPDF_MemSet (&attr->tw_cache, 0, sizeof attr->tw_cache); list = attr->converters_list[attr->converters_index]; bytes_factor = 1; chars_factor = 1; if (list && list->count) { for (i = 0; i < (HPDF_INT)list->count; i++) { converter = (HPDF_Converter)HPDF_List_ItemAt (list, i); if (bytes_factor < converter->bytes_factor) bytes_factor = converter->bytes_factor; chars_factor *= converter->chars_factor; } } attr->text_cache_len = len; len *= bytes_factor; len *= chars_factor; len *= 2; allocated = attr->text_cache_allocated; if (!attr->text_cache_allocated) attr->text_cache_allocated = HPDF_TEXT_DEFAULT_LEN; while (attr->text_cache_allocated < len) attr->text_cache_allocated *= 2; if (attr->text_cache_allocated != allocated) { if (attr->text_cache) HPDF_FreeMem (font->mmgr, attr->text_cache); attr->text_cache = HPDF_GetMem (font->mmgr, attr->text_cache_allocated); if (!attr->text_cache) return HPDF_CheckError (font->error); } /* do convert */ if (!list || list->count <= 0) { HPDF_MemCpy (attr->text_cache, text, attr->text_cache_len); text = (char *)(dst = attr->text_cache); } else { for (i = list->count; i--;) { dst = attr->text_cache; if (i & 1) dst += (attr->text_cache_allocated / 2); converter = (HPDF_Converter)HPDF_List_ItemAt (list, i); attr->text_cache_len = converter->convert_fn (converter, flags, text, attr->text_cache_len, dst); text = (char *)dst; } } /* set relief font index */ if (attr->relief_font) SetReliefFontIndex (font); /* remove control character */ if (!(flags & HPDF_CONVERT_HOLD_CHARACTERS)) { HPDF_UINT bytes; HPDF_UCS4 b = 0; HPDF_UINT irfofs = attr->text_cache_allocated / 2; for (i = 0; i < attr->text_cache_len;) { b = HPDF_Encoder_GetUcs4 (attr->encoder, (const HPDF_BYTE *)text, &bytes); if (!bytes) bytes = 1; i += bytes; if ((b <= 0x001F) || (0x007F <= b && b <= 0x009F) || (b == 0x00AD) || (0x200B <= b && b <= 0x200F) || (0x202A <= b && b <= 0x202E) || (0xFE00 <= b && b <= 0xFE0F) || (0xFEFF == b) || (0xFFF0 <= b && b <= 0xFFFF)) /* control codes */ text += bytes; else while (bytes--) { dst[irfofs] = ((const HPDF_BYTE *)text)[irfofs]; *dst++ = *(const HPDF_BYTE *)text++; } } if (b == 0x00AD) { HPDF_BYTE irf; HPDF_Font_GetReliefFont (font, '-', &irf); bytes = 1; if (attr->encoder->charenc == HPDF_CHARENC_UNSUPPORTED || attr->encoder->charenc == HPDF_CHARENC_UTF8) *dst = '-'; else bytes = UCS4TO_FNS[attr->encoder->charenc] (dst, '-'); while (bytes--) (dst++)[irfofs] = irf; } attr->text_cache_len = (HPDF_UINT)(dst - attr->text_cache); } return HPDF_OK; } static HPDF_UINT GetUncovertedBytes (HPDF_Font font, const char *text, HPDF_UINT cache_begin, HPDF_TextLineWidth *width) { HPDF_FontAttr attr; HPDF_CharEnc src_charenc; HPDF_CharEnc dst_charenc; HPDF_UINT i, j, numbytes; attr = (HPDF_FontAttr)font->attr; dst_charenc = attr->encoder->charenc; if (dst_charenc == HPDF_CHARENC_UNSUPPORTED) return width->linebytes; src_charenc = GetSourceCharEnc (font); i = j = numbytes = 0; while (i < width->linebytes) { i += BYTES_FNS[dst_charenc] (attr->text_cache + cache_begin + i); j += BYTES_FNS[src_charenc] ((const HPDF_BYTE *)text + j); if (width->numbytes == i) numbytes = j; } width->numbytes = numbytes; width->linebytes = j; return j; } HPDF_BOOL HPDF_Font_IsRtL (HPDF_Font font) { HPDF_BOOL ret = HPDF_FALSE; HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; HPDF_List list = attr->converters_list[attr->converters_index]; HPDF_PTRACE ((" HPDF_Font_IsRtL\n")); #ifdef LIBHPDF_ENABLE_BIDI if (list) { HPDF_UINT i; HPDF_ConverterBiDi bidi; for (i = 0; i < list->count; i++) { bidi = (HPDF_ConverterBiDi)HPDF_List_ItemAt (list, i); if (bidi->hdr.convert_fn == BiDi) { ret = ((bidi->par->base_dir & FRIBIDI_MASK_RTL) != 0); break; } } } #endif return ret; } void HPDF_Font_CheckBiDi (HPDF_Font font, HPDF_BOOL even_users) { HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; HPDF_List list = attr->converters_list[attr->converters_index]; HPDF_PTRACE ((" HPDF_Font_CheckBiDi\n")); #ifdef LIBHPDF_ENABLE_BIDI if (list) { HPDF_UINT i; HPDF_ConverterBiDi bidi; for (i = 0; i < list->count; i++) { bidi = (HPDF_ConverterBiDi)HPDF_List_ItemAt (list, i); if (bidi->hdr.convert_fn == BiDi) { if (even_users || bidi->par == (HPDF_ConverterBiDi_Param_Rec *)(bidi + 1)) bidi->par->base_dir = 0; break; } } } #endif } HPDF_EXPORT(HPDF_STATUS) HPDF_Font_SetTatweelCount (HPDF_Font font, HPDF_UINT dst_tatweels, HPDF_UINT src_tatweels, HPDF_UINT numchars) { HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; HPDF_List list = attr->converters_list[attr->converters_index]; HPDF_PTRACE ((" HPDF_Font_SetTatweelCount\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; #ifdef LIBHPDF_ENABLE_BIDI if (list) { HPDF_UINT i; HPDF_ConverterBiDi bidi; for (i = 0; i < list->count; i++) { bidi = (HPDF_ConverterBiDi)HPDF_List_ItemAt (list, i); if (bidi->hdr.convert_fn == BiDi) { bidi->dst_tatweels = dst_tatweels; bidi->src_tatweels = src_tatweels; bidi->hdr.chars_factor = (numchars - 1 + numchars + dst_tatweels - src_tatweels) / numchars; if (!bidi->hdr.chars_factor) bidi->hdr.chars_factor = 1; break; } } } #endif return HPDF_OK; } void HPDF_Font_SetParseText (HPDF_Font font, HPDF_ParseText_Rec *state, const char *text, HPDF_UINT len) { HPDF_FontAttr attr; HPDF_PTRACE ((" HPDF_Font_SetParseText\n")); attr = (HPDF_FontAttr)font->attr; HPDF_Encoder_SetParseText (attr->encoder, state, (const HPDF_BYTE *)text, len); state->charenc = GetSourceCharEnc (font); } HPDF_EXPORT(HPDF_ByteType) HPDF_Font_GetByteType (HPDF_Font font, const char *text, HPDF_UINT index) { HPDF_Encoder encoder; HPDF_ParseText_Rec parse_state; HPDF_ByteType btype; HPDF_UINT bytes; HPDF_PTRACE ((" HPDF_Font_GetByteType\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; if (HPDF_Font_StrLen (font, text, index + 4) < index) return HPDF_BYTE_TYPE_UNKNOWN; encoder = ((HPDF_FontAttr)font->attr)->encoder; if (encoder->type != HPDF_ENCODER_TYPE_MULTI_BYTE) return HPDF_BYTE_TYPE_SINGLE; HPDF_Font_SetParseText (font, &parse_state, text, index + 4); for (;;) { btype = HPDF_CMapEncoder_ByteType (encoder, &parse_state, &bytes); if (index == 0) break; text++; index--; } return btype; } HPDF_EXPORT(HPDF_UCS4) HPDF_Font_GetUcs4 (HPDF_Font font, const char *text, HPDF_UINT *bytes) { HPDF_FontAttr attr; HPDF_CharEnc charenc; HPDF_UCS4 ucs4; HPDF_UINT tmp_bytes; HPDF_PTRACE ((" HPDF_Font_GetUcs4\n")); if (!HPDF_Font_Validate (font)) return 0; attr = (HPDF_FontAttr)font->attr; charenc = GetSourceCharEnc (font); if (charenc == HPDF_CHARENC_UNSUPPORTED) return HPDF_Encoder_GetUcs4 (attr->encoder, (const HPDF_BYTE *)text, bytes); tmp_bytes = BYTES_FNS[charenc] ((const HPDF_BYTE *)text); ucs4 = TOUCS4_FNS[charenc] ((const HPDF_BYTE *)text, tmp_bytes); if (bytes) *bytes = tmp_bytes; return ucs4; } HPDF_EXPORT(HPDF_STATUS) HPDF_Font_SetReliefFont (HPDF_Font font, HPDF_Font relief_font) { HPDF_FontAttr attr, rf_attr; HPDF_PTRACE ((" HPDF_Font_SetReliefFont\n")); if (!HPDF_Font_Validate (font)) return HPDF_INVALID_FONT; attr = (HPDF_FontAttr)font->attr; if (!relief_font) { attr->relief_font = relief_font; return HPDF_OK; } if (!HPDF_Font_Validate (relief_font)) return HPDF_INVALID_FONT; rf_attr = (HPDF_FontAttr)relief_font->attr; if (attr->type == HPDF_FONT_TYPE1 || rf_attr->type == HPDF_FONT_TYPE1) return HPDF_RaiseError (font->error, HPDF_UNSUPPORTED_FONT_TYPE, 0); if (!attr->text_cache) HPDF_NormalizeCharEnc (&attr->encoder->charenc); if (!rf_attr->text_cache) HPDF_NormalizeCharEnc (&rf_attr->encoder->charenc); if (rf_attr->encoder != attr->encoder && (rf_attr->encoder->charenc == HPDF_CHARENC_UNSUPPORTED || rf_attr->encoder->charenc != attr->encoder->charenc)) return HPDF_RaiseError (font->error, HPDF_UNMATCHED_RELIEF_FONT, 0); for (font = relief_font; font; font = ((HPDF_FontAttr)font->attr)->relief_font) if ((HPDF_FontAttr)font->attr == attr) return HPDF_RaiseError (font->error, HPDF_LOOPED_RELIEF_FONT, 0); attr->relief_font = relief_font; return HPDF_OK; } HPDF_Font HPDF_Font_GetReliefFont (HPDF_Font font, HPDF_UCS4 ucs4, HPDF_BYTE *index) { HPDF_BYTE irf = 0; HPDF_Font rf = font; HPDF_FontAttr rfattr = (HPDF_FontAttr)rf->attr; if (rfattr->fontdef->type != HPDF_FONT_TYPE1) { for (; rf && irf <= HPDF_RELIEF_FONT_INDEX_MASK; rf = rfattr->relief_font, irf++) { rfattr = (HPDF_FontAttr)rf->attr; if (rfattr->fontdef->type == HPDF_FONTDEF_TYPE_CID) { /* cid-based font */ if (HPDF_CMapEncoder_ToCID (rfattr->encoder, ucs4)) break; } else { /* unicode-based font */ HPDF_UINT16 gid; HPDF_TTFontDefAttr ttattr; ttattr = (HPDF_TTFontDefAttr)rfattr->fontdef->attr; if (ttattr) { gid = HPDF_TTFontDef_GetGlyphid (rfattr->fontdef, ucs4); if (gid && gid < ttattr->num_glyphs) break; } } } } if (HPDF_RELIEF_FONT_INDEX_MASK < irf) rf = NULL; if (index) *index = (rf? irf: 0); return rf; } static void SetReliefFontIndex (HPDF_Font font) { HPDF_FontAttr attr = (HPDF_FontAttr)font->attr; HPDF_Encoder encoder = attr->encoder; HPDF_BYTE irf = 0; HPDF_BYTE irff = 0; HPDF_ParseText_Rec parse_state; HPDF_UINT i; HPDF_BYTE *pirf = attr->text_cache + (attr->text_cache_allocated / 2); HPDF_PTRACE ((" HPDF_CIDFont_SetReliefFontIndex\n")); HPDF_Encoder_SetParseText (encoder, &parse_state, attr->text_cache, attr->text_cache_len); for (i = 0; i < attr->text_cache_len; i++) { HPDF_UINT bytes; HPDF_ByteType btype; btype = HPDF_CMapEncoder_ByteType (encoder, &parse_state, &bytes); if (btype != HPDF_BYTE_TYPE_TRIAL) { HPDF_UCS4 b = HPDF_Encoder_ToUcs4 (encoder, attr->text_cache + i, bytes); HPDF_Font_GetReliefFont (font, b, &irf); switch (b) { case 0xFFF9: /* IAA */ irff &= ~(HPDF_INTERLINEAR_ANNOTATED | HPDF_INTERLINEAR_ANNOTATION); irff |= HPDF_INTERLINEAR_ANNOTATED; break; case 0xFFFA: /* IAS */ irff &= ~(HPDF_INTERLINEAR_ANNOTATED | HPDF_INTERLINEAR_ANNOTATION); irff |= HPDF_INTERLINEAR_ANNOTATION; break; case 0xFFFB: /* IAT */ irff &= ~(HPDF_INTERLINEAR_ANNOTATED | HPDF_INTERLINEAR_ANNOTATION); break; } } pirf[i] = irff | irf; } } static HPDF_BOOL IsCIDText (HPDF_Font font, HPDF_UINT index) { HPDF_FontAttr rfattr = (HPDF_FontAttr)font->attr; while (index-- && rfattr) { if (!(font = rfattr->relief_font)) break; rfattr = (HPDF_FontAttr)font->attr; } return (rfattr->type == HPDF_FONT_TYPE0_TT && (((HPDF_TTFontDefAttr)rfattr->fontdef->attr)->options & HPDF_FONTOPT_WITHOUT_CID_MAP)); }