hpdf.c

/* Lua binding to Haru Free PDF Library 2.0.0

$Id: hpdf.c 32002 2010-11-10 12:37:13Z kurt $

*/

#include <hpdf.h>
#include <lauxlib.h>
#include <lua.h>
#include <lualib.h>

#ifndef HPDF_SHARED
  typedef void *HPDF_HANDLE;
#endif

#define CnHpdfStr "hpdf"

#define CnUnsupported 0

#define HPDF_CALLBACK __stdcall

#define LclCheckReal(L, P) (HPDF_REAL) luaL_checknumber((L), (P))

#define LclCheckU16(L, P) (HPDF_UINT16) luaL_checkinteger((L), (P))

#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
LUALIB_API void luaL_setfuncs (
  lua_State *L,
  const luaL_Reg *l,
  int nup)

{
  int i;

  luaL_checkstack(L, nup, "too many upvalues");
  for (; l->name != NULL; l++) {  /* fill the table with given functions */
    for (i = 0; i < nup; i++) { /* copy upvalues to the top */
      lua_pushvalue(L, -nup);
    }
    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
    lua_setfield(L, -(nup + 2), l->name);
  }
  lua_pop(L, nup);  /* remove upvalues */
}
#define lua_rawlen lua_objlen
#endif

typedef enum LclHndCatEnum {
  CnHndAnnotation,
  CnHndDestination,
  CnHndDoc,
  CnHndEncoder,
  CnHndExtGState,
  CnHndFont,
  CnHndImage,
  CnHndOutline,
  CnHndPage,
  CnHndXObject
} LclHndCatType;

const char * CnPageLayout[] = {
  "HPDF_PAGE_LAYOUT_SINGLE",
  "HPDF_PAGE_LAYOUT_ONE_COLUMN",
  "HPDF_PAGE_LAYOUT_TWO_COLUMN_LEFT",
  "HPDF_PAGE_LAYOUT_TWO_COLUMN_RIGHT",
  "HPDF_PAGE_LAYOUT_EOF",
  NULL};

const char * CnPageMode[] = {
  "HPDF_PAGE_MODE_USE_NONE",
  "HPDF_PAGE_MODE_USE_OUTLINE",
  "HPDF_PAGE_MODE_USE_THUMBS",
  "HPDF_PAGE_MODE_FULL_SCREEN",
  "HPDF_PAGE_MODE_EOF",
  NULL};

const char * CnPageSizes[] = {
  "HPDF_PAGE_SIZE_LETTER",
  "HPDF_PAGE_SIZE_LEGAL",
  "HPDF_PAGE_SIZE_A3",
  "HPDF_PAGE_SIZE_A4",
  "HPDF_PAGE_SIZE_A5",
  "HPDF_PAGE_SIZE_B4",
  "HPDF_PAGE_SIZE_B5",
  "HPDF_PAGE_SIZE_EXECUTIVE",
  "HPDF_PAGE_SIZE_US4x6",
  "HPDF_PAGE_SIZE_US4x8",
  "HPDF_PAGE_SIZE_US5x7",
  "HPDF_PAGE_SIZE_COMM10",
  "HPDF_PAGE_SIZE_EOF",
  NULL};

const char * CnPageDirection[] = {
  "HPDF_PAGE_PORTRAIT",
  "HPDF_PAGE_LANDSCAPE",
  NULL};

const char * CnPageNumStyle[] = {
  "HPDF_PAGE_NUM_STYLE_DECIMAL",
  "HPDF_PAGE_NUM_STYLE_UPPER_ROMAN",
  "HPDF_PAGE_NUM_STYLE_LOWER_ROMAN",
  "HPDF_PAGE_NUM_STYLE_UPPER_LETTERS",
  "HPDF_PAGE_NUM_STYLE_LOWER_LETTERS",
  "HPDF_PAGE_NUM_STYLE_EOF",
  NULL};

const char * CnEncoderType[] = {
  "HPDF_ENCODER_TYPE_SINGLE_BYTE",
  "HPDF_ENCODER_TYPE_DOUBLE_BYTE",
  "HPDF_ENCODER_TYPE_UNINITIALIZED",
  "HPDF_ENCODER_UNKNOWN",
  NULL};

const char * CnByteType[] = {
  "HPDF_BYTE_TYPE_SINGLE",
  "HPDF_BYTE_TYPE_LEAD",
  "HPDF_BYTE_TYPE_TRIAL",
  "HPDF_BYTE_TYPE_UNKNOWN",
  NULL};

const char * CnWritingMode[] = {
  "HPDF_WMODE_HORIZONTAL",
  "HPDF_WMODE_VERTICAL",
  "HPDF_WMODE_EOF",
  NULL};

const char * CnAnnotHighlightMode[] = {
  "HPDF_ANNOT_NO_HIGHTLIGHT",
  "HPDF_ANNOT_INVERT_BOX",
  "HPDF_ANNOT_INVERT_BORDER",
  "HPDF_ANNOT_DOWN_APPEARANCE",
  "HPDF_ANNOT_HIGHTLIGHT_MODE_EOF",
  NULL};

const char * CnAnnotIcon[] = {
  "HPDF_ANNOT_ICON_COMMENT",
  "HPDF_ANNOT_ICON_KEY",
  "HPDF_ANNOT_ICON_NOTE",
  "HPDF_ANNOT_ICON_HELP",
  "HPDF_ANNOT_ICON_NEW_PARAGRAPH",
  "HPDF_ANNOT_ICON_PARAGRAPH",
  "HPDF_ANNOT_ICON_INSERT",
  "HPDF_ANNOT_ICON_EOF",
  NULL};

const char * CnColorSpace[] = {
  "HPDF_CS_DEVICE_GRAY",
  "HPDF_CS_DEVICE_RGB",
  "HPDF_CS_DEVICE_CMYK",
  "HPDF_CS_CAL_GRAY",
  "HPDF_CS_CAL_RGB",
  "HPDF_CS_LAB",
  "HPDF_CS_ICC_BASED",
  "HPDF_CS_SEPARATION",
  "HPDF_CS_DEVICE_N",
  "HPDF_CS_INDEXED",
  "HPDF_CS_PATTERN",
  "HPDF_CS_EOF",
  NULL};

const char * CnInfoType[] = {
  /* date-time type parameters */
  "HPDF_INFO_CREATION_DATE",
  "HPDF_INFO_MOD_DATE",
  /* string type parameters */
  "HPDF_INFO_AUTHOR",
  "HPDF_INFO_CREATOR",
  "HPDF_INFO_PRODUCER",
  "HPDF_INFO_TITLE",
  "HPDF_INFO_SUBJECT",
  "HPDF_INFO_KEYWORDS",
  "HPDF_INFO_EOF",
  NULL};

const char * CnEncryptMode[] = {
  "",
  "",
  "HPDF_ENCRYPT_R2",
  "HPDF_ENCRYPT_R3",
  NULL};

const char * CnBlendMode[] = {
  "HPDF_BM_NORMAL",
  "HPDF_BM_MULTIPLY",
  "HPDF_BM_SCREEN",
  "HPDF_BM_OVERLAY",
  "HPDF_BM_DARKEN",
  "HPDF_BM_LIGHTEN",
  "HPDF_BM_COLOR_DODGE",
  "HPDF_BM_COLOR_BUM",
  "HPDF_BM_HARD_LIGHT",
  "HPDF_BM_SOFT_LIGHT",
  "HPDF_BM_DIFFERENCE",
  "HPDF_BM_EXCLUSHON",
  "HPDF_BM_EOF",
  NULL};

const char * CnLineCap[] = {
  "HPDF_BUTT_END",
  "HPDF_ROUND_END",
  "HPDF_PROJECTING_SCUARE_END",
  "HPDF_LINECAP_EOF",
  NULL};

const char * CnLineJoin[] = {
  "HPDF_MITER_JOIN",
  "HPDF_ROUND_JOIN",
  "HPDF_BEVEL_JOIN",
  "HPDF_LINEJOIN_EOF",
  NULL};

const char * CnTextRenderingMode[] = {
  "HPDF_FILL",
  "HPDF_STROKE",
  "HPDF_FILL_THEN_STROKE",
  "HPDF_INVISIBLE",
  "HPDF_FILL_CLIPPING",
  "HPDF_STROKE_CLIPPING",
  "HPDF_FILL_STROKE_CLIPPING",
  "HPDF_CLIPPING",
  "HPDF_RENDERING_MODE_EOF",
  NULL};

const char * CnTextAlignment[] = {
  "HPDF_TALIGN_LEFT",
  "HPDF_TALIGN_RIGHT",
  "HPDF_TALIGN_CENTER",
  "HPDF_TALIGN_JUSTIFY",
  NULL};

const char * CnTransitionStyle[] = {
  "HPDF_TS_WIPE_RIGHT",
  "HPDF_TS_WIPE_UP",
  "HPDF_TS_WIPE_LEFT",
  "HPDF_TS_WIPE_DOWN",
  "HPDF_TS_BARN_DOORS_HORIZONTAL_OUT",
  "HPDF_TS_BARN_DOORS_HORIZONTAL_IN",
  "HPDF_TS_BARN_DOORS_VERTICAL_OUT",
  "HPDF_TS_BARN_DOORS_VERTICAL_IN",
  "HPDF_TS_BOX_OUT",
  "HPDF_TS_BOX_IN",
  "HPDF_TS_BLINDS_HORIZONTAL",
  "HPDF_TS_BLINDS_VERTICAL",
  "HPDF_TS_DISSOLVE",
  "HPDF_TS_GLITTER_RIGHT",
  "HPDF_TS_GLITTER_DOWN",
  "HPDF_TS_GLITTER_TOP_LEFT_TO_BOTTOM_RIGHT",
  "HPDF_TS_REPLACE",
  "HPDF_TS_EOF",
  NULL};

typedef struct LclErrMsgStruct
{
  int value;
  const char * name;
} LclErrMsgType;

const LclErrMsgType CnErrorMessages[] = {
  {HPDF_ARRAY_COUNT_ERR, "Internal error. Data consistency was lost."},
  {HPDF_ARRAY_ITEM_NOT_FOUND, "Internal error. Data consistency was lost."},
  {HPDF_ARRAY_ITEM_UNEXPECTED_TYPE, "Internal error. Data consistency was lost."},
  {HPDF_BINARY_LENGTH_ERR, "Data length > HPDF_LIMIT_MAX_STRING_LEN."},
  {HPDF_CANNOT_GET_PALLET, "Cannot get pallet data from PNG image."},
  {HPDF_DICT_COUNT_ERR, "Dictionary elements > HPDF_LIMIT_MAX_DICT_ELEMENT"},
  {HPDF_DICT_ITEM_NOT_FOUND, "Internal error. Data consistency was lost."},
  {HPDF_DICT_ITEM_UNEXPECTED_TYPE, "Internal error. Data consistency was lost."},
  {HPDF_DICT_STREAM_LENGTH_NOT_FOUND, "Internal error. Data consistency was lost."},
  {HPDF_DOC_ENCRYPTDICT_NOT_FOUND, "HPDF_SetEncryptMode() or HPDF_SetPermission() called before password set."},
  {HPDF_DOC_INVALID_OBJECT, "Internal error. Data consistency was lost."},
  {HPDF_DUPLICATE_REGISTRATION, "Tried to re-register a registered font."},
  {HPDF_EXCEED_JWW_CODE_NUM_LIMIT, "Cannot register a character to the Japanese word wrap characters list."},
  {HPDF_ENCRYPT_INVALID_PASSWORD, "1. Tried to set the owner password to NULL.\n"
    "2. Owner and user password are the same."},
  {HPDF_ERR_UNKNOWN_CLASS, "Internal error. Data consistency was lost."},
  {HPDF_EXCEED_GSTATE_LIMIT, "Stack depth > HPDF_LIMIT_MAX_GSTATE."},
  {HPDF_FAILD_TO_ALLOC_MEM, "Memory allocation failed."},
  {HPDF_FILE_IO_ERROR, "File processing failed. (Detailed code is set.)"},
  {HPDF_FILE_OPEN_ERROR, "Cannot open a file. (Detailed code is set.)"},
  {HPDF_FONT_EXISTS, "Tried to load a font that has been registered."},
  {HPDF_FONT_INVALID_WIDTHS_TABLE, "1. Font-file format is invalid.\n"
    "2. Internal error. Data consistency was lost."},
  {HPDF_INVALID_AFM_HEADER, "Cannot recognize header of afm file."},
  {HPDF_INVALID_ANNOTATION, "Specified annotation handle is invalid."},
  {HPDF_INVALID_BIT_PER_COMPONENT, "Bit-per-component of a image which was set as mask-image is invalid."},
  {HPDF_INVALID_CHAR_MATRICS_DATA, "Cannot recognize char-matrics-data of afm file."},
  {HPDF_INVALID_COLOR_SPACE, "1. Invalid color_space parameter of HPDF_LoadRawImage.\n"
    "2. Color-space of a image which was set as mask-image is invalid.\n"
    "3. Invoked function invalid in present color-space."},
  {HPDF_INVALID_COMPRESSION_MODE, "Invalid value set when invoking HPDF_SetCommpressionMode()."},
  {HPDF_INVALID_DATE_TIME, "An invalid date-time value was set."},
  {HPDF_INVALID_DESTINATION, "An invalid destination handle was set."},
  {HPDF_INVALID_DOCUMENT, "An invalid document handle was set."},
  {HPDF_INVALID_DOCUMENT_STATE, "Function invalid in the present state was invoked."},
  {HPDF_INVALID_ENCODER, "An invalid encoder handle was set."},
  {HPDF_INVALID_ENCODER_TYPE, "Combination between font and encoder is wrong."},
  {HPDF_INVALID_ENCODING_NAME, "An Invalid encoding name is specified."},
  {HPDF_INVALID_ENCRYPT_KEY_LEN, "Encryption key length is invalid."},
  {HPDF_INVALID_FONTDEF_DATA, "1. An invalid font handle was set.\n"
    "2. Unsupported font format."},
  {HPDF_INVALID_FONTDEF_TYPE, "Internal error. Data consistency was lost."},
  {HPDF_INVALID_FONT_NAME, "Font with the specified name is not found."},
  {HPDF_INVALID_IMAGE, "Unsupported image format."},
  {HPDF_INVALID_JPEG_DATA, "Unsupported image format."},
  {HPDF_INVALID_N_DATA, "Cannot read a postscript-name from an afm file."},
  {HPDF_INVALID_OBJECT, "1. An invalid object is set.\n"
    "2. Internal error. Data consistency was lost."},
  {HPDF_INVALID_OBJ_ID, "Internal error. Data consistency was lost."},
  {HPDF_INVALID_OPERATION, "Invoked HPDF_Image_SetColorMask() against the image-object which was set a mask-image."},
  {HPDF_INVALID_OUTLINE, "An invalid outline-handle was specified."},
  {HPDF_INVALID_PAGE, "An invalid page-handle was specified."},
  {HPDF_INVALID_PAGES, "An invalid pages-handle was specified. (internal error)"},
  {HPDF_INVALID_PARAMETER, "An invalid value is set."},
  {HPDF_INVALID_PNG_IMAGE, "Invalid PNG image format."},
  {HPDF_INVALID_STREAM, "Internal error. Data consistency was lost."},
  {HPDF_MISSING_FILE_NAME_ENTRY, "Internal error. \"_FILE_NAME\" entry for delayed loading is missing."},
  {HPDF_INVALID_TTC_FILE, "Invalid .TTC file format."},
  {HPDF_INVALID_TTC_INDEX, "Index parameter > number of included fonts."},
  {HPDF_INVALID_WX_DATA, "Cannot read a width-data from an afm file."},
  {HPDF_ITEM_NOT_FOUND, "Internal error. Data consistency was lost."},
  {HPDF_LIBPNG_ERROR, "Error returned from PNGLIB while loading image."},
  {HPDF_NAME_INVALID_VALUE, "Internal error. Data consistency was lost."},
  {HPDF_NAME_OUT_OF_RANGE, "Internal error. Data consistency was lost."},
  {HPDF_PAGES_MISSING_KIDS_ENTRY, "Internal error. Data consistency was lost."},
  {HPDF_PAGE_CANNOT_FIND_OBJECT, "Internal error. Data consistency was lost."},
  {HPDF_PAGE_CANNOT_GET_ROOT_PAGES, "Internal error. Data consistency was lost."},
  {HPDF_PAGE_CANNOT_RESTORE_GSTATE, "There are no graphics-states to be restored."},
  {HPDF_PAGE_CANNOT_SET_PARENT, "Internal error. Data consistency was lost."},
  {HPDF_PAGE_FONT_NOT_FOUND, "The current font is not set."},
  {HPDF_PAGE_INVALID_FONT, "An invalid font-handle was specified."},
  {HPDF_PAGE_INVALID_FONT_SIZE, "An invalid font-size was set."},
  {HPDF_PAGE_INVALID_GMODE, "Invalid Graphics mode."},
  {HPDF_PAGE_INVALID_INDEX, "Internal error. Data consistency was lost."},
  {HPDF_PAGE_INVALID_ROTATE_VALUE, "Specified value is not multiple of 90."},
  {HPDF_PAGE_INVALID_SIZE, "An invalid page-size was set."},
  {HPDF_PAGE_INVALID_XOBJECT, "An invalid image-handle was set."},
  {HPDF_PAGE_OUT_OF_RANGE, "The specified value is out of range."},
  {HPDF_REAL_OUT_OF_RANGE, "The specified value is out of range."},
  {HPDF_STREAM_EOF, "Unexpected EOF marker was detected."},
  {HPDF_STREAM_READLN_CONTINUE, "Internal error. Data consistency was lost."},
  {HPDF_STRING_OUT_OF_RANGE, "The length of the text is too long."},
  {HPDF_THIS_FUNC_WAS_SKIPPED, "Function not executed because of other errors."},
  {HPDF_TTF_CANNOT_EMBEDDING_FONT, "Font cannot be embedded. (license restriction)"},
  {HPDF_TTF_INVALID_CMAP, "Unsupported ttf format. (cannot find unicode cmap)"},
  {HPDF_TTF_INVALID_FOMAT, "Unsupported ttf format."},
  {HPDF_TTF_MISSING_TABLE, "Unsupported ttf format. (cannot find a necessary table)"},
  {HPDF_UNSUPPORTED_FONT_TYPE, "Internal error. Data consistency was lost."},
  {HPDF_UNSUPPORTED_FUNC, "1. Library not configured to use PNGLIB.\n"
    "2. Internal error. Data consistency was lost."},
  {HPDF_UNSUPPORTED_JPEG_FORMAT, "Unsupported JPEG format."},
  {HPDF_UNSUPPORTED_TYPE1_FONT, "Failed to parse .PFB file."},
  {HPDF_XREF_COUNT_ERR, "Internal error. Data consistency was lost."},
  {HPDF_ZLIB_ERROR, "Error while executing ZLIB function."},
  {HPDF_INVALID_PAGE_INDEX, "An invalid page index was passed."},
  {HPDF_INVALID_URI, "An invalid URI was set."},
  /*{HPDF_PAGELAYOUT_OUT_OF_RANGE, "An invalid page-layout was set."},*/
  /*{HPDF_PAGEMODE_OUT_OF_RANGE, "An invalid page-mode was set."},*/
  /*{HPDF_PAGENUM_STYLE_OUT_OF_RANGE, "An invalid page-num-style was set."},*/
  {HPDF_ANNOT_INVALID_ICON, "An invalid icon was set."},
  {HPDF_ANNOT_INVALID_BORDER_STYLE, "An invalid border-style was set."},
  {HPDF_PAGE_INVALID_DIRECTION, "An invalid page-direction was set."},
  {HPDF_INVALID_FONT, "An invalid font-handle was specified."},
  {0, NULL}};

/* * */

void HPDF_STDCALL LclErrHandler(
  HPDF_STATUS ErrNum,
  HPDF_STATUS DetailNum,
  void * UserPtr)

{
  char ErrStr[128];
  lua_State * L = (lua_State *) UserPtr;
  const LclErrMsgType * it;

  /* TODO
  [ ] Make error more descriptive
  [ ] Use Lua concatentation instead of sprintf
  */

  for (it=CnErrorMessages; it->name; ++it)
  {
    if (it->value==ErrNum)
    {
      lua_pushstring(L, it->name);
      if (DetailNum != 0)
      {
        lua_pushfstring(L, "(detail %d)", DetailNum);
        lua_concat(L, 2);
      }
      break;
    }
  }
  if (!it->name)
  {
    sprintf(ErrStr, "HPDF error 0x%04X, detail %u", (HPDF_UINT) ErrNum,
      (HPDF_UINT) DetailNum);
    lua_pushstring(L, ErrStr);
  }
  lua_error(L);
}

/* * */

static void LclHandlePush(
  lua_State * L,
  HPDF_HANDLE Hnd,
  LclHndCatType Cat)

{
  /* Stk: ...  */
  lua_pushvalue(L, lua_upvalueindex(1));
  /* Stk: ... HndTbl */
  lua_pushlightuserdata(L, Hnd);
  /* Stk: ... HndTbl Hnd */
  lua_pushinteger(L, Cat);
  /* Stk: ... HndTbl Hnd Cat */
  lua_rawset(L, -3);
  /* Stk: ... HndTbl */
  lua_pop(L, 1);
  /* Stk: ...  */
  lua_pushlightuserdata(L, Hnd);
  /* Stk: ... Hnd */
}

/* * */

static HPDF_HANDLE LclHandleGet(
  lua_State * L,
  LclHndCatType Cat,
  int StkPos)

{
  HPDF_HANDLE Hnd;
  int ChkCat;

  luaL_argcheck(L, lua_isuserdata(L, StkPos), StkPos, "expecting handle");
  Hnd = lua_touserdata(L, StkPos);
  /* Stk: ...  */
  lua_pushvalue(L, lua_upvalueindex(1));
  /* Stk: ... HndTbl */
  lua_pushlightuserdata(L, Hnd);
  /* Stk: ... HndTbl Hnd */
  lua_rawget(L, -2);
  /* Stk: ... HndTbl HndCat? */
  luaL_argcheck(L, lua_isnumber(L, -1), StkPos, "expecting HPDF handle");
  ChkCat = lua_tointeger(L, -1);
  luaL_argcheck(L, (Cat == ChkCat), StkPos, "unexpected HPDF handle type");
  lua_pop(L, 2);
  return Hnd;
}

/* * */

static HPDF_HANDLE LclOptHandleGet(
  lua_State * L,
  LclHndCatType Cat,
  int StkPos)

  /* If handle is missing or nil at StkPos, return (HPDF_HANDLE) 0. */

{
  int Tp = lua_type(L, StkPos);
  return ((LUA_TNIL == Tp) || (LUA_TNONE == Tp)) ? (HPDF_HANDLE) 0 :
    LclHandleGet(L, Cat, StkPos);
}

/* * */

static HPDF_REAL LclTblNum(
  lua_State * L,
  const char * NameStr)

{
  HPDF_REAL Num = 0;

  /* Stk: ... Tbl */
  lua_pushstring(L, NameStr);
  /* Stk: ... Tbl NameStr */
  lua_rawget(L, -2);
  /* Stk: ... Tbl Num? */
  if (lua_isnumber(L, -1)) {
    Num = (HPDF_REAL) lua_tonumber(L, -1);
  } else {
    luaL_error(L, "field " LUA_QS " not found", NameStr);
  }
  lua_pop(L, 1);
  /* Stk: ... Tbl */
  return Num;
}

/* * */

static HPDF_INT LclTblIntOpt(
  lua_State * L,
  const char * NameStr,
  lua_Integer Default)

{
  HPDF_INT Num = 0;

  /* Stk: ... Tbl */
  lua_pushstring(L, NameStr);
  /* Stk: ... Tbl NameStr */
  lua_rawget(L, -2);
  /* Stk: ... Tbl Num? */
  if (lua_isnumber(L, -1)) {
    Num = lua_tointeger(L, -1);
  } else {
    Num = Default;
  }
  lua_pop(L, 1);
  /* Stk: ... Tbl */
  return Num;
}

/* * */

static HPDF_INT LclTblInt(
  lua_State * L,
  const char * NameStr)

{
  HPDF_INT Num = 0;

  /* Stk: ... Tbl */
  lua_pushstring(L, NameStr);
  /* Stk: ... Tbl NameStr */
  lua_rawget(L, -2);
  /* Stk: ... Tbl Num? */
  if (lua_isnumber(L, -1)) {
    Num = lua_tointeger(L, -1);
  } else {
    luaL_error(L, "field " LUA_QS " not found", NameStr);
  }
  lua_pop(L, 1);
  /* Stk: ... Tbl */
  return Num;
}

/* * */

static char LclTblChar(
  lua_State * L,
  const char * NameStr)

{
  const char * Str;
  char Ch = ' ';

  /* Stk: ... RctTbl */
  lua_pushstring(L, NameStr);
  /* Stk: ... RctTbl NameStr */
  lua_rawget(L, -2);
  /* Stk: ... RctTbl Str? */
  Str = lua_tostring(L, -1);
  if (! Str) {
    luaL_error(L, "expecting character field " LUA_QS, NameStr);
  } else {
    Ch = *Str;
  }
  lua_pop(L, 1);
  /* Stk: ... RctTbl */
  return Ch;
}

/* * */

static void LclRectGet(
  lua_State * L,
  HPDF_Rect * RctPtr,
  int StkPos)

{
  /* Stk: ... */
  luaL_argcheck(L, lua_istable(L, StkPos), StkPos, "expecting rectangle table");
  lua_pushvalue(L, StkPos);
  /* Stk: ... RctTbl? */
  RctPtr->left = LclTblNum(L, "left");
  RctPtr->bottom = LclTblNum(L, "bottom");
  RctPtr->right = LclTblNum(L, "right");
  RctPtr->top = LclTblNum(L, "top");
  /* Stk: ... RctTbl */
  lua_pop(L, 1);
  /* Stk: ...  */
}

/* * */

static void LclSetNumField(
  lua_State * L,
  HPDF_REAL Num,
  const char * FldStr)

  /* Sets field T[FldStr] = Num where T is table at top of stack */

{
  /* Stk: ... Tbl */
  lua_pushstring(L, FldStr);
  /* Stk: ... Tbl FldStr */
  lua_pushnumber(L, Num);
  /* Stk: ... Tbl FldStr Num */
  lua_rawset(L, -3);
  /* Stk: ... Tbl */
}

/* * */

static void LclSetIntField(
  lua_State * L,
  HPDF_UINT Num,
  const char * FldStr)

  /* Sets field T[FldStr] = Num where T is table at top of stack */

{
  /* Stk: ... Tbl */
  lua_pushinteger(L, Num);
  /* Stk: ... Tbl Num */
  lua_setfield(L, -2, FldStr);
  /* Stk: ... Tbl */
}

/* * */

static void LclTransMatrixPush(
  lua_State * L,
  HPDF_TransMatrix Tm)

{
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */
  LclSetNumField(L, Tm.a, "a");
  LclSetNumField(L, Tm.b, "b");
  LclSetNumField(L, Tm.c, "c");
  LclSetNumField(L, Tm.d, "d");
  LclSetNumField(L, Tm.x, "x");
  LclSetNumField(L, Tm.y, "y");
  /* Stk: ... Tbl */
}

/* * */

static void LclPointPush(
  lua_State * L,
  HPDF_Point Pt)

{
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */
  LclSetNumField(L, Pt.x, "x");
  LclSetNumField(L, Pt.y, "y");
  /* Stk: ... Tbl */
}

/* * */

static void LclRgbPush(
  lua_State * L,
  HPDF_RGBColor Clr)

{
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */
  LclSetNumField(L, Clr.r, "r");
  LclSetNumField(L, Clr.g, "g");
  LclSetNumField(L, Clr.b, "b");
  /* Stk: ... Tbl */
}

/* * */

static void LclCmykPush(
  lua_State * L,
  HPDF_CMYKColor Clr)

{
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */
  LclSetNumField(L, Clr.c, "c");
  LclSetNumField(L, Clr.m, "m");
  LclSetNumField(L, Clr.y, "y");
  LclSetNumField(L, Clr.k, "k");
  /* Stk: ... Tbl */
}

/* * */

static void LclDateGet(
  lua_State * L,
  HPDF_Date * DatePtr,
  int StkPos)

{
  /* Stk: ... */
  luaL_argcheck(L, lua_istable(L, StkPos), StkPos, "expecting date table");
  lua_pushvalue(L, StkPos);
  /* Stk: ... DateTbl? */
  DatePtr->year = LclTblInt(L, "year");
  DatePtr->month = LclTblInt(L, "month");
  DatePtr->day = LclTblInt(L, "day");
  DatePtr->hour = LclTblInt(L, "hour");
  DatePtr->minutes = LclTblInt(L, "minutes");
  DatePtr->seconds = LclTblInt(L, "seconds");
  DatePtr->ind = LclTblChar(L, "ind");
  DatePtr->off_hour = LclTblIntOpt(L, "off_hour", 0);
  DatePtr->off_minutes = LclTblIntOpt(L, "off_minutes", 0);
  /* Stk: ... DateTbl */
  lua_pop(L, 1);
  /* Stk: ...  */
}

/* * */

static int LclGetHandleTable(lua_State *L)

  /* handle table <- hpdf.GetHandleTable() */

{
  /* Stk: ...  */
    lua_pushvalue(L, lua_upvalueindex(1));
  /* Stk: ... HndTbl */
  return 1;
}

/* * */

static int LclGetVersion(lua_State *L)

  /* string <- hpdf.GetVersion() */

{
  const char * result = HPDF_GetVersion();
  lua_pushstring(L, result);
  return 1;
}

/* * */

#if CnUnsupported

static int LclNewEx(lua_State *L)

  /* HPDF_Doc <- hpdf.NewEx(user_error_fn, user_alloc_fn,
       user_free_fn, mem_pool_buf_size, user_data) */

{
  HPDF_Error_Handler user_error_fn = LclHandleGet(L, "HPDF_Error_Handler", 1);
  HPDF_Alloc_Func user_alloc_fn = LclHandleGet(L, "HPDF_Alloc_Func", 2);
  HPDF_Free_Func user_free_fn = LclHandleGet(L, "HPDF_Free_Func", 3);
  HPDF_UINT mem_pool_buf_size = luaL_checkinteger(L, 4);
  /*  id * user_data  ! Get argument 5 (void *) here */
  HPDF_Doc result = HPDF_NewEx(user_error_fn, user_alloc_fn,
    user_free_fn, mem_pool_buf_size, user_data);
  LclHandlePush(L, result, CnHndDoc);
  return 1;
}

#endif

/* * */

#if CnUnsupported

static int LclNew(lua_State *L)

  /* HPDF_Doc <- hpdf.New(user_error_fn, user_data)
  API change
  Doc <- hpdf.New() */

{
  HPDF_Error_Handler user_error_fn = LclHandleGet(L, "HPDF_Error_Handler", 1);
  /*  void * user_data  ! Get argument 2 (void *) here */
  HPDF_Doc result = HPDF_New(user_error_fn, user_data);
  LclHandlePush(L, result, CnHndDoc);
  return 1;
}

#endif

/* * */

static int LclNew(lua_State *L)

  /* HPDF_Doc <- hpdf.New() */

{
  HPDF_Doc result = HPDF_New(LclErrHandler, L);
  LclHandlePush(L, result, CnHndDoc);
  return 1;
}

/* * */

#if CnUnsupported

static int LclSetErrorHandler(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetErrorHandler(pdf, user_error_fn) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Error_Handler user_error_fn = LclHandleGet(L, "HPDF_Error_Handler", 2);
  HPDF_STATUS result = HPDF_SetErrorHandler(pdf, user_error_fn);
  lua_pushinteger(L, result);
  return 1;
}

#endif

/* * */

static int LclFree(lua_State *L)

  /* hpdf.Free(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Free(pdf);
  return 0;
}

/* * */

static int LclNewDoc(lua_State *L)

  /* HPDF_STATUS <- hpdf.NewDoc(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_NewDoc(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFreeDoc(lua_State *L)

  /* hpdf.FreeDoc(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_FreeDoc(pdf);
  return 0;
}

/* * */

static int LclHasDoc(lua_State *L)

  /* boolean <- hpdf.HasDoc(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_BOOL result = HPDF_HasDoc(pdf);
  lua_pushboolean(L, result);
  return 1;
}

/* * */

static int LclFreeDocAll(lua_State *L)

  /* hpdf.FreeDocAll(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_FreeDocAll(pdf);
  return 0;
}

/* * */

static int LclSaveToStream(lua_State *L)

  /* HPDF_STATUS <- hpdf.SaveToStream(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_SaveToStream(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetStreamSize(lua_State *L)

  /* integer <- hpdf.GetStreamSize(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT32 result = HPDF_GetStreamSize(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

#if CnUnsupported

static int LclReadFromStream(lua_State *L)

  /* HPDF_STATUS <- hpdf.ReadFromStream(pdf, buf, size) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
/*  HPDF_BYTE * buf  ! Get argument 2 (HPDF_BYTE *) here */
/*  HPDF_UINT32 * size  ! Get argument 3 (HPDF_UINT32 *) here */
  HPDF_STATUS result = HPDF_ReadFromStream(pdf, buf, size);
  lua_pushinteger(L, result);
  return 1;
}

#endif

/* * */

static int LclResetStream(lua_State *L)

  /* HPDF_STATUS <- hpdf.ResetStream(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_ResetStream(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSaveToFile(lua_State *L)

  /* HPDF_STATUS <- hpdf.SaveToFile(pdf, file_name) */

{
  FILE * fl;
  HPDF_STATUS result;
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * file_name = luaL_checkstring(L, 2);
  fl = fopen(file_name, "we");
  if (fl) {
    fclose(fl);
    result = HPDF_SaveToFile(pdf, file_name);
  } else {
    result = 0x1016;
  }
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetError(lua_State *L)

  /* HPDF_STATUS <- hpdf.GetError(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_GetError(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetErrorDetail(lua_State *L)

  /* HPDF_STATUS <- hpdf.GetErrorDetail(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_GetErrorDetail(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclResetError(lua_State *L)

  /* hpdf.ResetError(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_ResetError(pdf);
  return 0;
}

/* * */

static int LclSetPagesConfiguration(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetPagesConfiguration(pdf, page_per_pages) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT page_per_pages = luaL_checkinteger(L, 2);
  HPDF_STATUS result = HPDF_SetPagesConfiguration(pdf, page_per_pages);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetPageByIndex(lua_State *L)

  /* HPDF_Page <- hpdf.GetPageByIndex(pdf, index) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT index = luaL_checkinteger(L, 2);
  HPDF_Page result = HPDF_GetPageByIndex(pdf, index);
  LclHandlePush(L, result, CnHndPage);
  return 1;
}

/* * */

static int LclGetPageLayout(lua_State *L)

  /* HPDF_PageLayout <- hpdf.GetPageLayout(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_PageLayout result = HPDF_GetPageLayout(pdf);
  lua_pushstring(L, CnPageLayout[result]);
  return 1;
}

/* * */

static int LclSetPageLayout(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetPageLayout(pdf, layout) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_PageLayout layout = luaL_checkoption(L, 2,
    "HPDF_PAGE_LAYOUT_SINGLE", CnPageLayout);
  HPDF_STATUS result = HPDF_SetPageLayout(pdf, layout);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetPageMode(lua_State *L)

  /* HPDF_PageMode <- hpdf.GetPageMode(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_PageMode result = HPDF_GetPageMode(pdf);
  lua_pushstring(L, CnPageMode[result]);
  return 1;
}

/* * */

static int LclSetPageMode(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetPageMode(pdf, mode) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_PageMode mode = luaL_checkoption(L, 2,
    "HPDF_PAGE_MODE_USE_NONE", CnPageMode);
  HPDF_STATUS result = HPDF_SetPageMode(pdf, mode);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetViewerPreference(lua_State *L)

  /* integer <- hpdf.GetViewerPreference(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT result = HPDF_GetViewerPreference(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetViewerPreference(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetViewerPreference(pdf, value) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT value = luaL_checkinteger(L, 2);
  HPDF_STATUS result = HPDF_SetViewerPreference(pdf, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetOpenAction(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetOpenAction(pdf, open_action) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Destination open_action = LclHandleGet(L, CnHndDestination, 2);
  HPDF_STATUS result = HPDF_SetOpenAction(pdf, open_action);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetCurrentPage(lua_State *L)

  /* HPDF_Page <- hpdf.GetCurrentPage(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Page result = HPDF_GetCurrentPage(pdf);
  LclHandlePush(L, result, CnHndPage);
  return 1;
}

/* * */

static int LclAddPage(lua_State *L)

  /* HPDF_Page <- hpdf.AddPage(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Page result = HPDF_AddPage(pdf);
  LclHandlePush(L, result, CnHndPage);
  return 1;
}

/* * */

static int LclInsertPage(lua_State *L)

  /* HPDF_Page <- hpdf.InsertPage(pdf, page) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Page page = LclHandleGet(L, CnHndPage, 2);
  HPDF_Page result = HPDF_InsertPage(pdf, page);
  LclHandlePush(L, result, CnHndPage);
  return 1;
}

/* * */

static int LclPage_SetWidth(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetWidth(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetWidth(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetHeight(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetHeight(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetHeight(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetSize(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetSize(page, size, direction) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_PageSizes size = luaL_checkoption(L, 2, "HPDF_PAGE_SIZE_LETTER",
    CnPageSizes);
  HPDF_PageDirection direction = luaL_checkoption(L, 3,
    "HPDF_PAGE_PORTRAIT", CnPageDirection);
  HPDF_STATUS result = HPDF_Page_SetSize(page, size, direction);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetRotate(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetRotate(page, angle) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_UINT16 angle = LclCheckU16(L, 2);
  HPDF_STATUS result = HPDF_Page_SetRotate(page, angle);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetFont(lua_State *L)

  /* HPDF_Font <- hpdf.GetFont(pdf, font_name, encoding_name) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * font_name = luaL_checkstring(L, 2);
  const char * encoding_name = luaL_optstring(L, 3, (char *) 0);
  HPDF_Font result = HPDF_GetFont(pdf, font_name, encoding_name);
  LclHandlePush(L, result, CnHndFont);
  return 1;
}

/* * */

static int LclLoadType1FontFromFile(lua_State *L)

  /* string <- hpdf.LoadType1FontFromFile(pdf, afm_file_name, data_file_name) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * afm_file_name = luaL_checkstring(L, 2);
  const char * data_file_name = luaL_checkstring(L, 3);
  const char * result = HPDF_LoadType1FontFromFile(pdf,
    afm_file_name, data_file_name);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclLoadTTFontFromFile(lua_State *L)

  /* string <- hpdf.LoadTTFontFromFile(pdf, file_name, embedding) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * file_name = luaL_checkstring(L, 2);
  HPDF_BOOL embedding = lua_toboolean(L, 3);
  const char * result = HPDF_LoadTTFontFromFile(pdf, file_name, embedding);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclLoadTTFontFromFile2(lua_State *L)

  /* string <- hpdf.LoadTTFontFromFile2(pdf, file_name, index, embedding) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * file_name = luaL_checkstring(L, 2);
  HPDF_UINT index = luaL_checkinteger(L, 3);
  HPDF_BOOL embedding = lua_toboolean(L, 4);
  const char * result = HPDF_LoadTTFontFromFile2(pdf,
    file_name, index, embedding);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclAddPageLabel(lua_State *L)

  /* HPDF_STATUS <- hpdf.AddPageLabel(pdf, page_num, style, first_page, prefix) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT page_num = luaL_checkinteger(L, 2);
  HPDF_PageNumStyle style = luaL_checkoption(L, 3,
    "HPDF_PAGE_NUM_STYLE_DECIMAL", CnPageNumStyle);
  HPDF_UINT first_page = luaL_checkinteger(L, 4);
  const char * prefix = luaL_checkstring(L, 5);
  HPDF_STATUS result = HPDF_AddPageLabel(pdf, page_num,
    style, first_page, prefix);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseJPFonts(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseJPFonts(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseJPFonts(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseKRFonts(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseKRFonts(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseKRFonts(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseCNSFonts(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseCNSFonts(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseCNSFonts(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseCNTFonts(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseCNTFonts(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseCNTFonts(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclCreateOutline(lua_State *L)

  /* HPDF_Outline <- hpdf.CreateOutline(pdf, parent, title, encoder) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Outline parent = LclOptHandleGet(L, CnHndOutline, 2);
  const char * title = luaL_checkstring(L, 3);
  HPDF_Encoder encoder = LclOptHandleGet(L, CnHndEncoder, 4);
  HPDF_Outline result = HPDF_CreateOutline(pdf, parent, title, encoder);
  LclHandlePush(L, result, CnHndOutline);
  return 1;
}

/* * */

static int LclOutline_SetOpened(lua_State *L)

  /* HPDF_STATUS <- hpdf.Outline_SetOpened(outline, opened) */

{
  HPDF_Outline outline = LclHandleGet(L, CnHndOutline, 1);
  HPDF_BOOL opened = lua_toboolean(L, 2);
  HPDF_STATUS result = HPDF_Outline_SetOpened(outline, opened);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclOutline_SetDestination(lua_State *L)

  /* HPDF_STATUS <- hpdf.Outline_SetDestination(outline, dst) */

{
  HPDF_Outline outline = LclHandleGet(L, CnHndOutline, 1);
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 2);
  HPDF_STATUS result = HPDF_Outline_SetDestination(outline, dst);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_CreateDestination(lua_State *L)

  /* HPDF_Destination <- hpdf.Page_CreateDestination(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Destination result = HPDF_Page_CreateDestination(page);
  LclHandlePush(L, result, CnHndDestination);
  return 1;
}

/* * */

static int LclDestination_SetXYZ(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetXYZ(dst, left, top, zoom) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_REAL left = LclCheckReal(L, 2);
  HPDF_REAL top = LclCheckReal(L, 3);
  HPDF_REAL zoom = LclCheckReal(L, 4);
  HPDF_STATUS result = HPDF_Destination_SetXYZ(dst, left, top, zoom);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFit(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFit(dst) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_STATUS result = HPDF_Destination_SetFit(dst);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFitH(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFitH(dst, top) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_REAL top = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Destination_SetFitH(dst, top);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFitV(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFitV(dst, left) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_REAL left = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Destination_SetFitV(dst, left);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFitR(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFitR(dst, left, bottom, right, top) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_REAL left = LclCheckReal(L, 2);
  HPDF_REAL bottom = LclCheckReal(L, 3);
  HPDF_REAL right = LclCheckReal(L, 4);
  HPDF_REAL top = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Destination_SetFitR(dst, left, bottom, right, top);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFitB(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFitB(dst) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_STATUS result = HPDF_Destination_SetFitB(dst);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFitBH(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFitBH(dst, top) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_REAL top = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Destination_SetFitBH(dst, top);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclDestination_SetFitBV(lua_State *L)

  /* HPDF_STATUS <- hpdf.Destination_SetFitBV(dst, left) */

{
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 1);
  HPDF_REAL left = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Destination_SetFitBV(dst, left);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetEncoder(lua_State *L)

  /* HPDF_Encoder <- hpdf.GetEncoder(pdf, encoding_name) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * encoding_name = luaL_checkstring(L, 2);
  HPDF_Encoder result = HPDF_GetEncoder(pdf, encoding_name);
  LclHandlePush(L, result, CnHndEncoder);
  return 1;
}

/* * */

static int LclGetCurrentEncoder(lua_State *L)

  /* HPDF_Encoder <- hpdf.GetCurrentEncoder(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_Encoder result = HPDF_GetCurrentEncoder(pdf);
  LclHandlePush(L, result, CnHndEncoder);
  return 1;
}

/* * */

static int LclSetCurrentEncoder(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetCurrentEncoder(pdf, encoding_name) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * encoding_name = luaL_checkstring(L, 2);
  HPDF_STATUS result = HPDF_SetCurrentEncoder(pdf, encoding_name);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclEncoder_GetType(lua_State *L)

  /* HPDF_EncoderType <- hpdf.Encoder_GetType(encoder) */

{
  HPDF_Encoder encoder = LclHandleGet(L, CnHndEncoder, 1);
  HPDF_EncoderType result = HPDF_Encoder_GetType(encoder);
  lua_pushstring(L, CnEncoderType[result]);
  return 1;
}

/* * */

static int LclEncoder_GetByteType(lua_State *L)

  /* HPDF_ByteType <- hpdf.Encoder_GetByteType(encoder, text, index) */

{
  HPDF_Encoder encoder = LclHandleGet(L, CnHndEncoder, 1);
  const char * text = luaL_checkstring(L, 2);
  HPDF_UINT index = luaL_checkinteger(L, 3);
  HPDF_ByteType result = HPDF_Encoder_GetByteType(encoder, text, index);
  lua_pushstring(L, CnByteType[result]);
  return 1;
}

/* * */

static int LclEncoder_GetUnicode(lua_State *L)

  /* HPDF_UNICODE <- hpdf.Encoder_GetUnicode(encoder, code) */

{
  HPDF_Encoder encoder = LclHandleGet(L, CnHndEncoder, 1);
  HPDF_UINT16 code = LclCheckU16(L, 2);
  HPDF_UNICODE result = HPDF_Encoder_GetUnicode(encoder, code);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclEncoder_GetWritingMode(lua_State *L)

  /* HPDF_WritingMode <- hpdf.Encoder_GetWritingMode(encoder) */

{
  HPDF_Encoder encoder = LclHandleGet(L, CnHndEncoder, 1);
  HPDF_WritingMode result = HPDF_Encoder_GetWritingMode(encoder);
  lua_pushstring(L, CnWritingMode[result]);
  return 1;
}

/* * */

static int LclUseJPEncodings(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseJPEncodings(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseJPEncodings(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseKREncodings(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseKREncodings(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseKREncodings(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseCNSEncodings(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseCNSEncodings(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseCNSEncodings(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseCNTEncodings(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseCNTEncodings(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseCNTEncodings(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclUseUTFEncodings(lua_State *L)

  /* HPDF_STATUS <- hpdf.UseUTFEncodings(pdf) */
 
{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_STATUS result = HPDF_UseUTFEncodings(pdf);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_CreateTextAnnot(lua_State *L)

  /* HPDF_Annotation <- hpdf.Page_CreateTextAnnot(page, rect, text, encoder) */

{
  HPDF_Annotation result;
  HPDF_Rect rect;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  const char * text = luaL_checkstring(L, 3);
  HPDF_Encoder encoder = LclHandleGet(L, CnHndEncoder, 4);
  LclRectGet(L, &rect, 2);
  result = HPDF_Page_CreateTextAnnot(page, rect, text, encoder);
  LclHandlePush(L, result, CnHndAnnotation);
  return 1;
}

/* * */

static int LclPage_CreateLinkAnnot(lua_State *L)

  /* HPDF_Annotation <- hpdf.Page_CreateLinkAnnot(page, rect, dst) */

{
  HPDF_Rect rect;
  HPDF_Annotation result;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Destination dst = LclHandleGet(L, CnHndDestination, 3);
  LclRectGet(L, &rect, 2);
  result = HPDF_Page_CreateLinkAnnot(page, rect, dst);
  LclHandlePush(L, result, CnHndAnnotation);
  return 1;
}

/* * */

static int LclPage_CreateURILinkAnnot(lua_State *L)

  /* HPDF_Annotation <- hpdf.Page_CreateURILinkAnnot(page, rect, uri) */

{
  HPDF_Rect rect;
  HPDF_Annotation result;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  const char * uri = luaL_checkstring(L, 3);
  LclRectGet(L, &rect, 2);
  result = HPDF_Page_CreateURILinkAnnot(page, rect, uri);
  LclHandlePush(L, result, CnHndAnnotation);
  return 1;
}

/* * */

static int LclLinkAnnot_SetHighlightMode(lua_State *L)

  /* HPDF_STATUS <- hpdf.LinkAnnot_SetHighlightMode(annot, mode) */

{
  HPDF_Annotation annot = LclHandleGet(L, CnHndAnnotation, 1);
  HPDF_AnnotHighlightMode mode = luaL_checkoption(L, 2,
    "HPDF_ANNOT_NO_HIGHTLIGHT", CnAnnotHighlightMode);
  HPDF_STATUS result = HPDF_LinkAnnot_SetHighlightMode(annot, mode);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclLinkAnnot_SetBorderStyle(lua_State *L)

  /* HPDF_STATUS <- hpdf.LinkAnnot_SetBorderStyle(annot, width,
    dash_on, dash_off) */

{
  HPDF_Annotation annot = LclHandleGet(L, CnHndAnnotation, 1);
  HPDF_REAL width = LclCheckReal(L, 2);
  HPDF_UINT16 dash_on = LclCheckU16(L, 3);
  HPDF_UINT16 dash_off = LclCheckU16(L, 4);
  HPDF_STATUS result = HPDF_LinkAnnot_SetBorderStyle(annot, width,
    dash_on, dash_off);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclTextAnnot_SetIcon(lua_State *L)

  /* HPDF_STATUS <- hpdf.TextAnnot_SetIcon(annot, icon) */

{
  HPDF_Annotation annot = LclHandleGet(L, CnHndAnnotation, 1);
  HPDF_AnnotIcon icon = luaL_checkoption(L, 2, (char *) 0, CnAnnotIcon);
  HPDF_STATUS result = HPDF_TextAnnot_SetIcon(annot, icon);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclTextAnnot_SetOpened(lua_State *L)

  /* HPDF_STATUS <- hpdf.TextAnnot_SetOpened(annot, opened) */

{
  HPDF_Annotation annot = LclHandleGet(L, CnHndAnnotation, 1);
  HPDF_BOOL opened = lua_toboolean(L, 2);
  HPDF_STATUS result = HPDF_TextAnnot_SetOpened(annot, opened);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclLoadPngImageFromFile(lua_State *L)

  /* HPDF_Image <- hpdf.LoadPngImageFromFile(pdf, filename) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * filename = luaL_checkstring(L, 2);
  HPDF_Image result = HPDF_LoadPngImageFromFile(pdf, filename);
  LclHandlePush(L, result, CnHndImage);
  return 1;
}

/* * */

static int LclLoadPngImageFromFile2(lua_State *L)

  /* HPDF_Image <- hpdf.LoadPngImageFromFile2(pdf, filename) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * filename = luaL_checkstring(L, 2);
  HPDF_Image result = HPDF_LoadPngImageFromFile2(pdf, filename);
  LclHandlePush(L, result, CnHndImage);
  return 1;
}

/* * */

static int LclLoadJpegImageFromFile(lua_State *L)

  /* HPDF_Image <- hpdf.LoadJpegImageFromFile(pdf, filename) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * filename = luaL_checkstring(L, 2);
  HPDF_Image result = HPDF_LoadJpegImageFromFile(pdf, filename);
  LclHandlePush(L, result, CnHndImage);
  return 1;
}

/* * */

static int LclLoadRawImageFromFile(lua_State *L)

  /* HPDF_Image <- hpdf.LoadRawImageFromFile(pdf, filename,
     width, height, color_space) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * filename = luaL_checkstring(L, 2);
  HPDF_UINT width = luaL_checkinteger(L, 3);
  HPDF_UINT height = luaL_checkinteger(L, 4);
  HPDF_ColorSpace color_space = luaL_checkoption(L, 5,
    (char *) 0, CnColorSpace);
  HPDF_Image result = HPDF_LoadRawImageFromFile(pdf, filename,
    width, height, color_space);
  LclHandlePush(L, result, CnHndImage);
  return 1;
}

/* * */

static int LclLoadRawImageFromMem(lua_State *L)

  /* HPDF_Image <- hpdf.LoadRawImageFromMem(pdf, buf, width,
     height, color_space, bits_per_component) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const HPDF_BYTE * buf = (HPDF_BYTE *) luaL_checkstring(L, 2);
  HPDF_UINT width = luaL_checkinteger(L, 3);
  HPDF_UINT height = luaL_checkinteger(L, 4);
  HPDF_ColorSpace color_space = luaL_checkoption(L, 5, (char *) 0,
    CnColorSpace);
  HPDF_UINT bits_per_component = luaL_checkinteger(L, 6);
  HPDF_Image result = HPDF_LoadRawImageFromMem(pdf, buf, width,
    height, color_space, bits_per_component);
  LclHandlePush(L, result, CnHndImage);
  return 1;
}

/* * */

static int LclImage_GetSize(lua_State *L)

  /* HPDF_Point <- hpdf.Image_GetSize(image) */

{
  int RetCount;
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_Point result = HPDF_Image_GetSize(image);
  if ((result.x == 0) && (result.y == 0)) {
    RetCount = 0;
  } else {
    LclPointPush(L, result);
    RetCount = 1;
  }
  return RetCount;
}

/* * */

static int LclImage_GetSize2(lua_State *L)

  /* HPDF_STATUS <- hpdf.Image_GetSize2(image, size)
     API change
     Wd, Ht <- hpdf.Image_GetSize2(image) */

{
  HPDF_Point size;
  int RetCount;
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_STATUS result = HPDF_Image_GetSize2(image, &size);
  if (HPDF_OK == result) {
    lua_pushnumber(L, size.x);
    lua_pushnumber(L, size.y);
    RetCount = 2;
  } else {
   RetCount = 0;
  }
  return RetCount;
}

/* * */

static int LclImage_GetWidth(lua_State *L)

  /* integer <- hpdf.Image_GetWidth(image) */

{
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_UINT result = HPDF_Image_GetWidth(image);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclImage_GetHeight(lua_State *L)

  /* integer <- hpdf.Image_GetHeight(image) */

{
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_UINT result = HPDF_Image_GetHeight(image);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclImage_GetBitsPerComponent(lua_State *L)

  /* integer <- hpdf.Image_GetBitsPerComponent(image) */

{
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_UINT result = HPDF_Image_GetBitsPerComponent(image);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclImage_GetColorSpace(lua_State *L)

  /* string <- hpdf.Image_GetColorSpace(image) */

{
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  const char * result = HPDF_Image_GetColorSpace(image);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclImage_SetColorMask(lua_State *L)

  /* HPDF_STATUS <- hpdf.Image_SetColorMask(image, rmin, rmax,
     gmin, gmax, bmin, bmax) */

{
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_UINT rmin = luaL_checkinteger(L, 2);
  HPDF_UINT rmax = luaL_checkinteger(L, 3);
  HPDF_UINT gmin = luaL_checkinteger(L, 4);
  HPDF_UINT gmax = luaL_checkinteger(L, 5);
  HPDF_UINT bmin = luaL_checkinteger(L, 6);
  HPDF_UINT bmax = luaL_checkinteger(L, 7);
  HPDF_STATUS result = HPDF_Image_SetColorMask(image, rmin, rmax,
    gmin, gmax, bmin, bmax);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclImage_SetMaskImage(lua_State *L)

  /* HPDF_STATUS <- hpdf.Image_SetMaskImage(image, mask_image) */

{
  HPDF_Image image = LclHandleGet(L, CnHndImage, 1);
  HPDF_Image mask_image = LclHandleGet(L, CnHndImage, 2);
  HPDF_STATUS result = HPDF_Image_SetMaskImage(image, mask_image);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetInfoAttr(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetInfoAttr(pdf, type, value) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_InfoType type = luaL_checkoption(L, 2, (char *) 0, CnInfoType);
  const char * value = luaL_checkstring(L, 3);
  HPDF_STATUS result = HPDF_SetInfoAttr(pdf, type, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclGetInfoAttr(lua_State *L)

  /* string <- hpdf.GetInfoAttr(pdf, type) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_InfoType type = luaL_checkoption(L, 2, (char *) 0, CnInfoType);
  const char * result = HPDF_GetInfoAttr(pdf, type);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclSetInfoDateAttr(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetInfoDateAttr(pdf, type, value) */

{
  HPDF_Date value;
  HPDF_STATUS result;
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_InfoType type = luaL_checkoption(L, 2, (char *) 0, CnInfoType);
  LclDateGet(L, &value, 3);
  result = HPDF_SetInfoDateAttr(pdf, type, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetPassword(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetPassword(pdf, owner_passwd, user_passwd) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  const char * owner_passwd = luaL_checkstring(L, 2);
  const char * user_passwd = luaL_checkstring(L, 3);
  HPDF_STATUS result = HPDF_SetPassword(pdf, owner_passwd, user_passwd);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetPermission(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetPermission(pdf, permission) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT permission = luaL_checkinteger(L, 2);
  HPDF_STATUS result = HPDF_SetPermission(pdf, permission);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetEncryptionMode(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetEncryptionMode(pdf, mode, key_len) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_EncryptMode mode = luaL_checkoption(L, 2, (char *) 0, CnEncryptMode);
  HPDF_UINT key_len = luaL_checkinteger(L, 3);
  HPDF_STATUS result = HPDF_SetEncryptionMode(pdf, mode, key_len);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclSetCompressionMode(lua_State *L)

  /* HPDF_STATUS <- hpdf.SetCompressionMode(pdf, mode) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_UINT mode = luaL_checkinteger(L, 2);
  HPDF_STATUS result = HPDF_SetCompressionMode(pdf, mode);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFont_GetFontName(lua_State *L)

  /* string <- hpdf.Font_GetFontName(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  const char * result = HPDF_Font_GetFontName(font);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclFont_GetEncodingName(lua_State *L)

  /* string <- hpdf.Font_GetEncodingName(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  const char * result = HPDF_Font_GetEncodingName(font);
  lua_pushstring(L, result);
  return 1;
}

/* * */

static int LclFont_GetUnicodeWidth(lua_State *L)

  /* integer <- hpdf.Font_GetUnicodeWidth(font, code) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  HPDF_UNICODE code = LclCheckU16(L, 2);
  HPDF_INT result = HPDF_Font_GetUnicodeWidth(font, code);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFont_GetBBox(lua_State *L)

  /* HPDF_Box <- hpdf.Font_GetBBox(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  HPDF_Box result = HPDF_Font_GetBBox(font);
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */
  LclSetNumField(L, result.left, "left");
  LclSetNumField(L, result.bottom, "bottom");
  LclSetNumField(L, result.right, "right");
  LclSetNumField(L, result.top, "top");
  /* Stk: ... Tbl */
  return 1;
}

/* * */

static int LclFont_GetAscent(lua_State *L)

  /* integer <- hpdf.Font_GetAscent(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  HPDF_INT result = HPDF_Font_GetAscent(font);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFont_GetDescent(lua_State *L)

  /* integer <- hpdf.Font_GetDescent(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  HPDF_INT result = HPDF_Font_GetDescent(font);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFont_GetXHeight(lua_State *L)

  /* integer <- hpdf.Font_GetXHeight(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  HPDF_UINT result = HPDF_Font_GetXHeight(font);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFont_GetCapHeight(lua_State *L)

  /* integer <- hpdf.Font_GetCapHeight(font) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  HPDF_UINT result = HPDF_Font_GetCapHeight(font);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclFont_TextWidth(lua_State *L)

  /* HPDF_TextWidth <- hpdf.Font_TextWidth(font, text, len) */

{
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  const HPDF_BYTE * text = (HPDF_BYTE *) luaL_checkstring(L, 2);
  HPDF_UINT len = luaL_checkinteger(L, 3);
  HPDF_TextWidth result = HPDF_Font_TextWidth(font, text, len);
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */

  LclSetIntField(L, result.numchars, "numchars");
  LclSetIntField(L, result.numwords, "numwords");
  LclSetIntField(L, result.width, "width");
  LclSetIntField(L, result.numspace, "numspace");
  /* Stk: ... Tbl */
  return 1;
}

/* * */

static int LclFont_MeasureText(lua_State *L)

  /* integer <- hpdf.Font_MeasureText(font, text, width,
     font_size, char_space, word_space, wordwrap, real_width) */

{
  HPDF_UINT result;
  HPDF_REAL real_width, * real_width_ptr;
  HPDF_Font font = LclHandleGet(L, CnHndFont, 1);
  size_t len_;
  const HPDF_BYTE * text = (HPDF_BYTE *) luaL_checklstring(L, 2, &len_);
  HPDF_UINT len = (HPDF_UINT)len_;
  HPDF_REAL width = LclCheckReal(L, 3);
  HPDF_REAL font_size = LclCheckReal(L, 4);
  HPDF_REAL char_space = LclCheckReal(L, 5);
  HPDF_REAL word_space = LclCheckReal(L, 6);
  HPDF_BOOL wordwrap = lua_toboolean(L, 7);
  if (lua_isnumber(L, 8)) {
    real_width = (HPDF_REAL) lua_tonumber(L, 8);
    real_width_ptr = &real_width;
  } else {
    real_width_ptr = (HPDF_REAL *) 0;
  }
  result = HPDF_Font_MeasureText(font, text, len, width,
    font_size, char_space, word_space, wordwrap, real_width_ptr);
  lua_pushinteger(L, result);
  if (real_width_ptr) {
    lua_pushnumber(L, real_width);
    return 2;
  } else
    return 1;
}

/* * */

static int LclCreateExtGState(lua_State *L)

  /* HPDF_ExtGState <- hpdf.CreateExtGState(pdf) */

{
  HPDF_Doc pdf = LclHandleGet(L, CnHndDoc, 1);
  HPDF_ExtGState result = HPDF_CreateExtGState(pdf);
  LclHandlePush(L, result, CnHndExtGState);
  return 1;
}

/* * */

static int LclExtGState_SetAlphaStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.ExtGState_SetAlphaStroke(ext_gstate, value) */

{
  HPDF_ExtGState ext_gstate = LclHandleGet(L, CnHndExtGState, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_ExtGState_SetAlphaStroke(ext_gstate, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclExtGState_SetAlphaFill(lua_State *L)

  /* HPDF_STATUS <- hpdf.ExtGState_SetAlphaFill(ext_gstate, value) */

{
  HPDF_ExtGState ext_gstate = LclHandleGet(L, CnHndExtGState, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_ExtGState_SetAlphaFill(ext_gstate, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclExtGState_SetBlendMode(lua_State *L)

  /* HPDF_STATUS <- hpdf.ExtGState_SetBlendMode(ext_gstate, mode) */

{
  HPDF_ExtGState ext_gstate = LclHandleGet(L, CnHndExtGState, 1);
  HPDF_BlendMode mode = luaL_checkoption(L, 2, (char *) 0, CnBlendMode);
  HPDF_STATUS result = HPDF_ExtGState_SetBlendMode(ext_gstate, mode);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_TextWidth(lua_State *L)

  /* number <- hpdf.Page_TextWidth(page, text) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  const char * text = luaL_checkstring(L, 2);
  HPDF_REAL result = HPDF_Page_TextWidth(page, text);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_MeasureText(lua_State *L)

  /* integer <- hpdf.Page_MeasureText(page, text, width, wordwrap, real_width) */

{
  HPDF_UINT result;
  HPDF_REAL real_width, * real_width_ptr;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  const char * text = luaL_checkstring(L, 2);
  HPDF_REAL width = LclCheckReal(L, 3);
  HPDF_BOOL wordwrap = lua_toboolean(L, 4);
  if (lua_isnumber(L, 5)) {
    real_width = (HPDF_REAL) lua_tonumber(L, 5);
    real_width_ptr = &real_width;
  } else {
    real_width_ptr = (HPDF_REAL *) 0;
  }
  result = HPDF_Page_MeasureText(page, text, width, wordwrap, real_width_ptr);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_GetWidth(lua_State *L)

  /* number <- hpdf.Page_GetWidth(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetWidth(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetHeight(lua_State *L)

  /* number <- hpdf.Page_GetHeight(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetHeight(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetGMode(lua_State *L)

  /* integer <- hpdf.Page_GetGMode(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_UINT16 result = HPDF_Page_GetGMode(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_GetCurrentPos(lua_State *L)

  /* HPDF_Point <- hpdf.Page_GetCurrentPos(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Point result = HPDF_Page_GetCurrentPos(page);
  LclPointPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetCurrentPos2(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_GetCurrentPos2(page, pos)
     API change
     X, Y <- hpdf.Page_GetCurrentPos2(page) */

{
  int RetCount;
  HPDF_Point pos;

  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_GetCurrentPos2(page, &pos);
  if (HPDF_OK == result) {
    /* Stk: ... */
    lua_pushnumber(L, pos.x);
    /* Stk: ... X */
    lua_pushnumber(L, pos.y);
    /* Stk: ... X Y */
    RetCount = 2;
  } else {
    RetCount = 0;
  }
  return RetCount;
}

/* * */

static int LclPage_GetCurrentTextPos(lua_State *L)

  /* HPDF_Point <- hpdf.Page_GetCurrentTextPos(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Point result = HPDF_Page_GetCurrentTextPos(page);
  LclPointPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetCurrentTextPos2(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_GetCurrentTextPos2(page, pos)
     API change
     X, Y <- hpdf.Page_GetCurrentTextPos2(page) */

{
  HPDF_Point pos;
  int RetCount;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_GetCurrentTextPos2(page, &pos);
  if (HPDF_OK == result) {
    /* Stk: ... */
    lua_pushnumber(L, pos.x);
    /* Stk: ... X */
    lua_pushnumber(L, pos.y);
    /* Stk: ... Y */
    RetCount = 2;
  } else {
    RetCount = 0;
  }
  return RetCount;
}

/* * */

static int LclPage_GetCurrentFont(lua_State *L)

  /* HPDF_Font <- hpdf.Page_GetCurrentFont(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Font result = HPDF_Page_GetCurrentFont(page);
  LclHandlePush(L, result, CnHndFont);
  return 1;
}

/* * */

static int LclPage_GetCurrentFontSize(lua_State *L)

  /* number <- hpdf.Page_GetCurrentFontSize(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetCurrentFontSize(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetTransMatrix(lua_State *L)

  /* HPDF_TransMatrix <- hpdf.Page_GetTransMatrix(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_TransMatrix result = HPDF_Page_GetTransMatrix(page);
  LclTransMatrixPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetLineWidth(lua_State *L)

  /* number <- hpdf.Page_GetLineWidth(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetLineWidth(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetLineCap(lua_State *L)

  /* HPDF_LineCap <- hpdf.Page_GetLineCap(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_LineCap result = HPDF_Page_GetLineCap(page);
  lua_pushstring(L, CnLineCap[result]);
  return 1;
}

/* * */

static int LclPage_GetLineJoin(lua_State *L)

  /* HPDF_LineJoin <- hpdf.Page_GetLineJoin(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_LineJoin result = HPDF_Page_GetLineJoin(page);
  lua_pushstring(L, CnLineJoin[result]);
  return 1;
}

/* * */

static int LclPage_GetMiterLimit(lua_State *L)

  /* number <- hpdf.Page_GetMiterLimit(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetMiterLimit(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetDash(lua_State *L)

  /* HPDF_DashMode <- hpdf.Page_GetDash(page) */

{
  int J;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_DashMode result = HPDF_Page_GetDash(page);
  /* Stk: ... */
  lua_newtable(L);
  /* Stk: ... Tbl */
  lua_pushstring(L, "ptn");
  /* Stk: ... Tbl "ptn" */
  lua_newtable(L);
  /* Stk: ... Tbl "ptn" Tbl */
  for (J = 0; J < 8; J++) {
    lua_pushnumber(L, result.ptn[J]);
    /* Stk: ... Tbl "ptn" Tbl Num */
    lua_rawseti(L, -2, J + 1);
    /* Stk: ... Tbl "ptn" Tbl */
  }
  /* Stk: ... Tbl "ptn" Tbl */
  lua_rawset(L, -3);
  /* Stk: ... Tbl */
  LclSetIntField(L, result.num_ptn, "num_ptn");
  LclSetIntField(L, result.phase, "phase");
  /* Stk: ... Tbl */
  return 1;
}

/* * */

static int LclPage_GetFlat(lua_State *L)

  /* number <- hpdf.Page_GetFlat(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetFlat(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetCharSpace(lua_State *L)

  /* number <- hpdf.Page_GetCharSpace(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetCharSpace(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetWordSpace(lua_State *L)

  /* number <- hpdf.Page_GetWordSpace(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetWordSpace(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetHorizontalScalling(lua_State *L)

  /* number <- hpdf.Page_GetHorizontalScalling(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetHorizontalScalling(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetTextLeading(lua_State *L)

  /* number <- hpdf.Page_GetTextLeading(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetTextLeading(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetTextRenderingMode(lua_State *L)

  /* HPDF_TextRenderingMode <- hpdf.Page_GetTextRenderingMode(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_TextRenderingMode result = HPDF_Page_GetTextRenderingMode(page);
  lua_pushstring(L, CnTextRenderingMode[result]);
  return 1;
}

/* * */

static int LclPage_GetTextRaise(lua_State *L)

  /* number <- hpdf.Page_GetTextRaise(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetTextRaise(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetTextRise(lua_State *L)

  /* number <- hpdf.Page_GetTextRise(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetTextRise(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetRGBFill(lua_State *L)

  /* HPDF_RGBColor <- hpdf.Page_GetRGBFill(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_RGBColor result = HPDF_Page_GetRGBFill(page);
  LclRgbPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetRGBStroke(lua_State *L)

  /* HPDF_RGBColor <- hpdf.Page_GetRGBStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_RGBColor result = HPDF_Page_GetRGBStroke(page);
  LclRgbPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetCMYKFill(lua_State *L)

  /* HPDF_CMYKColor <- hpdf.Page_GetCMYKFill(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_CMYKColor result = HPDF_Page_GetCMYKFill(page);
  LclCmykPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetCMYKStroke(lua_State *L)

  /* HPDF_CMYKColor <- hpdf.Page_GetCMYKStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_CMYKColor result = HPDF_Page_GetCMYKStroke(page);
  LclCmykPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetGrayFill(lua_State *L)

  /* number <- hpdf.Page_GetGrayFill(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetGrayFill(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetGrayStroke(lua_State *L)

  /* number <- hpdf.Page_GetGrayStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL result = HPDF_Page_GetGrayStroke(page);
  lua_pushnumber(L, result);
  return 1;
}

/* * */

static int LclPage_GetStrokingColorSpace(lua_State *L)

  /* HPDF_ColorSpace <- hpdf.Page_GetStrokingColorSpace(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_ColorSpace result = HPDF_Page_GetStrokingColorSpace(page);
  lua_pushstring(L, CnColorSpace[result]);
  return 1;
}

/* * */

static int LclPage_GetFillingColorSpace(lua_State *L)

  /* HPDF_ColorSpace <- hpdf.Page_GetFillingColorSpace(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_ColorSpace result = HPDF_Page_GetFillingColorSpace(page);
  lua_pushstring(L, CnColorSpace[result]);
  return 1;
}

/* * */

static int LclPage_GetTextMatrix(lua_State *L)

  /* HPDF_TransMatrix <- hpdf.Page_GetTextMatrix(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_TransMatrix result = HPDF_Page_GetTextMatrix(page);
  LclTransMatrixPush(L, result);
  return 1;
}

/* * */

static int LclPage_GetGStateDepth(lua_State *L)

  /* integer <- hpdf.Page_GetGStateDepth(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_UINT result = HPDF_Page_GetGStateDepth(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetLineWidth(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetLineWidth(page, line_width) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL line_width = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetLineWidth(page, line_width);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetLineCap(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetLineCap(page, line_cap) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_LineCap line_cap = luaL_checkoption(L, 2, (char *) 0, CnLineCap);
  HPDF_STATUS result = HPDF_Page_SetLineCap(page, line_cap);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetLineJoin(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetLineJoin(page, line_join) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_LineJoin line_join = luaL_checkoption(L, 2, (char *) 0, CnLineJoin);
  HPDF_STATUS result = HPDF_Page_SetLineJoin(page, line_join);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetMiterLimit(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetMiterLimit(page, miter_limit) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL miter_limit = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetMiterLimit(page, miter_limit);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetDash(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetDash(page, dash_ptn, num_param, phase) */

{
  int Tp;
  HPDF_DashMode mode;
  HPDF_STATUS result;
  HPDF_Page page;

  page = LclHandleGet(L, CnHndPage, 1);
  Tp = lua_type(L, 2);

  mode.num_ptn = 0;
  mode.phase = 0;

  if (!(LUA_TNIL == Tp) && !(LUA_TNONE == Tp)) {
    luaL_argcheck(L, lua_istable(L, 2), 2, "expecting dash mode table");
    mode.num_ptn = lua_rawlen(L, 2);
    if (mode.num_ptn <= 8) {
      mode.phase = luaL_checkinteger(L, 3);
      int J;
      for (J = 0; J < mode.num_ptn; J++) {
        int Dash;
        /* Stk: ... */
        lua_rawgeti(L, 2, J + 1);
        /* Stk: ... ptn[J] */
        Dash = lua_tointeger(L, -1);
        mode.ptn[J] = Dash ? Dash : 1;
        lua_pop(L, 1);
        /* Stk: ... */
      }
    }
    else {
      lua_pushstring(L, "dash table must have 0 to 8 elements");
      lua_error(L);
    }
  }
  result = HPDF_Page_SetDash(page, mode.ptn, mode.num_ptn, mode.phase);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetFlat(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetFlat(page, flatness) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL flatness = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetFlat(page, flatness);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetExtGState(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetExtGState(page, ext_gstate) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_ExtGState ext_gstate = LclHandleGet(L, CnHndExtGState, 2);
  HPDF_STATUS result = HPDF_Page_SetExtGState(page, ext_gstate);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_GSave(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_GSave(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_GSave(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_GRestore(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_GRestore(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_GRestore(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Concat(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Concat(page, a, b, c, d, x, y) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL a = LclCheckReal(L, 2);
  HPDF_REAL b = LclCheckReal(L, 3);
  HPDF_REAL c = LclCheckReal(L, 4);
  HPDF_REAL d = LclCheckReal(L, 5);
  HPDF_REAL x = LclCheckReal(L, 6);
  HPDF_REAL y = LclCheckReal(L, 7);
  HPDF_STATUS result = HPDF_Page_Concat(page, a, b, c, d, x, y);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_MoveTo(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_MoveTo(page, x, y) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_STATUS result = HPDF_Page_MoveTo(page, x, y);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_LineTo(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_LineTo(page, x, y) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_STATUS result = HPDF_Page_LineTo(page, x, y);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_CurveTo(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_CurveTo(page, x1, y1, x2, y2, x3, y3) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x1 = LclCheckReal(L, 2);
  HPDF_REAL y1 = LclCheckReal(L, 3);
  HPDF_REAL x2 = LclCheckReal(L, 4);
  HPDF_REAL y2 = LclCheckReal(L, 5);
  HPDF_REAL x3 = LclCheckReal(L, 6);
  HPDF_REAL y3 = LclCheckReal(L, 7);
  HPDF_STATUS result = HPDF_Page_CurveTo(page, x1, y1, x2, y2, x3, y3);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_CurveTo2(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_CurveTo2(page, x2, y2, x3, y3) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x2 = LclCheckReal(L, 2);
  HPDF_REAL y2 = LclCheckReal(L, 3);
  HPDF_REAL x3 = LclCheckReal(L, 4);
  HPDF_REAL y3 = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Page_CurveTo2(page, x2, y2, x3, y3);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_CurveTo3(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_CurveTo3(page, x1, y1, x3, y3) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x1 = LclCheckReal(L, 2);
  HPDF_REAL y1 = LclCheckReal(L, 3);
  HPDF_REAL x3 = LclCheckReal(L, 4);
  HPDF_REAL y3 = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Page_CurveTo3(page, x1, y1, x3, y3);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ClosePath(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ClosePath(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_ClosePath(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Rectangle(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Rectangle(page, x, y, width, height) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_REAL width = LclCheckReal(L, 4);
  HPDF_REAL height = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Page_Rectangle(page, x, y, width, height);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Stroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Stroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_Stroke(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ClosePathStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ClosePathStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_ClosePathStroke(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Fill(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Fill(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_Fill(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Eofill(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Eofill(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_Eofill(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_FillStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_FillStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_FillStroke(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_EofillStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_EofillStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_EofillStroke(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ClosePathFillStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ClosePathFillStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_ClosePathFillStroke(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ClosePathEofillStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ClosePathEofillStroke(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_ClosePathEofillStroke(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_EndPath(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_EndPath(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_EndPath(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Clip(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Clip(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_Clip(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Eoclip(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Eoclip(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_Eoclip(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_BeginText(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_BeginText(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_BeginText(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_EndText(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_EndText(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_EndText(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetCharSpace(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetCharSpace(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetCharSpace(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetWordSpace(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetWordSpace(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetWordSpace(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetHorizontalScalling(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetHorizontalScalling(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetHorizontalScalling(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetTextLeading(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetTextLeading(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetTextLeading(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetFontAndSize(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetFontAndSize(page, font, size) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Font font = LclHandleGet(L, CnHndFont, 2);
  HPDF_REAL size = LclCheckReal(L, 3);
  HPDF_STATUS result = HPDF_Page_SetFontAndSize(page, font, size);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetTextRenderingMode(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetTextRenderingMode(page, mode) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_TextRenderingMode mode = luaL_checkoption(L, 2,
    (char *) 0, CnTextRenderingMode);
  HPDF_STATUS result = HPDF_Page_SetTextRenderingMode(page, mode);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetTextRise(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetTextRise(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetTextRise(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetTextRaise(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetTextRaise(page, value) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL value = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetTextRaise(page, value);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_MoveTextPos(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_MoveTextPos(page, x, y) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_STATUS result = HPDF_Page_MoveTextPos(page, x, y);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_MoveTextPos2(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_MoveTextPos2(page, x, y) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_STATUS result = HPDF_Page_MoveTextPos2(page, x, y);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetTextMatrix(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetTextMatrix(page, a, b, c, d, x, y) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL a = LclCheckReal(L, 2);
  HPDF_REAL b = LclCheckReal(L, 3);
  HPDF_REAL c = LclCheckReal(L, 4);
  HPDF_REAL d = LclCheckReal(L, 5);
  HPDF_REAL x = LclCheckReal(L, 6);
  HPDF_REAL y = LclCheckReal(L, 7);
  HPDF_STATUS result = HPDF_Page_SetTextMatrix(page, a, b, c, d, x, y);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_MoveToNextLine(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_MoveToNextLine(page) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_STATUS result = HPDF_Page_MoveToNextLine(page);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ShowText(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ShowText(page, text) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  const char * text = luaL_checkstring(L, 2);
  HPDF_STATUS result = HPDF_Page_ShowText(page, text);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ShowTextNextLine(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ShowTextNextLine(page, text) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  const char * text = luaL_checkstring(L, 2);
  HPDF_STATUS result = HPDF_Page_ShowTextNextLine(page, text);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ShowTextNextLineEx(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ShowTextNextLineEx(page, word_space,
     char_space, text) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL word_space = LclCheckReal(L, 2);
  HPDF_REAL char_space = LclCheckReal(L, 3);
  const char * text = luaL_checkstring(L, 4);
  HPDF_STATUS result = HPDF_Page_ShowTextNextLineEx(page, word_space,
    char_space, text);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetGrayFill(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetGrayFill(page, gray) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL gray = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetGrayFill(page, gray);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetGrayStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetGrayStroke(page, gray) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL gray = LclCheckReal(L, 2);
  HPDF_STATUS result = HPDF_Page_SetGrayStroke(page, gray);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetRGBFill(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetRGBFill(page, r, g, b) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL r = LclCheckReal(L, 2);
  HPDF_REAL g = LclCheckReal(L, 3);
  HPDF_REAL b = LclCheckReal(L, 4);
  HPDF_STATUS result = HPDF_Page_SetRGBFill(page, r, g, b);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetRGBStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetRGBStroke(page, r, g, b) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL r = LclCheckReal(L, 2);
  HPDF_REAL g = LclCheckReal(L, 3);
  HPDF_REAL b = LclCheckReal(L, 4);
  HPDF_STATUS result = HPDF_Page_SetRGBStroke(page, r, g, b);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetCMYKFill(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetCMYKFill(page, c, m, y, k) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL c = LclCheckReal(L, 2);
  HPDF_REAL m = LclCheckReal(L, 3);
  HPDF_REAL y = LclCheckReal(L, 4);
  HPDF_REAL k = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Page_SetCMYKFill(page, c, m, y, k);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_SetCMYKStroke(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetCMYKStroke(page, c, m, y, k) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL c = LclCheckReal(L, 2);
  HPDF_REAL m = LclCheckReal(L, 3);
  HPDF_REAL y = LclCheckReal(L, 4);
  HPDF_REAL k = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Page_SetCMYKStroke(page, c, m, y, k);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_ExecuteXObject(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_ExecuteXObject(page, obj) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_XObject obj = LclHandleGet(L, CnHndXObject, 2);
  HPDF_STATUS result = HPDF_Page_ExecuteXObject(page, obj);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_DrawImage(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_DrawImage(page, image, x, y, width, height) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_Image image = LclHandleGet(L, CnHndImage, 2);
  HPDF_REAL x = LclCheckReal(L, 3);
  HPDF_REAL y = LclCheckReal(L, 4);
  HPDF_REAL width = LclCheckReal(L, 5);
  HPDF_REAL height = LclCheckReal(L, 6);
  HPDF_STATUS result = HPDF_Page_DrawImage(page, image, x, y, width, height);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Circle(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Circle(page, x, y, ray) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_REAL ray = LclCheckReal(L, 4);
  HPDF_STATUS result = HPDF_Page_Circle(page, x, y, ray);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Ellipse(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Ellipse(page, x, y, xray, yray) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_REAL xray = LclCheckReal(L, 4);
  HPDF_REAL yray = LclCheckReal(L, 5);
  HPDF_STATUS result = HPDF_Page_Ellipse(page, x, y, xray, yray);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_Arc(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_Arc(page, x, y, ray, ang1, ang2) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL x = LclCheckReal(L, 2);
  HPDF_REAL y = LclCheckReal(L, 3);
  HPDF_REAL ray = LclCheckReal(L, 4);
  HPDF_REAL ang1 = LclCheckReal(L, 5);
  HPDF_REAL ang2 = LclCheckReal(L, 6);
  HPDF_STATUS result = HPDF_Page_Arc(page, x, y, ray, ang1, ang2);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_TextOut(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_TextOut(page, xpos, ypos, text) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL xpos = LclCheckReal(L, 2);
  HPDF_REAL ypos = LclCheckReal(L, 3);
  const char * text = luaL_checkstring(L, 4);
  HPDF_STATUS result = HPDF_Page_TextOut(page, xpos, ypos, text);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static int LclPage_TextRect(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_TextRect(page, left, top,
     right, bottom, text, align) */

{
  HPDF_UINT len;
  HPDF_STATUS result;
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_REAL left = LclCheckReal(L, 2);
  HPDF_REAL top = LclCheckReal(L, 3);
  HPDF_REAL right = LclCheckReal(L, 4);
  HPDF_REAL bottom = LclCheckReal(L, 5);
  const char * text = luaL_checkstring(L, 6);
  HPDF_TextAlignment align = luaL_checkoption(L, 7,
    (char *) 0, CnTextAlignment);
  len = 0;
  result = HPDF_Page_TextRect(page, left, top, right, bottom, text,
    align, &len);
  lua_pushinteger(L, result);
  lua_pushinteger(L, len);
  return 2;
}

/* * */

static int LclPage_SetSlideShow(lua_State *L)

  /* HPDF_STATUS <- hpdf.Page_SetSlideShow(page, type, disp_time, trans_time) */

{
  HPDF_Page page = LclHandleGet(L, CnHndPage, 1);
  HPDF_TransitionStyle type = luaL_checkoption(L, 2,
    (char *) 0, CnTransitionStyle);
  HPDF_REAL disp_time = LclCheckReal(L, 3);
  HPDF_REAL trans_time = LclCheckReal(L, 4);
  HPDF_STATUS result = HPDF_Page_SetSlideShow(page, type,
    disp_time, trans_time);
  lua_pushinteger(L, result);
  return 1;
}

/* * */

static void LclConstRegister(
  lua_State *L)

{
  typedef struct {
    const char *Str;
    lua_Integer Val;
  } KeyIntType, * KeyIntPtrType;

  static KeyIntType IntList[] = {
    {"OK", HPDF_OK},
    {"NOERROR", HPDF_NOERROR},
    /* buffer size which is required when we convert to character string. */
    {"TMP_BUF_SIZ", HPDF_TMP_BUF_SIZ},
    {"SHORT_BUF_SIZ", HPDF_SHORT_BUF_SIZ},
    {"REAL_LEN", HPDF_REAL_LEN},
    {"INT_LEN", HPDF_INT_LEN},
    {"TEXT_DEFAULT_LEN", HPDF_TEXT_DEFAULT_LEN},
    {"UNICODE_HEADER_LEN", HPDF_UNICODE_HEADER_LEN},
    {"DATE_TIME_STR_LEN", HPDF_DATE_TIME_STR_LEN},
    /* length of each item defined in PDF */
    {"BYTE_OFFSET_LEN", HPDF_BYTE_OFFSET_LEN},
    {"OBJ_ID_LEN", HPDF_OBJ_ID_LEN},
    {"GEN_NO_LEN", HPDF_GEN_NO_LEN},
    /* default value of Graphic State */
    {"DEF_PAGE_LAYOUT", HPDF_PAGE_LAYOUT_SINGLE},
    {"DEF_PAGE_MODE", HPDF_PAGE_MODE_USE_NONE},
    {"DEF_WORDSPACE", HPDF_DEF_WORDSPACE},
    {"DEF_CHARSPACE", HPDF_DEF_CHARSPACE},
    {"DEF_FONTSIZE", HPDF_DEF_FONTSIZE},
    {"DEF_HSCALING", HPDF_DEF_HSCALING},
    {"DEF_LEADING", HPDF_DEF_LEADING},
    {"DEF_RENDERING_MODE", HPDF_FILL},
    {"DEF_RISE", HPDF_DEF_RISE},
    {"DEF_RAISE", HPDF_DEF_RISE},
    {"DEF_LINEWIDTH", HPDF_DEF_LINEWIDTH},
    {"DEF_LINECAP", HPDF_BUTT_END},
    {"DEF_LINEJOIN", HPDF_MITER_JOIN},
    {"DEF_MITERLIMIT", HPDF_DEF_MITERLIMIT},
    {"DEF_FLATNESS", HPDF_DEF_FLATNESS},
    {"DEF_PAGE_NUM", HPDF_DEF_PAGE_NUM},
    {"BS_DEF_WIDTH", HPDF_BS_DEF_WIDTH},
    /* compression mode */
    {"COMP_NONE", HPDF_COMP_NONE},
    {"COMP_TEXT", HPDF_COMP_TEXT},
    {"COMP_IMAGE", HPDF_COMP_IMAGE},
    {"COMP_METADATA", HPDF_COMP_METADATA},
    {"COMP_ALL", HPDF_COMP_ALL},
    {"COMP_MASK", HPDF_COMP_MASK},
    /* permission flags (only Revision 2 is supported) */
    {"ENABLE_READ", HPDF_ENABLE_READ},
    {"ENABLE_PRINT", HPDF_ENABLE_PRINT},
    {"ENABLE_EDIT_ALL", HPDF_ENABLE_EDIT_ALL},
    {"ENABLE_COPY", HPDF_ENABLE_COPY},
    {"ENABLE_EDIT", HPDF_ENABLE_EDIT},
    /* viewer preferences definitions */
    {"HIDE_TOOLBAR", HPDF_HIDE_TOOLBAR},
    {"HIDE_MENUBAR", HPDF_HIDE_MENUBAR},
    {"HIDE_WINDOW_UI", HPDF_HIDE_WINDOW_UI},
    {"FIT_WINDOW", HPDF_FIT_WINDOW},
    {"CENTER_WINDOW", HPDF_CENTER_WINDOW},
    /* limitation of object implementation (PDF1.4) */
    {"LIMIT_MAX_INT", HPDF_LIMIT_MAX_INT},
    {"LIMIT_MIN_INT", HPDF_LIMIT_MIN_INT},
    {"LIMIT_MAX_STRING_LEN", HPDF_LIMIT_MAX_STRING_LEN},
    {"LIMIT_MAX_NAME_LEN", HPDF_LIMIT_MAX_NAME_LEN},
    {"LIMIT_MAX_ARRAY", HPDF_LIMIT_MAX_ARRAY},
    {"LIMIT_MAX_DICT_ELEMENT", HPDF_LIMIT_MAX_DICT_ELEMENT},
    {"LIMIT_MAX_XREF_ELEMENT", HPDF_LIMIT_MAX_XREF_ELEMENT},
    {"LIMIT_MAX_GSTATE", HPDF_LIMIT_MAX_GSTATE},
    {"LIMIT_MAX_DEVICE_N", HPDF_LIMIT_MAX_DEVICE_N},
    {"LIMIT_MAX_DEVICE_N_V15", HPDF_LIMIT_MAX_DEVICE_N_V15},
    {"LIMIT_MAX_CID", HPDF_LIMIT_MAX_CID},
    {"MAX_GENERATION_NUM", HPDF_MAX_GENERATION_NUM},
    {"MIN_PAGE_HEIGHT", HPDF_MIN_PAGE_HEIGHT},
    {"MIN_PAGE_WIDTH", HPDF_MIN_PAGE_WIDTH},
    {"MAX_PAGE_HEIGHT", HPDF_MAX_PAGE_HEIGHT},
    {"MAX_PAGE_WIDTH", HPDF_MAX_PAGE_WIDTH},
    {"MIN_MAGNIFICATION_FACTOR", HPDF_MIN_MAGNIFICATION_FACTOR},
    {"MAX_MAGNIFICATION_FACTOR", HPDF_MAX_MAGNIFICATION_FACTOR},
    /* limitation of various properties */
    {"MIN_PAGE_SIZE", HPDF_MIN_PAGE_SIZE},
    {"MAX_PAGE_SIZE", HPDF_MAX_PAGE_SIZE},
    {"MIN_HORIZONTALSCALING", HPDF_MIN_HORIZONTALSCALING},
    {"MAX_HORIZONTALSCALING", HPDF_MAX_HORIZONTALSCALING},
    {"MIN_WORDSPACE", HPDF_MIN_WORDSPACE},
    {"MAX_WORDSPACE", HPDF_MAX_WORDSPACE},
    {"MIN_CHARSPACE", HPDF_MIN_CHARSPACE},
    {"MAX_CHARSPACE", HPDF_MAX_CHARSPACE},
    {"MAX_FONTSIZE", HPDF_MAX_FONTSIZE},
    {"MAX_ZOOMSIZE", HPDF_MAX_ZOOMSIZE},
    {"MAX_LEADING", HPDF_MAX_LEADING},
    {"MAX_LINEWIDTH", HPDF_MAX_LINEWIDTH},
    {"MAX_DASH_PATTERN", HPDF_MAX_DASH_PATTERN},
    {"MAX_JWW_NUM", HPDF_MAX_JWW_NUM},
    /* Graphics mode */
    {"GMODE_PAGE_DESCRIPTION", HPDF_GMODE_PAGE_DESCRIPTION},
    {"GMODE_PATH_OBJECT", HPDF_GMODE_PATH_OBJECT},
    {"GMODE_TEXT_OBJECT", HPDF_GMODE_TEXT_OBJECT},
    {"GMODE_CLIPPING_PATH", HPDF_GMODE_CLIPPING_PATH},
    {"GMODE_SHADING", HPDF_GMODE_SHADING},
    {"GMODE_INLINE_IMAGE", HPDF_GMODE_INLINE_IMAGE},
    {"GMODE_EXTERNAL_OBJECT", HPDF_GMODE_EXTERNAL_OBJECT},
    {(char *) 0, 0}
  };

  KeyIntPtrType KeyIntPtr;

  for (KeyIntPtr = IntList; KeyIntPtr->Str; KeyIntPtr++) {
    /* Stk: ... Namespace */
    lua_pushinteger(L, KeyIntPtr->Val);
    /* Stk: ... Namespace Val */
    lua_setfield(L, -2, KeyIntPtr->Str);
    /* Stk: ... Namespace */
  }

  lua_pushnumber(L, HPDF_LIMIT_MIN_REAL);
  lua_setfield(L, -2, "HPDF_LIMIT_MIN_REAL");

  lua_pushnumber(L, HPDF_LIMIT_MAX_REAL);
  lua_setfield(L, -2, "HPDF_LIMIT_MAX_REAL");

  lua_pushnumber(L, HPDF_DEF_PAGE_WIDTH);
  lua_setfield(L, -2, "DEF_PAGE_WIDTH");

  lua_pushnumber(L, HPDF_DEF_PAGE_HEIGHT);
  lua_setfield(L, -2, "DEF_PAGE_HEIGHT");

  lua_pushstring(L, HPDF_DEF_FONT);
  lua_setfield(L, -2, "DEF_FONT");

  lua_pushstring(L, HPDF_VERSION_TEXT);
  lua_setfield(L, -2, "VERSION_TEXT");

  lua_pushboolean(L, 1);
  lua_setfield(L, -2, "TRUE");

  lua_pushboolean(L, 0);
  lua_setfield(L, -