static const char*
LoadType1FontFromStream (HPDF_Doc pdf,
HPDF_Stream afmdata,
HPDF_Stream pfmdata)
{
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_LoadType1FontFromStream\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
def = HPDF_Type1FontDef_Load (pdf->mmgr, afmdata, pfmdata);
if (def) {
HPDF_FontDef tmpdef = HPDF_Doc_FindFontDef (pdf, def->base_font);
if (tmpdef) {
HPDF_FontDef_Free (def);
HPDF_SetError (&pdf->error, HPDF_FONT_EXISTS, 0);
return NULL;
}
if (HPDF_List_Add (pdf->fontdef_list, def) != HPDF_OK) {
HPDF_FontDef_Free (def);
return NULL;
}
return def->base_font;
}
return NULL;
}
HPDF_GetEncoder (HPDF_Doc pdf,
const char *encoding_name)
{
HPDF_Encoder encoder;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_GetEncoder\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
encoder = HPDF_Doc_FindEncoder (pdf, encoding_name);
if (!encoder) {
encoder = HPDF_BasicEncoder_New (pdf->mmgr, encoding_name);
if (!encoder) {
HPDF_CheckError (&pdf->error);
return NULL;
}
if ((ret = HPDF_List_Add (pdf->encoder_list, encoder)) != HPDF_OK) {
HPDF_Encoder_Free (encoder);
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
}
return encoder;
}
HPDF_FontDef
HPDF_GetFontDef (HPDF_Doc pdf,
const char *font_name)
{
HPDF_STATUS ret;
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_GetFontDef\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
def = HPDF_Doc_FindFontDef (pdf, font_name);
if (!def) {
def = HPDF_Base14FontDef_New (pdf->mmgr, font_name);
if (!def)
return NULL;
if ((ret = HPDF_List_Add (pdf->fontdef_list, def)) != HPDF_OK) {
HPDF_FontDef_Free (def);
HPDF_RaiseError (&pdf->error, ret, 0);
def = NULL;
}
}
return def;
}
HPDF_STATUS
HPDF_CIDFontDef_AddWidth (HPDF_FontDef fontdef,
const HPDF_CID_Width *widths)
{
HPDF_CIDFontDefAttr attr = (HPDF_CIDFontDefAttr)fontdef->attr;
HPDF_PTRACE (" HPDF_CIDFontDef_AddWidth\n");
while (widths->cid != 0xFFFF) {
HPDF_CID_Width *w = HPDF_GetMem (fontdef->mmgr,
sizeof (HPDF_CID_Width));
HPDF_STATUS ret;
if (!w)
return fontdef->error->error_no;
w->cid = widths->cid;
w->width = widths->width;
if ((ret = HPDF_List_Add (attr->widths, w)) != HPDF_OK) {
HPDF_FreeMem (fontdef->mmgr, w);
return ret;
}
widths++;
}
return HPDF_OK;
}
HPDF_STATUS
HPDF_Xref_Add (HPDF_Xref xref,
void *obj)
{
HPDF_XrefEntry entry;
HPDF_Obj_Header *header;
HPDF_PTRACE((" HPDF_Xref_Add\n"));
if (!obj) {
if (HPDF_Error_GetCode (xref->error) == HPDF_OK)
return HPDF_SetError (xref->error, HPDF_INVALID_OBJECT, 0);
else
return HPDF_INVALID_OBJECT;
}
header = (HPDF_Obj_Header *)obj;
if (header->obj_id & HPDF_OTYPE_DIRECT ||
header->obj_id & HPDF_OTYPE_INDIRECT)
return HPDF_SetError(xref->error, HPDF_INVALID_OBJECT, 0);
if (xref->entries->count >= HPDF_LIMIT_MAX_XREF_ELEMENT) {
HPDF_SetError(xref->error, HPDF_XREF_COUNT_ERR, 0);
goto Fail;
}
/* in the following, we have to dispose the object when an error is
* occured.
*/
entry = (HPDF_XrefEntry)HPDF_GetMem (xref->mmgr,
sizeof(HPDF_XrefEntry_Rec));
if (entry == NULL)
goto Fail;
if (HPDF_List_Add(xref->entries, entry) != HPDF_OK) {
HPDF_FreeMem (xref->mmgr, entry);
goto Fail;
}
entry->entry_typ = HPDF_IN_USE_ENTRY;
entry->byte_offset = 0;
entry->gen_no = 0;
entry->obj = obj;
header->obj_id = xref->start_offset + xref->entries->count - 1 +
HPDF_OTYPE_INDIRECT;
header->gen_no = entry->gen_no;
return HPDF_OK;
Fail:
HPDF_Obj_ForceFree(xref->mmgr, obj);
return HPDF_Error_GetCode (xref->error);
}
HPDF_Xref
HPDF_Xref_New (HPDF_MMgr mmgr,
HPDF_UINT32 offset)
{
HPDF_Xref xref;
HPDF_XrefEntry new_entry;
HPDF_PTRACE((" HPDF_Xref_New\n"));
xref = (HPDF_Xref)HPDF_GetMem (mmgr, sizeof(HPDF_Xref_Rec));
if (!xref)
return NULL;
HPDF_MemSet (xref, 0, sizeof(HPDF_Xref_Rec));
xref->mmgr = mmgr;
xref->error = mmgr->error;
xref->start_offset = offset;
xref->entries = HPDF_List_New (mmgr, HPDF_DEFALUT_XREF_ENTRY_NUM);
if (!xref->entries)
goto Fail;
xref->addr = 0;
if (xref->start_offset == 0) {
new_entry = (HPDF_XrefEntry)HPDF_GetMem (mmgr,
sizeof(HPDF_XrefEntry_Rec));
if (!new_entry)
goto Fail;
if (HPDF_List_Add (xref->entries, new_entry) != HPDF_OK) {
HPDF_FreeMem (mmgr, new_entry);
goto Fail;
}
/* add first entry which is free entry and whose generation
* number is 0
*/
new_entry->entry_typ = HPDF_FREE_ENTRY;
new_entry->byte_offset = 0;
new_entry->gen_no = HPDF_MAX_GENERATION_NUM;
new_entry->obj = NULL;
}
xref->trailer = HPDF_Dict_New (mmgr);
if (!xref->trailer)
goto Fail;
return xref;
Fail:
HPDF_PTRACE((" HPDF_Xref_New failed\n"));
HPDF_Xref_Free (xref);
return NULL;
}
HPDF_STATUS
HPDF_Array_Add (HPDF_Array array,
void *obj)
{
HPDF_Obj_Header *header;
HPDF_STATUS ret;
HPDF_PTRACE((" HPDF_Array_Add\n"));
if (!obj) {
if (HPDF_Error_GetCode (array->error) == HPDF_OK)
return HPDF_SetError (array->error, HPDF_INVALID_OBJECT, 0);
else
return HPDF_INVALID_OBJECT;
}
header = (HPDF_Obj_Header *)obj;
if (header->obj_id & HPDF_OTYPE_DIRECT)
return HPDF_SetError (array->error, HPDF_INVALID_OBJECT, 0);
if (array->list->count >= HPDF_LIMIT_MAX_ARRAY) {
HPDF_PTRACE((" HPDF_Array_Add exceed limitatin of array count(%d)\n",
HPDF_LIMIT_MAX_ARRAY));
HPDF_Obj_Free (array->mmgr, obj);
return HPDF_SetError (array->error, HPDF_ARRAY_COUNT_ERR, 0);
}
if (header->obj_id & HPDF_OTYPE_INDIRECT) {
HPDF_Proxy proxy = HPDF_Proxy_New (array->mmgr, obj);
if (!proxy) {
HPDF_Obj_Free (array->mmgr, obj);
return HPDF_Error_GetCode (array->error);
}
proxy->header.obj_id |= HPDF_OTYPE_DIRECT;
obj = proxy;
} else
header->obj_id |= HPDF_OTYPE_DIRECT;
ret = HPDF_List_Add (array->list, obj);
if (ret != HPDF_OK)
HPDF_Obj_Free (array->mmgr, obj);
return ret;
}
static const char*
LoadTTFontFromStream2 (HPDF_Doc pdf,
HPDF_Stream font_data,
HPDF_UINT index,
HPDF_BOOL embedding,
const char *file_name)
{
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_LoadTTFontFromStream2\n"));
def = HPDF_TTFontDef_Load2 (pdf->mmgr, font_data, index, embedding);
if (def) {
HPDF_FontDef tmpdef = HPDF_Doc_FindFontDef (pdf, def->base_font);
if (tmpdef) {
HPDF_FontDef_Free (def);
HPDF_SetError (&pdf->error, HPDF_FONT_EXISTS, 0);
return NULL;
}
if (HPDF_List_Add (pdf->fontdef_list, def) != HPDF_OK) {
HPDF_FontDef_Free (def);
return NULL;
}
} else
return NULL;
if (embedding) {
if (pdf->ttfont_tag[0] == 0) {
HPDF_MemCpy (pdf->ttfont_tag, (HPDF_BYTE *)"HPDFAA", 6);
} else {
HPDF_INT i;
for (i = 5; i >= 0; i--) {
pdf->ttfont_tag[i] += 1;
if (pdf->ttfont_tag[i] > 'Z')
pdf->ttfont_tag[i] = 'A';
else
break;
}
}
HPDF_TTFontDef_SetTagName (def, (char *)pdf->ttfont_tag);
}
return def->base_font;
}
HPDF_AddPage (HPDF_Doc pdf)
{
HPDF_Page page;
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_AddPage\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
if (pdf->page_per_pages) {
if (pdf->page_per_pages <= pdf->cur_page_num) {
pdf->cur_pages = HPDF_Doc_AddPagesTo (pdf, pdf->root_pages);
if (!pdf->cur_pages)
return NULL;
pdf->cur_page_num = 0;
}
}
page = HPDF_Page_New (pdf->mmgr, pdf->xref);
if (!page) {
HPDF_CheckError (&pdf->error);
return NULL;
}
if ((ret = HPDF_Pages_AddKids (pdf->cur_pages, page)) != HPDF_OK) {
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
if ((ret = HPDF_List_Add (pdf->page_list, page)) != HPDF_OK) {
HPDF_RaiseError (&pdf->error, ret, 0);
return NULL;
}
pdf->cur_page = page;
if (pdf->compression_mode & HPDF_COMP_TEXT)
HPDF_Page_SetFilter (page, HPDF_STREAM_FILTER_FLATE_DECODE);
pdf->cur_page_num++;
return page;
}
HPDF_STATUS
HPDF_Doc_RegisterEncoder (HPDF_Doc pdf,
HPDF_Encoder encoder)
{
HPDF_STATUS ret;
if (!encoder)
return HPDF_SetError (&pdf->error, HPDF_INVALID_OBJECT, 0);
if (HPDF_Doc_FindEncoder (pdf, encoder->name) != NULL) {
HPDF_Encoder_Free (encoder);
return HPDF_SetError (&pdf->error, HPDF_DUPLICATE_REGISTRATION, 0);
}
if ((ret = HPDF_List_Add (pdf->encoder_list, encoder)) != HPDF_OK) {
HPDF_Encoder_Free (encoder);
return HPDF_SetError (&pdf->error, ret, 0);
}
return HPDF_OK;
}
HPDF_STATUS
HPDF_List_Insert (HPDF_List list,
void *target,
void *item)
{
HPDF_INT target_idx = HPDF_List_Find (list, target);
void *last_item = list->obj[list->count - 1];
HPDF_INT i;
HPDF_PTRACE((" HPDF_List_Insert\n"));
if (target_idx < 0)
return HPDF_ITEM_NOT_FOUND;
/* move the item of the list to behind one by one. */
for (i = list->count - 2; i >= target_idx; i--)
list->obj[i + 1] = list->obj[i];
list->obj[target_idx] = item;
return HPDF_List_Add (list, last_item);
}
HPDF_STATUS
HPDF_Doc_RegisterFontDef (HPDF_Doc pdf,
HPDF_FontDef fontdef)
{
HPDF_STATUS ret;
HPDF_PTRACE ((" HPDF_Doc_RegisterFontDef\n"));
if (!fontdef)
return HPDF_SetError (&pdf->error, HPDF_INVALID_OBJECT, 0);
if (HPDF_Doc_FindFontDef (pdf, fontdef->base_font) != NULL) {
HPDF_FontDef_Free (fontdef);
return HPDF_SetError (&pdf->error, HPDF_DUPLICATE_REGISTRATION, 0);
}
if ((ret = HPDF_List_Add (pdf->fontdef_list, fontdef)) != HPDF_OK) {
HPDF_FontDef_Free (fontdef);
return HPDF_SetError (&pdf->error, ret, 0);
}
return HPDF_OK;
}
HPDF_GetFont (HPDF_Doc pdf,
const char *font_name,
const char *encoding_name)
{
HPDF_FontDef fontdef = NULL;
HPDF_Encoder encoder = NULL;
HPDF_Font font;
HPDF_PTRACE ((" HPDF_GetFont\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
if (!font_name) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_FONT_NAME, 0);
return NULL;
}
/* if encoding-name is not specified, find default-encoding of fontdef
*/
if (!encoding_name) {
fontdef = HPDF_GetFontDef (pdf, font_name);
if (fontdef) {
HPDF_Type1FontDefAttr attr = (HPDF_Type1FontDefAttr)fontdef->attr;
if (fontdef->type == HPDF_FONTDEF_TYPE_TYPE1 &&
HPDF_StrCmp (attr->encoding_scheme,
HPDF_ENCODING_FONT_SPECIFIC) == 0)
encoder = HPDF_GetEncoder (pdf, HPDF_ENCODING_FONT_SPECIFIC);
else
encoder = HPDF_GetEncoder (pdf, HPDF_ENCODING_STANDARD);
} else {
HPDF_CheckError (&pdf->error);
return NULL;
}
if (!encoder) {
HPDF_CheckError (&pdf->error);
return NULL;
}
font = HPDF_Doc_FindFont (pdf, font_name, encoder->name);
} else {
font = HPDF_Doc_FindFont (pdf, font_name, encoding_name);
}
if (font)
return font;
if (!fontdef) {
fontdef = HPDF_GetFontDef (pdf, font_name);
if (!fontdef) {
HPDF_CheckError (&pdf->error);
return NULL;
}
}
if (!encoder) {
encoder = HPDF_GetEncoder (pdf, encoding_name);
if (!encoder)
return NULL;
}
switch (fontdef->type) {
case HPDF_FONTDEF_TYPE_TYPE1:
font = HPDF_Type1Font_New (pdf->mmgr, fontdef, encoder, pdf->xref);
if (font)
HPDF_List_Add (pdf->font_mgr, font);
break;
case HPDF_FONTDEF_TYPE_TRUETYPE:
if (encoder->type == HPDF_ENCODER_TYPE_DOUBLE_BYTE)
font = HPDF_Type0Font_New (pdf->mmgr, fontdef, encoder,
pdf->xref);
else
font = HPDF_TTFont_New (pdf->mmgr, fontdef, encoder, pdf->xref);
if (font)
HPDF_List_Add (pdf->font_mgr, font);
break;
case HPDF_FONTDEF_TYPE_CID:
font = HPDF_Type0Font_New (pdf->mmgr, fontdef, encoder, pdf->xref);
if (font)
HPDF_List_Add (pdf->font_mgr, font);
break;
default:
HPDF_RaiseError (&pdf->error, HPDF_UNSUPPORTED_FONT_TYPE, 0);
return NULL;
}
if (!font)
HPDF_CheckError (&pdf->error);
if (font && (pdf->compression_mode & HPDF_COMP_METADATA))
font->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
return font;
}
