mirror/yacreader
1
0
Fork 0
mirror of https://github.com/YACReader/yacreader synced 2026-02-04 22:30:11 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fixed path encoding used for opening PDF files with pdfium.

Browse Source
This commit is contained in:
Luis Ángel San Martín
2017-03-28 22:18:07 +02:00
commit 1459ebb261
1012 changed files with 96766 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
dependencies/pdfium/public/DEPS vendored Normal file
View File

@ -0,0 +1,8 @@
include_rules = [
# public/ needs to be standalone. Explicitly disallow everything.
'-core',
'-fpdfsdk',
'-testing',
'-third_party',
'-v8',
]

13
dependencies/pdfium/public/README vendored Normal file
View File

@ -0,0 +1,13 @@
public/ README
The header files in this directory are the only ones that should ever be
included by an embedder of PDFium. If there arises a need for functionality
beyond what is present here, then a new API must be added here to provide it.
These header files must be entirely contained in this directory; they must
never include other header files from outside of it.
These files must compile cleanly without warnings on both C and C++ compilers.
Changes to these files must be carefully considered to avoid breaking
compatibility.

198
dependencies/pdfium/public/fpdf_dataavail.h vendored Normal file
View File

@ -0,0 +1,198 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_DATAAVAIL_H_
#define PUBLIC_FPDF_DATAAVAIL_H_
#include <stddef.h>
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#define PDF_LINEARIZATION_UNKNOWN -1
#define PDF_NOT_LINEARIZED 0
#define PDF_LINEARIZED 1
#define PDF_DATA_ERROR -1
#define PDF_DATA_NOTAVAIL 0
#define PDF_DATA_AVAIL 1
#define PDF_FORM_ERROR -1
#define PDF_FORM_NOTAVAIL 0
#define PDF_FORM_AVAIL 1
#define PDF_FORM_NOTEXIST 2
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Interface for checking whether sections of the file are available.
typedef struct _FX_FILEAVAIL {
// Version number of the interface. Must be 1.
int version;
// Reports if the specified data section is currently available. A section is
// available if all bytes in the section are available.
//
// Interface Version: 1
// Implementation Required: Yes
//
// pThis - pointer to the interface structure.
// offset - the offset of the data section in the file.
// size - the size of the data section.
//
// Returns true if the specified data section at |offset| of |size|
// is available.
FPDF_BOOL (*IsDataAvail)(struct _FX_FILEAVAIL* pThis,
size_t offset,
size_t size);
} FX_FILEAVAIL;
typedef void* FPDF_AVAIL;
// Create a document availability provider.
//
// file_avail - pointer to file availability interface.
// file - pointer to a file access interface.
//
// Returns a handle to the document availability provider, or NULL on error.
//
// |FPDFAvail_Destroy| must be called when done with the availability provider.
DLLEXPORT FPDF_AVAIL STDCALL FPDFAvail_Create(FX_FILEAVAIL* file_avail,
FPDF_FILEACCESS* file);
// Destroy the |avail| document availability provider.
//
// avail - handle to document availability provider to be destroyed.
DLLEXPORT void STDCALL FPDFAvail_Destroy(FPDF_AVAIL avail);
// Download hints interface. Used to receive hints for further downloading.
typedef struct _FX_DOWNLOADHINTS {
// Version number of the interface. Must be 1.
int version;
// Add a section to be downloaded.
//
// Interface Version: 1
// Implementation Required: Yes
//
// pThis - pointer to the interface structure.
// offset - the offset of the hint reported to be downloaded.
// size - the size of the hint reported to be downloaded.
//
// The |offset| and |size| of the section may not be unique. Part of the
// section might be already available. The download manager must deal with
// overlapping sections.
void (*AddSegment)(struct _FX_DOWNLOADHINTS* pThis,
size_t offset,
size_t size);
} FX_DOWNLOADHINTS;
// Checks if the document is ready for loading, if not, gets download hints.
//
// avail - handle to document availability provider.
// hints - pointer to a download hints interface.
//
// Returns one of:
// PDF_DATA_ERROR: A common error is returned. Data availability unknown.
// PDF_DATA_NOTAVAIL: Data not yet available.
// PDF_DATA_AVAIL: Data available.
//
// Applications should call this function whenever new data arrives, and process
// all the generated download hints, if any, until the function returns
// |PDF_DATA_ERROR| or |PDF_DATA_AVAIL|.
//
// Once all data is available, call |FPDFAvail_GetDocument| to get a document
// handle.
DLLEXPORT int STDCALL
FPDFAvail_IsDocAvail(FPDF_AVAIL avail, FX_DOWNLOADHINTS* hints);
// Get document from the availability provider.
//
// avail - handle to document availability provider.
// password - password for decrypting the PDF file. Optional.
//
// Returns a handle to the document.
//
// When |FPDFAvail_IsDocAvail| returns TRUE, call |FPDFAvail_GetDocument| to
// retrieve the document handle.
DLLEXPORT FPDF_DOCUMENT STDCALL FPDFAvail_GetDocument(FPDF_AVAIL avail,
FPDF_BYTESTRING password);
// Get the page number for the first available page in a linearized PDF.
//
// doc - document handle.
//
// Returns the zero-based index for the first available page.
//
// For most linearized PDFs, the first available page will be the first page,
// however, some PDFs might make another page the first available page.
// For non-linearized PDFs, this function will always return zero.
DLLEXPORT int STDCALL FPDFAvail_GetFirstPageNum(FPDF_DOCUMENT doc);
// Check if |page_index| is ready for loading, if not, get the
// |FX_DOWNLOADHINTS|.
//
// avail - handle to document availability provider.
// page_index - index number of the page. Zero for the first page.
// hints - pointer to a download hints interface. Populated if
// |page_index| is not available.
//
// Returns one of:
// PDF_DATA_ERROR: A common error is returned. Data availability unknown.
// PDF_DATA_NOTAVAIL: Data not yet available.
// PDF_DATA_AVAIL: Data available.
//
// This function can be called only after |FPDFAvail_GetDocument| is called.
// Applications should call this function whenever new data arrives and process
// all the generated download |hints|, if any, until this function returns
// |PDF_DATA_ERROR| or |PDF_DATA_AVAIL|. Applications can then perform page
// loading.
DLLEXPORT int STDCALL FPDFAvail_IsPageAvail(FPDF_AVAIL avail,
int page_index,
FX_DOWNLOADHINTS* hints);
// Check if form data is ready for initialization, if not, get the
// |FX_DOWNLOADHINTS|.
//
// avail - handle to document availability provider.
// hints - pointer to a download hints interface. Populated if form is not
// ready for initialization.
//
// Returns one of:
// PDF_FORM_ERROR: A common eror, in general incorrect parameters.
// PDF_FORM_NOTAVAIL: Data not available.
// PDF_FORM_AVAIL: Data available.
// PDF_FORM_NOTEXIST: No form data.
//
// This function can be called only after |FPDFAvail_GetDocument| is called.
// The application should call this function whenever new data arrives and
// process all the generated download |hints|, if any, until the function
// |PDF_FORM_ERROR|, |PDF_FORM_AVAIL| or |PDF_FORM_NOTEXIST|.
// Applications can then perform page loading. It is recommend to call
// |FPDFDOC_InitFormFillEnvironment| when |PDF_FORM_AVAIL| is returned.
DLLEXPORT int STDCALL FPDFAvail_IsFormAvail(FPDF_AVAIL avail,
FX_DOWNLOADHINTS* hints);
// Check whether a document is a linearized PDF.
//
// avail - handle to document availability provider.
//
// Returns one of:
// PDF_LINEARIZED
// PDF_NOT_LINEARIZED
// PDF_LINEARIZATION_UNKNOWN
//
// |FPDFAvail_IsLinearized| will return |PDF_LINEARIZED| or |PDF_NOT_LINEARIZED|
// when we have 1k of data. If the files size less than 1k, it returns
// |PDF_LINEARIZATION_UNKNOWN| as there is insufficient information to determine
// if the PDF is linearlized.
DLLEXPORT int STDCALL FPDFAvail_IsLinearized(FPDF_AVAIL avail);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_DATAAVAIL_H_

325
dependencies/pdfium/public/fpdf_doc.h vendored Normal file
View File

@ -0,0 +1,325 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_DOC_H_
#define PUBLIC_FPDF_DOC_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Unsupported action type.
#define PDFACTION_UNSUPPORTED 0
// Go to a destination within current document.
#define PDFACTION_GOTO 1
// Go to a destination within another document.
#define PDFACTION_REMOTEGOTO 2
// URI, including web pages and other Internet resources.
#define PDFACTION_URI 3
// Launch an application or open a file.
#define PDFACTION_LAUNCH 4
typedef struct _FS_QUADPOINTSF {
FS_FLOAT x1;
FS_FLOAT y1;
FS_FLOAT x2;
FS_FLOAT y2;
FS_FLOAT x3;
FS_FLOAT y3;
FS_FLOAT x4;
FS_FLOAT y4;
} FS_QUADPOINTSF;
// Get the first child of |bookmark|, or the first top-level bookmark item.
//
// document - handle to the document.
// bookmark - handle to the current bookmark. Pass NULL for the first top
// level item.
//
// Returns a handle to the first child of |bookmark| or the first top-level
// bookmark item. NULL if no child or top-level bookmark found.
DLLEXPORT FPDF_BOOKMARK STDCALL
FPDFBookmark_GetFirstChild(FPDF_DOCUMENT document, FPDF_BOOKMARK bookmark);
// Get the next sibling of |bookmark|.
//
// document - handle to the document.
// bookmark - handle to the current bookmark.
//
// Returns a handle to the next sibling of |bookmark|, or NULL if this is the
// last bookmark at this level.
DLLEXPORT FPDF_BOOKMARK STDCALL
FPDFBookmark_GetNextSibling(FPDF_DOCUMENT document, FPDF_BOOKMARK bookmark);
// Get the title of |bookmark|.
//
// bookmark - handle to the bookmark.
// buffer - buffer for the title. May be NULL.
// buflen - the length of the buffer in bytes. May be 0.
//
// Returns the number of bytes in the title, including the terminating NUL
// character. The number of bytes is returned regardless of the |buffer| and
// |buflen| parameters.
//
// Regardless of the platform, the |buffer| is always in UTF-16LE encoding. The
// string is terminated by a UTF16 NUL character. If |buflen| is less than the
// required length, or |buffer| is NULL, |buffer| will not be modified.
DLLEXPORT unsigned long STDCALL FPDFBookmark_GetTitle(FPDF_BOOKMARK bookmark,
void* buffer,
unsigned long buflen);
// Find the bookmark with |title| in |document|.
//
// document - handle to the document.
// title - the UTF-16LE encoded Unicode title for which to search.
//
// Returns the handle to the bookmark, or NULL if |title| can't be found.
//
// |FPDFBookmark_Find| will always return the first bookmark found even if
// multiple bookmarks have the same |title|.
DLLEXPORT FPDF_BOOKMARK STDCALL FPDFBookmark_Find(FPDF_DOCUMENT document,
FPDF_WIDESTRING title);
// Get the destination associated with |bookmark|.
//
// document - handle to the document.
// bookmark - handle to the bookmark.
//
// Returns the handle to the destination data, NULL if no destination is
// associated with |bookmark|.
DLLEXPORT FPDF_DEST STDCALL FPDFBookmark_GetDest(FPDF_DOCUMENT document,
FPDF_BOOKMARK bookmark);
// Get the action associated with |bookmark|.
//
// bookmark - handle to the bookmark.
//
// Returns the handle to the action data, or NULL if no action is associated
// with |bookmark|. When NULL is returned, |FPDFBookmark_GetDest| should be
// called to get the |bookmark| destination data.
DLLEXPORT FPDF_ACTION STDCALL FPDFBookmark_GetAction(FPDF_BOOKMARK bookmark);
// Get the type of |action|.
//
// action - handle to the action.
//
// Returns one of:
// PDFACTION_UNSUPPORTED
// PDFACTION_GOTO
// PDFACTION_REMOTEGOTO
// PDFACTION_URI
// PDFACTION_LAUNCH
DLLEXPORT unsigned long STDCALL FPDFAction_GetType(FPDF_ACTION action);
// Get the destination of |action|.
//
// document - handle to the document.
// action - handle to the action. |action| must be a |PDFACTION_GOTO| or
// |PDFACTION_REMOTEGOTO|.
//
// Returns a handle to the destination data.
//
// In the case of |PDFACTION_REMOTEGOTO|, you should first call
// |FPDFAction_GetFilePath| then load that document, the document handle from
// that document should pass as |document| to |FPDFAction_GetDest|.
DLLEXPORT FPDF_DEST STDCALL FPDFAction_GetDest(FPDF_DOCUMENT document,
FPDF_ACTION action);
// Get file path of a |PDFACTION_REMOTEGOTO| |action|.
//
// action - handle to the action. |action| must be a |PDFACTION_LAUNCH| or
// |PDFACTION_REMOTEGOTO|
// buffer - a buffer for output the path string. May be NULL.
// buflen - the length of the buffer, in bytes. May be 0.
//
// Returns the number of bytes in the file path, including the trailing UTF16
// NUL character.
//
// Regardless of the platform, the |buffer| is always in UTF-16LE encoding.
// If |buflen| is less than the returned length, or |buffer| is NULL, |buffer|
// will not be modified.
DLLEXPORT unsigned long STDCALL
FPDFAction_GetFilePath(FPDF_ACTION action, void* buffer, unsigned long buflen);
// Get the URI path of a |PDFACTION_URI| |action|.
//
// document - handle to the document.
// action - handle to the action. Must be a |PDFACTION_URI|.
// buffer - a buffer for the path string. May be NULL.
// buflen - the length of the buffer, in bytes. May be 0.
//
// Returns the number of bytes in the URI path, including trailing zeros.
//
// The |buffer| is always encoded in 7-bit ASCII. If |buflen| is less than the
// returned length, or |buffer| is NULL, |buffer| will not be modified.
DLLEXPORT unsigned long STDCALL FPDFAction_GetURIPath(FPDF_DOCUMENT document,
FPDF_ACTION action,
void* buffer,
unsigned long buflen);
// Get the page index of |dest|.
//
// document - handle to the document.
// dest - handle to the destination.
//
// Returns the page index containing |dest|. Page indices start from 0.
DLLEXPORT unsigned long STDCALL FPDFDest_GetPageIndex(FPDF_DOCUMENT document,
FPDF_DEST dest);
// Get the (x, y, zoom) location of |dest| in the destination page, if the
// destination is in [page /XYZ x y zoom] syntax.
//
// dest - handle to the destination.
// hasXVal - out parameter; true if the x value is not null
// hasYVal - out parameter; true if the y value is not null
// hasZoomVal - out parameter; true if the zoom value is not null
// x - out parameter; the x coordinate, in page coordinates.
// y - out parameter; the y coordinate, in page coordinates.
// zoom - out parameter; the zoom value.
// Returns TRUE on successfully reading the /XYZ value.
//
// Note the [x, y, zoom] values are only set if the corresponding hasXVal,
// hasYVal or hasZoomVal flags are true.
DLLEXPORT FPDF_BOOL STDCALL FPDFDest_GetLocationInPage(FPDF_DEST dest,
FPDF_BOOL* hasXCoord,
FPDF_BOOL* hasYCoord,
FPDF_BOOL* hasZoom,
FS_FLOAT* x,
FS_FLOAT* y,
FS_FLOAT* zoom);
// Find a link at point (|x|,|y|) on |page|.
//
// page - handle to the document page.
// x - the x coordinate, in the page coordinate system.
// y - the y coordinate, in the page coordinate system.
//
// Returns a handle to the link, or NULL if no link found at the given point.
//
// You can convert coordinates from screen coordinates to page coordinates using
// |FPDF_DeviceToPage|.
DLLEXPORT FPDF_LINK STDCALL FPDFLink_GetLinkAtPoint(FPDF_PAGE page,
double x,
double y);
// Find the Z-order of link at point (|x|,|y|) on |page|.
//
// page - handle to the document page.
// x - the x coordinate, in the page coordinate system.
// y - the y coordinate, in the page coordinate system.
//
// Returns the Z-order of the link, or -1 if no link found at the given point.
// Larger Z-order numbers are closer to the front.
//
// You can convert coordinates from screen coordinates to page coordinates using
// |FPDF_DeviceToPage|.
DLLEXPORT int STDCALL
FPDFLink_GetLinkZOrderAtPoint(FPDF_PAGE page, double x, double y);
// Get destination info for |link|.
//
// document - handle to the document.
// link - handle to the link.
//
// Returns a handle to the destination, or NULL if there is no destination
// associated with the link. In this case, you should call |FPDFLink_GetAction|
// to retrieve the action associated with |link|.
DLLEXPORT FPDF_DEST STDCALL FPDFLink_GetDest(FPDF_DOCUMENT document,
FPDF_LINK link);
// Get action info for |link|.
//
// link - handle to the link.
//
// Returns a handle to the action associated to |link|, or NULL if no action.
DLLEXPORT FPDF_ACTION STDCALL FPDFLink_GetAction(FPDF_LINK link);
// Enumerates all the link annotations in |page|.
//
// page - handle to the page.
// startPos - the start position, should initially be 0 and is updated with
// the next start position on return.
// linkAnnot - the link handle for |startPos|.
//
// Returns TRUE on success.
DLLEXPORT FPDF_BOOL STDCALL FPDFLink_Enumerate(FPDF_PAGE page,
int* startPos,
FPDF_LINK* linkAnnot);
// Get the rectangle for |linkAnnot|.
//
// linkAnnot - handle to the link annotation.
// rect - the annotation rectangle.
//
// Returns true on success.
DLLEXPORT FPDF_BOOL STDCALL FPDFLink_GetAnnotRect(FPDF_LINK linkAnnot,
FS_RECTF* rect);
// Get the count of quadrilateral points to the |linkAnnot|.
//
// linkAnnot - handle to the link annotation.
//
// Returns the count of quadrilateral points.
DLLEXPORT int STDCALL FPDFLink_CountQuadPoints(FPDF_LINK linkAnnot);
// Get the quadrilateral points for the specified |quadIndex| in |linkAnnot|.
//
// linkAnnot - handle to the link annotation.
// quadIndex - the specified quad point index.
// quadPoints - receives the quadrilateral points.
//
// Returns true on success.
DLLEXPORT FPDF_BOOL STDCALL FPDFLink_GetQuadPoints(FPDF_LINK linkAnnot,
int quadIndex,
FS_QUADPOINTSF* quadPoints);
// Get meta-data |tag| content from |document|.
//
// document - handle to the document.
// tag - the tag to retrieve. The tag can be one of:
// Title, Author, Subject, Keywords, Creator, Producer,
// CreationDate, or ModDate.
// For detailed explanations of these tags and their respective
// values, please refer to PDF Reference 1.6, section 10.2.1,
// 'Document Information Dictionary'.
// buffer - a buffer for the tag. May be NULL.
// buflen - the length of the buffer, in bytes. May be 0.
//
// Returns the number of bytes in the tag, including trailing zeros.
//
// The |buffer| is always encoded in UTF-16LE. The |buffer| is followed by two
// bytes of zeros indicating the end of the string. If |buflen| is less than
// the returned length, or |buffer| is NULL, |buffer| will not be modified.
DLLEXPORT unsigned long STDCALL FPDF_GetMetaText(FPDF_DOCUMENT document,
FPDF_BYTESTRING tag,
void* buffer,
unsigned long buflen);
// Get the page label for |page_index| from |document|.
//
// document - handle to the document.
// page_index - the 0-based index of the page.
// buffer - a buffer for the page label. May be NULL.
// buflen - the length of the buffer, in bytes. May be 0.
//
// Returns the number of bytes in the page label, including trailing zeros.
//
// The |buffer| is always encoded in UTF-16LE. The |buffer| is followed by two
// bytes of zeros indicating the end of the string. If |buflen| is less than
// the returned length, or |buffer| is NULL, |buffer| will not be modified.
DLLEXPORT unsigned long STDCALL FPDF_GetPageLabel(FPDF_DOCUMENT document,
int page_index,
void* buffer,
unsigned long buflen);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_DOC_H_

267
dependencies/pdfium/public/fpdf_edit.h vendored Normal file
View File

@ -0,0 +1,267 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_EDIT_H_
#define PUBLIC_FPDF_EDIT_H_
#include <stdint.h>
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#define FPDF_ARGB(a, r, g, b) \
((uint32_t)(((uint32_t)(b)&0xff) | (((uint32_t)(g)&0xff) << 8) | \
(((uint32_t)(r)&0xff) << 16) | (((uint32_t)(a)&0xff) << 24)))
#define FPDF_GetBValue(argb) ((uint8_t)(argb))
#define FPDF_GetGValue(argb) ((uint8_t)(((uint16_t)(argb)) >> 8))
#define FPDF_GetRValue(argb) ((uint8_t)((argb) >> 16))
#define FPDF_GetAValue(argb) ((uint8_t)((argb) >> 24))
// The page object constants.
#define FPDF_PAGEOBJ_TEXT 1
#define FPDF_PAGEOBJ_PATH 2
#define FPDF_PAGEOBJ_IMAGE 3
#define FPDF_PAGEOBJ_SHADING 4
#define FPDF_PAGEOBJ_FORM 5
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Create a new PDF document.
//
// Returns a handle to a new document, or NULL on failure.
DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_CreateNewDocument();
// Create a new PDF page.
//
// document - handle to document.
// page_index - suggested index of the page to create. If it is larger than
// document's current last index(L), the created page index is
// the next available index -- L+1.
// width - the page width.
// height - the page height.
//
// Returns the handle to the new page.
//
// The page should be closed with CPDF_ClosePage() when finished as
// with any other page in the document.
DLLEXPORT FPDF_PAGE STDCALL FPDFPage_New(FPDF_DOCUMENT document,
int page_index,
double width,
double height);
// Delete the page at |page_index|.
//
// document - handle to document.
// page_index - the index of the page to delete.
DLLEXPORT void STDCALL FPDFPage_Delete(FPDF_DOCUMENT document, int page_index);
// Get the rotation of |page|.
//
// page - handle to a page
//
// Returns one of the following indicating the page rotation:
// 0 - No rotation.
// 1 - Rotated 90 degrees clockwise.
// 2 - Rotated 180 degrees clockwise.
// 3 - Rotated 270 degrees clockwise.
DLLEXPORT int STDCALL FPDFPage_GetRotation(FPDF_PAGE page);
// Set rotation for |page|.
//
// page - handle to a page.
// rotate - the rotation value, one of:
// 0 - No rotation.
// 1 - Rotated 90 degrees clockwise.
// 2 - Rotated 180 degrees clockwise.
// 3 - Rotated 270 degrees clockwise.
DLLEXPORT void STDCALL FPDFPage_SetRotation(FPDF_PAGE page, int rotate);
// Insert |page_obj| into |page|.
//
// page - handle to a page
// page_obj - handle to a page object. The |page_obj| will be automatically
// freed.
DLLEXPORT void STDCALL FPDFPage_InsertObject(FPDF_PAGE page,
FPDF_PAGEOBJECT page_obj);
// Get number of page objects inside |page|.
//
// page - handle to a page.
//
// Returns the number of objects in |page|.
DLLEXPORT int STDCALL FPDFPage_CountObject(FPDF_PAGE page);
// Get object in |page| at |index|.
//
// page - handle to a page.
// index - the index of a page object.
//
// Returns the handle to the page object, or NULL on failed.
DLLEXPORT FPDF_PAGEOBJECT STDCALL FPDFPage_GetObject(FPDF_PAGE page, int index);
// Checks if |page| contains transparency.
//
// page - handle to a page.
//
// Returns TRUE if |page| contains transparency.
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_HasTransparency(FPDF_PAGE page);
// Generate the content of |page|.
//
// page - handle to a page.
//
// Returns TRUE on success.
//
// Before you save the page to a file, or reload the page, you must call
// |FPDFPage_GenerateContent| or any changes to |page| will be lost.
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_GenerateContent(FPDF_PAGE page);
// Checks if |pageObject| contains transparency.
//
// pageObject - handle to a page object.
//
// Returns TRUE if |pageObject| contains transparency.
DLLEXPORT FPDF_BOOL STDCALL
FPDFPageObj_HasTransparency(FPDF_PAGEOBJECT pageObject);
// Transform |pageObject| by the given matrix.
//
// page_object - handle to a page object.
// a - matrix value.
// b - matrix value.
// c - matrix value.
// d - matrix value.
// e - matrix value.
// f - matrix value.
//
// The matrix is composed as:
// |a c e|
// |b d f|
// and can be used to scale, rotate, shear and translate the |page_object|.
DLLEXPORT void STDCALL FPDFPageObj_Transform(FPDF_PAGEOBJECT page_object,
double a,
double b,
double c,
double d,
double e,
double f);
// Transform all annotations in |page|.
//
// page - handle to a page.
// a - matrix value.
// b - matrix value.
// c - matrix value.
// d - matrix value.
// e - matrix value.
// f - matrix value.
//
// The matrix is composed as:
// |a c e|
// |b d f|
// and can be used to scale, rotate, shear and translate the |page| annotations.
DLLEXPORT void STDCALL FPDFPage_TransformAnnots(FPDF_PAGE page,
double a,
double b,
double c,
double d,
double e,
double f);
// Create a new image object.
//
// document - handle to a document.
//
// Returns a handle to a new image object.
DLLEXPORT FPDF_PAGEOBJECT STDCALL
FPDFPageObj_NewImgeObj(FPDF_DOCUMENT document);
// Load an image from a JPEG image file and then set it into |image_object|.
//
// pages - pointer to the start of all loaded pages, may be NULL.
// nCount - number of |pages|, may be 0.
// image_object - handle to an image object.
// fileAccess - file access handler which specifies the JPEG image file.
//
// Returns TRUE on success.
//
// The image object might already have an associated image, which is shared and
// cached by the loaded pages. In that case, we need to clear the cached image
// for all the loaded pages. Pass |pages| and page count (|nCount|) to this API
// to clear the image cache. If the image is not previously shared, or NULL is a
// valid |pages| value.
DLLEXPORT FPDF_BOOL STDCALL
FPDFImageObj_LoadJpegFile(FPDF_PAGE* pages,
int nCount,
FPDF_PAGEOBJECT image_object,
FPDF_FILEACCESS* fileAccess);
// Load an image from a JPEG image file and then set it into |image_object|.
//
// pages - pointer to the start of all loaded pages, may be NULL.
// nCount - number of |pages|, may be 0.
// image_object - handle to an image object.
// fileAccess - file access handler which specifies the JPEG image file.
//
// Returns TRUE on success.
//
// The image object might already have an associated image, which is shared and
// cached by the loaded pages. In that case, we need to clear the cached image
// for all the loaded pages. Pass |pages| and page count (|nCount|) to this API
// to clear the image cache. If the image is not previously shared, or NULL is a
// valid |pages| value. This function loads the JPEG image inline, so the image
// content is copied to the file. This allows |fileAccess| and its associated
// data to be deleted after this function returns.
DLLEXPORT FPDF_BOOL STDCALL
FPDFImageObj_LoadJpegFileInline(FPDF_PAGE* pages,
int nCount,
FPDF_PAGEOBJECT image_object,
FPDF_FILEACCESS* fileAccess);
// Set the transform matrix of |image_object|.
//
// image_object - handle to an image object.
// a - matrix value.
// b - matrix value.
// c - matrix value.
// d - matrix value.
// e - matrix value.
// f - matrix value.
//
// The matrix is composed as:
// |a c e|
// |b d f|
// and can be used to scale, rotate, shear and translate the |page| annotations.
//
// Returns TRUE on success.
DLLEXPORT FPDF_BOOL STDCALL FPDFImageObj_SetMatrix(FPDF_PAGEOBJECT image_object,
double a,
double b,
double c,
double d,
double e,
double f);
// Set |bitmap| to |image_object|.
//
// pages - pointer to the start of all loaded pages, may be NULL.
// nCount - number of |pages|, may be 0.
// image_object - handle to an image object.
// bitmap - handle of the bitmap.
//
// Returns TRUE on success.
DLLEXPORT FPDF_BOOL STDCALL FPDFImageObj_SetBitmap(FPDF_PAGE* pages,
int nCount,
FPDF_PAGEOBJECT image_object,
FPDF_BITMAP bitmap);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_EDIT_H_

98
dependencies/pdfium/public/fpdf_ext.h vendored Normal file
View File

@ -0,0 +1,98 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_EXT_H_
#define PUBLIC_FPDF_EXT_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Unsupported XFA form.
#define FPDF_UNSP_DOC_XFAFORM 1
// Unsupported portable collection.
#define FPDF_UNSP_DOC_PORTABLECOLLECTION 2
// Unsupported attachment.
#define FPDF_UNSP_DOC_ATTACHMENT 3
// Unsupported security.
#define FPDF_UNSP_DOC_SECURITY 4
// Unsupported shared review.
#define FPDF_UNSP_DOC_SHAREDREVIEW 5
// Unsupported shared form, acrobat.
#define FPDF_UNSP_DOC_SHAREDFORM_ACROBAT 6
// Unsupported shared form, filesystem.
#define FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM 7
// Unsupported shared form, email.
#define FPDF_UNSP_DOC_SHAREDFORM_EMAIL 8
// Unsupported 3D annotation.
#define FPDF_UNSP_ANNOT_3DANNOT 11
// Unsupported movie annotation.
#define FPDF_UNSP_ANNOT_MOVIE 12
// Unsupported sound annotation.
#define FPDF_UNSP_ANNOT_SOUND 13
// Unsupported screen media annotation.
#define FPDF_UNSP_ANNOT_SCREEN_MEDIA 14
// Unsupported screen rich media annotation.
#define FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA 15
// Unsupported attachment annotation.
#define FPDF_UNSP_ANNOT_ATTACHMENT 16
// Unsupported signature annotation.
#define FPDF_UNSP_ANNOT_SIG 17
// Interface for unsupported feature notifications.
typedef struct _UNSUPPORT_INFO {
// Version number of the interface. Must be 1.
int version;
// Unsupported object notification function.
// Interface Version: 1
// Implementation Required: Yes
//
// pThis - pointer to the interface structure.
// nType - the type of unsupported object. One of the |FPDF_UNSP_*| entries.
void (*FSDK_UnSupport_Handler)(struct _UNSUPPORT_INFO* pThis, int nType);
} UNSUPPORT_INFO;
// Setup an unsupported object handler.
//
// unsp_info - Pointer to an UNSUPPORT_INFO structure.
//
// Returns TRUE on success.
DLLEXPORT FPDF_BOOL STDCALL
FSDK_SetUnSpObjProcessHandler(UNSUPPORT_INFO* unsp_info);
// Unknown page mode.
#define PAGEMODE_UNKNOWN -1
// Document outline, and thumbnails hidden.
#define PAGEMODE_USENONE 0
// Document outline visible.
#define PAGEMODE_USEOUTLINES 1
// Thumbnail images visible.
#define PAGEMODE_USETHUMBS 2
// Full-screen mode, no menu bar, window controls, or other decorations visible.
#define PAGEMODE_FULLSCREEN 3
// Optional content group panel visible.
#define PAGEMODE_USEOC 4
// Attachments panel visible.
#define PAGEMODE_USEATTACHMENTS 5
// Get the document's PageMode.
//
// doc - Handle to document.
//
// Returns one of the |PAGEMODE_*| flags defined above.
//
// The page mode defines how the document should be initially displayed.
DLLEXPORT int STDCALL FPDFDoc_GetPageMode(FPDF_DOCUMENT document);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_EXT_H_

44
dependencies/pdfium/public/fpdf_flatten.h vendored Normal file
View File

@ -0,0 +1,44 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_FLATTEN_H_
#define PUBLIC_FPDF_FLATTEN_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
// Flatten operation failed.
#define FLATTEN_FAIL 0
// Flatten operation succeed.
#define FLATTEN_SUCCESS 1
// Nothing to be flattened.
#define FLATTEN_NOTHINGTODO 2
// Flatten for normal display.
#define FLAT_NORMALDISPLAY 0
// Flatten for print.
#define FLAT_PRINT 1
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Flatten annotations and form fields into the page contents.
//
// page - handle to the page.
// nFlag - One of the |FLAT_*| values denoting the page usage.
//
// Returns one of the |FLATTEN_*| values.
//
// Currently, all failures return |FLATTEN_FAIL| with no indication of the
// cause.
DLLEXPORT int STDCALL FPDFPage_Flatten(FPDF_PAGE page, int nFlag);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_FLATTEN_H_

1764
dependencies/pdfium/public/fpdf_formfill.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

284
dependencies/pdfium/public/fpdf_fwlevent.h vendored Normal file
View File

@ -0,0 +1,284 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_FWLEVENT_H_
#define PUBLIC_FPDF_FWLEVENT_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef int FPDF_INT32;
typedef unsigned int FPDF_UINT32;
typedef float FPDF_FLOAT;
// Event types.
typedef enum {
FWL_EVENTTYPE_Mouse = 0,
FWL_EVENTTYPE_MouseWheel,
FWL_EVENTTYPE_Key,
} FWL_EVENTTYPE;
// Key flags.
typedef enum {
FWL_EVENTFLAG_ShiftKey = 1 << 0,
FWL_EVENTFLAG_ControlKey = 1 << 1,
FWL_EVENTFLAG_AltKey = 1 << 2,
FWL_EVENTFLAG_MetaKey = 1 << 3,
FWL_EVENTFLAG_KeyPad = 1 << 4,
FWL_EVENTFLAG_AutoRepeat = 1 << 5,
FWL_EVENTFLAG_LeftButtonDown = 1 << 6,
FWL_EVENTFLAG_MiddleButtonDown = 1 << 7,
FWL_EVENTFLAG_RightButtonDown = 1 << 8,
} FWL_EVENTFLAG;
// Mouse messages.
typedef enum {
FWL_EVENTMOUSECMD_LButtonDown = 1,
FWL_EVENTMOUSECMD_LButtonUp,
FWL_EVENTMOUSECMD_LButtonDblClk,
FWL_EVENTMOUSECMD_RButtonDown,
FWL_EVENTMOUSECMD_RButtonUp,
FWL_EVENTMOUSECMD_RButtonDblClk,
FWL_EVENTMOUSECMD_MButtonDown,
FWL_EVENTMOUSECMD_MButtonUp,
FWL_EVENTMOUSECMD_MButtonDblClk,
FWL_EVENTMOUSECMD_MouseMove,
FWL_EVENTMOUSECMD_MouseEnter,
FWL_EVENTMOUSECMD_MouseHover,
FWL_EVENTMOUSECMD_MouseLeave,
} FWL_EVENT_MOUSECMD;
// Mouse events.
struct FWL_EVENT_MOUSE {
FPDF_UINT32 command;
FPDF_DWORD flag;
FPDF_FLOAT x;
FPDF_FLOAT y;
};
// Mouse wheel events.
struct FWL_EVENT_MOUSEWHEEL {
FPDF_DWORD flag;
FPDF_FLOAT x;
FPDF_FLOAT y;
FPDF_FLOAT deltaX;
FPDF_FLOAT deltaY;
};
// Virtual keycodes.
typedef enum {
FWL_VKEY_Back = 0x08,
FWL_VKEY_Tab = 0x09,
FWL_VKEY_NewLine = 0x0A,
FWL_VKEY_Clear = 0x0C,
FWL_VKEY_Return = 0x0D,
FWL_VKEY_Shift = 0x10,
FWL_VKEY_Control = 0x11,
FWL_VKEY_Menu = 0x12,
FWL_VKEY_Pause = 0x13,
FWL_VKEY_Capital = 0x14,
FWL_VKEY_Kana = 0x15,
FWL_VKEY_Hangul = 0x15,
FWL_VKEY_Junja = 0x17,
FWL_VKEY_Final = 0x18,
FWL_VKEY_Hanja = 0x19,
FWL_VKEY_Kanji = 0x19,
FWL_VKEY_Escape = 0x1B,
FWL_VKEY_Convert = 0x1C,
FWL_VKEY_NonConvert = 0x1D,
FWL_VKEY_Accept = 0x1E,
FWL_VKEY_ModeChange = 0x1F,
FWL_VKEY_Space = 0x20,
FWL_VKEY_Prior = 0x21,
FWL_VKEY_Next = 0x22,
FWL_VKEY_End = 0x23,
FWL_VKEY_Home = 0x24,
FWL_VKEY_Left = 0x25,
FWL_VKEY_Up = 0x26,
FWL_VKEY_Right = 0x27,
FWL_VKEY_Down = 0x28,
FWL_VKEY_Select = 0x29,
FWL_VKEY_Print = 0x2A,
FWL_VKEY_Execute = 0x2B,
FWL_VKEY_Snapshot = 0x2C,
FWL_VKEY_Insert = 0x2D,
FWL_VKEY_Delete = 0x2E,
FWL_VKEY_Help = 0x2F,
FWL_VKEY_0 = 0x30,
FWL_VKEY_1 = 0x31,
FWL_VKEY_2 = 0x32,
FWL_VKEY_3 = 0x33,
FWL_VKEY_4 = 0x34,
FWL_VKEY_5 = 0x35,
FWL_VKEY_6 = 0x36,
FWL_VKEY_7 = 0x37,
FWL_VKEY_8 = 0x38,
FWL_VKEY_9 = 0x39,
FWL_VKEY_A = 0x41,
FWL_VKEY_B = 0x42,
FWL_VKEY_C = 0x43,
FWL_VKEY_D = 0x44,
FWL_VKEY_E = 0x45,
FWL_VKEY_F = 0x46,
FWL_VKEY_G = 0x47,
FWL_VKEY_H = 0x48,
FWL_VKEY_I = 0x49,
FWL_VKEY_J = 0x4A,
FWL_VKEY_K = 0x4B,
FWL_VKEY_L = 0x4C,
FWL_VKEY_M = 0x4D,
FWL_VKEY_N = 0x4E,
FWL_VKEY_O = 0x4F,
FWL_VKEY_P = 0x50,
FWL_VKEY_Q = 0x51,
FWL_VKEY_R = 0x52,
FWL_VKEY_S = 0x53,
FWL_VKEY_T = 0x54,
FWL_VKEY_U = 0x55,
FWL_VKEY_V = 0x56,
FWL_VKEY_W = 0x57,
FWL_VKEY_X = 0x58,
FWL_VKEY_Y = 0x59,
FWL_VKEY_Z = 0x5A,
FWL_VKEY_LWin = 0x5B,
FWL_VKEY_Command = 0x5B,
FWL_VKEY_RWin = 0x5C,
FWL_VKEY_Apps = 0x5D,
FWL_VKEY_Sleep = 0x5F,
FWL_VKEY_NumPad0 = 0x60,
FWL_VKEY_NumPad1 = 0x61,
FWL_VKEY_NumPad2 = 0x62,
FWL_VKEY_NumPad3 = 0x63,
FWL_VKEY_NumPad4 = 0x64,
FWL_VKEY_NumPad5 = 0x65,
FWL_VKEY_NumPad6 = 0x66,
FWL_VKEY_NumPad7 = 0x67,
FWL_VKEY_NumPad8 = 0x68,
FWL_VKEY_NumPad9 = 0x69,
FWL_VKEY_Multiply = 0x6A,
FWL_VKEY_Add = 0x6B,
FWL_VKEY_Separator = 0x6C,
FWL_VKEY_Subtract = 0x6D,
FWL_VKEY_Decimal = 0x6E,
FWL_VKEY_Divide = 0x6F,
FWL_VKEY_F1 = 0x70,
FWL_VKEY_F2 = 0x71,
FWL_VKEY_F3 = 0x72,
FWL_VKEY_F4 = 0x73,
FWL_VKEY_F5 = 0x74,
FWL_VKEY_F6 = 0x75,
FWL_VKEY_F7 = 0x76,
FWL_VKEY_F8 = 0x77,
FWL_VKEY_F9 = 0x78,
FWL_VKEY_F10 = 0x79,
FWL_VKEY_F11 = 0x7A,
FWL_VKEY_F12 = 0x7B,
FWL_VKEY_F13 = 0x7C,
FWL_VKEY_F14 = 0x7D,
FWL_VKEY_F15 = 0x7E,
FWL_VKEY_F16 = 0x7F,
FWL_VKEY_F17 = 0x80,
FWL_VKEY_F18 = 0x81,
FWL_VKEY_F19 = 0x82,
FWL_VKEY_F20 = 0x83,
FWL_VKEY_F21 = 0x84,
FWL_VKEY_F22 = 0x85,
FWL_VKEY_F23 = 0x86,
FWL_VKEY_F24 = 0x87,
FWL_VKEY_NunLock = 0x90,
FWL_VKEY_Scroll = 0x91,
FWL_VKEY_LShift = 0xA0,
FWL_VKEY_RShift = 0xA1,
FWL_VKEY_LControl = 0xA2,
FWL_VKEY_RControl = 0xA3,
FWL_VKEY_LMenu = 0xA4,
FWL_VKEY_RMenu = 0xA5,
FWL_VKEY_BROWSER_Back = 0xA6,
FWL_VKEY_BROWSER_Forward = 0xA7,
FWL_VKEY_BROWSER_Refresh = 0xA8,
FWL_VKEY_BROWSER_Stop = 0xA9,
FWL_VKEY_BROWSER_Search = 0xAA,
FWL_VKEY_BROWSER_Favorites = 0xAB,
FWL_VKEY_BROWSER_Home = 0xAC,
FWL_VKEY_VOLUME_Mute = 0xAD,
FWL_VKEY_VOLUME_Down = 0xAE,
FWL_VKEY_VOLUME_Up = 0xAF,
FWL_VKEY_MEDIA_NEXT_Track = 0xB0,
FWL_VKEY_MEDIA_PREV_Track = 0xB1,
FWL_VKEY_MEDIA_Stop = 0xB2,
FWL_VKEY_MEDIA_PLAY_Pause = 0xB3,
FWL_VKEY_MEDIA_LAUNCH_Mail = 0xB4,
FWL_VKEY_MEDIA_LAUNCH_MEDIA_Select = 0xB5,
FWL_VKEY_MEDIA_LAUNCH_APP1 = 0xB6,
FWL_VKEY_MEDIA_LAUNCH_APP2 = 0xB7,
FWL_VKEY_OEM_1 = 0xBA,
FWL_VKEY_OEM_Plus = 0xBB,
FWL_VKEY_OEM_Comma = 0xBC,
FWL_VKEY_OEM_Minus = 0xBD,
FWL_VKEY_OEM_Period = 0xBE,
FWL_VKEY_OEM_2 = 0xBF,
FWL_VKEY_OEM_3 = 0xC0,
FWL_VKEY_OEM_4 = 0xDB,
FWL_VKEY_OEM_5 = 0xDC,
FWL_VKEY_OEM_6 = 0xDD,
FWL_VKEY_OEM_7 = 0xDE,
FWL_VKEY_OEM_8 = 0xDF,
FWL_VKEY_OEM_102 = 0xE2,
FWL_VKEY_ProcessKey = 0xE5,
FWL_VKEY_Packet = 0xE7,
FWL_VKEY_Attn = 0xF6,
FWL_VKEY_Crsel = 0xF7,
FWL_VKEY_Exsel = 0xF8,
FWL_VKEY_Ereof = 0xF9,
FWL_VKEY_Play = 0xFA,
FWL_VKEY_Zoom = 0xFB,
FWL_VKEY_NoName = 0xFC,
FWL_VKEY_PA1 = 0xFD,
FWL_VKEY_OEM_Clear = 0xFE,
FWL_VKEY_Unknown = 0,
} FWL_VKEYCODE;
// Key event commands.
typedef enum {
FWL_EVENTKEYCMD_KeyDown = 1,
FWL_EVENTKEYCMD_KeyUp,
FWL_EVENTKEYCMD_Char,
} FWL_EVENTKEYCMD;
// Key events.
struct FWL_EVENT_KEY {
FPDF_UINT32 command;
FPDF_DWORD flag;
union {
// Virtual key code.
FPDF_UINT32 vkcode;
// Character code.
FPDF_DWORD charcode;
} code;
};
// Event types.
struct FWL_EVENT {
// Structure size.
FPDF_UINT32 size;
// FWL_EVENTTYPE.
FPDF_UINT32 type;
union {
struct FWL_EVENT_MOUSE mouse;
struct FWL_EVENT_MOUSEWHEEL wheel;
struct FWL_EVENT_KEY key;
} s;
};
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_FWLEVENT_H_

44
dependencies/pdfium/public/fpdf_ppo.h vendored Normal file
View File

@ -0,0 +1,44 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_PPO_H_
#define PUBLIC_FPDF_PPO_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif
// Import pages to a FPDF_DOCUMENT.
//
// dest_doc - The destination document for the pages.
// src_doc - The document to be imported.
// pagerange - A page range string, Such as "1,3,5-7". If |pagerange| is NULL,
// all pages from |src_doc| are imported.
// index - The page index to insert at.
//
// Returns TRUE on success.
DLLEXPORT FPDF_BOOL STDCALL FPDF_ImportPages(FPDF_DOCUMENT dest_doc,
FPDF_DOCUMENT src_doc,
FPDF_BYTESTRING pagerange,
int index);
// Copy the viewer preferences from |src_doc| into |dest_doc|.
//
// dest_doc - Document to write the viewer preferences into.
// src_doc - Document to read the viewer preferences from.
//
// Returns TRUE on success.
DLLEXPORT FPDF_BOOL STDCALL FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc,
FPDF_DOCUMENT src_doc);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_PPO_H_

120
dependencies/pdfium/public/fpdf_progressive.h vendored Normal file
View File

@ -0,0 +1,120 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_PROGRESSIVE_H_
#define PUBLIC_FPDF_PROGRESSIVE_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
// Flags for progressive process status.
#define FPDF_RENDER_READER 0
#define FPDF_RENDER_TOBECOUNTINUED 1
#define FPDF_RENDER_DONE 2
#define FPDF_RENDER_FAILED 3
#ifdef __cplusplus
extern "C" {
#endif
// IFPDF_RENDERINFO interface.
typedef struct _IFSDK_PAUSE {
/**
* Version number of the interface. Currently must be 1.
**/
int version;
/*
* Method: NeedToPauseNow
* Check if we need to pause a progressive process now.
* Interface Version:
* 1
* Implementation Required:
* yes
* Parameters:
* pThis - Pointer to the interface structure itself
* Return Value:
* Non-zero for pause now, 0 for continue.
*
*/
FPDF_BOOL (*NeedToPauseNow)(struct _IFSDK_PAUSE* pThis);
// A user defined data pointer, used by user's application. Can be NULL.
void* user;
} IFSDK_PAUSE;
// Function: FPDF_RenderPageBitmap_Start
// Start to render page contents to a device independent bitmap
// progressively.
// Parameters:
// bitmap - Handle to the device independent bitmap (as the
// output buffer).
// Bitmap handle can be created by FPDFBitmap_Create
// function.
// page - Handle to the page. Returned by FPDF_LoadPage
// function.
// start_x - Left pixel position of the display area in the
// bitmap coordinate.
// start_y - Top pixel position of the display area in the bitmap
// coordinate.
// 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 in fpdfview.h. With FPDF_ANNOT flag, it
// renders all annotations that does not require
// user-interaction, which are all annotations except
// widget and popup annotations.
// pause - The IFSDK_PAUSE interface.A callback mechanism
// allowing the page rendering process
// Return value:
// Rendering Status. See flags for progressive process status for the
// details.
//
DLLEXPORT int STDCALL FPDF_RenderPageBitmap_Start(FPDF_BITMAP bitmap,
FPDF_PAGE page,
int start_x,
int start_y,
int size_x,
int size_y,
int rotate,
int flags,
IFSDK_PAUSE* pause);
// Function: FPDF_RenderPage_Continue
// Continue rendering a PDF page.
// Parameters:
// page - Handle to the page. Returned by FPDF_LoadPage
// function.
// pause - The IFSDK_PAUSE interface.A callback mechanism
// allowing the page rendering process
// to be paused before it's finished. This can be NULL
// if you don't want to pause.
// Return value:
// The rendering status. See flags for progressive process status for
// the details.
DLLEXPORT int STDCALL FPDF_RenderPage_Continue(FPDF_PAGE page,
IFSDK_PAUSE* pause);
// Function: FPDF_RenderPage_Close
// Release the resource allocate during page rendering. Need to be
// called after finishing rendering or
// cancel the rendering.
// Parameters:
// page - Handle to the page. Returned by FPDF_LoadPage
// function.
// Return value:
// NULL
DLLEXPORT void STDCALL FPDF_RenderPage_Close(FPDF_PAGE page);
#ifdef __cplusplus
}
#endif
#endif // PUBLIC_FPDF_PROGRESSIVE_H_

87
dependencies/pdfium/public/fpdf_save.h vendored Normal file
View File

@ -0,0 +1,87 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_SAVE_H_
#define PUBLIC_FPDF_SAVE_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif
// Structure for custom file write
typedef struct FPDF_FILEWRITE_ {
//
// Version number of the interface. Currently must be 1.
//
int version;
//
// Method: WriteBlock
// Output a block of data in your custom way.
// Interface Version:
// 1
// Implementation Required:
// Yes
// Comments:
// Called by function FPDF_SaveDocument
// Parameters:
// pThis - Pointer to the structure itself
// pData - Pointer to a buffer to output
// size - The size of the buffer.
// Return value:
// Should be non-zero if successful, zero for error.
//
int (*WriteBlock)(struct FPDF_FILEWRITE_* pThis,
const void* pData,
unsigned long size);
} FPDF_FILEWRITE;
/** @brief Incremental. */
#define FPDF_INCREMENTAL 1
/** @brief No Incremental. */
#define FPDF_NO_INCREMENTAL 2
/** @brief Remove security. */
#define FPDF_REMOVE_SECURITY 3
// Function: FPDF_SaveAsCopy
// Saves the copy of specified document in custom way.
// Parameters:
// document - Handle to document. Returned by
// FPDF_LoadDocument and FPDF_CreateNewDocument.
// pFileWrite - A pointer to a custom file write structure.
// flags - The creating flags.
// Return value:
// TRUE for succeed, FALSE for failed.
//
DLLEXPORT FPDF_BOOL STDCALL FPDF_SaveAsCopy(FPDF_DOCUMENT document,
FPDF_FILEWRITE* pFileWrite,
FPDF_DWORD flags);
// Function: FPDF_SaveWithVersion
// Same as function ::FPDF_SaveAsCopy, except the file version of the
// saved document could be specified by user.
// Parameters:
// document - Handle to document.
// pFileWrite - A pointer to a custom file write structure.
// flags - The creating flags.
// fileVersion - The PDF file version. File version: 14 for 1.4,
// 15 for 1.5, ...
// Return value:
// TRUE if succeed, FALSE if failed.
//
DLLEXPORT FPDF_BOOL STDCALL FPDF_SaveWithVersion(FPDF_DOCUMENT document,
FPDF_FILEWRITE* pFileWrite,
FPDF_DWORD flags,
int fileVersion);
#ifdef __cplusplus
}
#endif
#endif // PUBLIC_FPDF_SAVE_H_

30
dependencies/pdfium/public/fpdf_searchex.h vendored Normal file
View File

@ -0,0 +1,30 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_SEARCHEX_H_
#define PUBLIC_FPDF_SEARCHEX_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Get the character index in |text_page| internal character list.
//
// text_page - a text page information structure.
// nTextIndex - index of the text returned from |FPDFText_GetText|.
//
// Returns the index of the character in internal character list. -1 for error.
DLLEXPORT int STDCALL
FPDFText_GetCharIndexFromTextIndex(FPDF_TEXTPAGE text_page, int nTextIndex);
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // PUBLIC_FPDF_SEARCHEX_H_

103
dependencies/pdfium/public/fpdf_structtree.h vendored Normal file
View File

@ -0,0 +1,103 @@
// Copyright 2016 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_STRUCTTREE_H_
#define PUBLIC_FPDF_STRUCTTREE_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif
// Function: FPDF_StructTree_GetForPage
// Get the structure tree for a page.
// Parameters:
// page - Handle to the page. Returned by FPDF_LoadPage
// function.
// Return value:
// A handle to the structure tree or NULL on error.
DLLEXPORT FPDF_STRUCTTREE STDCALL FPDF_StructTree_GetForPage(FPDF_PAGE page);
// Function: FPDF_StructTree_Close
// Release the resource allocate by FPDF_StructTree_GetForPage.
// Parameters:
// struct_tree - Handle to the struct tree. Returned by
// FPDF_StructTree_LoadPage function.
// Return value:
// NULL
DLLEXPORT void STDCALL FPDF_StructTree_Close(FPDF_STRUCTTREE struct_tree);
// Function: FPDF_StructTree_CountChildren
// Count the number of children for the structure tree.
// Parameters:
// struct_tree - Handle to the struct tree. Returned by
// FPDF_StructTree_LoadPage function.
// Return value:
// The number of children, or -1 on error.
DLLEXPORT int STDCALL
FPDF_StructTree_CountChildren(FPDF_STRUCTTREE struct_tree);
// Function: FPDF_StructTree_GetChildAtIndex
// Get a child in the structure tree.
// Parameters:
// struct_tree - Handle to the struct tree. Returned by
// FPDF_StructTree_LoadPage function.
// index - The index for the child, 0-based.
// Return value:
// The child at the n-th index or NULL on error.
DLLEXPORT FPDF_STRUCTELEMENT STDCALL
FPDF_StructTree_GetChildAtIndex(FPDF_STRUCTTREE struct_tree, int index);
// Function: FPDF_StructElement_GetAltText
// Get the alt text for a given element.
// Parameters:
// struct_element - Handle to the struct element.
// buffer - A buffer for output the alt text. May be NULL.
// buflen - The length of the buffer, in bytes. May be 0.
// Return value:
// The number of bytes in the title, including the terminating NUL
// character. The number of bytes is returned regardless of the
// |buffer| and |buflen| parameters.
// Comments:
// Regardless of the platform, the |buffer| is always in UTF-16LE
// encoding. The string is terminated by a UTF16 NUL character. If
// |buflen| is less than the required length, or |buffer| is NULL,
// |buffer| will not be modified.
DLLEXPORT unsigned long STDCALL
FPDF_StructElement_GetAltText(FPDF_STRUCTELEMENT struct_element,
void* buffer,
unsigned long buflen);
// Function: FPDF_StructElement_CountChildren
// Count the number of children for the structure element.
// Parameters:
// struct_element - Handle to the struct element.
// Return value:
// The number of children, or -1 on error.
DLLEXPORT int STDCALL
FPDF_StructElement_CountChildren(FPDF_STRUCTELEMENT struct_element);
// Function: FPDF_StructElement_GetChildAtIndex
// Get a child in the structure element.
// Parameters:
// struct_tree - Handle to the struct element.
// index - The index for the child, 0-based.
// Return value:
// The child at the n-th index or NULL on error.
// Comments:
// If the child exists but is not an element, then this function will
// return NULL. This will also return NULL for out of bounds indices.
DLLEXPORT FPDF_STRUCTELEMENT STDCALL
FPDF_StructElement_GetChildAtIndex(FPDF_STRUCTELEMENT struct_element,
int index);
#ifdef __cplusplus
}
#endif
#endif // PUBLIC_FPDF_STRUCTTREE_H_

316
dependencies/pdfium/public/fpdf_sysfontinfo.h vendored Normal file
View File

@ -0,0 +1,316 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_SYSFONTINFO_H_
#define PUBLIC_FPDF_SYSFONTINFO_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
/* Character sets for the font */
#define FXFONT_ANSI_CHARSET 0
#define FXFONT_DEFAULT_CHARSET 1
#define FXFONT_SYMBOL_CHARSET 2
#define FXFONT_SHIFTJIS_CHARSET 128
#define FXFONT_HANGEUL_CHARSET 129
#define FXFONT_GB2312_CHARSET 134
#define FXFONT_CHINESEBIG5_CHARSET 136
/* Font pitch and family flags */
#define FXFONT_FF_FIXEDPITCH 1
#define FXFONT_FF_ROMAN (1 << 4)
#define FXFONT_FF_SCRIPT (4 << 4)
/* Typical weight values */
#define FXFONT_FW_NORMAL 400
#define FXFONT_FW_BOLD 700
// Exported Functions
#ifdef __cplusplus
extern "C" {
#endif
/**
* Interface: FPDF_SYSFONTINFO
* Interface for getting system font information and font mapping
*/
typedef struct _FPDF_SYSFONTINFO {
/**
* Version number of the interface. Currently must be 1.
**/
int version;
/**
* Method: Release
* Give implementation a chance to release any data after the
* interface is no longer used
* Interface Version:
* 1
* Implementation Required:
* No
* Comments:
* Called by Foxit SDK during the final cleanup process.
* Parameters:
* pThis - Pointer to the interface structure itself
* Return Value:
* None
*/
void (*Release)(struct _FPDF_SYSFONTINFO* pThis);
/**
* Method: EnumFonts
* Enumerate all fonts installed on the system
* Interface Version:
* 1
* Implementation Required:
* No
* Comments:
* Implementation should call FPDF_AddIntalledFont() function for
* each font found.
* Only TrueType/OpenType and Type1 fonts are accepted by Foxit SDK.
* Parameters:
* pThis - Pointer to the interface structure itself
* pMapper - An opaque pointer to internal font mapper, used
* when calling FPDF_AddInstalledFont
* Return Value:
* None
*/
void (*EnumFonts)(struct _FPDF_SYSFONTINFO* pThis, void* pMapper);
/**
* Method: MapFont
* Use the system font mapper to get a font handle from requested
*parameters
* Interface Version:
* 1
* Implementation Required:
* Yes only if GetFont method is not implemented.
* Comments:
* If the system supports native font mapper (like Windows),
*implementation can implement this method to get a font handle.
* Otherwise, Foxit SDK will do the mapping and then call GetFont
*method.
* Only TrueType/OpenType and Type1 fonts are accepted by Foxit SDK.
* Parameters:
* pThis - Pointer to the interface structure itself
* weight - Weight of the requested font. 400 is normal and
*700 is bold.
* bItalic - Italic option of the requested font, TRUE or
*FALSE.
* charset - Character set identifier for the requested font.
*See above defined constants.
* pitch_family - A combination of flags. See above defined
*constants.
* face - Typeface name. Currently use system local encoding
*only.
* bExact - Pointer to a boolean value receiving the indicator
*whether mapper found the exact match.
* If mapper is not sure whether it's exact match,
*ignore this paramter.
* Return Value:
* An opaque pointer for font handle, or NULL if system mapping is
*not supported.
**/
void* (*MapFont)(struct _FPDF_SYSFONTINFO* pThis,
int weight,
FPDF_BOOL bItalic,
int charset,
int pitch_family,
const char* face,
FPDF_BOOL* bExact);
/**
* Method: GetFont
* Get a handle to a particular font by its internal ID
* Interface Version:
* 1
* Implementation Required:
* Yes only if MapFont method is not implemented.
* Comments:
* If the system mapping not supported, Foxit SDK will do the font
*mapping and use this method to get a font handle.
* Parameters:
* pThis - Pointer to the interface structure itself
* face - Typeface name. Currently use system local encoding
*only.
* Return Value:
* An opaque pointer for font handle.
**/
void* (*GetFont)(struct _FPDF_SYSFONTINFO* pThis, const char* face);
/**
* Method: GetFontData
* Get font data from a font
* Interface Version:
* 1
* Implementation Required:
* Yes
* Comments:
* Can read either full font file, or a particular TrueType/OpenType
*table
* Parameters:
* pThis - Pointer to the interface structure itself
* hFont - Font handle returned by MapFont or GetFont method
* table - TrueType/OpenType table identifier (refer to
*TrueType specification).
* 0 for the whole font file.
* buffer - The buffer receiving the font data. Can be NULL if
*not provided
* buf_size - Buffer size, can be zero if not provided
* Return Value:
* Number of bytes needed, if buffer not provided or not large
*enough,
* or number of bytes written into buffer otherwise.
**/
unsigned long (*GetFontData)(struct _FPDF_SYSFONTINFO* pThis,
void* hFont,
unsigned int table,
unsigned char* buffer,
unsigned long buf_size);
/**
* Method: GetFaceName
* Get face name from a font handle
* Interface Version:
* 1
* Implementation Required:
* No
* Parameters:
* pThis - Pointer to the interface structure itself
* hFont - Font handle returned by MapFont or GetFont method
* buffer - The buffer receiving the face name. Can be NULL if
*not provided
* buf_size - Buffer size, can be zero if not provided
* Return Value:
* Number of bytes needed, if buffer not provided or not large
*enough,
* or number of bytes written into buffer otherwise.
**/
unsigned long (*GetFaceName)(struct _FPDF_SYSFONTINFO* pThis,
void* hFont,
char* buffer,
unsigned long buf_size);
/**
* Method: GetFontCharset
* Get character set information for a font handle
* Interface Version:
* 1
* Implementation Required:
* No
* Parameters:
* pThis - Pointer to the interface structure itself
* hFont - Font handle returned by MapFont or GetFont method
* Return Value:
* Character set identifier. See defined constants above.
**/
int (*GetFontCharset)(struct _FPDF_SYSFONTINFO* pThis, void* hFont);
/**
* Method: DeleteFont
* Delete a font handle
* Interface Version:
* 1
* Implementation Required:
* Yes
* Parameters:
* pThis - Pointer to the interface structure itself
* hFont - Font handle returned by MapFont or GetFont method
* Return Value:
* None
**/
void (*DeleteFont)(struct _FPDF_SYSFONTINFO* pThis, void* hFont);
} FPDF_SYSFONTINFO;
/**
* Struct: FPDF_CharsetFontMap
* Provides the name of a font to use for a given charset value.
**/
typedef struct FPDF_CharsetFontMap_ {
int charset; // Character Set Enum value, see FXFONT_*_CHARSET above.
const char* fontname; // Name of default font to use with that charset.
} FPDF_CharsetFontMap;
/**
* Function: FPDF_GetDefaultTTFMap
* Returns a pointer to the default character set to TT Font name map. The
* map is an array of FPDF_CharsetFontMap structs, with its end indicated
* by a { -1, NULL } entry.
* Parameters:
* None.
* Return Value:
* Pointer to the Charset Font Map.
**/
DLLEXPORT const FPDF_CharsetFontMap* STDCALL FPDF_GetDefaultTTFMap();
/**
* Function: FPDF_AddInstalledFont
* Add a system font to the list in Foxit SDK.
* Comments:
* This function is only called during the system font list building
*process.
* Parameters:
* mapper - Opaque pointer to Foxit font mapper
* face - The font face name
* charset - Font character set. See above defined constants.
* Return Value:
* None.
**/
DLLEXPORT void STDCALL FPDF_AddInstalledFont(void* mapper,
const char* face,
int charset);
/**
* Function: FPDF_SetSystemFontInfo
* Set the system font info interface into Foxit SDK
* Comments:
* Platform support implementation should implement required methods of
*FFDF_SYSFONTINFO interface,
* then call this function during SDK initialization process.
* Parameters:
* pFontInfo - Pointer to a FPDF_SYSFONTINFO structure
* Return Value:
* None
**/
DLLEXPORT void STDCALL FPDF_SetSystemFontInfo(FPDF_SYSFONTINFO* pFontInfo);
/**
* Function: FPDF_GetDefaultSystemFontInfo
* Get default system font info interface for current platform
* Comments:
* For some platforms Foxit SDK implement a default version of system
*font info interface.
* The default implementation can be used in FPDF_SetSystemFontInfo
*function.
* Parameters:
* None
* Return Value:
* Pointer to a FPDF_SYSFONTINFO structure describing the default
*interface.
* Or NULL if the platform doesn't have a default interface.
* Application should call FPDF_FreeDefaultSystemFontInfo to free the
*returned pointer.
**/
DLLEXPORT FPDF_SYSFONTINFO* STDCALL FPDF_GetDefaultSystemFontInfo();
/**
* Function: FPDF_FreeDefaultSystemFontInfo
* Free a default system font info interface
* Comments:
* This function should be called on the output from
*FPDF_SetSystemFontInfo once it is no longer needed by the client.
* Parameters:
* pFontInfo - Pointer to a FPDF_SYSFONTINFO structure
* Return Value:
* None
**/
DLLEXPORT void FPDF_FreeDefaultSystemFontInfo(FPDF_SYSFONTINFO* pFontInfo);
#ifdef __cplusplus
}
#endif
#endif // PUBLIC_FPDF_SYSFONTINFO_H_

425
dependencies/pdfium/public/fpdf_text.h vendored Normal file
View File

@ -0,0 +1,425 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_TEXT_H_
#define PUBLIC_FPDF_TEXT_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
// Exported Functions
#ifdef __cplusplus
extern "C" {
#endif
// Function: FPDFText_LoadPage
// Prepare information about all characters in a page.
// Parameters:
// page - Handle to the page. Returned by FPDF_LoadPage function
// (in FPDFVIEW module).
// Return value:
// A handle to the text page information structure.
// NULL if something goes wrong.
// Comments:
// Application must call FPDFText_ClosePage to release the text page
// information.
//
DLLEXPORT FPDF_TEXTPAGE STDCALL FPDFText_LoadPage(FPDF_PAGE page);
// Function: FPDFText_ClosePage
// Release all resources allocated for a text page information
// structure.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// Return Value:
// None.
//
DLLEXPORT void STDCALL FPDFText_ClosePage(FPDF_TEXTPAGE text_page);
// Function: FPDFText_CountChars
// Get number of characters in a page.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// Return value:
// Number of characters in the page. Return -1 for error.
// Generated characters, like additional space characters, new line
// characters, are also counted.
// Comments:
// Characters in a page form a "stream", inside the stream, each
// character has an index.
// We will use the index parameters in many of FPDFTEXT functions. The
// first character in the page
// has an index value of zero.
//
DLLEXPORT int STDCALL FPDFText_CountChars(FPDF_TEXTPAGE text_page);
// Function: FPDFText_GetUnicode
// Get Unicode of a character in a page.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// index - Zero-based index of the character.
// Return value:
// The Unicode of the particular character.
// If a character is not encoded in Unicode and Foxit engine can't
// convert to Unicode,
// the return value will be zero.
//
DLLEXPORT unsigned int STDCALL FPDFText_GetUnicode(FPDF_TEXTPAGE text_page,
int index);
// Function: FPDFText_GetFontSize
// Get the font size of a particular character.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// index - Zero-based index of the character.
// Return value:
// The font size of the particular character, measured in points (about
// 1/72 inch).
// This is the typographic size of the font (so called "em size").
//
DLLEXPORT double STDCALL FPDFText_GetFontSize(FPDF_TEXTPAGE text_page,
int index);
// Function: FPDFText_GetCharBox
// Get bounding box of a particular character.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// index - Zero-based index of the character.
// left - Pointer to a double number receiving left position
// of the character box.
// right - Pointer to a double number receiving right position
// of the character box.
// bottom - Pointer to a double number receiving bottom position
// of the character box.
// top - Pointer to a double number receiving top position of
// the character box.
// Return Value:
// None.
// Comments:
// All positions are measured in PDF "user space".
//
DLLEXPORT void STDCALL FPDFText_GetCharBox(FPDF_TEXTPAGE text_page,
int index,
double* left,
double* right,
double* bottom,
double* top);
// Function: FPDFText_GetCharIndexAtPos
// Get the index of a character at or nearby a certain position on the
// page.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// x - X position in PDF "user space".
// y - Y position in PDF "user space".
// xTolerance - An x-axis tolerance value for character hit
// detection, in point unit.
// yTolerance - A y-axis tolerance value for character hit
// detection, in point unit.
// Return Value:
// The zero-based index of the character at, or nearby the point (x,y).
// If there is no character at or nearby the point, return value will
// be -1.
// If an error occurs, -3 will be returned.
//
DLLEXPORT int STDCALL FPDFText_GetCharIndexAtPos(FPDF_TEXTPAGE text_page,
double x,
double y,
double xTolerance,
double yTolerance);
// Function: FPDFText_GetText
// Extract unicode text string from the page.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// start_index - Index for the start characters.
// count - Number of characters to be extracted.
// result - A buffer (allocated by application) receiving the
// extracted unicodes.
// The size of the buffer must be able to hold the
// number of characters plus a terminator.
// Return Value:
// Number of characters written into the result buffer, including the
// trailing terminator.
// Comments:
// This function ignores characters without unicode information.
//
DLLEXPORT int STDCALL FPDFText_GetText(FPDF_TEXTPAGE text_page,
int start_index,
int count,
unsigned short* result);
// Function: FPDFText_CountRects
// Count number of rectangular areas occupied by a segment of texts.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// start_index - Index for the start characters.
// count - Number of characters.
// Return value:
// Number of rectangles. Zero for error.
// Comments:
// This function, along with FPDFText_GetRect can be used by
// applications to detect the position
// on the page for a text segment, so proper areas can be highlighted
// or something.
// FPDFTEXT will automatically merge small character boxes into bigger
// one if those characters
// are on the same line and use same font settings.
//
DLLEXPORT int STDCALL FPDFText_CountRects(FPDF_TEXTPAGE text_page,
int start_index,
int count);
// Function: FPDFText_GetRect
// Get a rectangular area from the result generated by
// FPDFText_CountRects.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// rect_index - Zero-based index for the rectangle.
// left - Pointer to a double value receiving the rectangle
// left boundary.
// top - Pointer to a double value receiving the rectangle
// top boundary.
// right - Pointer to a double value receiving the rectangle
// right boundary.
// bottom - Pointer to a double value receiving the rectangle
// bottom boundary.
// Return Value:
// None.
//
DLLEXPORT void STDCALL FPDFText_GetRect(FPDF_TEXTPAGE text_page,
int rect_index,
double* left,
double* top,
double* right,
double* bottom);
// Function: FPDFText_GetBoundedText
// Extract unicode text within a rectangular boundary on the page.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// left - Left boundary.
// top - Top boundary.
// right - Right boundary.
// bottom - Bottom boundary.
// buffer - A unicode buffer.
// buflen - Number of characters (not bytes) for the buffer,
// excluding an additional terminator.
// Return Value:
// If buffer is NULL or buflen is zero, return number of characters
// (not bytes) of text present within
// the rectangle, excluding a terminating NUL. Generally you should
// pass a buffer at least one larger
// than this if you want a terminating NUL, which will be provided if
// space is available.
// Otherwise, return number of characters copied into the buffer,
// including the terminating NUL
// when space for it is available.
// Comment:
// If the buffer is too small, as much text as will fit is copied into
// it.
//
DLLEXPORT int STDCALL FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page,
double left,
double top,
double right,
double bottom,
unsigned short* buffer,
int buflen);
// Flags used by FPDFText_FindStart function.
#define FPDF_MATCHCASE \
0x00000001 // If not set, it will not match case by default.
#define FPDF_MATCHWHOLEWORD \
0x00000002 // If not set, it will not match the whole word by default.
// Function: FPDFText_FindStart
// Start a search.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// findwhat - A unicode match pattern.
// flags - Option flags.
// start_index - Start from this character. -1 for end of the page.
// Return Value:
// A handle for the search context. FPDFText_FindClose must be called
// to release this handle.
//
DLLEXPORT FPDF_SCHHANDLE STDCALL FPDFText_FindStart(FPDF_TEXTPAGE text_page,
FPDF_WIDESTRING findwhat,
unsigned long flags,
int start_index);
// Function: FPDFText_FindNext
// Search in the direction from page start to end.
// Parameters:
// handle - A search context handle returned by
// FPDFText_FindStart.
// Return Value:
// Whether a match is found.
//
DLLEXPORT FPDF_BOOL STDCALL FPDFText_FindNext(FPDF_SCHHANDLE handle);
// Function: FPDFText_FindPrev
// Search in the direction from page end to start.
// Parameters:
// handle - A search context handle returned by
// FPDFText_FindStart.
// Return Value:
// Whether a match is found.
//
DLLEXPORT FPDF_BOOL STDCALL FPDFText_FindPrev(FPDF_SCHHANDLE handle);
// Function: FPDFText_GetSchResultIndex
// Get the starting character index of the search result.
// Parameters:
// handle - A search context handle returned by
// FPDFText_FindStart.
// Return Value:
// Index for the starting character.
//
DLLEXPORT int STDCALL FPDFText_GetSchResultIndex(FPDF_SCHHANDLE handle);
// Function: FPDFText_GetSchCount
// Get the number of matched characters in the search result.
// Parameters:
// handle - A search context handle returned by
// FPDFText_FindStart.
// Return Value:
// Number of matched characters.
//
DLLEXPORT int STDCALL FPDFText_GetSchCount(FPDF_SCHHANDLE handle);
// Function: FPDFText_FindClose
// Release a search context.
// Parameters:
// handle - A search context handle returned by
// FPDFText_FindStart.
// Return Value:
// None.
//
DLLEXPORT void STDCALL FPDFText_FindClose(FPDF_SCHHANDLE handle);
// Function: FPDFLink_LoadWebLinks
// Prepare information about weblinks in a page.
// Parameters:
// text_page - Handle to a text page information structure.
// Returned by FPDFText_LoadPage function.
// Return Value:
// A handle to the page's links information structure.
// NULL if something goes wrong.
// Comments:
// Weblinks are those links implicitly embedded in PDF pages. PDF also
// has a type of
// annotation called "link", FPDFTEXT doesn't deal with that kind of
// link.
// FPDFTEXT weblink feature is useful for automatically detecting links
// in the page
// contents. For example, things like "http://www.foxitsoftware.com"
// will be detected,
// so applications can allow user to click on those characters to
// activate the link,
// even the PDF doesn't come with link annotations.
//
// FPDFLink_CloseWebLinks must be called to release resources.
//
DLLEXPORT FPDF_PAGELINK STDCALL FPDFLink_LoadWebLinks(FPDF_TEXTPAGE text_page);
// Function: FPDFLink_CountWebLinks
// Count number of detected web links.
// Parameters:
// link_page - Handle returned by FPDFLink_LoadWebLinks.
// Return Value:
// Number of detected web links.
//
DLLEXPORT int STDCALL FPDFLink_CountWebLinks(FPDF_PAGELINK link_page);
// Function: FPDFLink_GetURL
// Fetch the URL information for a detected web link.
// Parameters:
// link_page - Handle returned by FPDFLink_LoadWebLinks.
// link_index - Zero-based index for the link.
// buffer - A unicode buffer for the result.
// buflen - Number of characters (not bytes) for the buffer,
// including an additional terminator.
// Return Value:
// If |buffer| is NULL or |buflen| is zero, return the number of
// characters (not bytes) needed to buffer the result (an additional
// terminator is included in this count).
// Otherwise, copy the result into |buffer|, truncating at |buflen| if
// the result is too large to fit, and return the number of characters
// actually copied into the buffer (the additional terminator is also
// included in this count).
// If |link_index| does not correspond to a valid link, then the result
// is an empty string.
//
DLLEXPORT int STDCALL FPDFLink_GetURL(FPDF_PAGELINK link_page,
int link_index,
unsigned short* buffer,
int buflen);
// Function: FPDFLink_CountRects
// Count number of rectangular areas for the link.
// Parameters:
// link_page - Handle returned by FPDFLink_LoadWebLinks.
// link_index - Zero-based index for the link.
// Return Value:
// Number of rectangular areas for the link. If |link_index| does
// not correspond to a valid link, then 0 is returned.
//
DLLEXPORT int STDCALL FPDFLink_CountRects(FPDF_PAGELINK link_page,
int link_index);
// Function: FPDFLink_GetRect
// Fetch the boundaries of a rectangle for a link.
// Parameters:
// link_page - Handle returned by FPDFLink_LoadWebLinks.
// link_index - Zero-based index for the link.
// rect_index - Zero-based index for a rectangle.
// left - Pointer to a double value receiving the rectangle
// left boundary.
// top - Pointer to a double value receiving the rectangle
// top boundary.
// right - Pointer to a double value receiving the rectangle
// right boundary.
// bottom - Pointer to a double value receiving the rectangle
// bottom boundary.
// Return Value:
// None. If |link_index| does not correspond to a valid link, then
// |left|, |top|, |right|, and |bottom| remain unmodified.
//
DLLEXPORT void STDCALL FPDFLink_GetRect(FPDF_PAGELINK link_page,
int link_index,
int rect_index,
double* left,
double* top,
double* right,
double* bottom);
// Function: FPDFLink_CloseWebLinks
// Release resources used by weblink feature.
// Parameters:
// link_page - Handle returned by FPDFLink_LoadWebLinks.
// Return Value:
// None.
//
DLLEXPORT void STDCALL FPDFLink_CloseWebLinks(FPDF_PAGELINK link_page);
#ifdef __cplusplus
}
#endif
#endif // PUBLIC_FPDF_TEXT_H_

161
dependencies/pdfium/public/fpdf_transformpage.h vendored Normal file
View File

@ -0,0 +1,161 @@
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef PUBLIC_FPDF_TRANSFORMPAGE_H_
#define PUBLIC_FPDF_TRANSFORMPAGE_H_
// NOLINTNEXTLINE(build/include)
#include "fpdfview.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef void* FPDF_PAGEARCSAVER;
typedef void* FPDF_PAGEARCLOADER;
/**
* Set "MediaBox" entry to the page dictionary.
* @param[in] page - Handle to a page.
* @param[in] left - The left of the rectangle.
* @param[in] bottom - The bottom of the rectangle.
* @param[in] right - The right of the rectangle.
* @param[in] top - The top of the rectangle.
* @retval None.
*/
DLLEXPORT void STDCALL FPDFPage_SetMediaBox(FPDF_PAGE page,
float left,
float bottom,
float right,
float top);
/**
* Set "CropBox" entry to the page dictionary.
* @param[in] page - Handle to a page.
* @param[in] left - The left of the rectangle.
* @param[in] bottom - The bottom of the rectangle.
* @param[in] right - The right of the rectangle.
* @param[in] top - The top of the rectangle.
* @retval None.
*/
DLLEXPORT void STDCALL FPDFPage_SetCropBox(FPDF_PAGE page,
float left,
float bottom,
float right,
float top);
/** Get "MediaBox" entry from the page dictionary.
* @param[in] page - Handle to a page.
* @param[in] left - Pointer to a double value receiving the left of the
* rectangle.
* @param[in] bottom - Pointer to a double value receiving the bottom of the
* rectangle.
* @param[in] right - Pointer to a double value receiving the right of the
* rectangle.
* @param[in] top - Pointer to a double value receiving the top of the
* rectangle.
* @retval True if success,else fail.
*/
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_GetMediaBox(FPDF_PAGE page,
float* left,
float* bottom,
float* right,
float* top);
/** Get "CropBox" entry from the page dictionary.
* @param[in] page - Handle to a page.
* @param[in] left - Pointer to a double value receiving the left of the
* rectangle.
* @param[in] bottom - Pointer to a double value receiving the bottom of the
* rectangle.
* @param[in] right - Pointer to a double value receiving the right of the
* rectangle.
* @param[in] top - Pointer to a double value receiving the top of the
* rectangle.
* @retval True if success,else fail.
*/
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_GetCropBox(FPDF_PAGE page,
float* left,
float* bottom,
float* right,
float* top);
/**
* Transform the whole page with a specified matrix, then clip the page content
* region.
*
* @param[in] page - A page handle.
* @param[in] matrix - The transform matrix.
* @param[in] clipRect - A rectangle page area to be clipped.
* @Note. This function will transform the whole page, and would take effect to
* all the objects in the page.
*/
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_TransFormWithClip(FPDF_PAGE page,
FS_MATRIX* matrix,
FS_RECTF* clipRect);
/**
* Transform (scale, rotate, shear, move) the clip path of page object.
* @param[in] page_object - Handle to a page object. Returned by
* FPDFPageObj_NewImageObj.
* @param[in] a - The coefficient "a" of the matrix.
* @param[in] b - The coefficient "b" of the matrix.
* @param[in] c - The coefficient "c" of the matrix.
* @param[in] d - The coefficient "d" of the matrix.
* @param[in] e - The coefficient "e" of the matrix.
* @param[in] f - The coefficient "f" of the matrix.
* @retval None.
*/
DLLEXPORT void STDCALL
FPDFPageObj_TransformClipPath(FPDF_PAGEOBJECT page_object,
double a,
double b,
double c,
double d,
double e,
double f);
/**
* Create a new clip path, with a rectangle inserted.
*
* @param[in] left - The left of the clip box.
* @param[in] bottom - The bottom of the clip box.
* @param[in] right - The right of the clip box.
* @param[in] top - The top of the clip box.
* @retval a handle to the clip path.
*/
DLLEXPORT FPDF_CLIPPATH STDCALL FPDF_CreateClipPath(float left,
float bottom,
float right,
float top);
/**
* Destroy the clip path.
*
* @param[in] clipPath - A handle to the clip path.
* Destroy the clip path.
* @retval None.
*/
DLLEXPORT void STDCALL FPDF_DestroyClipPath(FPDF_CLIPPATH clipPath);
/**
* Clip the page content, the page content that outside the clipping region
* become invisible.
*
* @param[in] page - A page handle.
* @param[in] clipPath - A handle to the clip path.
* @Note. A clip path will be inserted before the page content stream or content
* array. In this way, the page content will be clipped
* by this clip path.
*/
DLLEXPORT void STDCALL FPDFPage_InsertClipPath(FPDF_PAGE page,
FPDF_CLIPPATH clipPath);
#ifdef __cplusplus
}
#endif
#endif // PUBLIC_FPDF_TRANSFORMPAGE_H_

1043
dependencies/pdfium/public/fpdfview.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
dependencies/pdfium/x64/pdfium.dll vendored Normal file
View File

Binary file not shown.

BIN
dependencies/pdfium/x64/pdfium.lib vendored Normal file
View File

Binary file not shown.

BIN
dependencies/pdfium/x86/pdfium.dll vendored Normal file
View File

Binary file not shown.

BIN
dependencies/pdfium/x86/pdfium.lib vendored Normal file
View File

Binary file not shown.

BIN
dependencies/poppler/bin/poppler-qt5.dll vendored Normal file
View File

Binary file not shown.

BIN
dependencies/poppler/dependencies/bin/freetype6.dll vendored Normal file
View File

Binary file not shown.

10
dependencies/poppler/dependencies/bin/freetype6.dll.manifest vendored Normal file
View File

@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>

BIN
dependencies/poppler/dependencies/bin/openjpeg.dll vendored Normal file
View File

Binary file not shown.

10
dependencies/poppler/dependencies/bin/openjpeg.dll.manifest vendored Normal file
View File

@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>

0
dependencies/poppler/dependencies/lib/empty.txt vendored Normal file
View File

170
dependencies/poppler/include/qt5/ArthurOutputDev.h vendored Normal file
View File

@ -0,0 +1,170 @@
//========================================================================
//
// ArthurOutputDev.h
//
// Copyright 2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2005 Brad Hards <bradh@frogmouth.net>
// Copyright (C) 2005 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2009, 2011 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2010 Pino Toscano <pino@kde.org>
// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com>
// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#ifndef ARTHUROUTPUTDEV_H
#define ARTHUROUTPUTDEV_H
#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif
#include "goo/gtypes.h"
#include "OutputDev.h"
#include "GfxState.h"
#include <QtGui/QPainter>
class GfxState;
class GfxPath;
class Gfx8BitFont;
struct GfxRGB;
class SplashFont;
class SplashFontEngine;
struct SplashGlyphBitmap;
//------------------------------------------------------------------------
// ArthurOutputDev - Qt 4 QPainter renderer
//------------------------------------------------------------------------
class ArthurOutputDev: public OutputDev {
public:
/**
* Describes how fonts are distorted (aka hinted) to fit the pixel grid.
* More hinting means sharper edges and less adherence to the true letter shapes.
*/
enum FontHinting {
NoHinting = 0, ///< Font shapes are left unchanged
SlightHinting, ///< Font shapes are distorted vertically only
FullHinting ///< Font shapes are distorted horizontally and vertically
};
// Constructor.
ArthurOutputDev(QPainter *painter );
// Destructor.
virtual ~ArthurOutputDev();
void setFontHinting(FontHinting hinting) { m_fontHinting = hinting; }
//----- get info about output device
// Does this device use upside-down coordinates?
// (Upside-down means (0,0) is the top left corner of the page.)
virtual GBool upsideDown() { return gTrue; }
// Does this device use drawChar() or drawString()?
virtual GBool useDrawChar() { return gTrue; }
// Does this device use beginType3Char/endType3Char? Otherwise,
// text in Type 3 fonts will be drawn with drawChar/drawString.
virtual GBool interpretType3Chars() { return gTrue; }
//----- initialization and control
// Start a page.
virtual void startPage(int pageNum, GfxState *state, XRef *xref);
// End a page.
virtual void endPage();
//----- save/restore graphics state
virtual void saveState(GfxState *state);
virtual void restoreState(GfxState *state);
//----- update graphics state
virtual void updateAll(GfxState *state);
virtual void updateCTM(GfxState *state, double m11, double m12,
double m21, double m22, double m31, double m32);
virtual void updateLineDash(GfxState *state);
virtual void updateFlatness(GfxState *state);
virtual void updateLineJoin(GfxState *state);
virtual void updateLineCap(GfxState *state);
virtual void updateMiterLimit(GfxState *state);
virtual void updateLineWidth(GfxState *state);
virtual void updateFillColor(GfxState *state);
virtual void updateStrokeColor(GfxState *state);
virtual void updateFillOpacity(GfxState *state);
virtual void updateStrokeOpacity(GfxState *state);
//----- update text state
virtual void updateFont(GfxState *state);
//----- path painting
virtual void stroke(GfxState *state);
virtual void fill(GfxState *state);
virtual void eoFill(GfxState *state);
//----- path clipping
virtual void clip(GfxState *state);
virtual void eoClip(GfxState *state);
//----- text drawing
// virtual void drawString(GfxState *state, GooString *s);
virtual void drawChar(GfxState *state, double x, double y,
double dx, double dy,
double originX, double originY,
CharCode code, int nBytes, Unicode *u, int uLen);
virtual GBool beginType3Char(GfxState *state, double x, double y,
double dx, double dy,
CharCode code, Unicode *u, int uLen);
virtual void endType3Char(GfxState *state);
virtual void endTextObject(GfxState *state);
//----- image drawing
virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
int width, int height, GBool invert,
GBool interpolate, GBool inlineImg);
virtual void drawImage(GfxState *state, Object *ref, Stream *str,
int width, int height, GfxImageColorMap *colorMap,
GBool interpolate, int *maskColors, GBool inlineImg);
//----- Type 3 font operators
virtual void type3D0(GfxState *state, double wx, double wy);
virtual void type3D1(GfxState *state, double wx, double wy,
double llx, double lly, double urx, double ury);
//----- special access
// Called to indicate that a new PDF document has been loaded.
void startDoc(XRef *xrefA);
GBool isReverseVideo() { return gFalse; }
private:
QPainter *m_painter;
FontHinting m_fontHinting;
QFont m_currentFont;
QPen m_currentPen;
QBrush m_currentBrush;
GBool m_needFontUpdate; // set when the font needs to be updated
SplashFontEngine *m_fontEngine;
SplashFont *m_font; // current font
XRef *xref; // xref table for current document
};
#endif

198
dependencies/poppler/include/qt5/poppler-annotation-helper.h vendored Normal file
View File

@ -0,0 +1,198 @@
/* poppler-annotation-helper.h: qt interface to poppler
* Copyright (C) 2006, 2008, Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2008, Pino Toscano <pino@kde.org>
* Copyright (C) 2012, Fabio D'Urso <fabiodurso@hotmail.it>
* Adapting code from
* Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <QtCore/QDebug>
#include <Object.h>
class QColor;
class AnnotColor;
namespace Poppler {
class XPDFReader
{
public:
// find named symbol and parse it
static inline void lookupName( Dict *, char *, QString & dest );
static inline void lookupString( Dict *, char *, QString & dest );
static inline void lookupBool( Dict *, char *, bool & dest );
static inline void lookupInt( Dict *, char *, int & dest );
static inline void lookupNum( Dict *, char *, double & dest );
static inline int lookupNumArray( Dict *, char *, double * dest, int len );
static inline void lookupColor( Dict *, char *, QColor & color );
static inline void lookupIntRef( Dict *, char *, int & dest );
static inline void lookupDate( Dict *, char *, QDateTime & dest );
// transform from user coords to normalized ones using the matrix M
static inline void transform( double * M, double x, double y, QPointF &res );
static inline void invTransform( double * M, const QPointF &p, double &x, double &y );
};
void XPDFReader::lookupName( Dict * dict, char * type, QString & dest )
{
Object nameObj;
dict->lookup( type, &nameObj );
if ( nameObj.isNull() )
return;
if ( nameObj.isName() )
dest = nameObj.getName();
else
qDebug() << type << " is not Name." << endl;
nameObj.free();
}
void XPDFReader::lookupString( Dict * dict, char * type, QString & dest )
{
Object stringObj;
dict->lookup( type, &stringObj );
if ( stringObj.isNull() )
return;
if ( stringObj.isString() )
dest = stringObj.getString()->getCString();
else
qDebug() << type << " is not String." << endl;
stringObj.free();
}
void XPDFReader::lookupBool( Dict * dict, char * type, bool & dest )
{
Object boolObj;
dict->lookup( type, &boolObj );
if ( boolObj.isNull() )
return;
if ( boolObj.isBool() )
dest = boolObj.getBool() == gTrue;
else
qDebug() << type << " is not Bool." << endl;
boolObj.free();
}
void XPDFReader::lookupInt( Dict * dict, char * type, int & dest )
{
Object intObj;
dict->lookup( type, &intObj );
if ( intObj.isNull() )
return;
if ( intObj.isInt() )
dest = intObj.getInt();
else
qDebug() << type << " is not Int." << endl;
intObj.free();
}
void XPDFReader::lookupNum( Dict * dict, char * type, double & dest )
{
Object numObj;
dict->lookup( type, &numObj );
if ( numObj.isNull() )
return;
if ( numObj.isNum() )
dest = numObj.getNum();
else
qDebug() << type << " is not Num." << endl;
numObj.free();
}
int XPDFReader::lookupNumArray( Dict * dict, char * type, double * dest, int len )
{
Object arrObj;
dict->lookup( type, &arrObj );
if ( arrObj.isNull() )
return 0;
Object numObj;
if ( arrObj.isArray() )
{
len = qMin( len, arrObj.arrayGetLength() );
for ( int i = 0; i < len; i++ )
{
dest[i] = arrObj.arrayGet( i, &numObj )->getNum();
numObj.free();
}
}
else
{
len = 0;
qDebug() << type << "is not Array." << endl;
}
arrObj.free();
return len;
}
void XPDFReader::lookupColor( Dict * dict, char * type, QColor & dest )
{
double c[3];
if ( XPDFReader::lookupNumArray( dict, type, c, 3 ) == 3 )
dest = QColor( (int)(c[0]*255.0), (int)(c[1]*255.0), (int)(c[2]*255.0));
}
void XPDFReader::lookupIntRef( Dict * dict, char * type, int & dest )
{
Object refObj;
dict->lookupNF( type, &refObj );
if ( refObj.isNull() )
return;
if ( refObj.isRef() )
dest = refObj.getRefNum();
else
qDebug() << type << " is not Ref." << endl;
refObj.free();
}
void XPDFReader::lookupDate( Dict * dict, char * type, QDateTime & dest )
{
Object dateObj;
dict->lookup( type, &dateObj );
if ( dateObj.isNull() )
return;
if ( dateObj.isString() )
{
dest = convertDate( dateObj.getString()->getCString() );
}
else
qDebug() << type << " is not Date" << endl;
dateObj.free();
}
void XPDFReader::transform( double * M, double x, double y, QPointF &res )
{
res.setX( M[0] * x + M[2] * y + M[4] );
res.setY( M[1] * x + M[3] * y + M[5] );
}
void XPDFReader::invTransform( double * M, const QPointF &p, double &x, double &y )
{
const double det = M[0]*M[3] - M[1]*M[2];
Q_ASSERT(det != 0);
const double invM[4] = { M[3]/det, -M[1]/det, -M[2]/det, M[0]/det };
const double xt = p.x() - M[4];
const double yt = p.y() - M[5];
x = invM[0] * xt + invM[2] * yt;
y = invM[1] * xt + invM[3] * yt;
}
QColor convertAnnotColor( AnnotColor *color );
AnnotColor* convertQColor( const QColor &color );
}

112
dependencies/poppler/include/qt5/poppler-annotation-private.h vendored Normal file
View File

@ -0,0 +1,112 @@
/* poppler-annotation-private.h: qt interface to poppler
* Copyright (C) 2007, Pino Toscano <pino@kde.org>
* Copyright (C) 2012, Tobias Koenig <tokoe@kdab.com>
* Copyright (C) 2012, 2013 Fabio D'Urso <fabiodurso@hotmail.it>
* Copyright (C) 2012, Albert Astals Cid <aacid@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _POPPLER_ANNOTATION_PRIVATE_H_
#define _POPPLER_ANNOTATION_PRIVATE_H_
#include <QtCore/QLinkedList>
#include <QtCore/QPointF>
#include <QtCore/QSharedDataPointer>
#include "poppler-annotation.h"
#include <Object.h>
class Annot;
class AnnotPath;
class Link;
class Page;
class PDFRectangle;
namespace Poppler
{
class DocumentData;
class AnnotationPrivate : public QSharedData
{
public:
AnnotationPrivate();
virtual ~AnnotationPrivate();
void addRevision(Annotation *ann, Annotation::RevScope scope, Annotation::RevType type);
/* Returns an Annotation of the right subclass whose d_ptr points to
* this AnnotationPrivate */
virtual Annotation * makeAlias() = 0;
/* properties: contents related */
QString author;
QString contents;
QString uniqueName;
QDateTime modDate; // before or equal to currentDateTime()
QDateTime creationDate; // before or equal to modifyDate
/* properties: look/interaction related */
int flags;
QRectF boundary;
/* style and popup */
Annotation::Style style;
Annotation::Popup popup;
/* revisions */
Annotation::RevScope revisionScope;
Annotation::RevType revisionType;
QList<Annotation*> revisions;
/* After this call, the Annotation object will behave like a wrapper for
* the specified Annot object. All cached values are discarded */
void tieToNativeAnnot(Annot *ann, ::Page *page, DocumentData *doc);
/* Creates a new Annot object on the specified page, flushes current
* values to that object and ties this Annotation to that object */
virtual Annot* createNativeAnnot(::Page *destPage, DocumentData *doc) = 0;
/* Inited to 0 (i.e. untied annotation) */
Annot *pdfAnnot;
::Page *pdfPage;
DocumentData * parentDoc;
/* The following helpers only work if pdfPage is set */
void flushBaseAnnotationProperties();
void fillNormalizationMTX(double MTX[6], int pageRotation) const;
void fillTransformationMTX(double MTX[6]) const;
QRectF fromPdfRectangle(const PDFRectangle &r) const;
PDFRectangle boundaryToPdfRectangle(const QRectF &r, int flags) const;
AnnotPath * toAnnotPath(const QLinkedList<QPointF> &l) const;
/* Scan page for annotations, parentId=0 searches for root annotations */
static QList<Annotation*> findAnnotations(::Page *pdfPage, DocumentData *doc, int parentId = 0);
/* Add given annotation to given page */
static void addAnnotationToPage(::Page *pdfPage, DocumentData *doc, const Annotation * ann);
/* Remove annotation from page and destroy ann */
static void removeAnnotationFromPage(::Page *pdfPage, const Annotation * ann);
Ref pdfObjectReference() const;
Link* additionalAction( Annotation::AdditionalActionType type ) const;
};
}
#endif

1030
dependencies/poppler/include/qt5/poppler-annotation.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

49
dependencies/poppler/include/qt5/poppler-converter-private.h vendored Normal file
View File

@ -0,0 +1,49 @@
/* poppler-converter-private.h: Qt interface to poppler
* Copyright (C) 2007, 2009, Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2008, Pino Toscano <pino@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef POPPLER_QT5_CONVERTER_PRIVATE_H
#define POPPLER_QT5_CONVERTER_PRIVATE_H
#include <QtCore/QString>
class QIODevice;
namespace Poppler {
class DocumentData;
class BaseConverterPrivate
{
public:
BaseConverterPrivate();
virtual ~BaseConverterPrivate();
QIODevice* openDevice();
void closeDevice();
DocumentData *document;
QString outputFileName;
QIODevice *iodev;
bool ownIodev : 1;
BaseConverter::Error lastError;
};
}
#endif

42
dependencies/poppler/include/qt5/poppler-embeddedfile-private.h vendored Normal file
View File

@ -0,0 +1,42 @@
/* poppler-embeddedfile-private.h: Qt interface to poppler
* Copyright (C) 2005, 2008, 2009, 2012, Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2005, Brad Hards <bradh@frogmouth.net>
* Copyright (C) 2008, 2011, Pino Toscano <pino@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef POPPLER_EMBEDDEDFILE_PRIVATE_H
#define POPPLER_EMBEDDEDFILE_PRIVATE_H
class FileSpec;
namespace Poppler
{
class EmbeddedFileData
{
public:
EmbeddedFileData(FileSpec *fs);
~EmbeddedFileData();
EmbFile *embFile() const;
FileSpec *filespec;
};
}
#endif

17
dependencies/poppler/include/qt5/poppler-export.h vendored Normal file
View File

@ -0,0 +1,17 @@
/*
* This file is used to set the poppler_qt5_EXPORT macros right.
* This is needed for setting the visibility on windows, it will have no effect on other platforms.
*/
#if defined(_WIN32)
# define LIB_EXPORT __declspec(dllexport)
# define LIB_IMPORT __declspec(dllimport)
#else
# define LIB_EXPORT
# define LIB_IMPORT
#endif
#ifdef poppler_qt5_EXPORTS
# define POPPLER_QT5_EXPORT LIB_EXPORT
#else
# define POPPLER_QT5_EXPORT LIB_IMPORT
#endif

343
dependencies/poppler/include/qt5/poppler-form.h vendored Normal file
View File

@ -0,0 +1,343 @@
/* poppler-form.h: qt interface to poppler
* Copyright (C) 2007-2008, Pino Toscano <pino@kde.org>
* Copyright (C) 2008, 2011, Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2012, Adam Reichold <adamreichold@myopera.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _POPPLER_QT5_FORM_H_
#define _POPPLER_QT5_FORM_H_
#include <QtCore/QRectF>
#include <QtCore/QStringList>
#include "poppler-export.h"
class Page;
class FormWidget;
class FormWidgetButton;
class FormWidgetText;
class FormWidgetChoice;
namespace Poppler {
class DocumentData;
class Link;
class FormFieldData;
/**
The base class representing a form field.
\since 0.6
*/
class POPPLER_QT5_EXPORT FormField {
public:
/**
The different types of form field.
*/
enum FormType {
FormButton, ///< A button field. See \ref Poppler::FormFieldButton::ButtonType "ButtonType"
FormText, ///< A text field. See \ref Poppler::FormFieldText::TextType "TextType"
FormChoice, ///< A single choice field. See \ref Poppler::FormFieldChoice::ChoiceType "ChoiceType"
FormSignature ///< A signature field.
};
virtual ~FormField();
/**
The type of the field.
*/
virtual FormType type() const = 0;
/**
\return The size of the field, in normalized coordinates, i.e.
[0..1] with regard to the dimensions (cropbox) of the page
*/
QRectF rect() const;
/**
The ID of the field.
*/
int id() const;
/**
The internal name of the field.
*/
QString name() const;
/**
The internal fully qualified name of the field.
\since 0.18
*/
QString fullyQualifiedName() const;
/**
The name of the field to be used in user interface (eg messages to
the user).
*/
QString uiName() const;
/**
Whether this form field is read-only.
*/
bool isReadOnly() const;
/**
Whether this form field is visible.
*/
bool isVisible() const;
/**
The activation action of this form field.
\note It may be null.
*/
Link* activationAction() const;
protected:
/// \cond PRIVATE
FormField(FormFieldData &dd);
FormFieldData *m_formData;
/// \endcond
private:
Q_DISABLE_COPY(FormField)
};
/**
A form field that represents a "button".
\since 0.8
*/
class POPPLER_QT5_EXPORT FormFieldButton : public FormField {
public:
/**
* The types of button field.
*/
enum ButtonType
{
Push, ///< A simple push button.
CheckBox, ///< A check box.
Radio ///< A radio button.
};
/// \cond PRIVATE
FormFieldButton(DocumentData *doc, ::Page *p, ::FormWidgetButton *w);
/// \endcond
virtual ~FormFieldButton();
virtual FormType type() const;
/**
The particular type of the button field.
*/
ButtonType buttonType() const;
/**
* The caption to be used for the button.
*/
QString caption() const;
/**
The state of the button.
*/
bool state() const;
/**
Sets the state of the button to the new \p state .
*/
void setState( bool state );
/**
The list with the IDs of siblings (ie, buttons belonging to the same
group as the current one.
Valid only for \ref Radio buttons, an empty list otherwise.
*/
QList<int> siblings() const;
private:
Q_DISABLE_COPY(FormFieldButton)
};
/**
A form field that represents a text input.
\since 0.6
*/
class POPPLER_QT5_EXPORT FormFieldText : public FormField {
public:
/**
The particular type of this text field.
*/
enum TextType {
Normal, ///< A simple singleline text field.
Multiline, ///< A multiline text field.
FileSelect ///< An input field to select the path of a file on disk.
};
/// \cond PRIVATE
FormFieldText(DocumentData *doc, ::Page *p, ::FormWidgetText *w);
/// \endcond
virtual ~FormFieldText();
virtual FormType type() const;
/**
The text type of the text field.
*/
TextType textType() const;
/**
The text associated with the text field.
*/
QString text() const;
/**
Sets the text associated with the text field to the specified
\p text.
*/
void setText( const QString& text );
/**
Whether this text field is a password input, eg its text \b must be
replaced with asterisks.
Always false for \ref FileSelect text fields.
*/
bool isPassword() const;
/**
Whether this text field should allow rich text.
*/
bool isRichText() const;
/**
The maximum length for the text of this field, or -1 if not set.
*/
int maximumLength() const;
/**
The horizontal alignment for the text of this text field.
*/
Qt::Alignment textAlignment() const;
/**
Whether the text inserted manually in the field (where possible)
can be spell-checked.
*/
bool canBeSpellChecked() const;
private:
Q_DISABLE_COPY(FormFieldText)
};
/**
A form field that represents a choice field.
\since 0.6
*/
class POPPLER_QT5_EXPORT FormFieldChoice : public FormField {
public:
/**
The particular type of this choice field.
*/
enum ChoiceType {
ComboBox, ///< A simple singleline text field.
ListBox ///< A multiline text field.
};
/// \cond PRIVATE
FormFieldChoice(DocumentData *doc, ::Page *p, ::FormWidgetChoice *w);
/// \endcond
virtual ~FormFieldChoice();
virtual FormType type() const;
/**
The choice type of the choice field.
*/
ChoiceType choiceType() const;
/**
The possible choices of the choice field.
*/
QStringList choices() const;
/**
Whether this FormFieldChoice::ComboBox is editable, i.e. the user
can type in a custom value.
Always false for the other types of choices.
*/
bool isEditable() const;
/**
Whether more than one choice of this FormFieldChoice::ListBox
can be selected at the same time.
Always false for the other types of choices.
*/
bool multiSelect() const;
/**
The currently selected choices.
*/
QList<int> currentChoices() const;
/**
Sets the selected choices to \p choice.
*/
void setCurrentChoices( const QList<int> &choice );
/**
The text entered into an editable combo box choice field. Otherwise a null string.
\since 0.22
*/
QString editChoice() const;
/**
Sets the text entered into an editable combo box choice field. Otherwise does nothing.
\since 0.22
*/
void setEditChoice(const QString& text);
/**
The horizontal alignment for the text of this text field.
*/
Qt::Alignment textAlignment() const;
/**
Whether the text inserted manually in the field (where possible)
can be spell-checked.
Returns false if the field is not an editable text field.
*/
bool canBeSpellChecked() const;
private:
Q_DISABLE_COPY(FormFieldChoice)
};
}
#endif

57
dependencies/poppler/include/qt5/poppler-link-extractor-private.h vendored Normal file
View File

@ -0,0 +1,57 @@
/* poppler-link-extractor_p.h: qt interface to poppler
* Copyright (C) 2007, 2008, 2011, Pino Toscano <pino@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _POPPLER_LINK_EXTRACTOR_H_
#define _POPPLER_LINK_EXTRACTOR_H_
#include <Object.h>
#include <OutputDev.h>
#include <QtCore/QList>
namespace Poppler
{
class Link;
class PageData;
class LinkExtractorOutputDev : public OutputDev
{
public:
LinkExtractorOutputDev(PageData *data);
virtual ~LinkExtractorOutputDev();
// inherited from OutputDev
virtual GBool upsideDown() { return gFalse; }
virtual GBool useDrawChar() { return gFalse; }
virtual GBool interpretType3Chars() { return gFalse; }
virtual void processLink(::AnnotLink *link);
// our stuff
QList< Link* > links();
private:
PageData *m_data;
double m_pageCropWidth;
double m_pageCropHeight;
QList< Link* > m_links;
};
}
#endif

602
dependencies/poppler/include/qt5/poppler-link.h vendored Normal file
View File

@ -0,0 +1,602 @@
/* poppler-link.h: qt interface to poppler
* Copyright (C) 2006, 2013, Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2007-2008, 2010, Pino Toscano <pino@kde.org>
* Copyright (C) 2010, 2012, Guillermo Amaral <gamaral@kdab.com>
* Copyright (C) 2012, Tobias Koenig <tokoe@kdab.com>
* Copyright (C) 2013, Anthony Granger <grangeranthony@gmail.com>
* Adapting code from
* Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _POPPLER_LINK_H_
#define _POPPLER_LINK_H_
#include <QtCore/QString>
#include <QtCore/QRectF>
#include <QtCore/QSharedDataPointer>
#include "poppler-export.h"
struct Ref;
class MediaRendition;
namespace Poppler {
class LinkPrivate;
class LinkGotoPrivate;
class LinkExecutePrivate;
class LinkBrowsePrivate;
class LinkActionPrivate;
class LinkSoundPrivate;
class LinkJavaScriptPrivate;
class LinkMoviePrivate;
class LinkDestinationData;
class LinkDestinationPrivate;
class LinkRenditionPrivate;
class MediaRendition;
class SoundObject;
/**
* \short A destination.
*
* The LinkDestination class represent a "destination" (in terms of visual
* viewport to be displayed) for \link Poppler::LinkGoto GoTo\endlink links,
* and items in the table of contents (TOC) of a document.
*
* Coordinates are in 0..1 range
*/
class POPPLER_QT5_EXPORT LinkDestination
{
public:
/**
* The possible kind of "viewport destination".
*/
enum Kind
{
/**
* The new viewport is specified in terms of:
* - possibile new left coordinate (see isChangeLeft() )
* - possibile new top coordinate (see isChangeTop() )
* - possibile new zoom level (see isChangeZoom() )
*/
destXYZ = 1,
destFit = 2,
destFitH = 3,
destFitV = 4,
destFitR = 5,
destFitB = 6,
destFitBH = 7,
destFitBV = 8
};
/// \cond PRIVATE
LinkDestination(const LinkDestinationData &data);
LinkDestination(const QString &description);
/// \endcond
/**
* Copy constructor.
*/
LinkDestination(const LinkDestination &other);
/**
* Destructor.
*/
~LinkDestination();
// Accessors.
/**
* The kind of destination.
*/
Kind kind() const;
/**
* Which page is the target of this destination.
*
* \note this number is 1-based, so for a 5 pages document the
* valid page numbers go from 1 to 5 (both included).
*/
int pageNumber() const;
/**
* The new left for the viewport of the target page, in case
* it is specified to be changed (see isChangeLeft() )
*/
double left() const;
double bottom() const;
double right() const;
/**
* The new top for the viewport of the target page, in case
* it is specified to be changed (see isChangeTop() )
*/
double top() const;
double zoom() const;
/**
* Whether the left of the viewport on the target page should
* be changed.
*
* \see left()
*/
bool isChangeLeft() const;
/**
* Whether the top of the viewport on the target page should
* be changed.
*
* \see top()
*/
bool isChangeTop() const;
/**
* Whether the zoom level should be changed.
*
* \see zoom()
*/
bool isChangeZoom() const;
/**
* Return a string repesentation of this destination.
*/
QString toString() const;
/**
* Return the name of this destination.
*
* \since 0.12
*/
QString destinationName() const;
/**
* Assignment operator.
*/
LinkDestination& operator=(const LinkDestination &other);
private:
QSharedDataPointer< LinkDestinationPrivate > d;
};
/**
* \short Encapsulates data that describes a link.
*
* This is the base class for links. It makes mandatory for inherited
* kind of links to reimplement the linkType() method and return the type of
* the link described by the reimplemented class.
*/
class POPPLER_QT5_EXPORT Link
{
public:
/// \cond PRIVATE
Link( const QRectF &linkArea );
/// \endcond
/**
* The possible kinds of link.
*
* Inherited classes must return an unique identifier
*/
enum LinkType
{
None, ///< Unknown link
Goto, ///< A "Go To" link
Execute, ///< A command to be executed
Browse, ///< An URL to be browsed (eg "http://poppler.freedesktop.org")
Action, ///< A "standard" action to be executed in the viewer
Sound, ///< A link representing a sound to be played
Movie, ///< An action to be executed on a movie
Rendition, ///< A rendition link \since 0.20
JavaScript ///< A JavaScript code to be interpreted \since 0.10
};
/**
* The type of this link.
*/
virtual LinkType linkType() const;
/**
* Destructor.
*/
virtual ~Link();
/**
* The area of a Page where the link should be active.
*
* \note this can be a null rect, in this case the link represents
* a general action. The area is given in 0..1 range
*/
QRectF linkArea() const;
protected:
/// \cond PRIVATE
Link( LinkPrivate &dd );
Q_DECLARE_PRIVATE( Link )
LinkPrivate *d_ptr;
/// \endcond
private:
Q_DISABLE_COPY( Link )
};
/**
* \brief Viewport reaching request.
*
* With a LinkGoto link, the document requests the specified viewport to be
* reached (aka, displayed in a viewer). Furthermore, if a file name is specified,
* then the destination refers to that document (and not to the document the
* current LinkGoto belongs to).
*/
class POPPLER_QT5_EXPORT LinkGoto : public Link
{
public:
/**
* Create a new Goto link.
*
* \param linkArea the active area of the link
* \param extFileName if not empty, the file name to be open
* \param destination the destination to be reached
*/
LinkGoto( const QRectF &linkArea, QString extFileName, const LinkDestination & destination );
/**
* Destructor.
*/
~LinkGoto();
/**
* Whether the destination is in an external document
* (i.e. not the current document)
*/
bool isExternal() const;
// query for goto parameters
/**
* The file name of the document the destination() refers to,
* or an empty string in case it refers to the current document.
*/
QString fileName() const;
/**
* The destination to reach.
*/
LinkDestination destination() const;
LinkType linkType() const;
private:
Q_DECLARE_PRIVATE( LinkGoto )
Q_DISABLE_COPY( LinkGoto )
};
/**
* \brief Generic execution request.
*
* The LinkExecute link represent a "file name" execution request. The result
* depends on the \link fileName() file name\endlink:
* - if it is a document, then it is requested to be open
* - otherwise, it represents an executable to be run with the specified parameters
*/
class POPPLER_QT5_EXPORT LinkExecute : public Link
{
public:
/**
* The file name to be executed
*/
QString fileName() const;
/**
* The parameters for the command.
*/
QString parameters() const;
/**
* Create a new Execute link.
*
* \param linkArea the active area of the link
* \param file the file name to be open, or the program to be execute
* \param params the parameters for the program to execute
*/
LinkExecute( const QRectF &linkArea, const QString & file, const QString & params );
/**
* Destructor.
*/
~LinkExecute();
LinkType linkType() const;
private:
Q_DECLARE_PRIVATE( LinkExecute )
Q_DISABLE_COPY( LinkExecute )
};
/**
* \brief An URL to browse.
*
* The LinkBrowse link holds a URL (eg 'http://poppler.freedesktop.org',
* 'mailto:john@some.org', etc) to be open.
*
* The format of the URL is specified by RFC 2396 (http://www.ietf.org/rfc/rfc2396.txt)
*/
class POPPLER_QT5_EXPORT LinkBrowse : public Link
{
public:
/**
* The URL to open
*/
QString url() const;
/**
* Create a new browse link.
*
* \param linkArea the active area of the link
* \param url the URL to be open
*/
LinkBrowse( const QRectF &linkArea, const QString &url );
/**
* Destructor.
*/
~LinkBrowse();
LinkType linkType() const;
private:
Q_DECLARE_PRIVATE( LinkBrowse )
Q_DISABLE_COPY( LinkBrowse )
};
/**
* \brief "Standard" action request.
*
* The LinkAction class represents a link that request a "standard" action
* to be performed by the viewer on the displayed document.
*/
class POPPLER_QT5_EXPORT LinkAction : public Link
{
public:
/**
* The possible types of actions
*/
enum ActionType { PageFirst = 1,
PagePrev = 2,
PageNext = 3,
PageLast = 4,
HistoryBack = 5,
HistoryForward = 6,
Quit = 7,
Presentation = 8,
EndPresentation = 9,
Find = 10,
GoToPage = 11,
Close = 12,
Print = 13 ///< \since 0.16
};
/**
* The action of the current LinkAction
*/
ActionType actionType() const;
/**
* Create a new Action link, that executes a specified action
* on the document.
*
* \param linkArea the active area of the link
* \param actionType which action should be executed
*/
LinkAction( const QRectF &linkArea, ActionType actionType );
/**
* Destructor.
*/
~LinkAction();
LinkType linkType() const;
private:
Q_DECLARE_PRIVATE( LinkAction )
Q_DISABLE_COPY( LinkAction )
};
/**
* Sound: a sound to be played.
*
* \since 0.6
*/
class POPPLER_QT5_EXPORT LinkSound : public Link
{
public:
// create a Link_Sound
LinkSound( const QRectF &linkArea, double volume, bool sync, bool repeat, bool mix, SoundObject *sound );
/**
* Destructor.
*/
virtual ~LinkSound();
LinkType linkType() const;
/**
* The volume to be used when playing the sound.
*
* The volume is in the range [ -1, 1 ], where:
* - a negative number: no volume (mute)
* - 1: full volume
*/
double volume() const;
/**
* Whether the playback of the sound should be synchronous
* (thus blocking, waiting for the end of the sound playback).
*/
bool synchronous() const;
/**
* Whether the sound should be played continuously (that is,
* started again when it ends)
*/
bool repeat() const;
/**
* Whether the playback of this sound can be mixed with
* playbacks with other sounds of the same document.
*
* \note When false, any other playback must be stopped before
* playing the sound.
*/
bool mix() const;
/**
* The sound object to be played
*/
SoundObject *sound() const;
private:
Q_DECLARE_PRIVATE( LinkSound )
Q_DISABLE_COPY( LinkSound )
};
/**
* Rendition: Rendition link.
*
* \since 0.20
*/
class POPPLER_QT5_EXPORT LinkRendition : public Link
{
public:
/**
* Describes the possible rendition actions.
*
* \since 0.22
*/
enum RenditionAction {
NoRendition,
PlayRendition,
StopRendition,
PauseRendition,
ResumeRendition
};
/**
* Create a new rendition link.
*
* \param linkArea the active area of the link
* \param rendition the media rendition object. Ownership is taken
* \param operation the numeric operation (action) (@see ::LinkRendition::RenditionOperation)
* \param script the java script code
* \param annotationReference the object reference of the screen annotation associated with this rendition action
* \since 0.22
*/
LinkRendition( const QRectF &linkArea, ::MediaRendition *rendition, int operation, const QString &script, const Ref &annotationReference );
/**
* Destructor.
*/
virtual ~LinkRendition();
LinkType linkType() const;
/**
* Returns the media rendition object if the redition provides one, @c 0 otherwise
*/
MediaRendition *rendition() const;
/**
* Returns the action that should be executed if a rendition object is provided.
*
* \since 0.22
*/
RenditionAction action() const;
/**
* The JS code that shall be executed or an empty string.
*
* \since 0.22
*/
QString script() const;
/**
* Returns whether the given @p annotation is the referenced screen annotation for this rendition @p link.
*
* \since 0.22
*/
bool isReferencedAnnotation( const ScreenAnnotation *annotation ) const;
private:
Q_DECLARE_PRIVATE( LinkRendition )
Q_DISABLE_COPY( LinkRendition )
};
/**
* JavaScript: a JavaScript code to be interpreted.
*
* \since 0.10
*/
class POPPLER_QT5_EXPORT LinkJavaScript : public Link
{
public:
/**
* Create a new JavaScript link.
*
* \param linkArea the active area of the link
* \param js the JS code to be interpreted
*/
LinkJavaScript( const QRectF &linkArea, const QString &js );
/**
* Destructor.
*/
virtual ~LinkJavaScript();
LinkType linkType() const;
/**
* The JS code
*/
QString script() const;
private:
Q_DECLARE_PRIVATE( LinkJavaScript )
Q_DISABLE_COPY( LinkJavaScript )
};
/**
* Movie: a movie to be played.
*
* \since 0.20
*/
class POPPLER_QT5_EXPORT LinkMovie : public Link
{
public:
/**
* Describes the operation to be performed on the movie.
*/
enum Operation { Play,
Stop,
Pause,
Resume
};
/**
* Create a new Movie link.
*
* \param linkArea the active area of the link
* \param operation the operation to be performed on the movie
* \param annotationTitle the title of the movie annotation identifying the movie to be played
* \param annotationReference the object reference of the movie annotation identifying the movie to be played
*
* Note: This constructor is supposed to be used by Poppler::Page only.
*/
LinkMovie( const QRectF &linkArea, Operation operation, const QString &annotationTitle, const Ref &annotationReference );
/**
* Destructor.
*/
~LinkMovie();
LinkType linkType() const;
/**
* Returns the operation to be performed on the movie.
*/
Operation operation() const;
/**
* Returns whether the given @p annotation is the referenced movie annotation for this movie @p link.
*/
bool isReferencedAnnotation( const MovieAnnotation *annotation ) const;
private:
Q_DECLARE_PRIVATE( LinkMovie )
Q_DISABLE_COPY( LinkMovie )
};
}
#endif

100
dependencies/poppler/include/qt5/poppler-media.h vendored Normal file
View File

@ -0,0 +1,100 @@
/* poppler-media.h: qt interface to poppler
* Copyright (C) 2012 Guillermo A. Amaral B. <gamaral@kde.org>
* Copyright (C) 2012, 2013 Albert Astals Cid <aacid@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __POPPLER_MEDIARENDITION_H__
#define __POPPLER_MEDIARENDITION_H__
#include "poppler-export.h"
#include <QtCore/QSize>
#include <QtCore/QString>
class MediaRendition;
class QIODevice;
namespace Poppler
{
class MediaRenditionPrivate;
/**
Qt wrapper for MediaRendition.
\since 0.20
*/
class POPPLER_QT5_EXPORT MediaRendition {
public:
/**
Constructs a MediaRendition. Takes ownership of the passed rendition
*/
MediaRendition(::MediaRendition *rendition);
~MediaRendition();
/**
Check if wrapper is holding a valid rendition object.
*/
bool isValid() const;
/**
Returns content type.
*/
QString contentType() const;
/**
Returns file name.
*/
QString fileName() const;
/**
Returns true if media is embedded.
*/
bool isEmbedded() const;
/**
Returns data buffer.
*/
QByteArray data() const;
/**
Convenience accessor for auto-play parameter.
*/
bool autoPlay() const;
/**
Convenience accessor for show controls parameter.
*/
bool showControls() const;
/**
Convenience accessor for repeat count parameter.
*/
float repeatCount() const;
/**
Convenience accessor for size parameter.
*/
QSize size() const;
private:
Q_DECLARE_PRIVATE( MediaRendition )
MediaRenditionPrivate *d_ptr;
Q_DISABLE_COPY( MediaRendition )
};
}
#endif /* __POPPLER_MEDIARENDITION_H__ */

121
dependencies/poppler/include/qt5/poppler-optcontent-private.h vendored Normal file
View File

@ -0,0 +1,121 @@
/* poppler-optcontent-private.h: qt interface to poppler
*
* Copyright (C) 2007, Brad Hards <bradh@kde.org>
* Copyright (C) 2008, Pino Toscano <pino@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef POPPLER_OPTCONTENT_PRIVATE_H
#define POPPLER_OPTCONTENT_PRIVATE_H
#include <QtCore/QMap>
#include <QtCore/QSet>
#include <QtCore/QString>
class Array;
class OCGs;
class OptionalContentGroup;
class QModelIndex;
namespace Poppler
{
class OptContentItem;
class OptContentModel;
class OptContentModelPrivate;
class RadioButtonGroup
{
public:
RadioButtonGroup( OptContentModelPrivate *ocModel, Array *rbarray);
~RadioButtonGroup();
QSet<OptContentItem *> setItemOn( OptContentItem *itemToSetOn );
private:
QList<OptContentItem*> itemsInGroup;
};
class OptContentItem
{
public:
enum ItemState { On, Off, HeadingOnly };
OptContentItem( OptionalContentGroup *group );
OptContentItem( const QString &label );
OptContentItem();
~OptContentItem();
QString name() const { return m_name; }
ItemState state() const { return m_stateBackup; }
bool setState(ItemState state, QSet<OptContentItem *> &changedItems);
QList<OptContentItem*> childList() { return m_children; }
void setParent( OptContentItem* parent) { m_parent = parent; }
OptContentItem* parent() { return m_parent; }
void addChild( OptContentItem *child );
void appendRBGroup( RadioButtonGroup *rbgroup );
bool isEnabled() const { return m_enabled; }
QSet<OptContentItem*> recurseListChildren(bool includeMe = false) const;
private:
OptionalContentGroup *m_group;
QString m_name;
ItemState m_state; // true for ON, false for OFF
ItemState m_stateBackup;
QList<OptContentItem*> m_children;
OptContentItem *m_parent;
QList<RadioButtonGroup*> m_rbGroups;
bool m_enabled;
};
class OptContentModelPrivate
{
public:
OptContentModelPrivate( OptContentModel *qq, OCGs *optContent );
~OptContentModelPrivate();
void parseRBGroupsArray( Array *rBGroupArray );
OptContentItem *nodeFromIndex(const QModelIndex &index, bool canBeNull = false) const;
QModelIndex indexFromItem(OptContentItem *node, int column) const;
/**
Get the OptContentItem corresponding to a given reference value.
\param ref the reference number (e.g. from Object.getRefNum()) to look up
\return the matching optional content item, or null if the reference wasn't found
*/
OptContentItem *itemFromRef( const QString &ref ) const;
void setRootNode(OptContentItem *node);
OptContentModel *q;
QMap<QString, OptContentItem*> m_optContentItems;
QList<RadioButtonGroup*> m_rbgroups;
OptContentItem *m_rootNode;
private:
void addChild( OptContentItem *parent, OptContentItem *child);
void parseOrderArray( OptContentItem *parentNode, Array *orderArray );
};
}
#endif

77
dependencies/poppler/include/qt5/poppler-optcontent.h vendored Normal file
View File

@ -0,0 +1,77 @@
/* poppler-optcontent.h: qt interface to poppler
*
* Copyright (C) 2007, Brad Hards <bradh@kde.org>
* Copyright (C) 2008, Pino Toscano <pino@kde.org>
* Copyright (C) 2013, Anthony Granger <grangeranthony@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef POPPLER_OPTCONTENT_H
#define POPPLER_OPTCONTENT_H
#include <QtCore/QAbstractListModel>
#include "poppler-export.h"
class OCGs;
namespace Poppler
{
class Document;
class OptContentModelPrivate;
/**
* \brief Model for optional content
*
* OptContentModel is an item model representing the optional content items
* that can be found in PDF documents.
*
* The model offers a mostly read-only display of the data, allowing to
* enable/disable some contents setting the Qt::CheckStateRole data role.
*
* \since 0.8
*/
class POPPLER_QT5_EXPORT OptContentModel : public QAbstractItemModel
{
friend class Document;
Q_OBJECT
public:
virtual ~OptContentModel();
QModelIndex index(int row, int column, const QModelIndex &parent) const;
QModelIndex parent(const QModelIndex &child) const;
int rowCount(const QModelIndex &parent = QModelIndex()) const;
int columnCount(const QModelIndex &parent) const;
QVariant data(const QModelIndex &index, int role) const;
virtual bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole );
Qt::ItemFlags flags ( const QModelIndex & index ) const;
virtual QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
private:
OptContentModel( OCGs *optContent, QObject *parent = 0);
friend class OptContentModelPrivate;
OptContentModelPrivate *d;
};
}
#endif

54
dependencies/poppler/include/qt5/poppler-page-private.h vendored Normal file
View File

@ -0,0 +1,54 @@
/* poppler-page.cc: qt interface to poppler
* Copyright (C) 2005, Net Integration Technologies, Inc.
* Copyright (C) 2007, 2012, Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2008, Pino Toscano <pino@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _POPPLER_PAGE_PRIVATE_H_
#define _POPPLER_PAGE_PRIVATE_H_
#include "CharTypes.h"
class QRectF;
class LinkAction;
class Page;
class TextPage;
namespace Poppler
{
class DocumentData;
class PageTransition;
class PageData {
public:
Link* convertLinkActionToLink(::LinkAction * a, const QRectF &linkArea);
DocumentData *parentDoc;
::Page *page;
int index;
PageTransition *transition;
static Link* convertLinkActionToLink(::LinkAction * a, DocumentData *parentDoc, const QRectF &linkArea);
TextPage *prepareTextSearch(const QString &text, Page::SearchMode caseSensitive, Page::Rotation rotate, GBool *sCase, QVector<Unicode> *u);
};
}
#endif

28
dependencies/poppler/include/qt5/poppler-page-transition-private.h vendored Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (C) 2005, Albert Astals Cid
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
class Object;
namespace Poppler {
class PageTransitionParams {
public:
Object *dictObj;
};
}

148
dependencies/poppler/include/qt5/poppler-page-transition.h vendored Normal file
View File

@ -0,0 +1,148 @@
/* PageTransition.h
* Copyright (C) 2005, Net Integration Technologies, Inc.
* Copyright (C) 2005, Brad Hards <bradh@frogmouth.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __PAGETRANSITION_X_H__
#define __PAGETRANSITION_X_H__
#include "poppler-export.h"
namespace Poppler {
class PageTransitionParams;
class PageTransitionData;
/**
\brief Describes how a PDF file viewer shall perform the transition
from one page to another
In PDF files there is a way to specify if the viewer shall use
certain effects to perform the transition from one page to
another. This feature can be used, e.g., in a PDF-based beamer
presentation.
This utility class represents the transition effect, and can be
used to extract the information from a PDF object.
*/
class POPPLER_QT5_EXPORT PageTransition {
public:
/** \brief transition effect that shall be used
*/
// if changed remember to keep in sync with PageTransition.h enum
enum Type {
Replace = 0,
Split,
Blinds,
Box,
Wipe,
Dissolve,
Glitter,
Fly,
Push,
Cover,
Uncover,
Fade
};
/** \brief alignment of the transition effect that shall be used
*/
// if changed remember to keep in sync with PageTransition.h enum
enum Alignment {
Horizontal = 0,
Vertical
};
/** \brief direction of the transition effect that shall be used
*/
// if changed remember to keep in sync with PageTransition.h enum
enum Direction {
Inward = 0,
Outward
};
/** \brief Construct a new PageTransition object from a page dictionary.
Users of the library will rarely need to construct a
PageTransition object themselves. Instead, the method
Poppler::Page::transition() can be used to find out if a certain
transition effect is specified.
@warning In case or error, this method will print an error message to stderr,
and construct a default object.
@param params an object whose dictionary will be read and
parsed. This must be a valid object, whose dictionaries are
accessed by the constructor. The object is only accessed by this
constructor, and may be deleted after the constructor returns.
*/
PageTransition(const PageTransitionParams &params);
/** \brief copy constructor */
PageTransition(const PageTransition &pt);
/**
Destructor
*/
~PageTransition();
/**
\brief Get type of the transition.
*/
Type type() const;
/**
\brief Get duration of the transition in seconds.
*/
int duration() const;
/**
\brief Get dimension in which the transition effect occurs.
*/
Alignment alignment() const;
/**
\brief Get direction of motion of the transition effect.
*/
Direction direction() const;
/**
\brief Get direction in which the transition effect moves.
*/
int angle() const;
/**
\brief Get starting or ending scale.
*/
double scale() const;
/**
\brief Returns true if the area to be flown is rectangular and
opaque.
*/
bool isRectangular() const;
private:
PageTransitionData *data;
};
}
#endif

240
dependencies/poppler/include/qt5/poppler-private.h vendored Normal file
View File

@ -0,0 +1,240 @@
/* poppler-private.h: qt interface to poppler
* Copyright (C) 2005, Net Integration Technologies, Inc.
* Copyright (C) 2005, 2008, Brad Hards <bradh@frogmouth.net>
* Copyright (C) 2006-2009, 2011, 2012 by Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2007-2009, 2011 by Pino Toscano <pino@kde.org>
* Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com>
* Copyright (C) 2011 Hib Eris <hib@hiberis.nl>
* Copyright (C) 2012, 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
* Copyright (C) 2013 Anthony Granger <grangeranthony@gmail.com>
* Inspired on code by
* Copyright (C) 2004 by Albert Astals Cid <tsdgeos@terra.es>
* Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _POPPLER_PRIVATE_H_
#define _POPPLER_PRIVATE_H_
#include <QtCore/QFile>
#include <QtCore/QPointer>
#include <QtCore/QVector>
#include <config.h>
#include <GfxState.h>
#include <GlobalParams.h>
#include <PDFDoc.h>
#include <FontInfo.h>
#include <OutputDev.h>
#include <Error.h>
#if defined(HAVE_SPLASH)
#include <SplashOutputDev.h>
#endif
#include "poppler-qt5.h"
#include "poppler-embeddedfile-private.h"
class LinkDest;
class FormWidget;
namespace Poppler {
/* borrowed from kpdf */
QString unicodeToQString(Unicode* u, int len);
QString UnicodeParsedString(GooString *s1);
GooString *QStringToUnicodeGooString(const QString &s);
GooString *QStringToGooString(const QString &s);
void qt5ErrorFunction(int pos, char *msg, va_list args);
class LinkDestinationData
{
public:
LinkDestinationData( LinkDest *l, GooString *nd, Poppler::DocumentData *pdfdoc, bool external )
: ld(l), namedDest(nd), doc(pdfdoc), externalDest(external)
{
}
LinkDest *ld;
GooString *namedDest;
Poppler::DocumentData *doc;
bool externalDest;
};
class DocumentData {
public:
DocumentData(const QString &filePath, GooString *ownerPassword, GooString *userPassword)
{
init();
m_filePath = filePath;
#if defined(_WIN32)
wchar_t *fileName = new WCHAR[filePath.length()];
int length = filePath.toWCharArray(fileName);
doc = new PDFDoc(fileName, length, ownerPassword, userPassword);
delete[] fileName;
#else
GooString *fileName = new GooString(QFile::encodeName(filePath));
doc = new PDFDoc(fileName, ownerPassword, userPassword);
#endif
delete ownerPassword;
delete userPassword;
}
DocumentData(const QByteArray &data, GooString *ownerPassword, GooString *userPassword)
{
Object obj;
fileContents = data;
obj.initNull();
MemStream *str = new MemStream((char*)fileContents.data(), 0, fileContents.length(), &obj);
init();
doc = new PDFDoc(str, ownerPassword, userPassword);
delete ownerPassword;
delete userPassword;
}
void init();
~DocumentData();
void addTocChildren( QDomDocument * docSyn, QDomNode * parent, GooList * items );
void setPaperColor(const QColor &color)
{
paperColor = color;
}
void fillMembers()
{
m_fontInfoIterator = new FontIterator(0, this);
int numEmb = doc->getCatalog()->numEmbeddedFiles();
if (!(0 == numEmb)) {
// we have some embedded documents, build the list
for (int yalv = 0; yalv < numEmb; ++yalv) {
FileSpec *fs = doc->getCatalog()->embeddedFile(yalv);
m_embeddedFiles.append(new EmbeddedFile(*new EmbeddedFileData(fs)));
}
}
}
static Document *checkDocument(DocumentData *doc);
PDFDoc *doc;
QString m_filePath;
QByteArray fileContents;
bool locked;
FontIterator *m_fontInfoIterator;
Document::RenderBackend m_backend;
QList<EmbeddedFile*> m_embeddedFiles;
QPointer<OptContentModel> m_optContentModel;
QColor paperColor;
int m_hints;
static int count;
};
class FontInfoData
{
public:
FontInfoData()
{
isEmbedded = false;
isSubset = false;
type = FontInfo::unknown;
}
FontInfoData( const FontInfoData &fid )
{
fontName = fid.fontName;
fontFile = fid.fontFile;
isEmbedded = fid.isEmbedded;
isSubset = fid.isSubset;
type = fid.type;
embRef = fid.embRef;
}
FontInfoData( ::FontInfo* fi )
{
if (fi->getName()) fontName = fi->getName()->getCString();
if (fi->getFile()) fontFile = fi->getFile()->getCString();
isEmbedded = fi->getEmbedded();
isSubset = fi->getSubset();
type = (Poppler::FontInfo::Type)fi->getType();
embRef = fi->getEmbRef();
}
QString fontName;
QString fontFile;
bool isEmbedded : 1;
bool isSubset : 1;
FontInfo::Type type;
Ref embRef;
};
class FontIteratorData
{
public:
FontIteratorData( int startPage, DocumentData *dd )
: fontInfoScanner( dd->doc, startPage )
, totalPages( dd->doc->getNumPages() )
, currentPage( qMax( startPage, 0 ) - 1 )
{
}
~FontIteratorData()
{
}
FontInfoScanner fontInfoScanner;
int totalPages;
int currentPage;
};
class TextBoxData
{
public:
TextBoxData()
: nextWord(0), hasSpaceAfter(false)
{
}
QString text;
QRectF bBox;
TextBox *nextWord;
QVector<QRectF> charBBoxes; // the boundingRect of each character
bool hasSpaceAfter;
};
class FormFieldData
{
public:
FormFieldData(DocumentData *_doc, ::Page *p, ::FormWidget *w) :
doc(_doc), page(p), fm(w)
{
}
DocumentData *doc;
::Page *page;
::FormWidget *fm;
QRectF box;
};
}
#endif

47
dependencies/poppler/include/qt5/poppler-qiodeviceoutstream-private.h vendored Normal file
View File

@ -0,0 +1,47 @@
/* poppler-qiodevicestream-private.h: Qt5 interface to poppler
* Copyright (C) 2008, Pino Toscano <pino@kde.org>
* Copyright (C) 2013 Adrian Johnson <ajohnson@redneon.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef POPPLER_QIODEVICESTREAM_PRIVATE_H
#define POPPLER_QIODEVICESTREAM_PRIVATE_H
#include "Object.h"
#include "Stream.h"
class QIODevice;
namespace Poppler {
class QIODeviceOutStream : public OutStream
{
public:
QIODeviceOutStream(QIODevice* device);
virtual ~QIODeviceOutStream();
virtual void close();
virtual Goffset getPos();
virtual void put(char c);
virtual void printf(const char *format, ...);
private:
QIODevice *m_device;
};
}
#endif

1771
dependencies/poppler/include/qt5/poppler-qt5.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
dependencies/poppler/lib/poppler-qt5.lib vendored Normal file
View File

Binary file not shown.