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; }
void* HPDF_Page_GetInheritableItem (HPDF_Page page, const char *key, HPDF_UINT16 obj_class) { HPDF_BOOL chk = HPDF_FALSE; HPDF_INT i = 0; void * obj; HPDF_PTRACE((" HPDF_Page_GetInheritableItem\n")); /* check whether the specified key is valid */ while (HPDF_INHERITABLE_ENTRIES[i]) { if (HPDF_StrCmp (key, HPDF_INHERITABLE_ENTRIES[i]) == 0) { chk = HPDF_TRUE; break; } i++; } /* the key is not inheritable */ if (chk != HPDF_TRUE) { HPDF_SetError (page->error, HPDF_INVALID_PARAMETER, 0); return NULL; } obj = HPDF_Dict_GetItem (page, key, obj_class); /* if resources of the object is NULL, search resources of parent * pages recursivly */ if (!obj) { HPDF_Pages pages = HPDF_Dict_GetItem (page, "Parent", HPDF_OCLASS_DICT); while (pages) { obj = HPDF_Dict_GetItem (page, key, obj_class); if (obj) break; pages = HPDF_Dict_GetItem (pages, "Parent", HPDF_OCLASS_DICT); } } return obj; }
HPDF_PageMode HPDF_Catalog_GetPageMode (HPDF_Catalog catalog) { HPDF_Name mode; HPDF_UINT i = 0; mode = (HPDF_Name)HPDF_Dict_GetItem (catalog, "PageMode", HPDF_OCLASS_NAME); if (!mode) return HPDF_PAGE_MODE_USE_NONE; while (HPDF_PAGE_MODE_NAMES[i]) { if (HPDF_StrCmp (mode->value, HPDF_PAGE_MODE_NAMES[i]) == 0) return (HPDF_PageMode)i; i++; } return HPDF_PAGE_MODE_USE_NONE; }
HPDF_PageLayout HPDF_Catalog_GetPageLayout (HPDF_Catalog catalog) { HPDF_Name layout; HPDF_UINT i = 0; layout = (HPDF_Name)HPDF_Dict_GetItem (catalog, "PageLayout", HPDF_OCLASS_NAME); if (!layout) return HPDF_PAGE_LAYOUT_EOF; while (HPDF_PAGE_LAYOUT_NAMES[i]) { if (HPDF_StrCmp (layout->value, HPDF_PAGE_LAYOUT_NAMES[i]) == 0) return (HPDF_PageLayout)i; i++; } return HPDF_PAGE_LAYOUT_EOF; }
HPDF_Image_AddSMask (HPDF_Image image, HPDF_Image smask) { const char *name; if (!HPDF_Image_Validate (image)) return HPDF_INVALID_IMAGE; if (!HPDF_Image_Validate (smask)) return HPDF_INVALID_IMAGE; if (HPDF_Dict_GetItem (image, "SMask", HPDF_OCLASS_BOOLEAN)) return HPDF_RaiseError (image->error, HPDF_INVALID_OPERATION, 0); name = HPDF_Image_GetColorSpace (smask); if (!name || HPDF_StrCmp (COL_GRAY, name) != 0) return HPDF_RaiseError (smask->error, HPDF_INVALID_COLOR_SPACE, 0); return HPDF_Dict_Add (image, "SMask", smask); }
static HPDF_BOOL CheckSubType (HPDF_Annotation annot, HPDF_AnnotType type) { HPDF_Name subtype; HPDF_PTRACE((" HPDF_Annotation_CheckSubType\n")); if (!HPDF_Annotation_Validate (annot)) return HPDF_FALSE; subtype = HPDF_Dict_GetItem (annot, "Subtype", HPDF_OCLASS_NAME); if (!subtype || HPDF_StrCmp (subtype->value, HPDF_ANNOT_TYPE_NAMES[(HPDF_INT)type]) != 0) { HPDF_RaiseError (annot->error, HPDF_INVALID_ANNOTATION, 0); return HPDF_FALSE; } return HPDF_TRUE; }
HPDF_STATUS HPDF_EncryptDict_SetPassword (HPDF_EncryptDict dict, const char *owner_passwd, const char *user_passwd) { HPDF_Encrypt attr = (HPDF_Encrypt)dict->attr; HPDF_PTRACE((" HPDF_EncryptDict_SetPassword\n")); if (HPDF_StrLen(owner_passwd, 2) == 0) return HPDF_SetError(dict->error, HPDF_ENCRYPT_INVALID_PASSWORD, 0); if (owner_passwd && user_passwd && HPDF_StrCmp (owner_passwd, user_passwd) == 0) return HPDF_SetError(dict->error, HPDF_ENCRYPT_INVALID_PASSWORD, 0); HPDF_PadOrTrancatePasswd (owner_passwd, attr->owner_passwd); HPDF_PadOrTrancatePasswd (user_passwd, attr->user_passwd); return HPDF_OK; }
HPDF_BOOL HPDF_Image_Validate (HPDF_Image image) { HPDF_Name subtype; HPDF_PTRACE ((" HPDF_Image_Validate\n")); if (!image) return HPDF_FALSE; if (image->header.obj_class != (HPDF_OSUBCLASS_XOBJECT | HPDF_OCLASS_DICT)) { HPDF_RaiseError (image->error, HPDF_INVALID_IMAGE, 0); return HPDF_FALSE; } subtype = HPDF_Dict_GetItem (image, "Subtype", HPDF_OCLASS_NAME); if (!subtype || HPDF_StrCmp (subtype->value, "Image") != 0) { HPDF_RaiseError (image->error, HPDF_INVALID_IMAGE, 0); return HPDF_FALSE; } return HPDF_TRUE; }
HPDF_EXPORT(HPDF_STATUS) HPDF_U3D_Set3DActivation(HPDF_Annotation u3dAnnotation, HPDF_Dict activation) { HPDF_STATUS ret = HPDF_OK; HPDF_Name subtype; HPDF_PTRACE ((" HPDF_U3D_Set3DActivation\n")); if (u3d == NULL || activation == NULL) { return HPDF_INVALID_U3D_DATA; } subtype = HPDF_Dict_GetItem (u3dAnnotation, "Subtype", HPDF_OCLASS_NAME); if (!subtype || HPDF_StrCmp (subtype->value, "3D") != 0) { HPDF_RaiseError (u3dAnnotation->error, HPDF_INVALID_ANNOTATION, 0); return HPDF_FALSE; } ret = HPDF_Dict_Add(u3dAnnotation, "3DA", activation); return ret; }
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; }
HPDF_GetFont (HPDF_Doc pdf, const char *font_name, const char *encoding_name) { HPDF_FontDef fontdef = NULL; HPDF_Encoder encoder = NULL; HPDF_Font font; HPDF_PTRACE ((" HPDF_GetFont\n")); if (!HPDF_HasDoc (pdf)) return NULL; if (!font_name) { HPDF_RaiseError (&pdf->error, HPDF_INVALID_FONT_NAME, 0); return NULL; } /* if encoding-name is not specified, find default-encoding of fontdef */ if (!encoding_name) { fontdef = HPDF_GetFontDef (pdf, font_name); if (fontdef) { HPDF_Type1FontDefAttr attr = (HPDF_Type1FontDefAttr)fontdef->attr; if (fontdef->type == HPDF_FONTDEF_TYPE_TYPE1 && HPDF_StrCmp (attr->encoding_scheme, HPDF_ENCODING_FONT_SPECIFIC) == 0) encoder = HPDF_GetEncoder (pdf, HPDF_ENCODING_FONT_SPECIFIC); else encoder = HPDF_GetEncoder (pdf, HPDF_ENCODING_STANDARD); } else { HPDF_CheckError (&pdf->error); return NULL; } if (!encoder) { HPDF_CheckError (&pdf->error); return NULL; } font = HPDF_Doc_FindFont (pdf, font_name, encoder->name); } else { font = HPDF_Doc_FindFont (pdf, font_name, encoding_name); } if (font) return font; if (!fontdef) { fontdef = HPDF_GetFontDef (pdf, font_name); if (!fontdef) { HPDF_CheckError (&pdf->error); return NULL; } } if (!encoder) { encoder = HPDF_GetEncoder (pdf, encoding_name); if (!encoder) return NULL; } switch (fontdef->type) { case HPDF_FONTDEF_TYPE_TYPE1: font = HPDF_Type1Font_New (pdf->mmgr, fontdef, encoder, pdf->xref); if (font) HPDF_List_Add (pdf->font_mgr, font); break; case HPDF_FONTDEF_TYPE_TRUETYPE: if (encoder->type == HPDF_ENCODER_TYPE_DOUBLE_BYTE) font = HPDF_Type0Font_New (pdf->mmgr, fontdef, encoder, pdf->xref); else font = HPDF_TTFont_New (pdf->mmgr, fontdef, encoder, pdf->xref); if (font) HPDF_List_Add (pdf->font_mgr, font); break; case HPDF_FONTDEF_TYPE_CID: font = HPDF_Type0Font_New (pdf->mmgr, fontdef, encoder, pdf->xref); if (font) HPDF_List_Add (pdf->font_mgr, font); break; default: HPDF_RaiseError (&pdf->error, HPDF_UNSUPPORTED_FONT_TYPE, 0); return NULL; } if (!font) HPDF_CheckError (&pdf->error); if (font && (pdf->compression_mode & HPDF_COMP_METADATA)) font->filter = HPDF_STREAM_FILTER_FLATE_DECODE; return font; }
static HPDF_STATUS LoadAfm (HPDF_FontDef fontdef, HPDF_Stream stream) { HPDF_Type1FontDefAttr attr = (HPDF_Type1FontDefAttr)fontdef->attr; char buf[HPDF_TMP_BUF_SIZ]; HPDF_CharData* cdata; HPDF_STATUS ret; HPDF_UINT len; char keyword[HPDF_LIMIT_MAX_NAME_LEN + 1]; HPDF_UINT i; HPDF_PTRACE (" LoadAfm\n"); len = HPDF_TMP_BUF_SIZ; /* chaeck AFM header */ if ((ret = HPDF_Stream_ReadLn (stream, buf, &len)) != HPDF_OK) return ret; GetKeyword (buf, keyword, HPDF_LIMIT_MAX_NAME_LEN + 1); if (HPDF_StrCmp (keyword, "StartFontMetrics") != 0) return HPDF_INVALID_AFM_HEADER; /* Global Font Information */ for (;;) { const char *s; len = HPDF_TMP_BUF_SIZ; if ((ret = HPDF_Stream_ReadLn (stream, buf, &len)) != HPDF_OK) return ret; s = GetKeyword (buf, keyword, HPDF_LIMIT_MAX_NAME_LEN + 1); if (HPDF_StrCmp (keyword, "FontName") == 0) { HPDF_StrCpy (fontdef->base_font, s, fontdef->base_font + HPDF_LIMIT_MAX_NAME_LEN); } else if (HPDF_StrCmp (keyword, "Weight") == 0) { if (HPDF_StrCmp (s, "Bold") == 0) fontdef->flags |= HPDF_FONT_FOURCE_BOLD; } else if (HPDF_StrCmp (keyword, "IsFixedPitch") == 0) { if (HPDF_StrCmp (s, "true") == 0) fontdef->flags |= HPDF_FONT_FIXED_WIDTH; } else if (HPDF_StrCmp (keyword, "ItalicAngle") == 0) { fontdef->italic_angle = (HPDF_INT16)HPDF_AToI (s); if (fontdef->italic_angle != 0) fontdef->flags |= HPDF_FONT_ITALIC; } else if (HPDF_StrCmp (keyword, "CharacterSet") == 0) { HPDF_UINT len = HPDF_StrLen (s, HPDF_LIMIT_MAX_STRING_LEN); if (len > 0) { attr->char_set = HPDF_GetMem (fontdef->mmgr, len + 1); if (!attr->char_set) return HPDF_Error_GetCode (fontdef->error); HPDF_StrCpy (attr->char_set, s, attr->char_set + len); } } else if (HPDF_StrCmp (keyword, "FontBBox") == 0) { char buf[HPDF_INT_LEN + 1]; s = GetKeyword (s, buf, HPDF_INT_LEN + 1); fontdef->font_bbox.left = (HPDF_REAL)HPDF_AToI (buf); s = GetKeyword (s, buf, HPDF_INT_LEN + 1); fontdef->font_bbox.bottom = (HPDF_REAL)HPDF_AToI (buf); s = GetKeyword (s, buf, HPDF_INT_LEN + 1); fontdef->font_bbox.right = (HPDF_REAL)HPDF_AToI (buf); GetKeyword (s, buf, HPDF_INT_LEN + 1); fontdef->font_bbox.top = (HPDF_REAL)HPDF_AToI (buf); } else if (HPDF_StrCmp (keyword, "EncodingScheme") == 0) { HPDF_StrCpy (attr->encoding_scheme, s, attr->encoding_scheme + HPDF_LIMIT_MAX_NAME_LEN); } else if (HPDF_StrCmp (keyword, "CapHeight") == 0) { fontdef->cap_height = (HPDF_UINT16)HPDF_AToI (s); } else if (HPDF_StrCmp (keyword, "Ascender") == 0) { fontdef->ascent = (HPDF_INT16)HPDF_AToI (s); } else if (HPDF_StrCmp (keyword, "Descender") == 0) { fontdef->descent = (HPDF_INT16)HPDF_AToI (s); } else if (HPDF_StrCmp (keyword, "STDHW") == 0) { fontdef->stemh = (HPDF_UINT16)HPDF_AToI (s); } else if (HPDF_StrCmp (keyword, "STDHV") == 0) { fontdef->stemv = (HPDF_UINT16)HPDF_AToI (s); } else if (HPDF_StrCmp (keyword, "StartCharMetrics") == 0) { attr->widths_count = HPDF_AToI (s); break; } } cdata = (HPDF_CharData*)HPDF_GetMem (fontdef->mmgr, sizeof(HPDF_CharData) * attr->widths_count); if (cdata == NULL) return HPDF_Error_GetCode (fontdef->error); HPDF_MemSet (cdata, 0, sizeof(HPDF_CharData) * attr->widths_count); attr->widths = cdata; /* load CharMetrics */ for (i = 0; i < attr->widths_count; i++, cdata++) { const char *s; char buf2[HPDF_LIMIT_MAX_NAME_LEN + 1]; len = HPDF_TMP_BUF_SIZ; if ((ret = HPDF_Stream_ReadLn (stream, buf, &len)) != HPDF_OK) return ret; /* C default character code. */ s = GetKeyword (buf, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1); if (HPDF_StrCmp (buf2, "CX") == 0) { /* not suppoted yet. */ return HPDF_SetError (fontdef->error, HPDF_INVALID_CHAR_MATRICS_DATA, 0); } else if (HPDF_StrCmp (buf2, "C") == 0) { s += 2; s = GetKeyword (s, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1); HPDF_AToI (buf2); cdata->char_cd = (HPDF_INT16)HPDF_AToI (buf2); } else return HPDF_SetError (fontdef->error, HPDF_INVALID_CHAR_MATRICS_DATA, 0); /* WX Character width */ s = HPDF_StrStr (s, "WX ", 0); if (!s) return HPDF_SetError (fontdef->error, HPDF_INVALID_WX_DATA, 0); s += 3; s = GetKeyword (s, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1); if (buf2[0] == 0) return HPDF_SetError (fontdef->error, HPDF_INVALID_WX_DATA, 0); cdata->width = (HPDF_INT16)HPDF_AToI (buf2); /* N PostScript language character name */ s = HPDF_StrStr (s, "N ", 0); if (!s) return HPDF_SetError (fontdef->error, HPDF_INVALID_N_DATA, 0); s += 2; GetKeyword (s, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1); cdata->unicode = HPDF_GryphNameToUnicode (buf2); } return HPDF_OK; }