hpdf 2.0.8

data/ext/hpdf_name.c

@@ -0,0 +1,71 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_name.c
+ *
+ * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_conf.h"
+#include "hpdf_utils.h"
+#include "hpdf_objects.h"
+
+
+HPDF_Name
+HPDF_Name_New  (HPDF_MMgr        mmgr,
+                const char  *value)
+{
+    HPDF_Name obj;
+
+    obj  = HPDF_GetMem (mmgr, sizeof(HPDF_Name_Rec));
+
+    if (obj) {
+        HPDF_MemSet (&obj->header, 0, sizeof(HPDF_Obj_Header));
+        obj->header.obj_class = HPDF_OCLASS_NAME;
+        obj->error = mmgr->error;
+        if (HPDF_Name_SetValue (obj, value) == HPDF_NAME_INVALID_VALUE) {
+            HPDF_FreeMem (mmgr, obj);
+            return NULL;
+        }
+    }
+
+    return obj;
+}
+
+
+HPDF_STATUS
+HPDF_Name_Write  (HPDF_Name    obj,
+                  HPDF_Stream  stream)
+{
+    return HPDF_Stream_WriteEscapeName (stream, obj->value);
+}
+
+
+HPDF_STATUS
+HPDF_Name_SetValue  (HPDF_Name        obj,
+                     const char  *value)
+{
+    if (!value || value[0] == 0)
+        return HPDF_SetError (obj->error, HPDF_NAME_INVALID_VALUE, 0);
+
+    if (HPDF_StrLen (value, HPDF_LIMIT_MAX_NAME_LEN + 1) >
+            HPDF_LIMIT_MAX_NAME_LEN)
+        return HPDF_SetError (obj->error, HPDF_NAME_OUT_OF_RANGE, 0);
+
+    HPDF_StrCpy (obj->value, value, obj->value + HPDF_LIMIT_MAX_NAME_LEN);
+
+    return HPDF_OK;
+}
+
+const char*
+HPDF_Name_GetValue (HPDF_Name  obj)
+{
+    return (const char *)obj->value;
+}
+

data/ext/hpdf_null.c

@@ -0,0 +1,31 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_null.c
+ *
+ * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_utils.h"
+#include "hpdf_objects.h"
+
+
+HPDF_Null
+HPDF_Null_New  (HPDF_MMgr  mmgr)
+{
+    HPDF_Null obj = HPDF_GetMem (mmgr, sizeof(HPDF_Null_Rec));
+
+    if (obj) {
+        HPDF_MemSet (&obj->header, 0, sizeof(HPDF_Obj_Header));
+        obj->header.obj_class = HPDF_OCLASS_NULL;
+    }
+
+    return obj;
+}
+

data/ext/hpdf_number.c

@@ -0,0 +1,49 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_number.c
+ *
+ * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_utils.h"
+#include "hpdf_objects.h"
+
+
+HPDF_Number
+HPDF_Number_New  (HPDF_MMgr   mmgr,
+                  HPDF_INT32  value)
+{
+    HPDF_Number obj = HPDF_GetMem (mmgr, sizeof(HPDF_Number_Rec));
+
+    if (obj) {
+        HPDF_MemSet (&obj->header, 0, sizeof(HPDF_Obj_Header));
+        obj->header.obj_class = HPDF_OCLASS_NUMBER;
+        obj->value = value;
+    }
+
+    return obj;
+}
+
+
+HPDF_STATUS
+HPDF_Number_Write  (HPDF_Number  obj,
+                    HPDF_Stream  stream)
+{
+    return HPDF_Stream_WriteInt (stream, obj->value);
+}
+
+
+void
+HPDF_Number_SetValue  (HPDF_Number  obj,
+                       HPDF_INT32   value)
+{
+    obj->value =value;
+}
+

data/ext/hpdf_objects.c

@@ -0,0 +1,172 @@
+/*
+ * << Haru Free PDF Library 2.0.3 >> -- HPDF_objects.c
+ *
+ * Copyright (c) 1999-2004 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_conf.h"
+#include "hpdf_utils.h"
+#include "hpdf_objects.h"
+
+void
+HPDF_Obj_Free  (HPDF_MMgr    mmgr,
+                void         *obj)
+{
+    HPDF_Obj_Header *header;
+
+    HPDF_PTRACE((" HPDF_Obj_Free\n"));
+
+    if (!obj)
+        return;
+
+    header = (HPDF_Obj_Header *)obj;
+
+    if (!(header->obj_id & HPDF_OTYPE_INDIRECT))
+        HPDF_Obj_ForceFree (mmgr, obj);
+}
+
+
+void
+HPDF_Obj_ForceFree  (HPDF_MMgr    mmgr,
+                     void         *obj)
+{
+    HPDF_Obj_Header *header;
+
+    HPDF_PTRACE((" HPDF_Obj_ForceFree\n"));
+
+    if (!obj)
+        return;
+
+    header = (HPDF_Obj_Header *)obj;
+
+    HPDF_PTRACE((" HPDF_Obj_ForceFree obj=0x%08X obj_id=0x%08X "
+                    "obj_class=0x%08X\n",
+                    (HPDF_UINT)obj, (HPDF_UINT)(header->obj_id),
+                    (HPDF_UINT)(header->obj_class)));
+
+    switch (header->obj_class & HPDF_OCLASS_ANY) {
+        case HPDF_OCLASS_STRING:
+            HPDF_String_Free (obj);
+            break;
+        case HPDF_OCLASS_BINARY:
+            HPDF_Binary_Free (obj);
+            break;
+        case HPDF_OCLASS_ARRAY:
+            HPDF_Array_Free (obj);
+            break;
+        case HPDF_OCLASS_DICT:
+            HPDF_Dict_Free (obj);
+            break;
+        default:
+            HPDF_FreeMem (mmgr, obj);
+    }
+}
+
+HPDF_STATUS
+HPDF_Obj_Write  (void          *obj,
+                 HPDF_Stream   stream,
+                 HPDF_Encrypt  e)
+{
+    HPDF_Obj_Header *header = (HPDF_Obj_Header *)obj;
+
+    HPDF_PTRACE((" HPDF_Obj_Write\n"));
+
+    if (header->obj_id & HPDF_OTYPE_HIDDEN) {
+         HPDF_PTRACE(("#HPDF_Obj_Write obj=0x%08X skipped\n", (HPDF_UINT)obj));
+         return HPDF_OK;
+    }
+
+    if (header->obj_class == HPDF_OCLASS_PROXY) {
+        char buf[HPDF_SHORT_BUF_SIZ];
+        char *pbuf = buf;
+        char *eptr = buf + HPDF_SHORT_BUF_SIZ - 1;
+        HPDF_Proxy p = obj;
+
+        header = (HPDF_Obj_Header*)p->obj;
+
+        pbuf = HPDF_IToA (pbuf, header->obj_id & 0x00FFFFFF, eptr);
+        *pbuf++ = ' ';
+        pbuf = HPDF_IToA (pbuf, header->gen_no, eptr);
+        HPDF_StrCpy(pbuf, " R", eptr);
+
+        return HPDF_Stream_WriteStr(stream, buf);
+    }
+
+    return HPDF_Obj_WriteValue(obj, stream, e);
+}
+
+HPDF_STATUS
+HPDF_Obj_WriteValue  (void          *obj,
+                      HPDF_Stream   stream,
+                      HPDF_Encrypt  e)
+{
+    HPDF_Obj_Header *header;
+    HPDF_STATUS ret;
+
+    HPDF_PTRACE((" HPDF_Obj_WriteValue\n"));
+
+    header = (HPDF_Obj_Header *)obj;
+
+    HPDF_PTRACE((" HPDF_Obj_WriteValue obj=0x%08X obj_class=0x%04X\n",
+            (HPDF_UINT)obj, (HPDF_UINT)header->obj_class));
+
+    switch (header->obj_class & HPDF_OCLASS_ANY) {
+        case HPDF_OCLASS_NAME:
+            ret = HPDF_Name_Write (obj, stream);
+            break;
+        case HPDF_OCLASS_NUMBER:
+            ret = HPDF_Number_Write (obj, stream);
+            break;
+        case HPDF_OCLASS_REAL:
+            ret = HPDF_Real_Write (obj, stream);
+            break;
+        case HPDF_OCLASS_STRING:
+            ret = HPDF_String_Write (obj, stream, e);
+            break;
+        case HPDF_OCLASS_BINARY:
+            ret = HPDF_Binary_Write (obj, stream, e);
+            break;
+        case HPDF_OCLASS_ARRAY:
+            ret = HPDF_Array_Write (obj, stream, e);
+            break;
+        case HPDF_OCLASS_DICT:
+            ret = HPDF_Dict_Write (obj, stream, e);
+            break;
+        case HPDF_OCLASS_BOOLEAN:
+            ret = HPDF_Boolean_Write (obj, stream);
+            break;
+        case HPDF_OCLASS_NULL:
+            ret = HPDF_Stream_WriteStr (stream, "null");
+            break;
+        default:
+            ret = HPDF_ERR_UNKNOWN_CLASS;
+    }
+
+    return ret;
+}
+
+HPDF_Proxy
+HPDF_Proxy_New  (HPDF_MMgr  mmgr,
+                 void       *obj)
+{
+    HPDF_Proxy p = HPDF_GetMem (mmgr, sizeof(HPDF_Proxy_Rec));
+
+    HPDF_PTRACE((" HPDF_Proxy_New\n"));
+
+    if (p) {
+        HPDF_MemSet (&p->header, 0, sizeof(HPDF_Obj_Header));
+        p->header.obj_class = HPDF_OCLASS_PROXY;
+        p->obj = obj;
+    }
+
+    return p;
+}
+

data/ext/hpdf_outline.c

@@ -0,0 +1,329 @@
+/*
+ * << Haru Free PDF Library 2.0.3 >> -- hpdf_outline.c
+ *
+ * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_conf.h"
+#include "hpdf_utils.h"
+#include "hpdf_destination.h"
+#include "hpdf.h"
+
+#define HPDF_OUTLINE_CLOSED     0
+#define HPDF_OUTLINE_OPENED     1
+
+
+static HPDF_STATUS
+AddChild  (HPDF_Outline  parent,
+           HPDF_Outline  item);
+
+
+static HPDF_STATUS
+BeforeWrite  (HPDF_Dict obj);
+
+
+static HPDF_UINT
+CountChild (HPDF_Outline  outline);
+
+
+
+/*----------------------------------------------------------------------------*/
+/*----- HPDF_Outline ---------------------------------------------------------*/
+
+HPDF_Outline
+HPDF_OutlineRoot_New  (HPDF_MMgr   mmgr,
+                       HPDF_Xref   xref)
+{
+    HPDF_Outline outline;
+    HPDF_STATUS ret = HPDF_OK;
+    HPDF_Number open_flg;
+
+    HPDF_PTRACE((" HPDF_OutlineRoot_New\n"));
+
+    outline = HPDF_Dict_New (mmgr);
+    if (!outline)
+        return NULL;
+
+    outline->before_write_fn = BeforeWrite;
+
+    if (HPDF_Xref_Add (xref, outline) != HPDF_OK)
+        return NULL;
+
+    open_flg = HPDF_Number_New (mmgr, HPDF_OUTLINE_OPENED);
+    if (!open_flg)
+        return NULL;
+
+    open_flg->header.obj_id |= HPDF_OTYPE_HIDDEN;
+
+    ret += HPDF_Dict_Add (outline, "_OPENED", open_flg);
+    ret += HPDF_Dict_AddName (outline, "Type", "Outline");
+
+    if (ret != HPDF_OK)
+        return NULL;
+
+    outline->header.obj_class |= HPDF_OSUBCLASS_OUTLINE;
+
+    return outline;
+}
+
+
+HPDF_Outline
+HPDF_Outline_New  (HPDF_MMgr          mmgr,
+                   HPDF_Outline       parent,
+                   const char   *title,
+                   HPDF_Encoder       encoder,
+                   HPDF_Xref          xref)
+{
+    HPDF_Outline outline;
+    HPDF_String s;
+    HPDF_STATUS ret = HPDF_OK;
+    HPDF_Number open_flg;
+
+    HPDF_PTRACE((" HPDF_Outline_New\n"));
+
+    if (!mmgr || !parent || !xref)
+        return NULL;
+
+    outline = HPDF_Dict_New (mmgr);
+    if (!outline)
+        return NULL;
+
+    outline->before_write_fn = BeforeWrite;
+
+    if (HPDF_Xref_Add (xref, outline) != HPDF_OK)
+        return NULL;
+
+    s = HPDF_String_New (mmgr, title, encoder);
+    if (!s)
+        return NULL;
+    else
+        ret += HPDF_Dict_Add (outline, "Title", s);
+
+    open_flg = HPDF_Number_New (mmgr, HPDF_OUTLINE_OPENED);
+    if (!open_flg)
+        return NULL;
+
+    open_flg->header.obj_id |= HPDF_OTYPE_HIDDEN;
+    ret += HPDF_Dict_Add (outline, "_OPENED", open_flg);
+
+    ret += HPDF_Dict_AddName (outline, "Type", "Outline");
+    ret += AddChild (parent, outline);
+
+    if (ret != HPDF_OK)
+        return NULL;
+
+    outline->header.obj_class |= HPDF_OSUBCLASS_OUTLINE;
+
+    return outline;
+}
+
+
+
+static HPDF_STATUS
+AddChild  (HPDF_Outline  parent,
+           HPDF_Outline  item)
+{
+    HPDF_Outline first = (HPDF_Outline)HPDF_Dict_GetItem (parent, "First",
+                    HPDF_OCLASS_DICT);
+    HPDF_Outline last = (HPDF_Outline)HPDF_Dict_GetItem (parent, "Last",
+                    HPDF_OCLASS_DICT);
+    HPDF_STATUS ret = 0;
+
+    HPDF_PTRACE((" AddChild\n"));
+
+    if (!first)
+        ret += HPDF_Dict_Add (parent, "First", item);
+
+    if (last) {
+        ret += HPDF_Dict_Add (last, "Next", item);
+        ret += HPDF_Dict_Add (item, "Prev", last);
+    }
+
+    ret += HPDF_Dict_Add (parent, "Last", item);
+    ret += HPDF_Dict_Add (item, "Parent", parent);
+
+    if (ret != HPDF_OK)
+        return HPDF_Error_GetCode (item->error);
+
+    return HPDF_OK;
+}
+
+
+HPDF_BOOL
+HPDF_Outline_GetOpened  (HPDF_Outline  outline)
+{
+    HPDF_Number n = (HPDF_Number)HPDF_Dict_GetItem (outline, "_OPENED",
+                        HPDF_OCLASS_NUMBER);
+
+    HPDF_PTRACE((" HPDF_Outline_GetOpened\n"));
+
+    if (!n)
+        return HPDF_FALSE;
+
+    return (HPDF_BOOL)n->value;
+}
+
+
+HPDF_Outline
+HPDF_Outline_GetFirst  (HPDF_Outline outline)
+{
+    HPDF_PTRACE((" HPDF_Outline_GetFirst\n"));
+
+    return (HPDF_Outline)HPDF_Dict_GetItem (outline, "First",
+                    HPDF_OCLASS_DICT);
+}
+
+
+HPDF_Outline
+HPDF_Outline_GetLast  (HPDF_Outline outline)
+{
+    HPDF_PTRACE((" HPDF_Outline_GetLast\n"));
+
+    return (HPDF_Outline)HPDF_Dict_GetItem (outline, "Last", HPDF_OCLASS_DICT);
+}
+
+
+HPDF_Outline
+HPDF_Outline_GetPrev  (HPDF_Outline outline)
+{
+    HPDF_PTRACE((" HPDF_Outline_GetPrev\n"));
+
+    return (HPDF_Outline)HPDF_Dict_GetItem (outline, "Prev", HPDF_OCLASS_DICT);
+}
+
+
+HPDF_Outline
+HPDF_Outline_GetNext  (HPDF_Outline outline)
+{
+    HPDF_PTRACE((" HPDF_Outline_GetNext\n"));
+
+    return (HPDF_Outline)HPDF_Dict_GetItem (outline, "Next", HPDF_OCLASS_DICT);
+}
+
+
+HPDF_Outline
+HPDF_Outline_GetParent  (HPDF_Outline outline)
+{
+    HPDF_PTRACE((" HPDF_Outline_GetParent\n"));
+
+    return (HPDF_Outline)HPDF_Dict_GetItem (outline, "Parent",
+                    HPDF_OCLASS_DICT);
+}
+
+
+static HPDF_STATUS
+BeforeWrite  (HPDF_Dict obj)
+{
+    HPDF_Number n = (HPDF_Number)HPDF_Dict_GetItem (obj, "Count",
+                HPDF_OCLASS_NUMBER);
+    HPDF_UINT count = CountChild ((HPDF_Outline)obj);
+
+    HPDF_PTRACE((" BeforeWrite\n"));
+
+    if (count == 0 && n)
+        return HPDF_Dict_RemoveElement (obj, "Count");
+
+    if (!HPDF_Outline_GetOpened ((HPDF_Outline)obj))
+        count *= -1;
+
+    if (n)
+        n->value = count;
+    else
+        if (count)
+            return HPDF_Dict_AddNumber (obj, "Count", count);
+
+    return HPDF_OK;
+}
+
+
+static HPDF_UINT
+CountChild (HPDF_Outline  outline)
+{
+    HPDF_Outline  child = HPDF_Outline_GetFirst (outline);
+    HPDF_UINT count = 0;
+
+    HPDF_PTRACE((" CountChild\n"));
+
+    while (child) {
+        count++;
+
+        if (HPDF_Outline_GetOpened (child))
+            count += CountChild (child);
+
+        child = HPDF_Outline_GetNext (child);
+    }
+
+    return count;
+}
+
+
+HPDF_BOOL
+HPDF_Outline_Validate (HPDF_Outline  outline)
+{
+    if (!outline)
+        return HPDF_FALSE;
+
+    HPDF_PTRACE((" HPDF_Outline_Validate\n"));
+
+    if (outline->header.obj_class !=
+                (HPDF_OSUBCLASS_OUTLINE | HPDF_OCLASS_DICT))
+        return HPDF_FALSE;
+
+    return HPDF_TRUE;
+}
+
+HPDF_EXPORT(HPDF_STATUS)
+HPDF_Outline_SetDestination (HPDF_Outline      outline,
+                             HPDF_Destination  dst)
+{
+    HPDF_PTRACE((" HPDF_Outline_SetDestination\n"));
+
+    if (!HPDF_Outline_Validate (outline))
+        return HPDF_INVALID_OUTLINE;
+
+    if (!HPDF_Destination_Validate (dst))
+        return HPDF_RaiseError (outline->error, HPDF_INVALID_DESTINATION, 0);
+
+    if (dst == NULL)
+        return HPDF_Dict_RemoveElement (outline, "Dest");
+
+    if (HPDF_Dict_Add (outline, "Dest", dst) != HPDF_OK)
+        return HPDF_CheckError (outline->error);
+
+    return HPDF_OK;
+}
+
+
+HPDF_EXPORT(HPDF_STATUS)
+HPDF_Outline_SetOpened  (HPDF_Outline  outline,
+                         HPDF_BOOL     opened)
+{
+    HPDF_Number n;
+
+    if (!HPDF_Outline_Validate (outline))
+        return HPDF_INVALID_OUTLINE;
+
+    n = (HPDF_Number)HPDF_Dict_GetItem (outline, "_OPENED",
+                        HPDF_OCLASS_NUMBER);
+
+    HPDF_PTRACE((" HPDF_Outline_SetOpened\n"));
+
+    if (!n) {
+        n = HPDF_Number_New (outline->mmgr, (HPDF_INT)opened);
+        if (!n || HPDF_Dict_Add (outline, "_OPENED", n) != HPDF_OK)
+            return HPDF_CheckError (outline->error);
+    } else
+        n->value = (HPDF_INT)opened;
+
+    return HPDF_OK;
+}
+
+