mirror of https://github.com/axmolengine/axmol.git
1766 lines
72 KiB
C
1766 lines
72 KiB
C
// 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_
|