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

HPDF_STATUSHPDF_Page_SetBoxValue (HPDF_Page          page,                       const char   *name,                       HPDF_UINT          index,                       HPDF_REAL          value){    HPDF_Real r;    HPDF_Array array;    HPDF_PTRACE((" HPDF_Page_SetBoxValue/n"));    if (!HPDF_Page_Validate (page))        return HPDF_INVALID_PAGE;    array = HPDF_Page_GetInheritableItem (page, name, HPDF_OCLASS_ARRAY);    if (!array)        return HPDF_SetError (page->error, HPDF_PAGE_CANNOT_FIND_OBJECT, 0);    r = HPDF_Array_GetItem (array, index, HPDF_OCLASS_REAL);    if (!r)        return HPDF_SetError (page->error, HPDF_PAGE_INVALID_INDEX, 0);    r->value = value;    return HPDF_OK;}

void*HPDF_Array_GetItem  (HPDF_Array   array,                     HPDF_UINT    index,                     HPDF_UINT16  obj_class){    void *obj;    HPDF_Obj_Header *header;    HPDF_PTRACE((" HPDF_Array_GetItem/n"));    obj = HPDF_List_ItemAt (array->list, index);    if (!obj) {        HPDF_SetError (array->error, HPDF_ARRAY_ITEM_NOT_FOUND, 0);        return NULL;    }    header = (HPDF_Obj_Header *)obj;    if (header->obj_class == HPDF_OCLASS_PROXY) {        obj = ((HPDF_Proxy)obj)->obj;        header = (HPDF_Obj_Header *)obj;    }    if ((header->obj_class & HPDF_OCLASS_ANY) != obj_class) {        HPDF_SetError (array->error, HPDF_ARRAY_ITEM_UNEXPECTED_TYPE, 0);        return NULL;    }    return obj;}

HPDF_STATUSHPDF_Array_Insert  (HPDF_Array  array,                    void        *target,                    void        *obj){    HPDF_Obj_Header *header;    HPDF_STATUS ret;    HPDF_UINT i;    HPDF_PTRACE (" HPDF_Array_Insert/n");    if (!obj) {        if (HPDF_Error_GetCode (array->error) == HPDF_OK)            return HPDF_SetError (array->error, HPDF_INVALID_OBJECT, 0);        else            return HPDF_INVALID_OBJECT;    }    header = (HPDF_Obj_Header *)obj;    if (header->obj_id & HPDF_OTYPE_DIRECT) {        HPDF_PTRACE (" HPDF_Array_Add this object cannot owned by array "#ifdef __ANDROID64__                "obj=0x%08X/n", (HPDF_UINT)(HPDF_UINTPTR)array);#else                "obj=0x%08X/n", (HPDF_UINT)array);#endif        return HPDF_SetError (array->error, HPDF_INVALID_OBJECT, 0);    }

HPDF_STATUSHPDF_Pages_AddKids  (HPDF_Pages  parent,                     HPDF_Dict   kid){    HPDF_Array kids;    HPDF_STATUS ret;    HPDF_PTRACE((" HPDF_Pages_AddKids/n"));    if (HPDF_Dict_GetItem (kid, "Parent", HPDF_OCLASS_DICT))        return HPDF_SetError (parent->error, HPDF_PAGE_CANNOT_SET_PARENT, 0);    if ((ret = HPDF_Dict_Add (kid, "Parent", parent)) != HPDF_OK)        return ret;    kids = (HPDF_Array )HPDF_Dict_GetItem (parent, "Kids", HPDF_OCLASS_ARRAY);    if (!kids)        return HPDF_SetError (parent->error, HPDF_PAGES_MISSING_KIDS_ENTRY, 0);    if (kid->header.obj_class == (HPDF_OCLASS_DICT | HPDF_OSUBCLASS_PAGE)) {        HPDF_PageAttr attr = (HPDF_PageAttr)kid->attr;        attr->parent = parent;    }    return HPDF_Array_Add (kids, kid);}

HPDF_STATUSHPDF_Page_InsertBefore  (HPDF_Page   page,                         HPDF_Page   target){    HPDF_Page parent;    HPDF_Array kids;    HPDF_STATUS ret;    HPDF_PageAttr attr;    HPDF_PTRACE((" HPDF_Page_InsertBefore/n"));    if (!target)        return HPDF_INVALID_PARAMETER;    attr = (HPDF_PageAttr )target->attr;    parent = attr->parent;    if (!parent)        return HPDF_PAGE_CANNOT_SET_PARENT;    if (HPDF_Dict_GetItem (page, "Parent", HPDF_OCLASS_DICT))        return HPDF_SetError (parent->error, HPDF_PAGE_CANNOT_SET_PARENT, 0);    if ((ret = HPDF_Dict_Add (page, "Parent", parent)) != HPDF_OK)        return ret;    kids = (HPDF_Array )HPDF_Dict_GetItem (parent, "Kids", HPDF_OCLASS_ARRAY);    if (!kids)        return HPDF_SetError (parent->error, HPDF_PAGES_MISSING_KIDS_ENTRY, 0);    attr = (HPDF_PageAttr)page->attr;    attr->parent = parent;    return HPDF_Array_Insert (kids, target, page);}

HPDF_STATUSHPDF_Xref_Add  (HPDF_Xref  xref,                void       *obj){    HPDF_XrefEntry entry;    HPDF_Obj_Header *header;    HPDF_PTRACE((" HPDF_Xref_Add/n"));    if (!obj) {        if (HPDF_Error_GetCode (xref->error) == HPDF_OK)            return HPDF_SetError (xref->error, HPDF_INVALID_OBJECT, 0);        else            return HPDF_INVALID_OBJECT;    }    header = (HPDF_Obj_Header *)obj;    if (header->obj_id & HPDF_OTYPE_DIRECT ||            header->obj_id & HPDF_OTYPE_INDIRECT)        return HPDF_SetError(xref->error, HPDF_INVALID_OBJECT, 0);    if (xref->entries->count >= HPDF_LIMIT_MAX_XREF_ELEMENT) {        HPDF_SetError(xref->error, HPDF_XREF_COUNT_ERR, 0);        goto Fail;    }    /* in the following, we have to dispose the object when an error is     * occured.     */    entry = (HPDF_XrefEntry)HPDF_GetMem (xref->mmgr,            sizeof(HPDF_XrefEntry_Rec));    if (entry == NULL)        goto Fail;    if (HPDF_List_Add(xref->entries, entry) != HPDF_OK) {        HPDF_FreeMem (xref->mmgr, entry);        goto Fail;    }    entry->entry_typ = HPDF_IN_USE_ENTRY;    entry->byte_offset = 0;    entry->gen_no = 0;    entry->obj = obj;    header->obj_id = xref->start_offset + xref->entries->count - 1 +                    HPDF_OTYPE_INDIRECT;    header->gen_no = entry->gen_no;    return HPDF_OK;Fail:    HPDF_Obj_ForceFree(xref->mmgr, obj);    return HPDF_Error_GetCode (xref->error);}

void*HPDF_GetMem  (HPDF_MMgr  mmgr,              HPDF_UINT  size){    void * ptr;    if (mmgr->mpool) {        HPDF_MPool_Node node = mmgr->mpool;#ifdef HPDF_ALINMENT_SIZ        size = (size + (HPDF_ALINMENT_SIZ - 1)) / HPDF_ALINMENT_SIZ;        size *= HPDF_ALINMENT_SIZ;#endif        if (node->size - node->used_size >= size) {            ptr = (HPDF_BYTE*)node->buf + node->used_size;            node->used_size += size;            return ptr;        } else {            HPDF_UINT tmp_buf_siz = (mmgr->buf_size < size) ?  size :                mmgr->buf_size;            node = (HPDF_MPool_Node)mmgr->alloc_fn (sizeof(HPDF_MPool_Node_Rec)                    + tmp_buf_siz);            HPDF_PTRACE(("+%p mmgr-new-node/n", node));            if (!node) {                HPDF_SetError (mmgr->error, HPDF_FAILD_TO_ALLOC_MEM,                        HPDF_NOERROR);                return NULL;            }            node->size = tmp_buf_siz;        }        node->next_node = mmgr->mpool;        mmgr->mpool = node;        node->used_size = size;        node->buf = (HPDF_BYTE*)node + sizeof(HPDF_MPool_Node_Rec);        ptr = node->buf;    } else {        ptr = mmgr->alloc_fn (size);        HPDF_PTRACE(("+%p mmgr-alloc_fn size=%u/n", ptr, size));        if (ptr == NULL)            HPDF_SetError (mmgr->error, HPDF_FAILD_TO_ALLOC_MEM, HPDF_NOERROR);    }#ifdef HPDF_MEM_DEBUG    if (ptr)        mmgr->alloc_cnt++;#endif    return ptr;}

HPDF_STATUSHPDF_Array_Add  (HPDF_Array  array,                 void        *obj){    HPDF_Obj_Header *header;    HPDF_STATUS ret;    HPDF_PTRACE((" HPDF_Array_Add/n"));    if (!obj) {        if (HPDF_Error_GetCode (array->error) == HPDF_OK)            return HPDF_SetError (array->error, HPDF_INVALID_OBJECT, 0);        else            return HPDF_INVALID_OBJECT;    }    header = (HPDF_Obj_Header *)obj;    if (header->obj_id & HPDF_OTYPE_DIRECT)        return HPDF_SetError (array->error, HPDF_INVALID_OBJECT, 0);    if (array->list->count >= HPDF_LIMIT_MAX_ARRAY) {        HPDF_PTRACE((" HPDF_Array_Add exceed limitatin of array count(%d)/n",                    HPDF_LIMIT_MAX_ARRAY));        HPDF_Obj_Free (array->mmgr, obj);        return HPDF_SetError (array->error, HPDF_ARRAY_COUNT_ERR, 0);    }    if (header->obj_id & HPDF_OTYPE_INDIRECT) {        HPDF_Proxy proxy = HPDF_Proxy_New (array->mmgr, obj);        if (!proxy) {            HPDF_Obj_Free (array->mmgr, obj);            return HPDF_Error_GetCode (array->error);        }        proxy->header.obj_id |= HPDF_OTYPE_DIRECT;        obj = proxy;    } else        header->obj_id |= HPDF_OTYPE_DIRECT;    ret = HPDF_List_Add (array->list, obj);    if (ret != HPDF_OK)        HPDF_Obj_Free (array->mmgr, obj);    return ret;}

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_STATUSHPDF_Real_SetValue  (HPDF_Real  obj,                     HPDF_REAL  value){    HPDF_STATUS ret = HPDF_OK;    if (value > HPDF_LIMIT_MAX_REAL)        return HPDF_SetError (obj->error, HPDF_REAL_OUT_OF_RANGE, 0);    if (value < HPDF_LIMIT_MIN_REAL)        return HPDF_SetError (obj->error, HPDF_REAL_OUT_OF_RANGE, 0);    obj->value =value;    return ret;}

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_XrefEntryHPDF_Xref_GetEntryByObjectId  (HPDF_Xref  xref,                               HPDF_UINT  obj_id){    HPDF_Xref tmp_xref = xref;    HPDF_PTRACE((" HPDF_Xref_GetEntryByObjectId/n"));    while (tmp_xref) {        HPDF_UINT i;        if (tmp_xref->entries->count + tmp_xref->start_offset > obj_id) {            HPDF_SetError (xref->error, HPDF_INVALID_OBJ_ID, 0);            return NULL;        }        if (tmp_xref->start_offset < obj_id) {            for (i = 0; i < tmp_xref->entries->count; i++) {                if (tmp_xref->start_offset + i == obj_id) {                    HPDF_XrefEntry entry = HPDF_Xref_GetEntry(tmp_xref, i);                    return entry;                }            }        }        tmp_xref = tmp_xref->prev;    }    return NULL;}

static HPDF_TextWidthTextWidth  (HPDF_Font         font,            const HPDF_BYTE  *text,            HPDF_UINT         len){    HPDF_FontAttr attr = (HPDF_FontAttr)font->attr;    HPDF_TextWidth ret = {0, 0, 0, 0};    HPDF_UINT i;    HPDF_BYTE b = 0;    HPDF_PTRACE ((" HPDF_TTFont_TextWidth/n"));    if (attr->widths) {        for (i = 0; i < len; i++) {            b = text[i];            ret.numchars++;            ret.width += CharWidth (font, b);            if (HPDF_IS_WHITE_SPACE(b)) {                ret.numspace++;                ret.numwords++;            }        }    } else        HPDF_SetError (font->error, HPDF_FONT_INVALID_WIDTHS_TABLE, 0);    /* 2006.08.19 add. */    if (HPDF_IS_WHITE_SPACE(b))        ; /* do nothing. */    else        ret.numwords++;    return ret;}

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_STATUSHPDF_Image_SetMask (HPDF_Image   image,                    HPDF_BOOL    mask){    HPDF_Boolean image_mask;    if (!HPDF_Image_Validate (image))        return HPDF_INVALID_IMAGE;    if (mask && HPDF_Image_GetBitsPerComponent (image) != 1)        return HPDF_SetError (image->error, HPDF_INVALID_BIT_PER_COMPONENT,                0);    image_mask = HPDF_Dict_GetItem (image, "ImageMask", HPDF_OCLASS_BOOLEAN);    if (!image_mask) {        HPDF_STATUS ret;        image_mask = HPDF_Boolean_New (image->mmgr, HPDF_FALSE);        if ((ret = HPDF_Dict_Add (image, "ImageMask", image_mask)) != HPDF_OK)            return ret;    }    image_mask->value = mask;    return HPDF_OK;}

HPDF_STATUSPages_BeforeWrite  (HPDF_Dict    obj){    HPDF_Array kids = (HPDF_Array )HPDF_Dict_GetItem (obj, "Kids",                    HPDF_OCLASS_ARRAY);    HPDF_Number count = (HPDF_Number)HPDF_Dict_GetItem (obj, "Count",                    HPDF_OCLASS_NUMBER);    HPDF_STATUS ret;    HPDF_PTRACE((" HPDF_Pages_BeforeWrite/n"));    if (!kids)        return HPDF_SetError (obj->error, HPDF_PAGES_MISSING_KIDS_ENTRY, 0);    if (count)        count->value = GetPageCount (obj);    else {        count = HPDF_Number_New (obj->mmgr, GetPageCount (obj));        if (!count)            return HPDF_Error_GetCode (obj->error);        if ((ret = HPDF_Dict_Add (obj, "Count", count)) != HPDF_OK)            return ret;    }    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_STATUSHPDF_String_SetValue  (HPDF_String      obj,                       const char  *value){    HPDF_UINT len;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_String_SetValue/n"));    if (obj->value) {        HPDF_FreeMem (obj->mmgr, obj->value);        obj->len = 0;    }    len = HPDF_StrLen(value, HPDF_LIMIT_MAX_STRING_LEN + 1);    if (len > HPDF_LIMIT_MAX_STRING_LEN)        return HPDF_SetError (obj->error, HPDF_STRING_OUT_OF_RANGE, 0);    obj->value = HPDF_GetMem (obj->mmgr, len + 1);    if (!obj->value)        return HPDF_Error_GetCode (obj->error);    HPDF_StrCpy ((char *)obj->value, value, (char *)obj->value + len);    obj->len = len;    return ret;}

HPDF_DestinationHPDF_Destination_New  (HPDF_MMgr   mmgr,                       HPDF_Page   target,                       HPDF_Xref   xref){    HPDF_Destination dst;    HPDF_PTRACE((" HPDF_Destination_New/n"));    if (!HPDF_Page_Validate (target)) {        HPDF_SetError (mmgr->error, HPDF_INVALID_PAGE, 0);        return NULL;    }    dst = HPDF_Array_New (mmgr);    if (!dst)        return NULL;    dst->header.obj_class |= HPDF_OSUBCLASS_DESTINATION;    if (HPDF_Xref_Add (xref, dst) != HPDF_OK)        return NULL;    /* first item of array must be target page */    if (HPDF_Array_Add (dst, target) != HPDF_OK)        return NULL;    /* default type is HPDF_FIT */    if (HPDF_Array_AddName (dst,            HPDF_DESTINATION_TYPE_NAMES[(HPDF_INT)HPDF_FIT]) != HPDF_OK)        return NULL;    return dst;}

static HPDF_ImageLoadPngImageFromStream (HPDF_Doc      pdf,                        HPDF_Stream   imagedata,                        HPDF_BOOL     delayed_loading){    HPDF_SetError (&pdf->error, HPDF_UNSUPPORTED_FUNC, 0);    return NULL;}

HPDF_STATUSHPDF_RaiseError  (HPDF_Error   error,                  HPDF_STATUS  error_no,                  HPDF_STATUS  detail_no){    HPDF_SetError (error, error_no, detail_no);    return HPDF_CheckError (error);}

HPDF_DictHPDF_PageLabel_New  (HPDF_Doc             pdf,                     HPDF_PageNumStyle    style,                     HPDF_INT             first_page,                     const char     *prefix){    HPDF_Dict obj = HPDF_Dict_New (pdf->mmgr);    HPDF_PTRACE ((" HPDF_PageLabel_New/n"));    if (!obj)        return NULL;    switch (style) {        case HPDF_PAGE_NUM_STYLE_DECIMAL:            if (HPDF_Dict_AddName (obj, "S", "D") != HPDF_OK)                goto Fail;            break;        case HPDF_PAGE_NUM_STYLE_UPPER_ROMAN:            if (HPDF_Dict_AddName (obj, "S", "R") != HPDF_OK)                goto Fail;            break;        case HPDF_PAGE_NUM_STYLE_LOWER_ROMAN:            if (HPDF_Dict_AddName (obj, "S", "r") != HPDF_OK)                goto Fail;            break;        case HPDF_PAGE_NUM_STYLE_UPPER_LETTERS:            if (HPDF_Dict_AddName (obj, "S", "A") != HPDF_OK)                goto Fail;            break;        case HPDF_PAGE_NUM_STYLE_LOWER_LETTERS:            if (HPDF_Dict_AddName (obj, "S", "a") != HPDF_OK)                goto Fail;            break;        default:            HPDF_SetError (&pdf->error, HPDF_PAGE_NUM_STYLE_OUT_OF_RANGE,                    (HPDF_STATUS)style);            goto Fail;    }    if (prefix && prefix[0] != 0)        if (HPDF_Dict_Add (obj, "P", HPDF_String_New (pdf->mmgr, prefix,                    pdf->def_encoder)) != HPDF_OK)            goto Fail;    if (first_page != 0)        if (HPDF_Dict_AddNumber (obj, "St", first_page) != HPDF_OK)            goto Fail;    return obj;Fail:    HPDF_Dict_Free (obj);    return NULL;}

HPDF_STATUSHPDF_Doc_SetCurrentPage  (HPDF_Doc    pdf,                          HPDF_Page   page){    HPDF_PTRACE ((" HPDF_Doc_SetCurrentPage/n"));    if (!HPDF_HasDoc (pdf))        return HPDF_INVALID_DOCUMENT;    if (!HPDF_Page_Validate (page))        return HPDF_SetError (&pdf->error, HPDF_INVALID_PAGE, 0);    /* check whether the page belong to the pdf */    if (pdf->mmgr != page->mmgr)        return HPDF_SetError (&pdf->error, HPDF_INVALID_PAGE, 0);    pdf->cur_page = page;    return HPDF_OK;}

HPDF_STATUSHPDF_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_STATUSHPDF_Doc_RegisterEncoder  (HPDF_Doc       pdf,                           HPDF_Encoder   encoder){    HPDF_STATUS ret;    if (!encoder)        return HPDF_SetError (&pdf->error, HPDF_INVALID_OBJECT, 0);    if (HPDF_Doc_FindEncoder (pdf, encoder->name) != NULL) {        HPDF_Encoder_Free (encoder);        return HPDF_SetError (&pdf->error, HPDF_DUPLICATE_REGISTRATION, 0);    }    if ((ret = HPDF_List_Add (pdf->encoder_list, encoder)) != HPDF_OK) {        HPDF_Encoder_Free (encoder);        return HPDF_SetError (&pdf->error, ret, 0);    }    return HPDF_OK;}

HPDF_Shading_AddVertexRGB(HPDF_Shading shading,                          HPDF_Shading_FreeFormTriangleMeshEdgeFlag edgeFlag,                          HPDF_REAL x, HPDF_REAL y,                          HPDF_UINT8 r, HPDF_UINT8 g, HPDF_UINT8 b){  HPDF_STATUS ret = HPDF_OK;  RGBVertex vert;  float bbox[4];  HPDF_PTRACE((" HPDF_Shading_AddVertexRGB/n"));  if (!shading) {    return HPDF_INVALID_OBJECT;  }  if (_GetDecodeArrayVertexValues(shading, bbox) != HPDF_TRUE) {    return HPDF_SetError(shading->error, HPDF_INVALID_OBJECT, 0);  }  vert.EdgeFlag = (HPDF_UINT8)edgeFlag;  vert.X = _EncodeValue(x, bbox[0], bbox[1]);  vert.Y = _EncodeValue(y, bbox[2], bbox[3]);  vert.RGB[0] = r;  vert.RGB[1] = g;  vert.RGB[2] = b;  ret = HPDF_Stream_Write(shading->stream,                          (HPDF_BYTE*)(&vert.EdgeFlag), sizeof(vert.EdgeFlag));  if (ret != HPDF_OK)  {    return ret;  }  ret = HPDF_Stream_Write(shading->stream,                          (HPDF_BYTE*)(&vert.X), sizeof(vert.X));  if (ret != HPDF_OK)  {    return ret;  }  ret = HPDF_Stream_Write(shading->stream,                          (HPDF_BYTE*)(&vert.Y), sizeof(vert.Y));  if (ret != HPDF_OK)  {    return ret;  }  ret = HPDF_Stream_Write(shading->stream,                          (HPDF_BYTE*)(&vert.RGB), sizeof(vert.RGB));  return ret;}

static HPDF_STATUSCreatePallet (HPDF_Dict    image,              png_structp  png_ptr,              png_infop    info_ptr){    HPDF_INT num_pl = 0;    png_color *src_pl = NULL;    HPDF_BYTE *ppallet;    HPDF_BYTE *p;    HPDF_UINT i;    HPDF_Array array;    /* png_get_PLTE does not call PngErrorFunc even if it failed.     * so we call HPDF_Set_Error to set error-code.     */    if (png_get_PLTE(png_ptr, info_ptr, (png_color**)&src_pl, &num_pl) !=            PNG_INFO_PLTE)        return HPDF_SetError (image->error, HPDF_LIBPNG_ERROR,                    HPDF_CANNOT_GET_PALLET);    /* make a pallet array for indexed image. */    ppallet = HPDF_GetMem (image->mmgr, num_pl * 3);    if (!ppallet)        return image->error->error_no;    p = ppallet;    for (i = 0; i < num_pl; i++, src_pl++) {        *p++ = src_pl->red;        *p++ = src_pl->green;        *p++ = src_pl->blue;    }    array = HPDF_Array_New (image->mmgr);    if (array) {        HPDF_Binary b;        HPDF_Dict_Add (image, "ColorSpace", array);        HPDF_Array_AddName (array, "Indexed");        HPDF_Array_AddName (array, "DeviceRGB");        HPDF_Array_AddNumber (array, num_pl - 1);        b = HPDF_Binary_New (image->mmgr, ppallet, num_pl * 3);        if (b)            HPDF_Array_Add (array, b);    }    HPDF_FreeMem (image->mmgr, ppallet);    return image->error->error_no;}

static HPDF_STATUSPngBeforeWrite  (HPDF_Dict obj){    HPDF_STATUS ret;    png_byte header[HPDF_PNG_BYTES_TO_CHECK];    HPDF_UINT len = HPDF_PNG_BYTES_TO_CHECK;    HPDF_Stream png_data;    HPDF_String s;    HPDF_PTRACE ((" PngBeforeWrite/n"));    HPDF_MemStream_FreeData(obj->stream);    s = HPDF_Dict_GetItem (obj, "_FILE_NAME", HPDF_OCLASS_STRING);    if (!s)        return HPDF_SetError (obj->error, HPDF_MISSING_FILE_NAME_ENTRY, 0);    png_data = HPDF_FileReader_New (obj->mmgr, (const char *)(s->value));    if (!HPDF_Stream_Validate (png_data))        return obj->error->error_no;    HPDF_MemSet (header, 0x00, HPDF_PNG_BYTES_TO_CHECK);    ret = HPDF_Stream_Read (png_data, header, &len);    if (ret != HPDF_OK ||            png_sig_cmp (header, (png_size_t)0, HPDF_PNG_BYTES_TO_CHECK)) {        HPDF_Stream_Free(png_data);        return HPDF_SetError (obj->error, HPDF_INVALID_PNG_IMAGE, 0);    }    if ((ret = LoadPngData (obj, NULL, png_data, HPDF_FALSE)) != HPDF_OK) {        HPDF_Stream_Free(png_data);        return ret;    }    HPDF_Stream_Free(png_data);    return HPDF_OK;}

HPDF_BOOLHPDF_NameDict_Validate  (HPDF_NameDict  namedict){    if (!namedict)        return HPDF_FALSE;    if (namedict->header.obj_class != (HPDF_OSUBCLASS_NAMEDICT |                HPDF_OCLASS_DICT)) {        HPDF_SetError (namedict->error, HPDF_INVALID_OBJECT, 0);        return HPDF_FALSE;    }    return HPDF_TRUE;}

HPDF_BOOLHPDF_NameTree_Validate  (HPDF_NameTree  nametree){    if (!nametree)        return HPDF_FALSE;    if (nametree->header.obj_class != (HPDF_OSUBCLASS_NAMETREE |                HPDF_OCLASS_DICT)) {        HPDF_SetError (nametree->error, HPDF_INVALID_OBJECT, 0);        return HPDF_FALSE;    }    return HPDF_TRUE;}