Remove the remainder of the skia source code from the Chromium repo....

skia/images/fpdfemb.h

-// FPDFEMB.H - Header file for FPDFEMB SDK
-// Copyright (c) 2007-2008 Foxit Software Company, All Right Reserved.
-
-// Date: 2008-04-07
-
-// Embedded platforms have many different aspects from desktop platforms,
-// among them, the followings are most important for PDF processing:
-//
-// 1.   Embedded platforms have only limited memory, and there is no virtual memory.
-//              PDF is a very complicated format, processing PDF may consumes quite
-//              large amount of memory, even for some smaller PDFs. And, in order to 
-//              increase the performance of PDF parsing and rendering, cache memory
-//              is often used. For some big PDFs with many pages, the cache may grow
-//              while user browing through pages, eventually, for some PDFs, the memory
-//              on the device may run out.
-//
-//              FPDFEMB SDK allows graceful out-of-memory (OOM) handling by returning 
-//              OOM error code for all functions that may involve memory allocation. 
-//              When an application detects OOM situation, it can do one of the followings:
-//
-//                      a) Give user some prompt and quit the application or close the document;
-//                      b) Or better, try to recover from the error. Sometimes OOM can be caused
-//                              by ever-growing cache. For example, when user browses a 1000-page 
-//                              document, let's say OOM happen at page #300. In this case, the
-//                              application might close the whole document (cache will be gone with
-//                              it), reopen the document, then go directly to page #300. It's likely
-//                              the process will go through this time. This is called "OOM recovery".
-//                              If OOM happens again during a recovery, then, it's not possible to finish
-//                              the process, the application must quit of close the document.
-//
-// 2.   Embedded platforms has only limited computing power. Since some PDFs
-//              can be very complicated and require a lot of processing to be displayed,
-//              it may take a lot of time for the process to finish. This may cause
-//              some problem with user experience, especially for devices like mobile
-//              phones, when an application may need to be put on hold any time. Therefore, 
-//              it's important to break lengthy process into small steps which can be 
-//              stopped or resumed at any time. We call this kind of process as 
-//              "progressive process".
-//
-//              FPDFEMB SDK allows progressive page parsing and rendering, the most time-
-//              consuming part of PDF processing.
-//
-// IMPORTANT:
-//              FPDFEMB module is not intended to run in multi-threaded environment.
-
-// Components inside FPDFEMB:
-//              * Library Memory Management
-//              * Document Operations
-//              * Page Basic Operations
-//              * Page Parsing
-//              * Page Rendering
-//              * Coordination Conversion
-//              * Text Search
-//              * Text Information
-//              * Device Independant Bitmap
-//              * Custom Font Handler and CJK Support
-//              * Bookmark Information
-//              * Hyperlink Information
-//              * Graphic Output
-
-#ifndef _FPDFEMB_H_
-#define _FPDFEMB_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Standard return type for many FPDFEMB functions: FPDFERR_SUCCESS for success, otherwise error code
-typedef int FPDFEMB_RESULT;
-
-// Standard boolean type: 0 for false, non-zero for true
-typedef int FPDFEMB_BOOL;
-
-// Unicode character. FPDFEMB uses UTF16LE format for unicode string.
-typedef unsigned short FPDFEMB_WCHAR;
-
-// Error codes
-#define FPDFERR_SUCCESS         0
-#define FPDFERR_MEMORY          1               // Out of memory
-#define FPDFERR_ERROR           2               // Error of any kind, without specific reason
-#define FPDFERR_PASSWORD        3               // Incorrect password
-#define FPDFERR_FORMAT          4               // Not PDF format
-#define FPDFERR_FILE            5               // File access error
-#define FPDFERR_PARAM           6               // Parameter error
-#define FPDFERR_STATUS          7               // Not in correct status
-#define FPDFERR_TOBECONTINUED   8       // To be continued
-#define FPDFERR_NOTFOUND        9               // Search result not found
-
-/********************************************************************************************
-****
-****            Library Memory Management
-****
-********************************************************************************************/
-
-// Structure: FPDFEMB_MEMMGR
-//                      Including interfaces implemented by host application, providing memory allocation
-//                      facilities. All members are required.
-//                      A memory manager structure is required to be valid during the entire period
-//                      when an application using FPDFEMB module.
-//
-//                      IMPORTANT NOTE: using of this interface is strongly not recommended, because
-//                      FPDFEMB now internally use FPDFEMB_MEMMGR_EX interface, which allows more
-//                      advanced memory management. This interface is retained for backward compatibility
-//                      only, and maybe discontinued in the future.
-//
-struct FPDFEMB_MEMMGR {
-        // Interface: Alloc
-        //              Allocate a memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              size            -       Number of bytes for the memory block.
-        // Return Value:
-        //              The pointer to allocated memory block. NULL if no memory available.
-        // Comments:
-        //              In order to handle OOM situation, application can use longjmp() inside 
-        //              implementation of this function. If underlying memory manager fails to 
-        //              allocate enough memory, then application can use longjmp() to jump to
-        //              OOM handling codes.
-        //
-        void*   (*Alloc)(struct FPDFEMB_MEMMGR* pMgr, unsigned int size);
-
-        // Interface: AllocNL
-        //              Allocate a memory block, without leaving
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              size            -       Number of bytes for the memory block.
-        // Return Value:
-        //              The pointer to allocated memory block. NULL if no memory available.
-        // Comments:
-        //              Implementation MUST return NULL if no memory available, no exception
-        //              or longjmp() can be used.
-        //
-        void*   (*AllocNL)(struct FPDFEMB_MEMMGR* pMgr, unsigned int size);
-
-        // Interfce: Realloc
-        //              Reallocate a memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              pointer         -       An existing memory block, or NULL.
-        //              new_size        -       New size (number of bytes) of the memory block. Can be zero.
-        // Return value:
-        //              The pointer of reallocated memory block, it could be a new block, or just
-        //              the previous block with size modified.
-        // Comments:
-        //              If an existing memory block specified, the data in the memory block will
-        //              be copied to the new block, if reallocated.
-        //
-        //              In order to handle OOM situation, application can use longjmp() inside 
-        //              implementation of this function. If underlying memory manager fails to 
-        //              allocate enough memory, then application can use longjmp() to jump to
-        //              OOM handling codes.
-        //
-        void*   (*Realloc)(struct FPDFEMB_MEMMGR* pMgr, void* pointer, unsigned int new_size);
-
-        // Interface: Free
-        //              Free a memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              pointer         -       An existing memory block.
-        // Return Value:
-        //              None.
-        //
-        void    (*Free)(struct FPDFEMB_MEMMGR* pMgr, void* pointer);
-};
-
-// Function: FPDFEMB_Init
-//                      Initialize the FPDFEMB module
-// Parameters:
-//                      mem_mgr         -       Pointer to memory manager structure
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      This function will allocate necessary internal data structure for
-//                      the whole module to operate.
-FPDFEMB_RESULT FPDFEMB_Init(FPDFEMB_MEMMGR* mem_mgr);
-
-typedef void (*FPDFEMB_FIXED_OOM_HANDLER)(void* memory, int size);
-
-// Function: FPDFEMB_InitFixedMemory
-//                      Initialize the FPDFEMB module, providing a fixed memory heap
-// Parameters:
-//                      memory          -       Pointer to a pre-allocated memory block
-//                      size            -       Number of bytes in the memory block
-//                      oom_handler     -       Pointer to a function which will be called when OOM happens. Can be
-//                                                      NULL if application doesn't want to be notified om OOM.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      In many embedded system, memory usage are predetermined. The application
-//                      is assigned with fixed size of available memory, then it can pre-allocate
-//                      a memory block with maximum size and pass to this function to initialize
-//                      FPDFEMB module. In this case, FPDFEMB won't need any additional memory
-//                      allocation.
-//
-//                      In case the pre-allocated memory has run out, the "oom_proc" callback
-//                      function will be called to notify the application that an OOM recovery
-//                      procedure needs to be performed.
-//
-FPDFEMB_RESULT FPDFEMB_InitFixedMemory(void* memory, int size, FPDFEMB_FIXED_OOM_HANDLER oom_handler);
-
-// Memory Management Flags
-#define FPDFEMB_NONLEAVE                1
-#define FPDFEMB_MOVABLE                 2
-#define FPDFEMB_DISCARDABLE             4
-
-// Structure: FPDFEMB_MEMMGR_EX
-//                      This is an extended version of memory manager interface, allowing advanced
-//                      memory management, including movable and discardable memory blocks.
-//
-//                      Use this interface with FPDFEMB_InitExt function.
-//
-struct FPDFEMB_MEMMGR_EX {
-        // Interface: Alloc
-        //              Allocate a memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              size            -       Number of bytes for the memory block.
-        //              flags           -       A combination of flags defined above.
-        // Return Value:
-        //              The pointer to allocated memory block. NULL if no memory available.
-        //              If FPDFEMB_MOVABLE flag is used, implementation should return a handle
-        //              to the memory block, if it supports movable block allocation.
-        // Comments:
-        //              The implementation should not do any action if no memory available,
-        //              just return NULL. OOM handling can be done in OOM_Handler interface.
-        //
-        void*   (*Alloc)(struct FPDFEMB_MEMMGR_EX* pMgr, unsigned int size, int flags);
-
-        // Interface: OOM_Handler
-        //              OOM (out-of-memory) situation handler
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        // Return Value:
-        //              None.
-        // Comments:
-        //              In order to handle OOM situation, application can use longjmp() inside 
-        //              implementation of this function.
-        //
-        void    (*OOM_Handler)(struct FPDFEMB_MEMMGR_EX* pMgr);
-
-        // Interfce: Realloc
-        //              Reallocate a memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              pointer         -       Pointer to an existing memory block, or handle to a movable
-        //                                              block. Can not be NULL.
-        //              new_size        -       New size (number of bytes) of the memory block. Can not be zero.
-        // Return value:
-        //              The pointer of reallocated memory block, it could be a new block, or just
-        //              the previous block with size modified.
-        //              If FPDFEMB_MOVABLE flag is used, implementation should return a handle
-        //              to the memory block, if it supports movable block allocation.
-        // Comments:
-        //              If an existing memory block specified, the data in the memory block should
-        //              be copied to the new block, if reallocated.
-        //
-        //              The implementation should not do any action if no memory available,
-        //              just return NULL. OOM handling can be done in OOM_Handler interface.
-        //
-        void*   (*Realloc)(struct FPDFEMB_MEMMGR_EX* pMgr, void* pointer, unsigned int new_size, int flags);
-
-        // Interface: Lock
-        //              Lock a movable memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              handle          -       Handle to movable memory block, returned by Alloc or Realloc.
-        // Return Value:
-        //              The pointer of the memory block. NULL if the block was discarded.
-        // Comments:
-        //              This interface is optional, if implementation doesn't support movable memory
-        //              block, then this interface can be set to NULL.
-        //
-        void*   (*Lock)(struct FPDFEMB_MEMMGR_EX* pMgr, void* handle);
-
-        // Interface: Unlock
-        //              Unlock a locked movable memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              handle          -       Handle to movable memory block, returned by Alloc or Realloc.
-        // Return Value:
-        //              None.
-        // Comments:
-        //              This interface is optional, if implementation doesn't support movable memory
-        //              block, then this interface can be set to NULL.
-        //
-        void    (*Unlock)(struct FPDFEMB_MEMMGR_EX* pMgr, void* handle);
-
-        // Interface: Free
-        //              Free a memory block
-        // Parameters:
-        //              pMgr            -       Pointer to the memory manager.
-        //              pointer         -       Pointer to an existing memory block, or handle to a movable block.
-        // Return Value:
-        //              None.
-        //
-        void    (*Free)(struct FPDFEMB_MEMMGR_EX* pMgr, void* pointer, int flags);
-
-        void*   user;           // A user pointer, used by the application
-};
-
-// Function: FPDFEMB_LoadJbig2Decoder
-// Function: FPDFEMB_LoadJpeg2000Decoder
-//                      Enable JBIG2 or JPEG2000 image decoder 
-// Parameters:
-//                      None.
-// Return Value:
-//                      None.
-// Comments:
-//                      If you want to display JBIG2 or JPEG2000 encoded images, you need to call 
-//                      these functions after FPDFEMB initialized.
-//
-//                      Calling these functions will increase code size by about 200K-400K bytes.
-//                      Also JPEG2000 decoder may not be available on some platforms.
-//
-void FPDFEMB_LoadJbig2Decoder();
-void FPDFEMB_LoadJpeg2000Decoder();
-
-// Function: FPDFEMB_InitEx
-//                      Initialize the FPDFEMB module with the extended memory manager
-// Parameters:
-//                      mem_mgr         -       Pointer to memory manager structure
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      This function will allocate necessary internal data structure for
-//                      the whole module to operate.
-FPDFEMB_RESULT FPDFEMB_InitEx(FPDFEMB_MEMMGR_EX* mem_mgr);
-
-// Function: FPDFEMB_Exit
-//                      Stop using FPDFEMB module and release all resources
-// Parameters:
-//                      None.
-// Return Value:
-//                      None.
-// Comments:
-//                      All loaded documents and pages will become invalid after this call.
-//
-//                      This function is useful for OOM recovery: when your application hits
-//                      an OOM situation, calling this function will clear all memory allocated
-//                      by FPDFEMB module, then you can call one of the initialization functions,
-//                      reopen the document and recovery from OOM.
-//
-void FPDFEMB_Exit();
-
-// Function: FPDFEMB_AllocMemory
-//                      Allocate memory
-// Parameters:
-//                      size            -       Number of bytes
-// Return Value:
-//                      The allocated buffer pointer. NULL for out of memory.
-//
-void* FPDFEMB_AllocMemory(unsigned int size);
-
-// Function: FPDFEMB_FreeMemory
-//                      Free allocated memory
-// Parameters:
-//                      pointer         -       Pointer returned by FPDFEMB_AllocMemory
-// Return Value:
-//                      None.
-//
-void FPDFEMB_FreeMemory(void* pointer);
-
-// Function: FPDFEMB_FreeCaches
-//                      Free all expendable caches used by FPDFEMB in order to save memory
-// Parameters:
-//                      None.
-// Return Value:
-//                      None.
-// Comments:
-//                      When an application memory manager runs out of memory, before an OOM situation 
-//                      is raised, the application can try this 
-//
-void FPDFEMB_FreeCaches();
-
-/********************************************************************************************
-****
-****            Document Operations
-****
-********************************************************************************************/
-
-// Structure: FPDFEMB_FILE_ACCESS
-//              Describe the way to access a file (readonly).
-struct FPDFEMB_FILE_ACCESS {
-        // Inteface: GetSize
-        //              Get total size of the file
-        // Parameters:
-        //              file            -       Pointer to this file access structure
-        // Return Value:
-        //              File size, in bytes. Implementation can return 0 for any error.
-        // 
-        unsigned int    (*GetSize)(struct FPDFEMB_FILE_ACCESS* file);
-
-        // Interface: ReadBlock
-        //              Read a data block from the file
-        // Parameters:
-        //              file            -       Pointer to this file access structure
-        //              buffer          -       Pointer to a buffer receiving read data
-        //              offset          -       Byte offset for the block, from beginning of the file
-        //              size            -       Number of bytes for the block.
-        // Return Value:
-        //              Error code, or FPDFERR_SUCCESS for success.
-        //
-        FPDFEMB_RESULT  (*ReadBlock)(struct FPDFEMB_FILE_ACCESS* file, void* buffer, 
-                                                                        unsigned int offset, unsigned int size);
-
-        void*           user;           // A user pointer, used by the application
-};
-
-// Structure: FPDFEMB_PAUSE
-//                      An interface for pausing a progressive process.
-struct FPDFEMB_PAUSE {
-        // Interface: NeedPauseNow
-        //              Check if we need to pause a progressive proccess now
-        // Parameters:
-        //              pause           -       Pointer to the pause structure
-        // Return Value:
-        //              Non-zero for pause now, 0 for continue.
-        // Comments:
-        //              Typically implementation of this interface compares the current system tick
-        //              with the previous one, if the time elapsed exceeds certain threshold, then
-        //              the implementation returns TRUE, indicating a pause is needed.
-        //
-        FPDFEMB_BOOL (*NeedPauseNow)(struct FPDFEMB_PAUSE* pause);
-
-        void*           user;           // A user pointer, used by the application
-};
-
-typedef void* FPDFEMB_DOCUMENT;
-
-// Function: FPDFEMB_StartLoadDocument
-//                      Start loading a PDF document
-// Parameters:
-//                      file            -       Pointer to file access structure.
-//                                                      This structure must be kept valid as long as the document is open.
-//                      password        -       Pointer to a zero-terminated byte string, for the password.
-//                                                      Or NULL for no password.
-//                      document        -       Receiving the document handle
-//                      pause           -       A callback mechanism allowing the document loading process
-//                                                      to be paused before it's finished. This can be NULL if you
-//                                                      don't want to pause.
-// Return Value:
-//                      FPDFERR_SUCCESS: document successfully loaded.
-//                      FPDFERR_TOBECONTINUED: The document loading can't be finished now.
-//                                      See comments below.
-//                      FPDFERR_PASSWORD: incorrect password.
-//                      FPDFERR_FORMAT: not a PDF or corrupted PDF.
-//                      FPDFERR_FILE: file access error.
-//                      FPDFERR_MEMORY: out of memory.
-// Comments:
-//                      Document loading is a progressive process. It might take a long time to
-//                      load a document, especiall when a file is corrupted, FPDFEMB will try to
-//                      recover the document contents by scanning the whole file. If "pause" parameter
-//                      is provided, this function may return FPDFERR_TOBECONTINUED any time during
-//                      the document loading.
-//
-//                      When FPDFERR_TOBECONTINUED is returned, the "document" parameter will
-//                      still receive a valid document handle, however, no further operations can
-//                      be performed on the document, except the "FPDFEMB_ContineLoadDocument" function
-//                      call, which resume the document loading.
-//
-FPDFEMB_RESULT FPDFEMB_StartLoadDocument(FPDFEMB_FILE_ACCESS* file, const char* password, 
-                                                                        FPDFEMB_DOCUMENT* document, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueLoadDocument
-//                      Continue loading a PDF document
-// Parameters:
-//                      document        -       Document handle returned by FPDFEMB_StartLoadDocument function
-//                      pause           -       A callback mechanism allowing the document loading process
-//                                                      to be paused before it's finished. This can be NULL if you
-//                                                      don't want to pause.
-// Return Value:
-//                      FPDFERR_SUCCESS: document successfully loaded.
-//                      FPDFERR_TOBECONTINUED: The document loading can't be finished now.
-//                                      Further call to this function is needed.
-//                      FPDFERR_PASSWORD: incorrect password.
-//                      FPDFERR_FORMAT: not a PDF or corrupted PDF.
-//                      FPDFERR_FILE: file access error.
-//                      FPDFERR_MEMORY: out of memory.
-//                      FPDFERR_STATUS: document already loaded.
-//                      FPDFERR_PARAM: invalid parameter (like NULL document handle)
-//
-FPDFEMB_RESULT FPDFEMB_ContinueLoadDocument(FPDFEMB_DOCUMENT document, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_CloseDocument
-//                      Close a PDF document and free all associated resources
-// Parameters:
-//                      document        -       Document handle
-// Return Value:
-//                      Error code. FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_CloseDocument(FPDFEMB_DOCUMENT document);
-
-// Function: Get page count
-//                      Get number of pages in the document
-// Parameters:
-//                      document        -       Document handle
-// Return Value:
-//                      Number of pages.
-//
-int FPDFEMB_GetPageCount(FPDFEMB_DOCUMENT document);
-
-// Function: FPDFEMB_SetFileBufferSize
-//                      Set size of internal buffer used to read from source file.
-// Parameters:
-//                      size            -       Number of bytes
-// Return Value:
-//                      None.
-// Comments:
-//                      Currently FPDFEMB uses 512 bytes as default buffer size. The new buffer size 
-//                      takes effect next time you call FPDFEMB_StartLoadDocument.
-//
-void FPDFEMB_SetFileBufferSize(int size);
-
-/********************************************************************************************
-****
-****            Page Basic Operations
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_PAGE;
-
-// Function: FPDFEMB_LoadPage
-//                      Load a page
-// Parameters:
-//                      document        -       Document handle
-//                      index           -       Page index, starting from zero
-//                      page            -       Receiving the loaded page handler
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_LoadPage(FPDFEMB_DOCUMENT document, int index, FPDFEMB_PAGE* page);
-
-// Function: FPDFEMB_ClosePage
-//                      Close a page and release all related resources
-// Parameters:
-//                      page            -       Page handle
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_ClosePage(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_GetPageSize
-//                      Get size of a page
-// Parameters:
-//                      page            -       Page handle
-//                      width           -       Receiving page width, in hundredth of points
-//                      height          -       Receiving page height, in hundredth of points
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_GetPageSize(FPDFEMB_PAGE page, int* width, int* height);
-
-// Structure: FPDFEMB_RECT
-//                      Rectangle area in device or page coordination system
-//
-struct FPDFEMB_RECT
-{
-        // For device system, coordinations are measured in pixels;
-        // For page system, coordinations are measured in hundredth of points.
-        int             left;
-        int             top;
-        int             right;
-        int             bottom;
-};
-
-// Function: FPDFEMB_GetPageBBox
-//                      Get displayable area (bounding box) of a page
-// Parameters:
-//                      page            -       Page handle
-//                      rect            -       Pointer to a structure receiving the rectangle
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_GetPageBBox(FPDFEMB_PAGE page, FPDFEMB_RECT* rect);
-
-/********************************************************************************************
-****
-****            Page Parsing
-****
-********************************************************************************************/
-
-// Function: FPDFEMB_StartParse
-//                      Start parsing a page, so it can get rendered or searched
-// Parameters:
-//                      page            -       Page handle
-//                      text_only       -       flag for parsing texts only (used for searching)
-//                      pause           -       A structure that can pause the parsing process.
-//                                                      Or NULL if you don't want to pause the process.
-// Return Value:
-//                      FPDFERR_SUCCESS: parsing successfully finished;
-//                      FPDFERR_TOBECONTINUED: parsing started successfully, but not finished;
-//                      FPDFERR_STATUS: page already parsed, or parsing already started. 
-//                      Other return value: error code.
-// Comments:
-//                      Parsing is a progressive process. This function starts the parsing process,
-//                      and may return before parsing is finished, if a pause structure is provided.
-//
-//                      Application should call FPDFEMB_ContinueParse repeatedly to finish the parsing
-//                      when return value is FPDFERR_TOBECONTINUED.
-//
-//                      There can be only one parsing procedure active for a page, and if a page
-//                      has already been parsed, you can't start a parsing again.
-//
-FPDFEMB_RESULT FPDFEMB_StartParse(FPDFEMB_PAGE page, FPDFEMB_BOOL text_only, 
-                                                                                                FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueParse
-//                      Continue the page parsing
-// Parameters:
-//                      page            -       Page handle
-//                      pause           -       A structure that can pause the parsing process.
-//                                                      Or NULL if you don't want to pause the process.
-// Return Value:
-//                      FPDFERR_SUCCESS: parsing successfully finished;
-//                      FPDFERR_TOBECONTINUED: parsing performed successfully, but not finished;
-//                      FPDFERR_STATUS: page already parsed (or parsing not started). 
-//                      Other return value: error code.
-// Comments:
-//                      FPDFEMB_StartParse should be called before on the page.
-//
-//                      Application should call FPDFEMB_ContinueParse repeatedly to finish the parsing
-//                      when return value is FPDFERR_TOBECONTINUED.
-//
-FPDFEMB_RESULT FPDFEMB_ContinueParse(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_GetParseProgress
-//                      Get an estimated parsing progress in percentage
-// Parameters:
-//                      page            -       Page handle
-// Return Value:
-//                      An integer between 0 and 100 (inclusive) indicating the parsing progress.
-//                      The result is just a rough estimation.
-//
-int FPDFEMB_GetParseProgress(FPDFEMB_PAGE page);
-
-/********************************************************************************************
-****
-****            Page Rendering
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_BITMAP;
-
-// Function: FPDFEMB_StartQuickDraw
-//                      Start drawing a quick preview of a page
-// Parameters:
-//                      dib                     -       DIB handle, as the rendering device
-//                      page            -       Page handle. The page has to be parsed first.
-//                      start_x         -       Left pixel position of the display area in the device coordination
-//                      start_y         -       Top pixel position of the display area in the device coordination
-//                      size_x          -       Horizontal size (in pixels) for displaying the page
-//                      size_y          -       Vertical size (in pixels) for displaying the page
-//                      rotate          -       Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//                                                              2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//                      flags           -       Reserved, must be zero.
-//                      pause           -       Pointer to a structure that can pause the rendering process.
-//                                                      Can be NULL if no pausing is needed.
-// Return Value:
-//                      FPDFERR_SUCCESS: quickdraw successly finished;
-//                      FPDFERR_TOBECONTINUED: quickdraw started successfully, but not finished.
-//                                                      FPDFEMB_ContinueQuickDraw needs to be called to finish the quickdraw;
-//                      FPDFERR_STATUS: quickdraw already in progress, or page not parsed;
-//                      Other return value: error code.
-// Comments:
-//                      It's often useful to present user a quick preview of a page, right after the
-//                      page is parsed. This preview renders only a limited set of easy features in the
-//                      page, so it'll be rather quick to finish this process.
-//
-FPDFEMB_RESULT FPDFEMB_StartQuickDraw(FPDFEMB_BITMAP dib, FPDFEMB_PAGE page,
-                                                        int start_x, int start_y, int size_x, int size_y, int rotate,
-                                                        int flags, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueQuickDraw
-//                      Continue a quick draw processing
-// Parameters:
-//                      page            -       Page handle. The page has to be parsed first.
-//                      pause           -       Pointer to a structure that can pause the rendering process.
-//                                                      Can be NULL if no pausing is needed.
-// Return Value:
-//                      FPDFERR_SUCCESS: quickdraw successly finished;
-//                      FPDFERR_TOBECONTINUED: quickdraw started successfully, but not finished.
-//                                                      more calls to this function needed to finish the quickdraw;
-//                      FPDFERR_STATUS: quickdraw not started yet; 
-//                      Other return value: error code.
-//
-FPDFEMB_RESULT FPDFEMB_ContinueQuickDraw(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);
-
-#define FPDFEMB_ANNOT                   0x01            // Set if annotations are to be rendered
-#define FPDFEMB_LCD_TEXT                0x02            // Set if using text rendering optimized for LCD display
-#define FPDFEMB_BGR_STRIPE              0x04            // Set if the device is using BGR LCD stripe
-
-// Function: FPDFEMB_StartRender
-//                      Start rendering of a page.
-// Parameter:
-//                      dib                     -       DIB handle, as the rendering device
-//                      page            -       Page handle. The page has to be parsed first.
-//                      start_x         -       Left pixel position of the display area in the device coordination
-//                      start_y         -       Top pixel position of the display area in the device coordination
-//                      size_x          -       Horizontal size (in pixels) for displaying the page
-//                      size_y          -       Vertical size (in pixels) for displaying the page
-//                      rotate          -       Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//                                                              2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//                      flags           -       0 for normal display, or combination of flags defined above
-//                      clip            -       Pointer to clip rectangle (in DIB device coordinations),
-//                                                      or NULL if no clipping needed.
-//                      pause           -       Pointer to a structure that can pause the rendering process.
-//                                                      Can be NULL if no pausing is needed.
-// Return Value:
-//                      FPDFERR_SUCCESS: rendering successfully finished;
-//                      FPDFERR_TOBECONTINUED: rendering started successfully, but not finished;
-//                      Other return value: error code.
-// Comments:
-//                      Rendering is a progressive process. This function starts the rendering process,
-//                      and may return before rendering is finished, if a pause structure is provided.
-//
-//                      Application should call FPDFEMB_ContinueRender repeatedly to finish the rendering 
-//                      when return value is FPDFERR_TOBECONTINUED.
-//
-//                      There can be only one rendering procedure for a page at any time. And rendering
-//                      can be started over and over again for the same page. If a page rendering is already
-//                      active, starting another one will cancel the previous rendering.
-//
-//                      Rendering of a page doesn't draw the page background, therefore, you usually need
-//                      to draw the background in the DIB yourself.
-//
-FPDFEMB_RESULT FPDFEMB_StartRender(FPDFEMB_BITMAP dib, FPDFEMB_PAGE page,
-                                                int start_x, int start_y, int size_x, int size_y, int rotate, int flags,
-                                                FPDFEMB_RECT* clip, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueRender
-//                      Continue the page rendering
-// Parameters:
-//                      page            -       Page handle
-//                      pause           -       Pointer to a structure that can pause the rendering process.
-//                                                      Can be NULL if no pausing is needed.
-// Return Value:
-//                      FPDFERR_SUCCESS: rendering successfully finished.
-//                      FPDFERR_TOBECONTINUED: rendering needs to be continued;
-//                      Other return value: error code.
-// Comments:
-//                      This function may return any time when the pause interface indicates 
-//                      a pause is needed. Application can call FPDFEMB_ContinueRender any number
-//                      of times, until FPDFERR_TOBECONTINUED is not returned.
-//
-FPDFEMB_RESULT FPDFEMB_ContinueRender(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_GetRenderProgress
-//                      Get an estimated rendering progress in percentage
-// Parameters:
-//                      page            -       Page handle
-// Return Value:
-//                      An integer between 0 and 100 (inclusive) indicating the rendering progress.
-//                      The result is just a rough estimation.
-//                      If the rendering just finished, this function will return 0.
-//
-int FPDFEMB_GetRenderProgress(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_SetHalftoneLimit
-//                      Set pixel count limit for using halftone when display image
-// Parameter:
-//                      limit           -       Number of pixels for the limit
-// Return Value:
-//                      None.
-// Comments:
-//                      By default, FPDFEMB displays all bitmaps using downsamping, which means
-//                      if the image is shrinked onto screen, only part of pixels will be picked
-//                      and displayed. This saves a lot of calculation, especially for big images
-//                      with millions of pixels. However the display quality can be bad. In order to
-//                      reach a balance between performance and quality, application can use this
-//                      function to set a limit, if number of pixels in an image is more than this
-//                      limit, then FPDFEMB will use downsampling for quick drawing, otherwise, if
-//                      the image has less pixels, FPDFEMB will use halftoning for better quality.
-//
-void FPDFEMB_SetHalftoneLimit(int limit);
-
-/********************************************************************************************
-****
-****            Coordination Conversion
-****
-********************************************************************************************/
-
-// Structure: FPDFEMB_POINT
-//                      A point in device or page coordination system
-//
-struct FPDFEMB_POINT
-{
-        // For device system, coordinations are measured in pixels;
-        // For page system, coordinations are measured hundredth of points.
-        int             x;
-        int             y;
-};
-
-// Function: FPDFEMB_DeviceToPagePoint, FPDFEMB_DeviceToPageRect
-//                      Convert the device coordinations of a point or a rectangle to page coordinations.
-// Parameters:
-//                      page            -       Handle to the page. Returned by FPDFEMB_LoadPage function.
-//                      start_x         -       Left pixel position of the display area in the device coordination
-//                      start_y         -       Top pixel position of the display area in the device coordination
-//                      size_x          -       Horizontal size (in pixels) for displaying the page
-//                      size_y          -       Vertical size (in pixels) for displaying the page
-//                      rotate          -       Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//                                                              2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//                      point           -       A point structure with device coordinations upon the call,
-//                                                      also receiving the result page coordinations.
-//                      rect            -       A rectangle structure with device coordinations upon the call,
-//                                                      also receiving the result page coordinations.
-// Return value:
-//                      None.
-// Comments:
-//                      The page coordination system has its origin at left-bottom corner of the page, 
-//                      with X axis goes along the bottom side to the right, and Y axis goes along the 
-//                      left side upward. No matter how you zoom, scroll, or rotate a page, a particular
-//                      element (like text or image) on the page should always have the same coordination 
-//                      values in the page coordination system. 
-//
-//                      The device coordination system is device dependant. For bitmap device, its origin 
-//                      is at left-top corner of the window. You must make sure the start_x, start_y, size_x, 
-//                      size_y and rotate parameters have exactly same values as you used in 
-//                      FPDFEMB_StartRender() function call.
-//
-//                      For rectangle conversion, the result rectangle is always "normalized", meaning for
-//                      page coordinations, left is always smaller than right, bottom is smaller than top.
-//
-void FPDFEMB_DeviceToPagePoint(FPDFEMB_PAGE page, 
-                                                int start_x, int start_y, int size_x, int size_y, int rotate, 
-                                                FPDFEMB_POINT* point);
-
-void FPDFEMB_DeviceToPageRect(FPDFEMB_PAGE page, 
-                                                int start_x, int start_y, int size_x, int size_y, int rotate, 
-                                                FPDFEMB_RECT* rect);
-
-// Function: FPDFEMB_PageToDevicePoint, FPDFEMB_PageToDeviceRect
-//                      Convert the page coordinations of a point or a rectangle to device coordinations.
-// Parameters:
-//                      page            -       Handle to the page. Returned by FPDFEMB_LoadPage function.
-//                      start_x         -       Left pixel position of the display area in the device coordination
-//                      start_y         -       Top pixel position of the display area in the device coordination
-//                      size_x          -       Horizontal size (in pixels) for displaying the page
-//                      size_y          -       Vertical size (in pixels) for displaying the page
-//                      rotate          -       Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//                                                              2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//                      point           -       A point structure with page coordinations upon the call,
-//                                                      also receiving the result device coordinations.
-//                      rect            -       A rectangle structure with page coordinations upon the call,
-//                                                      also receiving the result device coordinations.
-// Return value:
-//                      None
-// Comments:
-//                      For rectangle conversion, the result rectangle is always "normalized", meaning for
-//                      device coordinations, left is always smaller than right, top is smaller than bottom.
-//
-void FPDFEMB_PageToDevicePoint(FPDFEMB_PAGE page, 
-                                                int start_x, int start_y, int size_x, int size_y, int rotate, 
-                                                FPDFEMB_POINT* point);
-
-void FPDFEMB_PageToDeviceRect(FPDFEMB_PAGE page, 
-                                                int start_x, int start_y, int size_x, int size_y, int rotate, 
-                                                FPDFEMB_RECT* rect);
-
-/********************************************************************************************
-****
-****            Text Search
-****
-********************************************************************************************/
-
-// Search flags for FPDFEMB_FindFirst function
-#define FPDFEMB_MATCHCASE               1               // whether matching case
-#define FPDFEMB_MATCHWHOLEWORD  2               // whether matching whole word
-#define FPDFEMB_CONSECUTIVE             4               // whether matching consecutively (for example, "CC" will
-                                                                                // match twice in "CCC").
-
-// Function: FPDFEMB_FindFirst
-//                      Find first occurance of a pattern string in a page
-// Parameters:
-//                      page            -       Page handle.
-//                      pattern         -       A zero-terminated unicode string to be found. 
-//                      from_last       -       Whether we start from the end of page
-//                      flags           -       Search flags, see above defined constants
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//                      Is not found, FPDFERR_NOTFOUND is returned.
-// Comments:
-//                      A page must be parsed first before it can be searched.
-//                      There can be only one search in progress for a page. A new search will 
-//                      cancel the previous one.
-//
-//                      IMPORTANT: this function is now obsolete and kept for back compatibility
-//                      only, please use FPDFEMB_FindFrom function below.
-//
-FPDFEMB_RESULT FPDFEMB_FindFirst(FPDFEMB_PAGE page, const FPDFEMB_WCHAR* pattern, 
-                                                                 FPDFEMB_BOOL from_last, unsigned int flags);
-
-// Function: FPDFEMB_FindFrom
-//                      Find first occurance of a pattern string in a page, from a particular position
-// Parameters:
-//                      page            -       Page handle.
-//                      pattern         -       A zero-terminated unicode string to be found. 
-//                      pos                     -       The position, returned from FPDFEMB_GetSearchPos.
-//                                                      Or 0 from the beginning of page, -1 from the end of page.
-//                      flags           -       Search flags, see above defined constants
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//                      Is not found, FPDFERR_NOTFOUND is returned.
-// Comments:
-//                      A page must be parsed first before it can be searched.
-//                      There can be only one search in progress for a page. A new search will 
-//                      cancel the previous one.
-//
-FPDFEMB_RESULT FPDFEMB_FindFrom(FPDFEMB_PAGE page, const FPDFEMB_WCHAR* pattern, 
-                                                                 int pos, unsigned int flags);
-
-// Function: FPDFEMB_FindNext
-//                      Find next occurance of a search
-// Parameters:
-//                      page            -       Page handle. 
-//                                                      FPDFEMB_FindFirst must be called for this page first.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//                      Is not found, FPDFERR_NOTFOUND is returned.
-//
-FPDFEMB_RESULT FPDFEMB_FindNext(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_FindPrev
-//                      Find previous occurance of a search
-// Parameters:
-//                      page            -       Page handle.
-//                                                      FPDFEMB_FindFirst must be called for this page first.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//                      Is not found, FPDFERR_NOTFOUND is returned.
-//
-FPDFEMB_RESULT FPDFEMB_FindPrev(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_CountFoundRects
-//                      Get number of rectangles for last found result
-// Parameters:
-//                      page            -       Page handle.
-// Return Value:
-//                      Number of rectangles for last found result. 0 for not found or failure.
-//
-int FPDFEMB_CountFoundRects(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_GetFoundRect
-//                      Get a particular found rectangle
-// Parameters:
-//                      page            -       Page handle.
-//                      index           -       Zero-based index for the rectangle.
-//                      rect            -       Receiving the result rectangle, in hundredth of points
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      Application should always call FPDFEMB_CountFoundRects first to get
-//                      number of rectangles, then use this function to get each rectangle.
-//
-//                      The returned rectangle uses page coordination system.
-//
-FPDFEMB_RESULT FPDFEMB_GetFoundRect(FPDFEMB_PAGE page, int index, FPDFEMB_RECT* rect);
-
-// Function: FPDFEMB_GetSearchPos
-//                      Return position of current search result
-// Parameters:
-//                      page            -       Page handle.
-// Return Value:
-//                      Zero based character index for the current search result. -1 if not found.
-//
-int FPDFEMB_GetSearchPos(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_QuickSearch
-//                      Search a pattern in a page quickly, without the page to be parsed
-// Parameters:
-//                      document        -       Document handle returned by FPDFEMB_StartLoadDocument function
-//                      page_index      -       Zero-based index of the page
-//                      pattern         -       A zero-terminated unicode string to be found. 
-//                      case_sensitive  -       Non-zero for case-sensitive searching, zero for case-insensitive
-// Return Value:
-//                      FPDFERR_SUCCESS if pattern found, FPDFERR_NOTFOUND if pattern not found.
-//                      Otherwise error code is returned.
-// Comments:
-//                      This function does a rough and quick search in a page, before the page is loaded. 
-//                      The quick search will not generate an exact result saying where the pattern is
-//                      found, and, it might be possible if a quick search result is "pattern found", and
-//                      a real search for the same pattern, in the same page, will result in "not found".
-//
-//                      However, if quick search doesn't find a pattern in a page, then we can be sure the
-//                      pattern won't be found in this page when we do a real search. So, this function is 
-//                      very useful when we search in a multiple-page document, and we want to quickly skip
-//                      those pages in which the pattern can't possibly be found.
-//
-FPDFEMB_RESULT FPDFEMB_QuickSearch(FPDFEMB_DOCUMENT document, int page_index, 
-                                                                   const FPDFEMB_WCHAR* pattern, int case_sensitive);
-
-/********************************************************************************************
-****
-****            Text Information
-****
-********************************************************************************************/
-
-// Function: FPDFEMB_GetCharCount
-//                      Get number of characters in the page
-// Parameters:
-//                      page            -       Page handle
-//                      count           -       Receiving number of characters
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_GetCharCount(FPDFEMB_PAGE page, int* count);
-
-// Structure: FPDFEMB_CHAR_INFO
-//                      Character information.
-struct FPDFEMB_CHAR_INFO {
-        int             unicode;                // Unicode for the character. 0 if not available.
-                                                        // Space and new line charcters (U+0020 and U+000A) may be generated
-                                                        // according to the text formatting.
-        FPDFEMB_POINT   origin; // X/Y position for the character origin, in hundredth of points
-        FPDFEMB_RECT    bbox;   // Bounding box of the character, in hundredth of points
-                                                        // Maybe an empty box (left == right or top == bottom).
-};
-
-// Function: FPDFEMB_GetCharInfo
-//                      Get character information
-// Parameters:
-//                      page            -       Page handle
-//                      index           -       Character index, starting from zero
-//                      char_info       -       Receiving the character info
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      Application must call FPDFEMB_GetCharCount first before it can call this function
-//                      for any particular characters.
-//                      
-FPDFEMB_RESULT FPDFEMB_GetCharInfo(FPDFEMB_PAGE page, int index, FPDFEMB_CHAR_INFO* char_info);
-
-// Function: FPDFEMB_GetCharIndexAtPos()
-//                      Get index of character nearest to a certain position on the page
-// Parameters:
-//                      page            -       Page handle
-//                      x                       -       X position in PDF page coordination system
-//                      y                       -       Y position in PDF page coordination system
-//                      index           -       Pointer to an integer receiving zero-based character index.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      This function finds the character that's nearest to the particular page position.
-//                      If there is no character, the output index will be -1.
-//                      
-FPDFEMB_RESULT FPDFEMB_GetCharIndexAtPos(FPDFEMB_PAGE page, double x, double y, int* index);
-
-/********************************************************************************************
-****
-****            Device Independant Bitmap
-****
-********************************************************************************************/
-
-#define FPDFDIB_BGR             1       // 3 bytes per pixel, byte order: Blue, Green, Red
-#define FPDFDIB_BGRx    2       // 4 bytes per pixel, byte order: Blue, Green, Red, not used
-#define FPDFDIB_BGRA    3       // 4 bytes per pixel, byte order: Blue, Green, Red, Alpha
-#define FPDFDIB_GRAY    4       // 1 byte per pixel (grayscale)
-
-// Function: FPDFEMB_CreateDIB
-//                      Create a DIB (Device Independant Bitmap)
-// Parameters:
-//                      width           -       Width pixels;
-//                      height          -       Height pixels;
-//                      format          -       Format type. See FPDFDIB_xxx constants
-//                      buffer          -       External buffer provided for the DIB,
-//                                                      or NULL if new buffer is to be allocated.
-//                      stride          -       Number of bytes for each scan line, for external buffer only.
-//                                                      If not specified, 4-byte alignment assumed.
-//                      dib                     -       Receiving the created DIB handle
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      If "buffer" parameter is not NULL, then the provided buffer must conform
-//                      to standard DIB format (see comments of FPDFEMB_GetDIBData function below).
-//
-//                      This function doesn't initialize the pixels inside the DIB buffer. So if you
-//                      want to use the DIB to display a PDF page, you usually need to initialize
-//                      the DIB to white background by youself.
-//
-FPDFEMB_RESULT FPDFEMB_CreateDIB(int width, int height, int format, 
-                                                                           void* buffer, int stride, FPDFEMB_BITMAP* dib);
-
-// Function: FPDFEMB_DestroyDIB
-//                      Destroy a DIB
-// Parameters:
-//                      dib                     -       DIB handle
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      If external buffer is used (specified in "buffer" parameter when calling
-//                      FPDFEMB_CreateDIB), the buffer will not be destroyed.
-//
-FPDFEMB_RESULT FPDFEMB_DestroyDIB(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBWidth
-//                      Get width (in pixels) of a DIB
-// Parameters:
-//                      dib                     -       DIB handle
-// Return Value:
-//                      DIB width in pixels.
-//
-int FPDFEMB_GetDIBWidth(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBHeight
-//                      Get height (in pixels) of a DIB
-// Parameters:
-//                      dib                     -       DIB handle
-// Return Value:
-//                      DIB height in pixels.
-//
-int FPDFEMB_GetDIBHeight(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBData
-//                      Get data pointer to a DIB
-// Parameters:
-//                      dib                     -       DIB handle
-// Return Value:
-//                      Pointer to the DIB data.
-// Comments:
-//                      DIB data are organized in scanlines, from top down.
-//
-void* FPDFEMB_GetDIBData(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBStride
-//                      Get scan line stride of a DIB
-// Parameters:
-//                      dib                     -       DIB handle
-// Return Value:
-//                      Number of bytes occupied by a scanline
-//
-int FPDFEMB_GetDIBStride(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetRotatedDIB
-//                      Swap X/Y dimensions of a DIB to generate a rotated new DIB
-// Parameters:
-//                      dib                     -       DIB handle
-//                      flip_x          -       Whether flip pixels on the destination X dimension (left/right)
-//                      flip_y          -       Whether flip pixels on the destination Y dimension (up/down)
-//                      result_dib      -       Receiving the result DIB handle
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_GetRotatedDIB(FPDFEMB_BITMAP dib, 
-                                                                         FPDFEMB_BOOL bFlipX, FPDFEMB_BOOL bFlipY,
-                                                                         FPDFEMB_BITMAP* result_dib);
-
-// Function: FPDFEMB_StretchDIB
-//                      Stretch a source DIB into another destination DIB
-// Parameters:
-//                      dest_dib        -       The destination DIB handle
-//                      dest_left       -       Left position in the destination DIB
-//                      dest_top        -       Top position in the destination DIB
-//                      dest_width      -       Destination width, in pixels. Can be negative for horizontal flipping
-//                      dest_height     -       Destination height, in pixels. Can be negative for vertical flipping
-//                      clip            -       Destination clipping rectangle, or NULL for no clipping.
-//                                                      The coordinations are measured in destination bitmap.
-//                      src_dib         -       Source DIB handle.
-//                      interpol        -       Whether we use interpolation to improve the result quality
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_StretchDIB(FPDFEMB_BITMAP dest_dib, int dest_left, int dest_top,
-                                                                  int dest_width, int dest_height, FPDFEMB_RECT* clip_rect, 
-                                                                  FPDFEMB_BITMAP src_dib, FPDFEMB_BOOL interpol);
-
-// Function: FPDFEMB_TransformDIB
-//                      Transform a source DIB into another destination DIB
-// Parameters:
-//                      dest_dib        -       The destination DIB handle
-//                      clip            -       Destination clipping rectangle, or NULL for no clipping.
-//                                                      The coordinations are measured in destination bitmap.
-//                      src_dib         -       Source DIB handle.
-//                      x                       -       X coordination of the dest origin
-//                      y                       -       Y coordination of the dest origin
-//                      xx                      -       X distance of the dest X vector
-//                      yx                      -       Y distance of the dest X vector
-//                      xy                      -       X distance of the dest Y vector
-//                      yy                      -       Y distance of the dest Y vector
-//                      interpol        -       Whether we use interpolation to improve the result quality
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      All coordinations and distances are measured in destination bitmap system.
-//
-//                      This function places the bottom-left pixel of the image at the destination
-//                      origin, then the bottom sideline along the destination X vector, and left 
-//                      sideline along the destination Y vector.
-//                      
-FPDFEMB_RESULT FPDFEMB_TransformDIB(FPDFEMB_BITMAP dest_dib, FPDFEMB_RECT* clip_rect, 
-                                                                  FPDFEMB_BITMAP src_dib, int x, int y, int xx, int yx,
-                                                                  int xy, int yy, FPDFEMB_BOOL interpol);
-
-/********************************************************************************************
-****
-****            Custom Font Handler and CJK Support
-****
-********************************************************************************************/
-
-// FPDFEMB comes with standard fonts for Latin characters. If your device is targeted to
-// Eastern Asian markets, then system fonts must be provided and registered with FPDFEMB.
-// Depending on your device configuration, those system fonts might be in TrueType or Type1
-// format, or some other non-standard compact format. For the first case, you should register
-// a font mapper so FPDFEMB can pick the right font file, and for the second case, you
-// should register a glyph provider so FPDFEMB can get glyph bitmap for each character.
-
-#define FPDFEMB_CHARSET_DEFAULT         0
-#define FPDFEMB_CHARSET_GB                      936
-#define FPDFEMB_CHARSET_BIG5            950
-#define FPDFEMB_CHARSET_JIS                     932
-#define FPDFEMB_CHARSET_KOREA           949
-#define FPDFEMB_CHARSET_UNICODE         1200
-
-#define FPDFEMB_FONT_FIXEDPITCH         1
-#define FPDFEMB_FONT_SERIF                      2
-#define FPDFEMB_FONT_SYMBOLIC           4
-#define FPDFEMB_FONT_SCRIPT                     8
-#define FPDFEMB_FONT_NONSYMBOLIC        32
-#define FPDFEMB_FONT_ITALIC                     64
-#define FPDFEMB_FONT_ALLCAP                     0x10000
-#define FPDFEMB_FONT_SMALLCAP           0x20000
-#define FPDFEMB_FONT_FORCEBOLD          0x40000
-
-// Structure: FPDFEMB_FONT_MAPPER
-//                      Defines interface for system font mapper.
-//
-struct FPDFEMB_FONT_MAPPER
-{
-        // Interface: MapFont
-        //              Find font file path for a particular PDF font
-        // Parameters:
-        //              mapper          -       Pointer to the FPDFEMB_FONT_MAPPER structure
-        //              name            -       Font name
-        //              charset         -       Charset ID (see above FPDFEMB_CHARSET_xxx constants)
-        //              flags           -       Font flags (see above FPDFEMB_FONT_xxx constants)
-        //              weight          -       Weight of the font. Range from 100 to 900. 400 is normal,
-        //                                              700 is bold.
-        //              path            -       Receiving the full file path. The buffer size is 512 bytes.
-        //              face_index      -       Receiving an zero-based index value for the font face, if the 
-        //                                              mapped font file is a "collection" (meaning a number of faces 
-        //                                              are stored in the same file). If the font file is not a 
-        //                                              collection, the index value should be zero.
-        // Return Value:
-        //              Non-zero for success, 0 for failure.
-        //
-        FPDFEMB_BOOL    (*MapFont)(struct FPDFEMB_FONT_MAPPER* mapper, const char* name, int charset,
-                                                                        unsigned int flags,     int weight,
-                                                                        char* path, int* face_index);
-
-        void*           user;           // A user pointer, used by the application
-};
-
-// Function: FPDFEMB_SetFontMapper
-//                      Use a system font mapper (typically for Chinese/Japanese/Korean charsets)
-// Parameters:
-//                      mapper          -       Pointer to FPDFEMB_FONT_MAPPER structure.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      This function is used with devices that come with one or more system fonts,
-//                      and those fonts are in standard TT or T1 format.
-//
-FPDFEMB_RESULT FPDFEMB_SetFontMapper(FPDFEMB_FONT_MAPPER* mapper);
-
-// Structure: FPDFEMB_GLYPH_PROVIDER
-//                      Interface for providing glyph bitmap of non-latin characters.
-//                      This is usually used for embedded devices with Chinese/Japanese/Korean 
-//                      fonts installed, but those fonts are not in TrueType or Type1 format.
-//
-struct FPDFEMB_GLYPH_PROVIDER
-{
-        // Interface: MapFont
-        //              Return an internal handle for a font
-        // Parameters:
-        //              provider        -       Pointer to this structure
-        //              name            -       Font name
-        //              charset         -       Charset ID (see above FPDFEMB_CHARSET_xxx constants)
-        //              flags           -       Font flags (see above FPDFEMB_FONT_xxx constants)
-        //              weight          -       Weight of the font. Range from 100 to 900. 400 is normal,
-        //                                              700 is bold.
-        // Return Value:
-        //              An internal handle to the mapped font. If the embedded device supports
-        //              multiple fonts, then this value can serve as an identifier to differentiate
-        //              among them. If the device supports only one font, then implementation of
-        //              this function can simply return NULL.
-        //
-        void*   (*MapFont)(struct FPDFEMB_GLYPH_PROVIDER* provider, const char* name, int charset,
-                                                                        unsigned int flags,     int weight);
-        // Interface: GetGlyphBBox
-        //              Get glyph bounding box
-        // Parameters:
-        //              provider        -       Pointer to this structure
-        //              font            -       Internal handle to the font. Returned by MapFont interface.
-        //              unicode         -       Unicode of the character
-        //              CID                     -       Adobe CID for this character. Or zero if not available.
-        //              bbox            -       Receiving the result bounding box. See comments below.
-        // Return Value:
-        //              None.
-        // Comments:
-        //              The bounding box is measure in a glyph coordination system, in which the
-        //              origin is set to character origin, and unit is set to one-thousandth of
-        //              "em size" (representing the font size).
-        //
-        //              In most CJK fonts, all CJK characters (except some symbols or western 
-        //              characters) have same glyph bounding box:
-        //              left = 0, right = 1000, bottom = -220, top = 780.
-        //
-        //              It's OK to return a box that's larger than the actual glyph box.
-        //
-        void    (*GetGlyphBBox)(struct FPDFEMB_GLYPH_PROVIDER* provider, void* font,
-                                                                        FPDFEMB_WCHAR unicode, unsigned short CID,
-                                                                        FPDFEMB_RECT* bbox);
-
-        // Interface: GetGlyphBitmap
-        //              Get bitmap of a glyph
-        // Parameters:
-        //              provider        -       Pointer to this structure
-        //              font            -       Internal handle to the font. Returned by MapFont interface.
-        //              unicode         -       Unicode of the character
-        //              CID                     -       Adobe CID for this character. Or zero if not available.
-        //              font_width      -       Width of the font em square, measured in device units.
-        //              font_height     -       Height of the font em square, measured in device units.
-        //              left            -       Receiving the left offset, from the character origin, of the
-        //                                              result glyph bitmap. Positive value will move the bitmap to
-        //                                              the right side, negative to the left.
-        //              top                     -       Receiving the top offset, from the character origin, of the
-        //                                              result glyph bitmap. Positive value will move the bitmap upward,
-        //                                              negative downward.
-        //              bitmap_width -  Receiving number of width pixels in the result bitmap
-        //              bitmap_height - Receiving number of height pixels in the result bitmap
-        //              buffer          -       Receiving a data buffer pointer, allocated by the implementation.
-        //                                              See comments below.
-        //              stride          -       Receiving number of bytes per scanline, in the data buffer.
-        //              pdf_width       -       Width of the character specified in PDF. It is measured in one-
-        //                                              thousandth of the font width. It can be 0 if width not specified
-        //                                              in PDF. See comments below.
-        // Return Value:
-        //              Non-zero for success. 0 for failure. In this case the glyph can not be displayed.
-        // Comments:
-        //              The buffer should be allocated by implemenation. And it must be allocated
-        //              using FPDFEMB_AllocMemory function. The result buffer will be destroyed by
-        //              FPDFEMB SDK, so implementation should not destroy it.
-        //
-        //              The implementation should write "coverage" data into allocated buffer, one byte 
-        //              for each pixel, from top scanline to bottom scanline, within each scan line, 
-        //              from left pixel to right. Coverage 0 means the pixel is outside the glyph, 
-        //              coverage 255 means the pixel is inside the glyph.
-        //
-        //              The "pdf_width" parameter can be used to scale the character in system font
-        //              horizontally to match the font width specified in PDF. For example, if we have
-        //              a PDF file which requires a character in half-width (pdf_width is 500), but
-        //              in the system font the character has full-width (1000), then the glyph provider
-        //              implementation should scale the font horizontally to half of its original width.
-        //
-        FPDFEMB_BOOL (*GetGlyphBitmap)(struct FPDFEMB_GLYPH_PROVIDER* provider, void* font,
-                                                                        FPDFEMB_WCHAR unicode, unsigned short CID,
-                                                                        double font_width, double font_height, int* left, int* top,
-                                                                        int* bitmap_width, int* bitmap_height, 
-                                                                        void** buffer, int* stride, int pdf_width);
-
-        void*           user;           // A user pointer, used by the application
-};
-
-// Function: FPDFEMB_SetGlyphProvider
-//                      Make use of a glyph provider: generating glyph bitmap for non-Latin characters
-// Parameters:
-//                      provider        -       Pointer to the glyph provider structure.
-//                                                      This structure must stay valid throughout usage of FPDFEMB module.
-// Return Value:
-//                      None.
-// Comments:
-//                      FPDFEMB embeds some standard fonts for Latin characters and symbols, like
-//                      Times, Courier and Helvetica (Arial). For non-Latin characters, however,
-//                      FPDFEMB has to ask glyph provide for help.
-//
-//                      If an embedded device carries fonts for non-Latin character sets, especially
-//                      those for CJK markets, then the application can implement a glyph provider,
-//                      allowing PDFs using non-embedded CJK fonts to be properly displayed.
-//
-void FPDFEMB_SetGlyphProvider(FPDFEMB_GLYPH_PROVIDER* provider);
-
-// Function: FPDFEMB_LoadCMap_GB
-// Function: FPDFEMB_LoadCMap_GB_Ext
-// Function: FPDFEMB_LoadCMap_CNS
-// Function: FPDFEMB_LoadCMap_Korean
-// Function: FPDFEMB_LoadCMap_Japan
-// Function: FPDFEMB_LoadCMap_Japan_Ext
-//                      Make use of character encoding maps embedded with FPDFEMB
-// Parameters:
-//                      None.
-// Return Value:
-//                      None.
-// Comments:
-//                      These functions add character encoding data to your application. Each call
-//                      will increase the code size of your application. Total data size for all
-//                      character sets is 151K bytes.
-void FPDFEMB_LoadCMap_GB();
-void FPDFEMB_LoadCMap_GB_Ext();         // Load full code table for GB
-void FPDFEMB_LoadCMap_CNS();
-void FPDFEMB_LoadCMap_Korea();
-void FPDFEMB_LoadCMap_Japan();
-void FPDFEMB_LoadCMap_Japan_Ext();      // Load full code table for Japan
-
-/********************************************************************************************
-****
-****            Document Information
-****
-********************************************************************************************/
-
-// Function: PDFEMB_GetDocInfoString
-//                      Get information string about the document, like creator, modifcation date, etc.
-// Parameters:
-//                      document        -       Handle to the document
-//                      key                     -       A byte string for the information key. Currently can be one of the followings:
-//                                                      "Title", "Author", "Subject", "Keywords", "Creator", "Producer", "CreationDate",
-//                                                      "ModDate", or some custom information key, if supported by the PDF file.
-//                      buffer          -       A buffer allocated by the application, or NULL.
-//                      bufsize         -       [IN/OUT] A pointer to a number indicating the buffer size (number of bytes),
-//                                                      before this function call. After return, this place will store
-//                                                      number of bytes used by the output (including terminator).
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      The string is output in Unicode, using UTF-16LE format. It's terminated by
-//                      two consecutive zero bytes.
-//
-//                      If the "buffer" parameter is NULL, then the "bufsize" parameter will receive
-//                      number of bytes required to store the string (including the two-byte terminator).
-//
-FPDFEMB_RESULT FPDFEMB_GetDocInfoString(FPDFEMB_DOCUMENT document, const char* key, void* buffer, unsigned int* bufsize);
-
-/********************************************************************************************
-****
-****            Action (Destination) Information
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_ACTION;
-
-// Action types supported by FPDFEMB
-#define FPDFEMB_DEST_NONE                       0               // No or unsupported destination
-#define FPDFEMB_DEST_PAGE                       1               // A page inside the same document
-#define FPDFEMB_DEST_DOC                        2               // An external PDF document
-#define FPDFEMB_DEST_URL                        3               // An external URL
-#define FPDFEMB_ACTION_LAUNCH           4               // Launch an external file or command
-
-// Zoom mode for destination
-#define FPDFEMB_ZOOM_NONE                       0               // Zoom mode not specified
-#define FPDFEMB_ZOOM_FACTOR                     1               // Specific zoom factor is used
-#define FPDFEMB_ZOOM_FITPAGE            2               // Fit the whole page on screen
-#define FPDFEMB_ZOOM_FITWIDTH           3               // Fit width of the page on screen
-#define FPDFEMB_ZOOM_FITHEIGHT          4               // Fit height of the page on screen
-#define FPDFEMB_ZOOM_FITRECT            5               // Fit a particular rectangle on screen
-#define FPDFEMB_ZOOM_FITCONTENT         6               // Fit whole content of page on screen
-#define FPDFEMB_ZOOM_FITCONTENTW        7               // Fit content width of page on screen
-#define FPDFEMB_ZOOM_FITCONTENTH        8               // Fit content height of page on screen
-
-// Data structure for page destination
-struct FPDFEMB_PAGEDEST
-{
-        int                             page_index;             // Zero based index for the page
-        int                             zoom_mode;              // See FPDFEMB_ZOOM_xxx definition above
-        int                             zoom_factor;    // For FPDFEMB_ZOOM_FACTOR only: the zoom factor (in percentage)
-        FPDFEMB_RECT    position;               // Specify position inside the page. Depends on the zoom mode,
-                                                                        // different members of the rectangle are used:
-                                                                        // FPDFEMB_ZOOM_NONE:                   left, top
-                                                                        // FPDFEMB_ZOOM_FACTOR:                 left, top
-                                                                        // FPDFEMB_ZOOM_FITPAGE:                none
-                                                                        // FPDFEMB_ZOOM_FITWIDTH:               top
-                                                                        // FPDFEMB_ZOOM_FITHEIGHT:              left
-                                                                        // FPDFEMB_ZOOM_FITRECT:                left, top, bottom, right
-                                                                        // FPDFEMB_ZOOM_FITCONTENT:             none
-                                                                        // FPDFEMB_ZOOM_FITCONTENTW:    top
-                                                                        // FPDFEMB_ZOOM_FITCONTENTH:    left
-};
-
-// Data structure for document destination
-struct FPDFEMB_DOCDEST
-{
-        FPDFEMB_PAGEDEST        page_data;      // page data
-        char*                           file_name;      // The file name, encoded in original charset (maybe MBCS)
-};
-
-// Data structure for URL destination
-struct FPDFEMB_URLDEST
-{
-        char*                           url;            // URL encoded in 7-bit ASCII
-};
-
-// Data structure for Launch action
-struct FPDFEMB_LAUNCHACTION
-{
-        int                                     new_window;     // Whether a new window should be opened
-        char*                           file_name;      // The file name, encoded in original charset (maybe MBCS)
-};
-
-// Function: FPDFEMB_Action_GetType
-//                      Get type of an action
-// Parameters:
-//                      document        -       Handle to the document
-//                      action          -       Handle to the action
-//                      dest_type       -       Pointer to an integer receiving type of the destination. See the above
-//                                                      FPDFEMB_DEST_xxx definitions
-//                      data_size       -       Pointer to an integer receiving data block size for the destination.
-//                                                      If this parameter is NULL, then data size won't be retrieved.
-// Comments:
-//                      Each different type of destination has different data structure. The "data_size" result
-//                      indicates how many bytes is required to hold the destination data structure. The application
-//                      can then allocate sufficient buffer and then call FPDFEMB_Bookmark_GetDest function to
-//                      get the real data.
-//
-FPDFEMB_RESULT FPDFEMB_Action_GetType(FPDFEMB_DOCUMENT document, FPDFEMB_ACTION action, int* dest_type, int* data_size);
-
-// Function: FPDFEMB_Action_GetData
-//                      Get detailed data of a particular action
-// Parameters:
-//                      document        -       Handle to the document
-//                      action          -       Handle to the action
-//                      buffer          -       Application allocated buffer receiving the destination data
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      See data structure definition for different action type above. Please note
-//                      the actual action data might use more space than the structure definition
-//                      shows, to store things like file name or URL. So you should always call
-//                      FPDFEMB_Action_GetType first to get data size then allocate enough buffer
-//                      for this call.
-//
-FPDFEMB_RESULT FPDFEMB_Action_GetData(FPDFEMB_DOCUMENT document, FPDFEMB_ACTION action, void* buffer);
-
-// Function: FPDFEMB_Action_GetNext
-//                      Get next action in an action chain
-// Parameters:
-//                      document        -       Handle to the document
-//                      action          -       Handle to current action
-//                      next            -       Receiving handle to next action.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      If there is no next action, the "next" parameter will be set to NULL after the function returns.
-//
-FPDFEMB_RESULT FPDFEMB_Action_GetNext(FPDFEMB_ACTION action, FPDFEMB_ACTION* next);
-
-/********************************************************************************************
-****
-****            Bookmark Information
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_BOOKMARK;
-
-// Function: FPDFEMB_Bookmark_GetFirstChild
-//                      Get first child of a bookmark item, or first top level bookmark item
-// Parameters: 
-//                      document        -       Handle to the document
-//                      parent          -       Handle to the parent bookmark. 
-//                                                      Can be NULL if you want to get the first top level item.
-//                      bookmark        -       Receiving handle to the first child or top level bookmark item. 
-//                                                      If result is NULL, then bookmark not found.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetFirstChild(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK parent,
-                                                                                          FPDFEMB_BOOKMARK* bookmark);
-
-// Function: FPDFEMB_Bookmark_GetFirstChild
-//                      Get next sibling of a bookmark item
-// Parameters: 
-//                      document        -       Handle to the document
-//                      bookmark        -       Handle to the bookmark 
-//                      sibling         -       Receiving the handle of next sibling.
-//                                                      If result is NULL, then this is the last bookmark in this level.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetNextSibling(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark,
-                                                                                          FPDFEMB_BOOKMARK* sibling);
-
-// Function: FPDFEMB_Bookmark_GetTitle
-//                      Get title of a bookmark
-// Parameters: 
-//                      bookmark        -       Handle to the bookmark 
-//                      buffer          -       A buffer allocated by the application, or NULL.
-//                      bufsize         -       [IN/OUT] A pointer to a number indicating the buffer size,
-//                                                      before this function call. After return, this place will store
-//                                                      number of bytes used by the output (including terminator).
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      The title is output in Unicode, using UTF-16LE format. It's terminated by
-//                      two consecutive zero bytes.
-//
-//                      If the "buffer" parameter is NULL, then the "bufsize" parameter will receive
-//                      number of bytes required to store the bookmark title (including the two-
-//                      byte terminator).
-//
-//                      If the buffer provided is smaller than the required size, then this function
-//                      will not copy any data, return FPDFEMB_PARAM, and the required buffer size will 
-//                      also be put in "bufsize" parameter.
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetTitle(FPDFEMB_BOOKMARK bookmark, void* buffer, unsigned int* bufsize);
-
-// Function: FPDFEMB_Bookmark_GetPage
-//                      Get page number of a bookmark pointing to
-// Parameters:
-//                      document        -       Handle to the document
-//                      bookmark        -       Handle to the bookmark 
-//                      page            -       Receiving the page number. -1 if this bookmark doesn't actually
-//                                                      point to a page inside the document.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//                      Some bookmark might not point to a page, some bookmark might have more than one destination
-//                      (action), for detailed information about a bookmark, you should call FPDFEMB_Bookmark_GetAction.
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetPage(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark, int* page);
-
-// Function: FPDFEMB_Bookmark_GetAction
-//                      Get action(s) associated with a particular bookmark
-// Parameters:
-//                      document        -       Handle to the document
-//                      bookmark        -       Handle to the bookmark 
-//                      action          -       Receiving handle of first action
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetAction(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark, FPDFEMB_ACTION* action);
-
-/********************************************************************************************
-****
-****            Hyperlink Information
-****
-********************************************************************************************/
-
-// Function: FPDFEMB_Link_GetCount
-//                      Get number of hyperlinks inside a page
-// Parameters:
-//                      page            -       Page handle.
-//                      link_count      -       Pointer to an integer receiving the number of links
-//                      reserved        -       Must be zero now.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      This function must be called before any other link related function can
-//                      be called for the page.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetCount(FPDFEMB_PAGE page, int* link_count, int reserved);
-
-// Function: FPDFEMB_Link_GetAction
-//                      Get action(s) associated with a particular hyperlink
-// Parameters:
-//                      page            -       Page handle
-//                      link_index      -       Zero-based index for the link
-//                      action          -       Receiving handle of first action
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetAction(FPDFEMB_PAGE page, int link_index, FPDFEMB_ACTION* action);
-
-// Function: FPDFEMB_Link_GetAreaCount
-//                      Get number of area (quadrilaterals) for a link
-// Parameters:
-//                      page            -       Page handle
-//                      link_index      -       Zero-based index for the link
-//                      count           -       Pointer to an integer receiving number of quadrilaterals
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetAreaCount(FPDFEMB_PAGE page, int link_index, int* count);
-
-// Function: FPDFEMB_Link_GetArea
-//                      Get a particular quadrilateral for a link
-// Parameters:
-//                      page            -       Page handle
-//                      link_index      -       Zero-based index for the link
-//                      area_index      -       Zero-based index for the quadrilateral
-//                      points          -       Pointer to an array consists 4 points, receiving coordinations
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      The result in "points" array are the X/Y coordinations for the four vertices
-//                      of the quadrilateral. Vertices are in the following order: lower left, lower
-//                      right, upper right, upper left.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetArea(FPDFEMB_PAGE page, int link_index, int area_index, 
-                                                                        FPDFEMB_POINT* points);
-
-/********************************************************************************************
-****
-****            Graphic Output (onto DIB)
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_FONT;
-
-// Function: FPDFEMB_OpenStandardFont
-//                      Get ready to use a standard PDF font
-// Parameters:
-//                      font_name       -       Name of the font. See a list of supported fonts below.
-//                      font_handle     -       Receiving the font handle.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      Currently supported standard fonts:
-//                      Courier, Courier-Bold, Courier-BoldOblique, Courier-Oblique,
-//                      Helvetica, Helvetica-Bold, Helvetica-BoldOblique, Helvetica-Oblique,
-//                      Times-Roman, Times-Bold, Times-Italic, Times-BoldItalic,
-//                      Symbol, ZapfDingbats.
-//
-FPDFEMB_RESULT FPDFEMB_OpenStandardFont(const char* font_name, FPDFEMB_FONT* font_handle);
-
-// Function: FPDFEMB_OpenSystemFont
-//                      Get ready to use a system font
-// Parameters:
-//                      font_name       -       Font name
-//                      charset         -       Charset ID (see above FPDFEMB_CHARSET_xxx constants)
-//                      flags           -       Font flags (see above FPDFEMB_FONT_xxx constants)
-//                      weight          -       Weight of the font. Range from 100 to 900. 400 is normal,
-//                                                      700 is bold.
-//                      font_handle     -       Receiving the font handle.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//                      System font is supported only if either FPDFEMB_SetFontMapper or
-//                      FPDFEMB_SetGlyphProvider is called.
-//                      Font attributes (name, charset, flags and weight) can be all optional, if the
-//                      font mapper or glyph provider doesn't make use of them.
-//
-FPDFEMB_RESULT FPDFEMB_OpenSystemFont(const char* font_name, int charset, unsigned int flags, int weight,
-                                                                          FPDFEMB_FONT* font_handle);
-
-// Function: FPDFEMB_CloseFont
-//                      Close a font handle.
-// Parameters:
-//                      font_handle     -       Handle to the font.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_CloseFont(FPDFEMB_FONT font_handle);
-
-struct FPDFEMB_TEXTMATRIX
-{
-        double  a, b, c, d;
-};
-
-// Function: FPDFEMB_OutputText
-//                      Output text string onto a DIB device.
-// Parameters:
-//                      dib                     -       DIB handle, as the output device
-//                      x, y            -       DIB coordinations for the origin point of the first character.
-//                      font_handle     -       Handle to the font
-//                      font_size       -       Font size in pixels
-//                      matrix          -       Matrix for the text output. Can be NULL.
-//                      text            -       Zero-terminated unicode text string
-//                      argb            -       Color of the text, in 0xaarrggbb format.
-// Return Value:
-//                      Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_OutputText(FPDFEMB_BITMAP dib, int x, int y, FPDFEMB_FONT font_handle, double font_size,
-                                                                  FPDFEMB_TEXTMATRIX* matrix, const FPDFEMB_WCHAR* text, unsigned long argb);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif  // #ifdef _FPDFEMB_H_