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_STATUS AddResource (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_STATUS HPDF_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_STATUS HPDF_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_STATUS HPDF_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_STATUS Resize (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_STATUS AddAnnotation (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_STATUS HPDF_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_EXPORT(HPDF_STATUS) HPDF_3DView_SetOrthogonalProjection(HPDF_Dict view, HPDF_REAL mag) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict projection; HPDF_PTRACE ((" HPDF_3DView_SetOrthogonalProjection\n")); if (view == NULL || mag <= 0) { return HPDF_INVALID_U3D_DATA; } projection = HPDF_Dict_New (view->mmgr); if (!projection) { return HPDF_Error_GetCode (view->error); } ret = HPDF_Dict_AddName (projection, "Subtype", "O"); if (ret != HPDF_OK) { HPDF_Dict_Free (projection); return ret; } ret = HPDF_Dict_AddReal (projection, "OS", mag); if (ret != HPDF_OK) { HPDF_Dict_Free (projection); return ret; } ret = HPDF_Dict_Add (view, "P", projection); if (ret != HPDF_OK) { HPDF_Dict_Free (projection); return ret; } return ret; }
HPDF_STATUS Pages_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_STATUS HPDF_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_STATUS HPDF_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_STATUS HPDF_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_STATUS HPDF_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_STATUS HPDF_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; }
HPDF_EXPORT(HPDF_STATUS) HPDF_3DView_SetLighting(HPDF_Dict view, const char *scheme) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict lighting; int i; static const char *schemes[] = { "Artwork", "None", "White", "Day", "Night", "Hard", "Primary", "Blue", "Red", "Cube", "CAD", "Headlamp" }; HPDF_PTRACE ((" HPDF_3DView_SetLighting\n")); if (view == NULL || scheme == NULL || scheme[0] == '\0') { return HPDF_INVALID_U3D_DATA; } for (i = 0; i < 12; i++) { if (!strcmp(scheme, schemes[i])) { break; } } if (i == 12) { return HPDF_INVALID_U3D_DATA; } lighting = HPDF_Dict_New (view->mmgr); if (!lighting) { return HPDF_Error_GetCode (view->error); } ret = HPDF_Dict_AddName (lighting, "Type", "3DLightingScheme"); if (ret != HPDF_OK) { HPDF_Dict_Free (lighting); return ret; } ret = HPDF_Dict_AddName (lighting, "Subtype", scheme); if (ret != HPDF_OK) { HPDF_Dict_Free (lighting); return ret; } ret = HPDF_Dict_Add (view, "LS", lighting); if (ret != HPDF_OK) { HPDF_Dict_Free (lighting); return ret; } return ret; }