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;
}
