static HPDF_STATUS AddAnnotation (HPDF_Page page, HPDF_Annotation annot) { HPDF_Array array; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_Pages\n")); /* find "Annots" entry */ array = HPDF_Dict_GetItem (page, "Annots", HPDF_OCLASS_ARRAY); if (!array) { array = HPDF_Array_New (page->mmgr); if (!array) return HPDF_Error_GetCode (page->error); ret = HPDF_Dict_Add (page, "Annots", array); if (ret != HPDF_OK) return ret; } if ((ret = HPDF_Array_Add (array, annot)) != HPDF_OK) return ret; /* Add Parent to the annotation */ ret = HPDF_Dict_Add( annot, "P", page); return ret; }
HPDF_Array HPDF_Box_Array_New (HPDF_MMgr mmgr, HPDF_Box box) { HPDF_Array obj; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_Box_Array_New\n")); obj = HPDF_Array_New (mmgr); if (!obj) return NULL; ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.left)); ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.bottom)); ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.right)); ret += HPDF_Array_Add (obj, HPDF_Real_New (mmgr, box.top)); if (ret != HPDF_OK) { HPDF_Array_Free (obj); return NULL; } return obj; }
HPDF_NameTree HPDF_NameTree_New (HPDF_MMgr mmgr, HPDF_Xref xref) { HPDF_STATUS ret = HPDF_OK; HPDF_NameTree ntree; HPDF_Array items; HPDF_PTRACE (" HPDF_NameTree_New\n"); ntree = HPDF_Dict_New (mmgr); if (!ntree) return NULL; if (HPDF_Xref_Add (xref, ntree) != HPDF_OK) return NULL; ntree->header.obj_class |= HPDF_OSUBCLASS_NAMETREE; items = HPDF_Array_New (mmgr); if (!ntree) return NULL; ret += HPDF_Dict_Add (ntree, "Names", items); if (ret != HPDF_OK) return NULL; return ntree; }
HPDF_Pages HPDF_Pages_New (HPDF_MMgr mmgr, HPDF_Pages parent, HPDF_Xref xref) { HPDF_STATUS ret = HPDF_OK; HPDF_Pages pages; HPDF_PTRACE((" HPDF_Pages_New\n")); pages = HPDF_Dict_New (mmgr); if (!pages) return NULL; pages->header.obj_class |= HPDF_OSUBCLASS_PAGES; pages->before_write_fn = Pages_BeforeWrite; if (HPDF_Xref_Add (xref, pages) != HPDF_OK) return NULL; /* add requiered elements */ ret += HPDF_Dict_AddName (pages, "Type", "Pages"); ret += HPDF_Dict_Add (pages, "Kids", HPDF_Array_New (pages->mmgr)); ret += HPDF_Dict_Add (pages, "Count", HPDF_Number_New (pages->mmgr, 0)); if (ret == HPDF_OK && parent) ret += HPDF_Pages_AddKids (parent, pages); if (ret != HPDF_OK) return NULL; return pages; }
HPDF_LineAnnot_SetCaption (HPDF_Annotation annot, HPDF_BOOL showCaption, HPDF_LineAnnotCapPosition position, HPDF_INT horzOffset, HPDF_INT vertOffset) { HPDF_STATUS ret = HPDF_OK; HPDF_Array capOffset; HPDF_PTRACE((" HPDF_LineAnnot_SetCaption\n")); ret += HPDF_Dict_AddBoolean ( annot, "Cap", showCaption); ret += HPDF_Dict_AddName( annot, "CP", HPDF_LINE_ANNOT_CAP_POSITION_NAMES[(HPDF_INT)position]); if (ret != HPDF_OK) return HPDF_Error_GetCode ( annot->error); capOffset = HPDF_Array_New ( annot->mmgr); if ( !capOffset) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "CO", capOffset)) != HPDF_OK) return ret; ret += HPDF_Array_AddNumber (capOffset, horzOffset); ret += HPDF_Array_AddNumber (capOffset, vertOffset); if (ret != HPDF_OK) return HPDF_Error_GetCode (capOffset->error); return HPDF_OK; }
HPDF_EXPORT(HPDF_STATUS) HPDF_U3D_Add3DView(HPDF_U3D u3d, HPDF_Dict view) { HPDF_Array views = NULL; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE ((" HPDF_Add3DView\n")); if (u3d == NULL || view == NULL) { return HPDF_INVALID_U3D_DATA; } views = (HPDF_Array)HPDF_Dict_GetItem (u3d, "VA", HPDF_OCLASS_ARRAY); if (views == NULL) { views = HPDF_Array_New (u3d->mmgr); if (!views) { return HPDF_Error_GetCode (u3d->error); } ret = HPDF_Dict_Add (u3d, "VA", views); if (ret == HPDF_OK) { ret = HPDF_Dict_AddNumber (u3d, "DV", 0); } else { HPDF_Array_Free (views); return ret; } } if (ret == HPDF_OK) { ret = HPDF_Array_Add( views, view); } return ret; }
HPDF_MarkupAnnot_SetRectDiff (HPDF_Annotation annot, HPDF_Rect rect) /* RD entry : this is the difference between Rect and the text annotation rectangle */ { HPDF_Array array; HPDF_STATUS ret = HPDF_OK; HPDF_REAL tmp; HPDF_PTRACE((" HPDF_MarkupAnnot_SetRectDiff\n")); array = HPDF_Array_New ( annot->mmgr); if ( !array) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "RD", array)) != HPDF_OK) return ret; if (rect.top < rect.bottom) { tmp = rect.top; rect.top = rect.bottom; rect.bottom = tmp; } ret += HPDF_Array_AddReal (array, rect.left); ret += HPDF_Array_AddReal (array, rect.bottom); ret += HPDF_Array_AddReal (array, rect.right); ret += HPDF_Array_AddReal (array, rect.top); if (ret != HPDF_OK) return HPDF_Error_GetCode (array->error); return HPDF_OK; }
HPDF_FreeTextAnnot_Set3PointCalloutLine ( HPDF_Annotation annot, HPDF_Point startPoint, HPDF_Point kneePoint, HPDF_Point endPoint) /* Callout line will be in default user space */ { HPDF_Array clPoints; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_FreeTextAnnot_Set3PointCalloutLine\n")); clPoints = HPDF_Array_New ( annot->mmgr); if ( !clPoints) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "CL", clPoints)) != HPDF_OK) return ret; ret += HPDF_Array_AddReal (clPoints, startPoint.x); ret += HPDF_Array_AddReal (clPoints, startPoint.y); ret += HPDF_Array_AddReal (clPoints, kneePoint.x); ret += HPDF_Array_AddReal (clPoints, kneePoint.y); ret += HPDF_Array_AddReal (clPoints, endPoint.x); ret += HPDF_Array_AddReal (clPoints, endPoint.y); if (ret != HPDF_OK) return HPDF_Error_GetCode (clPoints->error); return HPDF_OK; }
HPDF_Destination HPDF_Destination_New (HPDF_MMgr mmgr, HPDF_Page target, HPDF_Xref xref) { HPDF_Destination dst; HPDF_PTRACE((" HPDF_Destination_New\n")); if (!HPDF_Page_Validate (target)) { HPDF_SetError (mmgr->error, HPDF_INVALID_PAGE, 0); return NULL; } dst = HPDF_Array_New (mmgr); if (!dst) return NULL; dst->header.obj_class |= HPDF_OSUBCLASS_DESTINATION; if (HPDF_Xref_Add (xref, dst) != HPDF_OK) return NULL; /* first item of array must be target page */ if (HPDF_Array_Add (dst, target) != HPDF_OK) return NULL; /* default type is HPDF_FIT */ if (HPDF_Array_AddName (dst, HPDF_DESTINATION_TYPE_NAMES[(HPDF_INT)HPDF_FIT]) != HPDF_OK) return NULL; return dst; }
HPDF_3DView_Add3DC3DMeasure(HPDF_Dict view, HPDF_3DMeasure measure) { HPDF_STATUS ret = HPDF_OK; HPDF_Array array; void* a; a = HPDF_Dict_GetItem (view, "MA", HPDF_OCLASS_ARRAY); if ( a ) { array = (HPDF_Array)a; } else { array = HPDF_Array_New (view->mmgr); if (!array) return 0; if (HPDF_Dict_Add (view, "MA", array) != HPDF_OK) return 0; } ret = HPDF_Array_Add(array, measure); return ret; }
/* Generate an ID for the trailer dict, PDF/A needs this. TODO: Better algorithm for generate unique ID. */ HPDF_STATUS HPDF_PDFA_GenerateID(HPDF_Doc pdf) { HPDF_Array id; HPDF_BYTE *currentTime; HPDF_BYTE idkey[HPDF_MD5_KEY_LEN]; HPDF_MD5_CTX md5_ctx; time_t ltime; ltime = time(NULL); currentTime = (HPDF_BYTE *)ctime(<ime); id = HPDF_Dict_GetItem(pdf->trailer, "ID", HPDF_OCLASS_ARRAY); if (!id) { id = HPDF_Array_New(pdf->mmgr); if (!id || HPDF_Dict_Add(pdf->trailer, "ID", id) != HPDF_OK) return pdf->error.error_no; HPDF_MD5Init(&md5_ctx); HPDF_MD5Update(&md5_ctx, (HPDF_BYTE *) "libHaru", sizeof("libHaru") - 1); HPDF_MD5Update(&md5_ctx, currentTime, HPDF_StrLen((const char *)currentTime, -1)); HPDF_MD5Final(idkey, &md5_ctx); if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr, idkey, HPDF_MD5_KEY_LEN)) != HPDF_OK) return pdf->error.error_no; if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr,idkey,HPDF_MD5_KEY_LEN)) != HPDF_OK) return pdf->error.error_no; return HPDF_OK; } return HPDF_OK; }
HPDF_STATUS AddResource (HPDF_Page page) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict resource; HPDF_Array procset; HPDF_PTRACE((" HPDF_Page_AddResource\n")); resource = HPDF_Dict_New (page->mmgr); if (!resource) return HPDF_Error_GetCode (page->error); /* althoth ProcSet-entry is obsolete, add it to resouce for * compatibility */ ret += HPDF_Dict_Add (page, "Resources", resource); procset = HPDF_Array_New (page->mmgr); if (!procset) return HPDF_Error_GetCode (page->error); ret += HPDF_Dict_Add (resource, "ProcSet", procset); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "PDF")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "Text")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageB")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageC")); ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageI")); return ret; }
HPDF_TextMarkupAnnot_SetQuadPoints ( HPDF_Annotation annot, HPDF_Point lb, HPDF_Point rb, HPDF_Point lt, HPDF_Point rt) /* l-left, r-right, b-bottom, t-top positions */ { HPDF_Array quadPoints; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_TextMarkupAnnot_SetQuadPoints\n")); quadPoints = HPDF_Array_New ( annot->mmgr); if ( !quadPoints) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "QuadPoints", quadPoints)) != HPDF_OK) return ret; ret += HPDF_Array_AddReal (quadPoints, lb.x); ret += HPDF_Array_AddReal (quadPoints, lb.y); ret += HPDF_Array_AddReal (quadPoints, rb.x); ret += HPDF_Array_AddReal (quadPoints, rb.y); ret += HPDF_Array_AddReal (quadPoints, lt.x); ret += HPDF_Array_AddReal (quadPoints, lt.y); ret += HPDF_Array_AddReal (quadPoints, rt.x); ret += HPDF_Array_AddReal (quadPoints, rt.y); if (ret != HPDF_OK) return HPDF_Error_GetCode (quadPoints->error); return HPDF_OK; }
HPDF_LinkAnnot_SetBorderStyle (HPDF_Annotation annot, HPDF_REAL width, HPDF_UINT16 dash_on, HPDF_UINT16 dash_off) { HPDF_Array array; HPDF_STATUS ret; HPDF_PTRACE((" HPDF_LinkAnnot_SetBorderStyle\n")); if (!CheckSubType (annot, HPDF_ANNOT_LINK)) return HPDF_INVALID_ANNOTATION; if (width < 0) return HPDF_RaiseError (annot->error, HPDF_INVALID_PARAMETER, 0); array = HPDF_Array_New (annot->mmgr); if (!array) return HPDF_CheckError (annot->error); if ((ret = HPDF_Dict_Add (annot, "Border", array)) != HPDF_OK) return HPDF_CheckError (annot->error); ret += HPDF_Array_AddNumber (array, 0); ret += HPDF_Array_AddNumber (array, 0); ret += HPDF_Array_AddReal (array, width); if (ret != HPDF_OK) return HPDF_CheckError (annot->error); if (dash_on && dash_off) { HPDF_Array dash = HPDF_Array_New (annot->mmgr); if (!dash) return HPDF_CheckError (annot->error); if ((ret = HPDF_Array_Add (array, dash)) != HPDF_OK) return HPDF_CheckError (annot->error); ret += HPDF_Array_AddNumber (dash, dash_on); ret += HPDF_Array_AddNumber (dash, dash_off); if (ret != HPDF_OK) return HPDF_CheckError (annot->error); } return HPDF_OK; }
HPDF_LineAnnot_SetPosition (HPDF_Annotation annot, HPDF_Point startPoint, HPDF_LineAnnotEndingStyle startStyle, HPDF_Point endPoint, HPDF_LineAnnotEndingStyle endStyle) { HPDF_Array lineEndPoints; HPDF_Array lineEndStyles; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_LineAnnot_SetPosition\n")); lineEndPoints = HPDF_Array_New ( annot->mmgr); if ( !lineEndPoints) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "L", lineEndPoints)) != HPDF_OK) return ret; ret += HPDF_Array_AddReal (lineEndPoints, startPoint.x); ret += HPDF_Array_AddReal (lineEndPoints, startPoint.y); ret += HPDF_Array_AddReal (lineEndPoints, endPoint.x); ret += HPDF_Array_AddReal (lineEndPoints, endPoint.y); if (ret != HPDF_OK) return HPDF_Error_GetCode ( lineEndPoints->error); lineEndStyles = HPDF_Array_New ( annot->mmgr); if ( !lineEndStyles) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "LE", lineEndStyles)) != HPDF_OK) return ret; ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)startStyle]); ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)endStyle]); if (ret != HPDF_OK) return HPDF_Error_GetCode ( lineEndStyles->error); return HPDF_OK; }
static HPDF_STATUS CreatePallet (HPDF_Dict image, png_structp png_ptr, png_infop info_ptr) { HPDF_INT num_pl = 0; png_color *src_pl = NULL; HPDF_BYTE *ppallet; HPDF_BYTE *p; HPDF_UINT i; HPDF_Array array; /* png_get_PLTE does not call PngErrorFunc even if it failed. * so we call HPDF_Set_Error to set error-code. */ if (png_get_PLTE(png_ptr, info_ptr, (png_color**)&src_pl, &num_pl) != PNG_INFO_PLTE) return HPDF_SetError (image->error, HPDF_LIBPNG_ERROR, HPDF_CANNOT_GET_PALLET); /* make a pallet array for indexed image. */ ppallet = HPDF_GetMem (image->mmgr, num_pl * 3); if (!ppallet) return image->error->error_no; p = ppallet; for (i = 0; i < num_pl; i++, src_pl++) { *p++ = src_pl->red; *p++ = src_pl->green; *p++ = src_pl->blue; } array = HPDF_Array_New (image->mmgr); if (array) { HPDF_Binary b; HPDF_Dict_Add (image, "ColorSpace", array); HPDF_Array_AddName (array, "Indexed"); HPDF_Array_AddName (array, "DeviceRGB"); HPDF_Array_AddNumber (array, num_pl - 1); b = HPDF_Binary_New (image->mmgr, ppallet, num_pl * 3); if (b) HPDF_Array_Add (array, b); } HPDF_FreeMem (image->mmgr, ppallet); return image->error->error_no; }
HPDF_Annotation HPDF_Annotation_New (HPDF_MMgr mmgr, HPDF_Xref xref, HPDF_AnnotType type, HPDF_Rect rect) { HPDF_Annotation annot; HPDF_Array array; HPDF_STATUS ret = HPDF_OK; HPDF_REAL tmp; HPDF_PTRACE((" HPDF_Annotation_New\n")); annot = HPDF_Dict_New (mmgr); if (!annot) return NULL; if (HPDF_Xref_Add (xref, annot) != HPDF_OK) return NULL; array = HPDF_Array_New (mmgr); if (!array) return NULL; if (HPDF_Dict_Add (annot, "Rect", array) != HPDF_OK) return NULL; if (rect.top < rect.bottom) { tmp = rect.top; rect.top = rect.bottom; rect.bottom = tmp; } ret += HPDF_Array_AddReal (array, rect.left); ret += HPDF_Array_AddReal (array, rect.bottom); ret += HPDF_Array_AddReal (array, rect.right); ret += HPDF_Array_AddReal (array, rect.top); ret += HPDF_Dict_AddName (annot, "Type", "Annot"); ret += HPDF_Dict_AddName (annot, "Subtype", HPDF_ANNOT_TYPE_NAMES[(HPDF_INT)type]); if (ret != HPDF_OK) return NULL; annot->header.obj_class |= HPDF_OSUBCLASS_ANNOTATION; return annot; }
HPDF_Annot_SetNoColor (HPDF_Annotation annot) { HPDF_Array cArray; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_Annot_SetNoColor\n")); cArray = HPDF_Array_New (annot->mmgr); if (!cArray) return HPDF_Error_GetCode ( annot->error); ret = HPDF_Dict_Add (annot, "C", cArray); return ret; }
HPDF_MarkupAnnot_SetInteriorTransparent (HPDF_Annotation annot) /* IC with No Color entry */ { HPDF_Array cArray; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_MarkupAnnot_SetInteriorTransparent\n")); cArray = HPDF_Array_New ( annot->mmgr); if (!cArray) return HPDF_Error_GetCode ( annot->error); ret = HPDF_Dict_Add (annot, "IC", cArray); return ret; }
HPDF_Image_SetColorMask (HPDF_Image image, HPDF_UINT rmin, HPDF_UINT rmax, HPDF_UINT gmin, HPDF_UINT gmax, HPDF_UINT bmin, HPDF_UINT bmax) { HPDF_Array array; const char *name; HPDF_STATUS ret = HPDF_OK; if (!HPDF_Image_Validate (image)) return HPDF_INVALID_IMAGE; if (HPDF_Dict_GetItem (image, "ImageMask", HPDF_OCLASS_BOOLEAN)) return HPDF_RaiseError (image->error, HPDF_INVALID_OPERATION, 0); if (HPDF_Image_GetBitsPerComponent (image) != 8) return HPDF_RaiseError (image->error, HPDF_INVALID_BIT_PER_COMPONENT, 0); name = HPDF_Image_GetColorSpace (image); if (!name || HPDF_StrCmp (COL_RGB, name) != 0) return HPDF_RaiseError (image->error, HPDF_INVALID_COLOR_SPACE, 0); /* Each integer must be in the range 0 to 2^BitsPerComponent - 1 */ if (rmax > 255 || gmax > 255 || bmax > 255) return HPDF_RaiseError (image->error, HPDF_INVALID_PARAMETER, 0); array = HPDF_Array_New (image->mmgr); if (!array) return HPDF_CheckError (image->error); ret += HPDF_Dict_Add (image, "Mask", array); ret += HPDF_Array_AddNumber (array, rmin); ret += HPDF_Array_AddNumber (array, rmax); ret += HPDF_Array_AddNumber (array, gmin); ret += HPDF_Array_AddNumber (array, gmax); ret += HPDF_Array_AddNumber (array, bmin); ret += HPDF_Array_AddNumber (array, bmax); if (ret != HPDF_OK) return HPDF_CheckError (image->error); return HPDF_OK; }
HPDF_STATUS HPDF_PDFA_AppendOutputIntents(HPDF_Doc pdf, const char *iccname, HPDF_Dict iccdict) { HPDF_Array intents; HPDF_Dict intent; HPDF_STATUS ret; if (!HPDF_HasDoc (pdf)) return HPDF_INVALID_DOCUMENT; /* prepare intent */ intent = HPDF_Dict_New (pdf->mmgr); ret = HPDF_Xref_Add (pdf->xref, intent); if ( ret != HPDF_OK) { HPDF_Dict_Free(intent); return ret; } ret += HPDF_Dict_AddName (intent, "Type", "OutputIntent"); ret += HPDF_Dict_AddName (intent, "S", "GTS_PDFA1"); ret += HPDF_Dict_Add (intent, "OutputConditionIdentifier", HPDF_String_New (pdf->mmgr, iccname, NULL)); ret += HPDF_Dict_Add (intent, "OutputCondition", HPDF_String_New (pdf->mmgr, iccname,NULL)); ret += HPDF_Dict_Add (intent, "Info", HPDF_String_New (pdf->mmgr, iccname, NULL)); ret += HPDF_Dict_Add (intent, "DestOutputProfile ", iccdict); if ( ret != HPDF_OK) { HPDF_Dict_Free(intent); return ret; } /* Copied from HPDF_AddIntent - not public function */ intents = HPDF_Dict_GetItem (pdf->catalog, "OutputIntents", HPDF_OCLASS_ARRAY); if (intents == NULL) { intents = HPDF_Array_New (pdf->mmgr); if (intents) { HPDF_STATUS ret = HPDF_Dict_Add (pdf->catalog, "OutputIntents", intents); if (ret != HPDF_OK) { HPDF_CheckError (&pdf->error); return HPDF_Error_GetDetailCode (&pdf->error); } } } HPDF_Array_Add(intents,intent); return HPDF_Error_GetDetailCode (&pdf->error); }
HPDF_Annot_SetGrayColor (HPDF_Annotation annot, HPDF_REAL color) { HPDF_Array cArray; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_Annot_SetGrayColor\n")); cArray = HPDF_Array_New (annot->mmgr); if (!cArray) return HPDF_Error_GetCode ( annot->error); ret += HPDF_Dict_Add (annot, "C", cArray); ret += HPDF_Array_AddReal ( cArray, color); if (ret != HPDF_OK) return HPDF_Error_GetCode ( annot->error); return HPDF_OK; }
HPDF_MarkupAnnot_SetInteriorGrayColor (HPDF_Annotation annot, HPDF_REAL color)/* IC with Gray entry */ { HPDF_Array cArray; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_MarkupAnnot_SetInteriorGrayColor\n")); cArray = HPDF_Array_New ( annot->mmgr); if (!cArray) return HPDF_Error_GetCode ( annot->error); ret += HPDF_Dict_Add (annot, "IC", cArray); ret += HPDF_Array_AddReal (cArray, color); if (ret != HPDF_OK) return HPDF_Error_GetCode ( annot->error); return HPDF_OK; }
HPDF_STATUS HPDF_Catalog_AddPageLabel (HPDF_Catalog catalog, HPDF_UINT page_num, HPDF_Dict page_label) { HPDF_STATUS ret; HPDF_Array nums; HPDF_Dict labels = HPDF_Dict_GetItem (catalog, "PageLabels", HPDF_OCLASS_DICT); HPDF_PTRACE ((" HPDF_Catalog_AddPageLabel\n")); if (!labels) { labels = HPDF_Dict_New (catalog->mmgr); if (!labels) return catalog->error->error_no; if ((ret = HPDF_Dict_Add (catalog, "PageLabels", labels)) != HPDF_OK) return ret; } nums = HPDF_Dict_GetItem (labels, "Nums", HPDF_OCLASS_ARRAY); if (!nums) { nums = HPDF_Array_New (catalog->mmgr); if (!nums) return catalog->error->error_no; if ((ret = HPDF_Dict_Add (labels, "Nums", nums)) != HPDF_OK) return ret; } if ((ret = HPDF_Array_AddNumber (nums, page_num)) != HPDF_OK) return ret; return HPDF_Array_Add (nums, page_label); }
HPDF_FreeTextAnnot_SetLineEndingStyle (HPDF_Annotation annot, HPDF_LineAnnotEndingStyle startStyle, HPDF_LineAnnotEndingStyle endStyle) { HPDF_Array lineEndStyles; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_FreeTextAnnot_SetLineEndingStyle\n")); lineEndStyles = HPDF_Array_New ( annot->mmgr); if ( !lineEndStyles) return HPDF_Error_GetCode ( annot->error); if ((ret = HPDF_Dict_Add ( annot, "LE", lineEndStyles)) != HPDF_OK) return ret; ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)startStyle]); ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)endStyle]); if (ret != HPDF_OK) return HPDF_Error_GetCode (lineEndStyles->error); return HPDF_OK; }
HPDF_STATUS HPDF_Doc_PrepareEncryption (HPDF_Doc pdf) { HPDF_Encrypt e= HPDF_EncryptDict_GetAttr (pdf->encrypt_dict); HPDF_Dict info = GetInfo (pdf); HPDF_Array id; if (!e) return HPDF_DOC_ENCRYPTDICT_NOT_FOUND; if (!info) return pdf->error.error_no; if (HPDF_EncryptDict_Prepare (pdf->encrypt_dict, info, pdf->xref) != HPDF_OK) return pdf->error.error_no; /* reset 'ID' to trailer-dictionary */ id = HPDF_Dict_GetItem (pdf->trailer, "ID", HPDF_OCLASS_ARRAY); if (!id) { id = HPDF_Array_New (pdf->mmgr); if (!id || HPDF_Dict_Add (pdf->trailer, "ID", id) != HPDF_OK) return pdf->error.error_no; } else HPDF_Array_Clear (id); if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr, e->encrypt_id, HPDF_ID_LEN)) != HPDF_OK) return pdf->error.error_no; if (HPDF_Array_Add (id, HPDF_Binary_New (pdf->mmgr, e->encrypt_id, HPDF_ID_LEN)) != HPDF_OK) return pdf->error.error_no; 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; }
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_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_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 = sin((roll/180.0f)*M_PI); cosroll = 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 = fabs(roo); if (roo == 0.0) { roo = 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", roo); failed: if (ret != HPDF_OK) { HPDF_Array_Free (matrix); return ret; } return ret; }