HPDF_STATUS
HPDF_Catalog_SetViewerPreference (HPDF_Catalog catalog,
HPDF_UINT value)
{
HPDF_STATUS ret;
HPDF_Dict preferences;
HPDF_PTRACE ((" HPDF_Catalog_SetViewerPreference\n"));
if (!value) {
ret = HPDF_Dict_RemoveElement (catalog, "ViewerPreferences");
if (ret == HPDF_DICT_ITEM_NOT_FOUND)
ret = HPDF_OK;
return ret;
}
preferences = HPDF_Dict_New (catalog->mmgr);
if (!preferences)
return catalog->error->error_no;
if ((ret = HPDF_Dict_Add (catalog, "ViewerPreferences", preferences))
!= HPDF_OK)
return ret;
/* */
if (value & HPDF_HIDE_TOOLBAR) {
if ((ret = HPDF_Dict_AddBoolean (preferences, "HideToolbar",
HPDF_TRUE)) != HPDF_OK)
return ret;
} else {
if ((ret = HPDF_Dict_RemoveElement (preferences, "HideToolbar")) !=
HPDF_OK)
if (ret != HPDF_DICT_ITEM_NOT_FOUND)
return ret;
}
if (value & HPDF_HIDE_MENUBAR) {
if ((ret = HPDF_Dict_AddBoolean (preferences, "HideMenubar",
HPDF_TRUE)) != HPDF_OK)
return ret;
} else {
if ((ret = HPDF_Dict_RemoveElement (preferences, "HideMenubar")) !=
HPDF_OK)
if (ret != HPDF_DICT_ITEM_NOT_FOUND)
return ret;
}
if (value & HPDF_HIDE_WINDOW_UI) {
if ((ret = HPDF_Dict_AddBoolean (preferences, "HideWindowUI",
HPDF_TRUE)) != HPDF_OK)
return ret;
} else {
if ((ret = HPDF_Dict_RemoveElement (preferences, "HideWindowUI")) !=
HPDF_OK)
if (ret != HPDF_DICT_ITEM_NOT_FOUND)
return ret;
}
if (value & HPDF_FIT_WINDOW) {
if ((ret = HPDF_Dict_AddBoolean (preferences, "FitWindow",
HPDF_TRUE)) != HPDF_OK)
return ret;
} else {
if ((ret = HPDF_Dict_RemoveElement (preferences, "FitWindow")) !=
HPDF_OK)
if (ret != HPDF_DICT_ITEM_NOT_FOUND)
return ret;
}
if (value & HPDF_CENTER_WINDOW) {
if ((ret = HPDF_Dict_AddBoolean (preferences, "CenterWindow",
HPDF_TRUE)) != HPDF_OK)
return ret;
} else {
if ((ret = HPDF_Dict_RemoveElement (preferences, "CenterWindow")) !=
HPDF_OK)
if (ret != HPDF_DICT_ITEM_NOT_FOUND)
return ret;
}
if (value & HPDF_PRINT_SCALING_NONE) {
if ((ret = HPDF_Dict_AddName (preferences, "PrintScaling",
"None")) != HPDF_OK)
return ret;
} else {
if ((ret = HPDF_Dict_RemoveElement (preferences, "PrintScaling")) !=
HPDF_OK)
if (ret != HPDF_DICT_ITEM_NOT_FOUND)
return ret;
}
return HPDF_OK;
}
static HPDF_Font
CIDFontType0_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_CIDFontDefAttr fontdef_attr = (HPDF_CIDFontDefAttr)fontdef->attr;
HPDF_Encoder encoder = attr->encoder;
HPDF_CMapEncoderAttr encoder_attr =
(HPDF_CMapEncoderAttr)encoder->attr;
HPDF_UINT16 save_cid = 0;
HPDF_Font font;
HPDF_Array array;
HPDF_Array sub_array = NULL;
HPDF_UINT i;
HPDF_Dict descriptor;
HPDF_Dict cid_system_info;
HPDF_PTRACE ((" HPDF_CIDFontType0_New\n"));
font = HPDF_Dict_New (parent->mmgr);
if (!font)
return NULL;
if (HPDF_Xref_Add (xref, font) != HPDF_OK)
return NULL;
ret += HPDF_Dict_AddName (font, "Type", "Font");
ret += HPDF_Dict_AddName (font, "Subtype", "CIDFontType0");
ret += HPDF_Dict_AddNumber (font, "DW", fontdef_attr->DW);
ret += HPDF_Dict_AddName (font, "BaseFont", fontdef->base_font);
if (ret != HPDF_OK)
return NULL;
/* add 'DW2' element */
array = HPDF_Array_New (parent->mmgr);
if (!array)
return NULL;
if (HPDF_Dict_Add (font, "DW2", array) != HPDF_OK)
return NULL;
ret += HPDF_Array_AddNumber (array, fontdef_attr->DW2[0]);
ret += HPDF_Array_AddNumber (array, fontdef_attr->DW2[1]);
if (ret != HPDF_OK)
return NULL;
/* add 'W' element */
array = HPDF_Array_New (parent->mmgr);
if (!array)
return NULL;
if (HPDF_Dict_Add (font, "W", array) != HPDF_OK)
return NULL;
/* Create W array. */
for (i = 0; i< fontdef_attr->widths->count; i++) {
HPDF_CID_Width *w =
(HPDF_CID_Width *)HPDF_List_ItemAt (fontdef_attr->widths, i);
if (w->cid != save_cid + 1 || !sub_array) {
sub_array = HPDF_Array_New (parent->mmgr);
if (!sub_array)
return NULL;
ret += HPDF_Array_AddNumber (array, w->cid);
ret += HPDF_Array_Add (array, sub_array);
}
ret += HPDF_Array_AddNumber (sub_array, w->width);
save_cid = w->cid;
if (ret != HPDF_OK)
return NULL;
}
/* create descriptor */
descriptor = HPDF_Dict_New (parent->mmgr);
if (!descriptor)
return NULL;
if (HPDF_Xref_Add (xref, descriptor) != HPDF_OK)
return NULL;
if (HPDF_Dict_Add (font, "FontDescriptor", descriptor) != HPDF_OK)
return NULL;
ret += HPDF_Dict_AddName (descriptor, "Type", "FontDescriptor");
ret += HPDF_Dict_AddName (descriptor, "FontName", fontdef->base_font);
ret += HPDF_Dict_AddNumber (descriptor, "Ascent", fontdef->ascent);
ret += HPDF_Dict_AddNumber (descriptor, "Descent", fontdef->descent);
ret += HPDF_Dict_AddNumber (descriptor, "CapHeight",
fontdef->cap_height);
ret += HPDF_Dict_AddNumber (descriptor, "MissingWidth",
fontdef->missing_width);
ret += HPDF_Dict_AddNumber (descriptor, "Flags", fontdef->flags);
if (ret != HPDF_OK)
return NULL;
array = HPDF_Box_Array_New (parent->mmgr, fontdef->font_bbox);
if (!array)
return NULL;
ret += HPDF_Dict_Add (descriptor, "FontBBox", array);
ret += HPDF_Dict_AddNumber (descriptor, "ItalicAngle",
fontdef->italic_angle);
ret += HPDF_Dict_AddNumber (descriptor, "StemV", fontdef->stemv);
if (ret != HPDF_OK)
return NULL;
/* create CIDSystemInfo dictionary */
cid_system_info = HPDF_Dict_New (parent->mmgr);
if (!cid_system_info)
return NULL;
if (HPDF_Dict_Add (font, "CIDSystemInfo", cid_system_info) != HPDF_OK)
return NULL;
ret += HPDF_Dict_Add (cid_system_info, "Registry",
HPDF_String_New (parent->mmgr, encoder_attr->registry, NULL));
ret += HPDF_Dict_Add (cid_system_info, "Ordering",
HPDF_String_New (parent->mmgr, encoder_attr->ordering, NULL));
ret += HPDF_Dict_AddNumber (cid_system_info, "Supplement",
encoder_attr->suppliment);
if (ret != HPDF_OK)
return NULL;
return font;
}
HPDF_EXPORT(HPDF_STATUS) HPDF_3DView_SetBackgroundColor(HPDF_Dict view, HPDF_REAL r, HPDF_REAL g, HPDF_REAL b)
{
HPDF_Array color;
HPDF_STATUS ret = HPDF_OK;
HPDF_Dict background;
HPDF_PTRACE ((" HPDF_3DView_SetBackgroundColor\n"));
if (view == NULL || r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1) {
return HPDF_INVALID_U3D_DATA;
}
background = HPDF_Dict_New (view->mmgr);
if (!background) {
return HPDF_Error_GetCode (view->error);
}
color = HPDF_Array_New (view->mmgr);
if (!color) {
HPDF_Dict_Free (background);
return HPDF_Error_GetCode (view->error);
}
ret = HPDF_Array_AddReal (color, r);
if (ret != HPDF_OK) {
HPDF_Array_Free (color);
HPDF_Dict_Free (background);
return ret;
}
ret = HPDF_Array_AddReal (color, g);
if (ret != HPDF_OK) {
HPDF_Array_Free (color);
HPDF_Dict_Free (background);
return ret;
}
ret = HPDF_Array_AddReal (color, b);
if (ret != HPDF_OK) {
HPDF_Array_Free (color);
HPDF_Dict_Free (background);
return ret;
}
ret = HPDF_Dict_AddName (background, "Type", "3DBG");
if (ret != HPDF_OK) {
HPDF_Array_Free (color);
HPDF_Dict_Free (background);
return ret;
}
ret = HPDF_Dict_Add (background, "C", color);
if (ret != HPDF_OK) {
HPDF_Array_Free (color);
HPDF_Dict_Free (background);
return ret;
}
ret = HPDF_Dict_Add (view, "BG", background);
if (ret != HPDF_OK) {
HPDF_Array_Free (color);
HPDF_Dict_Free (background);
return ret;
}
return ret;
}
HPDF_EXPORT(HPDF_STATUS) HPDF_3DView_SetCamera(HPDF_Dict view, HPDF_REAL coox, HPDF_REAL cooy, HPDF_REAL cooz, HPDF_REAL c2cx, HPDF_REAL c2cy, HPDF_REAL c2cz, HPDF_REAL roo, HPDF_REAL roll)
{
HPDF_REAL viewx, viewy, viewz;
HPDF_REAL leftx, lefty, leftz;
HPDF_REAL upx, upy, upz;
HPDF_REAL transx, transy, transz;
HPDF_Array matrix;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE ((" HPDF_3DView_SetCamera\n"));
if (view == NULL) {
return HPDF_INVALID_U3D_DATA;
}
/* view vector (opposite to c2c) */
viewx = -c2cx;
viewy = -c2cy;
viewz = -c2cz;
/* c2c = (0, -1, 0) by default */
if (viewx == 0.0 && viewy == 0.0 && viewz == 0.0) {
viewy = 1.0;
}
/* normalize view vector */
normalize(viewx, viewy, viewz);
/* rotation matrix */
/* top and bottom views */
leftx = -1.0f;
lefty = 0.0f;
leftz = 0.0f;
/* up-vector */
if (viewz < 0.0) /* top view*/
{
upx = 0.0f;
upy = 1.0f;
upz = 0.0f;
}
else /* bottom view*/
{
upx = 0.0f;
upy =-1.0f;
upz = 0.0f;
}
if ( fabs(viewx) + fabs(viewy) != 0.0f) /* other views than top and bottom*/
{
/* up-vector = up_world - (up_world dot view) view*/
upx = -viewz*viewx;
upy = -viewz*viewy;
upz = -viewz*viewz + 1.0f;
/* normalize up-vector*/
normalize(upx, upy, upz);
/* left vector = up x view*/
leftx = viewz*upy - viewy*upz;
lefty = viewx*upz - viewz*upx;
leftz = viewy*upx - viewx*upy;
/* normalize left vector*/
normalize(leftx, lefty, leftz);
}
/* apply camera roll*/
{
HPDF_REAL leftxprime, leftyprime, leftzprime;
HPDF_REAL upxprime, upyprime, upzprime;
HPDF_REAL sinroll, cosroll;
sinroll = (HPDF_REAL)sin((roll/180.0f)*M_PI);
cosroll = (HPDF_REAL)cos((roll/180.0f)*M_PI);
leftxprime = leftx*cosroll + upx*sinroll;
leftyprime = lefty*cosroll + upy*sinroll;
leftzprime = leftz*cosroll + upz*sinroll;
upxprime = upx*cosroll + leftx*sinroll;
upyprime = upy*cosroll + lefty*sinroll;
upzprime = upz*cosroll + leftz*sinroll;
leftx = leftxprime;
lefty = leftyprime;
leftz = leftzprime;
upx = upxprime;
upy = upyprime;
upz = upzprime;
}
/* translation vector*/
roo = (HPDF_REAL)fabs(roo);
if (roo == 0.0) {
roo = (HPDF_REAL)0.000000000000000001;
}
transx = coox - roo*viewx;
transy = cooy - roo*viewy;
transz = cooz - roo*viewz;
/* transformation matrix*/
matrix = HPDF_Array_New (view->mmgr);
if (!matrix) {
return HPDF_Error_GetCode (view->error);
}
ret = HPDF_Array_AddReal (matrix, leftx);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, lefty);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, leftz);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, upx);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, upy);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, upz);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, viewx);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, viewy);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, viewz);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, transx);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, transy);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Array_AddReal (matrix, transz);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Dict_AddName (view, "MS", "M");
if (ret != HPDF_OK) goto failed;
ret = HPDF_Dict_Add (view, "C2W", matrix);
if (ret != HPDF_OK) goto failed;
ret = HPDF_Dict_AddNumber (view, "CO", (HPDF_INT32)roo);
failed:
if (ret != HPDF_OK) {
HPDF_Array_Free (matrix);
return ret;
}
return ret;
}
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_EXPORT(HPDF_STATUS) HPDF_3DView_AddNode(HPDF_Dict view, const char *name, HPDF_REAL opacity, HPDF_BOOL visible)
{
HPDF_Array nodes = NULL;
HPDF_Dict node;
HPDF_STATUS ret = HPDF_OK;
HPDF_PTRACE ((" HPDF_3DView_AddNode\n"));
if (view == NULL || opacity < 0 || opacity > 1 || name == NULL || name[0] == '\0') {
return HPDF_INVALID_U3D_DATA;
}
nodes = (HPDF_Array)HPDF_Dict_GetItem (view, "NA", HPDF_OCLASS_ARRAY);
if (nodes == NULL) {
nodes = HPDF_Array_New (view->mmgr);
if (!nodes) {
return HPDF_Error_GetCode (view->error);
}
ret = HPDF_Dict_Add (view, "NA", nodes);
if (ret != HPDF_OK) {
HPDF_Array_Free (nodes);
return ret;
}
}
node = HPDF_Dict_New (view->mmgr);
if (!node) {
HPDF_Array_Free (nodes);
return HPDF_Error_GetCode (view->error);
}
ret = HPDF_Dict_AddName (node, "Type", "3DNode");
if (ret != HPDF_OK) {
HPDF_Array_Free (nodes);
HPDF_Dict_Free (node);
return ret;
}
ret = HPDF_Dict_Add (node, "N", HPDF_String_New (view->mmgr, name, NULL));
if (ret != HPDF_OK) {
HPDF_Array_Free (nodes);
HPDF_Dict_Free (node);
return ret;
}
ret = HPDF_Dict_AddReal (node, "O", opacity);
if (ret != HPDF_OK) {
HPDF_Array_Free (nodes);
HPDF_Dict_Free (node);
return ret;
}
ret = HPDF_Dict_AddBoolean (node, "V", visible);
if (ret != HPDF_OK) {
HPDF_Dict_Free (node);
HPDF_Array_Free (nodes);
return ret;
}
ret = HPDF_Array_Add(nodes, node);
if (ret != HPDF_OK) {
HPDF_Dict_Free (node);
HPDF_Array_Free (nodes);
return ret;
}
return ret;
}
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_Font
HPDF_Type0Font_New (HPDF_MMgr mmgr,
HPDF_FontDef fontdef,
HPDF_Encoder encoder,
HPDF_Xref xref)
{
HPDF_Dict font;
HPDF_FontAttr attr;
HPDF_CMapEncoderAttr encoder_attr;
HPDF_STATUS ret = 0;
HPDF_Array descendant_fonts;
HPDF_PTRACE ((" HPDF_Type0Font_New\n"));
font = HPDF_Dict_New (mmgr);
if (!font)
return NULL;
font->header.obj_class |= HPDF_OSUBCLASS_FONT;
/* check whether the fontdef object and the encoder object is valid. */
if (encoder->type != HPDF_ENCODER_TYPE_DOUBLE_BYTE) {
HPDF_SetError(font->error, HPDF_INVALID_ENCODER_TYPE, 0);
return NULL;
}
if (fontdef->type != HPDF_FONTDEF_TYPE_CID &&
fontdef->type != HPDF_FONTDEF_TYPE_TRUETYPE) {
HPDF_SetError(font->error, HPDF_INVALID_FONTDEF_TYPE, 0);
return NULL;
}
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 = NULL;
font->free_fn = OnFree_Func;
font->attr = attr;
encoder_attr = (HPDF_CMapEncoderAttr)encoder->attr;
HPDF_MemSet (attr, 0, sizeof(HPDF_FontAttr_Rec));
attr->writing_mode = encoder_attr->writing_mode;
attr->text_width_fn = TextWidth;
attr->measure_text_fn = MeasureText;
attr->fontdef = fontdef;
attr->encoder = encoder;
attr->xref = xref;
if (HPDF_Xref_Add (xref, font) != HPDF_OK)
return NULL;
ret += HPDF_Dict_AddName (font, "Type", "Font");
ret += HPDF_Dict_AddName (font, "BaseFont", fontdef->base_font);
ret += HPDF_Dict_AddName (font, "Subtype", "Type0");
if (fontdef->type == HPDF_FONTDEF_TYPE_CID) {
ret += HPDF_Dict_AddName (font, "Encoding", encoder->name);
} else {
attr->cmap_stream = CreateCMap (encoder, xref);
if (attr->cmap_stream) {
ret += HPDF_Dict_Add (font, "Encoding", attr->cmap_stream);
} else
return NULL;
}
if (ret != HPDF_OK)
return NULL;
descendant_fonts = HPDF_Array_New (mmgr);
if (!descendant_fonts)
return NULL;
if (HPDF_Dict_Add (font, "DescendantFonts", descendant_fonts) != HPDF_OK)
return NULL;
if (fontdef->type == HPDF_FONTDEF_TYPE_CID) {
attr->descendant_font = CIDFontType0_New (font, xref);
attr->type = HPDF_FONT_TYPE0_CID;
} else {
attr->descendant_font = CIDFontType2_New (font, xref);
attr->type = HPDF_FONT_TYPE0_TT;
}
if (!attr->descendant_font)
return NULL;
else
if (HPDF_Array_Add (descendant_fonts, attr->descendant_font) !=
HPDF_OK)
return NULL;
return font;
}
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++) {
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;
}
}
}
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;
}
HPDF_Annotation_SetBorderStyle (HPDF_Annotation annot,
HPDF_BSSubtype subtype,
HPDF_REAL width,
HPDF_UINT16 dash_on,
HPDF_UINT16 dash_off,
HPDF_UINT16 dash_phase)
{
HPDF_Dict bs;
HPDF_Array dash;
HPDF_STATUS ret;
HPDF_PTRACE((" HPDF_Annotation_SetBoderStyle\n"));
bs = HPDF_Dict_New (annot->mmgr);
if (!bs)
return HPDF_Error_GetCode (annot->error);
if ((ret = HPDF_Dict_Add (annot, "BS", bs)) != HPDF_OK)
return ret;
if (subtype == HPDF_BS_DASHED) {
dash = HPDF_Array_New (annot->mmgr);
if (!dash)
return HPDF_Error_GetCode (annot->error);
if ((ret = HPDF_Dict_Add (bs, "D", dash)) != HPDF_OK)
return ret;
ret += HPDF_Dict_AddName (bs, "Type", "Border");
ret += HPDF_Array_AddReal (dash, dash_on);
ret += HPDF_Array_AddReal (dash, dash_off);
if (dash_phase != 0)
ret += HPDF_Array_AddReal (dash, dash_off);
}
switch (subtype) {
case HPDF_BS_SOLID:
ret += HPDF_Dict_AddName (bs, "S", "S");
break;
case HPDF_BS_DASHED:
ret += HPDF_Dict_AddName (bs, "S", "D");
break;
case HPDF_BS_BEVELED:
ret += HPDF_Dict_AddName (bs, "S", "B");
break;
case HPDF_BS_INSET:
ret += HPDF_Dict_AddName (bs, "S", "I");
break;
case HPDF_BS_UNDERLINED:
ret += HPDF_Dict_AddName (bs, "S", "U");
break;
default:
return HPDF_SetError (annot->error, HPDF_ANNOT_INVALID_BORDER_STYLE, 0);
}
if (width != HPDF_BS_DEF_WIDTH)
ret += HPDF_Dict_AddReal (bs, "W", width);
if (ret != HPDF_OK)
return HPDF_Error_GetCode (annot->error);
return HPDF_OK;
}
HPDF_Font
HPDF_Type0Font_New (HPDF_MMgr mmgr,
HPDF_FontDef fontdef,
HPDF_Encoder encoder,
HPDF_Xref xref)
{
HPDF_Dict font;
HPDF_FontAttr attr;
HPDF_CMapEncoderAttr encoder_attr;
HPDF_STATUS ret = 0;
HPDF_Array descendant_fonts;
HPDF_PTRACE (" HPDF_Type0Font_New\n");
font = HPDF_Dict_New (mmgr);
if (!font)
return NULL;
font->header.obj_class |= HPDF_OSUBCLASS_FONT;
/* check whether the fontdef object and the encoder object is valid. */
if (encoder->type != HPDF_ENCODER_TYPE_DOUBLE_BYTE) {
HPDF_SetError(font->error, HPDF_INVALID_ENCODER_TYPE, 0);
return NULL;
}
if (fontdef->type != HPDF_FONTDEF_TYPE_CID &&
fontdef->type != HPDF_FONTDEF_TYPE_TRUETYPE) {
HPDF_SetError(font->error, HPDF_INVALID_FONTDEF_TYPE, 0);
return NULL;
}
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 = NULL;
font->free_fn = OnFree_Func;
font->attr = attr;
encoder_attr = (HPDF_CMapEncoderAttr)encoder->attr;
HPDF_MemSet (attr, 0, sizeof(HPDF_FontAttr_Rec));
attr->writing_mode = encoder_attr->writing_mode;
attr->text_width_fn = TextWidth;
attr->measure_text_fn = MeasureText;
attr->fontdef = fontdef;
attr->encoder = encoder;
attr->xref = xref;
if (HPDF_Xref_Add (xref, font) != HPDF_OK)
return NULL;
ret += HPDF_Dict_AddName (font, "Type", "Font");
ret += HPDF_Dict_AddName (font, "BaseFont", fontdef->base_font);
ret += HPDF_Dict_AddName (font, "Subtype", "Type0");
if (fontdef->type == HPDF_FONTDEF_TYPE_CID) {
ret += HPDF_Dict_AddName (font, "Encoding", encoder->name);
} else {
/*
* Handle the Unicode encoding, see hpdf_encoding_utf.c For some
* reason, xpdf-based readers cannot deal with our cmap but work
* fine when using the predefined "Identity-H"
* encoding. However, text selection does not work, unless we
* add a ToUnicode cmap. This CMap should also be "Identity",
* but that does not work -- specifying our cmap as a stream however
* does work. Who can understand that ?
*/
if (HPDF_StrCmp(encoder_attr->ordering, "Identity-H") == 0) {
ret += HPDF_Dict_AddName (font, "Encoding", "Identity-H");
attr->cmap_stream = CreateCMap (encoder, xref);
if (attr->cmap_stream) {
ret += HPDF_Dict_Add (font, "ToUnicode", attr->cmap_stream);
} else
return NULL;
} else {
attr->cmap_stream = CreateCMap (encoder, xref);
if (attr->cmap_stream) {
ret += HPDF_Dict_Add (font, "Encoding", attr->cmap_stream);
} else
return NULL;
}
}
if (ret != HPDF_OK)
return NULL;
descendant_fonts = HPDF_Array_New (mmgr);
if (!descendant_fonts)
return NULL;
if (HPDF_Dict_Add (font, "DescendantFonts", descendant_fonts) != HPDF_OK)
return NULL;
if (fontdef->type == HPDF_FONTDEF_TYPE_CID) {
attr->descendant_font = CIDFontType0_New (font, xref);
attr->type = HPDF_FONT_TYPE0_CID;
} else {
attr->descendant_font = CIDFontType2_New (font, xref);
attr->type = HPDF_FONT_TYPE0_TT;
}
if (!attr->descendant_font)
return NULL;
else
if (HPDF_Array_Add (descendant_fonts, attr->descendant_font) !=
HPDF_OK)
return NULL;
return font;
}
