HPDF_ReadFromStream (HPDF_Doc pdf, HPDF_BYTE *buf, HPDF_UINT32 *size) { HPDF_UINT isize = *size; HPDF_STATUS ret; if (!HPDF_HasDoc (pdf)) return HPDF_INVALID_DOCUMENT; if (!HPDF_Stream_Validate (pdf->stream)) return HPDF_RaiseError (&pdf->error, HPDF_INVALID_OPERATION, 0); if (*size == 0) return HPDF_RaiseError (&pdf->error, HPDF_INVALID_PARAMETER, 0); ret = HPDF_Stream_Read (pdf->stream, buf, &isize); *size = isize; if (ret != HPDF_OK) HPDF_CheckError (&pdf->error); return ret; }
HPDF_SetPagesConfiguration (HPDF_Doc pdf, HPDF_UINT page_per_pages) { HPDF_PTRACE ((" HPDF_SetPagesConfiguration\n")); if (!HPDF_HasDoc (pdf)) return HPDF_INVALID_DOCUMENT; if (pdf->cur_page) return HPDF_RaiseError (&pdf->error, HPDF_INVALID_DOCUMENT_STATE, 0); if (page_per_pages > HPDF_LIMIT_MAX_ARRAY) return HPDF_RaiseError (&pdf->error, HPDF_INVALID_PARAMETER, 0); if (pdf->cur_pages == pdf->root_pages) { pdf->cur_pages = HPDF_Doc_AddPagesTo (pdf, pdf->root_pages); if (!pdf->cur_pages) return pdf->error.error_no; pdf->cur_page_num = 0; } pdf->page_per_pages = page_per_pages; return HPDF_OK; }
HPDF_Font_MeasureText (HPDF_Font font, const HPDF_BYTE *text, HPDF_UINT len, HPDF_REAL width, HPDF_REAL font_size, HPDF_REAL char_space, HPDF_REAL word_space, HPDF_BOOL wordwrap, HPDF_REAL *real_width) { HPDF_FontAttr attr; HPDF_PTRACE ((" HPDF_Font_MeasureText\n")); if (!HPDF_Font_Validate(font)) return 0; if (len > HPDF_LIMIT_MAX_STRING_LEN) { HPDF_RaiseError (font->error, HPDF_STRING_OUT_OF_RANGE, 0); return 0; } attr = (HPDF_FontAttr)font->attr; if (!attr->measure_text_fn) { HPDF_RaiseError (font->error, HPDF_INVALID_OBJECT, 0); return 0; } return attr->measure_text_fn (font, text, len, width, font_size, char_space, word_space, wordwrap, real_width); }
HPDF_Pages HPDF_Doc_AddPagesTo (HPDF_Doc pdf, HPDF_Pages parent) { HPDF_Pages pages; HPDF_PTRACE ((" HPDF_AddPagesTo\n")); if (!HPDF_HasDoc (pdf)) return NULL; if (!HPDF_Pages_Validate (parent)) { HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGES, 0); return NULL; } /* check whether the page belong to the pdf */ if (pdf->mmgr != parent->mmgr) { HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGES, 0); return NULL; } pages = HPDF_Pages_New (pdf->mmgr, parent, pdf->xref); if (pages) pdf->cur_pages = pages; else HPDF_CheckError (&pdf->error); return pages; }
HPDF_Page_MeasureText (HPDF_Page page, const char *text, HPDF_REAL width, HPDF_BOOL wordwrap, HPDF_REAL *real_width) { HPDF_PageAttr attr; HPDF_UINT len = HPDF_StrLen(text, HPDF_LIMIT_MAX_STRING_LEN + 1); HPDF_UINT ret; if (!HPDF_Page_Validate (page) || len == 0) return 0; attr = (HPDF_PageAttr )page->attr; HPDF_PTRACE((" HPDF_Page_MeasureText\n")); /* no font exists */ if (!attr->gstate->font) { HPDF_RaiseError (page->error, HPDF_PAGE_FONT_NOT_FOUND, 0); return 0; } ret = HPDF_Font_MeasureText (attr->gstate->font, (HPDF_BYTE *)text, len, width, attr->gstate->font_size, attr->gstate->char_space, attr->gstate->word_space, wordwrap, real_width); HPDF_CheckError (page->error); return ret; }
HPDF_GetEncoder (HPDF_Doc pdf, const char *encoding_name) { HPDF_Encoder encoder; HPDF_STATUS ret; HPDF_PTRACE ((" HPDF_GetEncoder\n")); if (!HPDF_HasDoc (pdf)) return NULL; encoder = HPDF_Doc_FindEncoder (pdf, encoding_name); if (!encoder) { encoder = HPDF_BasicEncoder_New (pdf->mmgr, encoding_name); if (!encoder) { HPDF_CheckError (&pdf->error); return NULL; } if ((ret = HPDF_List_Add (pdf->encoder_list, encoder)) != HPDF_OK) { HPDF_Encoder_Free (encoder); HPDF_RaiseError (&pdf->error, ret, 0); return NULL; } } return encoder; }
HPDF_AddPageLabel (HPDF_Doc pdf, HPDF_UINT page_num, HPDF_PageNumStyle style, HPDF_UINT first_page, const char *prefix) { HPDF_Dict page_label; HPDF_STATUS ret; HPDF_PTRACE ((" HPDF_AddPageLabel\n")); if (!HPDF_HasDoc (pdf)) return HPDF_INVALID_DOCUMENT; page_label = HPDF_PageLabel_New (pdf, style, first_page, prefix); if (!page_label) return HPDF_CheckError (&pdf->error); if (style < 0 || style >= HPDF_PAGE_NUM_STYLE_EOF) return HPDF_RaiseError (&pdf->error, HPDF_PAGE_NUM_STYLE_OUT_OF_RANGE, (HPDF_STATUS)style); ret = HPDF_Catalog_AddPageLabel (pdf->catalog, page_num, page_label); if (ret != HPDF_OK) return HPDF_CheckError (&pdf->error); return HPDF_OK; }
HPDF_FontDef HPDF_GetFontDef (HPDF_Doc pdf, const char *font_name) { HPDF_STATUS ret; HPDF_FontDef def; HPDF_PTRACE ((" HPDF_GetFontDef\n")); if (!HPDF_HasDoc (pdf)) return NULL; def = HPDF_Doc_FindFontDef (pdf, font_name); if (!def) { def = HPDF_Base14FontDef_New (pdf->mmgr, font_name); if (!def) return NULL; if ((ret = HPDF_List_Add (pdf->fontdef_list, def)) != HPDF_OK) { HPDF_FontDef_Free (def); HPDF_RaiseError (&pdf->error, ret, 0); def = NULL; } } return def; }
HPDF_Destination_SetXYZ (HPDF_Destination dst, HPDF_REAL left, HPDF_REAL top, HPDF_REAL zoom) { HPDF_STATUS ret = HPDF_OK; HPDF_Page target; HPDF_PTRACE((" HPDF_Destination_SetXYZ\n")); if (!HPDF_Destination_Validate (dst)) return HPDF_INVALID_DESTINATION; if (left < 0 || top < 0 || zoom < 0.08 || zoom > 32) return HPDF_RaiseError (dst->error, HPDF_INVALID_PARAMETER, 0); target = (HPDF_Page)HPDF_Array_GetItem (dst, 0, HPDF_OCLASS_DICT); if (dst->list->count > 1) { HPDF_Array_Clear (dst); ret += HPDF_Array_Add (dst, target); } ret += HPDF_Array_AddName (dst, HPDF_DESTINATION_TYPE_NAMES[(HPDF_INT)HPDF_XYZ]); ret += HPDF_Array_AddReal (dst, left); ret += HPDF_Array_AddReal (dst, top); ret += HPDF_Array_AddReal (dst, zoom); if (ret != HPDF_OK) return HPDF_CheckError (dst->error); return HPDF_OK; }
HPDF_Page_SetSize (HPDF_Page page, HPDF_PageSizes size, HPDF_PageDirection direction) { HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_Page_SetSize\n")); if (!HPDF_Page_Validate (page)) return HPDF_INVALID_PAGE; if ((int)size < 0 || size > HPDF_PAGE_SIZE_EOF) //CAL:Supress "comparison of unsigned expression < 0 is always false" warning return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_SIZE, (HPDF_STATUS)direction); if (direction == HPDF_PAGE_LANDSCAPE) { ret += HPDF_Page_SetHeight (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x); ret += HPDF_Page_SetWidth (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y); } else if (direction == HPDF_PAGE_PORTRAIT) { ret += HPDF_Page_SetHeight (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y); ret += HPDF_Page_SetWidth (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x); } else ret = HPDF_SetError (page->error, HPDF_PAGE_INVALID_DIRECTION, (HPDF_STATUS)direction); if (ret != HPDF_OK) return HPDF_CheckError (page->error); return HPDF_OK; }
HPDF_Page_SetSize (HPDF_Page page, HPDF_PageSizes size, HPDF_PageDirection direction) { HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE((" HPDF_Page_SetSize\n")); if (!HPDF_Page_Validate (page)) return HPDF_INVALID_PAGE; if (size < 0 || size > HPDF_PAGE_SIZE_EOF) return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_SIZE, (HPDF_STATUS)direction); if (direction == HPDF_PAGE_LANDSCAPE) { ret += HPDF_Page_SetHeight (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x); ret += HPDF_Page_SetWidth (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y); } else if (direction == HPDF_PAGE_PORTRAIT) { ret += HPDF_Page_SetHeight (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].y); ret += HPDF_Page_SetWidth (page, HPDF_PREDEFINED_PAGE_SIZES[(HPDF_UINT)size].x); } else ret = HPDF_SetError (page->error, HPDF_PAGE_INVALID_DIRECTION, (HPDF_STATUS)direction); if (ret != HPDF_OK) return HPDF_CheckError (page->error); return HPDF_OK; }
HPDF_Annotation HPDF_Page_CreateTextMarkupAnnot (HPDF_Page page, HPDF_Rect rect, const char *text, HPDF_Encoder encoder, HPDF_AnnotType subType) { HPDF_PageAttr attr; HPDF_Annotation annot; HPDF_PTRACE((" HPDF_Page_CreateTextMarkupAnnot\n")); if (!HPDF_Page_Validate (page)) return NULL; attr = (HPDF_PageAttr)page->attr; if (encoder && !HPDF_Encoder_Validate (encoder)) { HPDF_RaiseError (page->error, HPDF_INVALID_ENCODER, 0); return NULL; } annot = HPDF_MarkupAnnot_New ( page->mmgr, attr->xref, rect, text, encoder, subType); if (annot) { if (AddAnnotation (page, annot) != HPDF_OK) { HPDF_CheckError (page->error); annot = NULL; } } else HPDF_CheckError (page->error); return annot; }
HPDF_Page_CreateURILinkAnnot (HPDF_Page page, HPDF_Rect rect, const char *uri) { HPDF_PageAttr attr; HPDF_Annotation annot; HPDF_PTRACE((" HPDF_Page_CreateURILinkAnnot\n")); if (!HPDF_Page_Validate (page)) return NULL; attr = (HPDF_PageAttr)page->attr; if (HPDF_StrLen (uri, HPDF_LIMIT_MAX_STRING_LEN) <= 0) { HPDF_RaiseError (page->error, HPDF_INVALID_URI, 0); return NULL; } annot = HPDF_URILinkAnnot_New (page->mmgr, attr->xref, rect, uri); if (annot) { if (AddAnnotation (page, annot) != HPDF_OK) { HPDF_CheckError (page->error); annot = NULL; } } else HPDF_CheckError (page->error); return annot; }
HPDF_Font_TextWidth (HPDF_Font font, const HPDF_BYTE *text, HPDF_UINT len) { HPDF_TextWidth tw = {0, 0, 0, 0}; HPDF_FontAttr attr; HPDF_PTRACE ((" HPDF_Font_TextWidth\n")); if (!HPDF_Font_Validate(font)) return tw; if (len > HPDF_LIMIT_MAX_STRING_LEN) { HPDF_RaiseError (font->error, HPDF_STRING_OUT_OF_RANGE, 0); return tw; } attr = (HPDF_FontAttr)font->attr; if (!attr->text_width_fn) { HPDF_SetError (font->error, HPDF_INVALID_OBJECT, 0); return tw; } tw = attr->text_width_fn (font, text, len); return tw; }
HPDF_Image HPDF_Image_LoadJpegImageFromMem (HPDF_MMgr mmgr, const HPDF_BYTE *buf, HPDF_UINT size, HPDF_Xref xref) { HPDF_Stream jpeg_data; HPDF_Image image; HPDF_PTRACE ((" HPDF_Image_LoadJpegImageFromMem\n")); jpeg_data = HPDF_MemStream_New(mmgr,size); if (!HPDF_Stream_Validate (jpeg_data)) { HPDF_RaiseError (mmgr->error, HPDF_INVALID_STREAM, 0); return NULL; } if (HPDF_Stream_Write (jpeg_data, buf, size) != HPDF_OK) { HPDF_Stream_Free (jpeg_data); return NULL; } image = HPDF_Image_LoadJpegImage(mmgr,jpeg_data,xref); /* destroy file stream */ HPDF_Stream_Free (jpeg_data); return image; }
HPDF_Page_TextWidth (HPDF_Page page, const char *text) { HPDF_PageAttr attr; HPDF_TextWidth tw; HPDF_REAL ret = 0; HPDF_UINT len = HPDF_StrLen(text, HPDF_LIMIT_MAX_STRING_LEN + 1); HPDF_PTRACE((" HPDF_Page_TextWidth\n")); if (!HPDF_Page_Validate (page) || len == 0) return 0; attr = (HPDF_PageAttr )page->attr; /* no font exists */ if (!attr->gstate->font) { HPDF_RaiseError (page->error, HPDF_PAGE_FONT_NOT_FOUND, 0); return 0; } tw = HPDF_Font_TextWidth (attr->gstate->font, (HPDF_BYTE *)text, len); ret += attr->gstate->word_space * tw.numspace; ret += tw.width * attr->gstate->font_size / 1000; ret += attr->gstate->char_space * tw.numchars; HPDF_CheckError (page->error); return ret; }
HPDF_Page_CreateLinkAnnot (HPDF_Page page, HPDF_Rect rect, HPDF_Destination dst) { HPDF_PageAttr attr; HPDF_Annotation annot; HPDF_PTRACE((" HPDF_Page_CreateLinkAnnot\n")); if (!HPDF_Page_Validate (page)) return NULL; attr = (HPDF_PageAttr)page->attr; if (!HPDF_Destination_Validate (dst)) { HPDF_RaiseError (page->error, HPDF_INVALID_DESTINATION, 0); return NULL; } annot = HPDF_LinkAnnot_New (page->mmgr, attr->xref, rect, dst); if (annot) { if (AddAnnotation (page, annot) != HPDF_OK) { HPDF_CheckError (page->error); annot = NULL; } } else HPDF_CheckError (page->error); return annot; }
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_AddPage (HPDF_Doc pdf) { HPDF_Page page; HPDF_STATUS ret; HPDF_PTRACE ((" HPDF_AddPage\n")); if (!HPDF_HasDoc (pdf)) return NULL; if (pdf->page_per_pages) { if (pdf->page_per_pages <= pdf->cur_page_num) { pdf->cur_pages = HPDF_Doc_AddPagesTo (pdf, pdf->root_pages); if (!pdf->cur_pages) return NULL; pdf->cur_page_num = 0; } } page = HPDF_Page_New (pdf->mmgr, pdf->xref); if (!page) { HPDF_CheckError (&pdf->error); return NULL; } if ((ret = HPDF_Pages_AddKids (pdf->cur_pages, page)) != HPDF_OK) { HPDF_RaiseError (&pdf->error, ret, 0); return NULL; } if ((ret = HPDF_List_Add (pdf->page_list, page)) != HPDF_OK) { HPDF_RaiseError (&pdf->error, ret, 0); return NULL; } pdf->cur_page = page; if (pdf->compression_mode & HPDF_COMP_TEXT) HPDF_Page_SetFilter (page, HPDF_STREAM_FILTER_FLATE_DECODE); pdf->cur_page_num++; return page; }
HPDF_InsertPage (HPDF_Doc pdf, HPDF_Page target) { HPDF_Page page; HPDF_STATUS ret; HPDF_PTRACE ((" HPDF_InsertPage\n")); if (!HPDF_HasDoc (pdf)) return NULL; if (!HPDF_Page_Validate (target)) { HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGE, 0); return NULL; } /* check whether the page belong to the pdf */ if (pdf->mmgr != target->mmgr) { HPDF_RaiseError (&pdf->error, HPDF_INVALID_PAGE, 0); return NULL; } page = HPDF_Page_New (pdf->mmgr, pdf->xref); if (!page) { HPDF_CheckError (&pdf->error); return NULL; } if ((ret = HPDF_Page_InsertBefore (page, target)) != HPDF_OK) { HPDF_RaiseError (&pdf->error, ret, 0); return NULL; } if ((ret = HPDF_List_Insert (pdf->page_list, target, page)) != HPDF_OK) { HPDF_RaiseError (&pdf->error, ret, 0); return NULL; } if (pdf->compression_mode & HPDF_COMP_TEXT) HPDF_Page_SetFilter (page, HPDF_STREAM_FILTER_FLATE_DECODE); return page; }
HPDF_ResetStream (HPDF_Doc pdf) { if (!HPDF_HasDoc (pdf)) return HPDF_INVALID_DOCUMENT; if (!HPDF_Stream_Validate (pdf->stream)) return HPDF_RaiseError (&pdf->error, HPDF_INVALID_OPERATION, 0); return HPDF_Stream_Seek (pdf->stream, 0, HPDF_SEEK_SET); }
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); }
HPDF_Page_SetHeight (HPDF_Page page, HPDF_REAL value) { HPDF_PTRACE((" HPDF_Page_SetWidth\n")); if (value < 3 || value > 14400) return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_SIZE, 0); if (HPDF_Page_SetBoxValue (page, "MediaBox", 3, value) != HPDF_OK) return HPDF_CheckError (page->error); return HPDF_OK; }
HPDF_HasDoc (HPDF_Doc pdf) { HPDF_PTRACE ((" HPDF_HasDoc\n")); if (!pdf || pdf->sig_bytes != HPDF_SIG_BYTES) return HPDF_FALSE; if (!pdf->catalog || pdf->error.error_no != HPDF_NOERROR) { HPDF_RaiseError (&pdf->error, HPDF_INVALID_DOCUMENT, 0); return HPDF_FALSE; } else return HPDF_TRUE; }
HPDF_STATUS ExtGState_Check (HPDF_ExtGState ext_gstate) { if (!HPDF_ExtGState_Validate (ext_gstate)) return HPDF_INVALID_OBJECT; if (ext_gstate->header.obj_class == (HPDF_OSUBCLASS_EXT_GSTATE_R | HPDF_OCLASS_DICT)) return HPDF_RaiseError (ext_gstate->error, HPDF_EXT_GSTATE_READ_ONLY, 0); return HPDF_OK; }
HPDF_SetEncryptionMode (HPDF_Doc pdf, HPDF_EncryptMode mode, HPDF_UINT key_len) { HPDF_Encrypt e; HPDF_PTRACE ((" HPDF_SetEncryptionMode\n")); if (!HPDF_Doc_Validate (pdf)) return HPDF_DOC_INVALID_OBJECT; e = HPDF_EncryptDict_GetAttr (pdf->encrypt_dict); if (!e) return HPDF_RaiseError (&pdf->error, HPDF_DOC_ENCRYPTDICT_NOT_FOUND, 0); else { if (mode == HPDF_ENCRYPT_R2) e->key_len = 5; else { /* if encryption mode is specified revision-3, the version of * pdf file is set to 1.4 */ pdf->pdf_version = HPDF_VER_14; if (key_len >= 5 && key_len <= 16) e->key_len = key_len; else if (key_len == 0) e->key_len = 16; else return HPDF_RaiseError (&pdf->error, HPDF_INVALID_ENCRYPT_KEY_LEN, 0); } e->mode = mode; } return HPDF_OK; }
HPDF_ExtGState_SetAlphaStroke (HPDF_ExtGState ext_gstate, HPDF_REAL value) { HPDF_STATUS ret = ExtGState_Check (ext_gstate); if (ret != HPDF_OK) return ret; if (value < 0 || value > 1.0f) return HPDF_RaiseError (ext_gstate->error, HPDF_EXT_GSTATE_OUT_OF_RANGE, 0); return HPDF_Dict_AddReal (ext_gstate, "CA", value); }
HPDF_ExtGState_SetBlendMode (HPDF_ExtGState ext_gstate, HPDF_BlendMode bmode) { HPDF_STATUS ret = ExtGState_Check (ext_gstate); if (ret != HPDF_OK) return ret; if ((int)bmode < 0 || (int)bmode > (int)HPDF_BM_EOF) return HPDF_RaiseError (ext_gstate->error, HPDF_EXT_GSTATE_OUT_OF_RANGE, 0); return HPDF_Dict_AddName (ext_gstate, "BM", HPDF_BM_NAMES[(int)bmode]); }
HPDF_STATUS HPDF_Page_CheckState (HPDF_Page page, HPDF_UINT mode) { if (!page) return HPDF_INVALID_OBJECT; if (page->header.obj_class != (HPDF_OSUBCLASS_PAGE | HPDF_OCLASS_DICT)) return HPDF_INVALID_PAGE; if (!(((HPDF_PageAttr)page->attr)->gmode & mode)) return HPDF_RaiseError (page->error, HPDF_PAGE_INVALID_GMODE, 0); 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; }