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

HPDF_LineAnnot_SetCaption (HPDF_Annotation annot, HPDF_BOOL showCaption, HPDF_LineAnnotCapPosition position, HPDF_INT horzOffset, HPDF_INT vertOffset){    HPDF_STATUS ret = HPDF_OK;    HPDF_Array capOffset;    HPDF_PTRACE((" HPDF_LineAnnot_SetCaption/n"));    ret += HPDF_Dict_AddBoolean ( annot, "Cap", showCaption);    ret += HPDF_Dict_AddName( annot, "CP", HPDF_LINE_ANNOT_CAP_POSITION_NAMES[(HPDF_INT)position]);    if (ret != HPDF_OK)       return HPDF_Error_GetCode ( annot->error);    capOffset = HPDF_Array_New ( annot->mmgr);    if ( !capOffset)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "CO", capOffset)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddNumber (capOffset, horzOffset);    ret += HPDF_Array_AddNumber (capOffset, vertOffset);    if (ret != HPDF_OK)       return HPDF_Error_GetCode (capOffset->error);    return HPDF_OK;}

HPDF_TextMarkupAnnot_SetQuadPoints ( HPDF_Annotation annot, HPDF_Point lb, HPDF_Point rb, HPDF_Point lt, HPDF_Point rt) /* l-left, r-right, b-bottom, t-top positions */{    HPDF_Array quadPoints;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_TextMarkupAnnot_SetQuadPoints/n"));    quadPoints = HPDF_Array_New ( annot->mmgr);    if ( !quadPoints)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "QuadPoints", quadPoints)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddReal (quadPoints, lb.x);    ret += HPDF_Array_AddReal (quadPoints, lb.y);    ret += HPDF_Array_AddReal (quadPoints, rb.x);    ret += HPDF_Array_AddReal (quadPoints, rb.y);    ret += HPDF_Array_AddReal (quadPoints, lt.x);    ret += HPDF_Array_AddReal (quadPoints, lt.y);    ret += HPDF_Array_AddReal (quadPoints, rt.x);    ret += HPDF_Array_AddReal (quadPoints, rt.y);    if (ret != HPDF_OK)       return HPDF_Error_GetCode (quadPoints->error);    return HPDF_OK;}

static HPDF_STATUS Get3DStreamType (HPDF_Stream  stream, const char **type){	HPDF_BYTE tag[4];	HPDF_UINT len;	HPDF_PTRACE ((" HPDF_U3D_Get3DStreamType/n"));	len = 4;	if (HPDF_Stream_Read (stream, tag, &len) != HPDF_OK) {		return HPDF_Error_GetCode (stream->error);	}	if (HPDF_Stream_Seek (stream, 0, HPDF_SEEK_SET) != HPDF_OK) {		return HPDF_Error_GetCode (stream->error);	}	if (HPDF_MemCmp(tag, (HPDF_BYTE *)u3d, 4/* yes, /0 is required */) == 0) {		*type = u3d;		return HPDF_OK;	}	if (HPDF_MemCmp(tag, (HPDF_BYTE *)prc, 3) == 0) {		*type = prc;		return HPDF_OK;	}	return HPDF_INVALID_U3D_DATA;}

HPDF_FreeTextAnnot_Set3PointCalloutLine ( HPDF_Annotation annot, HPDF_Point startPoint, HPDF_Point kneePoint, HPDF_Point endPoint) /* Callout line will be in default user space */{    HPDF_Array clPoints;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_FreeTextAnnot_Set3PointCalloutLine/n"));    clPoints = HPDF_Array_New ( annot->mmgr);    if ( !clPoints)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "CL", clPoints)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddReal (clPoints, startPoint.x);    ret += HPDF_Array_AddReal (clPoints, startPoint.y);    ret += HPDF_Array_AddReal (clPoints, kneePoint.x);    ret += HPDF_Array_AddReal (clPoints, kneePoint.y);    ret += HPDF_Array_AddReal (clPoints, endPoint.x);    ret += HPDF_Array_AddReal (clPoints, endPoint.y);    if (ret != HPDF_OK)       return HPDF_Error_GetCode (clPoints->error);    return HPDF_OK;}

HPDF_STATUSAddResource  (HPDF_Page  page){    HPDF_STATUS ret = HPDF_OK;    HPDF_Dict resource;    HPDF_Array procset;    HPDF_PTRACE((" HPDF_Page_AddResource/n"));    resource = HPDF_Dict_New (page->mmgr);    if (!resource)        return HPDF_Error_GetCode (page->error);    /* althoth ProcSet-entry is obsolete, add it to resouce for     * compatibility     */    ret += HPDF_Dict_Add (page, "Resources", resource);    procset = HPDF_Array_New (page->mmgr);    if (!procset)        return HPDF_Error_GetCode (page->error);    ret += HPDF_Dict_Add (resource, "ProcSet", procset);    ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "PDF"));    ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "Text"));    ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageB"));    ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageC"));    ret += HPDF_Array_Add (procset, HPDF_Name_New (page->mmgr, "ImageI"));    return ret;}

HPDF_MarkupAnnot_SetRectDiff (HPDF_Annotation  annot, HPDF_Rect  rect) /* RD entry : this is the difference between Rect and the text annotation rectangle */{    HPDF_Array array;    HPDF_STATUS ret = HPDF_OK;    HPDF_REAL tmp;    HPDF_PTRACE((" HPDF_MarkupAnnot_SetRectDiff/n"));    array = HPDF_Array_New ( annot->mmgr);    if ( !array)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "RD", array)) != HPDF_OK)        return ret;    if (rect.top < rect.bottom) {        tmp = rect.top;        rect.top = rect.bottom;        rect.bottom = tmp;    }    ret += HPDF_Array_AddReal (array, rect.left);    ret += HPDF_Array_AddReal (array, rect.bottom);    ret += HPDF_Array_AddReal (array, rect.right);    ret += HPDF_Array_AddReal (array, rect.top);    if (ret != HPDF_OK)       return HPDF_Error_GetCode (array->error);    return HPDF_OK;}

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

HPDF_STATUSHPDF_EncryptDict_Prepare  (HPDF_EncryptDict  dict,                           HPDF_Dict         info,                           HPDF_Xref         xref){    HPDF_STATUS ret;    HPDF_Encrypt attr = (HPDF_Encrypt)dict->attr;    HPDF_Binary user_key;    HPDF_Binary owner_key;    HPDF_PTRACE((" HPDF_EncryptDict_Prepare/n"));    HPDF_EncryptDict_CreateID (dict, info, xref);    HPDF_Encrypt_CreateOwnerKey (attr);    HPDF_Encrypt_CreateEncryptionKey (attr);    HPDF_Encrypt_CreateUserKey (attr);    owner_key = HPDF_Binary_New (dict->mmgr, attr->owner_key, HPDF_PASSWD_LEN);    if (!owner_key)        return HPDF_Error_GetCode (dict->error);    if ((ret = HPDF_Dict_Add (dict, "O", owner_key)) != HPDF_OK)        return ret;    user_key = HPDF_Binary_New (dict->mmgr, attr->user_key, HPDF_PASSWD_LEN);    if (!user_key)        return HPDF_Error_GetCode (dict->error);    if ((ret = HPDF_Dict_Add (dict, "U", user_key)) != HPDF_OK)        return ret;    ret += HPDF_Dict_AddName (dict, "Filter", "Standard");    if (attr->mode == HPDF_ENCRYPT_R2) {        ret += HPDF_Dict_AddNumber (dict, "V", 1);        ret += HPDF_Dict_AddNumber (dict, "R", 2);    } else if (attr->mode == HPDF_ENCRYPT_R3) {        ret += HPDF_Dict_AddNumber (dict, "V", 2);        ret += HPDF_Dict_AddNumber (dict, "R", 3);        ret += HPDF_Dict_AddNumber (dict, "Length", attr->key_len * 8);    }    ret += HPDF_Dict_AddNumber (dict, "P", attr->permission);    if (ret != HPDF_OK)        return HPDF_Error_GetCode (dict->error);    return HPDF_OK;}

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

HPDF_GetError  (HPDF_Doc   pdf){    if (!HPDF_Doc_Validate (pdf))        return HPDF_INVALID_DOCUMENT;    return HPDF_Error_GetCode (&pdf->error);}

static HPDF_STATUSResize  (HPDF_List   list,         HPDF_UINT   count){    void **new_obj;    HPDF_PTRACE((" HPDF_List_Resize/n"));    if (list->count >= count) {        if (list->count == count)            return HPDF_OK;        else            return HPDF_INVALID_PARAMETER;    }    new_obj = (void **)HPDF_GetMem (list->mmgr, count * sizeof(void *));    if (!new_obj)        return HPDF_Error_GetCode (list->error);    if (list->obj)        HPDF_MemCpy ((HPDF_BYTE *)new_obj, (HPDF_BYTE *)list->obj,                list->block_siz * sizeof(void *));    list->block_siz = count;    if (list->obj)        HPDF_FreeMem (list->mmgr, list->obj);    list->obj = new_obj;    return HPDF_OK;}

static HPDF_STATUSAddAnnotation  (HPDF_Page        page,                HPDF_Annotation  annot){    HPDF_Array array;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Pages/n"));    /* find "Annots" entry */    array = HPDF_Dict_GetItem (page, "Annots", HPDF_OCLASS_ARRAY);    if (!array) {        array = HPDF_Array_New (page->mmgr);        if (!array)            return HPDF_Error_GetCode (page->error);        ret = HPDF_Dict_Add (page, "Annots", array);        if (ret != HPDF_OK)            return ret;    }        if ((ret = HPDF_Array_Add (array, annot)) != HPDF_OK)       return ret;    /* Add Parent to the annotation  */    ret = HPDF_Dict_Add( annot, "P", page);    return ret;}

HPDF_EXPORT(HPDF_STATUS) HPDF_U3D_Add3DView(HPDF_U3D u3d, HPDF_Dict view){	HPDF_Array views = NULL;	HPDF_STATUS ret = HPDF_OK;	HPDF_PTRACE ((" HPDF_Add3DView/n"));	if (u3d == NULL || view == NULL) {		return HPDF_INVALID_U3D_DATA;	}	views = (HPDF_Array)HPDF_Dict_GetItem (u3d, "VA", HPDF_OCLASS_ARRAY);	if (views == NULL) {		views = HPDF_Array_New (u3d->mmgr);		if (!views) {			return HPDF_Error_GetCode (u3d->error);		}		ret = HPDF_Dict_Add (u3d, "VA", views);		if (ret == HPDF_OK) {			ret = HPDF_Dict_AddNumber (u3d, "DV", 0);		} else {			HPDF_Array_Free (views);			return ret;		}	}	if (ret == HPDF_OK) {		ret = HPDF_Array_Add( views, view);	}	return ret;}

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_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_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_Annot_SetGrayColor (HPDF_Annotation annot, HPDF_REAL color){    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Annot_SetGrayColor/n"));    cArray = HPDF_Array_New (annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret += HPDF_Dict_Add (annot, "C", cArray);    ret += HPDF_Array_AddReal ( cArray, color);    if (ret != HPDF_OK)        return HPDF_Error_GetCode ( annot->error);    return HPDF_OK;}

HPDF_MarkupAnnot_SetInteriorGrayColor (HPDF_Annotation  annot, HPDF_REAL color)/* IC with Gray entry */{    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_MarkupAnnot_SetInteriorGrayColor/n"));    cArray = HPDF_Array_New ( annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret += HPDF_Dict_Add (annot, "IC", cArray);    ret += HPDF_Array_AddReal (cArray, color);    if (ret != HPDF_OK)        return HPDF_Error_GetCode ( annot->error);    return HPDF_OK;}

HPDF_MarkupAnnot_SetCloudEffect (HPDF_Annotation  annot, HPDF_INT cloudIntensity) /* BE entry */{    HPDF_Dict borderEffect;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_MarkupAnnot_SetCloudEffect/n"));    borderEffect = HPDF_Dict_New ( annot->mmgr);    if (!borderEffect)        return HPDF_Error_GetCode ( annot->error);    ret += HPDF_Dict_Add ( annot, "BE", borderEffect);    ret += HPDF_Dict_AddName ( borderEffect, "S", "C");    ret += HPDF_Dict_AddNumber ( borderEffect, "I", cloudIntensity);    if (ret != HPDF_OK)        return HPDF_Error_GetCode (annot->error);    return HPDF_OK;}

HPDF_STATUSHPDF_Array_AddNull  (HPDF_Array  array){    HPDF_Null n = HPDF_Null_New (array->mmgr);    HPDF_PTRACE (" HPDF_Array_AddNull/n");    if (!n)        return HPDF_Error_GetCode (array->error);    else        return HPDF_Array_Add (array, n);}

HPDF_LineAnnot_SetPosition (HPDF_Annotation annot,                            HPDF_Point startPoint, HPDF_LineAnnotEndingStyle startStyle,                            HPDF_Point endPoint, HPDF_LineAnnotEndingStyle endStyle){    HPDF_Array lineEndPoints;    HPDF_Array lineEndStyles;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_LineAnnot_SetPosition/n"));    lineEndPoints = HPDF_Array_New ( annot->mmgr);    if ( !lineEndPoints)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "L", lineEndPoints)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddReal (lineEndPoints, startPoint.x);    ret += HPDF_Array_AddReal (lineEndPoints, startPoint.y);    ret += HPDF_Array_AddReal (lineEndPoints, endPoint.x);    ret += HPDF_Array_AddReal (lineEndPoints, endPoint.y);    if (ret != HPDF_OK)       return HPDF_Error_GetCode ( lineEndPoints->error);    lineEndStyles = HPDF_Array_New ( annot->mmgr);    if ( !lineEndStyles)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "LE", lineEndStyles)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)startStyle]);    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)endStyle]);    if (ret != HPDF_OK)       return HPDF_Error_GetCode ( lineEndStyles->error);    return HPDF_OK;}

HPDF_FreeTextAnnot_SetLineEndingStyle (HPDF_Annotation annot, HPDF_LineAnnotEndingStyle startStyle, HPDF_LineAnnotEndingStyle endStyle){    HPDF_Array lineEndStyles;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_FreeTextAnnot_SetLineEndingStyle/n"));    lineEndStyles = HPDF_Array_New ( annot->mmgr);    if ( !lineEndStyles)        return HPDF_Error_GetCode ( annot->error);    if ((ret = HPDF_Dict_Add ( annot, "LE", lineEndStyles)) != HPDF_OK)        return ret;    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)startStyle]);    ret += HPDF_Array_AddName (lineEndStyles, HPDF_LINE_ANNOT_ENDING_STYLE_NAMES[(HPDF_INT)endStyle]);    if (ret != HPDF_OK)       return HPDF_Error_GetCode (lineEndStyles->error);    return HPDF_OK;}

HPDF_STATUSHPDF_Array_AddNumber  (HPDF_Array  array,                       HPDF_INT32  value){    HPDF_Number n = HPDF_Number_New (array->mmgr, value);    HPDF_PTRACE((" HPDF_Array_AddNumber/n"));    if (!n)        return HPDF_Error_GetCode (array->error);    else        return HPDF_Array_Add (array, n);}

HPDF_STATUSHPDF_Array_AddName  (HPDF_Array       array,                     const char  *value){    HPDF_Name n = HPDF_Name_New (array->mmgr, value);    HPDF_PTRACE((" HPDF_Array_AddName/n"));    if (!n)        return HPDF_Error_GetCode (array->error);    else        return HPDF_Array_Add (array, n);}

HPDF_STATUSHPDF_Array_AddReal  (HPDF_Array  array,                     HPDF_REAL   value){    HPDF_Real r = HPDF_Real_New (array->mmgr, value);    HPDF_PTRACE((" HPDF_Array_AddReal/n"));    if (!r)        return HPDF_Error_GetCode (array->error);    else        return HPDF_Array_Add (array, r);}

HPDF_MarkupAnnot_SetInteriorTransparent (HPDF_Annotation  annot) /* IC with No Color entry */{    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_MarkupAnnot_SetInteriorTransparent/n"));    cArray = HPDF_Array_New ( annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret = HPDF_Dict_Add (annot, "IC", cArray);    return ret;}

HPDF_LineAnnot_SetLeader (HPDF_Annotation annot, HPDF_INT leaderLen, HPDF_INT leaderExtLen, HPDF_INT leaderOffsetLen){    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_LineAnnot_SetLeader/n"));    ret += HPDF_Dict_AddNumber ( annot, "LL", leaderLen);    ret += HPDF_Dict_AddNumber ( annot, "LLE", leaderExtLen);    ret += HPDF_Dict_AddNumber ( annot, "LLO", leaderOffsetLen);    if (ret != HPDF_OK)       return HPDF_Error_GetCode ( annot->error);    return HPDF_OK;}

HPDF_Annot_SetNoColor (HPDF_Annotation annot){    HPDF_Array cArray;    HPDF_STATUS ret = HPDF_OK;    HPDF_PTRACE((" HPDF_Annot_SetNoColor/n"));    cArray = HPDF_Array_New (annot->mmgr);    if (!cArray)        return HPDF_Error_GetCode ( annot->error);    ret = HPDF_Dict_Add (annot, "C", cArray);    return ret;}