自学教程：C++ HPDF_RaiseError函数代码示例

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_PagesHPDF_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_FontDefHPDF_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_AnnotationHPDF_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_ImageHPDF_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_STATUSExtGState_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_STATUSHPDF_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_BOOLHPDF_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;}