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;
}
void*
HPDF_Page_GetInheritableItem (HPDF_Page page,
const char *key,
HPDF_UINT16 obj_class)
{
HPDF_BOOL chk = HPDF_FALSE;
HPDF_INT i = 0;
void * obj;
HPDF_PTRACE((" HPDF_Page_GetInheritableItem\n"));
/* check whether the specified key is valid */
while (HPDF_INHERITABLE_ENTRIES[i]) {
if (HPDF_StrCmp (key, HPDF_INHERITABLE_ENTRIES[i]) == 0) {
chk = HPDF_TRUE;
break;
}
i++;
}
/* the key is not inheritable */
if (chk != HPDF_TRUE) {
HPDF_SetError (page->error, HPDF_INVALID_PARAMETER, 0);
return NULL;
}
obj = HPDF_Dict_GetItem (page, key, obj_class);
/* if resources of the object is NULL, search resources of parent
* pages recursivly
*/
if (!obj) {
HPDF_Pages pages = HPDF_Dict_GetItem (page, "Parent", HPDF_OCLASS_DICT);
while (pages) {
obj = HPDF_Dict_GetItem (page, key, obj_class);
if (obj)
break;
pages = HPDF_Dict_GetItem (pages, "Parent", HPDF_OCLASS_DICT);
}
}
return obj;
}
HPDF_PageMode
HPDF_Catalog_GetPageMode (HPDF_Catalog catalog)
{
HPDF_Name mode;
HPDF_UINT i = 0;
mode = (HPDF_Name)HPDF_Dict_GetItem (catalog, "PageMode", HPDF_OCLASS_NAME);
if (!mode)
return HPDF_PAGE_MODE_USE_NONE;
while (HPDF_PAGE_MODE_NAMES[i]) {
if (HPDF_StrCmp (mode->value, HPDF_PAGE_MODE_NAMES[i]) == 0)
return (HPDF_PageMode)i;
i++;
}
return HPDF_PAGE_MODE_USE_NONE;
}
HPDF_PageLayout
HPDF_Catalog_GetPageLayout (HPDF_Catalog catalog)
{
HPDF_Name layout;
HPDF_UINT i = 0;
layout = (HPDF_Name)HPDF_Dict_GetItem (catalog, "PageLayout",
HPDF_OCLASS_NAME);
if (!layout)
return HPDF_PAGE_LAYOUT_EOF;
while (HPDF_PAGE_LAYOUT_NAMES[i]) {
if (HPDF_StrCmp (layout->value, HPDF_PAGE_LAYOUT_NAMES[i]) == 0)
return (HPDF_PageLayout)i;
i++;
}
return HPDF_PAGE_LAYOUT_EOF;
}
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);
}
static HPDF_BOOL
CheckSubType (HPDF_Annotation annot,
HPDF_AnnotType type)
{
HPDF_Name subtype;
HPDF_PTRACE((" HPDF_Annotation_CheckSubType\n"));
if (!HPDF_Annotation_Validate (annot))
return HPDF_FALSE;
subtype = HPDF_Dict_GetItem (annot, "Subtype", HPDF_OCLASS_NAME);
if (!subtype || HPDF_StrCmp (subtype->value,
HPDF_ANNOT_TYPE_NAMES[(HPDF_INT)type]) != 0) {
HPDF_RaiseError (annot->error, HPDF_INVALID_ANNOTATION, 0);
return HPDF_FALSE;
}
return HPDF_TRUE;
}
HPDF_STATUS
HPDF_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_BOOL
HPDF_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;
}
HPDF_EXPORT(HPDF_STATUS) HPDF_U3D_Set3DActivation(HPDF_Annotation u3dAnnotation, HPDF_Dict activation)
{
HPDF_STATUS ret = HPDF_OK;
HPDF_Name subtype;
HPDF_PTRACE ((" HPDF_U3D_Set3DActivation\n"));
if (u3d == NULL || activation == NULL)
{
return HPDF_INVALID_U3D_DATA;
}
subtype = HPDF_Dict_GetItem (u3dAnnotation, "Subtype", HPDF_OCLASS_NAME);
if (!subtype || HPDF_StrCmp (subtype->value, "3D") != 0)
{
HPDF_RaiseError (u3dAnnotation->error, HPDF_INVALID_ANNOTATION, 0);
return HPDF_FALSE;
}
ret = HPDF_Dict_Add(u3dAnnotation, "3DA", activation);
return ret;
}
HPDF_Font
HPDF_Type0Font_New (HPDF_MMgr mmgr,
HPDF_FontDef fontdef,
HPDF_Encoder encoder,
HPDF_Xref xref)
{
HPDF_Dict font;
HPDF_FontAttr attr;
HPDF_CMapEncoderAttr encoder_attr;
HPDF_STATUS ret = 0;
HPDF_Array descendant_fonts;
HPDF_PTRACE ((" HPDF_Type0Font_New\n"));
font = HPDF_Dict_New (mmgr);
if (!font)
return NULL;
font->header.obj_class |= HPDF_OSUBCLASS_FONT;
/* check whether the fontdef object and the encoder object is valid. */
if (encoder->type != HPDF_ENCODER_TYPE_DOUBLE_BYTE) {
HPDF_SetError(font->error, HPDF_INVALID_ENCODER_TYPE, 0);
return NULL;
}
if (fontdef->type != HPDF_FONTDEF_TYPE_CID &&
fontdef->type != HPDF_FONTDEF_TYPE_TRUETYPE) {
HPDF_SetError(font->error, HPDF_INVALID_FONTDEF_TYPE, 0);
return NULL;
}
attr = HPDF_GetMem (mmgr, sizeof(HPDF_FontAttr_Rec));
if (!attr) {
HPDF_Dict_Free (font);
return NULL;
}
font->header.obj_class |= HPDF_OSUBCLASS_FONT;
font->write_fn = NULL;
font->free_fn = OnFree_Func;
font->attr = attr;
encoder_attr = (HPDF_CMapEncoderAttr)encoder->attr;
HPDF_MemSet (attr, 0, sizeof(HPDF_FontAttr_Rec));
attr->writing_mode = encoder_attr->writing_mode;
attr->text_width_fn = TextWidth;
attr->measure_text_fn = MeasureText;
attr->fontdef = fontdef;
attr->encoder = encoder;
attr->xref = xref;
if (HPDF_Xref_Add (xref, font) != HPDF_OK)
return NULL;
ret += HPDF_Dict_AddName (font, "Type", "Font");
ret += HPDF_Dict_AddName (font, "BaseFont", fontdef->base_font);
ret += HPDF_Dict_AddName (font, "Subtype", "Type0");
if (fontdef->type == HPDF_FONTDEF_TYPE_CID) {
ret += HPDF_Dict_AddName (font, "Encoding", encoder->name);
} else {
/*
* Handle the Unicode encoding, see hpdf_encoding_utf.c For some
* reason, xpdf-based readers cannot deal with our cmap but work
* fine when using the predefined "Identity-H"
* encoding. However, text selection does not work, unless we
* add a ToUnicode cmap. This CMap should also be "Identity",
* but that does not work -- specifying our cmap as a stream however
* does work. Who can understand that ?
*/
if (HPDF_StrCmp(encoder_attr->ordering, "Identity-H") == 0) {
ret += HPDF_Dict_AddName (font, "Encoding", "Identity-H");
attr->cmap_stream = CreateCMap (encoder, xref);
if (attr->cmap_stream) {
ret += HPDF_Dict_Add (font, "ToUnicode", attr->cmap_stream);
} else
return NULL;
} else {
attr->cmap_stream = CreateCMap (encoder, xref);
if (attr->cmap_stream) {
ret += HPDF_Dict_Add (font, "Encoding", attr->cmap_stream);
} else
return NULL;
}
}
if (ret != HPDF_OK)
return NULL;
descendant_fonts = HPDF_Array_New (mmgr);
if (!descendant_fonts)
return NULL;
if (HPDF_Dict_Add (font, "DescendantFonts", descendant_fonts) != HPDF_OK)
return NULL;
if (fontdef->type == HPDF_FONTDEF_TYPE_CID) {
attr->descendant_font = CIDFontType0_New (font, xref);
attr->type = HPDF_FONT_TYPE0_CID;
} else {
attr->descendant_font = CIDFontType2_New (font, xref);
attr->type = HPDF_FONT_TYPE0_TT;
}
if (!attr->descendant_font)
return NULL;
else
if (HPDF_Array_Add (descendant_fonts, attr->descendant_font) !=
HPDF_OK)
return NULL;
return font;
}
HPDF_GetFont (HPDF_Doc pdf,
const char *font_name,
const char *encoding_name)
{
HPDF_FontDef fontdef = NULL;
HPDF_Encoder encoder = NULL;
HPDF_Font font;
HPDF_PTRACE ((" HPDF_GetFont\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
if (!font_name) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_FONT_NAME, 0);
return NULL;
}
/* if encoding-name is not specified, find default-encoding of fontdef
*/
if (!encoding_name) {
fontdef = HPDF_GetFontDef (pdf, font_name);
if (fontdef) {
HPDF_Type1FontDefAttr attr = (HPDF_Type1FontDefAttr)fontdef->attr;
if (fontdef->type == HPDF_FONTDEF_TYPE_TYPE1 &&
HPDF_StrCmp (attr->encoding_scheme,
HPDF_ENCODING_FONT_SPECIFIC) == 0)
encoder = HPDF_GetEncoder (pdf, HPDF_ENCODING_FONT_SPECIFIC);
else
encoder = HPDF_GetEncoder (pdf, HPDF_ENCODING_STANDARD);
} else {
HPDF_CheckError (&pdf->error);
return NULL;
}
if (!encoder) {
HPDF_CheckError (&pdf->error);
return NULL;
}
font = HPDF_Doc_FindFont (pdf, font_name, encoder->name);
} else {
font = HPDF_Doc_FindFont (pdf, font_name, encoding_name);
}
if (font)
return font;
if (!fontdef) {
fontdef = HPDF_GetFontDef (pdf, font_name);
if (!fontdef) {
HPDF_CheckError (&pdf->error);
return NULL;
}
}
if (!encoder) {
encoder = HPDF_GetEncoder (pdf, encoding_name);
if (!encoder)
return NULL;
}
switch (fontdef->type) {
case HPDF_FONTDEF_TYPE_TYPE1:
font = HPDF_Type1Font_New (pdf->mmgr, fontdef, encoder, pdf->xref);
if (font)
HPDF_List_Add (pdf->font_mgr, font);
break;
case HPDF_FONTDEF_TYPE_TRUETYPE:
if (encoder->type == HPDF_ENCODER_TYPE_DOUBLE_BYTE)
font = HPDF_Type0Font_New (pdf->mmgr, fontdef, encoder,
pdf->xref);
else
font = HPDF_TTFont_New (pdf->mmgr, fontdef, encoder, pdf->xref);
if (font)
HPDF_List_Add (pdf->font_mgr, font);
break;
case HPDF_FONTDEF_TYPE_CID:
font = HPDF_Type0Font_New (pdf->mmgr, fontdef, encoder, pdf->xref);
if (font)
HPDF_List_Add (pdf->font_mgr, font);
break;
default:
HPDF_RaiseError (&pdf->error, HPDF_UNSUPPORTED_FONT_TYPE, 0);
return NULL;
}
if (!font)
HPDF_CheckError (&pdf->error);
if (font && (pdf->compression_mode & HPDF_COMP_METADATA))
font->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
return font;
}
static HPDF_STATUS
LoadAfm (HPDF_FontDef fontdef,
HPDF_Stream stream)
{
HPDF_Type1FontDefAttr attr = (HPDF_Type1FontDefAttr)fontdef->attr;
char buf[HPDF_TMP_BUF_SIZ];
HPDF_CharData* cdata;
HPDF_STATUS ret;
HPDF_UINT len;
char keyword[HPDF_LIMIT_MAX_NAME_LEN + 1];
HPDF_UINT i;
HPDF_PTRACE (" LoadAfm\n");
len = HPDF_TMP_BUF_SIZ;
/* chaeck AFM header */
if ((ret = HPDF_Stream_ReadLn (stream, buf, &len)) != HPDF_OK)
return ret;
GetKeyword (buf, keyword, HPDF_LIMIT_MAX_NAME_LEN + 1);
if (HPDF_StrCmp (keyword, "StartFontMetrics") != 0)
return HPDF_INVALID_AFM_HEADER;
/* Global Font Information */
for (;;) {
const char *s;
len = HPDF_TMP_BUF_SIZ;
if ((ret = HPDF_Stream_ReadLn (stream, buf, &len)) != HPDF_OK)
return ret;
s = GetKeyword (buf, keyword, HPDF_LIMIT_MAX_NAME_LEN + 1);
if (HPDF_StrCmp (keyword, "FontName") == 0) {
HPDF_StrCpy (fontdef->base_font, s,
fontdef->base_font + HPDF_LIMIT_MAX_NAME_LEN);
} else
if (HPDF_StrCmp (keyword, "Weight") == 0) {
if (HPDF_StrCmp (s, "Bold") == 0)
fontdef->flags |= HPDF_FONT_FOURCE_BOLD;
} else
if (HPDF_StrCmp (keyword, "IsFixedPitch") == 0) {
if (HPDF_StrCmp (s, "true") == 0)
fontdef->flags |= HPDF_FONT_FIXED_WIDTH;
} else
if (HPDF_StrCmp (keyword, "ItalicAngle") == 0) {
fontdef->italic_angle = (HPDF_INT16)HPDF_AToI (s);
if (fontdef->italic_angle != 0)
fontdef->flags |= HPDF_FONT_ITALIC;
} else
if (HPDF_StrCmp (keyword, "CharacterSet") == 0) {
HPDF_UINT len = HPDF_StrLen (s, HPDF_LIMIT_MAX_STRING_LEN);
if (len > 0) {
attr->char_set = HPDF_GetMem (fontdef->mmgr, len + 1);
if (!attr->char_set)
return HPDF_Error_GetCode (fontdef->error);
HPDF_StrCpy (attr->char_set, s, attr->char_set + len);
}
} else
if (HPDF_StrCmp (keyword, "FontBBox") == 0) {
char buf[HPDF_INT_LEN + 1];
s = GetKeyword (s, buf, HPDF_INT_LEN + 1);
fontdef->font_bbox.left = (HPDF_REAL)HPDF_AToI (buf);
s = GetKeyword (s, buf, HPDF_INT_LEN + 1);
fontdef->font_bbox.bottom = (HPDF_REAL)HPDF_AToI (buf);
s = GetKeyword (s, buf, HPDF_INT_LEN + 1);
fontdef->font_bbox.right = (HPDF_REAL)HPDF_AToI (buf);
GetKeyword (s, buf, HPDF_INT_LEN + 1);
fontdef->font_bbox.top = (HPDF_REAL)HPDF_AToI (buf);
} else
if (HPDF_StrCmp (keyword, "EncodingScheme") == 0) {
HPDF_StrCpy (attr->encoding_scheme, s,
attr->encoding_scheme + HPDF_LIMIT_MAX_NAME_LEN);
} else
if (HPDF_StrCmp (keyword, "CapHeight") == 0) {
fontdef->cap_height = (HPDF_UINT16)HPDF_AToI (s);
} else
if (HPDF_StrCmp (keyword, "Ascender") == 0) {
fontdef->ascent = (HPDF_INT16)HPDF_AToI (s);
} else
if (HPDF_StrCmp (keyword, "Descender") == 0) {
fontdef->descent = (HPDF_INT16)HPDF_AToI (s);
} else
if (HPDF_StrCmp (keyword, "STDHW") == 0) {
fontdef->stemh = (HPDF_UINT16)HPDF_AToI (s);
} else
if (HPDF_StrCmp (keyword, "STDHV") == 0) {
fontdef->stemv = (HPDF_UINT16)HPDF_AToI (s);
} else
if (HPDF_StrCmp (keyword, "StartCharMetrics") == 0) {
attr->widths_count = HPDF_AToI (s);
break;
}
}
cdata = (HPDF_CharData*)HPDF_GetMem (fontdef->mmgr,
sizeof(HPDF_CharData) * attr->widths_count);
if (cdata == NULL)
return HPDF_Error_GetCode (fontdef->error);
HPDF_MemSet (cdata, 0, sizeof(HPDF_CharData) * attr->widths_count);
attr->widths = cdata;
/* load CharMetrics */
for (i = 0; i < attr->widths_count; i++, cdata++) {
const char *s;
char buf2[HPDF_LIMIT_MAX_NAME_LEN + 1];
len = HPDF_TMP_BUF_SIZ;
if ((ret = HPDF_Stream_ReadLn (stream, buf, &len)) != HPDF_OK)
return ret;
/* C default character code. */
s = GetKeyword (buf, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1);
if (HPDF_StrCmp (buf2, "CX") == 0) {
/* not suppoted yet. */
return HPDF_SetError (fontdef->error,
HPDF_INVALID_CHAR_MATRICS_DATA, 0);
} else
if (HPDF_StrCmp (buf2, "C") == 0) {
s += 2;
s = GetKeyword (s, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1);
HPDF_AToI (buf2);
cdata->char_cd = (HPDF_INT16)HPDF_AToI (buf2);
} else
return HPDF_SetError (fontdef->error,
HPDF_INVALID_CHAR_MATRICS_DATA, 0);
/* WX Character width */
s = HPDF_StrStr (s, "WX ", 0);
if (!s)
return HPDF_SetError (fontdef->error, HPDF_INVALID_WX_DATA, 0);
s += 3;
s = GetKeyword (s, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1);
if (buf2[0] == 0)
return HPDF_SetError (fontdef->error, HPDF_INVALID_WX_DATA, 0);
cdata->width = (HPDF_INT16)HPDF_AToI (buf2);
/* N PostScript language character name */
s = HPDF_StrStr (s, "N ", 0);
if (!s)
return HPDF_SetError (fontdef->error, HPDF_INVALID_N_DATA, 0);
s += 2;
GetKeyword (s, buf2, HPDF_LIMIT_MAX_NAME_LEN + 1);
cdata->unicode = HPDF_GryphNameToUnicode (buf2);
}
return HPDF_OK;
}
