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

HPDF_LoadPngImageFromFile  (HPDF_Doc  pdf,					const HPDF_CHAR  *filename){    HPDF_Stream imagedata;    HPDF_Image image;    HPDF_PTRACE ((" HPDF_LoadPngImageFromFile/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    /* create file stream */    imagedata = HPDF_FileReader_New (pdf->mmgr, filename);    if (HPDF_Stream_Validate (imagedata))        image = LoadPngImageFromStream (pdf, imagedata, HPDF_FALSE);    else        image = NULL;    /* destroy file stream */    if (imagedata)        HPDF_Stream_Free (imagedata);    if (!image)        HPDF_CheckError (&pdf->error);    return image;}

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

/* * Class:     org_libharu_PdfDocument * Method:    hasDoc * Signature: (I)Z */JNIEXPORT jboolean JNICALLJava_org_libharu_PdfDocument_hasDoc(JNIEnv *env, jclass cls, jint pdf) {    if (HPDF_HasDoc((HPDF_Doc) pdf)) {        return JNI_TRUE;    }    return JNI_FALSE;}

HPDF_LoadTTFontFromFile2 (HPDF_Doc         pdf,                          const char      *file_name,                          HPDF_UINT        index,                          HPDF_BOOL        embedding){    HPDF_Stream font_data;    const char *ret;    HPDF_PTRACE ((" HPDF_LoadTTFontFromFile2/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    /* create file stream */    font_data = HPDF_FileReader_New (pdf->mmgr, file_name);    if (HPDF_Stream_Validate (font_data)) {        ret = LoadTTFontFromStream2 (pdf, font_data, index, embedding, file_name);    } else        ret = NULL;    if (!ret)        HPDF_CheckError (&pdf->error);    return ret;}

HPDF_LoadRawImageFromFile  (HPDF_Doc          pdf,                            const char       *filename,                            HPDF_UINT         width,                            HPDF_UINT         height,                            HPDF_ColorSpace   color_space){    HPDF_Stream imagedata;    HPDF_Image image;    HPDF_PTRACE ((" HPDF_LoadRawImageFromFile/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    /* create file stream */    imagedata = HPDF_FileReader_New (pdf->mmgr, filename);    if (HPDF_Stream_Validate (imagedata))        image = HPDF_Image_LoadRawImage (pdf->mmgr, imagedata, pdf->xref, width,                    height, color_space);    else        image = NULL;    /* destroy file stream */    HPDF_Stream_Free (imagedata);    if (!image)        HPDF_CheckError (&pdf->error);    if (image && pdf->compression_mode & HPDF_COMP_IMAGE)        image->filter = HPDF_STREAM_FILTER_FLATE_DECODE;    return image;}

static const char*LoadType1FontFromStream  (HPDF_Doc      pdf,                          HPDF_Stream   afmdata,                          HPDF_Stream   pfmdata){    HPDF_FontDef def;    HPDF_PTRACE ((" HPDF_LoadType1FontFromStream/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    def = HPDF_Type1FontDef_Load (pdf->mmgr, afmdata, pfmdata);    if (def) {        HPDF_FontDef  tmpdef = HPDF_Doc_FindFontDef (pdf, def->base_font);        if (tmpdef) {            HPDF_FontDef_Free (def);            HPDF_SetError (&pdf->error, HPDF_FONT_EXISTS, 0);            return NULL;        }        if (HPDF_List_Add (pdf->fontdef_list, def) != HPDF_OK) {            HPDF_FontDef_Free (def);            return NULL;        }        return def->base_font;    }    return NULL;}

HPDF_GetCurrentEncoder  (HPDF_Doc    pdf){    if (!HPDF_HasDoc (pdf))        return NULL;    return pdf->cur_encoder;}

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_LoadRawImageFromMem  (HPDF_Doc           pdf,                           const HPDF_BYTE   *buf,                           HPDF_UINT          width,                           HPDF_UINT          height,                           HPDF_ColorSpace    color_space,                           HPDF_UINT          bits_per_component){    HPDF_Image image;    HPDF_PTRACE ((" HPDF_LoadRawImageFromMem/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    image = HPDF_Image_LoadRawImageFromMem (pdf->mmgr, buf, pdf->xref, width,                height, color_space, bits_per_component);    if (!image)        HPDF_CheckError (&pdf->error);    if (image && pdf->compression_mode & HPDF_COMP_IMAGE)        image->filter = HPDF_STREAM_FILTER_FLATE_DECODE;    return image;}

HPDF_LoadU3DFromFile  (HPDF_Doc     pdf,						const char  *filename){	HPDF_Stream imagedata;	HPDF_Image image;	HPDF_PTRACE ((" HPDF_LoadU3DFromFile/n"));	if (!HPDF_HasDoc (pdf)) {		return NULL;	}	/* create file stream */	imagedata = HPDF_FileReader_New (pdf->mmgr, filename);	if (HPDF_Stream_Validate (imagedata)) {		image = HPDF_U3D_LoadU3D (pdf->mmgr, imagedata, pdf->xref);	} else {		image = NULL;	}	/* destroy file stream */	HPDF_Stream_Free (imagedata);	if (!image) {		HPDF_CheckError (&pdf->error);	}	return image;}

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_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_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_GetContents   (HPDF_Doc   pdf,                   HPDF_BYTE  *buf,                 HPDF_UINT32  *size){    HPDF_Stream stream;    HPDF_UINT isize;    HPDF_STATUS ret;    HPDF_PTRACE ((" HPDF_GetContents/n"));    if (!HPDF_HasDoc (pdf)) {        return HPDF_INVALID_DOCUMENT;    }    stream = HPDF_MemStream_New (pdf->mmgr, HPDF_STREAM_BUF_SIZ);    if (!stream) {        return HPDF_CheckError (&pdf->error);    }    if (InternalSaveToStream (pdf, stream) != HPDF_OK) {        HPDF_Stream_Free (stream);        return HPDF_CheckError (&pdf->error);    }    ret = HPDF_Stream_Read (stream, buf, &isize);    *size = isize;    HPDF_Stream_Free (stream);    return ret;}

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_UseCNTFonts   (HPDF_Doc   pdf){    HPDF_FontDef fontdef;    HPDF_STATUS ret;    if (!HPDF_HasDoc (pdf))        return HPDF_INVALID_DOCUMENT;    /* MingLiU */    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "MingLiU",                MingLiU_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "MingLiU,Bold",                MingLiU_Bold_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "MingLiU,Italic",                MingLiU_Italic_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "MingLiU,BoldItalic",                MingLiU_BoldItalic_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    return HPDF_OK;}

HPDF_UseCNSFonts   (HPDF_Doc   pdf){    HPDF_FontDef fontdef;    HPDF_STATUS ret;    if (!HPDF_HasDoc (pdf))        return HPDF_INVALID_DOCUMENT;    /* SimSun */    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimSun",                SimSun_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimSun,Bold",                SimSun_Bold_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimSun,Italic",                SimSun_Italic_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimSun,BoldItalic",                SimSun_BoldItalic_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    /* SimHei */    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimHei",                SimHei_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimHei,Bold",                SimHei_Bold_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimHei,Italic",                SimHei_Italic_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    fontdef = HPDF_CIDFontDef_New (pdf->mmgr,  "SimHei,BoldItalic",                SimHei_BoldItalic_Init);    if ((ret = HPDF_Doc_RegisterFontDef (pdf, fontdef)) != HPDF_OK)        return ret;    return HPDF_OK;}

extern void AP_savePdfAndCleanUp(char *path,HPDF_Doc pdf){    HPDF_SaveToFile(pdf, path);    printf("[libharu] Freeing PDF object ");    if (HPDF_HasDoc(pdf)) {        HPDF_Free(pdf);    }    printf("[libharu] PDF Creation END");}

HPDF_GetCurrentPage  (HPDF_Doc   pdf){    HPDF_PTRACE ((" HPDF_GetCurrentPage/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    return pdf->cur_page;}

HPDF_GetViewerPreference  (HPDF_Doc   pdf){    HPDF_PTRACE ((" HPDF_Catalog_GetViewerPreference/n"));    if (!HPDF_HasDoc (pdf))        return 0;    return HPDF_Catalog_GetViewerPreference (pdf->catalog);}

HPDF_GetPageMode  (HPDF_Doc   pdf){    HPDF_PTRACE ((" HPDF_GetPageMode/n"));    if (!HPDF_HasDoc (pdf))        return HPDF_PAGE_MODE_USE_NONE;    return HPDF_Catalog_GetPageMode (pdf->catalog);}

HPDF_GetPageLayout  (HPDF_Doc   pdf){    HPDF_PTRACE ((" HPDF_GetPageLayout/n"));    if (!HPDF_HasDoc (pdf))        return HPDF_PAGE_LAYOUT_SINGLE;    return HPDF_Catalog_GetPageLayout (pdf->catalog);}

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_GetStreamSize  (HPDF_Doc   pdf){    HPDF_PTRACE ((" HPDF_GetStreamSize/n"));    if (!HPDF_HasDoc (pdf))        return HPDF_INVALID_DOCUMENT;    if (!HPDF_Stream_Validate (pdf->stream))        return 0;    return HPDF_Stream_Size(pdf->stream);}

HPDF_CreateExtGState  (HPDF_Doc  pdf){    HPDF_ExtGState ext_gstate;    if (!HPDF_HasDoc (pdf))        return NULL;    pdf->pdf_version = HPDF_VER_14;    ext_gstate = HPDF_ExtGState_New (pdf->mmgr, pdf->xref);    if (!ext_gstate)        HPDF_CheckError (&pdf->error);    return ext_gstate;}

static HPDF_DictGetInfo  (HPDF_Doc  pdf){    if (!HPDF_HasDoc (pdf))        return NULL;    if (!pdf->info) {        pdf->info = HPDF_Dict_New (pdf->mmgr);        if (!pdf->info || HPDF_Xref_Add (pdf->xref, pdf->info) != HPDF_OK)            pdf->info = NULL;    }    return pdf->info;}

HPDF_SetCurrentEncoder  (HPDF_Doc    pdf,                         const char  *encoding_name){    HPDF_Encoder encoder;    if (!HPDF_HasDoc (pdf))        return HPDF_GetError (pdf);    encoder = HPDF_GetEncoder (pdf, encoding_name);    pdf->cur_encoder = encoder;    if (!pdf)        return HPDF_GetError (pdf);    return HPDF_OK;}

HPDF_UseUTFEncodings   (HPDF_Doc   pdf){    HPDF_Encoder encoder;    HPDF_STATUS ret;    if (!HPDF_HasDoc (pdf))        return HPDF_INVALID_DOCUMENT;    encoder = HPDF_CMapEncoder_New (pdf->mmgr,  "UTF-8",                UTF8_Init);    if ((ret = HPDF_Doc_RegisterEncoder (pdf, encoder)) != HPDF_OK)        return ret;    return HPDF_OK;}

HPDF_SetViewerPreference  (HPDF_Doc     pdf,                           HPDF_UINT    value){    HPDF_STATUS ret;    HPDF_PTRACE ((" HPDF_Catalog_SetViewerPreference/n"));    if (!HPDF_HasDoc (pdf))        return HPDF_INVALID_DOCUMENT;    ret = HPDF_Catalog_SetViewerPreference (pdf->catalog, value);    if (ret != HPDF_OK)        return HPDF_CheckError (&pdf->error);    return HPDF_OK;}

HPDF_LoadPngImageFromFile2  (HPDF_Doc     pdf,                             const char  *filename){    HPDF_Stream imagedata;    HPDF_Image image;    HPDF_String fname;    HPDF_PTRACE ((" HPDF_LoadPngImageFromFile/n"));    if (!HPDF_HasDoc (pdf))        return NULL;    /* check whether file name is valid or not. */    imagedata = HPDF_FileReader_New (pdf->mmgr, filename);    if (HPDF_Stream_Validate (imagedata))        image = LoadPngImageFromStream (pdf, imagedata, HPDF_TRUE);    else        image = NULL;    /* destroy file stream */    if (imagedata)        HPDF_Stream_Free (imagedata);    if (!image) {        HPDF_CheckError (&pdf->error);        return NULL;    }    /* add file-name to image dictionary as a hidden entry.     * it is used when the image data is needed.     */    fname = HPDF_String_New (pdf->mmgr, filename, NULL);    if (!fname) {        HPDF_CheckError (&pdf->error);        return NULL;    }    fname->header.obj_id |= HPDF_OTYPE_HIDDEN;    if ((HPDF_Dict_Add (image, "_FILE_NAME", fname)) != HPDF_OK) {        HPDF_CheckError (&pdf->error);        return NULL;    }    return image;}