HPDF_Page
HPDF_Page_New (HPDF_MMgr mmgr,
HPDF_Xref xref)
{
HPDF_STATUS ret;
HPDF_PageAttr attr;
HPDF_Page page;
HPDF_PTRACE((" HPDF_Page_New\n"));
page = HPDF_Dict_New (mmgr);
if (!page)
return NULL;
page->header.obj_class |= HPDF_OSUBCLASS_PAGE;
page->free_fn = Page_OnFree;
page->before_write_fn = Page_BeforeWrite;
attr = HPDF_GetMem (page->mmgr, sizeof(HPDF_PageAttr_Rec));
if (!attr) {
HPDF_Dict_Free (page);
return NULL;
}
page->attr = attr;
HPDF_MemSet (attr, 0, sizeof(HPDF_PageAttr_Rec));
attr->gmode = HPDF_GMODE_PAGE_DESCRIPTION;
attr->cur_pos = HPDF_ToPoint (0, 0);
attr->text_pos = HPDF_ToPoint (0, 0);
ret = HPDF_Xref_Add (xref, page);
if (ret != HPDF_OK)
return NULL;
attr->gstate = HPDF_GState_New (page->mmgr, NULL);
attr->contents = HPDF_DictStream_New (page->mmgr, xref);
if (!attr->gstate || !attr->contents)
return NULL;
attr->stream = attr->contents->stream;
attr->xref = xref;
/* add requiered elements */
ret += HPDF_Dict_AddName (page, "Type", "Page");
ret += HPDF_Dict_Add (page, "MediaBox", HPDF_Box_Array_New (page->mmgr,
HPDF_ToBox (0, 0, (HPDF_INT16)(HPDF_DEF_PAGE_WIDTH), (HPDF_INT16)(HPDF_DEF_PAGE_HEIGHT))));
ret += HPDF_Dict_Add (page, "Contents", attr->contents);
ret += AddResource (page);
if (ret != HPDF_OK)
return NULL;
return page;
}
HPDF_Image
HPDF_Image_LoadJpegImage (HPDF_MMgr mmgr,
HPDF_Stream jpeg_data,
HPDF_Xref xref)
{
HPDF_Dict image;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE ((" HPDF_Image_LoadJpegImage\n"));
image = HPDF_DictStream_New (mmgr, xref);
if (!image)
return NULL;
image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
/* add requiered elements */
image->filter = HPDF_STREAM_FILTER_DCT_DECODE;
ret += HPDF_Dict_AddName (image, "Type", "XObject");
ret += HPDF_Dict_AddName (image, "Subtype", "Image");
if (ret != HPDF_OK)
return NULL;
if (LoadJpegHeader (image, jpeg_data) != HPDF_OK)
return NULL;
if (HPDF_Stream_Seek (jpeg_data, 0, HPDF_SEEK_SET) != HPDF_OK)
return NULL;
for (;;) {
HPDF_BYTE buf[HPDF_STREAM_BUF_SIZ];
HPDF_UINT len = HPDF_STREAM_BUF_SIZ;
HPDF_STATUS ret = HPDF_Stream_Read (jpeg_data, buf,
&len);
if (ret != HPDF_OK) {
if (ret == HPDF_STREAM_EOF) {
if (len > 0) {
ret = HPDF_Stream_Write (image->stream, buf, len);
if (ret != HPDF_OK)
return NULL;
}
break;
} else
return NULL;
}
if (HPDF_Stream_Write (image->stream, buf, len) != HPDF_OK)
return NULL;
}
return image;
}
HPDF_EmbeddedFile
HPDF_EmbeddedFile_New (HPDF_MMgr mmgr,
HPDF_Xref xref,
const char *file)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Dict ef; /* the dictionary for the embedded file: /Type /EF */
HPDF_String name; /* the name of the file: /F (name) */
HPDF_Dict eff; /* ef has an /EF <<blah>> key - this is it */
HPDF_Dict filestream; /* the stream that /EF <</F _ _ R>> refers to */
HPDF_Stream stream;
ef = HPDF_Dict_New (mmgr);
if (!ef)
return NULL;
if (HPDF_Xref_Add (xref, ef) != HPDF_OK)
return NULL;
filestream = HPDF_DictStream_New (mmgr, xref);
if (!filestream)
return NULL;
stream = HPDF_FileReader_New (mmgr, file);
if (!stream)
return NULL;
HPDF_Stream_Free(filestream->stream);
filestream->stream = stream;
filestream->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
eff = HPDF_Dict_New (mmgr);
if (!eff)
return NULL;
name = HPDF_String_New (mmgr, file, NULL);
if (!name)
return NULL;
ret += HPDF_Dict_AddName (ef, "Type", "F");
ret += HPDF_Dict_Add (ef, "F", name);
ret += HPDF_Dict_Add (ef, "EF", eff);
ret += HPDF_Dict_Add (eff, "F", filestream);
if (ret != HPDF_OK)
return NULL;
return ef;
}
HPDF_EXPORT(HPDF_JavaScript) HPDF_CreateJavaScript( HPDF_Doc pdf, const char *code )
{
HPDF_JavaScript javaScript;
int len ;
HPDF_PTRACE ((" HPDF_CreateJavaScript\n"));
javaScript = (HPDF_JavaScript) HPDF_DictStream_New(pdf->mmgr, pdf->xref);
if (!javaScript) {
return NULL;
}
len = (HPDF_UINT)strlen(code);
if (HPDF_Stream_Write (javaScript->stream, (HPDF_BYTE *)code, len) != HPDF_OK) {
HPDF_Dict_Free(javaScript);
return NULL;
}
return javaScript;
}
HPDF_U3D
HPDF_U3D_LoadU3DFromMem ( HPDF_MMgr mmgr,
const HPDF_BYTE *buf,
HPDF_UINT size,
HPDF_Xref xref )
{
HPDF_Dict image;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE ((" HPDF_U3D_LoadU3DFromMem\n"));
image = HPDF_DictStream_New (mmgr, xref);
if (!image) {
return NULL;
}
image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
ret = HPDF_Dict_AddName (image, "Type", "XObject");
if (ret != HPDF_OK) {
HPDF_Dict_Free(image);
return NULL;
}
ret = HPDF_Dict_AddName (image, "Subtype", "Image");
if (ret != HPDF_OK) {
HPDF_Dict_Free(image);
return NULL;
}
if (HPDF_Stream_Write (image->stream, buf, size) != HPDF_OK) {
HPDF_Dict_Free(image);
return NULL;
}
return image;
}
HPDF_Image
HPDF_Image_LoadPngImage (HPDF_MMgr mmgr,
HPDF_Stream png_data,
HPDF_Xref xref,
HPDF_BOOL delayed_loading)
{
HPDF_STATUS ret;
HPDF_Dict image;
png_byte header[HPDF_PNG_BYTES_TO_CHECK];
HPDF_UINT len = HPDF_PNG_BYTES_TO_CHECK;
HPDF_PTRACE ((" HPDF_Image_LoadPngImage\n"));
HPDF_MemSet (header, 0x00, HPDF_PNG_BYTES_TO_CHECK);
ret = HPDF_Stream_Read (png_data, header, &len);
if (ret != HPDF_OK ||
png_sig_cmp (header, (png_size_t)0, HPDF_PNG_BYTES_TO_CHECK)) {
HPDF_SetError (mmgr->error, HPDF_INVALID_PNG_IMAGE, 0);
return NULL;
}
image = HPDF_DictStream_New (mmgr, xref);
if (!image)
return NULL;
image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
ret += HPDF_Dict_AddName (image, "Type", "XObject");
ret += HPDF_Dict_AddName (image, "Subtype", "Image");
if (ret != HPDF_OK)
return NULL;
if (LoadPngData (image, xref, png_data, delayed_loading) != HPDF_OK)
return NULL;
return image;
}
HPDF_U3D
HPDF_U3D_LoadU3D (HPDF_MMgr mmgr,
HPDF_Stream u3d_data,
HPDF_Xref xref)
{
HPDF_Dict u3d;
const char *type;
HPDF_PTRACE ((" HPDF_U3D_LoadU3D\n"));
u3d = HPDF_DictStream_New (mmgr, xref);
if (!u3d) {
return NULL;
}
u3d->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
/* add required elements */
u3d->filter = HPDF_STREAM_FILTER_NONE;
if (HPDF_Dict_AddName (u3d, "Type", "3D") != HPDF_OK) {
HPDF_Dict_Free(u3d);
return NULL;
}
if (Get3DStreamType (u3d_data, &type) != HPDF_OK) {
HPDF_Dict_Free(u3d);
return NULL;
}
if (HPDF_Dict_AddName (u3d, "Subtype", type) != HPDF_OK) {
HPDF_Dict_Free(u3d);
return NULL;
}
for (;;) {
HPDF_BYTE buf[HPDF_STREAM_BUF_SIZ];
HPDF_UINT len = HPDF_STREAM_BUF_SIZ;
HPDF_STATUS ret = HPDF_Stream_Read (u3d_data, buf, &len);
if (ret != HPDF_OK) {
if (ret == HPDF_STREAM_EOF) {
if (len > 0) {
ret = HPDF_Stream_Write (u3d->stream, buf, len);
if (ret != HPDF_OK) {
HPDF_Dict_Free(u3d);
return NULL;
}
}
break;
} else {
HPDF_Dict_Free(u3d);
return NULL;
}
}
if (HPDF_Stream_Write (u3d->stream, buf, len) != HPDF_OK) {
HPDF_Dict_Free(u3d);
return NULL;
}
}
return u3d;
}
HPDF_Shading_New (HPDF_Doc pdf,
HPDF_ShadingType type,
HPDF_ColorSpace colorSpace,
HPDF_REAL xMin, HPDF_REAL xMax,
HPDF_REAL yMin, HPDF_REAL yMax)
{
HPDF_Shading shading;
HPDF_Array decodeArray;
HPDF_STATUS ret = HPDF_OK;
int i;
HPDF_PTRACE((" HPDF_Shading_New\n"));
if (!HPDF_HasDoc(pdf)) {
return NULL;
}
/* Validate shading type: */
switch (type)
{
case HPDF_SHADING_FREE_FORM_TRIANGLE_MESH:
break;
default:
HPDF_SetError (pdf->mmgr->error, HPDF_INVALID_SHADING_TYPE, 0);
return NULL;
}
decodeArray = HPDF_Array_New(pdf->mmgr);
if (!decodeArray) {
return NULL;
}
/* X-range */
ret += HPDF_Array_AddReal(decodeArray, xMin);
ret += HPDF_Array_AddReal(decodeArray, xMax);
/* Y-range */
ret += HPDF_Array_AddReal(decodeArray, yMin);
ret += HPDF_Array_AddReal(decodeArray, yMax);
const char *colName = NULL;
switch (colorSpace) {
case HPDF_CS_DEVICE_RGB:
colName = COL_RGB;
for (i = 0; i < 3; ++i) {
ret += HPDF_Array_AddReal(decodeArray, 0.0);
ret += HPDF_Array_AddReal(decodeArray, 1.0);
}
break;
default:
HPDF_SetError(pdf->mmgr->error, HPDF_INVALID_COLOR_SPACE, 0);
return NULL;
}
if (ret != HPDF_OK) {
return NULL;
}
shading = HPDF_DictStream_New(pdf->mmgr, pdf->xref);
if (!shading) {
return NULL;
}
shading->header.obj_class |= HPDF_OSUBCLASS_SHADING;
ret += HPDF_Dict_AddNumber(shading, "ShadingType", type);
ret += HPDF_Dict_AddName(shading, "ColorSpace", colName);
switch (type)
{
case HPDF_SHADING_FREE_FORM_TRIANGLE_MESH:
ret += HPDF_Dict_AddNumber(shading, "BitsPerCoordinate", 32);
ret += HPDF_Dict_AddNumber(shading, "BitsPerComponent", 8);
ret += HPDF_Dict_AddNumber(shading, "BitsPerFlag", 8);
ret += HPDF_Dict_Add(shading, "Decode", decodeArray);
break;
default:
HPDF_SetError (pdf->mmgr->error, HPDF_INVALID_SHADING_TYPE, 0);
return NULL;
}
if (ret != HPDF_OK) {
return NULL;
}
return shading;
}
HPDF_Image
HPDF_Image_LoadRawImageFromMem (HPDF_MMgr mmgr,
const HPDF_BYTE *buf,
HPDF_Xref xref,
HPDF_UINT width,
HPDF_UINT height,
HPDF_ColorSpace color_space,
HPDF_UINT bits_per_component)
{
HPDF_Dict image;
HPDF_STATUS ret = HPDF_OK;
HPDF_UINT size=0;
HPDF_PTRACE ((" HPDF_Image_LoadRawImageFromMem\n"));
if (color_space != HPDF_CS_DEVICE_GRAY &&
color_space != HPDF_CS_DEVICE_RGB &&
color_space != HPDF_CS_DEVICE_CMYK) {
HPDF_SetError (mmgr->error, HPDF_INVALID_COLOR_SPACE, 0);
return NULL;
}
if (bits_per_component != 1 && bits_per_component != 2 &&
bits_per_component != 4 && bits_per_component != 8) {
HPDF_SetError (mmgr->error, HPDF_INVALID_IMAGE, 0);
return NULL;
}
image = HPDF_DictStream_New (mmgr, xref);
if (!image)
return NULL;
image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
ret += HPDF_Dict_AddName (image, "Type", "XObject");
ret += HPDF_Dict_AddName (image, "Subtype", "Image");
if (ret != HPDF_OK)
return NULL;
switch (color_space) {
case HPDF_CS_DEVICE_GRAY:
size = (HPDF_UINT)((HPDF_DOUBLE)width * height / (8 / bits_per_component) + 0.876);
ret = HPDF_Dict_AddName (image, "ColorSpace", COL_GRAY);
break;
case HPDF_CS_DEVICE_RGB:
size = (HPDF_UINT)((HPDF_DOUBLE)width * height / (8 / bits_per_component) + 0.876);
size *= 3;
ret = HPDF_Dict_AddName (image, "ColorSpace", COL_RGB);
break;
case HPDF_CS_DEVICE_CMYK:
size = (HPDF_UINT)((HPDF_DOUBLE)width * height / (8 / bits_per_component) + 0.876);
size *= 4;
ret = HPDF_Dict_AddName (image, "ColorSpace", COL_CMYK);
break;
default:;
}
if (ret != HPDF_OK)
return NULL;
if (HPDF_Dict_AddNumber (image, "Width", width) != HPDF_OK)
return NULL;
if (HPDF_Dict_AddNumber (image, "Height", height) != HPDF_OK)
return NULL;
if (HPDF_Dict_AddNumber (image, "BitsPerComponent", bits_per_component)
!= HPDF_OK)
return NULL;
if (HPDF_Stream_Write (image->stream, buf, size) != HPDF_OK)
return NULL;
return image;
}
HPDF_Font
HPDF_Type3RasterFont_New(HPDF_MMgr mmgr,
HPDF_FontDef fontdef,
HPDF_Encoder encoder,
HPDF_Xref xref)
{
HPDF_Dict font;
HPDF_FontAttr attr;
HPDF_Type3RasterFontDefAttr fontdef_attr;
HPDF_BasicEncoderAttr encoder_attr;
HPDF_STATUS ret = 0;
HPDF_UINT i;
HPDF_PTRACE((" HPDF_Type3RasterFont_New\n"));
/* check whether the fontdef object and the encoder object is valid. */
if (encoder->type != HPDF_ENCODER_TYPE_SINGLE_BYTE) {
HPDF_SetError(mmgr->error, HPDF_INVALID_ENCODER_TYPE, 0);
return NULL;
}
if (fontdef->type != HPDF_FONTDEF_TYPE_TYPE3RASTER) {
HPDF_SetError(mmgr->error, HPDF_INVALID_FONTDEF_TYPE, 0);
return NULL;
}
font = HPDF_Dict_New(mmgr);
if (!font)
return NULL;
font->header.obj_class |= HPDF_OSUBCLASS_FONT;
attr = HPDF_GetMem(mmgr, sizeof(HPDF_FontAttr_Rec));
if (!attr) {
HPDF_Dict_Free(font);
return NULL;
}
font->header.obj_class |= HPDF_OSUBCLASS_FONT;
font->write_fn = Type3RasterFont_OnWrite;
font->free_fn = Type3RasterFont_OnFree;
HPDF_MemSet(attr, 0, sizeof(HPDF_FontAttr_Rec));
font->attr = attr;
attr->type = HPDF_FONT_TYPE3;
attr->writing_mode = HPDF_WMODE_HORIZONTAL;
attr->text_width_fn = Type3RasterFont_TextWidth;
attr->measure_text_fn = Type3RasterFont_MeasureText;
attr->fontdef = fontdef;
attr->encoder = encoder;
attr->xref = xref;
/* singlebyte-font has a widths-array which is an array of 256 signed
* short integer.
*/
attr->widths = HPDF_GetMem(mmgr, sizeof(HPDF_INT16) * 256);
if (!attr->widths) {
HPDF_Dict_Free(font);
return NULL;
}
encoder_attr = (HPDF_BasicEncoderAttr)encoder->attr;
HPDF_MemSet(attr->widths, 0, sizeof(HPDF_INT16) * 256);
for (i = 0 /*encoder_attr->first_char*/; i <= 255 /*encoder_attr->last_char*/; i++) {
HPDF_UINT16 w = HPDF_Type3RasterFontDef_GetWidth(fontdef, i);
attr->widths[i] = w;
}
fontdef_attr = (HPDF_Type3RasterFontDefAttr)fontdef->attr;
ret += HPDF_Dict_AddName(font, "Name", fontdef->base_font);
ret += HPDF_Dict_AddName(font, "Type", "Font");
ret += HPDF_Dict_AddName(font, "Subtype", "Type3");
HPDF_REAL scale_x = 72.0f / (HPDF_REAL)fontdef_attr->dpi_x;
HPDF_REAL scale_y = 72.0f / (HPDF_REAL)fontdef_attr->dpi_y;
HPDF_TransMatrix font_matrix;
font_matrix.a = scale_x;
font_matrix.b = 0;
font_matrix.c = 0;
font_matrix.d = scale_y;
font_matrix.x = 0;
font_matrix.y = 0;
HPDF_Array array = HPDF_Array_New(mmgr);
ret += HPDF_Array_AddReal(array, font_matrix.a);
ret += HPDF_Array_AddReal(array, font_matrix.b);
ret += HPDF_Array_AddReal(array, font_matrix.c);
ret += HPDF_Array_AddReal(array, font_matrix.d);
ret += HPDF_Array_AddReal(array, font_matrix.x);
ret += HPDF_Array_AddReal(array, font_matrix.y);
ret += HPDF_Dict_Add(font, "FontMatrix", array);
HPDF_Array diff_array = HPDF_Array_New(mmgr);
ret += HPDF_Array_AddNumber(diff_array, 0);
for (i = 0; i < 256; ++i) {
char name[3];
sprintf(name, "%02X", i);
ret += HPDF_Array_AddName(diff_array, name);
}
HPDF_Dict encoding = HPDF_Dict_New(mmgr);
ret += HPDF_Dict_Add(encoding, "Differences", diff_array);
ret += HPDF_Dict_Add(font, "Encoding", encoding);
HPDF_Dict char_procs = HPDF_Dict_New(mmgr);
for (i = 0; i < 256; ++i) {
char name[3];
sprintf(name, "%02X", i);
HPDF_Dict char_stream_dict = HPDF_DictStream_New(mmgr, xref);
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].width / scale_x);
HPDF_Stream_WriteStr(char_stream_dict->stream, " 0 ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].left / scale_x);
HPDF_Stream_WriteStr(char_stream_dict->stream, " ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].bottom / scale_y);
HPDF_Stream_WriteStr(char_stream_dict->stream, " ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].right / scale_x);
HPDF_Stream_WriteStr(char_stream_dict->stream, " ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].top / scale_y);
HPDF_Stream_WriteStr(char_stream_dict->stream, " d1\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "q\012");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].pixels_x);
HPDF_Stream_WriteStr(char_stream_dict->stream, " 0 0 ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].pixels_y);
HPDF_Stream_WriteStr(char_stream_dict->stream, " ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].left / scale_x);
HPDF_Stream_WriteStr(char_stream_dict->stream, " ");
HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].bottom / scale_y);
HPDF_Stream_WriteStr(char_stream_dict->stream, " cm\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "BI\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "/IM true\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "/W ");
HPDF_Stream_WriteInt(char_stream_dict->stream, fontdef_attr->chars[i].pixels_x);
HPDF_Stream_WriteStr(char_stream_dict->stream, " /H ");
HPDF_Stream_WriteInt(char_stream_dict->stream, fontdef_attr->chars[i].pixels_y);
HPDF_Stream_WriteStr(char_stream_dict->stream, "\012/BPC 1\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "/D [1 0]\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "ID\012");
if (fontdef_attr->chars[i].raster_data != NULL)
HPDF_Stream_Write(char_stream_dict->stream, fontdef_attr->chars[i].raster_data, fontdef_attr->chars[i].raster_data_size);
HPDF_Stream_WriteStr(char_stream_dict->stream, "\012EI\012");
HPDF_Stream_WriteStr(char_stream_dict->stream, "Q");
ret += HPDF_Dict_Add(char_procs, name, char_stream_dict);
if (fontdef_attr->chars[i].left < fontdef->font_bbox.left)
fontdef->font_bbox.left = fontdef_attr->chars[i].left;
if (fontdef_attr->chars[i].bottom < fontdef->font_bbox.bottom)
fontdef->font_bbox.bottom = fontdef_attr->chars[i].bottom;
if (fontdef_attr->chars[i].right > fontdef->font_bbox.right)
fontdef->font_bbox.right = fontdef_attr->chars[i].right;
if (fontdef_attr->chars[i].top > fontdef->font_bbox.top)
fontdef->font_bbox.top = fontdef_attr->chars[i].top;
}
fontdef->font_bbox.left /= scale_x;
fontdef->font_bbox.bottom /= scale_y;
fontdef->font_bbox.right /= scale_x;
fontdef->font_bbox.top /= scale_y;
ret += HPDF_Dict_Add(font, "CharProcs", char_procs);
array = HPDF_Box_Array_New(mmgr, fontdef->font_bbox);
ret += HPDF_Dict_Add(font, "FontBBox", array);
if (ret != HPDF_OK) {
HPDF_Dict_Free(font);
return NULL;
}
if (HPDF_Xref_Add(xref, font) != HPDF_OK)
return NULL;
return font;
}
static HPDF_STATUS
CreateDescriptor (HPDF_Font font)
{
HPDF_FontAttr font_attr = (HPDF_FontAttr)font->attr;
HPDF_FontDef def = font_attr->fontdef;
HPDF_TTFontDefAttr def_attr = (HPDF_TTFontDefAttr)def->attr;
HPDF_PTRACE ((" HPDF_TTFont_CreateDescriptor\n"));
if (!font_attr->fontdef->descriptor) {
HPDF_Dict descriptor = HPDF_Dict_New (font->mmgr);
HPDF_STATUS ret = 0;
HPDF_Array array;
if (!descriptor)
return HPDF_Error_GetCode (font->error);
ret += HPDF_Xref_Add (font_attr->xref, descriptor);
ret += HPDF_Dict_AddName (descriptor, "Type", "FontDescriptor");
ret += HPDF_Dict_AddNumber (descriptor, "Ascent", def->ascent);
ret += HPDF_Dict_AddNumber (descriptor, "Descent", def->descent);
ret += HPDF_Dict_AddNumber (descriptor, "Flags", def->flags);
array = HPDF_Box_Array_New (font->mmgr, def->font_bbox);
ret += HPDF_Dict_Add (descriptor, "FontBBox", array);
ret += HPDF_Dict_AddName (descriptor, "FontName", def_attr->base_font);
ret += HPDF_Dict_AddNumber (descriptor, "ItalicAngle",
def->italic_angle);
ret += HPDF_Dict_AddNumber (descriptor, "StemV", def->stemv);
ret += HPDF_Dict_AddNumber (descriptor, "XHeight", def->x_height);
if (def_attr->char_set)
ret += HPDF_Dict_AddName (descriptor, "CharSet",
def_attr->char_set);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (font->error);
if (def_attr->embedding) {
HPDF_Dict font_data = HPDF_DictStream_New (font->mmgr,
font_attr->xref);
if (!font_data)
return HPDF_Error_GetCode (font->error);
if (HPDF_TTFontDef_SaveFontData (font_attr->fontdef,
font_data->stream) != HPDF_OK)
return HPDF_Error_GetCode (font->error);
ret += HPDF_Dict_Add (descriptor, "FontFile2", font_data);
ret += HPDF_Dict_AddNumber (font_data, "Length1",
def_attr->length1);
ret += HPDF_Dict_AddNumber (font_data, "Length2", 0);
ret += HPDF_Dict_AddNumber (font_data, "Length3", 0);
font_data->filter = font->filter;
}
if (ret != HPDF_OK)
return HPDF_Error_GetCode (font->error);
font_attr->fontdef->descriptor = descriptor;
}
return HPDF_Dict_Add (font, "FontDescriptor",
font_attr->fontdef->descriptor);
}
HPDF_STATUS
HPDF_PDFA_SetPDFAConformance (HPDF_Doc pdf,HPDF_PDFAType pdfatype)
{
HPDF_OutputIntent xmp;
HPDF_STATUS ret;
const char *info = NULL;
if (!HPDF_HasDoc(pdf)) {
return HPDF_INVALID_DOCUMENT;
}
xmp = HPDF_DictStream_New(pdf->mmgr,pdf->xref);
if (!xmp) {
return HPDF_INVALID_STREAM;
}
HPDF_Dict_AddName(xmp,"Type","Metadata");
HPDF_Dict_AddName(xmp,"SubType","XML");
ret = HPDF_OK;
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_HEADER);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PRODUCER_STARTTAG);
info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_PRODUCER);
ret += HPDF_Stream_WriteStr(xmp->stream, info);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PRODUCER_ENDTAG);
/* Add CreateDate, ModifyDate, and CreatorTool */
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_INFODATA_STARTTAG);
info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_CREATION_DATE);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATE_DATE_STARTTAG);
/* Convert date to XMP compatible format */
ret += ConvertDateToXMDate(xmp->stream, info);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATE_DATE_ENDTAG);
info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_MOD_DATE);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_MOD_DATE_STARTTAG);
ret += ConvertDateToXMDate(xmp->stream, info);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_MOD_DATE_ENDTAG);
info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_CREATOR);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATORTOOL_STARTTAG);
ret += HPDF_Stream_WriteStr(xmp->stream, info);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATORTOOL_ENDTAG);
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_INFODATA_ENDTAG);
switch(pdfatype) {
case HPDF_PDFA_1A:
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PDFA1A);
break;
case HPDF_PDFA_1B:
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PDFA1B);
break;
}
ret += HPDF_Stream_WriteStr(xmp->stream, XMP_FOOTER);
if (ret != HPDF_OK) {
return HPDF_INVALID_STREAM;
}
if ((ret = HPDF_Dict_Add(pdf->catalog, "Metadata", xmp)) != HPDF_OK) {
return ret;
}
return HPDF_PDFA_GenerateID(pdf);
}
static HPDF_STATUS
Type1Font_CreateDescriptor (HPDF_MMgr mmgr,
HPDF_Font font,
HPDF_Xref xref)
{
HPDF_FontAttr font_attr = (HPDF_FontAttr)font->attr;
HPDF_FontDef def = font_attr->fontdef;
HPDF_Type1FontDefAttr def_attr = (HPDF_Type1FontDefAttr)def->attr;
HPDF_PTRACE ((" HPDF_Type1Font_CreateDescriptor\n"));
if (!font_attr->fontdef->descriptor) {
HPDF_Dict descriptor = HPDF_Dict_New (mmgr);
HPDF_STATUS ret = 0;
HPDF_Array array;
if (!descriptor)
return HPDF_Error_GetCode (font->error);
ret += HPDF_Xref_Add (xref, descriptor);
ret += HPDF_Dict_AddName (descriptor, "Type", "FontDescriptor");
ret += HPDF_Dict_AddNumber (descriptor, "Ascent", def->ascent);
ret += HPDF_Dict_AddNumber (descriptor, "Descent", def->descent);
if (def->cap_height)
{
ret += HPDF_Dict_AddNumber (descriptor, "CapHeight", def->cap_height);
}
ret += HPDF_Dict_AddNumber (descriptor, "Flags", def->flags);
array = HPDF_Box_Array_New (mmgr, def->font_bbox);
ret += HPDF_Dict_Add (descriptor, "FontBBox", array);
if(strncmp (font_attr->fontdef->base_font, "HPDF_", 5) == 0 && font_attr->fontdef->is_form_font == HPDF_TRUE)
{
ret += HPDF_Dict_AddName (descriptor, "FontName",
font_attr->fontdef->base_font + 5);
}
else
{
ret += HPDF_Dict_AddName (descriptor, "FontName",
font_attr->fontdef->base_font);
}
ret += HPDF_Dict_AddNumber (descriptor, "ItalicAngle",
def->italic_angle);
ret += HPDF_Dict_AddNumber (descriptor, "StemV", def->stemv);
ret += HPDF_Dict_AddNumber (descriptor, "XHeight", def->x_height);
if (def_attr->char_set)
ret += HPDF_Dict_AddName (descriptor, "CharSet",
def_attr->char_set);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (font->error);
if (def_attr->font_data) {
HPDF_Dict font_data = HPDF_DictStream_New (mmgr, xref);
if (!font_data)
return HPDF_Error_GetCode (font->error);
if (HPDF_Stream_WriteToStream (def_attr->font_data,
font_data->stream, HPDF_STREAM_FILTER_NONE, NULL) != HPDF_OK)
return HPDF_Error_GetCode (font->error);
ret += HPDF_Dict_Add (descriptor, "FontFile", font_data);
ret += HPDF_Dict_AddNumber (font_data, "Length1",
def_attr->length1);
ret += HPDF_Dict_AddNumber (font_data, "Length2",
def_attr->length2);
ret += HPDF_Dict_AddNumber (font_data, "Length3",
def_attr->length3);
font_data->filter = font->filter;
}
if (ret != HPDF_OK)
return HPDF_Error_GetCode (font->error);
font_attr->fontdef->descriptor = descriptor;
}
return HPDF_Dict_Add (font, "FontDescriptor",
font_attr->fontdef->descriptor);
}
static HPDF_STATUS
LoadPngData (HPDF_Dict image,
HPDF_Xref xref,
HPDF_Stream png_data,
HPDF_BOOL delayed_loading)
{
HPDF_STATUS ret = HPDF_OK;
png_uint_32 width, height;
int bit_depth, color_type;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
HPDF_PTRACE ((" HPDF_Image_LoadPngImage\n"));
/* create read_struct. */
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
image->error, PngErrorFunc, PngErrorFunc);
if (png_ptr == NULL) {
HPDF_SetError (image->error, HPDF_FAILD_TO_ALLOC_MEM, 0);
return HPDF_FAILD_TO_ALLOC_MEM;
}
/* create info-struct */
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL) {
HPDF_SetError (image->error, HPDF_FAILD_TO_ALLOC_MEM, 0);
goto Exit;
}
png_set_sig_bytes (png_ptr, HPDF_PNG_BYTES_TO_CHECK);
png_set_read_fn (png_ptr, (void *)png_data, (png_rw_ptr)&PngReadFunc);
/* reading info structure. */
png_read_info(png_ptr, info_ptr);
if (image->error->error_no != HPDF_OK) {
goto Exit;
}
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
/* 16bit images are not supported. */
if (bit_depth == 16) {
png_set_strip_16(png_ptr);
}
png_read_update_info(png_ptr, info_ptr);
if (image->error->error_no != HPDF_OK) {
goto Exit;
}
/* check palette-based images for transparent areas and load them immediately if found */
if (xref && PNG_COLOR_TYPE_PALETTE & color_type) {
png_bytep trans;
int num_trans;
HPDF_Dict smask;
png_bytep smask_data;
if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) ||
!png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL)) {
goto no_transparent_color_in_palette;
}
smask = HPDF_DictStream_New (image->mmgr, xref);
if (!smask) {
ret = HPDF_FAILD_TO_ALLOC_MEM;
goto Exit;
}
smask->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
ret = HPDF_Dict_AddName (smask, "Type", "XObject");
ret += HPDF_Dict_AddName (smask, "Subtype", "Image");
ret += HPDF_Dict_AddNumber (smask, "Width", (HPDF_UINT)width);
ret += HPDF_Dict_AddNumber (smask, "Height", (HPDF_UINT)height);
ret += HPDF_Dict_AddName (smask, "ColorSpace", "DeviceGray");
ret += HPDF_Dict_AddNumber (smask, "BitsPerComponent", (HPDF_UINT)bit_depth);
if (ret != HPDF_OK) {
HPDF_Dict_Free(smask);
ret = HPDF_INVALID_PNG_IMAGE;
goto Exit;
}
smask_data = HPDF_GetMem(image->mmgr, width * height);
if (!smask_data) {
HPDF_Dict_Free(smask);
ret = HPDF_FAILD_TO_ALLOC_MEM;
goto Exit;
}
if (ReadTransparentPaletteData(image, png_ptr, info_ptr, smask_data, trans, num_trans) != HPDF_OK) {
HPDF_FreeMem(image->mmgr, smask_data);
HPDF_Dict_Free(smask);
ret = HPDF_INVALID_PNG_IMAGE;
goto Exit;
}
if (HPDF_Stream_Write(smask->stream, smask_data, width * height) != HPDF_OK) {
HPDF_FreeMem(image->mmgr, smask_data);
HPDF_Dict_Free(smask);
ret = HPDF_FILE_IO_ERROR;
goto Exit;
}
HPDF_FreeMem(image->mmgr, smask_data);
ret += CreatePallet(image, png_ptr, info_ptr);
ret += HPDF_Dict_AddNumber (image, "Width", (HPDF_UINT)width);
ret += HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)height);
ret += HPDF_Dict_AddNumber (image, "BitsPerComponent", (HPDF_UINT)bit_depth);
ret += HPDF_Dict_Add (image, "SMask", smask);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return HPDF_OK;
}
no_transparent_color_in_palette:
/* read images with alpha channel right away
we have to do this because image transparent mask must be added to the Xref */
if (xref && PNG_COLOR_MASK_ALPHA & color_type) {
HPDF_Dict smask;
png_bytep smask_data;
smask = HPDF_DictStream_New (image->mmgr, xref);
if (!smask) {
ret = HPDF_FAILD_TO_ALLOC_MEM;
goto Exit;
}
smask->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
ret = HPDF_Dict_AddName (smask, "Type", "XObject");
ret += HPDF_Dict_AddName (smask, "Subtype", "Image");
ret += HPDF_Dict_AddNumber (smask, "Width", (HPDF_UINT)width);
ret += HPDF_Dict_AddNumber (smask, "Height", (HPDF_UINT)height);
ret += HPDF_Dict_AddName (smask, "ColorSpace", "DeviceGray");
ret += HPDF_Dict_AddNumber (smask, "BitsPerComponent", (HPDF_UINT)bit_depth);
if (ret != HPDF_OK) {
HPDF_Dict_Free(smask);
ret = HPDF_INVALID_PNG_IMAGE;
goto Exit;
}
smask_data = HPDF_GetMem(image->mmgr, width * height);
if (!smask_data) {
HPDF_Dict_Free(smask);
ret = HPDF_FAILD_TO_ALLOC_MEM;
goto Exit;
}
if (ReadTransparentPngData(image, png_ptr, info_ptr, smask_data) != HPDF_OK) {
HPDF_FreeMem(image->mmgr, smask_data);
HPDF_Dict_Free(smask);
ret = HPDF_INVALID_PNG_IMAGE;
goto Exit;
}
if (HPDF_Stream_Write(smask->stream, smask_data, width * height) != HPDF_OK) {
HPDF_FreeMem(image->mmgr, smask_data);
HPDF_Dict_Free(smask);
ret = HPDF_FILE_IO_ERROR;
goto Exit;
}
HPDF_FreeMem(image->mmgr, smask_data);
if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
ret += HPDF_Dict_AddName (image, "ColorSpace", "DeviceGray");
} else {
ret += HPDF_Dict_AddName (image, "ColorSpace", "DeviceRGB");
}
ret += HPDF_Dict_AddNumber (image, "Width", (HPDF_UINT)width);
ret += HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)height);
ret += HPDF_Dict_AddNumber (image, "BitsPerComponent", (HPDF_UINT)bit_depth);
ret += HPDF_Dict_Add (image, "SMask", smask);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return HPDF_OK;
}
/* if the image has color palette, copy the pallet of the image to
* create color map.
*/
if (color_type == PNG_COLOR_TYPE_PALETTE)
ret = CreatePallet(image, png_ptr, info_ptr);
else if (color_type == PNG_COLOR_TYPE_GRAY)
ret = HPDF_Dict_AddName (image, "ColorSpace", "DeviceGray");
else
ret = HPDF_Dict_AddName (image, "ColorSpace", "DeviceRGB");
if (ret != HPDF_OK)
goto Exit;
/* read image-data
* if the image is interlaced, read whole image at once.
* if delayed_loading is HPDF_TRUE, the data does not load this phase.
*/
if (delayed_loading) {
image->before_write_fn = PngBeforeWrite;
image->after_write_fn = PngAfterWrite;
} else {
if (png_get_interlace_type(png_ptr, info_ptr) != PNG_INTERLACE_NONE)
ret = ReadPngData_Interlaced(image, png_ptr, info_ptr);
else
ret = ReadPngData(image, png_ptr, info_ptr);
if (ret != HPDF_OK)
goto Exit;
}
/* setting the info of the image. */
if (HPDF_Dict_AddNumber (image, "Width", (HPDF_UINT)width)
!= HPDF_OK)
goto Exit;
if (HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)height)
!= HPDF_OK)
goto Exit;
if (HPDF_Dict_AddNumber (image, "BitsPerComponent",
(HPDF_UINT)bit_depth) != HPDF_OK)
goto Exit;
/* clean up */
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return HPDF_OK;
Exit:
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
if (ret != HPDF_OK) {
return ret;
}
return image->error->error_no;
}
HPDF_Image
HPDF_Image_LoadRawImage (HPDF_MMgr mmgr,
HPDF_Stream raw_data,
HPDF_Xref xref,
HPDF_UINT width,
HPDF_UINT height,
HPDF_ColorSpace color_space)
{
HPDF_Dict image;
HPDF_STATUS ret = HPDF_OK;
HPDF_UINT size;
HPDF_PTRACE ((" HPDF_Image_LoadRawImage\n"));
if (color_space != HPDF_CS_DEVICE_GRAY &&
color_space != HPDF_CS_DEVICE_RGB &&
color_space != HPDF_CS_DEVICE_CMYK) {
HPDF_SetError (mmgr->error, HPDF_INVALID_COLOR_SPACE, 0);
return NULL;
}
image = HPDF_DictStream_New (mmgr, xref);
if (!image)
return NULL;
image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
ret += HPDF_Dict_AddName (image, "Type", "XObject");
ret += HPDF_Dict_AddName (image, "Subtype", "Image");
if (ret != HPDF_OK)
return NULL;
if (color_space == HPDF_CS_DEVICE_GRAY) {
size = width * height;
ret = HPDF_Dict_AddName (image, "ColorSpace", COL_GRAY);
} else if (color_space == HPDF_CS_DEVICE_CMYK) {
size = width * height * 4;
ret = HPDF_Dict_AddName (image, "ColorSpace", COL_CMYK);
} else {
size = width * height * 3;
ret = HPDF_Dict_AddName (image, "ColorSpace", COL_RGB);
}
if (ret != HPDF_OK)
return NULL;
if (HPDF_Dict_AddNumber (image, "Width", width) != HPDF_OK)
return NULL;
if (HPDF_Dict_AddNumber (image, "Height", height) != HPDF_OK)
return NULL;
if (HPDF_Dict_AddNumber (image, "BitsPerComponent", 8) != HPDF_OK)
return NULL;
if (HPDF_Stream_WriteToStream (raw_data, image->stream, 0, NULL) != HPDF_OK)
return NULL;
if (image->stream->size != size) {
HPDF_SetError (image->error, HPDF_INVALID_IMAGE, 0);
return NULL;
}
return image;
}
static HPDF_Font
CIDFontType2_New (HPDF_Font parent, HPDF_Xref xref)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_FontAttr attr = (HPDF_FontAttr)parent->attr;
HPDF_FontDef fontdef = attr->fontdef;
HPDF_TTFontDefAttr fontdef_attr = (HPDF_TTFontDefAttr)fontdef->attr;
HPDF_Encoder encoder = attr->encoder;
HPDF_CMapEncoderAttr encoder_attr =
(HPDF_CMapEncoderAttr)encoder->attr;
HPDF_Font font;
HPDF_Array array;
HPDF_UINT i;
HPDF_UNICODE tmp_map[65536];
HPDF_Dict cid_system_info;
HPDF_UINT16 max = 0;
HPDF_PTRACE ((" HPDF_CIDFontType2_New\n"));
font = HPDF_Dict_New (parent->mmgr);
if (!font)
return NULL;
if (HPDF_Xref_Add (xref, font) != HPDF_OK)
return NULL;
parent->before_write_fn = CIDFontType2_BeforeWrite_Func;
ret += HPDF_Dict_AddName (font, "Type", "Font");
ret += HPDF_Dict_AddName (font, "Subtype", "CIDFontType2");
ret += HPDF_Dict_AddNumber (font, "DW", fontdef->missing_width);
if (ret != HPDF_OK)
return NULL;
/* add 'DW2' element */
array = HPDF_Array_New (font->mmgr);
if (!array)
return NULL;
if (HPDF_Dict_Add (font, "DW2", array) != HPDF_OK)
return NULL;
ret += HPDF_Array_AddNumber (array, (HPDF_INT32)(fontdef->font_bbox.bottom));
ret += HPDF_Array_AddNumber (array, (HPDF_INT32)(fontdef->font_bbox.bottom -
fontdef->font_bbox.top));
HPDF_MemSet (tmp_map, 0, sizeof(HPDF_UNICODE) * 65536);
if (ret != HPDF_OK)
return NULL;
for (i = 0; i < 256; i++) {
HPDF_UINT j;
for (j = 0; j < 256; j++) {
if (encoder->to_unicode_fn == HPDF_CMapEncoder_ToUnicode) {
HPDF_UINT16 cid = encoder_attr->cid_map[i][j];
if (cid != 0) {
HPDF_UNICODE unicode = encoder_attr->unicode_map[i][j];
HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (fontdef,
unicode);
tmp_map[cid] = gid;
if (max < cid)
max = cid;
}
} else {
HPDF_UNICODE unicode = (i << 8) | j;
HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (fontdef,
unicode);
tmp_map[unicode] = gid;
if (max < unicode)
max = unicode;
}
}
}
if (max > 0) {
HPDF_INT16 dw = fontdef->missing_width;
HPDF_UNICODE *ptmp_map = tmp_map;
HPDF_Array tmp_array = NULL;
/* add 'W' element */
array = HPDF_Array_New (font->mmgr);
if (!array)
return NULL;
if (HPDF_Dict_Add (font, "W", array) != HPDF_OK)
return NULL;
for (i = 0; i < max; i++, ptmp_map++) {
HPDF_INT w = HPDF_TTFontDef_GetGidWidth (fontdef, *ptmp_map);
if (w != dw) {
if (!tmp_array) {
if (HPDF_Array_AddNumber (array, i) != HPDF_OK)
return NULL;
tmp_array = HPDF_Array_New (font->mmgr);
if (!tmp_array)
return NULL;
if (HPDF_Array_Add (array, tmp_array) != HPDF_OK)
return NULL;
}
if ((ret = HPDF_Array_AddNumber (tmp_array, w)) != HPDF_OK)
return NULL;
} else
tmp_array = NULL;
}
/* create "CIDToGIDMap" data */
if (fontdef_attr->embedding) {
attr->map_stream = HPDF_DictStream_New (font->mmgr, xref);
if (!attr->map_stream)
return NULL;
if (HPDF_Dict_Add (font, "CIDToGIDMap", attr->map_stream) != HPDF_OK)
return NULL;
for (i = 0; i < max; i++) {
HPDF_BYTE u[2];
HPDF_UINT16 gid = tmp_map[i];
u[0] = (HPDF_BYTE)(gid >> 8);
u[1] = (HPDF_BYTE)gid;
HPDF_MemCpy ((HPDF_BYTE *)(tmp_map + i), u, 2);
}
if ((ret = HPDF_Stream_Write (attr->map_stream->stream,
(HPDF_BYTE *)tmp_map, max * 2)) != HPDF_OK)
return NULL;
}
static HPDF_STATUS
CIDFontType2_BeforeWrite_Func (HPDF_Dict obj)
{
HPDF_FontAttr font_attr = (HPDF_FontAttr)obj->attr;
HPDF_FontDef def = font_attr->fontdef;
HPDF_TTFontDefAttr def_attr = (HPDF_TTFontDefAttr)def->attr;
HPDF_STATUS ret = 0;
HPDF_Font font;
HPDF_Encoder encoder = font_attr->encoder;
HPDF_CMapEncoderAttr encoder_attr =
(HPDF_CMapEncoderAttr)encoder->attr;
HPDF_Array array;
HPDF_UINT i;
HPDF_UNICODE tmp_map[65536];
HPDF_UINT16 max = 0;
HPDF_PTRACE ((" CIDFontType2_BeforeWrite_Func\n"));
font = font_attr->descendant_font;
HPDF_MemSet (tmp_map, 0, sizeof(HPDF_UNICODE) * 65536);
if (ret != HPDF_OK)
return ret;
for (i = 0; i < 256; i++) {
HPDF_UINT j;
for (j = 0; j < 256; j++) {
if (encoder->to_unicode_fn == HPDF_CMapEncoder_ToUnicode) {
HPDF_UINT16 cid = encoder_attr->cid_map[i][j];
if (cid != 0) {
HPDF_UNICODE unicode = encoder_attr->unicode_map[i][j];
HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (def,
unicode);
tmp_map[cid] = gid;
if (max < cid)
max = cid;
}
} else {
HPDF_UNICODE unicode = (i << 8) | j;
HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (def,
unicode);
tmp_map[unicode] = gid;
if (max < unicode)
max = unicode;
}
}
}
if (def_attr->is_cidfont) {
max = def_attr->num_glyphs;
}
if (max > 0) {
HPDF_INT16 dw = def->missing_width;
HPDF_UNICODE *ptmp_map = tmp_map;
HPDF_Array tmp_array = NULL;
/* add 'W' element */
array = HPDF_Array_New (font->mmgr);
if (!array)
return HPDF_FAILD_TO_ALLOC_MEM;
if (HPDF_Dict_Add (font, "W", array) != HPDF_OK)
return HPDF_FAILD_TO_ALLOC_MEM;
for (i = 0; i < max; i++) {
HPDF_INT w;
HPDF_UINT16 gid;
if (def_attr->is_cidfont) {
gid = i;
} else {
gid = *ptmp_map;
ptmp_map++;
}
w = HPDF_TTFontDef_GetGidWidth (def, gid);
if (def_attr->glyph_tbl.flgs[gid] && w != dw) {
if (!tmp_array) {
if (HPDF_Array_AddNumber (array, i) != HPDF_OK)
return HPDF_FAILD_TO_ALLOC_MEM;
tmp_array = HPDF_Array_New (font->mmgr);
if (!tmp_array)
return HPDF_FAILD_TO_ALLOC_MEM;
if (HPDF_Array_Add (array, tmp_array) != HPDF_OK)
return HPDF_FAILD_TO_ALLOC_MEM;
}
if ((ret = HPDF_Array_AddNumber (tmp_array, w)) != HPDF_OK)
return HPDF_FAILD_TO_ALLOC_MEM;
} else
tmp_array = NULL;
}
/* create "CIDToGIDMap" data */
if (def_attr->embedding) {
if (def_attr->is_cidfont) {
ret += HPDF_Dict_AddName (font, "CIDToGIDMap", "Identity");
} else {
font_attr->map_stream = HPDF_DictStream_New (font->mmgr, font_attr->xref);
if (!font_attr->map_stream)
return HPDF_FAILD_TO_ALLOC_MEM;
if (HPDF_Dict_Add (font, "CIDToGIDMap", font_attr->map_stream) != HPDF_OK)
return HPDF_FAILD_TO_ALLOC_MEM;
for (i = 0; i < max; i++) {
HPDF_BYTE u[2];
HPDF_UINT16 gid = tmp_map[i];
u[0] = (HPDF_BYTE)(gid >> 8);
u[1] = (HPDF_BYTE)gid;
HPDF_MemCpy ((HPDF_BYTE *)(tmp_map + i), u, 2);
}
if ((ret = HPDF_Stream_Write (font_attr->map_stream->stream,
(HPDF_BYTE *)tmp_map, max * 2)) != HPDF_OK)
return HPDF_FAILD_TO_ALLOC_MEM;
}
}
} else {
