From 01afb7ab2d1cb3b32431976340b392c2a2539be4 Mon Sep 17 00:00:00 2001 From: Bill Moyers Date: Sun, 6 Aug 2017 09:04:48 -0400 Subject: [PATCH 01/32] Expose a few functions from fpdf_text.h for getting text on a page. --- .../com/shockwave/pdfium/PdfDocument.java | 3 + .../java/com/shockwave/pdfium/PdfiumCore.java | 228 +++++++++++++++++- src/main/jni/src/mainJNILib.cpp | 168 +++++++++++++ 3 files changed, 398 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/shockwave/pdfium/PdfDocument.java b/src/main/java/com/shockwave/pdfium/PdfDocument.java index b5306a67..82ca9a5e 100644 --- a/src/main/java/com/shockwave/pdfium/PdfDocument.java +++ b/src/main/java/com/shockwave/pdfium/PdfDocument.java @@ -1,6 +1,7 @@ package com.shockwave.pdfium; import android.graphics.RectF; +import android.content.res.AssetFileDescriptor; import android.os.ParcelFileDescriptor; import android.support.v4.util.ArrayMap; @@ -111,4 +112,6 @@ public RectF getBounds() { public boolean hasPage(int index) { return mNativePagesPtr.containsKey(index); } + + /*package*/ final Map mNativeTextPagesPtr = new ArrayMap<>(); } diff --git a/src/main/java/com/shockwave/pdfium/PdfiumCore.java b/src/main/java/com/shockwave/pdfium/PdfiumCore.java index 07b2a040..7209b99d 100644 --- a/src/main/java/com/shockwave/pdfium/PdfiumCore.java +++ b/src/main/java/com/shockwave/pdfium/PdfiumCore.java @@ -13,6 +13,8 @@ import java.io.FileDescriptor; import java.io.IOException; import java.lang.reflect.Field; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; import java.util.ArrayList; import java.util.List; @@ -78,6 +80,34 @@ private native void nativeRenderPageBitmap(long pagePtr, Bitmap bitmap, int dpi, private native long nativeGetBookmarkDestIndex(long docPtr, long bookmarkPtr); + private native long nativeLoadTextPage(long docPtr, int pageIndex); + + private native long[] nativeLoadTextPages(long docPtr, int fromIndex, int toIndex); + + private native void nativeCloseTextPage(long pagePtr); + + private native void nativeCloseTextPages(long[] pagesPtr); + + private native int nativeTextCountChars(long textPagePtr); + + private native int nativeTextGetText(long textPagePtr, int start_index, int count, short[] result); + + private native int nativeTextGetUnicode(long textPagePtr, int index); + + private native double[] nativeTextGetCharBox(long textPagePtr, int index); + + private native int nativeTextGetCharIndexAtPos(long textPagePtr, double x, double y, double xTolerance, double yTolerance); + + private native int nativeTextCountRects(long textPagePtr, int start_index, int count); + + private native double[] nativeTextGetRect(long textPagePtr, int rect_index); + + private native int nativeTextGetBoundedText(long textPagePtr, double left, double top, double right, double bottom, short[] arr); + + private static final Class FD_CLASS = FileDescriptor.class; + private static final String FD_FIELD_NAME = "descriptor"; + private static Field mFdField = null; + private native Size nativeGetPageSizeByIndex(long docPtr, int pageIndex, int dpi); private native long[] nativeGetPageLinks(long pagePtr); @@ -91,7 +121,6 @@ private native void nativeRenderPageBitmap(long pagePtr, Bitmap bitmap, int dpi, private native Point nativePageCoordsToDevice(long pagePtr, int startX, int startY, int sizeX, int sizeY, int rotate, double pageX, double pageY); - /* synchronize native methods */ private static final Object lock = new Object(); private static Field mFdField = null; @@ -440,4 +469,201 @@ public RectF mapRectToDevice(PdfDocument doc, int pageIndex, int startX, int sta coords.right, coords.bottom); return new RectF(leftTop.x, leftTop.y, rightBottom.x, rightBottom.y); } + + public long openTextPage(PdfDocument doc, int pageIndex) { + long textPagePtr; + synchronized (lock) { + textPagePtr = nativeLoadTextPage(doc.mNativeDocPtr, pageIndex); + doc.mNativeTextPagesPtr.put(pageIndex, textPagePtr); + return textPagePtr; + } + + } + + public long[] openTextPage(PdfDocument doc, int fromIndex, int toIndex) { + long[] textPagesPtr; + synchronized (lock) { + textPagesPtr = nativeLoadPages(doc.mNativeDocPtr, fromIndex, toIndex); + int pageIndex = fromIndex; + for (long page : textPagesPtr) { + if (pageIndex > toIndex) break; + doc.mNativeTextPagesPtr.put(pageIndex, page); + pageIndex++; + } + + return textPagesPtr; + } + } + + public int textPageCountChars(PdfDocument doc, int textPageIndex) { + synchronized (lock) { + try { + return nativeTextCountChars(doc.mNativeTextPagesPtr.get(textPageIndex)); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return -1; + } + + public String textPageGetText(PdfDocument doc, int textPageIndex, int startIndex, int length) { + synchronized (lock) { + try { + short[] buf = new short[length+1]; + + int r = nativeTextGetText(doc.mNativeTextPagesPtr.get(textPageIndex), startIndex, length, buf); + + byte[] bytes = new byte[(r-1)*2]; + ByteBuffer bb = ByteBuffer.wrap(bytes); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for (int i = 0; i < r-1; i++) { + short s = buf[i]; + bb.putShort(s); + } + return new String(bytes, "UTF-16LE"); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + return null; + } + } + + + + + + + + + + + public char textPageGetUnicode(PdfDocument doc, int textPageIndex, int index) { + synchronized (lock) { + try { + return (char)nativeTextGetUnicode(doc.mNativeTextPagesPtr.get(textPageIndex), index); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return 0; + } + + public class Rect { + public double left; + public double right; + public double bottom; + public double top; + } + + public Rect textPageGetCharBox(PdfDocument doc, int textPageIndex, int index) { + synchronized (lock) { + try { + double[] o = nativeTextGetCharBox(doc.mNativeTextPagesPtr.get(textPageIndex), index); + Rect r = new Rect(); + r.left = o[0]; + r.right = o[1]; + r.bottom = o[2]; + r.top = o[3]; + return r; + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return null; + } + + public int textPageGetCharIndexAtPos(PdfDocument doc, int textPageIndex, double x, double y, double xTolerance, double yTolerance) { + synchronized (lock) { + try { + return nativeTextGetCharIndexAtPos(doc.mNativeTextPagesPtr.get(textPageIndex), x, y, xTolerance, yTolerance); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return -1; + } + + public int textPageCountRects(PdfDocument doc, int textPageIndex, int start_index, int count) { + synchronized (lock) { + try { + return nativeTextCountRects(doc.mNativeTextPagesPtr.get(textPageIndex), start_index, count); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return -1; + } + + public Rect textPageGetRect(PdfDocument doc, int textPageIndex, int rect_index) { + synchronized (lock) { + try { + double[] o = nativeTextGetRect(doc.mNativeTextPagesPtr.get(textPageIndex), rect_index); + Rect r = new Rect(); + r.left = o[0]; + r.top = o[1]; + r.right = o[2]; + r.bottom = o[3]; + return r; + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return null; + } + + public String textPageGetBoundedText(PdfDocument doc, int textPageIndex, Rect rect, int length) { + synchronized (lock) { + try { + short[] buf = new short[length+1]; + + int r = nativeTextGetBoundedText(doc.mNativeTextPagesPtr.get(textPageIndex), rect.left, rect.top, rect.right, rect.bottom, buf); + + byte[] bytes = new byte[(r-1)*2]; + ByteBuffer bb = ByteBuffer.wrap(bytes); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for (int i = 0; i < r-1; i++) { + short s = buf[i]; + bb.putShort(s); + } + return new String(bytes, "UTF-16LE"); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + return null; + } + } } diff --git a/src/main/jni/src/mainJNILib.cpp b/src/main/jni/src/mainJNILib.cpp index a888e69f..cc87ab5a 100644 --- a/src/main/jni/src/mainJNILib.cpp +++ b/src/main/jni/src/mainJNILib.cpp @@ -16,6 +16,7 @@ using namespace android; #include #include +#include #include #include @@ -688,4 +689,171 @@ JNI_FUNC(jobject, PdfiumCore, nativePageCoordsToDevice)(JNI_ARGS, jlong pagePtr, return env->NewObject(clazz, constructorID, deviceX, deviceY); } +////////////////////////////////////////// +//Begin FPDF_TEXTPAGE section + +static jlong loadTextPageInternal(JNIEnv *env, DocumentFile *doc, int textPageIndex){ + try{ + if(doc == NULL) throw "Get page document null"; + + FPDF_PAGE page = reinterpret_cast(loadPageInternal(env, doc, textPageIndex)); + if(page != NULL){ + FPDF_TEXTPAGE textPage = FPDFText_LoadPage(page); + if (textPage == NULL) { + throw "Loaded text page is null"; + } + return reinterpret_cast(textPage); + }else{ + throw "Load page null"; + } + }catch(const char *msg){ + LOGE("%s", msg); + + jniThrowException(env, "java/lang/IllegalStateException", + "cannot load text page"); + + return -1; + } +} + +static void closeTextPageInternal(jlong textPagePtr) { FPDFText_ClosePage(reinterpret_cast(textPagePtr)); } + +JNI_FUNC(jlong, PdfiumCore, nativeLoadTextPage)(JNI_ARGS, jlong docPtr, jint pageIndex){ + DocumentFile *doc = reinterpret_cast(docPtr); + return loadTextPageInternal(env, doc, (int)pageIndex); +} +JNI_FUNC(jlongArray, PdfiumCore, nativeLoadTextPages)(JNI_ARGS, jlong docPtr, jint fromIndex, jint toIndex){ + DocumentFile *doc = reinterpret_cast(docPtr); + + if(toIndex < fromIndex) return NULL; + jlong pages[ toIndex - fromIndex + 1 ]; + + int i; + for(i = 0; i <= (toIndex - fromIndex); i++){ + pages[i] = loadTextPageInternal(env, doc, (int)(i + fromIndex)); + } + + jlongArray javaPages = env -> NewLongArray( (jsize)(toIndex - fromIndex + 1) ); + env -> SetLongArrayRegion(javaPages, 0, (jsize)(toIndex - fromIndex + 1), (const jlong*)pages); + + return javaPages; +} + +JNI_FUNC(void, PdfiumCore, nativeCloseTextPage)(JNI_ARGS, jlong textPagePtr){ closeTextPageInternal(textPagePtr); } +JNI_FUNC(void, PdfiumCore, nativeCloseTextPages)(JNI_ARGS, jlongArray textPagesPtr){ + int length = (int)(env -> GetArrayLength(textPagesPtr)); + jlong *textPages = env -> GetLongArrayElements(textPagesPtr, NULL); + + int i; + for(i = 0; i < length; i++){ closeTextPageInternal(textPages[i]); } +} + +//DLLEXPORT int STDCALL FPDFText_CountChars(FPDF_TEXTPAGE text_page); +JNI_FUNC(jint, PdfiumCore, nativeTextCountChars)(JNI_ARGS, jlong textPagePtr){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_CountChars(textPage); +} + +//DLLEXPORT unsigned int STDCALL FPDFText_GetUnicode(FPDF_TEXTPAGE text_page, int index); +JNI_FUNC(jint, PdfiumCore, nativeTextGetUnicode)(JNI_ARGS, jlong textPagePtr, jint index){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_GetUnicode(textPage, (int)index); +} + +/*DLLEXPORT void STDCALL FPDFText_GetCharBox(FPDF_TEXTPAGE text_page, + int index, + double* left, + double* right, + double* bottom, + double* top);*/ +JNI_FUNC(jdoubleArray, PdfiumCore, nativeTextGetCharBox)(JNI_ARGS, jlong textPagePtr, jint index){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jdoubleArray result = env->NewDoubleArray(4); + if (result == NULL) { + return NULL; + } + double fill[4]; + FPDFText_GetCharBox(textPage, (int)index, &fill[0], &fill[1], &fill[2], &fill[3]); + env->SetDoubleArrayRegion(result, 0, 4, (jdouble*)fill); + return result; +} + +/*DLLEXPORT int STDCALL FPDFText_GetCharIndexAtPos(FPDF_TEXTPAGE text_page, + double x, + double y, + double xTolerance, + double yTolerance);*/ +JNI_FUNC(jint, PdfiumCore, nativeTextGetCharIndexAtPos)(JNI_ARGS, jlong textPagePtr, jdouble x, jdouble y, jdouble xTolerance, jdouble yTolerance){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_GetCharIndexAtPos(textPage, (double)x, (double)y, (double)xTolerance, (double)yTolerance); +} + +/*DLLEXPORT int STDCALL FPDFText_GetText(FPDF_TEXTPAGE text_page, + int start_index, + int count, + unsigned short* result);*/ +JNI_FUNC(jint, PdfiumCore, nativeTextGetText)(JNI_ARGS, jlong textPagePtr, jint start_index, jint count, jshortArray result){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jboolean isCopy = 0; + unsigned short *arr = (unsigned short *)env->GetShortArrayElements(result, &isCopy); + jint output = (jint)FPDFText_GetText(textPage, (int)start_index, (int)count, arr); + if (isCopy) { + env->SetShortArrayRegion(result, 0, output, (jshort*)arr); + env->ReleaseShortArrayElements(result, (jshort*)arr, JNI_ABORT); + } + return output; +} + +/*DLLEXPORT int STDCALL FPDFText_CountRects(FPDF_TEXTPAGE text_page, + int start_index, + int count);*/ +JNI_FUNC(jint, PdfiumCore, nativeTextCountRects)(JNI_ARGS, jlong textPagePtr, jint start_index, jint count){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_CountRects(textPage, (int)start_index, (int) count); +} + +/*DLLEXPORT void STDCALL FPDFText_GetRect(FPDF_TEXTPAGE text_page, + int rect_index, + double* left, + double* top, + double* right, + double* bottom);*/ +JNI_FUNC(jdoubleArray, PdfiumCore, nativeTextGetRect)(JNI_ARGS, jlong textPagePtr, jint rect_index){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jdoubleArray result = env->NewDoubleArray(4); + if (result == NULL) { + return NULL; + } + double fill[4]; + FPDFText_GetRect(textPage, (int)rect_index, &fill[0], &fill[1], &fill[2], &fill[3]); + env->SetDoubleArrayRegion(result, 0, 4, (jdouble*)fill); + return result; +} + +/*DLLEXPORT int STDCALL FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page, + double left, + double top, + double right, + double bottom, + unsigned short* buffer, + int buflen); +*/ + +JNI_FUNC(jint, PdfiumCore, nativeTextGetBoundedText)(JNI_ARGS, jlong textPagePtr, jdouble left, jdouble top, jdouble right, jdouble bottom, jshortArray arr){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jboolean isCopy = 0; + unsigned short *buffer = NULL; + int bufLen = 0; + if (arr != NULL) { + buffer = (unsigned short *)env->GetShortArrayElements(arr, &isCopy); + bufLen = env->GetArrayLength(arr); + } + jint output = (jint)FPDFText_GetBoundedText(textPage, (double)left, (double)top, (double)right, (double)bottom, buffer, bufLen); + if (isCopy) { + env->SetShortArrayRegion(arr, 0, output, (jshort*)buffer); + env->ReleaseShortArrayElements(arr, (jshort*)buffer, JNI_ABORT); + } + return output; +} + }//extern C From 85ac0bbeca2a19f867932e47871d73fb1a555141 Mon Sep 17 00:00:00 2001 From: Bill Moyers Date: Sun, 6 Aug 2017 09:04:48 -0400 Subject: [PATCH 02/32] Expose a few functions from fpdf_text.h for getting text on a page. --- .../com/shockwave/pdfium/PdfDocument.java | 2 + .../java/com/shockwave/pdfium/PdfiumCore.java | 223 ++++++++++++++++++ src/main/jni/src/mainJNILib.cpp | 168 +++++++++++++ 3 files changed, 393 insertions(+) diff --git a/src/main/java/com/shockwave/pdfium/PdfDocument.java b/src/main/java/com/shockwave/pdfium/PdfDocument.java index b5306a67..62cbf51f 100644 --- a/src/main/java/com/shockwave/pdfium/PdfDocument.java +++ b/src/main/java/com/shockwave/pdfium/PdfDocument.java @@ -111,4 +111,6 @@ public RectF getBounds() { public boolean hasPage(int index) { return mNativePagesPtr.containsKey(index); } + + /*package*/ final Map mNativeTextPagesPtr = new ArrayMap<>(); } diff --git a/src/main/java/com/shockwave/pdfium/PdfiumCore.java b/src/main/java/com/shockwave/pdfium/PdfiumCore.java index 07b2a040..fe9f809a 100644 --- a/src/main/java/com/shockwave/pdfium/PdfiumCore.java +++ b/src/main/java/com/shockwave/pdfium/PdfiumCore.java @@ -13,6 +13,8 @@ import java.io.FileDescriptor; import java.io.IOException; import java.lang.reflect.Field; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; import java.util.ArrayList; import java.util.List; @@ -78,6 +80,30 @@ private native void nativeRenderPageBitmap(long pagePtr, Bitmap bitmap, int dpi, private native long nativeGetBookmarkDestIndex(long docPtr, long bookmarkPtr); + private native long nativeLoadTextPage(long docPtr, int pageIndex); + + private native long[] nativeLoadTextPages(long docPtr, int fromIndex, int toIndex); + + private native void nativeCloseTextPage(long pagePtr); + + private native void nativeCloseTextPages(long[] pagesPtr); + + private native int nativeTextCountChars(long textPagePtr); + + private native int nativeTextGetText(long textPagePtr, int start_index, int count, short[] result); + + private native int nativeTextGetUnicode(long textPagePtr, int index); + + private native double[] nativeTextGetCharBox(long textPagePtr, int index); + + private native int nativeTextGetCharIndexAtPos(long textPagePtr, double x, double y, double xTolerance, double yTolerance); + + private native int nativeTextCountRects(long textPagePtr, int start_index, int count); + + private native double[] nativeTextGetRect(long textPagePtr, int rect_index); + + private native int nativeTextGetBoundedText(long textPagePtr, double left, double top, double right, double bottom, short[] arr); + private native Size nativeGetPageSizeByIndex(long docPtr, int pageIndex, int dpi); private native long[] nativeGetPageLinks(long pagePtr); @@ -440,4 +466,201 @@ public RectF mapRectToDevice(PdfDocument doc, int pageIndex, int startX, int sta coords.right, coords.bottom); return new RectF(leftTop.x, leftTop.y, rightBottom.x, rightBottom.y); } + + public long openTextPage(PdfDocument doc, int pageIndex) { + long textPagePtr; + synchronized (lock) { + textPagePtr = nativeLoadTextPage(doc.mNativeDocPtr, pageIndex); + doc.mNativeTextPagesPtr.put(pageIndex, textPagePtr); + return textPagePtr; + } + + } + + public long[] openTextPage(PdfDocument doc, int fromIndex, int toIndex) { + long[] textPagesPtr; + synchronized (lock) { + textPagesPtr = nativeLoadPages(doc.mNativeDocPtr, fromIndex, toIndex); + int pageIndex = fromIndex; + for (long page : textPagesPtr) { + if (pageIndex > toIndex) break; + doc.mNativeTextPagesPtr.put(pageIndex, page); + pageIndex++; + } + + return textPagesPtr; + } + } + + public int textPageCountChars(PdfDocument doc, int textPageIndex) { + synchronized (lock) { + try { + return nativeTextCountChars(doc.mNativeTextPagesPtr.get(textPageIndex)); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return -1; + } + + public String textPageGetText(PdfDocument doc, int textPageIndex, int startIndex, int length) { + synchronized (lock) { + try { + short[] buf = new short[length+1]; + + int r = nativeTextGetText(doc.mNativeTextPagesPtr.get(textPageIndex), startIndex, length, buf); + + byte[] bytes = new byte[(r-1)*2]; + ByteBuffer bb = ByteBuffer.wrap(bytes); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for (int i = 0; i < r-1; i++) { + short s = buf[i]; + bb.putShort(s); + } + return new String(bytes, "UTF-16LE"); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + return null; + } + } + + + + + + + + + + + public char textPageGetUnicode(PdfDocument doc, int textPageIndex, int index) { + synchronized (lock) { + try { + return (char)nativeTextGetUnicode(doc.mNativeTextPagesPtr.get(textPageIndex), index); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return 0; + } + + public class Rect { + public double left; + public double right; + public double bottom; + public double top; + } + + public Rect textPageGetCharBox(PdfDocument doc, int textPageIndex, int index) { + synchronized (lock) { + try { + double[] o = nativeTextGetCharBox(doc.mNativeTextPagesPtr.get(textPageIndex), index); + Rect r = new Rect(); + r.left = o[0]; + r.right = o[1]; + r.bottom = o[2]; + r.top = o[3]; + return r; + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return null; + } + + public int textPageGetCharIndexAtPos(PdfDocument doc, int textPageIndex, double x, double y, double xTolerance, double yTolerance) { + synchronized (lock) { + try { + return nativeTextGetCharIndexAtPos(doc.mNativeTextPagesPtr.get(textPageIndex), x, y, xTolerance, yTolerance); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return -1; + } + + public int textPageCountRects(PdfDocument doc, int textPageIndex, int start_index, int count) { + synchronized (lock) { + try { + return nativeTextCountRects(doc.mNativeTextPagesPtr.get(textPageIndex), start_index, count); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return -1; + } + + public Rect textPageGetRect(PdfDocument doc, int textPageIndex, int rect_index) { + synchronized (lock) { + try { + double[] o = nativeTextGetRect(doc.mNativeTextPagesPtr.get(textPageIndex), rect_index); + Rect r = new Rect(); + r.left = o[0]; + r.top = o[1]; + r.right = o[2]; + r.bottom = o[3]; + return r; + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + } + return null; + } + + public String textPageGetBoundedText(PdfDocument doc, int textPageIndex, Rect rect, int length) { + synchronized (lock) { + try { + short[] buf = new short[length+1]; + + int r = nativeTextGetBoundedText(doc.mNativeTextPagesPtr.get(textPageIndex), rect.left, rect.top, rect.right, rect.bottom, buf); + + byte[] bytes = new byte[(r-1)*2]; + ByteBuffer bb = ByteBuffer.wrap(bytes); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for (int i = 0; i < r-1; i++) { + short s = buf[i]; + bb.putShort(s); + } + return new String(bytes, "UTF-16LE"); + } catch (NullPointerException e) { + Log.e(TAG, "mContext may be null"); + e.printStackTrace(); + } catch (Exception e) { + Log.e(TAG, "Exception throw from native"); + e.printStackTrace(); + } + return null; + } + } } diff --git a/src/main/jni/src/mainJNILib.cpp b/src/main/jni/src/mainJNILib.cpp index a888e69f..cc87ab5a 100644 --- a/src/main/jni/src/mainJNILib.cpp +++ b/src/main/jni/src/mainJNILib.cpp @@ -16,6 +16,7 @@ using namespace android; #include #include +#include #include #include @@ -688,4 +689,171 @@ JNI_FUNC(jobject, PdfiumCore, nativePageCoordsToDevice)(JNI_ARGS, jlong pagePtr, return env->NewObject(clazz, constructorID, deviceX, deviceY); } +////////////////////////////////////////// +//Begin FPDF_TEXTPAGE section + +static jlong loadTextPageInternal(JNIEnv *env, DocumentFile *doc, int textPageIndex){ + try{ + if(doc == NULL) throw "Get page document null"; + + FPDF_PAGE page = reinterpret_cast(loadPageInternal(env, doc, textPageIndex)); + if(page != NULL){ + FPDF_TEXTPAGE textPage = FPDFText_LoadPage(page); + if (textPage == NULL) { + throw "Loaded text page is null"; + } + return reinterpret_cast(textPage); + }else{ + throw "Load page null"; + } + }catch(const char *msg){ + LOGE("%s", msg); + + jniThrowException(env, "java/lang/IllegalStateException", + "cannot load text page"); + + return -1; + } +} + +static void closeTextPageInternal(jlong textPagePtr) { FPDFText_ClosePage(reinterpret_cast(textPagePtr)); } + +JNI_FUNC(jlong, PdfiumCore, nativeLoadTextPage)(JNI_ARGS, jlong docPtr, jint pageIndex){ + DocumentFile *doc = reinterpret_cast(docPtr); + return loadTextPageInternal(env, doc, (int)pageIndex); +} +JNI_FUNC(jlongArray, PdfiumCore, nativeLoadTextPages)(JNI_ARGS, jlong docPtr, jint fromIndex, jint toIndex){ + DocumentFile *doc = reinterpret_cast(docPtr); + + if(toIndex < fromIndex) return NULL; + jlong pages[ toIndex - fromIndex + 1 ]; + + int i; + for(i = 0; i <= (toIndex - fromIndex); i++){ + pages[i] = loadTextPageInternal(env, doc, (int)(i + fromIndex)); + } + + jlongArray javaPages = env -> NewLongArray( (jsize)(toIndex - fromIndex + 1) ); + env -> SetLongArrayRegion(javaPages, 0, (jsize)(toIndex - fromIndex + 1), (const jlong*)pages); + + return javaPages; +} + +JNI_FUNC(void, PdfiumCore, nativeCloseTextPage)(JNI_ARGS, jlong textPagePtr){ closeTextPageInternal(textPagePtr); } +JNI_FUNC(void, PdfiumCore, nativeCloseTextPages)(JNI_ARGS, jlongArray textPagesPtr){ + int length = (int)(env -> GetArrayLength(textPagesPtr)); + jlong *textPages = env -> GetLongArrayElements(textPagesPtr, NULL); + + int i; + for(i = 0; i < length; i++){ closeTextPageInternal(textPages[i]); } +} + +//DLLEXPORT int STDCALL FPDFText_CountChars(FPDF_TEXTPAGE text_page); +JNI_FUNC(jint, PdfiumCore, nativeTextCountChars)(JNI_ARGS, jlong textPagePtr){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_CountChars(textPage); +} + +//DLLEXPORT unsigned int STDCALL FPDFText_GetUnicode(FPDF_TEXTPAGE text_page, int index); +JNI_FUNC(jint, PdfiumCore, nativeTextGetUnicode)(JNI_ARGS, jlong textPagePtr, jint index){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_GetUnicode(textPage, (int)index); +} + +/*DLLEXPORT void STDCALL FPDFText_GetCharBox(FPDF_TEXTPAGE text_page, + int index, + double* left, + double* right, + double* bottom, + double* top);*/ +JNI_FUNC(jdoubleArray, PdfiumCore, nativeTextGetCharBox)(JNI_ARGS, jlong textPagePtr, jint index){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jdoubleArray result = env->NewDoubleArray(4); + if (result == NULL) { + return NULL; + } + double fill[4]; + FPDFText_GetCharBox(textPage, (int)index, &fill[0], &fill[1], &fill[2], &fill[3]); + env->SetDoubleArrayRegion(result, 0, 4, (jdouble*)fill); + return result; +} + +/*DLLEXPORT int STDCALL FPDFText_GetCharIndexAtPos(FPDF_TEXTPAGE text_page, + double x, + double y, + double xTolerance, + double yTolerance);*/ +JNI_FUNC(jint, PdfiumCore, nativeTextGetCharIndexAtPos)(JNI_ARGS, jlong textPagePtr, jdouble x, jdouble y, jdouble xTolerance, jdouble yTolerance){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_GetCharIndexAtPos(textPage, (double)x, (double)y, (double)xTolerance, (double)yTolerance); +} + +/*DLLEXPORT int STDCALL FPDFText_GetText(FPDF_TEXTPAGE text_page, + int start_index, + int count, + unsigned short* result);*/ +JNI_FUNC(jint, PdfiumCore, nativeTextGetText)(JNI_ARGS, jlong textPagePtr, jint start_index, jint count, jshortArray result){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jboolean isCopy = 0; + unsigned short *arr = (unsigned short *)env->GetShortArrayElements(result, &isCopy); + jint output = (jint)FPDFText_GetText(textPage, (int)start_index, (int)count, arr); + if (isCopy) { + env->SetShortArrayRegion(result, 0, output, (jshort*)arr); + env->ReleaseShortArrayElements(result, (jshort*)arr, JNI_ABORT); + } + return output; +} + +/*DLLEXPORT int STDCALL FPDFText_CountRects(FPDF_TEXTPAGE text_page, + int start_index, + int count);*/ +JNI_FUNC(jint, PdfiumCore, nativeTextCountRects)(JNI_ARGS, jlong textPagePtr, jint start_index, jint count){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + return (jint)FPDFText_CountRects(textPage, (int)start_index, (int) count); +} + +/*DLLEXPORT void STDCALL FPDFText_GetRect(FPDF_TEXTPAGE text_page, + int rect_index, + double* left, + double* top, + double* right, + double* bottom);*/ +JNI_FUNC(jdoubleArray, PdfiumCore, nativeTextGetRect)(JNI_ARGS, jlong textPagePtr, jint rect_index){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jdoubleArray result = env->NewDoubleArray(4); + if (result == NULL) { + return NULL; + } + double fill[4]; + FPDFText_GetRect(textPage, (int)rect_index, &fill[0], &fill[1], &fill[2], &fill[3]); + env->SetDoubleArrayRegion(result, 0, 4, (jdouble*)fill); + return result; +} + +/*DLLEXPORT int STDCALL FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page, + double left, + double top, + double right, + double bottom, + unsigned short* buffer, + int buflen); +*/ + +JNI_FUNC(jint, PdfiumCore, nativeTextGetBoundedText)(JNI_ARGS, jlong textPagePtr, jdouble left, jdouble top, jdouble right, jdouble bottom, jshortArray arr){ + FPDF_TEXTPAGE *textPage = reinterpret_cast(textPagePtr); + jboolean isCopy = 0; + unsigned short *buffer = NULL; + int bufLen = 0; + if (arr != NULL) { + buffer = (unsigned short *)env->GetShortArrayElements(arr, &isCopy); + bufLen = env->GetArrayLength(arr); + } + jint output = (jint)FPDFText_GetBoundedText(textPage, (double)left, (double)top, (double)right, (double)bottom, buffer, bufLen); + if (isCopy) { + env->SetShortArrayRegion(arr, 0, output, (jshort*)buffer); + env->ReleaseShortArrayElements(arr, (jshort*)buffer, JNI_ABORT); + } + return output; +} + }//extern C From c6d78752deb4e29e74ddaa438fa9c34ca90fdbb1 Mon Sep 17 00:00:00 2001 From: Bill Moyers Date: Mon, 18 Dec 2017 09:47:06 -0500 Subject: [PATCH 03/32] Remove unnecessary new Rect class, just use RectF from Android. --- .../java/com/shockwave/pdfium/PdfiumCore.java | 33 ++++++++----------- 1 file changed, 13 insertions(+), 20 deletions(-) diff --git a/src/main/java/com/shockwave/pdfium/PdfiumCore.java b/src/main/java/com/shockwave/pdfium/PdfiumCore.java index fe9f809a..828831a9 100644 --- a/src/main/java/com/shockwave/pdfium/PdfiumCore.java +++ b/src/main/java/com/shockwave/pdfium/PdfiumCore.java @@ -558,22 +558,15 @@ public char textPageGetUnicode(PdfDocument doc, int textPageIndex, int index) { return 0; } - public class Rect { - public double left; - public double right; - public double bottom; - public double top; - } - - public Rect textPageGetCharBox(PdfDocument doc, int textPageIndex, int index) { + public RectF textPageGetCharBox(PdfDocument doc, int textPageIndex, int index) { synchronized (lock) { try { double[] o = nativeTextGetCharBox(doc.mNativeTextPagesPtr.get(textPageIndex), index); - Rect r = new Rect(); - r.left = o[0]; - r.right = o[1]; - r.bottom = o[2]; - r.top = o[3]; + RectF r = new RectF(); + r.left = (float)o[0]; + r.right = (float)o[1]; + r.bottom = (float)o[2]; + r.top = (float)o[3]; return r; } catch (NullPointerException e) { Log.e(TAG, "mContext may be null"); @@ -616,15 +609,15 @@ public int textPageCountRects(PdfDocument doc, int textPageIndex, int start_inde return -1; } - public Rect textPageGetRect(PdfDocument doc, int textPageIndex, int rect_index) { + public RectF textPageGetRect(PdfDocument doc, int textPageIndex, int rect_index) { synchronized (lock) { try { double[] o = nativeTextGetRect(doc.mNativeTextPagesPtr.get(textPageIndex), rect_index); - Rect r = new Rect(); - r.left = o[0]; - r.top = o[1]; - r.right = o[2]; - r.bottom = o[3]; + RectF r = new RectF(); + r.left = (float)o[0]; + r.top = (float)o[1]; + r.right = (float)o[2]; + r.bottom = (float)o[3]; return r; } catch (NullPointerException e) { Log.e(TAG, "mContext may be null"); @@ -637,7 +630,7 @@ public Rect textPageGetRect(PdfDocument doc, int textPageIndex, int rect_index) return null; } - public String textPageGetBoundedText(PdfDocument doc, int textPageIndex, Rect rect, int length) { + public String textPageGetBoundedText(PdfDocument doc, int textPageIndex, RectF rect, int length) { synchronized (lock) { try { short[] buf = new short[length+1]; From 4d5241add31c117f1043fc517fdf179fdb87a684 Mon Sep 17 00:00:00 2001 From: John Gray Date: Mon, 16 Jul 2018 08:35:27 -0400 Subject: [PATCH 04/32] Add support to close the text pages. Fixed a few crashes Fixed an issue with openTextPage leaking the page. --- .../java/com/shockwave/pdfium/PdfiumCore.java | 44 +++++++++++++------ src/main/jni/src/mainJNILib.cpp | 8 ++-- 2 files changed, 34 insertions(+), 18 deletions(-) diff --git a/src/main/java/com/shockwave/pdfium/PdfiumCore.java b/src/main/java/com/shockwave/pdfium/PdfiumCore.java index 828831a9..5d3334f2 100644 --- a/src/main/java/com/shockwave/pdfium/PdfiumCore.java +++ b/src/main/java/com/shockwave/pdfium/PdfiumCore.java @@ -80,14 +80,10 @@ private native void nativeRenderPageBitmap(long pagePtr, Bitmap bitmap, int dpi, private native long nativeGetBookmarkDestIndex(long docPtr, long bookmarkPtr); - private native long nativeLoadTextPage(long docPtr, int pageIndex); - - private native long[] nativeLoadTextPages(long docPtr, int fromIndex, int toIndex); + private native long nativeLoadTextPage(long docPtr, long pagePtr); private native void nativeCloseTextPage(long pagePtr); - private native void nativeCloseTextPages(long[] pagesPtr); - private native int nativeTextCountChars(long textPagePtr); private native int nativeTextGetText(long textPagePtr, int start_index, int count, short[] result); @@ -185,10 +181,15 @@ public int getPageCount(PdfDocument doc) { /** Open page and store native pointer in {@link PdfDocument} */ public long openPage(PdfDocument doc, int pageIndex) { - long pagePtr; synchronized (lock) { - pagePtr = nativeLoadPage(doc.mNativeDocPtr, pageIndex); - doc.mNativePagesPtr.put(pageIndex, pagePtr); + if (doc.mNativePagesPtr == null) { + return -1; + } + Long pagePtr = doc.mNativePagesPtr.get(pageIndex); + if (pagePtr == null) { + pagePtr = nativeLoadPage(doc.mNativeDocPtr, pageIndex); + doc.mNativePagesPtr.put(pageIndex, pagePtr); + } return pagePtr; } @@ -348,10 +349,12 @@ public void renderPageBitmap(PdfDocument doc, Bitmap bitmap, int pageIndex, /** Release native resources and opened file */ public void closeDocument(PdfDocument doc) { synchronized (lock) { - for (Integer index : doc.mNativePagesPtr.keySet()) { - nativeClosePage(doc.mNativePagesPtr.get(index)); + if (doc.mNativePagesPtr != null) { + for (Integer index : doc.mNativePagesPtr.keySet()) { + nativeClosePage(doc.mNativePagesPtr.get(index)); + } + doc.mNativePagesPtr.clear(); } - doc.mNativePagesPtr.clear(); nativeCloseDocument(doc.mNativeDocPtr); @@ -468,15 +471,28 @@ public RectF mapRectToDevice(PdfDocument doc, int pageIndex, int startX, int sta } public long openTextPage(PdfDocument doc, int pageIndex) { - long textPagePtr; synchronized (lock) { - textPagePtr = nativeLoadTextPage(doc.mNativeDocPtr, pageIndex); - doc.mNativeTextPagesPtr.put(pageIndex, textPagePtr); + long page = openPage(doc, pageIndex); + Long textPagePtr = doc.mNativeTextPagesPtr.get(pageIndex); + if (textPagePtr == null) { + textPagePtr = nativeLoadTextPage(doc.mNativeDocPtr, page); + doc.mNativeTextPagesPtr.put(pageIndex, textPagePtr); + } return textPagePtr; } } + public void closeTextPage(PdfDocument doc, int pageIndex) { + synchronized (lock) { + final Long nativeLoadTextPage = doc.mNativeTextPagesPtr.get(pageIndex); + if (nativeLoadTextPage != null) { + nativeCloseTextPage(nativeLoadTextPage); + doc.mNativeTextPagesPtr.remove(pageIndex); + } + } + } + public long[] openTextPage(PdfDocument doc, int fromIndex, int toIndex) { long[] textPagesPtr; synchronized (lock) { diff --git a/src/main/jni/src/mainJNILib.cpp b/src/main/jni/src/mainJNILib.cpp index cc87ab5a..253f3745 100644 --- a/src/main/jni/src/mainJNILib.cpp +++ b/src/main/jni/src/mainJNILib.cpp @@ -692,11 +692,11 @@ JNI_FUNC(jobject, PdfiumCore, nativePageCoordsToDevice)(JNI_ARGS, jlong pagePtr, ////////////////////////////////////////// //Begin FPDF_TEXTPAGE section -static jlong loadTextPageInternal(JNIEnv *env, DocumentFile *doc, int textPageIndex){ +static jlong loadTextPageInternal(JNIEnv *env, DocumentFile *doc, jlong pagePtr){ try{ if(doc == NULL) throw "Get page document null"; - FPDF_PAGE page = reinterpret_cast(loadPageInternal(env, doc, textPageIndex)); + FPDF_PAGE page = reinterpret_cast(pagePtr); if(page != NULL){ FPDF_TEXTPAGE textPage = FPDFText_LoadPage(page); if (textPage == NULL) { @@ -718,9 +718,9 @@ static jlong loadTextPageInternal(JNIEnv *env, DocumentFile *doc, int textPageIn static void closeTextPageInternal(jlong textPagePtr) { FPDFText_ClosePage(reinterpret_cast(textPagePtr)); } -JNI_FUNC(jlong, PdfiumCore, nativeLoadTextPage)(JNI_ARGS, jlong docPtr, jint pageIndex){ +JNI_FUNC(jlong, PdfiumCore, nativeLoadTextPage)(JNI_ARGS, jlong docPtr, jlong pagePtr){ DocumentFile *doc = reinterpret_cast(docPtr); - return loadTextPageInternal(env, doc, (int)pageIndex); + return loadTextPageInternal(env, doc, pagePtr); } JNI_FUNC(jlongArray, PdfiumCore, nativeLoadTextPages)(JNI_ARGS, jlong docPtr, jint fromIndex, jint toIndex){ DocumentFile *doc = reinterpret_cast(docPtr); From 50e49755b0922bf9fa23b5ba7878818f0076fc61 Mon Sep 17 00:00:00 2001 From: mcsong Date: Sun, 26 Nov 2017 19:51:24 -0800 Subject: [PATCH 05/32] fixed potential NPE --- src/main/java/com/shockwave/pdfium/PdfiumCore.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/shockwave/pdfium/PdfiumCore.java b/src/main/java/com/shockwave/pdfium/PdfiumCore.java index 5d3334f2..c8c37951 100644 --- a/src/main/java/com/shockwave/pdfium/PdfiumCore.java +++ b/src/main/java/com/shockwave/pdfium/PdfiumCore.java @@ -420,7 +420,11 @@ private void recursiveGetBookmark(List tree, PdfDocument d public List getPageLinks(PdfDocument doc, int pageIndex) { synchronized (lock) { List links = new ArrayList<>(); - long[] linkPtrs = nativeGetPageLinks(doc.mNativePagesPtr.get(pageIndex)); + Long nativePagePtr = doc.mNativePagesPtr.get(pageIndex); + if(nativePagePtr == null) { + return links; + } + long[] linkPtrs = nativeGetPageLinks(nativePagePtr); for (long linkPtr : linkPtrs) { Integer index = nativeGetDestPageIndex(doc.mNativeDocPtr, linkPtr); String uri = nativeGetLinkURI(doc.mNativeDocPtr, linkPtr); From 8c9ae376856a04fbc4286f941852c2963803585a Mon Sep 17 00:00:00 2001 From: Bartosz Schiller Date: Fri, 15 Dec 2017 22:18:49 +0100 Subject: [PATCH 06/32] Merge pull request fixing potential NPE when getting links Update README and CHANGELOG Update version --- CHANGELOG.md | 3 +++ README.md | 4 +++- build.gradle | 4 ++-- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8486369d..a10849c3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,6 @@ +## 1.8.2 (2017-12-15) +* Merge pull request by [mcsong](https://github.com/mcsong) fixing potential NPE when getting links + ## 1.8.1 (2017-11-15) * Handle `PdfiumCore#getPageSize()` errors and return `Size(0, 0)` diff --git a/README.md b/README.md index f3fdcc0f..10e51558 100644 --- a/README.md +++ b/README.md @@ -16,10 +16,12 @@ API is highly compatible with original version, only additional methods were cre 1.8.1 handles errors when using `PdfiumCore#getPageSize(PdfDocument, int)` and returns `Size(0, 0)` when error occurs +1.8.2 merges pull request by [mcsong](https://github.com/mcsong) fixing potential NPE when getting links + ## Installation Add to _build.gradle_: -`compile 'com.github.barteksc:pdfium-android:1.8.1'` +`compile 'com.github.barteksc:pdfium-android:1.8.2'` Library is available in jcenter and Maven Central repositories. diff --git a/build.gradle b/build.gradle index d8308d63..f354212f 100644 --- a/build.gradle +++ b/build.gradle @@ -25,7 +25,7 @@ ext { siteUrl = 'https://github.com/barteksc/PdfiumAndroid' gitUrl = 'https://github.com/barteksc/PdfiumAndroid.git' - libraryVersion = '1.8.1' + libraryVersion = '1.8.2' developerId = 'barteksc' developerName = 'Bartosz Schiller' @@ -44,7 +44,7 @@ android { minSdkVersion 9 targetSdkVersion 25 versionCode 1 - versionName "1.8.1" + versionName "1.8.2" } buildTypes { release { From 72c02446063d8093137925d1493f35900aefc481 Mon Sep 17 00:00:00 2001 From: Bartosz Schiller Date: Thu, 28 Jun 2018 22:49:13 +0200 Subject: [PATCH 07/32] Use pdfium built with c++_shared Update plugins Update compile SDK and support libs to 26 Set minimum SDK to 14 Update version and README --- README.md | 19 ++++++------ build.gradle | 27 +++++++++++------- gradle/wrapper/gradle-wrapper.properties | 2 +- .../java/com/shockwave/pdfium/PdfiumCore.java | 2 ++ src/main/jni/Android.mk | 15 +++++----- src/main/jni/Application.mk | 8 +++--- src/main/jni/lib/arm64-v8a/libc++_shared.so | Bin 0 -> 1282687 bytes .../jni/lib/{arm64 => arm64-v8a}/libmodft2.so | Bin 554880 -> 554880 bytes .../lib/{arm64 => arm64-v8a}/libmodpdfium.so | Bin 5367744 -> 5216024 bytes .../jni/lib/{arm64 => arm64-v8a}/libmodpng.so | Bin 214840 -> 214840 bytes src/main/jni/lib/armeabi-v7a/libc++_shared.so | Bin 0 -> 1370484 bytes .../lib/{armeabi => armeabi-v7a}/libmodft2.so | Bin 521640 -> 521640 bytes .../{armeabi => armeabi-v7a}/libmodpdfium.so | Bin 4802700 -> 4683804 bytes .../lib/{armeabi => armeabi-v7a}/libmodpng.so | Bin 148852 -> 148852 bytes src/main/jni/lib/mips/libc++_shared.so | Bin 0 -> 1686556 bytes src/main/jni/lib/mips/libmodft2.so | Bin 670572 -> 670572 bytes src/main/jni/lib/mips/libmodpdfium.so | Bin 5779004 -> 5587320 bytes src/main/jni/lib/mips/libmodpng.so | Bin 268560 -> 268560 bytes src/main/jni/lib/mips64/libc++_shared.so | Bin 0 -> 2729704 bytes src/main/jni/lib/mips64/libmodft2.so | Bin 0 -> 689144 bytes src/main/jni/lib/mips64/libmodpdfium.so | Bin 0 -> 6081224 bytes src/main/jni/lib/mips64/libmodpng.so | Bin 0 -> 270168 bytes src/main/jni/lib/x86/libc++_shared.so | Bin 0 -> 1434836 bytes src/main/jni/lib/x86/libmodft2.so | Bin 578876 -> 578876 bytes src/main/jni/lib/x86/libmodpdfium.so | Bin 5544036 -> 5380076 bytes src/main/jni/lib/x86/libmodpng.so | Bin 226564 -> 226564 bytes src/main/jni/lib/x86_64/libc++_shared.so | Bin 0 -> 1272144 bytes src/main/jni/lib/x86_64/libmodft2.so | Bin 599936 -> 599936 bytes src/main/jni/lib/x86_64/libmodpdfium.so | Bin 5720000 -> 5547800 bytes src/main/jni/lib/x86_64/libmodpng.so | Bin 227128 -> 227128 bytes 30 files changed, 39 insertions(+), 34 deletions(-) create mode 100755 src/main/jni/lib/arm64-v8a/libc++_shared.so rename src/main/jni/lib/{arm64 => arm64-v8a}/libmodft2.so (99%) rename src/main/jni/lib/{arm64 => arm64-v8a}/libmodpdfium.so (61%) rename src/main/jni/lib/{arm64 => arm64-v8a}/libmodpng.so (99%) create mode 100755 src/main/jni/lib/armeabi-v7a/libc++_shared.so rename src/main/jni/lib/{armeabi => armeabi-v7a}/libmodft2.so (99%) rename src/main/jni/lib/{armeabi => armeabi-v7a}/libmodpdfium.so (66%) rename src/main/jni/lib/{armeabi => armeabi-v7a}/libmodpng.so (99%) create mode 100755 src/main/jni/lib/mips/libc++_shared.so create mode 100755 src/main/jni/lib/mips64/libc++_shared.so create mode 100755 src/main/jni/lib/mips64/libmodft2.so create mode 100755 src/main/jni/lib/mips64/libmodpdfium.so create mode 100755 src/main/jni/lib/mips64/libmodpng.so create mode 100755 src/main/jni/lib/x86/libc++_shared.so create mode 100755 src/main/jni/lib/x86_64/libc++_shared.so diff --git a/README.md b/README.md index 10e51558..30a71ada 100644 --- a/README.md +++ b/README.md @@ -7,21 +7,18 @@ Forked for use with [AndroidPdfViewer](https://github.com/barteksc/AndroidPdfVie API is highly compatible with original version, only additional methods were created. -## What's new in 1.8.0? -* Add method for reading links from given page -* Add method for mapping page coordinates to screen coordinates -* Add `PdfiumCore#getPageSize(...)` method, which does not require page to be opened -* Add `Size` and `SizeF` utility classes -* Add javadoc comments to `PdfiumCore` - -1.8.1 handles errors when using `PdfiumCore#getPageSize(PdfDocument, int)` and returns `Size(0, 0)` when error occurs - -1.8.2 merges pull request by [mcsong](https://github.com/mcsong) fixing potential NPE when getting links +## What's new in 1.9.0? +* Updated Pdfium library to 7.1.2_r36 +* Changed `gnustl_static` to `c++_shared` +* Update Gradle plugins +* Update compile SDK and support library to 26 +* Change minimum SDK to 14 +* Add support for mips64 ## Installation Add to _build.gradle_: -`compile 'com.github.barteksc:pdfium-android:1.8.2'` +`compile 'com.github.barteksc:pdfium-android:1.9.0'` Library is available in jcenter and Maven Central repositories. diff --git a/build.gradle b/build.gradle index f354212f..49863608 100644 --- a/build.gradle +++ b/build.gradle @@ -1,12 +1,13 @@ buildscript { repositories { jcenter() + google() } dependencies { - classpath 'com.android.tools.build:gradle:2.3.2' - classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7.3' - classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5' + classpath 'com.android.tools.build:gradle:3.1.3' + classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.1' + classpath 'com.github.dcendents:android-maven-gradle-plugin:2.1' } } @@ -25,7 +26,7 @@ ext { siteUrl = 'https://github.com/barteksc/PdfiumAndroid' gitUrl = 'https://github.com/barteksc/PdfiumAndroid.git' - libraryVersion = '1.8.2' + libraryVersion = '1.9.0' developerId = 'barteksc' developerName = 'Bartosz Schiller' @@ -37,14 +38,13 @@ ext { } android { - compileSdkVersion 25 - buildToolsVersion "25.0.3" + compileSdkVersion 26 defaultConfig { - minSdkVersion 9 - targetSdkVersion 25 + minSdkVersion 14 + targetSdkVersion 26 versionCode 1 - versionName "1.8.2" + versionName "1.9.0" } buildTypes { release { @@ -61,9 +61,14 @@ android { } } +repositories { + google() + jcenter() +} + dependencies { - compile fileTree(dir: 'libs', include: ['*.jar']) - compile 'com.android.support:support-v4:25.3.1' + implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation 'com.android.support:support-v4:26.1.0' } apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/installv1.gradle' diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index f39445e4..7d202716 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip diff --git a/src/main/java/com/shockwave/pdfium/PdfiumCore.java b/src/main/java/com/shockwave/pdfium/PdfiumCore.java index c8c37951..7d600600 100644 --- a/src/main/java/com/shockwave/pdfium/PdfiumCore.java +++ b/src/main/java/com/shockwave/pdfium/PdfiumCore.java @@ -25,6 +25,7 @@ public class PdfiumCore { static { try { + System.loadLibrary("c++_shared"); System.loadLibrary("modpng"); System.loadLibrary("modft2"); System.loadLibrary("modpdfium"); @@ -140,6 +141,7 @@ public static int getNumFd(ParcelFileDescriptor fdObj) { /** Context needed to get screen density */ public PdfiumCore(Context ctx) { mCurrentDpi = ctx.getResources().getDisplayMetrics().densityDpi; + Log.d(TAG, "Starting PdfiumAndroid " + BuildConfig.VERSION_NAME); } /** Create new document from file */ diff --git a/src/main/jni/Android.mk b/src/main/jni/Android.mk index 9d91e609..131211ee 100644 --- a/src/main/jni/Android.mk +++ b/src/main/jni/Android.mk @@ -5,18 +5,19 @@ include $(CLEAR_VARS) LOCAL_MODULE := aospPdfium ARCH_PATH = $(TARGET_ARCH_ABI) -ifeq ($(TARGET_ARCH_ABI), armeabi-v7a) - ARCH_PATH = armeabi -endif - -ifeq ($(TARGET_ARCH_ABI), arm64-v8a) - ARCH_PATH = arm64 -endif LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libmodpdfium.so include $(PREBUILT_SHARED_LIBRARY) +#c++_shared +include $(CLEAR_VARS) +LOCAL_MODULE := libmodc++_shared + +LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libc++_shared.so + +include $(PREBUILT_SHARED_LIBRARY) + #libmodft2 include $(CLEAR_VARS) LOCAL_MODULE := libmodft2 diff --git a/src/main/jni/Application.mk b/src/main/jni/Application.mk index fc45dc15..df5c5088 100644 --- a/src/main/jni/Application.mk +++ b/src/main/jni/Application.mk @@ -1,12 +1,12 @@ -APP_STL := gnustl_static +APP_STL := c++_shared APP_CPPFLAGS += -fexceptions #For ANativeWindow support -APP_PLATFORM = android-9 +APP_PLATFORM = android-14 -APP_ABI := armeabi \ - armeabi-v7a \ +APP_ABI := armeabi-v7a \ arm64-v8a \ mips \ + mips64 \ x86 \ x86_64 \ No newline at end of file diff --git a/src/main/jni/lib/arm64-v8a/libc++_shared.so b/src/main/jni/lib/arm64-v8a/libc++_shared.so new file mode 100755 index 0000000000000000000000000000000000000000..562430e3833389aef5d411df5055184b8abd9113 GIT binary patch literal 1282687 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%0Dv$xXvpm;5}`ItzKJrgSeFHCE>On6^m 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%0Dx%Pad`Yy5;%g=-EUM&Cl(B(T4 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

pI%loc8xi~iU5erkSPsKw-sk(*cw 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 z%0A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±1nZzay^Kx8Swb`Z>3i%I*AQ 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

*/ public void renderPageBitmap(PdfDocument doc, Bitmap bitmap, int pageIndex, - int startX, int startY, int drawSizeX, int drawSizeY) { - renderPageBitmap(doc, bitmap, pageIndex, startX, startY, drawSizeX, drawSizeY, false); + int startX, int startY, int drawSizeX, int drawSizeY, boolean textMask) { + renderPageBitmap(doc, bitmap, pageIndex, startX, startY, drawSizeX, drawSizeY, false, textMask); } /** @@ -387,11 +481,11 @@ public void renderPageBitmap(PdfDocument doc, Bitmap bitmap, int pageIndex, */ public void renderPageBitmap(PdfDocument doc, Bitmap bitmap, int pageIndex, int startX, int startY, int drawSizeX, int drawSizeY, - boolean renderAnnot) { + boolean renderAnnot, boolean textMask) { synchronized (lock) { try { nativeRenderPageBitmap(doc.mNativePagesPtr.get(pageIndex), bitmap, mCurrentDpi, - startX, startY, drawSizeX, drawSizeY, renderAnnot); + startX, startY, drawSizeX, drawSizeY, renderAnnot, textMask); } catch (NullPointerException e) { Log.e(TAG, "mContext may be null"); e.printStackTrace(); diff --git a/src/main/jni/Android.mk b/src/main/jni/Android.mk index 131211ee..5c05b006 100644 --- a/src/main/jni/Android.mk +++ b/src/main/jni/Android.mk @@ -6,7 +6,7 @@ LOCAL_MODULE := aospPdfium ARCH_PATH = $(TARGET_ARCH_ABI) -LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libmodpdfium.so +LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libpdfium.cr.so include $(PREBUILT_SHARED_LIBRARY) @@ -14,23 +14,31 @@ include $(PREBUILT_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := libmodc++_shared -LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libc++_shared.so +LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libc++.cr.so include $(PREBUILT_SHARED_LIBRARY) -#libmodft2 +#libchrome_zlib include $(CLEAR_VARS) -LOCAL_MODULE := libmodft2 +LOCAL_MODULE := libchrome_zlib -LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libmodft2.so +LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libchrome_zlib.cr.so include $(PREBUILT_SHARED_LIBRARY) -#libmodpng +#libicui18n include $(CLEAR_VARS) -LOCAL_MODULE := libmodpng +LOCAL_MODULE := libicui18n -LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libmodpng.so +LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libicui18n.cr.so + +include $(PREBUILT_SHARED_LIBRARY) + +#libicuuc +include $(CLEAR_VARS) +LOCAL_MODULE := libicuuc + +LOCAL_SRC_FILES := $(LOCAL_PATH)/lib/$(ARCH_PATH)/libicuuc.cr.so include $(PREBUILT_SHARED_LIBRARY) diff --git a/src/main/jni/include/fpdf_dataavail.h b/src/main/jni/include/fpdf_dataavail.h index 0f8ff7d6..ad70b7f4 100644 --- a/src/main/jni/include/fpdf_dataavail.h +++ b/src/main/jni/include/fpdf_dataavail.h @@ -7,8 +7,9 @@ #ifndef PUBLIC_FPDF_DATAAVAIL_H_ #define PUBLIC_FPDF_DATAAVAIL_H_ -#include // For size_t. +#include +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" #define PDF_LINEARIZATION_UNKNOWN -1 @@ -26,248 +27,179 @@ #ifdef __cplusplus extern "C" { -#endif +#endif // __cplusplus -/** - * Interface: FX_FILEAVAIL - * Interface for checking whether the section of the file is available. - */ +// Interface for checking whether sections of the file are available. typedef struct _FX_FILEAVAIL { - /** - * Version number of the interface. Currently must be 1. - */ + // Version number of the interface. Must be 1. int version; - /** - * Method: IsDataAvail - * Report whether the specified data section is available. A section is - * available only if all bytes in the section is available. - * Interface Version: - * 1 - * Implementation Required: - * Yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * offset - The offset of the data section in the file. - * size - The size of the data section - * Return Value: - * true means the specified data section is available. - * Comments: - * Called by Foxit SDK to check whether the data section is ready. - */ - FPDF_BOOL (*IsDataAvail)(struct _FX_FILEAVAIL* pThis, size_t offset, size_t size); + // 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; -/** -* Function: FPDFAvail_Create -* Create a document availability provider. -* -* Parameters: -* file_avail - Pointer to file availability interface to check -* availability of file data. -* file - Pointer to a file access interface for reading data -* from file. -* Return value: -* A handle to the document availability provider. NULL for error. -* Comments: -* Application must call FPDFAvail_Destroy when done with the -* availability provider. -*/ -DLLEXPORT FPDF_AVAIL STDCALL FPDFAvail_Create(FX_FILEAVAIL* file_avail, - FPDF_FILEACCESS* file); - -/** -* Function: FPDFAvail_Destroy -* Destroy a document availibity provider. -* -* Parameters: -* avail - Handle to document availability provider returned by -* FPDFAvail_Create -* Return Value: -* None. -*/ -DLLEXPORT void STDCALL FPDFAvail_Destroy(FPDF_AVAIL avail); - -/** - * Interface: FX_DOWNLOADHINTS - * Download hints interface. Used to receive hints for further - * downloading. - */ +// 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. +FPDF_EXPORT FPDF_AVAIL FPDF_CALLCONV FPDFAvail_Create(FX_FILEAVAIL* file_avail, + FPDF_FILEACCESS* file); + +// Destroy the |avail| document availability provider. +// +// avail - handle to document availability provider to be destroyed. +FPDF_EXPORT void FPDF_CALLCONV FPDFAvail_Destroy(FPDF_AVAIL avail); + +// Download hints interface. Used to receive hints for further downloading. typedef struct _FX_DOWNLOADHINTS { - /** - * Version number of the interface. Currently must be 1. - */ + // Version number of the interface. Must be 1. int version; - /** - * Method: AddSegment - * Add a section to be downloaded. - * Interface Version: - * 1 - * Implementation Required: - * Yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * offset - The offset of the hint reported to be downloaded. - * size - The size of the hint reported to be downloaded. - * Return Value: - * None. - * Comments: - * Called by Foxit SDK to report some downloading hints for download - * manager. - * The position and size of section may be not accurate, part of the - * section might be already available. - * The download manager must deal with that to maximize download - * efficiency. - */ + // 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; -/** -* Function: FPDFAvail_IsDocAvail -* Check whether the document is ready for loading, if not, get -* download hints. -* -* Parameters: -* avail - Handle to document availability provider returned by -* FPDFAvail_Create -* hints - Pointer to a download hints interface, receiving -* generated hints -* Return value: -* PDF_DATA_ERROR: A common error is returned. It can't tell -* whehter data are availabe or not. -* PDF_DATA_NOTAVAIL: Data are not yet available. -* PDF_DATA_AVAIL: Data are available. -* Comments: -* Applications should call this function whenever new data arrived, -* and process all the generated download hints if any, until the -* function returns PDF_DATA_ERROR or PDF_DATA_AVAIL. Then -* applications can call FPDFAvail_GetDocument() to get a document -* handle. -*/ -DLLEXPORT int STDCALL -FPDFAvail_IsDocAvail(FPDF_AVAIL avail, FX_DOWNLOADHINTS* hints); - -/** -* Function: FPDFAvail_GetDocument -* Get document from the availability provider. -* -* Parameters: -* avail - Handle to document availability provider returned by -* FPDFAvail_Create -* password - Optional password for decrypting the PDF file. -* Return value: -* Handle to the document. -* Comments: -* After FPDFAvail_IsDocAvail() returns TRUE, the application should -* call this function to -* get the document handle. To close the document, use -* FPDF_CloseDocument function. -*/ -DLLEXPORT FPDF_DOCUMENT STDCALL FPDFAvail_GetDocument(FPDF_AVAIL avail, - FPDF_BYTESTRING password); - -/** -* Function: FPDFAvail_GetFirstPageNum -* Get page number for the first available page in a linearized PDF -* -* Parameters: -* doc - A document handle returned by FPDFAvail_GetDocument -* Return Value: -* Zero-based index for the first available page. -* Comments: -* For most linearized PDFs, the first available page would be just the -* first page, however, -* some PDFs might make other page to be the first available page. -* For non-linearized PDF, this function will always return zero. -*/ -DLLEXPORT int STDCALL FPDFAvail_GetFirstPageNum(FPDF_DOCUMENT doc); - -/** -* Function: FPDFAvail_IsPageAvail -* Check whether a page is ready for loading, if not, get download -* hints. -* -* Parameters: -* avail - Handle to document availability provider returned by -* FPDFAvail_Create -* page_index - Index number of the page. 0 for the first page. -* hints - Pointer to a download hints interface, receiving -* generated hints -* Return value: -* PDF_DATA_ERROR: A common error is returned. It can't tell -* whehter data are availabe or not. -* PDF_DATA_NOTAVAIL: Data are not yet available. -* PDF_DATA_AVAIL: Data are available. -* Comments: -* This function can be called only after FPDFAvail_GetDocument is -* called. Applications should call this function whenever new data -* arrived and process all the generated download hints if any, until -* this function returns PDF_DATA_ERROR or PDF_DATA_AVAIL. Then -* applications can perform page loading. -*/ -DLLEXPORT int STDCALL FPDFAvail_IsPageAvail(FPDF_AVAIL avail, - int page_index, - FX_DOWNLOADHINTS* hints); - -/** -* Function: FPDFAvail_ISFormAvail -* Check whether Form data is ready for init, if not, get download -* hints. -* -* Parameters: -* avail - Handle to document availability provider returned by -* FPDFAvail_Create -* hints - Pointer to a download hints interface, receiving -* generated hints -* Return value: -* PDF_FORM_ERROR - A common eror, in general incorrect parameters, -* like 'hints' is nullptr. -* PDF_FORM_NOTAVAIL - data not available -* PDF_FORM_AVAIL - data available -* PDF_FORM_NOTEXIST - no form data -* Comments: -* This function can be called only after FPDFAvail_GetDocument is -* called. -* The application should call this function whenever new data arrived, -* and process all the -* generated download hints if any, until the function returns non-zero -* value. Then the -* application can perform page loading. Recommend to call -* FPDFDOC_InitFormFillEnvironment -* after the function returns non-zero value. -*/ -DLLEXPORT int STDCALL FPDFAvail_IsFormAvail(FPDF_AVAIL avail, - FX_DOWNLOADHINTS* hints); - -/** -* Function: FPDFAvail_IsLinearized -* To check whether a document is Linearized PDF file. -* -* Parameters: -* avail - Handle to document availability provider returned by -* FPDFAvail_Create -* Return value: -* PDF_LINEARIZED is a linearize file. -* PDF_NOT_LINEARIZED is not a linearize file. -* PDF_LINEARIZATION_UNKNOWN doesn't know whether the file is a -*linearize file. -* -* Comments: -* It return PDF_LINEARIZED or PDF_NOT_LINEARIZED as soon as -* we have first 1K data. If the file's size less than 1K, it returns -* PDF_LINEARIZATION_UNKNOWN because there is not enough information to -* tell whether a PDF file is a linearized file or not. -* -*/ -DLLEXPORT int STDCALL FPDFAvail_IsLinearized(FPDF_AVAIL avail); +// 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|. +// if hints is nullptr, the function just check current document availability. +// +// Once all data is available, call FPDFAvail_GetDocument() to get a document +// handle. +FPDF_EXPORT int FPDF_CALLCONV 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. +// See the comments for FPDF_LoadDocument() regarding the encoding for +// |password|. +FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV +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. +FPDF_EXPORT int FPDF_CALLCONV 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. +// if hints is nullptr, the function just check current availability of +// specified page. +FPDF_EXPORT int FPDF_CALLCONV 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|. +// if hints is nullptr, the function just check current form availability. +// +// Applications can then perform page loading. It is recommend to call +// FPDFDOC_InitFormFillEnvironment() when |PDF_FORM_AVAIL| is returned. +FPDF_EXPORT int FPDF_CALLCONV 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. +FPDF_EXPORT int FPDF_CALLCONV FPDFAvail_IsLinearized(FPDF_AVAIL avail); #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_DATAAVAIL_H_ diff --git a/src/main/jni/include/fpdf_doc.h b/src/main/jni/include/fpdf_doc.h index de05eb3a..565314eb 100644 --- a/src/main/jni/include/fpdf_doc.h +++ b/src/main/jni/include/fpdf_doc.h @@ -7,294 +7,35 @@ #ifndef PUBLIC_FPDF_DOC_H_ #define PUBLIC_FPDF_DOC_H_ +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" -// Exported Functions #ifdef __cplusplus extern "C" { -#endif - -// Function: FPDFBookmark_GetFirstChild -// Get the first child of a bookmark item, or the first top level -// bookmark item. -// Parameters: -// document - Handle to the document. Returned by -// FPDF_LoadDocument or FPDF_LoadMemDocument. -// bookmark - Handle to the current bookmark. Can be NULL if you -// want to get the first top level item. -// Return value: -// Handle to the first child or 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); +#endif // __cplusplus -// Function: FPDFBookmark_GetNextSibling -// Get next bookmark item at the same level. -// Parameters: -// document - Handle to the document. Returned by -// FPDF_LoadDocument or FPDF_LoadMemDocument. -// bookmark - Handle to the current bookmark. Cannot be NULL. -// Return value: -// Handle to the next bookmark item at the same level. NULL if this is -// the last bookmark at this level. -// -DLLEXPORT FPDF_BOOKMARK STDCALL -FPDFBookmark_GetNextSibling(FPDF_DOCUMENT document, FPDF_BOOKMARK bookmark); +// 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 -// Function: FPDFBookmark_GetTitle -// Get title of a bookmark. -// Parameters: -// bookmark - Handle to the bookmark. -// buffer - Buffer for the title. Can be NULL. -// buflen - The length of the buffer in bytes. Can be 0. -// Return value: -// Number of bytes the title consumes, including trailing zeros. -// Comments: -// Regardless of the platform, the title is always in UTF-16LE -// encoding. That means the buffer -// can be treated as an array of WORD (on Intel and compatible CPUs), -// each WORD representing the Unicode of -// a character(some special Unicode may take 2 WORDs).The string is -// followed by two bytes of zero -// indicating the end of the string. -// -// The return value always indicates the number of bytes required for -// the buffer, even if no buffer is specified -// or the buffer size is less then required. In these cases, the buffer -// will not be modified. -// -DLLEXPORT unsigned long STDCALL FPDFBookmark_GetTitle(FPDF_BOOKMARK bookmark, - void* buffer, - unsigned long buflen); - -// Function: FPDFBookmark_Find -// Find a bookmark in the document, using the bookmark title. -// Parameters: -// document - Handle to the document. Returned by -// FPDF_LoadDocument or FPDF_LoadMemDocument. -// title - The UTF-16LE encoded Unicode string for the bookmark -// title to be searched. Can't be NULL. -// Return value: -// Handle to the found bookmark item. NULL if the title can't be found. -// Comments: -// It always returns the first found bookmark if more than one -// bookmarks have the same title. -// -DLLEXPORT FPDF_BOOKMARK STDCALL FPDFBookmark_Find(FPDF_DOCUMENT document, - FPDF_WIDESTRING title); - -// Function: FPDFBookmark_GetDest -// Get the destination associated with a bookmark item. -// Parameters: -// document - Handle to the document. -// bookmark - Handle to the bookmark. -// Return value: -// Handle to the destination data. NULL if no destination is associated -// with this bookmark. -// -DLLEXPORT FPDF_DEST STDCALL FPDFBookmark_GetDest(FPDF_DOCUMENT document, - FPDF_BOOKMARK bookmark); - -// Function: FPDFBookmark_GetAction -// Get the action associated with a bookmark item. -// Parameters: -// bookmark - Handle to the bookmark. -// Return value: -// Handle to the action data. NULL if no action is associated with this -// bookmark. In this case, the -// application should try FPDFBookmark_GetDest. -// -DLLEXPORT FPDF_ACTION STDCALL FPDFBookmark_GetAction(FPDF_BOOKMARK bookmark); - -#define PDFACTION_UNSUPPORTED 0 // Unsupported action type. -#define PDFACTION_GOTO 1 // Go to a destination within current document. -#define PDFACTION_REMOTEGOTO 2 // Go to a destination within another document. -#define PDFACTION_URI 3 // Universal Resource Identifier, including web - // pages and other Internet based resources. -#define PDFACTION_LAUNCH 4 // Launch an application or open a file. - -// Function: FPDFAction_GetType -// Get type of an action. -// Parameters: -// action - Handle to the action. -// Return value: -// A type number as defined above. -// -DLLEXPORT unsigned long STDCALL FPDFAction_GetType(FPDF_ACTION action); - -// Function: FPDFAction_GetDest -// Get destination of an action. -// Parameters: -// document - Handle to the document. -// action - Handle to the action. It must be a GOTO or -// REMOTEGOTO action. -// Return value: -// Handle to the destination data. -// Comments: -// In case of remote goto action, the application should first use -// FPDFAction_GetFilePath to -// get file path, then load that particular document, and use its -// document handle to call this -// function. -// -DLLEXPORT FPDF_DEST STDCALL FPDFAction_GetDest(FPDF_DOCUMENT document, - FPDF_ACTION action); - -// Function: FPDFAction_GetFilePath -// Get file path of a remote goto action. -// Parameters: -// action - Handle to the action. Must be a REMOTEGOTO or -// LAUNCH action. -// buffer - A buffer for output the path string. Can be NULL. -// buflen - The length of the buffer, number of bytes. Can be 0. -// Return value: -// Number of bytes the file path consumes, including trailing zero. -// -// Comments: -// The file path is UTF-8 encoded. The return value is the number of -// bytes required for the buffer, even when there is no buffer -// specified, or the buffer size is less then required. In this case, -// the buffer will not be modified. -// -DLLEXPORT unsigned long STDCALL -FPDFAction_GetFilePath(FPDF_ACTION action, void* buffer, unsigned long buflen); +// View destination fit types. See pdfmark reference v9, page 48. +#define PDFDEST_VIEW_UNKNOWN_MODE 0 +#define PDFDEST_VIEW_XYZ 1 +#define PDFDEST_VIEW_FIT 2 +#define PDFDEST_VIEW_FITH 3 +#define PDFDEST_VIEW_FITV 4 +#define PDFDEST_VIEW_FITR 5 +#define PDFDEST_VIEW_FITB 6 +#define PDFDEST_VIEW_FITBH 7 +#define PDFDEST_VIEW_FITBV 8 -// Function: FPDFAction_GetURIPath -// Get URI path of a URI action. -// Parameters: -// document - Handle to the document. -// action - Handle to the action. Must be a URI action. -// buffer - A buffer for output the path string. Can be NULL. -// buflen - The length of the buffer, number of bytes. Can be 0. -// Return value: -// Number of bytes the URI path consumes, including trailing zeros. -// Comments: -// The URI path is always encoded in 7-bit ASCII. -// -// The return value is the number of bytes required for the buffer, -// even when there is no buffer specified, or the buffer size is less -// then required. In this case, the buffer will not be modified. -// -DLLEXPORT unsigned long STDCALL FPDFAction_GetURIPath(FPDF_DOCUMENT document, - FPDF_ACTION action, - void* buffer, - unsigned long buflen); - -// Function: FPDFDest_GetPageIndex -// Get page index of a destination. -// Parameters: -// document - Handle to the document. -// dest - Handle to the destination. -// Return value: -// The page index. Starting from 0 for the first page. -// -DLLEXPORT unsigned long STDCALL FPDFDest_GetPageIndex(FPDF_DOCUMENT document, - FPDF_DEST dest); - -// Function: FPDFLink_GetLinkAtPoint -// Find a link at specified point on a document page. -// Parameters: -// page - Handle to the document page. -// x - The x coordinate of the point, specified in page -// coordinate system. -// y - The y coordinate of the point, specified in page -// coordinate system. -// Return value: -// Handle to the link. NULL if no link found at that point. -// Comments: -// The point coordinates are specified in page coordinate system. You can -// convert coordinates from screen system to page system using -// FPDF_DeviceToPage(). -// -DLLEXPORT FPDF_LINK STDCALL FPDFLink_GetLinkAtPoint(FPDF_PAGE page, - double x, - double y); - -// Function: FPDFLink_GetLinkZOrderAtPoint -// Find the z-order of a link at specified point on a document page. -// Parameters: -// page - Handle to the document page. -// x - The x coordinate of the point, specified in page -// coordinate system. -// y - The y coordinate of the point, specified in page -// coordinate system. -// Return value: -// Z-order of the link, or -1 if no link found at that point. -// Higher numbers are closer to the front. -// Comments: -// The point coordinates are specified in page coordinate system. You can -// convert coordinates from screen system to page system using -// FPDF_DeviceToPage(). -// -DLLEXPORT int STDCALL -FPDFLink_GetLinkZOrderAtPoint(FPDF_PAGE page, double x, double y); - -// Function: FPDFLink_GetDest -// Get destination info of a link. -// Parameters: -// document - Handle to the document. -// link - Handle to the link. Returned by -// FPDFLink_GetLinkAtPoint. -// Return value: -// Handle to the destination. NULL if there is no destination -// associated with the link, in this case -// the application should try FPDFLink_GetAction. -// -DLLEXPORT FPDF_DEST STDCALL FPDFLink_GetDest(FPDF_DOCUMENT document, - FPDF_LINK link); - -// Function: FPDFLink_GetAction -// Get action info of a link. -// Parameters: -// link - Handle to the link. -// Return value: -// Handle to the action. NULL if there is no action associated with the -// link. -// -DLLEXPORT FPDF_ACTION STDCALL FPDFLink_GetAction(FPDF_LINK link); - -// Function: FPDFLink_Enumerate -// This function would enumerate all the link annotations in a single -// PDF page. -// Parameters: -// page[in] - Handle to the page. -// startPos[in,out] - The start position to enumerate the link -// annotations, which should be specified to start from -// - 0 for the first call, and would receive the -// next position for enumerating to start from. -// linkAnnot[out] - Receive the link handle. -// Return value: -// TRUE if succceed, else False; -// -DLLEXPORT FPDF_BOOL STDCALL FPDFLink_Enumerate(FPDF_PAGE page, - int* startPos, - FPDF_LINK* linkAnnot); - -// Function: FPDFLink_GetAnnotRect -// Get the annotation rectangle. (Specified by the ¡°Rect¡± entry of -// annotation dictionary). -// Parameters: -// linkAnnot[in] - Handle to the link annotation. -// rect[out] - The annotation rect. -// Return value: -// TRUE if succceed, else False; -// -DLLEXPORT FPDF_BOOL STDCALL FPDFLink_GetAnnotRect(FPDF_LINK linkAnnot, - FS_RECTF* rect); - -// Function: FPDFLink_CountQuadPoints -// Get the count of quadrilateral points to the link annotation. -// Parameters: -// linkAnnot[in] - Handle to the link annotation. -// Return value: -// The count of quadrilateral points. -// -DLLEXPORT int STDCALL FPDFLink_CountQuadPoints(FPDF_LINK linkAnnot); - -/* _FS_DEF_STRUCTURE_QUADPOINTSF_ */ -#ifndef _FS_DEF_STRUCTURE_QUADPOINTSF_ -#define _FS_DEF_STRUCTURE_QUADPOINTSF_ typedef struct _FS_QUADPOINTSF { FS_FLOAT x1; FS_FLOAT y1; @@ -305,61 +46,318 @@ typedef struct _FS_QUADPOINTSF { FS_FLOAT x4; FS_FLOAT y4; } FS_QUADPOINTSF; -#endif /* _FS_DEF_STRUCTURE_QUADPOINTSF_ */ - -// Function: FPDFLink_GetQuadPoints -// Get the quadrilateral points for the specified index in the link -// annotation. -// Parameters: -// linkAnnot[in] - Handle to the link annotation. -// quadIndex[in] - The specified quad points index. -// quadPoints[out] - Receive the quadrilateral points. -// Return value: -// True if succeed, else False. -// -DLLEXPORT FPDF_BOOL STDCALL FPDFLink_GetQuadPoints(FPDF_LINK linkAnnot, - int quadIndex, - FS_QUADPOINTSF* quadPoints); - -// Function: FPDF_GetMetaText -// Get a text from meta data of the document. Result is encoded in -// UTF-16LE. -// Parameters: -// doc - Handle to a document -// tag - The tag for the meta data. Currently, It can be -// "Title", "Author", -// "Subject", "Keywords", "Creator", "Producer", -// "CreationDate", or "ModDate". -// For detailed explanation 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 output the title. Can be NULL. -// buflen - The length of the buffer, number of bytes. Can be 0. -// Return value: -// Number of bytes the title consumes, including trailing zeros. -// Comments: -// No matter on what platform, the title is always output in UTF-16LE -// encoding, which means the buffer -// can be regarded as an array of WORD (on Intel and compatible CPUs), -// each WORD represent the Unicode of -// a character (some special Unicode may take 2 WORDs). The string is -// followed by two bytes of zero -// indicating end of the string. -// -// The return value always indicated number of bytes required for the -// buffer, even when there is -// no buffer specified, or the buffer size is less then required. In -// this case, the buffer will not -// be modified. -// -DLLEXPORT unsigned long STDCALL FPDF_GetMetaText(FPDF_DOCUMENT doc, - FPDF_BYTESTRING tag, - void* buffer, - unsigned long buflen); + +// 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. +FPDF_EXPORT FPDF_BOOKMARK FPDF_CALLCONV +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. +FPDF_EXPORT FPDF_BOOKMARK FPDF_CALLCONV +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. +FPDF_EXPORT unsigned long FPDF_CALLCONV +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|. +FPDF_EXPORT FPDF_BOOKMARK FPDF_CALLCONV +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|. +FPDF_EXPORT FPDF_DEST FPDF_CALLCONV +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. +FPDF_EXPORT FPDF_ACTION FPDF_CALLCONV +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 +FPDF_EXPORT unsigned long FPDF_CALLCONV 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, or NULL on error, typically +// because the arguments were bad or the action was of the wrong type. +// +// In the case of |PDFACTION_REMOTEGOTO|, you must first call +// FPDFAction_GetFilePath(), then load the document at that path, then pass +// the document handle from that document as |document| to FPDFAction_GetDest(). +FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDFAction_GetDest(FPDF_DOCUMENT document, + FPDF_ACTION action); + +// Get the file path of |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 NUL +// character, or 0 on error, typically because the arguments were bad or the +// action was of the wrong type. +// +// Regardless of the platform, the |buffer| is always in UTF-8 encoding. +// If |buflen| is less than the returned length, or |buffer| is NULL, |buffer| +// will not be modified. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFAction_GetFilePath(FPDF_ACTION action, void* buffer, unsigned long buflen); + +// Get the URI path of |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 the trailing NUL +// character, or 0 on error, typically because the arguments were bad or the +// action was of the wrong type. +// +// 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. +FPDF_EXPORT unsigned long FPDF_CALLCONV +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 0-based page index containing |dest|. Returns -1 on error. +FPDF_EXPORT int FPDF_CALLCONV FPDFDest_GetDestPageIndex(FPDF_DOCUMENT document, + FPDF_DEST dest); + +// Get the view (fit type) specified by |dest|. +// Experimental API. Subject to change. +// +// dest - handle to the destination. +// pNumParams - receives the number of view parameters, which is at most 4. +// pParams - buffer to write the view parameters. Must be at least 4 +// FS_FLOATs long. +// Returns one of the PDFDEST_VIEW_* constants, PDFDEST_VIEW_UNKNOWN_MODE if +// |dest| does not specify a view. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFDest_GetView(FPDF_DEST dest, unsigned long* pNumParams, FS_FLOAT* pParams); + +// 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. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFDest_GetLocationInPage(FPDF_DEST dest, + FPDF_BOOL* hasXVal, + FPDF_BOOL* hasYVal, + FPDF_BOOL* hasZoomVal, + 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(). +FPDF_EXPORT FPDF_LINK FPDF_CALLCONV 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(). +FPDF_EXPORT int FPDF_CALLCONV 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|. +FPDF_EXPORT FPDF_DEST FPDF_CALLCONV 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. +FPDF_EXPORT FPDF_ACTION FPDF_CALLCONV FPDFLink_GetAction(FPDF_LINK link); + +// Enumerates all the link annotations in |page|. +// +// page - handle to the page. +// start_pos - the start position, should initially be 0 and is updated with +// the next start position on return. +// link_annot - the link handle for |startPos|. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_Enumerate(FPDF_PAGE page, + int* start_pos, + FPDF_LINK* link_annot); + +// Get the rectangle for |link_annot|. +// +// link_annot - handle to the link annotation. +// rect - the annotation rectangle. +// +// Returns true on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetAnnotRect(FPDF_LINK link_annot, + FS_RECTF* rect); + +// Get the count of quadrilateral points to the |link_annot|. +// +// link_annot - handle to the link annotation. +// +// Returns the count of quadrilateral points. +FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountQuadPoints(FPDF_LINK link_annot); + +// Get the quadrilateral points for the specified |quad_index| in |link_annot|. +// +// link_annot - handle to the link annotation. +// quad_index - the specified quad point index. +// quad_points - receives the quadrilateral points. +// +// Returns true on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFLink_GetQuadPoints(FPDF_LINK link_annot, + int quad_index, + FS_QUADPOINTSF* quad_points); + +// 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. +// +// For linearized files, FPDFAvail_IsFormAvail must be called before this, and +// it must have returned PDF_FORM_AVAIL or PDF_FORM_NOTEXIST. Before that, there +// is no guarantee the metadata has been loaded. +FPDF_EXPORT unsigned long FPDF_CALLCONV 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. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDF_GetPageLabel(FPDF_DOCUMENT document, + int page_index, + void* buffer, + unsigned long buflen); #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_DOC_H_ diff --git a/src/main/jni/include/fpdf_edit.h b/src/main/jni/include/fpdf_edit.h index 64eef263..8e0d2343 100644 --- a/src/main/jni/include/fpdf_edit.h +++ b/src/main/jni/include/fpdf_edit.h @@ -9,299 +9,1221 @@ #include +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" -// Define all types used in the SDK. Note they can be simply regarded as opaque -// pointers -// or long integer numbers. - -#define FPDF_ARGB(a, r, g, b) \ - ((((uint32_t)(((uint8_t)(b) | ((FX_WORD)((uint8_t)(g)) << 8)) | \ - (((FX_DWORD)(uint8_t)(r)) << 16)))) | \ - (((FX_DWORD)(uint8_t)(a)) << 24)) +#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)) -#ifdef __cplusplus -extern "C" { -#endif - -////////////////////////////////////////////////////////////////////// -// -// Document functions -// -////////////////////////////////////////////////////////////////////// - -// Function: FPDF_CreateNewDocument -// Create a new PDF document. -// Parameters: -// None. -// Return value: -// A handle to a document. If failed, NULL is returned. -DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_CreateNewDocument(); - -////////////////////////////////////////////////////////////////////// -// -// Page functions -// -////////////////////////////////////////////////////////////////////// - -// Function: FPDFPage_New -// Construct an empty page. -// Parameters: -// document - Handle to document. Returned by FPDF_LoadDocument -// and FPDF_CreateNewDocument. -// page_index - The index of a page. -// width - The page width. -// height - The page height. -// Return value: -// The handle to the page. -// Comments: -// Loaded page can be deleted by FPDFPage_Delete. -DLLEXPORT FPDF_PAGE STDCALL FPDFPage_New(FPDF_DOCUMENT document, - int page_index, - double width, - double height); - -// Function: FPDFPage_Delete -// Delete a PDF page. -// Parameters: -// document - Handle to document. Returned by FPDF_LoadDocument -// and FPDF_CreateNewDocument. -// page_index - The index of a page. -// Return value: -// None. -DLLEXPORT void STDCALL FPDFPage_Delete(FPDF_DOCUMENT document, int page_index); - -// Function: FPDFPage_GetRotation -// Get the page rotation. One of following values will be returned: -// 0(0), 1(90), 2(180), 3(270). -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// Return value: -// The PDF page rotation. -// Comment: -// The PDF page rotation is rotated clockwise. -DLLEXPORT int STDCALL FPDFPage_GetRotation(FPDF_PAGE page); - -// Function: FPDFPage_SetRotation -// Set page rotation. One of following values will be set: 0(0), 1(90), -// 2(180), 3(270). -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// rotate - The value of the PDF page rotation. -// Return value: -// None. -// Comment: -// The PDF page rotation is rotated clockwise. -// -DLLEXPORT void STDCALL FPDFPage_SetRotation(FPDF_PAGE page, int rotate); - -// Function: FPDFPage_InsertObject -// Insert an object to the page. The page object is automatically -// freed. -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// page_obj - Handle to a page object. Returned by -// FPDFPageObj_NewTextObj,FPDFPageObj_NewTextObjEx and -// FPDFPageObj_NewPathObj. -// Return value: -// None. -DLLEXPORT void STDCALL FPDFPage_InsertObject(FPDF_PAGE page, - FPDF_PAGEOBJECT page_obj); - -// Function: FPDFPage_CountObject -// Get number of page objects inside the page. -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// Return value: -// The number of the page object. -DLLEXPORT int STDCALL FPDFPage_CountObject(FPDF_PAGE page); - -// Function: FPDFPage_GetObject -// Get page object by index. -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// index - The index of a page object. -// Return value: -// The handle of the page object. Null for failed. -DLLEXPORT FPDF_PAGEOBJECT STDCALL FPDFPage_GetObject(FPDF_PAGE page, int index); - -// Function: FPDFPage_HasTransparency -// Check that whether the content of specified PDF page contains -// transparency. -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// Return value: -// TRUE means that the PDF page does contains transparency. -// Otherwise, returns FALSE. -DLLEXPORT FPDF_BOOL STDCALL FPDFPage_HasTransparency(FPDF_PAGE page); - -// Function: FPDFPage_GenerateContent -// Generate PDF Page content. -// Parameters: -// page - Handle to a page. Returned by FPDFPage_New or -// FPDF_LoadPage. -// Return value: -// True if successful, false otherwise. -// Comment: -// Before you save the page to a file, or reload the page, you must -// call the FPDFPage_GenerateContent function. -// Or the changed information will be lost. -DLLEXPORT FPDF_BOOL STDCALL FPDFPage_GenerateContent(FPDF_PAGE page); - -////////////////////////////////////////////////////////////////////// -// -// Page Object functions -// -////////////////////////////////////////////////////////////////////// - -// Function: FPDFPageObj_HasTransparency -// Check that whether the specified PDF page object contains -// transparency. -// Parameters: -// pageObject - Handle to a page object. -// Return value: -// TRUE means that the PDF page object does contains transparency. -// Otherwise, returns FALSE. -DLLEXPORT FPDF_BOOL STDCALL -FPDFPageObj_HasTransparency(FPDF_PAGEOBJECT pageObject); - -// Function: FPDFPageObj_Transform -// Transform (scale, rotate, shear, move) page object. -// Parameters: -// page_object - Handle to a page object. Returned by -// FPDFPageObj_NewImageObj. -// a - The coefficient "a" of the matrix. -// b - The coefficient "b" of the matrix. -// c - The coefficient "c" of the matrix. -// d - The coefficient "d" of the matrix. -// e - The coefficient "e" of the matrix. -// f - The coefficient "f" of the matrix. -// Return value: -// None. -DLLEXPORT void STDCALL FPDFPageObj_Transform(FPDF_PAGEOBJECT page_object, - double a, - double b, - double c, - double d, - double e, - double f); - -// Function: FPDFPage_TransformAnnots -// Transform (scale, rotate, shear, move) all annots in a page. -// Parameters: -// page - Handle to a page. -// a - The coefficient "a" of the matrix. -// b - The coefficient "b" of the matrix. -// c - The coefficient "c" of the matrix. -// d - The coefficient "d" of the matrix. -// e - The coefficient "e" of the matrix. -// f - The coefficient "f" of the matrix. -// Return value: -// None. -DLLEXPORT void STDCALL FPDFPage_TransformAnnots(FPDF_PAGE page, - double a, - double b, - double c, - double d, - double e, - double f); +// Refer to PDF Reference version 1.7 table 4.12 for all color space families. +#define FPDF_COLORSPACE_UNKNOWN 0 +#define FPDF_COLORSPACE_DEVICEGRAY 1 +#define FPDF_COLORSPACE_DEVICERGB 2 +#define FPDF_COLORSPACE_DEVICECMYK 3 +#define FPDF_COLORSPACE_CALGRAY 4 +#define FPDF_COLORSPACE_CALRGB 5 +#define FPDF_COLORSPACE_LAB 6 +#define FPDF_COLORSPACE_ICCBASED 7 +#define FPDF_COLORSPACE_SEPARATION 8 +#define FPDF_COLORSPACE_DEVICEN 9 +#define FPDF_COLORSPACE_INDEXED 10 +#define FPDF_COLORSPACE_PATTERN 11 // The page object constants. +#define FPDF_PAGEOBJ_UNKNOWN 0 #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 -////////////////////////////////////////////////////////////////////// -// -// Image functions -// -////////////////////////////////////////////////////////////////////// - -// Function: FPDFPageObj_NewImgeObj -// Create a new Image Object. -// Parameters: -// document - Handle to document. Returned by -// FPDF_LoadDocument or FPDF_CreateNewDocument function. -// Return Value: -// Handle of image object. -DLLEXPORT FPDF_PAGEOBJECT STDCALL -FPDFPageObj_NewImgeObj(FPDF_DOCUMENT document); - -// Function: FPDFImageObj_LoadJpegFile -// Load Image from a JPEG image file and then set it to an image -// object. -// Parameters: -// pages - Pointers to the start of all loaded pages, could -// be NULL. -// nCount - Number of pages, could be 0. -// image_object - Handle of image object returned by -// FPDFPageObj_NewImgeObj. -// fileAccess - The custom file access handler, which specifies -// the JPEG image file. -// Return Value: -// TRUE if successful, FALSE otherwise. -// Note: -// The image object might already has an associated image, which is -// shared and cached by the loaded pages, In this case, we need to -// clear the cache of image for all the loaded pages. -// Pass pages and count to this API to clear the image cache. -DLLEXPORT FPDF_BOOL STDCALL +// The path segment constants. +#define FPDF_SEGMENT_UNKNOWN -1 +#define FPDF_SEGMENT_LINETO 0 +#define FPDF_SEGMENT_BEZIERTO 1 +#define FPDF_SEGMENT_MOVETO 2 + +#define FPDF_FILLMODE_NONE 0 +#define FPDF_FILLMODE_ALTERNATE 1 +#define FPDF_FILLMODE_WINDING 2 + +#define FPDF_FONT_TYPE1 1 +#define FPDF_FONT_TRUETYPE 2 + +#define FPDF_LINECAP_BUTT 0 +#define FPDF_LINECAP_ROUND 1 +#define FPDF_LINECAP_PROJECTING_SQUARE 2 + +#define FPDF_LINEJOIN_MITER 0 +#define FPDF_LINEJOIN_ROUND 1 +#define FPDF_LINEJOIN_BEVEL 2 + +#define FPDF_PRINTMODE_EMF 0 +#define FPDF_PRINTMODE_TEXTONLY 1 +#define FPDF_PRINTMODE_POSTSCRIPT2 2 +#define FPDF_PRINTMODE_POSTSCRIPT3 3 +#define FPDF_PRINTMODE_POSTSCRIPT2_PASSTHROUGH 4 +#define FPDF_PRINTMODE_POSTSCRIPT3_PASSTHROUGH 5 + +typedef struct FPDF_IMAGEOBJ_METADATA { + // The image width in pixels. + unsigned int width; + // The image height in pixels. + unsigned int height; + // The image's horizontal pixel-per-inch. + float horizontal_dpi; + // The image's vertical pixel-per-inch. + float vertical_dpi; + // The number of bits used to represent each pixel. + unsigned int bits_per_pixel; + // The image's colorspace. See above for the list of FPDF_COLORSPACE_*. + int colorspace; + // The image's marked content ID. Useful for pairing with associated alt-text. + // A value of -1 indicates no ID. + int marked_content_id; +} FPDF_IMAGEOBJ_METADATA; + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +// Create a new PDF document. +// +// Returns a handle to a new document, or NULL on failure. +FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV FPDF_CreateNewDocument(); + +// Create a new PDF page. +// +// document - handle to document. +// page_index - suggested 0-based 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 in points. +// height - the page height in points. +// +// Returns the handle to the new page or NULL on failure. +// +// The page should be closed with FPDF_ClosePage() when finished as +// with any other page in the document. +FPDF_EXPORT FPDF_PAGE FPDF_CALLCONV 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. +FPDF_EXPORT void FPDF_CALLCONV 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. +FPDF_EXPORT int FPDF_CALLCONV 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. +FPDF_EXPORT void FPDF_CALLCONV 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. +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_InsertObject(FPDF_PAGE page, + FPDF_PAGEOBJECT page_obj); + +// Experimental API. +// Remove |page_obj| from |page|. +// +// page - handle to a page +// page_obj - handle to a page object to be removed. +// +// Returns TRUE on success. +// +// Ownership is transferred to the caller. Call FPDFPageObj_Destroy() to free +// it. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPage_RemoveObject(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|. +FPDF_EXPORT int FPDF_CALLCONV FPDFPage_CountObjects(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. +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPage_GetObject(FPDF_PAGE page, + int index); + +// Checks if |page| contains transparency. +// +// page - handle to a page. +// +// Returns TRUE if |page| contains transparency. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV 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. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GenerateContent(FPDF_PAGE page); + +// Destroy |page_obj| by releasing its resources. |page_obj| must have been +// created by FPDFPageObj_CreateNew{Path|Rect}() or +// FPDFPageObj_New{Text|Image}Obj(). This function must be called on +// newly-created objects if they are not added to a page through +// FPDFPage_InsertObject() or to an annotation through FPDFAnnot_AppendObject(). +// +// page_obj - handle to a page object. +FPDF_EXPORT void FPDF_CALLCONV FPDFPageObj_Destroy(FPDF_PAGEOBJECT page_obj); + +// Checks if |page_object| contains transparency. +// +// page_object - handle to a page object. +// +// Returns TRUE if |page_object| contains transparency. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_HasTransparency(FPDF_PAGEOBJECT page_object); + +// Get type of |page_object|. +// +// page_object - handle to a page object. +// +// Returns one of the FPDF_PAGEOBJ_* values on success, FPDF_PAGEOBJ_UNKNOWN on +// error. +FPDF_EXPORT int FPDF_CALLCONV FPDFPageObj_GetType(FPDF_PAGEOBJECT page_object); + +// Transform |page_object| 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|. +FPDF_EXPORT void FPDF_CALLCONV +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. +FPDF_EXPORT void FPDF_CALLCONV 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. +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV +FPDFPageObj_NewImageObj(FPDF_DOCUMENT document); + +// Experimental API. +// Get number of content marks in |page_object|. +// +// page_object - handle to a page object. +// +// Returns the number of content marks in |page_object|, or -1 in case of +// failure. +FPDF_EXPORT int FPDF_CALLCONV +FPDFPageObj_CountMarks(FPDF_PAGEOBJECT page_object); + +// Experimental API. +// Get content mark in |page_object| at |index|. +// +// page_object - handle to a page object. +// index - the index of a page object. +// +// Returns the handle to the content mark, or NULL on failure. The handle is +// still owned by the library, and it should not be freed directly. It becomes +// invalid if the page object is destroyed, either directly or indirectly by +// unloading the page. +FPDF_EXPORT FPDF_PAGEOBJECTMARK FPDF_CALLCONV +FPDFPageObj_GetMark(FPDF_PAGEOBJECT page_object, unsigned long index); + +// Experimental API. +// Add a new content mark to a |page_object|. +// +// page_object - handle to a page object. +// name - the name (tag) of the mark. +// +// Returns the handle to the content mark, or NULL on failure. The handle is +// still owned by the library, and it should not be freed directly. It becomes +// invalid if the page object is destroyed, either directly or indirectly by +// unloading the page. +FPDF_EXPORT FPDF_PAGEOBJECTMARK FPDF_CALLCONV +FPDFPageObj_AddMark(FPDF_PAGEOBJECT page_object, FPDF_BYTESTRING name); + +// Experimental API. +// Removes a content |mark| from a |page_object|. +// The mark handle will be invalid after the removal. +// +// page_object - handle to a page object. +// mark - handle to a content mark in that object to remove. +// +// Returns TRUE if the operation succeeded, FALSE if it failed. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_RemoveMark(FPDF_PAGEOBJECT page_object, FPDF_PAGEOBJECTMARK mark); + +// Experimental API. +// Get the name of a content mark. +// +// mark - handle to a content mark. +// buffer - buffer for holding the returned name in UTF-16LE. This is only +// modified if |buflen| is longer than the length of the name. +// Optional, pass null to just retrieve the size of the buffer +// needed. +// buflen - length of the buffer. +// out_buflen - pointer to variable that will receive the minimum buffer size +// to contain the name. Not filled if FALSE is returned. +// +// Returns TRUE if the operation succeeded, FALSE if it failed. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_GetName(FPDF_PAGEOBJECTMARK mark, + void* buffer, + unsigned long buflen, + unsigned long* out_buflen); + +// Experimental API. +// Get the number of key/value pair parameters in |mark|. +// +// mark - handle to a content mark. +// +// Returns the number of key/value pair parameters |mark|, or -1 in case of +// failure. +FPDF_EXPORT int FPDF_CALLCONV +FPDFPageObjMark_CountParams(FPDF_PAGEOBJECTMARK mark); + +// Experimental API. +// Get the key of a property in a content mark. +// +// mark - handle to a content mark. +// index - index of the property. +// buffer - buffer for holding the returned key in UTF-16LE. This is only +// modified if |buflen| is longer than the length of the key. +// Optional, pass null to just retrieve the size of the buffer +// needed. +// buflen - length of the buffer. +// out_buflen - pointer to variable that will receive the minimum buffer size +// to contain the key. Not filled if FALSE is returned. +// +// Returns TRUE if the operation was successful, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_GetParamKey(FPDF_PAGEOBJECTMARK mark, + unsigned long index, + void* buffer, + unsigned long buflen, + unsigned long* out_buflen); + +// Experimental API. +// Get the type of the value of a property in a content mark by key. +// +// mark - handle to a content mark. +// key - string key of the property. +// +// Returns the type of the value, or FPDF_OBJECT_UNKNOWN in case of failure. +FPDF_EXPORT FPDF_OBJECT_TYPE FPDF_CALLCONV +FPDFPageObjMark_GetParamValueType(FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key); + +// Experimental API. +// Get the value of a number property in a content mark by key as int. +// FPDFPageObjMark_GetParamValueType() should have returned FPDF_OBJECT_NUMBER +// for this property. +// +// mark - handle to a content mark. +// key - string key of the property. +// out_value - pointer to variable that will receive the value. Not filled if +// false is returned. +// +// Returns TRUE if the key maps to a number value, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_GetParamIntValue(FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key, + int* out_value); + +// Experimental API. +// Get the value of a string property in a content mark by key. +// +// mark - handle to a content mark. +// key - string key of the property. +// buffer - buffer for holding the returned value in UTF-16LE. This is +// only modified if |buflen| is longer than the length of the +// value. +// Optional, pass null to just retrieve the size of the buffer +// needed. +// buflen - length of the buffer. +// out_buflen - pointer to variable that will receive the minimum buffer size +// to contain the value. Not filled if FALSE is returned. +// +// Returns TRUE if the key maps to a string/blob value, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_GetParamStringValue(FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key, + void* buffer, + unsigned long buflen, + unsigned long* out_buflen); + +// Experimental API. +// Get the value of a blob property in a content mark by key. +// +// mark - handle to a content mark. +// key - string key of the property. +// buffer - buffer for holding the returned value. This is only modified +// if |buflen| is at least as long as the length of the value. +// Optional, pass null to just retrieve the size of the buffer +// needed. +// buflen - length of the buffer. +// out_buflen - pointer to variable that will receive the minimum buffer size +// to contain the value. Not filled if FALSE is returned. +// +// Returns TRUE if the key maps to a string/blob value, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_GetParamBlobValue(FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key, + void* buffer, + unsigned long buflen, + unsigned long* out_buflen); + +// Experimental API. +// Set the value of an int property in a content mark by key. If a parameter +// with key |key| exists, its value is set to |value|. Otherwise, it is added as +// a new parameter. +// +// document - handle to the document. +// page_object - handle to the page object with the mark. +// mark - handle to a content mark. +// key - string key of the property. +// value - int value to set. +// +// Returns TRUE if the operation succeeded, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_SetIntParam(FPDF_DOCUMENT document, + FPDF_PAGEOBJECT page_object, + FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key, + int value); + +// Experimental API. +// Set the value of a string property in a content mark by key. If a parameter +// with key |key| exists, its value is set to |value|. Otherwise, it is added as +// a new parameter. +// +// document - handle to the document. +// page_object - handle to the page object with the mark. +// mark - handle to a content mark. +// key - string key of the property. +// value - string value to set. +// +// Returns TRUE if the operation succeeded, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_SetStringParam(FPDF_DOCUMENT document, + FPDF_PAGEOBJECT page_object, + FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key, + FPDF_BYTESTRING value); + +// Experimental API. +// Set the value of a blob property in a content mark by key. If a parameter +// with key |key| exists, its value is set to |value|. Otherwise, it is added as +// a new parameter. +// +// document - handle to the document. +// page_object - handle to the page object with the mark. +// mark - handle to a content mark. +// key - string key of the property. +// value - pointer to blob value to set. +// value_len - size in bytes of |value|. +// +// Returns TRUE if the operation succeeded, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_SetBlobParam(FPDF_DOCUMENT document, + FPDF_PAGEOBJECT page_object, + FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key, + void* value, + unsigned long value_len); + +// Experimental API. +// Removes a property from a content mark by key. +// +// page_object - handle to the page object with the mark. +// mark - handle to a content mark. +// key - string key of the property. +// +// Returns TRUE if the operation succeeded, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObjMark_RemoveParam(FPDF_PAGEOBJECT page_object, + FPDF_PAGEOBJECTMARK mark, + FPDF_BYTESTRING key); + +// 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. +// count - number of |pages|, may be 0. +// image_object - handle to an image object. +// file_access - 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 (|count|) to this API +// to clear the image cache. If the image is not previously shared, or NULL is a +// valid |pages| value. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFImageObj_LoadJpegFile(FPDF_PAGE* pages, - int nCount, + int count, FPDF_PAGEOBJECT image_object, - FPDF_FILEACCESS* fileAccess); - -// Function: FPDFImageObj_SetMatrix -// Set the matrix of an image object. -// Parameters: -// image_object - Handle of image object returned by -// FPDFPageObj_NewImgeObj. -// a - The coefficient "a" of the matrix. -// b - The coefficient "b" of the matrix. -// c - The coefficient "c" of the matrix. -// d - The coefficient "d" of the matrix. -// e - The coefficient "e" of the matrix. -// f - The coefficient "f" of the matrix. -// Return value: -// TRUE if successful, FALSE otherwise. -DLLEXPORT FPDF_BOOL STDCALL FPDFImageObj_SetMatrix(FPDF_PAGEOBJECT image_object, - double a, - double b, - double c, - double d, - double e, - double f); - -// Function: FPDFImageObj_SetBitmap -// Set the bitmap to an image object. -// Parameters: -// pages - Pointer's to the start of all loaded pages. -// nCount - Number of pages. -// image_object - Handle of image object returned by -// FPDFPageObj_NewImgeObj. -// bitmap - The handle of the bitmap which you want to set -// it to the image object. -// Return value: -// TRUE if successful, FALSE otherwise. -DLLEXPORT FPDF_BOOL STDCALL FPDFImageObj_SetBitmap(FPDF_PAGE* pages, - int nCount, - FPDF_PAGEOBJECT image_object, - FPDF_BITMAP bitmap); + FPDF_FILEACCESS* file_access); + +// 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. +// count - number of |pages|, may be 0. +// image_object - handle to an image object. +// file_access - 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 (|count|) 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 |file_access| and its associated +// data to be deleted after this function returns. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFImageObj_LoadJpegFileInline(FPDF_PAGE* pages, + int count, + FPDF_PAGEOBJECT image_object, + FPDF_FILEACCESS* file_access); + +// Experimental API. +// Get the transform matrix of an 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 used to scale, rotate, shear and translate the image. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFImageObj_GetMatrix(FPDF_PAGEOBJECT image_object, + double* a, + double* b, + double* c, + double* d, + double* e, + double* f); + +// 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 |image_object|. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +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. +// count - number of |pages|, may be 0. +// image_object - handle to an image object. +// bitmap - handle of the bitmap. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFImageObj_SetBitmap(FPDF_PAGE* pages, + int count, + FPDF_PAGEOBJECT image_object, + FPDF_BITMAP bitmap); + +// Get a bitmap rasterisation of |image_object|. The returned bitmap will be +// owned by the caller, and FPDFBitmap_Destroy() must be called on the returned +// bitmap when it is no longer needed. +// +// image_object - handle to an image object. +// +// Returns the bitmap. +FPDF_EXPORT FPDF_BITMAP FPDF_CALLCONV +FPDFImageObj_GetBitmap(FPDF_PAGEOBJECT image_object); + +// Get the decoded image data of |image_object|. The decoded data is the +// uncompressed image data, i.e. the raw image data after having all filters +// applied. |buffer| is only modified if |buflen| is longer than the length of +// the decoded image data. +// +// image_object - handle to an image object. +// buffer - buffer for holding the decoded image data. +// buflen - length of the buffer in bytes. +// +// Returns the length of the decoded image data. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFImageObj_GetImageDataDecoded(FPDF_PAGEOBJECT image_object, + void* buffer, + unsigned long buflen); + +// Get the raw image data of |image_object|. The raw data is the image data as +// stored in the PDF without applying any filters. |buffer| is only modified if +// |buflen| is longer than the length of the raw image data. +// +// image_object - handle to an image object. +// buffer - buffer for holding the raw image data. +// buflen - length of the buffer in bytes. +// +// Returns the length of the raw image data. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFImageObj_GetImageDataRaw(FPDF_PAGEOBJECT image_object, + void* buffer, + unsigned long buflen); + +// Get the number of filters (i.e. decoders) of the image in |image_object|. +// +// image_object - handle to an image object. +// +// Returns the number of |image_object|'s filters. +FPDF_EXPORT int FPDF_CALLCONV +FPDFImageObj_GetImageFilterCount(FPDF_PAGEOBJECT image_object); + +// Get the filter at |index| of |image_object|'s list of filters. Note that the +// filters need to be applied in order, i.e. the first filter should be applied +// first, then the second, etc. |buffer| is only modified if |buflen| is longer +// than the length of the filter string. +// +// image_object - handle to an image object. +// index - the index of the filter requested. +// buffer - buffer for holding filter string, encoded in UTF-8. +// buflen - length of the buffer. +// +// Returns the length of the filter string. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFImageObj_GetImageFilter(FPDF_PAGEOBJECT image_object, + int index, + void* buffer, + unsigned long buflen); + +// Get the image metadata of |image_object|, including dimension, DPI, bits per +// pixel, and colorspace. If the |image_object| is not an image object or if it +// does not have an image, then the return value will be false. Otherwise, +// failure to retrieve any specific parameter would result in its value being 0. +// +// image_object - handle to an image object. +// page - handle to the page that |image_object| is on. Required for +// retrieving the image's bits per pixel and colorspace. +// metadata - receives the image metadata; must not be NULL. +// +// Returns true if successful. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFImageObj_GetImageMetadata(FPDF_PAGEOBJECT image_object, + FPDF_PAGE page, + FPDF_IMAGEOBJ_METADATA* metadata); + +// Create a new path object at an initial position. +// +// x - initial horizontal position. +// y - initial vertical position. +// +// Returns a handle to a new path object. +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPageObj_CreateNewPath(float x, + float y); + +// Create a closed path consisting of a rectangle. +// +// x - horizontal position for the left boundary of the rectangle. +// y - vertical position for the bottom boundary of the rectangle. +// w - width of the rectangle. +// h - height of the rectangle. +// +// Returns a handle to the new path object. +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPageObj_CreateNewRect(float x, + float y, + float w, + float h); + +// Get the bounding box of |page_object|. +// +// page_object - handle to a page object. +// left - pointer where the left coordinate will be stored +// bottom - pointer where the bottom coordinate will be stored +// right - pointer where the right coordinate will be stored +// top - pointer where the top coordinate will be stored +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_GetBounds(FPDF_PAGEOBJECT page_object, + float* left, + float* bottom, + float* right, + float* top); + +// Set the blend mode of |page_object|. +// +// page_object - handle to a page object. +// blend_mode - string containing the blend mode. +// +// Blend mode can be one of following: Color, ColorBurn, ColorDodge, Darken, +// Difference, Exclusion, HardLight, Hue, Lighten, Luminosity, Multiply, Normal, +// Overlay, Saturation, Screen, SoftLight +FPDF_EXPORT void FPDF_CALLCONV +FPDFPageObj_SetBlendMode(FPDF_PAGEOBJECT page_object, + FPDF_BYTESTRING blend_mode); + +// Set the stroke RGBA of a page object. Range of values: 0 - 255. +// +// page_object - the handle to the page object. +// R - the red component for the object's stroke color. +// G - the green component for the object's stroke color. +// B - the blue component for the object's stroke color. +// A - the stroke alpha for the object. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_SetStrokeColor(FPDF_PAGEOBJECT page_object, + unsigned int R, + unsigned int G, + unsigned int B, + unsigned int A); + +// Get the stroke RGBA of a page object. Range of values: 0 - 255. +// +// page_object - the handle to the page object. +// R - the red component of the path stroke color. +// G - the green component of the object's stroke color. +// B - the blue component of the object's stroke color. +// A - the stroke alpha of the object. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_GetStrokeColor(FPDF_PAGEOBJECT page_object, + unsigned int* R, + unsigned int* G, + unsigned int* B, + unsigned int* A); + +// Set the stroke width of a page object. +// +// path - the handle to the page object. +// width - the width of the stroke. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_SetStrokeWidth(FPDF_PAGEOBJECT page_object, float width); + +// Experimental API. +// Get the stroke width of a page object. +// +// path - the handle to the page object. +// width - the width of the stroke. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_GetStrokeWidth(FPDF_PAGEOBJECT page_object, float* width); + +// Get the line join of |page_object|. +// +// page_object - handle to a page object. +// +// Returns the line join, or -1 on failure. +// Line join can be one of following: FPDF_LINEJOIN_MITER, FPDF_LINEJOIN_ROUND, +// FPDF_LINEJOIN_BEVEL +FPDF_EXPORT int FPDF_CALLCONV +FPDFPageObj_GetLineJoin(FPDF_PAGEOBJECT page_object); + +// Set the line join of |page_object|. +// +// page_object - handle to a page object. +// line_join - line join +// +// Line join can be one of following: FPDF_LINEJOIN_MITER, FPDF_LINEJOIN_ROUND, +// FPDF_LINEJOIN_BEVEL +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_SetLineJoin(FPDF_PAGEOBJECT page_object, int line_join); + +// Get the line cap of |page_object|. +// +// page_object - handle to a page object. +// +// Returns the line cap, or -1 on failure. +// Line cap can be one of following: FPDF_LINECAP_BUTT, FPDF_LINECAP_ROUND, +// FPDF_LINECAP_PROJECTING_SQUARE +FPDF_EXPORT int FPDF_CALLCONV +FPDFPageObj_GetLineCap(FPDF_PAGEOBJECT page_object); + +// Set the line cap of |page_object|. +// +// page_object - handle to a page object. +// line_cap - line cap +// +// Line cap can be one of following: FPDF_LINECAP_BUTT, FPDF_LINECAP_ROUND, +// FPDF_LINECAP_PROJECTING_SQUARE +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_SetLineCap(FPDF_PAGEOBJECT page_object, int line_cap); + +// Set the fill RGBA of a page object. Range of values: 0 - 255. +// +// page_object - the handle to the page object. +// R - the red component for the object's fill color. +// G - the green component for the object's fill color. +// B - the blue component for the object's fill color. +// A - the fill alpha for the object. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_SetFillColor(FPDF_PAGEOBJECT page_object, + unsigned int R, + unsigned int G, + unsigned int B, + unsigned int A); + +// Get the fill RGBA of a page object. Range of values: 0 - 255. +// +// page_object - the handle to the page object. +// R - the red component of the object's fill color. +// G - the green component of the object's fill color. +// B - the blue component of the object's fill color. +// A - the fill alpha of the object. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPageObj_GetFillColor(FPDF_PAGEOBJECT page_object, + unsigned int* R, + unsigned int* G, + unsigned int* B, + unsigned int* A); + +// Experimental API. +// Get number of segments inside |path|. +// +// path - handle to a path. +// +// A segment is a command, created by e.g. FPDFPath_MoveTo(), +// FPDFPath_LineTo() or FPDFPath_BezierTo(). +// +// Returns the number of objects in |path| or -1 on failure. +FPDF_EXPORT int FPDF_CALLCONV FPDFPath_CountSegments(FPDF_PAGEOBJECT path); + +// Experimental API. +// Get segment in |path| at |index|. +// +// path - handle to a path. +// index - the index of a segment. +// +// Returns the handle to the segment, or NULL on faiure. +FPDF_EXPORT FPDF_PATHSEGMENT FPDF_CALLCONV +FPDFPath_GetPathSegment(FPDF_PAGEOBJECT path, int index); + +// Experimental API. +// Get coordinates of |segment|. +// +// segment - handle to a segment. +// x - the horizontal position of the segment. +// y - the vertical position of the segment. +// +// Returns TRUE on success, otherwise |x| and |y| is not set. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPathSegment_GetPoint(FPDF_PATHSEGMENT segment, float* x, float* y); + +// Experimental API. +// Get type of |segment|. +// +// segment - handle to a segment. +// +// Returns one of the FPDF_SEGMENT_* values on success, +// FPDF_SEGMENT_UNKNOWN on error. +FPDF_EXPORT int FPDF_CALLCONV FPDFPathSegment_GetType(FPDF_PATHSEGMENT segment); + +// Experimental API. +// Gets if the |segment| closes the current subpath of a given path. +// +// segment - handle to a segment. +// +// Returns close flag for non-NULL segment, FALSE otherwise. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPathSegment_GetClose(FPDF_PATHSEGMENT segment); + +// Move a path's current point. +// +// path - the handle to the path object. +// x - the horizontal position of the new current point. +// y - the vertical position of the new current point. +// +// Note that no line will be created between the previous current point and the +// new one. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_MoveTo(FPDF_PAGEOBJECT path, + float x, + float y); + +// Add a line between the current point and a new point in the path. +// +// path - the handle to the path object. +// x - the horizontal position of the new point. +// y - the vertical position of the new point. +// +// The path's current point is changed to (x, y). +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_LineTo(FPDF_PAGEOBJECT path, + float x, + float y); + +// Add a cubic Bezier curve to the given path, starting at the current point. +// +// path - the handle to the path object. +// x1 - the horizontal position of the first Bezier control point. +// y1 - the vertical position of the first Bezier control point. +// x2 - the horizontal position of the second Bezier control point. +// y2 - the vertical position of the second Bezier control point. +// x3 - the horizontal position of the ending point of the Bezier curve. +// y3 - the vertical position of the ending point of the Bezier curve. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_BezierTo(FPDF_PAGEOBJECT path, + float x1, + float y1, + float x2, + float y2, + float x3, + float y3); + +// Close the current subpath of a given path. +// +// path - the handle to the path object. +// +// This will add a line between the current point and the initial point of the +// subpath, thus terminating the current subpath. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_Close(FPDF_PAGEOBJECT path); + +// Set the drawing mode of a path. +// +// path - the handle to the path object. +// fillmode - the filling mode to be set: one of the FPDF_FILLMODE_* flags. +// stroke - a boolean specifying if the path should be stroked or not. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_SetDrawMode(FPDF_PAGEOBJECT path, + int fillmode, + FPDF_BOOL stroke); + +// Experimental API. +// Get the drawing mode of a path. +// +// path - the handle to the path object. +// fillmode - the filling mode of the path: one of the FPDF_FILLMODE_* flags. +// stroke - a boolean specifying if the path is stroked or not. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_GetDrawMode(FPDF_PAGEOBJECT path, + int* fillmode, + FPDF_BOOL* stroke); + +// Experimental API. +// Get the transform matrix of a path. +// +// path - handle to a path. +// matrix - pointer to struct to receive the matrix value. +// +// The matrix is composed as: +// |a c e| +// |b d f| +// and used to scale, rotate, shear and translate the path. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_GetMatrix(FPDF_PAGEOBJECT path, + FS_MATRIX* matrix); + +// Experimental API. +// Set the transform matrix of a path. +// +// path - handle to a path. +// matrix - pointer to struct with the matrix value. +// +// The matrix is composed as: +// |a c e| +// |b d f| +// and can be used to scale, rotate, shear and translate the path. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_SetMatrix(FPDF_PAGEOBJECT path, + const FS_MATRIX* matrix); + +// Create a new text object using one of the standard PDF fonts. +// +// document - handle to the document. +// font - string containing the font name, without spaces. +// font_size - the font size for the new text object. +// +// Returns a handle to a new text object, or NULL on failure +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV +FPDFPageObj_NewTextObj(FPDF_DOCUMENT document, + FPDF_BYTESTRING font, + float font_size); + +// Set the text for a textobject. If it had text, it will be replaced. +// +// text_object - handle to the text object. +// text - the UTF-16LE encoded string containing the text to be added. +// +// Returns TRUE on success +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFText_SetText(FPDF_PAGEOBJECT text_object, FPDF_WIDESTRING text); + +// Returns a font object loaded from a stream of data. The font is loaded +// into the document. +// +// document - handle to the document. +// data - the stream of data, which will be copied by the font object. +// size - size of the stream, in bytes. +// font_type - FPDF_FONT_TYPE1 or FPDF_FONT_TRUETYPE depending on the font +// type. +// cid - a boolean specifying if the font is a CID font or not. +// +// The loaded font can be closed using FPDFFont_Close. +// +// Returns NULL on failure +FPDF_EXPORT FPDF_FONT FPDF_CALLCONV FPDFText_LoadFont(FPDF_DOCUMENT document, + const uint8_t* data, + uint32_t size, + int font_type, + FPDF_BOOL cid); + +// Experimental API. +// Loads one of the standard 14 fonts per PDF spec 1.7 page 416. The preferred +// way of using font style is using a dash to separate the name from the style, +// for example 'Helvetica-BoldItalic'. +// +// document - handle to the document. +// font - string containing the font name, without spaces. +// +// The loaded font can be closed using FPDFFont_Close. +// +// Returns NULL on failure. +FPDF_EXPORT FPDF_FONT FPDF_CALLCONV +FPDFText_LoadStandardFont(FPDF_DOCUMENT document, FPDF_BYTESTRING font); + +// Experimental API. +// Get the transform matrix of a text object. +// +// text - handle to a text. +// matrix - pointer to struct with the matrix value. +// +// The matrix is composed as: +// |a c e| +// |b d f| +// and used to scale, rotate, shear and translate the text. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFTextObj_GetMatrix(FPDF_PAGEOBJECT text, + FS_MATRIX* matrix); + +// Experimental API. +// Get the font size of a text object. +// +// text - handle to a text. +// +// Returns the font size of the text object, measured in points (about 1/72 +// inch) on success; 0 on failure. +FPDF_EXPORT float FPDF_CALLCONV FPDFTextObj_GetFontSize(FPDF_PAGEOBJECT text); + +// Close a loaded PDF font. +// +// font - Handle to the loaded font. +FPDF_EXPORT void FPDF_CALLCONV FPDFFont_Close(FPDF_FONT font); + +// Create a new text object using a loaded font. +// +// document - handle to the document. +// font - handle to the font object. +// font_size - the font size for the new text object. +// +// Returns a handle to a new text object, or NULL on failure +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV +FPDFPageObj_CreateTextObj(FPDF_DOCUMENT document, + FPDF_FONT font, + float font_size); + +// Experimental API. +// Get the text rendering mode of a text object. +// +// text - the handle to the text object. +// +// Returns one of the known FPDF_TEXT_RENDERMODE enum values on success, +// FPDF_TEXTRENDERMODE_UNKNOWN on error. +FPDF_EXPORT FPDF_TEXT_RENDERMODE FPDF_CALLCONV +FPDFTextObj_GetTextRenderMode(FPDF_PAGEOBJECT text); + +// Experimental API. +// Set the text rendering mode of a text object. +// +// text - the handle to the text object. +// render_mode - the FPDF_TEXT_RENDERMODE enum value to be set (cannot set to +// FPDF_TEXTRENDERMODE_UNKNOWN). +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFTextObj_SetTextRenderMode(FPDF_PAGEOBJECT text, + FPDF_TEXT_RENDERMODE render_mode); + +// Experimental API. +// Get the font name of a text object. +// +// text - the handle to the text object. +// buffer - the address of a buffer that receives the font name. +// length - the size, in bytes, of |buffer|. +// +// Returns the number of bytes in the font name (including the trailing NUL +// character) on success, 0 on error. +// +// Regardless of the platform, the |buffer| is always in UTF-8 encoding. +// If |length| is less than the returned length, or |buffer| is NULL, |buffer| +// will not be modified. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFTextObj_GetFontName(FPDF_PAGEOBJECT text, + void* buffer, + unsigned long length); + +// Experimental API. +// Get the text of a text object. +// +// text_object - the handle to the text object. +// text_page - the handle to the text page. +// buffer - the address of a buffer that receives the text. +// length - the size, in bytes, of |buffer|. +// +// Returns the number of bytes in the text (including the trailing NUL +// character) on success, 0 on error. +// +// Regardless of the platform, the |buffer| is always in UTF-16LE encoding. +// If |length| is less than the returned length, or |buffer| is NULL, |buffer| +// will not be modified. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFTextObj_GetText(FPDF_PAGEOBJECT text_object, + FPDF_TEXTPAGE text_page, + void* buffer, + unsigned long length); + +// Experimental API. +// Get number of page objects inside |form_object|. +// +// form_object - handle to a form object. +// +// Returns the number of objects in |form_object| on success, -1 on error. +FPDF_EXPORT int FPDF_CALLCONV +FPDFFormObj_CountObjects(FPDF_PAGEOBJECT form_object); + +// Experimental API. +// Get page object in |form_object| at |index|. +// +// form_object - handle to a form object. +// index - the 0-based index of a page object. +// +// Returns the handle to the page object, or NULL on error. +FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV +FPDFFormObj_GetObject(FPDF_PAGEOBJECT form_object, unsigned long index); + +// Experimental API. +// Get the transform matrix of a form object. +// +// form_object - handle to a form. +// matrix - pointer to struct to receive the matrix value. +// +// The matrix is composed as: +// |a c e| +// |b d f| +// and used to scale, rotate, shear and translate the form object. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFFormObj_GetMatrix(FPDF_PAGEOBJECT form_object, FS_MATRIX* matrix); #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_EDIT_H_ diff --git a/src/main/jni/include/fpdf_ext.h b/src/main/jni/include/fpdf_ext.h index c80dcbbf..b1784dd6 100644 --- a/src/main/jni/include/fpdf_ext.h +++ b/src/main/jni/include/fpdf_ext.h @@ -7,102 +7,113 @@ #ifndef PUBLIC_FPDF_EXT_H_ #define PUBLIC_FPDF_EXT_H_ +#include + +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" #ifdef __cplusplus extern "C" { -#endif +#endif // __cplusplus -// flags for type of unsupport object. +// 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. Currently must be 1. - **/ + // Version number of the interface. Must be 1. int version; - /** - * Method: FSDK_UnSupport_Handler - * UnSupport Object process handling function. - * Interface Version: - * 1 - * Implementation Required: - * Yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * nType - The type of unsupportObject - * Return value: - * None. - * */ - + // 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; -/** - * Function: FSDK_SetUnSpObjProcessHandler - * Setup A UnSupport Object process handler for foxit sdk. - * Parameters: - * unsp_info - Pointer to a UNSUPPORT_INFO structure. - * Return Value: - * TRUE means successful. FALSE means fails. - **/ - -DLLEXPORT FPDF_BOOL STDCALL +// Setup an unsupported object handler. +// +// unsp_info - Pointer to an UNSUPPORT_INFO structure. +// +// Returns TRUE on success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FSDK_SetUnSpObjProcessHandler(UNSUPPORT_INFO* unsp_info); -// flags for page mode. - -// Unknown value +// Set replacement function for calls to time(). +// +// This API is intended to be used only for testing, thus may cause PDFium to +// behave poorly in production environments. +// +// func - Function pointer to alternate implementation of time(), or +// NULL to restore to actual time() call itself. +FPDF_EXPORT void FPDF_CALLCONV FSDK_SetTimeFunction(time_t (*func)()); + +// Set replacement function for calls to localtime(). +// +// This API is intended to be used only for testing, thus may cause PDFium to +// behave poorly in production environments. +// +// func - Function pointer to alternate implementation of localtime(), or +// NULL to restore to actual localtime() call itself. +FPDF_EXPORT void FPDF_CALLCONV +FSDK_SetLocaltimeFunction(struct tm* (*func)(const time_t*)); + +// Unknown page mode. #define PAGEMODE_UNKNOWN -1 - -// Neither document outline nor thumbnail images visible +// Document outline, and thumbnails hidden. #define PAGEMODE_USENONE 0 - -// Document outline visible +// Document outline visible. #define PAGEMODE_USEOUTLINES 1 - -// Thumbnial images visible +// Thumbnail images visible. #define PAGEMODE_USETHUMBS 2 - -// Full-screen mode, with no menu bar, window controls, or any other window -// visible +// Full-screen mode, no menu bar, window controls, or other decorations visible. #define PAGEMODE_FULLSCREEN 3 - -// Optional content group panel visible +// Optional content group panel visible. #define PAGEMODE_USEOC 4 - -// Attachments panel visible +// Attachments panel visible. #define PAGEMODE_USEATTACHMENTS 5 -/** - * Function: FPDFDoc_GetPageMode - * Get the document's PageMode(How the document should be displayed - *when opened) - * Parameters: - * doc - Handle to document. Returned by FPDF_LoadDocument - *function. - * Return Value: - * The flags for page mode. - **/ -DLLEXPORT int FPDFDoc_GetPageMode(FPDF_DOCUMENT document); +// 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. +FPDF_EXPORT int FPDF_CALLCONV FPDFDoc_GetPageMode(FPDF_DOCUMENT document); #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_EXT_H_ diff --git a/src/main/jni/include/fpdf_flatten.h b/src/main/jni/include/fpdf_flatten.h index af77c293..614540e1 100644 --- a/src/main/jni/include/fpdf_flatten.h +++ b/src/main/jni/include/fpdf_flatten.h @@ -7,39 +7,38 @@ #ifndef PUBLIC_FPDF_FLATTEN_H_ #define PUBLIC_FPDF_FLATTEN_H_ +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" -// Result codes. -#define FLATTEN_FAIL 0 // Flatten operation failed. -#define FLATTEN_SUCCESS 1 // Flatten operation succeed. -#define FLATTEN_NOTHINGTODO 2 // There is nothing to be flattened. +// Flatten operation failed. +#define FLATTEN_FAIL 0 +// Flatten operation succeed. +#define FLATTEN_SUCCESS 1 +// Nothing to be flattened. +#define FLATTEN_NOTHINGTODO 2 -// Flags. +// Flatten for normal display. #define FLAT_NORMALDISPLAY 0 +// Flatten for print. #define FLAT_PRINT 1 #ifdef __cplusplus extern "C" { -#endif - -// Function: FPDFPage_Flatten -// Make annotations and form fields become part of the page contents -// itself. -// Parameters: -// page - Handle to the page, as returned by FPDF_LoadPage(). -// nFlag - Intended use of the flattened result: 0 for normal display, -// 1 for printing. -// Return value: -// Either FLATTEN_FAIL, FLATTEN_SUCCESS, or FLATTEN_NOTHINGTODO (see -// above). -// Comments: -// Currently, all failures return FLATTEN_FAIL, with no indication for -// the reason -// for the failure. -DLLEXPORT int STDCALL FPDFPage_Flatten(FPDF_PAGE page, int nFlag); +#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. +FPDF_EXPORT int FPDF_CALLCONV FPDFPage_Flatten(FPDF_PAGE page, int nFlag); #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_FLATTEN_H_ diff --git a/src/main/jni/include/fpdf_formfill.h b/src/main/jni/include/fpdf_formfill.h index b3bbb928..9b6c4d44 100644 --- a/src/main/jni/include/fpdf_formfill.h +++ b/src/main/jni/include/fpdf_formfill.h @@ -7,15 +7,42 @@ #ifndef PUBLIC_FPDF_FORMFILL_H_ #define PUBLIC_FPDF_FORMFILL_H_ +// clang-format off +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" -typedef void* FPDF_FORMHANDLE; - -#ifdef PDF_ENABLE_XFA -#define DOCTYPE_PDF 0 // Normal pdf Document -#define DOCTYPE_DYNAMIC_XFA 1 // Dynamic xfa Document Type -#define DOCTYPE_STATIC_XFA 2 // Static xfa Document Type -#endif // PDF_ENABLE_XFA +// These values are return values for a public API, so should not be changed +// other than the count when adding new values. +#define FORMTYPE_NONE 0 // Document contains no forms +#define FORMTYPE_ACRO_FORM 1 // Forms are specified using AcroForm spec +#define FORMTYPE_XFA_FULL 2 // Forms are specified using entire XFA spec +#define FORMTYPE_XFA_FOREGROUND 3 // Forms are specified using the XFAF subset + // of XFA spec +#define FORMTYPE_COUNT 4 // The number of form types + +#define JSPLATFORM_ALERT_BUTTON_OK 0 // OK button +#define JSPLATFORM_ALERT_BUTTON_OKCANCEL 1 // OK & Cancel buttons +#define JSPLATFORM_ALERT_BUTTON_YESNO 2 // Yes & No buttons +#define JSPLATFORM_ALERT_BUTTON_YESNOCANCEL 3 // Yes, No & Cancel buttons +#define JSPLATFORM_ALERT_BUTTON_DEFAULT JSPLATFORM_ALERT_BUTTON_OK + +#define JSPLATFORM_ALERT_ICON_ERROR 0 // Error +#define JSPLATFORM_ALERT_ICON_WARNING 1 // Warning +#define JSPLATFORM_ALERT_ICON_QUESTION 2 // Question +#define JSPLATFORM_ALERT_ICON_STATUS 3 // Status +#define JSPLATFORM_ALERT_ICON_ASTERISK 4 // Asterisk +#define JSPLATFORM_ALERT_ICON_DEFAULT JSPLATFORM_ALERT_ICON_ERROR + +#define JSPLATFORM_ALERT_RETURN_OK 1 // OK +#define JSPLATFORM_ALERT_RETURN_CANCEL 2 // Cancel +#define JSPLATFORM_ALERT_RETURN_NO 3 // No +#define JSPLATFORM_ALERT_RETURN_YES 4 // Yes + +#define JSPLATFORM_BEEP_ERROR 0 // Error +#define JSPLATFORM_BEEP_WARNING 1 // Warning +#define JSPLATFORM_BEEP_QUESTION 2 // Question +#define JSPLATFORM_BEEP_STATUS 3 // Status +#define JSPLATFORM_BEEP_DEFAULT 4 // Default // Exported Functions #ifdef __cplusplus @@ -23,103 +50,89 @@ extern "C" { #endif typedef struct _IPDF_JsPlatform { - /** - * Version number of the interface. Currently must be 2. - **/ + /* + * Version number of the interface. Currently must be 2. + */ int version; /* Version 1. */ - /** - * Method: app_alert - * pop up a dialog to show warning or hint. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * Msg - A string containing the message to be displayed. - * Title - The title of the dialog. - * Type - The stype of button group. - * 0-OK(default); - * 1-OK,Cancel; - * 2-Yes,NO; - * 3-Yes, NO, Cancel. - * nIcon - The Icon type. - * 0-Error(default); - * 1-Warning; - * 2-Question; - * 3-Status. - * 4-Asterisk - * Return Value: - * The return value could be the folowing type: - * 1-OK; - * 2-Cancel; - * 3-NO; - * 4-Yes; - */ + /* + * Method: app_alert + * Pop up a dialog to show warning or hint. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * Msg - A string containing the message to be displayed. + * Title - The title of the dialog. + * Type - The type of button group, one of the + * JSPLATFORM_ALERT_BUTTON_* values above. + * nIcon - The type of the icon, one of the + * JSPLATFORM_ALERT_ICON_* above. + * Return Value: + * Option selected by user in dialogue, one of the + * JSPLATFORM_ALERT_RETURN_* values above. + */ int (*app_alert)(struct _IPDF_JsPlatform* pThis, FPDF_WIDESTRING Msg, FPDF_WIDESTRING Title, int Type, int Icon); - /** - * Method: app_beep - * Causes the system to play a sound. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * nType - The sound type. - * 0 - Error - * 1 - Warning - * 2 - Question - * 3 - Status - * 4 - Default (default value) - * Return Value: - * None - */ + /* + * Method: app_beep + * Causes the system to play a sound. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself + * nType - The sound type, see JSPLATFORM_BEEP_TYPE_* + * above. + * Return Value: + * None + */ void (*app_beep)(struct _IPDF_JsPlatform* pThis, int nType); - /** - * Method: app_response - * Displays a dialog box containing a question and an entry field for - * the user to reply to the question. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * Question - The question to be posed to the user. - * Title - The title of the dialog box. - * Default - A default value for the answer to the question. If - * not specified, no default value is presented. - * cLabel - A short string to appear in front of and on the - * same line as the edit text field. - * bPassword - If true, indicates that the user's response should - * show as asterisks (*) or bullets (?) to mask the response, which might be - * sensitive information. The default is false. - * response - A string buffer allocated by SDK, to receive the - * user's response. - * length - The length of the buffer, number of bytes. - * Currently, It's always be 2048. - * Return Value: - * Number of bytes the complete user input would actually require, not - * including trailing zeros, regardless of the value of the length - * parameter or the presence of the response buffer. - * Comments: - * No matter on what platform, the response buffer should be always - * written using UTF-16LE encoding. If a response buffer is - * present and the size of the user input exceeds the capacity of the - * buffer as specified by the length parameter, only the - * first "length" bytes of the user input are to be written to the - * buffer. - */ + /* + * Method: app_response + * Displays a dialog box containing a question and an entry field for + * the user to reply to the question. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself + * Question - The question to be posed to the user. + * Title - The title of the dialog box. + * Default - A default value for the answer to the question. If + * not specified, no default value is presented. + * cLabel - A short string to appear in front of and on the + * same line as the edit text field. + * bPassword - If true, indicates that the user's response should + * be shown as asterisks (*) or bullets (?) to mask + * the response, which might be sensitive information. + * response - A string buffer allocated by PDFium, to receive the + * user's response. + * length - The length of the buffer in bytes. Currently, it is + * always 2048. + * Return Value: + * Number of bytes the complete user input would actually require, not + * including trailing zeros, regardless of the value of the length + * parameter or the presence of the response buffer. + * Comments: + * No matter on what platform, the response buffer should be always + * written using UTF-16LE encoding. If a response buffer is + * present and the size of the user input exceeds the capacity of the + * buffer as specified by the length parameter, only the + * first "length" bytes of the user input are to be written to the + * buffer. + */ int (*app_response)(struct _IPDF_JsPlatform* pThis, FPDF_WIDESTRING Question, FPDF_WIDESTRING Title, @@ -130,65 +143,64 @@ typedef struct _IPDF_JsPlatform { int length); /* - * Method: Doc_getFilePath - * Get the file path of the current document. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * filePath - The string buffer to receive the file path. Can be - * NULL. - * length - The length of the buffer, number of bytes. Can be - * 0. - * Return Value: - * Number of bytes the filePath consumes, including trailing zeros. - * Comments: - * The filePath should be always input in local encoding. - * - * The return value always indicated number of bytes required for the - * buffer, even when there is - * no buffer specified, or the buffer size is less then required. In this - * case, the buffer will not - * be modified. - */ + * Method: Doc_getFilePath + * Get the file path of the current document. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself + * filePath - The string buffer to receive the file path. Can + * be NULL. + * length - The length of the buffer, number of bytes. Can + * be 0. + * Return Value: + * Number of bytes the filePath consumes, including trailing zeros. + * Comments: + * The filePath should always be provided in the local encoding. + * The return value always indicated number of bytes required for + * the buffer, even when there is no buffer specified, or the buffer + * size is less than required. In this case, the buffer will not + * be modified. + */ int (*Doc_getFilePath)(struct _IPDF_JsPlatform* pThis, void* filePath, int length); /* - * Method: Doc_mail - * Mails the data buffer as an attachment to all recipients, with or - * without user interaction. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * mailData - Pointer to the data buffer to be sent.Can be NULL. - * length - The size,in bytes, of the buffer pointed by - * mailData parameter.Can be 0. - * bUI - If true, the rest of the parameters are used in a - * compose-new-message window that is displayed to the user. If false, the cTo - * parameter is required and all others are optional. - * To - A semicolon-delimited list of recipients for the - * message. - * Subject - The subject of the message. The length limit is 64 - * KB. - * CC - A semicolon-delimited list of CC recipients for - * the message. - * BCC - A semicolon-delimited list of BCC recipients for - * the message. - * Msg - The content of the message. The length limit is 64 - * KB. - * Return Value: - * None. - * Comments: - * If the parameter mailData is NULL or length is 0, the current - * document will be mailed as an attachment to all recipients. - */ + * Method: Doc_mail + * Mails the data buffer as an attachment to all recipients, with or + * without user interaction. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself + * mailData - Pointer to the data buffer to be sent. Can be NULL. + * length - The size,in bytes, of the buffer pointed by + * mailData parameter. Can be 0. + * bUI - If true, the rest of the parameters are used in a + * compose-new-message window that is displayed to the + * user. If false, the cTo parameter is required and + * all others are optional. + * To - A semicolon-delimited list of recipients for the + * message. + * Subject - The subject of the message. The length limit is + * 64 KB. + * CC - A semicolon-delimited list of CC recipients for + * the message. + * BCC - A semicolon-delimited list of BCC recipients for + * the message. + * Msg - The content of the message. The length limit is + * 64 KB. + * Return Value: + * None. + * Comments: + * If the parameter mailData is NULL or length is 0, the current + * document will be mailed as an attachment to all recipients. + */ void (*Doc_mail)(struct _IPDF_JsPlatform* pThis, void* mailData, int length, @@ -200,29 +212,32 @@ typedef struct _IPDF_JsPlatform { FPDF_WIDESTRING Msg); /* - * Method: Doc_print - * Prints all or a specific number of pages of the document. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * bUI - If true, will cause a UI to be presented to the - * user to obtain printing information and confirm the action. - * nStart - A 0-based index that defines the start of an - * inclusive range of pages. - * nEnd - A 0-based index that defines the end of an - * inclusive page range. - * bSilent - If true, suppresses the cancel dialog box while - * the document is printing. The default is false. - * bShrinkToFit - If true, the page is shrunk (if necessary) to - * fit within the imageable area of the printed page. - * bPrintAsImage - If true, print pages as an image. - * bReverse - If true, print from nEnd to nStart. - * bAnnotations - If true (the default), annotations are - * printed. - */ + * Method: Doc_print + * Prints all or a specific number of pages of the document. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * bUI - If true, will cause a UI to be presented to the + * user to obtain printing information and confirm + * the action. + * nStart - A 0-based index that defines the start of an + * inclusive range of pages. + * nEnd - A 0-based index that defines the end of an + * inclusive page range. + * bSilent - If true, suppresses the cancel dialog box while + * the document is printing. The default is false. + * bShrinkToFit - If true, the page is shrunk (if necessary) to + * fit within the imageable area of the printed page. + * bPrintAsImage - If true, print pages as an image. + * bReverse - If true, print from nEnd to nStart. + * bAnnotations - If true (the default), annotations are + * printed. + * Return Value: + * None. + */ void (*Doc_print)(struct _IPDF_JsPlatform* pThis, FPDF_BOOL bUI, int nStart, @@ -234,68 +249,66 @@ typedef struct _IPDF_JsPlatform { FPDF_BOOL bAnnotations); /* - * Method: Doc_submitForm - * Send the form data to a specified URL. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * formData - Pointer to the data buffer to be sent. - * length - The size,in bytes, of the buffer pointed by - * formData parameter. - * URL - The URL to send to. - * Return Value: - * None. - * - */ + * Method: Doc_submitForm + * Send the form data to a specified URL. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself + * formData - Pointer to the data buffer to be sent. + * length - The size,in bytes, of the buffer pointed by + * formData parameter. + * URL - The URL to send to. + * Return Value: + * None. + */ void (*Doc_submitForm)(struct _IPDF_JsPlatform* pThis, void* formData, int length, FPDF_WIDESTRING URL); /* - * Method: Doc_gotoPage - * Jump to a specified page. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself - * nPageNum - The specified page number, zero for the first - * page. - * Return Value: - * None. - * - */ + * Method: Doc_gotoPage + * Jump to a specified page. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself + * nPageNum - The specified page number, zero for the first page. + * Return Value: + * None. + * + */ void (*Doc_gotoPage)(struct _IPDF_JsPlatform* pThis, int nPageNum); + /* - * Method: Field_browse - * Show a file selection dialog, and return the selected file path. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * filePath - Pointer to the data buffer to receive the file - * path.Can be NULL. - * length - The length of the buffer, number of bytes. Can be - * 0. - * Return Value: - * Number of bytes the filePath consumes, including trailing zeros. - * Comments: - * The filePath shoule be always input in local encoding. - */ + * Method: Field_browse + * Show a file selection dialog, and return the selected file path. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * filePath - Pointer to the data buffer to receive the file + * path. Can be NULL. + * length - The length of the buffer, in bytes. Can be 0. + * Return Value: + * Number of bytes the filePath consumes, including trailing zeros. + * Comments: + * The filePath shoule always be provided in local encoding. + */ int (*Field_browse)(struct _IPDF_JsPlatform* pThis, void* filePath, int length); - /** - * pointer to FPDF_FORMFILLINFO interface. - **/ + /* + * Pointer to FPDF_FORMFILLINFO interface. + */ void* m_pFormfillinfo; /* Version 2. */ @@ -305,7 +318,6 @@ typedef struct _IPDF_JsPlatform { /* Version 3. */ /* Version 3 moves m_Isolate and m_v8EmbedderSlot to FPDF_LIBRARY_CONFIG. */ - } IPDF_JSPLATFORM; // Flags for Cursor type @@ -316,19 +328,19 @@ typedef struct _IPDF_JsPlatform { #define FXCT_HBEAM 4 #define FXCT_HAND 5 -/** - * Declares of a pointer type to the callback function for the FFI_SetTimer - *method. +/* + * Function signature for the callback function passed to the FFI_SetTimer + * method. * Parameters: * idEvent - Identifier of the timer. * Return value: * None. - **/ + */ typedef void (*TimerCallback)(int idEvent); -/** +/* * Declares of a struct type to the local system time. -**/ + */ typedef struct _FPDF_SYSTEMTIME { unsigned short wYear; /* years since 1900 */ unsigned short wMonth; /* months since January - [0,11] */ @@ -341,92 +353,84 @@ typedef struct _FPDF_SYSTEMTIME { } FPDF_SYSTEMTIME; #ifdef PDF_ENABLE_XFA -// XFA -/** - * @name Pageview event flags - */ -/*@{*/ -/** @brief After a new pageview is added. */ -#define FXFA_PAGEVIEWEVENT_POSTADDED 1 -/** @brief After a pageview is removed. */ -#define FXFA_PAGEVIEWEVENT_POSTREMOVED 3 -/*@}*/ - -// menu -/** - * @name Macro Definitions for Right Context Menu Features Of XFA Fields - */ -/*@{*/ -#define FXFA_MEMU_COPY 1 -#define FXFA_MEMU_CUT 2 -#define FXFA_MEMU_SELECTALL 4 -#define FXFA_MEMU_UNDO 8 -#define FXFA_MEMU_REDO 16 -#define FXFA_MEMU_PASTE 32 -/*@}*/ - -// file type -/** - * @name Macro Definitions for File Type. - */ -/*@{*/ + +// Pageview event flags +#define FXFA_PAGEVIEWEVENT_POSTADDED 1 // After a new pageview is added. +#define FXFA_PAGEVIEWEVENT_POSTREMOVED 3 // After a pageview is removed. + +// Definitions for Right Context Menu Features Of XFA Fields +#define FXFA_MENU_COPY 1 +#define FXFA_MENU_CUT 2 +#define FXFA_MENU_SELECTALL 4 +#define FXFA_MENU_UNDO 8 +#define FXFA_MENU_REDO 16 +#define FXFA_MENU_PASTE 32 + +// Definitions for File Type. #define FXFA_SAVEAS_XML 1 #define FXFA_SAVEAS_XDP 2 -/*@}*/ + #endif // PDF_ENABLE_XFA typedef struct _FPDF_FORMFILLINFO { - /** - * Version number of the interface. Currently must be 1 (when PDFium is built - * without the XFA module) or must be 2 (when built with the XFA module). - **/ + /* + * Version number of the interface. + * Version 1 contains stable interfaces. Version 2 has additional + * experimental interfaces. + * When PDFium is built without the XFA module, version can be 1 or 2. + * With version 1, only stable interfaces are called. With version 2, + * additional experimental interfaces are also called. + * When PDFium is built with the XFA module, version must be 2. + * All the XFA related interfaces are experimental. If PDFium is built with + * the XFA module and version 1 then none of the XFA related interfaces + * would be called. When PDFium is built with XFA module then the version + * must be 2. + */ int version; /* Version 1. */ - /** - *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 + /* + * Method: Release + * Give the implementation a chance to release any resources after the + * interface is no longer used. + * Interface Version: + * 1 + * Implementation Required: + * No + * Comments: + * Called by PDFium during the final cleanup process. + * Parameters: + * pThis - Pointer to the interface structure itself + * Return Value: + * None */ void (*Release)(struct _FPDF_FORMFILLINFO* pThis); - /** + /* * Method: FFI_Invalidate - * Invalidate the client area within the specified rectangle. + * Invalidate the client area within the specified rectangle. * Interface Version: - * 1 + * 1 * Implementation Required: - * yes + * yes * Parameters: - * pThis - Pointer to the interface structure itself. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * left - Left position of the client area in PDF page - *coordinate. - * top - Top position of the client area in PDF page - *coordinate. - * right - Right position of the client area in PDF page - *coordinate. - * bottom - Bottom position of the client area in PDF page - *coordinate. + * pThis - Pointer to the interface structure itself. + * page - Handle to the page. Returned by FPDF_LoadPage(). + * left - Left position of the client area in PDF page + * coordinates. + * top - Top position of the client area in PDF page + * coordinates. + * right - Right position of the client area in PDF page + * coordinates. + * bottom - Bottom position of the client area in PDF page + * coordinates. * Return Value: - * None. - * - *comments: - * All positions are measured in PDF "user space". - * Implementation should call FPDF_RenderPageBitmap() function for - *repainting a specified page area. - */ + * None. + * Comments: + * All positions are measured in PDF "user space". + * Implementation should call FPDF_RenderPageBitmap() for repainting + * the specified page area. + */ void (*FFI_Invalidate)(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, double left, @@ -434,38 +438,34 @@ typedef struct _FPDF_FORMFILLINFO { double right, double bottom); - /** + /* * Method: FFI_OutputSelectedRect - * When user is taking the mouse to select texts on a form field, - * this callback function will keep - * returning the selected areas to the implementation. - * + * When the user selects text in form fields with the mouse, this + * callback function will be invoked with the selected areas. * Interface Version: - * 1 + * 1 * Implementation Required: - * No + * No * Parameters: - * pThis - Pointer to the interface structure itself. - * page - Handle to the page. Returned by FPDF_LoadPage - * function. - * left - Left position of the client area in PDF page - * coordinate. - * top - Top position of the client area in PDF page - * coordinate. - * right - Right position of the client area in PDF page - * coordinate. - * bottom - Bottom position of the client area in PDF page - * coordinate. + * pThis - Pointer to the interface structure itself. + * page - Handle to the page. Returned by FPDF_LoadPage()/ + * left - Left position of the client area in PDF page + * coordinates. + * top - Top position of the client area in PDF page + * coordinates. + * right - Right position of the client area in PDF page + * coordinates. + * bottom - Bottom position of the client area in PDF page + * coordinates. * Return Value: - * None. - * - * comments: - * This CALLBACK function is useful for implementing special text - * selection effect. Implementation should - * first records the returned rectangles, then draw them one by one - * at the painting period, last,remove all - * the recorded rectangles when finish painting. - */ + * None. + * Comments: + * This callback function is useful for implementing special text + * selection effects. An implementation should first record the + * returned rectangles, then draw them one by one during the next + * painting period. Lastly, it should remove all the recorded + * rectangles when finished painting. + */ void (*FFI_OutputSelectedRect)(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, double left, @@ -473,260 +473,289 @@ typedef struct _FPDF_FORMFILLINFO { double right, double bottom); - /** - * Method: FFI_SetCursor - * Set the Cursor shape. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * nCursorType - Cursor type. see Flags for Cursor type for the - * details. - * Return value: - * None. - * */ + /* + * Method: FFI_SetCursor + * Set the Cursor shape. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * nCursorType - Cursor type, see Flags for Cursor type for details. + * Return value: + * None. + */ void (*FFI_SetCursor)(struct _FPDF_FORMFILLINFO* pThis, int nCursorType); - /** - * Method: FFI_SetTimer - * This method installs a system timer. A time-out value is - * specified, - * and every time a time-out occurs, the system passes a message to - * the TimerProc callback function. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * uElapse - Specifies the time-out value, in milliseconds. - * lpTimerFunc - A pointer to the callback function-TimerCallback. - * Return value: - * The timer identifier of the new timer if the function is successful. - * An application passes this value to the FFI_KillTimer method to kill - * the timer. Nonzero if it is successful; otherwise, it is zero. - * */ + /* + * Method: FFI_SetTimer + * This method installs a system timer. An interval value is specified, + * and every time that interval elapses, the system must call into the + * callback function with the timer ID as returned by this function. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * uElapse - Specifies the time-out value, in milliseconds. + * lpTimerFunc - A pointer to the callback function-TimerCallback. + * Return value: + * The timer identifier of the new timer if the function is successful. + * An application passes this value to the FFI_KillTimer method to kill + * the timer. Nonzero if it is successful; otherwise, it is zero. + */ int (*FFI_SetTimer)(struct _FPDF_FORMFILLINFO* pThis, int uElapse, TimerCallback lpTimerFunc); - /** - * Method: FFI_KillTimer - * This method kills the timer event identified by nIDEvent, set by - * an earlier call to FFI_SetTimer. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * nTimerID - The timer ID return by FFI_SetTimer function. - * Return value: - * None. - * */ + /* + * Method: FFI_KillTimer + * This method uninstalls a system timer, as set by an earlier call to + * FFI_SetTimer. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * nTimerID - The timer ID returned by FFI_SetTimer function. + * Return value: + * None. + */ void (*FFI_KillTimer)(struct _FPDF_FORMFILLINFO* pThis, int nTimerID); - /** - * Method: FFI_GetLocalTime - * This method receives the current local time on the system. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * Return value: - * None. - * */ + /* + * Method: FFI_GetLocalTime + * This method receives the current local time on the system. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * Return value: + * The local time. See FPDF_SYSTEMTIME above for details. + * Note: Unused. + */ FPDF_SYSTEMTIME (*FFI_GetLocalTime)(struct _FPDF_FORMFILLINFO* pThis); - /** - * Method: FFI_OnChange - * This method will be invoked to notify implementation when the - * value of any FormField on the document had been changed. - * Interface Version: - * 1 - * Implementation Required: - * no - * Parameters: - * pThis - Pointer to the interface structure itself. - * Return value: - * None. - * */ + /* + * Method: FFI_OnChange + * This method will be invoked to notify the implementation when the + * value of any FormField on the document had been changed. + * Interface Version: + * 1 + * Implementation Required: + * no + * Parameters: + * pThis - Pointer to the interface structure itself. + * Return value: + * None. + */ void (*FFI_OnChange)(struct _FPDF_FORMFILLINFO* pThis); - /** - * Method: FFI_GetPage - * This method receives the page pointer associated with a specified - * page index. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * document - Handle to document. Returned by FPDF_LoadDocument - * function. - * nPageIndex - Index number of the page. 0 for the first page. - * Return value: - * Handle to the page. Returned by FPDF_LoadPage function. - * Comments: - * In some cases, the document-level JavaScript action may refer to a - * page which hadn't been loaded yet. - * To successfully run the javascript action, implementation need to load - * the page for SDK. - * */ - FPDF_PAGE (*FFI_GetPage)(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, int nPageIndex); - - /** - * Method: FFI_GetCurrentPage - * This method receives the current page pointer. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * document - Handle to document. Returned by FPDF_LoadDocument - * function. - * Return value: - * Handle to the page. Returned by FPDF_LoadPage function. - * */ - FPDF_PAGE (*FFI_GetCurrentPage)(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document); + /* + * Method: FFI_GetPage + * This method receives the page handle associated with a specified + * page index. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * document - Handle to document. Returned by FPDF_LoadDocument(). + * nPageIndex - Index number of the page. 0 for the first page. + * Return value: + * Handle to the page, as previously returned to the implementation by + * FPDF_LoadPage(). + * Comments: + * The implementation is expected to keep track of the page handles it + * receives from PDFium, and their mappings to page numbers. In some + * cases, the document-level JavaScript action may refer to a page + * which hadn't been loaded yet. To successfully run the Javascript + * action, the implementation needs to load the page. + */ + FPDF_PAGE (*FFI_GetPage)(struct _FPDF_FORMFILLINFO* pThis, + FPDF_DOCUMENT document, + int nPageIndex); - /** - * Method: FFI_GetRotation - * This method receives currently rotation of the page view. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * page - Handle to page. Returned by FPDF_LoadPage function. - * Return value: - * The page rotation. Should be 0(0 degree),1(90 degree),2(180 - * degree),3(270 degree), in a clockwise direction. - * */ + /* + * Method: FFI_GetCurrentPage + * This method receives the handle to the current page. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * document - Handle to document. Returned by FPDF_LoadDocument(). + * Return value: + * Handle to the page. Returned by FPDF_LoadPage(). + * Comments: + * The implementation is expected to keep track of the current page, + * e.g. the current page can be the one that is most visible on screen. + */ + FPDF_PAGE (*FFI_GetCurrentPage)(struct _FPDF_FORMFILLINFO* pThis, + FPDF_DOCUMENT document); + + /* + * Method: FFI_GetRotation + * This method receives currently rotation of the page view. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * page - Handle to page, as returned by FPDF_LoadPage(). + * Return value: + * A number to indicate the page rotation in 90 degree increments + * in a clockwise direction: + * 0 - 0 degrees + * 1 - 90 degrees + * 2 - 180 degrees + * 3 - 270 degrees + * Note: Unused. + */ int (*FFI_GetRotation)(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page); - /** - * Method: FFI_ExecuteNamedAction - * This method will execute an named action. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * namedAction - A byte string which indicates the named action, - * terminated by 0. - * Return value: - * None. - * Comments: - * See the named actions description of <> - * for more details. - * */ + /* + * Method: FFI_ExecuteNamedAction + * This method will execute a named action. + * Interface Version: + * 1 + * Implementation Required: + * yes + * Parameters: + * pThis - Pointer to the interface structure itself. + * namedAction - A byte string which indicates the named action, + * terminated by 0. + * Return value: + * None. + * Comments: + * See the named actions description of <> + * for more details. + */ void (*FFI_ExecuteNamedAction)(struct _FPDF_FORMFILLINFO* pThis, FPDF_BYTESTRING namedAction); - /** - * @brief This method will be called when a text field is getting or losing a - * focus. - * - * @param[in] pThis Pointer to the interface structure itself. - * @param[in] value The string value of the form field, in UTF-16LE - * format. - * @param[in] valueLen The length of the string value, number of characters - * (not bytes). - * @param[in] is_focus True if the form field is getting a focus, False for - * losing a focus. - * - * @return None. - * - * @note Currently,only support text field and combobox field. - * */ + /* + * Method: FFI_SetTextFieldFocus + * Called when a text field is getting or losing focus. + * Interface Version: + * 1 + * Implementation Required: + * no + * Parameters: + * pThis - Pointer to the interface structure itself. + * value - The string value of the form field, in UTF-16LE + * format. + * valueLen - The length of the string value. This is the + * number of characters, not bytes. + * is_focus - True if the form field is getting focus, false + * if the form field is losing focus. + * Return value: + * None. + * Comments: + * Only supports text fields and combobox fields. + */ void (*FFI_SetTextFieldFocus)(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING value, FPDF_DWORD valueLen, FPDF_BOOL is_focus); - /** - * Method: FFI_DoURIAction - * This action resolves to a uniform resource identifier. - * Interface Version: - * 1 - * Implementation Required: - * No - * Parameters: - * pThis - Pointer to the interface structure itself. - * bsURI - A byte string which indicates the uniform resource - * identifier, terminated by 0. - * Return value: - * None. - * Comments: - * See the URI actions description of <> for - * more details. - * */ + /* + * Method: FFI_DoURIAction + * Ask the implementation to navigate to a uniform resource identifier. + * Interface Version: + * 1 + * Implementation Required: + * No + * Parameters: + * pThis - Pointer to the interface structure itself. + * bsURI - A byte string which indicates the uniform + * resource identifier, terminated by 0. + * Return value: + * None. + * Comments: + * See the URI actions description of <> + * for more details. + */ void (*FFI_DoURIAction)(struct _FPDF_FORMFILLINFO* pThis, FPDF_BYTESTRING bsURI); - /** - * Method: FFI_DoGoToAction - * This action changes the view to a specified destination. - * Interface Version: - * 1 - * Implementation Required: - * No - * Parameters: - * pThis - Pointer to the interface structure itself. - * nPageIndex - The index of the PDF page. - * zoomMode - The zoom mode for viewing page.See Macros - *"PDFZOOM_XXX" defined in "fpdfdoc.h". - * fPosArray - The float array which carries the position info. - * sizeofArray - The size of float array. - * Return value: - * None. - * Comments: - * See the Destinations description of <> in - *8.2.1 for more details. - **/ + /* + * Method: FFI_DoGoToAction + * This action changes the view to a specified destination. + * Interface Version: + * 1 + * Implementation Required: + * No + * Parameters: + * pThis - Pointer to the interface structure itself. + * nPageIndex - The index of the PDF page. + * zoomMode - The zoom mode for viewing page. See below. + * fPosArray - The float array which carries the position info. + * sizeofArray - The size of float array. + * PDFZoom values: + * - XYZ = 1 + * - FITPAGE = 2 + * - FITHORZ = 3 + * - FITVERT = 4 + * - FITRECT = 5 + * - FITBBOX = 6 + * - FITBHORZ = 7 + * - FITBVERT = 8 + * Return value: + * None. + * Comments: + * See the Destinations description of <> + * in 8.2.1 for more details. + */ void (*FFI_DoGoToAction)(struct _FPDF_FORMFILLINFO* pThis, int nPageIndex, int zoomMode, float* fPosArray, int sizeofArray); - /** - * pointer to IPDF_JSPLATFORM interface - **/ + /* + * Pointer to IPDF_JSPLATFORM interface. + * Unused if PDFium is built without V8 support. Otherwise, if NULL, then + * JavaScript will be prevented from executing while rendering the document. + */ IPDF_JSPLATFORM* m_pJsPlatform; -#ifdef PDF_ENABLE_XFA - /* Version 2. */ - /** - * Method: FFI_DisplayCaret - * This method will show the caret at specified position. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * page - Handle to page. Returned by FPDF_LoadPage - *function. - * left - Left position of the client area in PDF page - *coordinate. - * top - Top position of the client area in PDF page - *coordinate. - * right - Right position of the client area in PDF page - *coordinate. - * bottom - Bottom position of the client area in PDF page - *coordinate. - * Return value: - * None. - **/ + /* Version 2 - Experimental. */ + /* + * Whether the XFA module is disabled when built with the XFA module. + * Interface Version: + * Ignored if |version| < 2. + */ + FPDF_BOOL xfa_disabled; + + /* + * Method: FFI_DisplayCaret + * This method will show the caret at specified position. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * page - Handle to page. Returned by FPDF_LoadPage(). + * left - Left position of the client area in PDF page + * coordinates. + * top - Top position of the client area in PDF page + * coordinates. + * right - Right position of the client area in PDF page + * coordinates. + * bottom - Bottom position of the client area in PDF page + * coordinates. + * Return value: + * None. + */ void (*FFI_DisplayCaret)(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_BOOL bVisible, @@ -735,157 +764,185 @@ typedef struct _FPDF_FORMFILLINFO { double right, double bottom); - /** - * Method: FFI_GetCurrentPageIndex - * This method will get the current page index. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * document - Handle to document. Returned by FPDF_LoadDocument - *function. - * Return value: - * The index of current page. - **/ + /* + * Method: FFI_GetCurrentPageIndex + * This method will get the current page index. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * document - Handle to document from FPDF_LoadDocument(). + * Return value: + * The index of current page. + */ int (*FFI_GetCurrentPageIndex)(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document); - /** - * Method: FFI_SetCurrentPage - * This method will set the current page. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * document - Handle to document. Returned by FPDF_LoadDocument - *function. - * iCurPage - The index of the PDF page. - * Return value: - * None. - **/ + /* + * Method: FFI_SetCurrentPage + * This method will set the current page. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * document - Handle to document from FPDF_LoadDocument(). + * iCurPage - The index of the PDF page. + * Return value: + * None. + */ void (*FFI_SetCurrentPage)(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, int iCurPage); - /** + /* * Method: FFI_GotoURL - * This method will link to the specified URL. + * This method will navigate to the specified URL. * Interface Version: - * 1 + * Ignored if |version| < 2. * Implementation Required: - * no + * Required for XFA, otherwise set to NULL. * Parameters: - * pThis - Pointer to the interface structure itself. - * document - Handle to document. Returned by FPDF_LoadDocument - *function. - * wsURL - The string value of the URL, in UTF-16LE format. + * pThis - Pointer to the interface structure itself. + * document - Handle to document from FPDF_LoadDocument(). + * wsURL - The string value of the URL, in UTF-16LE format. * Return value: * None. - **/ + */ void (*FFI_GotoURL)(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, FPDF_WIDESTRING wsURL); - /** - * Method: FFI_GetPageViewRect - * This method will get the current page view rectangle. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * page - Handle to page. Returned by FPDF_LoadPage - *function. - * left - The pointer to receive left position of the page - *view area in PDF page coordinate. - * top - The pointer to receive top position of the page - *view area in PDF page coordinate. - * right - The pointer to receive right position of the - *client area in PDF page coordinate. - * bottom - The pointer to receive bottom position of the - *client area in PDF page coordinate. - * Return value: - * None. - **/ + /* + * Method: FFI_GetPageViewRect + * This method will get the current page view rectangle. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * page - Handle to page. Returned by FPDF_LoadPage(). + * left - The pointer to receive left position of the page + * view area in PDF page coordinates. + * top - The pointer to receive top position of the page + * view area in PDF page coordinates. + * right - The pointer to receive right position of the + * page view area in PDF page coordinates. + * bottom - The pointer to receive bottom position of the + * page view area in PDF page coordinates. + * Return value: + * None. + */ void (*FFI_GetPageViewRect)(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, double* left, double* top, double* right, double* bottom); - /** - * Method: FFI_PopupMenu - * This method will track the right context menu for XFA fields. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * page - Handle to page. Returned by FPDF_LoadPage - *function. - * hWidget - Handle to XFA fields. - * menuFlag - The menu flags. Please refer to macro definition - *of FXFA_MEMU_XXX and this can be one or a combination of these macros. - * x - X position of the client area in PDF page - *coordinate. - * y - Y position of the client area in PDF page - *coordinate. - * Return value: - * TRUE indicates success; otherwise false. - **/ - FPDF_BOOL (*FFI_PopupMenu)(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_WIDGET hWidget, int menuFlag, float x, float y); - - /** - * Method: FFI_OpenFile - * This method will open the specified file with the specified mode. - * Interface Version - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * fileFlag - The file flag.Please refer to macro definition of - *FXFA_SAVEAS_XXX and this can be one of these macros. - * wsURL - The string value of the file URL, in UTF-16LE - *format. - * mode - The mode for open file. - * Return value: - * The handle to FPDF_FILEHANDLER. - **/ + + /* + * Method: FFI_PageEvent + * This method fires when pages have been added to or deleted from + * the XFA document. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * page_count - The number of pages to be added or deleted. + * event_type - See FXFA_PAGEVIEWEVENT_* above. + * Return value: + * None. + * Comments: + * The pages to be added or deleted always start from the last page + * of document. This means that if parameter page_count is 2 and + * event type is FXFA_PAGEVIEWEVENT_POSTADDED, 2 new pages have been + * appended to the tail of document; If page_count is 2 and + * event type is FXFA_PAGEVIEWEVENT_POSTREMOVED, the last 2 pages + * have been deleted. + */ + void (*FFI_PageEvent)(struct _FPDF_FORMFILLINFO* pThis, + int page_count, + FPDF_DWORD event_type); + + /* + * Method: FFI_PopupMenu + * This method will track the right context menu for XFA fields. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * page - Handle to page. Returned by FPDF_LoadPage(). + * hWidget - Always null, exists for compatibility. + * menuFlag - The menu flags. Please refer to macro definition + * of FXFA_MENU_XXX and this can be one or a + * combination of these macros. + * x - X position of the client area in PDF page + * coordinates. + * y - Y position of the client area in PDF page + * coordinates. + * Return value: + * TRUE indicates success; otherwise false. + */ + FPDF_BOOL (*FFI_PopupMenu)(struct _FPDF_FORMFILLINFO* pThis, + FPDF_PAGE page, + FPDF_WIDGET hWidget, + int menuFlag, + float x, + float y); + + /* + * Method: FFI_OpenFile + * This method will open the specified file with the specified mode. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * fileFlag - The file flag. Please refer to macro definition + * of FXFA_SAVEAS_XXX and use one of these macros. + * wsURL - The string value of the file URL, in UTF-16LE + * format. + * mode - The mode for open file, e.g. "rb" or "wb". + * Return value: + * The handle to FPDF_FILEHANDLER. + */ FPDF_FILEHANDLER* (*FFI_OpenFile)(struct _FPDF_FORMFILLINFO* pThis, int fileFlag, FPDF_WIDESTRING wsURL, const char* mode); - /** - * Method: FFI_EmailTo - * This method will email the specified file stream to the specified - *contacter. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * pFileHandler - Handle to the FPDF_FILEHANDLER. - * pTo - A semicolon-delimited list of recipients for the - *message,in UTF-16LE format. - * pSubject - The subject of the message,in UTF-16LE format. - * pCC - A semicolon-delimited list of CC recipients for - *the message,in UTF-16LE format. - * pBcc - A semicolon-delimited list of BCC recipients for - *the message,in UTF-16LE format. - * pMsg - Pointer to the data buffer to be sent.Can be - *NULL,in UTF-16LE format. - * Return value: - * None. - **/ + /* + * Method: FFI_EmailTo + * This method will email the specified file stream to the specified + * contact. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * pFileHandler - Handle to the FPDF_FILEHANDLER. + * pTo - A semicolon-delimited list of recipients for the + * message,in UTF-16LE format. + * pSubject - The subject of the message,in UTF-16LE format. + * pCC - A semicolon-delimited list of CC recipients for + * the message,in UTF-16LE format. + * pBcc - A semicolon-delimited list of BCC recipients for + * the message,in UTF-16LE format. + * pMsg - Pointer to the data buffer to be sent.Can be + * NULL,in UTF-16LE format. + * Return value: + * None. + */ void (*FFI_EmailTo)(struct _FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* fileHandler, FPDF_WIDESTRING pTo, @@ -894,427 +951,677 @@ typedef struct _FPDF_FORMFILLINFO { FPDF_WIDESTRING pBcc, FPDF_WIDESTRING pMsg); - /** - * Method: FFI_UploadTo - * This method will get upload the specified file stream to the - *specified URL. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * pFileHandler - Handle to the FPDF_FILEHANDLER. - * fileFlag - The file flag.Please refer to macro definition of - *FXFA_SAVEAS_XXX and this can be one of these macros. - * uploadTo - Pointer to the URL path, in UTF-16LE format. - * Return value: - * None. - **/ + /* + * Method: FFI_UploadTo + * This method will upload the specified file stream to the + * specified URL. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * pFileHandler - Handle to the FPDF_FILEHANDLER. + * fileFlag - The file flag. Please refer to macro definition + * of FXFA_SAVEAS_XXX and use one of these macros. + * uploadTo - Pointer to the URL path, in UTF-16LE format. + * Return value: + * None. + */ void (*FFI_UploadTo)(struct _FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* fileHandler, int fileFlag, FPDF_WIDESTRING uploadTo); - /** - * Method: FFI_GetPlatform - * This method will get the current platform. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * platform - Pointer to the data buffer to receive the - *platform.Can be NULL,in UTF-16LE format. - * length - The length of the buffer, number of bytes. Can be - *0. - * Return value: - * The length of the buffer, number of bytes. - **/ + /* + * Method: FFI_GetPlatform + * This method will get the current platform. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * platform - Pointer to the data buffer to receive the + * platform,in UTF-16LE format. Can be NULL. + * length - The length of the buffer in bytes. Can be + * 0 to query the required size. + * Return value: + * The length of the buffer, number of bytes. + */ int (*FFI_GetPlatform)(struct _FPDF_FORMFILLINFO* pThis, void* platform, int length); - /** - * Method: FFI_GetLanguage - * This method will get the current language. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * language - Pointer to the data buffer to receive the current - *language.Can be NULL. - * length - The length of the buffer, number of bytes. Can be - *0. - * Return value: - * The length of the buffer, number of bytes. - **/ + /* + * Method: FFI_GetLanguage + * This method will get the current language. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * language - Pointer to the data buffer to receive the + * current language. Can be NULL. + * length - The length of the buffer in bytes. Can be + * 0 to query the required size. + * Return value: + * The length of the buffer, number of bytes. + */ int (*FFI_GetLanguage)(struct _FPDF_FORMFILLINFO* pThis, void* language, int length); - /** + /* * Method: FFI_DownloadFromURL - * This method will download the specified file from the URL. + * This method will download the specified file from the URL. * Interface Version: - * 1 + * Ignored if |version| < 2. * Implementation Required: - * yes + * Required for XFA, otherwise set to NULL. * Parameters: * pThis - Pointer to the interface structure itself. * URL - The string value of the file URL, in UTF-16LE - *format. + * format. * Return value: * The handle to FPDF_FILEHANDLER. - **/ - FPDF_LPFILEHANDLER (*FFI_DownloadFromURL)(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING URL); - /** - * Method: FFI_PostRequestURL - * This method will post the request to the server URL. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * wsURL - The string value of the server URL, in UTF-16LE - *format. - * wsData - The post data,in UTF-16LE format. - * wsContentType - The content type of the request data,in UTF-16LE - *format. - * wsEncode - The encode type,in UTF-16LE format. - * wsHeader - The request header,in UTF-16LE format. - * response - Pointer to the FPDF_BSTR to receive the response - *data from server,,in UTF-16LE format. - * Return value: - * TRUE indicates success, otherwise FALSE. - **/ - FPDF_BOOL (*FFI_PostRequestURL)(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsURL, FPDF_WIDESTRING wsData, FPDF_WIDESTRING wsContentType, FPDF_WIDESTRING wsEncode, FPDF_WIDESTRING wsHeader, FPDF_BSTR* respone); + */ + FPDF_FILEHANDLER* (*FFI_DownloadFromURL)(struct _FPDF_FORMFILLINFO* pThis, + FPDF_WIDESTRING URL); + /* + * Method: FFI_PostRequestURL + * This method will post the request to the server URL. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * wsURL - The string value of the server URL, in UTF-16LE + * format. + * wsData - The post data,in UTF-16LE format. + * wsContentType - The content type of the request data, in + * UTF-16LE format. + * wsEncode - The encode type, in UTF-16LE format. + * wsHeader - The request header,in UTF-16LE format. + * response - Pointer to the FPDF_BSTR to receive the response + * data from the server, in UTF-16LE format. + * Return value: + * TRUE indicates success, otherwise FALSE. + */ + FPDF_BOOL (*FFI_PostRequestURL)(struct _FPDF_FORMFILLINFO* pThis, + FPDF_WIDESTRING wsURL, + FPDF_WIDESTRING wsData, + FPDF_WIDESTRING wsContentType, + FPDF_WIDESTRING wsEncode, + FPDF_WIDESTRING wsHeader, + FPDF_BSTR* response); - /** - * Method: FFI_PutRequestURL - * This method will put the request to the server URL. - * Interface Version: - * 1 - * Implementation Required: - * yes - * Parameters: - * pThis - Pointer to the interface structure itself. - * wsURL - The string value of the server URL, in UTF-16LE - *format. - * wsData - The put data, in UTF-16LE format. - * wsEncode - The encode type, in UTR-16LE format. - * Return value: - * TRUE indicates success, otherwise FALSE. - **/ - FPDF_BOOL (*FFI_PutRequestURL)(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsURL, FPDF_WIDESTRING wsData, FPDF_WIDESTRING wsEncode); -#endif // PDF_ENABLE_XFA + /* + * Method: FFI_PutRequestURL + * This method will put the request to the server URL. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * Required for XFA, otherwise set to NULL. + * Parameters: + * pThis - Pointer to the interface structure itself. + * wsURL - The string value of the server URL, in UTF-16LE + * format. + * wsData - The put data, in UTF-16LE format. + * wsEncode - The encode type, in UTR-16LE format. + * Return value: + * TRUE indicates success, otherwise FALSE. + */ + FPDF_BOOL (*FFI_PutRequestURL)(struct _FPDF_FORMFILLINFO* pThis, + FPDF_WIDESTRING wsURL, + FPDF_WIDESTRING wsData, + FPDF_WIDESTRING wsEncode); + /* + * Method: FFI_OnFocusChange + * Called when the focused annotation is updated. + * Interface Version: + * Ignored if |version| < 2. + * Implementation Required: + * No + * Parameters: + * param - Pointer to the interface structure itself. + * annot - The focused annotation. + * page_index - Index number of the page which contains the + * focused annotation. 0 for the first page. + * Return value: + * None. + * Comments: + * This callback function is useful for implementing any view based + * action such as scrolling the annotation rect into view. The + * embedder should not copy and store the annot as its scope is + * limited to this call only. + */ + void (*FFI_OnFocusChange)(struct _FPDF_FORMFILLINFO* param, + FPDF_ANNOTATION annot, + int page_index); } FPDF_FORMFILLINFO; -/** +/* * Function: FPDFDOC_InitFormFillEnvironment - * Init form fill environment. - * Comments: - * This function should be called before any form fill operation. + * Initialize form fill environment. * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * pFormFillInfo - Pointer to a FPDF_FORMFILLINFO structure. + * document - Handle to document from FPDF_LoadDocument(). + * pFormFillInfo - Pointer to a FPDF_FORMFILLINFO structure. * Return Value: - * Return handler to the form fill module. NULL means fails. - **/ -DLLEXPORT FPDF_FORMHANDLE STDCALL + * Handle to the form fill module, or NULL on failure. + * Comments: + * This function should be called before any form fill operation. + */ +FPDF_EXPORT FPDF_FORMHANDLE FPDF_CALLCONV FPDFDOC_InitFormFillEnvironment(FPDF_DOCUMENT document, FPDF_FORMFILLINFO* formInfo); -/** +/* * Function: FPDFDOC_ExitFormFillEnvironment - * Exit form fill environment. + * Take ownership of |hHandle| and exit form fill environment. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). * Return Value: - * NULL. - **/ -DLLEXPORT void STDCALL FPDFDOC_ExitFormFillEnvironment(FPDF_FORMHANDLE hHandle); + * None. + * Comments: + * This function is a no-op when |hHandle| is null. + */ +FPDF_EXPORT void FPDF_CALLCONV +FPDFDOC_ExitFormFillEnvironment(FPDF_FORMHANDLE hHandle); -/** +/* * Function: FORM_OnAfterLoadPage - * This method is required for implementing all the form related - *functions. Should be invoked after user - * successfully loaded a PDF page, and method - *FPDFDOC_InitFormFillEnvironment had been invoked. + * This method is required for implementing all the form related + * functions. Should be invoked after user successfully loaded a + * PDF page, and FPDFDOC_InitFormFillEnvironment() has been invoked. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). * Return Value: - * NONE. - **/ -DLLEXPORT void STDCALL FORM_OnAfterLoadPage(FPDF_PAGE page, - FPDF_FORMHANDLE hHandle); + * None. + */ +FPDF_EXPORT void FPDF_CALLCONV FORM_OnAfterLoadPage(FPDF_PAGE page, + FPDF_FORMHANDLE hHandle); -/** +/* * Function: FORM_OnBeforeClosePage - * This method is required for implementing all the form related - *functions. Should be invoked before user - * close the PDF page. + * This method is required for implementing all the form related + * functions. Should be invoked before user closes the PDF page. * Parameters: - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. + * page - Handle to the page, as returned by FPDF_LoadPage(). + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). * Return Value: - * NONE. - **/ -DLLEXPORT void STDCALL FORM_OnBeforeClosePage(FPDF_PAGE page, - FPDF_FORMHANDLE hHandle); - -/** -* Function: FORM_DoDocumentJSAction -* This method is required for performing Document-level JavaScript -*action. It should be invoked after the PDF document -* had been loaded. -* Parameters: -* hHandle - Handle to the form fill module. Returned by -*FPDFDOC_InitFormFillEnvironment. -* Return Value: -* NONE -* Comments: -* If there is Document-level JavaScript action embedded in the -*document, this method will execute the javascript action; -* otherwise, the method will do nothing. -**/ -DLLEXPORT void STDCALL FORM_DoDocumentJSAction(FPDF_FORMHANDLE hHandle); - -/** -* Function: FORM_DoDocumentOpenAction -* This method is required for performing open-action when the document -*is opened. -* Parameters: -* hHandle - Handle to the form fill module. Returned by -*FPDFDOC_InitFormFillEnvironment. -* Return Value: -* NONE -* Comments: -* This method will do nothing if there is no open-actions embedded in -*the document. -**/ -DLLEXPORT void STDCALL FORM_DoDocumentOpenAction(FPDF_FORMHANDLE hHandle); - -// additional actions type of document. -#define FPDFDOC_AACTION_WC \ - 0x10 // WC, before closing document, JavaScript action. -#define FPDFDOC_AACTION_WS \ - 0x11 // WS, before saving document, JavaScript action. -#define FPDFDOC_AACTION_DS 0x12 // DS, after saving document, JavaScript - // action. -#define FPDFDOC_AACTION_WP \ - 0x13 // WP, before printing document, JavaScript action. -#define FPDFDOC_AACTION_DP \ - 0x14 // DP, after printing document, JavaScript action. - -/** -* Function: FORM_DoDocumentAAction -* This method is required for performing the document's -*additional-action. -* Parameters: -* hHandle - Handle to the form fill module. Returned by -*FPDFDOC_InitFormFillEnvironment. -* aaType - The type of the additional-actions which defined -*above. -* Return Value: -* NONE -* Comments: -* This method will do nothing if there is no document -*additional-action corresponding to the specified aaType. -**/ - -DLLEXPORT void STDCALL FORM_DoDocumentAAction(FPDF_FORMHANDLE hHandle, - int aaType); - -// Additional-action types of page object -#define FPDFPAGE_AACTION_OPEN \ - 0 // /O -- An action to be performed when the page is opened -#define FPDFPAGE_AACTION_CLOSE \ - 1 // /C -- An action to be performed when the page is closed - -/** -* Function: FORM_DoPageAAction -* This method is required for performing the page object's -*additional-action when opened or closed. -* Parameters: -* page - Handle to the page. Returned by FPDF_LoadPage -*function. -* hHandle - Handle to the form fill module. Returned by -*FPDFDOC_InitFormFillEnvironment. -* aaType - The type of the page object's additional-actions -*which defined above. -* Return Value: -* NONE -* Comments: -* This method will do nothing if no additional-action corresponding to -*the specified aaType exists. -**/ -DLLEXPORT void STDCALL FORM_DoPageAAction(FPDF_PAGE page, - FPDF_FORMHANDLE hHandle, - int aaType); - -/** + * None. + */ +FPDF_EXPORT void FPDF_CALLCONV FORM_OnBeforeClosePage(FPDF_PAGE page, + FPDF_FORMHANDLE hHandle); + +/* + * Function: FORM_DoDocumentJSAction + * This method is required for performing document-level JavaScript + * actions. It should be invoked after the PDF document has been loaded. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * Return Value: + * None. + * Comments: + * If there is document-level JavaScript action embedded in the + * document, this method will execute the JavaScript action. Otherwise, + * the method will do nothing. + */ +FPDF_EXPORT void FPDF_CALLCONV +FORM_DoDocumentJSAction(FPDF_FORMHANDLE hHandle); + +/* + * Function: FORM_DoDocumentOpenAction + * This method is required for performing open-action when the document + * is opened. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * Return Value: + * None. + * Comments: + * This method will do nothing if there are no open-actions embedded + * in the document. + */ +FPDF_EXPORT void FPDF_CALLCONV +FORM_DoDocumentOpenAction(FPDF_FORMHANDLE hHandle); + +// Additional actions type of document: +// WC, before closing document, JavaScript action. +// WS, before saving document, JavaScript action. +// DS, after saving document, JavaScript action. +// WP, before printing document, JavaScript action. +// DP, after printing document, JavaScript action. +#define FPDFDOC_AACTION_WC 0x10 +#define FPDFDOC_AACTION_WS 0x11 +#define FPDFDOC_AACTION_DS 0x12 +#define FPDFDOC_AACTION_WP 0x13 +#define FPDFDOC_AACTION_DP 0x14 + +/* + * Function: FORM_DoDocumentAAction + * This method is required for performing the document's + * additional-action. + * Parameters: + * hHandle - Handle to the form fill module. Returned by + * FPDFDOC_InitFormFillEnvironment. + * aaType - The type of the additional-actions which defined + * above. + * Return Value: + * None. + * Comments: + * This method will do nothing if there is no document + * additional-action corresponding to the specified |aaType|. + */ +FPDF_EXPORT void FPDF_CALLCONV FORM_DoDocumentAAction(FPDF_FORMHANDLE hHandle, + int aaType); + +// Additional-action types of page object: +// OPEN (/O) -- An action to be performed when the page is opened +// CLOSE (/C) -- An action to be performed when the page is closed +#define FPDFPAGE_AACTION_OPEN 0 +#define FPDFPAGE_AACTION_CLOSE 1 + +/* + * Function: FORM_DoPageAAction + * This method is required for performing the page object's + * additional-action when opened or closed. + * Parameters: + * page - Handle to the page, as returned by FPDF_LoadPage(). + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * aaType - The type of the page object's additional-actions + * which defined above. + * Return Value: + * None. + * Comments: + * This method will do nothing if no additional-action corresponding + * to the specified |aaType| exists. + */ +FPDF_EXPORT void FPDF_CALLCONV FORM_DoPageAAction(FPDF_PAGE page, + FPDF_FORMHANDLE hHandle, + int aaType); + +/* * Function: FORM_OnMouseMove - * You can call this member function when the mouse cursor moves. + * Call this member function when the mouse cursor moves. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * modifier - Indicates whether various virtual keys are down. - * page_x - Specifies the x-coordinate of the cursor in PDF user - *space. - * page_y - Specifies the y-coordinate of the cursor in PDF user - *space. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * modifier - Indicates whether various virtual keys are down. + * page_x - Specifies the x-coordinate of the cursor in PDF user + * space. + * page_y - Specifies the y-coordinate of the cursor in PDF user + * space. * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_OnMouseMove(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int modifier, - double page_x, - double page_y); - -/** + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnMouseMove(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); + +/* + * Function: FORM_OnFocus + * This function focuses the form annotation at a given point. If the + * annotation at the point already has focus, nothing happens. If there + * is no annotation at the point, removes form focus. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * modifier - Indicates whether various virtual keys are down. + * page_x - Specifies the x-coordinate of the cursor in PDF user + * space. + * page_y - Specifies the y-coordinate of the cursor in PDF user + * space. + * Return Value: + * True if there is an annotation at the given point and it has focus. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnFocus(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); + +/* * Function: FORM_OnLButtonDown - * You can call this member function when the user presses the left - *mouse button. + * Call this member function when the user presses the left + * mouse button. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * modifier - Indicates whether various virtual keys are down. - * page_x - Specifies the x-coordinate of the cursor in PDF user - *space. - * page_y - Specifies the y-coordinate of the cursor in PDF user - *space. + * hHandle - Handle to the form fill module. as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * modifier - Indicates whether various virtual keys are down. + * page_x - Specifies the x-coordinate of the cursor in PDF user + * space. + * page_y - Specifies the y-coordinate of the cursor in PDF user + * space. * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_OnLButtonDown(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int modifier, - double page_x, - double page_y); - -/** + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnLButtonDown(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); + +/* + * Function: FORM_OnRButtonDown + * Same as above, execpt for the right mouse button. + * Comments: + * At the present time, has no effect except in XFA builds, but is + * included for the sake of symmetry. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnRButtonDown(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); +/* * Function: FORM_OnLButtonUp - * You can call this member function when the user releases the left - *mouse button. + * Call this member function when the user releases the left + * mouse button. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * modifier - Indicates whether various virtual keys are down. - * page_x - Specifies the x-coordinate of the cursor in device. - * page_y - Specifies the y-coordinate of the cursor in device. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page. as returned by FPDF_LoadPage(). + * modifier - Indicates whether various virtual keys are down. + * page_x - Specifies the x-coordinate of the cursor in device. + * page_y - Specifies the y-coordinate of the cursor in device. * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_OnLButtonUp(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int modifier, - double page_x, - double page_y); - -#ifdef PDF_ENABLE_XFA -DLLEXPORT FPDF_BOOL STDCALL FORM_OnRButtonDown(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int modifier, - double page_x, - double page_y); -DLLEXPORT FPDF_BOOL STDCALL FORM_OnRButtonUp(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int modifier, - double page_x, - double page_y); -#endif // PDF_ENABLE_XFA - -/** + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnLButtonUp(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); + +/* + * Function: FORM_OnRButtonUp + * Same as above, execpt for the right mouse button. + * Comments: + * At the present time, has no effect except in XFA builds, but is + * included for the sake of symmetry. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnRButtonUp(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); + +/* + * Function: FORM_OnLButtonDoubleClick + * Call this member function when the user double clicks the + * left mouse button. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * modifier - Indicates whether various virtual keys are down. + * page_x - Specifies the x-coordinate of the cursor in PDF user + * space. + * page_y - Specifies the y-coordinate of the cursor in PDF user + * space. + * Return Value: + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FORM_OnLButtonDoubleClick(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int modifier, + double page_x, + double page_y); + +/* * Function: FORM_OnKeyDown - * You can call this member function when a nonsystem key is pressed. + * Call this member function when a nonsystem key is pressed. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * nKeyCode - Indicates whether various virtual keys are down. - * modifier - Contains the scan code, key-transition code, - *previous key state, and context code. + * hHandle - Handle to the form fill module, aseturned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * nKeyCode - Indicates whether various virtual keys are down. + * modifier - Contains the scan code, key-transition code, + * previous key state, and context code. * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_OnKeyDown(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int nKeyCode, - int modifier); - -/** + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnKeyDown(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int nKeyCode, + int modifier); + +/* * Function: FORM_OnKeyUp - * You can call this member function when a nonsystem key is released. + * Call this member function when a nonsystem key is released. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * nKeyCode - The virtual-key code of the given key. - * modifier - Contains the scan code, key-transition code, - *previous key state, and context code. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * nKeyCode - The virtual-key code of the given key. + * modifier - Contains the scan code, key-transition code, + * previous key state, and context code. * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_OnKeyUp(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int nKeyCode, - int modifier); - -/** + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnKeyUp(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int nKeyCode, + int modifier); + +/* * Function: FORM_OnChar - * You can call this member function when a keystroke translates to a - *nonsystem character. + * Call this member function when a keystroke translates to a + * nonsystem character. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * nChar - The character code value of the key. + * modifier - Contains the scan code, key-transition code, + * previous key state, and context code. + * Return Value: + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnChar(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int nChar, + int modifier); + +/* + * Experimental API + * Function: FORM_GetFocusedText + * Call this function to obtain the text within the current focused + * field, if any. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * buffer - Buffer for holding the form text, encoded in + * UTF-16LE. If NULL, |buffer| is not modified. + * buflen - Length of |buffer| in bytes. If |buflen| is less + * than the length of the form text string, |buffer| is + * not modified. + * Return Value: + * Length in bytes for the text in the focused field. + */ +FPDF_EXPORT unsigned long FPDF_CALLCONV +FORM_GetFocusedText(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + void* buffer, + unsigned long buflen); + +/* + * Function: FORM_GetSelectedText + * Call this function to obtain selected text within a form text + * field or form combobox text field. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * buffer - Buffer for holding the selected text, encoded in + * UTF-16LE. If NULL, |buffer| is not modified. + * buflen - Length of |buffer| in bytes. If |buflen| is less + * than the length of the selected text string, + * |buffer| is not modified. + * Return Value: + * Length in bytes of selected text in form text field or form combobox + * text field. + */ +FPDF_EXPORT unsigned long FPDF_CALLCONV +FORM_GetSelectedText(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + void* buffer, + unsigned long buflen); + +/* + * Function: FORM_ReplaceSelection + * Call this function to replace the selected text in a form + * text field or user-editable form combobox text field with another + * text string (which can be empty or non-empty). If there is no + * selected text, this function will append the replacement text after + * the current caret position. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as Returned by FPDF_LoadPage(). + * wsText - The text to be inserted, in UTF-16LE format. + * Return Value: + * None. + */ +FPDF_EXPORT void FPDF_CALLCONV FORM_ReplaceSelection(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + FPDF_WIDESTRING wsText); + +/* + * Function: FORM_CanUndo + * Find out if it is possible for the current focused widget in a given + * form to perform an undo operation. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * Return Value: + * True if it is possible to undo. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_CanUndo(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page); + +/* + * Function: FORM_CanRedo + * Find out if it is possible for the current focused widget in a given + * form to perform a redo operation. + * Parameters: + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * Return Value: + * True if it is possible to redo. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_CanRedo(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page); + +/* + * Function: FORM_Undo + * Make the current focussed widget perform an undo operation. + * Parameters: + * hHandle - Handle to the form fill module. as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). + * Return Value: + * True if the undo operation succeeded. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_Undo(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page); + +/* + * Function: FORM_Redo + * Make the current focussed widget perform a redo operation. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * page - Handle to the page. Returned by FPDF_LoadPage - *function. - * nChar - The character code value of the key. - * modifier - Contains the scan code, key-transition code, - *previous key state, and context code. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to the page, as returned by FPDF_LoadPage(). * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_OnChar(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - int nChar, - int modifier); - -/** + * True if the redo operation succeeded. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_Redo(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page); + +/* * Function: FORM_ForceToKillFocus. - * You can call this member function to force to kill the focus of the - *form field which got focus. - * It would kill the focus on the form field, save the value of form - *field if it's changed by user. + * Call this member function to force to kill the focus of the form + * field which has focus. If it would kill the focus of a form field, + * save the value of form field if was changed by theuser. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). * Return Value: - * TRUE indicates success; otherwise false. - **/ -DLLEXPORT FPDF_BOOL STDCALL FORM_ForceToKillFocus(FPDF_FORMHANDLE hHandle); + * True indicates success; otherwise false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FORM_ForceToKillFocus(FPDF_FORMHANDLE hHandle); -// Field Types +/* + * Experimental API. + * Function: FORM_GetFocusedAnnot. + * Call this member function to get the currently focused annotation. + * Parameters: + * handle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page_index - Buffer to hold the index number of the page which + * contains the focused annotation. 0 for the first page. + * Can't be NULL. + * annot - Buffer to hold the focused annotation. Can't be NULL. + * Return Value: + * On success, return true and write to the out parameters. Otherwise return + * false and leave the out parameters unmodified. + * Comments: + * Not currently supported for XFA forms - will report no focused + * annotation. + * Must call FPDFPage_CloseAnnot() when the annotation returned in |annot| + * by this function is no longer needed. + * This will return true and set |page_index| to -1 and |annot| to NULL, if + * there is no focused annotation. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FORM_GetFocusedAnnot(FPDF_FORMHANDLE handle, + int* page_index, + FPDF_ANNOTATION* annot); + +/* + * Experimental API. + * Function: FORM_SetFocusedAnnot. + * Call this member function to set the currently focused annotation. + * Parameters: + * handle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * page - Handle to a page. + * annot - Handle to an annotation. + * Return Value: + * True indicates success; otherwise false. + * Comments: + * |annot| can't be NULL. To kill focus, use FORM_ForceToKillFocus() + * instead. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FORM_SetFocusedAnnot(FPDF_FORMHANDLE handle, + FPDF_PAGE page, + FPDF_ANNOTATION annot); + +// Form Field Types +// The names of the defines are stable, but the specific values associated with +// them are not, so do not hardcode their values. #define FPDF_FORMFIELD_UNKNOWN 0 // Unknown. #define FPDF_FORMFIELD_PUSHBUTTON 1 // push button type. #define FPDF_FORMFIELD_CHECKBOX 2 // check box type. @@ -1322,11 +1629,37 @@ DLLEXPORT FPDF_BOOL STDCALL FORM_ForceToKillFocus(FPDF_FORMHANDLE hHandle); #define FPDF_FORMFIELD_COMBOBOX 4 // combo box type. #define FPDF_FORMFIELD_LISTBOX 5 // list box type. #define FPDF_FORMFIELD_TEXTFIELD 6 // text field type. +#define FPDF_FORMFIELD_SIGNATURE 7 // text field type. +#ifdef PDF_ENABLE_XFA +#define FPDF_FORMFIELD_XFA 8 // Generic XFA type. +#define FPDF_FORMFIELD_XFA_CHECKBOX 9 // XFA check box type. +#define FPDF_FORMFIELD_XFA_COMBOBOX 10 // XFA combo box type. +#define FPDF_FORMFIELD_XFA_IMAGEFIELD 11 // XFA image field type. +#define FPDF_FORMFIELD_XFA_LISTBOX 12 // XFA list box type. +#define FPDF_FORMFIELD_XFA_PUSHBUTTON 13 // XFA push button type. +#define FPDF_FORMFIELD_XFA_SIGNATURE 14 // XFA signture field type. +#define FPDF_FORMFIELD_XFA_TEXTFIELD 15 // XFA text field type. +#endif // PDF_ENABLE_XFA + +#ifdef PDF_ENABLE_XFA +#define FPDF_FORMFIELD_COUNT 16 +#else // PDF_ENABLE_XFA +#define FPDF_FORMFIELD_COUNT 8 +#endif // PDF_ENABLE_XFA + #ifdef PDF_ENABLE_XFA -#define FPDF_FORMFIELD_XFA 7 // text field type. +#define IS_XFA_FORMFIELD(type) \ + (((type) == FPDF_FORMFIELD_XFA) || \ + ((type) == FPDF_FORMFIELD_XFA_CHECKBOX) || \ + ((type) == FPDF_FORMFIELD_XFA_COMBOBOX) || \ + ((type) == FPDF_FORMFIELD_XFA_IMAGEFIELD) || \ + ((type) == FPDF_FORMFIELD_XFA_LISTBOX) || \ + ((type) == FPDF_FORMFIELD_XFA_PUSHBUTTON) || \ + ((type) == FPDF_FORMFIELD_XFA_SIGNATURE) || \ + ((type) == FPDF_FORMFIELD_XFA_TEXTFIELD)) #endif // PDF_ENABLE_XFA -/** +/* * Function: FPDFPage_HasFormFieldAtPoint * Get the form field type by point. * Parameters: @@ -1338,22 +1671,14 @@ DLLEXPORT FPDF_BOOL STDCALL FORM_ForceToKillFocus(FPDF_FORMHANDLE hHandle); * Return Value: * Return the type of the form field; -1 indicates no field. * See field types above. - **/ -DLLEXPORT int STDCALL FPDFPage_HasFormFieldAtPoint(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - double page_x, - double page_y); - -/** - * Function: FPDPage_HasFormFieldAtPoint - * DEPRECATED. Please use FPDFPage_HasFormFieldAtPoint. - **/ -DLLEXPORT int STDCALL FPDPage_HasFormFieldAtPoint(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - double page_x, - double page_y); - -/** + */ +FPDF_EXPORT int FPDF_CALLCONV +FPDFPage_HasFormFieldAtPoint(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + double page_x, + double page_y); + +/* * Function: FPDFPage_FormFieldZOrderAtPoint * Get the form field z-order by point. * Parameters: @@ -1365,328 +1690,206 @@ DLLEXPORT int STDCALL FPDPage_HasFormFieldAtPoint(FPDF_FORMHANDLE hHandle, * Return Value: * Return the z-order of the form field; -1 indicates no field. * Higher numbers are closer to the front. - **/ -DLLEXPORT int STDCALL FPDFPage_FormFieldZOrderAtPoint(FPDF_FORMHANDLE hHandle, - FPDF_PAGE page, - double page_x, - double page_y); + */ +FPDF_EXPORT int FPDF_CALLCONV +FPDFPage_FormFieldZOrderAtPoint(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + double page_x, + double page_y); -/** +/* * Function: FPDF_SetFormFieldHighlightColor - * Set the highlight color of specified or all the form fields in the - *document. + * Set the highlight color of the specified (or all) form fields + * in the document. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * doc - Handle to the document. Returned by - *FPDF_LoadDocument function. - * fieldType - A 32-bit integer indicating the type of a form - *field(defined above). - * color - The highlight color of the form field.Constructed by - *0xxxrrggbb. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * doc - Handle to the document, as returned by + * FPDF_LoadDocument(). + * fieldType - A 32-bit integer indicating the type of a form + * field (defined above). + * color - The highlight color of the form field. Constructed by + * 0xxxrrggbb. * Return Value: - * NONE. + * None. * Comments: - * When the parameter fieldType is set to zero, the highlight color - *will be applied to all the form fields in the - * document. - * Please refresh the client window to show the highlight immediately - *if necessary. - **/ -DLLEXPORT void STDCALL FPDF_SetFormFieldHighlightColor(FPDF_FORMHANDLE hHandle, - int fieldType, - unsigned long color); - -/** + * When the parameter fieldType is set to FPDF_FORMFIELD_UNKNOWN, the + * highlight color will be applied to all the form fields in the + * document. + * Please refresh the client window to show the highlight immediately + * if necessary. + */ +FPDF_EXPORT void FPDF_CALLCONV +FPDF_SetFormFieldHighlightColor(FPDF_FORMHANDLE hHandle, + int fieldType, + unsigned long color); + +/* * Function: FPDF_SetFormFieldHighlightAlpha - * Set the transparency of the form field highlight color in the - *document. + * Set the transparency of the form field highlight color in the + * document. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. - * doc - Handle to the document. Returned by - *FPDF_LoadDocument function. - * alpha - The transparency of the form field highlight color. - *between 0-255. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). + * doc - Handle to the document, as returaned by + * FPDF_LoadDocument(). + * alpha - The transparency of the form field highlight color, + * between 0-255. * Return Value: - * NONE. - **/ -DLLEXPORT void STDCALL FPDF_SetFormFieldHighlightAlpha(FPDF_FORMHANDLE hHandle, - unsigned char alpha); + * None. + */ +FPDF_EXPORT void FPDF_CALLCONV +FPDF_SetFormFieldHighlightAlpha(FPDF_FORMHANDLE hHandle, unsigned char alpha); -/** +/* * Function: FPDF_RemoveFormFieldHighlight - * Remove the form field highlight color in the document. + * Remove the form field highlight color in the document. * Parameters: - * hHandle - Handle to the form fill module. Returned by - *FPDFDOC_InitFormFillEnvironment. + * hHandle - Handle to the form fill module, as returned by + * FPDFDOC_InitFormFillEnvironment(). * Return Value: - * NONE. + * None. * Comments: - * Please refresh the client window to remove the highlight immediately - *if necessary. - **/ -DLLEXPORT void STDCALL FPDF_RemoveFormFieldHighlight(FPDF_FORMHANDLE hHandle); + * Please refresh the client window to remove the highlight immediately + * if necessary. + */ +FPDF_EXPORT void FPDF_CALLCONV +FPDF_RemoveFormFieldHighlight(FPDF_FORMHANDLE hHandle); -/** +/* * Function: FPDF_FFLDraw -* Render FormFeilds on a page to a device independent bitmap. +* Render FormFields and popup window on a page to a device independent +* bitmap. * Parameters: -* hHandle - Handle to the form fill module. Returned by -*FPDFDOC_InitFormFillEnvironment. -* 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 -*device coordinate. -* start_y - Top pixel position of the display area in the device -*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 above. +* hHandle - Handle to the form fill module, as returned by +* FPDFDOC_InitFormFillEnvironment(). +* bitmap - Handle to the device independent bitmap (as the +* output buffer). Bitmap handles can be created by +* FPDFBitmap_Create(). +* page - Handle to the page, as returned by FPDF_LoadPage(). +* start_x - Left pixel position of the display area in the +* device coordinates. +* start_y - Top pixel position of the display area in the device +* coordinates. +* size_x - Horizontal size (in pixels) for displaying the page. +* size_y - Vertical size (in pixels) for displaying the page. +* rotate - Page orientation: 0 (normal), 1 (rotated 90 degrees +* clockwise), 2 (rotated 180 degrees), 3 (rotated 90 +* degrees counter-clockwise). +* flags - 0 for normal display, or combination of flags +* defined above. * Return Value: -* None. +* None. * Comments: -* This method is designed to only render annotations and FormFields on -*the page. -* Without FPDF_ANNOT specified for flags, Rendering functions such as -*FPDF_RenderPageBitmap or FPDF_RenderPageBitmap_Start will only render page -*contents(without annotations) to a bitmap. -* In order to implement the FormFill functions,Implementation should -*call this method after rendering functions finish rendering the page contents. -**/ -DLLEXPORT void STDCALL FPDF_FFLDraw(FPDF_FORMHANDLE hHandle, - FPDF_BITMAP bitmap, - FPDF_PAGE page, - int start_x, - int start_y, - int size_x, - int size_y, - int rotate, - int flags); +* This function is designed to render annotations that are +* user-interactive, which are widget annotations (for FormFields) and +* popup annotations. +* With the FPDF_ANNOT flag, this function will render a popup annotation +* when users mouse-hover on a non-widget annotation. Regardless of +* FPDF_ANNOT flag, this function will always render widget annotations +* for FormFields. +* In order to implement the FormFill functions, implementation should +* call this function after rendering functions, such as +* FPDF_RenderPageBitmap() or FPDF_RenderPageBitmap_Start(), have +* finished rendering the page contents. +*/ +FPDF_EXPORT void FPDF_CALLCONV FPDF_FFLDraw(FPDF_FORMHANDLE hHandle, + FPDF_BITMAP bitmap, + FPDF_PAGE page, + int start_x, + int start_y, + int size_x, + int size_y, + int rotate, + int flags); + +#ifdef _SKIA_SUPPORT_ +FPDF_EXPORT void FPDF_CALLCONV FPDF_FFLRecord(FPDF_FORMHANDLE hHandle, + FPDF_RECORDER recorder, + FPDF_PAGE page, + int start_x, + int start_y, + int size_x, + int size_y, + int rotate, + int flags); +#endif -#ifdef PDF_ENABLE_XFA -/** - * Function: FPDF_HasXFAField - * This method is designed to check whether a pdf document - *has XFA fields. +/* + * Experimental API + * Function: FPDF_GetFormType + * Returns the type of form contained in the PDF document. * Parameters: - * document - Handle to document. - *Returned by FPDF_LoadDocument function. - * docType - Document type defined as - *DOCTYPE_xxx. + * document - Handle to document. * Return Value: - * TRUE indicates that the input document has XFA fields, - *otherwise FALSE. - **/ -DLLEXPORT FPDF_BOOL STDCALL FPDF_HasXFAField(FPDF_DOCUMENT document, - int* docType); + * Integer value representing one of the FORMTYPE_ values. + * Comments: + * If |document| is NULL, then the return value is FORMTYPE_NONE. + */ +FPDF_EXPORT int FPDF_CALLCONV FPDF_GetFormType(FPDF_DOCUMENT document); -/** - * Function: FPDF_LoadXFA - * If the document consists of XFA fields, there should call this - *method to load XFA fields. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * Return Value: - * TRUE indicates success,otherwise FALSE. - **/ -DLLEXPORT FPDF_BOOL STDCALL FPDF_LoadXFA(FPDF_DOCUMENT document); - -/** - * Function: FPDF_Widget_Undo - * This method will implement the undo feature for the specified xfa - *field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_Widget_Undo(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget); -/** - * Function: FPDF_Widget_Redo - * This method will implement the redo feature for the specified xfa - *field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_Widget_Redo(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget); -/** - * Function: FPDF_Widget_SelectAll - * This method will implement the select all feature for the specified - *xfa field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_Widget_SelectAll(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget); -/** - * Function: FPDF_Widget_Copy - * This method will implement the copy feature for the specified xfa - *field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * wsText - Pointer to data buffer to receive the copied - *data, in UTF-16LE format. - * size - The data buffer size. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_Widget_Copy(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget, - FPDF_WIDESTRING wsText, - FPDF_DWORD* size); -/** - * Function: FPDF_Widget_Cut - * This method will implement the cut feature for the specified xfa - *field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * wsText - Pointer to data buffer to receive the cut - *data,in UTF-16LE format. - * size - The data buffer size,not the byte number. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_Widget_Cut(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget, - FPDF_WIDESTRING wsText, - FPDF_DWORD* size); -/** - * Function: FPDF_Widget_Paste - * This method will implement the paste feature for the specified xfa - *field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * wsText - The paste text buffer, in UTF-16LE format. - * size - The data buffer size,not the byte number. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_Widget_Paste(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget, - FPDF_WIDESTRING wsText, - FPDF_DWORD size); -/** - * Function: FPDF_Widget_ReplaceSpellCheckWord - * This method will implement the spell check feature for the specified - *xfa field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * x - The x value of the specified point. - * y - The y value of the specified point. - * bsText - The text buffer needed to be speck check, in - *UTF-16LE format. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL -FPDF_Widget_ReplaceSpellCheckWord(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget, - float x, - float y, - FPDF_BYTESTRING bsText); -/** - * Function: FPDF_Widget_GetSpellCheckWords - * This method will implement the spell check feature for the specified - *xfa field. - * Parameters: - * document - Handle to document. Returned by - *FPDF_LoadDocument function. - * hWidget - Handle to the xfa field. - * x - The x value of the specified point. - * y - The y value of the specified point. - * stringHandle - Pointer to FPDF_STRINGHANDLE to receive the - *speck check text buffer, in UTF-16LE format. - * Return Value: - * None. - **/ -DLLEXPORT void STDCALL -FPDF_Widget_GetSpellCheckWords(FPDF_DOCUMENT document, - FPDF_WIDGET hWidget, - float x, - float y, - FPDF_STRINGHANDLE* stringHandle); -/** - * Function: FPDF_StringHandleCounts - * This method will get the count of the text buffer. +/* + * Experimental API + * Function: FORM_SetIndexSelected + * Selects/deselects the value at the given |index| of the focused + * annotation. * Parameters: - * stringHandle - Pointer to FPDF_STRINGHANDLE. + * hHandle - Handle to the form fill module. Returned by + * FPDFDOC_InitFormFillEnvironment. + * page - Handle to the page. Returned by FPDF_LoadPage + * index - 0-based index of value to be set as + * selected/unselected + * selected - true to select, false to deselect * Return Value: - * None. - **/ -DLLEXPORT int STDCALL FPDF_StringHandleCounts(FPDF_STRINGHANDLE stringHandle); -/** - * Function: FPDF_StringHandleGetStringByIndex - * This method will get the specified index of the text buffer. - * Parameters: - * stringHandle - Pointer to FPDF_STRINGHANDLE. - * index - The specified index of text buffer. - * bsText - Pointer to data buffer to receive the text - *buffer, in UTF-16LE format. - * size - The byte size of data buffer. - * Return Value: - * TRUE indicates success, otherwise FALSE. - **/ -DLLEXPORT FPDF_BOOL STDCALL -FPDF_StringHandleGetStringByIndex(FPDF_STRINGHANDLE stringHandle, - int index, - FPDF_BYTESTRING bsText, - FPDF_DWORD* size); -/** - * Function: FPDF_StringHandleRelease - * This method will release the FPDF_STRINGHANDLE. + * TRUE if the operation succeeded. + * FALSE if the operation failed or widget is not a supported type. + * Comments: + * Intended for use with listbox/combobox widget types. Comboboxes + * have at most a single value selected at a time which cannot be + * deselected. Deselect on a combobox is a no-op that returns false. + * Default implementation is a no-op that will return false for + * other types. + * Not currently supported for XFA forms - will return false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FORM_SetIndexSelected(FPDF_FORMHANDLE hHandle, + FPDF_PAGE page, + int index, + FPDF_BOOL selected); + +/* + * Experimental API + * Function: FORM_IsIndexSelected + * Returns whether or not the value at |index| of the focused + * annotation is currently selected. * Parameters: - * stringHandle - Pointer to FPDF_STRINGHANDLE. + * hHandle - Handle to the form fill module. Returned by + * FPDFDOC_InitFormFillEnvironment. + * page - Handle to the page. Returned by FPDF_LoadPage + * index - 0-based Index of value to check * Return Value: - * None. - **/ -DLLEXPORT void STDCALL FPDF_StringHandleRelease(FPDF_STRINGHANDLE stringHandle); -/** - * Function: FPDF_StringHandleAddString - * This method will add the specified text buffer. + * TRUE if value at |index| is currently selected. + * FALSE if value at |index| is not selected or widget is not a + * supported type. + * Comments: + * Intended for use with listbox/combobox widget types. Default + * implementation is a no-op that will return false for other types. + * Not currently supported for XFA forms - will return false. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FORM_IsIndexSelected(FPDF_FORMHANDLE hHandle, FPDF_PAGE page, int index); + +/* + * Function: FPDF_LoadXFA + * If the document consists of XFA fields, call this method to + * attempt to load XFA fields. * Parameters: - * stringHandle - Pointer to FPDF_STRINGHANDLE. - * bsText - Pointer to data buffer of the text buffer, in - *UTF-16LE format. - * size - The byte size of data buffer. + * document - Handle to document from FPDF_LoadDocument(). * Return Value: - * TRUE indicates success, otherwise FALSE. - **/ -DLLEXPORT FPDF_BOOL STDCALL -FPDF_StringHandleAddString(FPDF_STRINGHANDLE stringHandle, - FPDF_BYTESTRING bsText, - FPDF_DWORD size); -#endif // PDF_ENABLE_XFA + * TRUE upon success, otherwise FALSE. If XFA support is not built + * into PDFium, performs no action and always returns FALSE. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_LoadXFA(FPDF_DOCUMENT document); #ifdef __cplusplus } diff --git a/src/main/jni/include/fpdf_fwlevent.h b/src/main/jni/include/fpdf_fwlevent.h index 22c01e42..c8593e94 100644 --- a/src/main/jni/include/fpdf_fwlevent.h +++ b/src/main/jni/include/fpdf_fwlevent.h @@ -7,23 +7,14 @@ #ifndef PUBLIC_FPDF_FWLEVENT_H_ #define PUBLIC_FPDF_FWLEVENT_H_ +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" #ifdef __cplusplus extern "C" { -#endif +#endif // __cplusplus -typedef int FPDF_INT32; -typedef unsigned int FPDF_UINT32; -typedef float FPDF_FLOAT; -// event type -typedef enum { - FWL_EVENTTYPE_Mouse = 0, - FWL_EVENTTYPE_MouseWheel, - FWL_EVENTTYPE_Key, -} FWL_EVENTTYPE; - -// key flag +// Key flags. typedef enum { FWL_EVENTFLAG_ShiftKey = 1 << 0, FWL_EVENTFLAG_ControlKey = 1 << 1, @@ -36,44 +27,11 @@ typedef enum { FWL_EVENTFLAG_RightButtonDown = 1 << 8, } FWL_EVENTFLAG; -// Mouse message command -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 event -struct FWL_EVENT_MOUSE { - FPDF_UINT32 command; - FPDF_DWORD flag; - FPDF_FLOAT x; - FPDF_FLOAT y; -}; - -// mouse wheel -struct FWL_EVENT_MOUSEWHEEL { - FPDF_DWORD flag; - FPDF_FLOAT x; - FPDF_FLOAT y; - FPDF_FLOAT deltaX; - FPDF_FLOAT deltaY; -}; - -// virtual keycode +// 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, @@ -242,40 +200,8 @@ typedef enum { FWL_VKEY_Unknown = 0, } FWL_VKEYCODE; -// key event command -typedef enum { - FWL_EVENTKEYCMD_KeyDown = 1, - FWL_EVENTKEYCMD_KeyUp, - FWL_EVENTKEYCMD_Char, -} FWL_EVENTKEYCMD; - -// key event -struct FWL_EVENT_KEY { - FPDF_UINT32 command; - FPDF_DWORD flag; - union { - // Virtual key code. - FPDF_UINT32 vkcode; - // Character code. - FPDF_DWORD charcode; - } code; -}; - -// event type -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 -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_FWLEVENT_H_ diff --git a/src/main/jni/include/fpdf_ppo.h b/src/main/jni/include/fpdf_ppo.h index e7d77678..e9f3f666 100644 --- a/src/main/jni/include/fpdf_ppo.h +++ b/src/main/jni/include/fpdf_ppo.h @@ -7,41 +7,62 @@ #ifndef PUBLIC_FPDF_PPO_H_ #define PUBLIC_FPDF_PPO_H_ +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" #ifdef __cplusplus extern "C" { #endif -// Function: FPDF_ImportPages -// Import some pages to a PDF document. -// Parameters: -// dest_doc - The destination document which add the pages. -// src_doc - A document to be imported. -// pagerange - A page range string, Such as "1,3,5-7". -// If this parameter is NULL, it would import all pages -// in src_doc. -// index - The page index wanted to insert from. -// Return value: -// TRUE for succeed, FALSE for Failed. -DLLEXPORT FPDF_BOOL STDCALL FPDF_ImportPages(FPDF_DOCUMENT dest_doc, - FPDF_DOCUMENT src_doc, - FPDF_BYTESTRING pagerange, - int index); - -// Function: FPDF_CopyViewerPreferences -// Copy the viewer preferences from one PDF document to another.#endif -// Parameters: -// dest_doc - Handle to document to write the viewer preferences -// to. -// src_doc - Handle to document with the viewer preferences. +// 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. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_ImportPages(FPDF_DOCUMENT dest_doc, + FPDF_DOCUMENT src_doc, + FPDF_BYTESTRING pagerange, + int index); + +// Experimental API. +// Create a new document from |src_doc|. The pages of |src_doc| will be +// combined to provide |num_pages_on_x_axis x num_pages_on_y_axis| pages per +// |output_doc| page. +// +// src_doc - The document to be imported. +// output_width - The output page width in PDF "user space" units. +// output_height - The output page height in PDF "user space" units. +// num_pages_on_x_axis - The number of pages on X Axis. +// num_pages_on_y_axis - The number of pages on Y Axis. +// // Return value: -// TRUE for success, FALSE for failure. -DLLEXPORT FPDF_BOOL STDCALL FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc, - FPDF_DOCUMENT src_doc); +// A handle to the created document, or NULL on failure. +// +// Comments: +// number of pages per page = num_pages_on_x_axis * num_pages_on_y_axis +// +FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV +FPDF_ImportNPagesToOne(FPDF_DOCUMENT src_doc, + float output_width, + float output_height, + size_t num_pages_on_x_axis, + size_t num_pages_on_y_axis); + +// 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. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc, FPDF_DOCUMENT src_doc); #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_PPO_H_ diff --git a/src/main/jni/include/fpdf_progressive.h b/src/main/jni/include/fpdf_progressive.h index f352ff9d..99803b87 100644 --- a/src/main/jni/include/fpdf_progressive.h +++ b/src/main/jni/include/fpdf_progressive.h @@ -7,11 +7,13 @@ #ifndef PUBLIC_FPDF_PROGRESSIVE_H_ #define PUBLIC_FPDF_PROGRESSIVE_H_ +// clang-format off +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" // Flags for progressive process status. -#define FPDF_RENDER_READER 0 -#define FPDF_RENDER_TOBECOUNTINUED 1 +#define FPDF_RENDER_READY 0 +#define FPDF_RENDER_TOBECONTINUED 1 #define FPDF_RENDER_DONE 2 #define FPDF_RENDER_FAILED 3 @@ -21,24 +23,23 @@ extern "C" { // IFPDF_RENDERINFO interface. typedef struct _IFSDK_PAUSE { - /** - * Version number of the interface. Currently must be 1. - **/ + /* + * 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. - * - */ + * 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. @@ -50,64 +51,62 @@ typedef struct _IFSDK_PAUSE { // 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. +// output buffer). Bitmap handle can be created by +// FPDFBitmap_Create(). +// page - Handle to the page, as returned by FPDF_LoadPage(). // start_x - Left pixel position of the display area in the -// bitmap coordinate. +// bitmap coordinates. // start_y - Top pixel position of the display area in the bitmap -// coordinate. +// coordinates. // 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). +// clockwise), 2 (rotated 180 degrees), 3 (rotated 90 +// degrees counter-clockwise). // flags - 0 for normal display, or combination of flags -// defined above. +// 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 +// 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); +FPDF_EXPORT int FPDF_CALLCONV 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. +// page - Handle to the page, as returned by FPDF_LoadPage(). +// 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); +FPDF_EXPORT int FPDF_CALLCONV 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. +// page - Handle to the page, as returned by FPDF_LoadPage(). // Return value: -// NULL -DLLEXPORT void STDCALL FPDF_RenderPage_Close(FPDF_PAGE page); +// None. +FPDF_EXPORT void FPDF_CALLCONV FPDF_RenderPage_Close(FPDF_PAGE page); #ifdef __cplusplus } diff --git a/src/main/jni/include/fpdf_save.h b/src/main/jni/include/fpdf_save.h index 4eea054e..527d9428 100644 --- a/src/main/jni/include/fpdf_save.h +++ b/src/main/jni/include/fpdf_save.h @@ -7,6 +7,8 @@ #ifndef PUBLIC_FPDF_SAVE_H_ #define PUBLIC_FPDF_SAVE_H_ +// clang-format off +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" #ifdef __cplusplus @@ -20,7 +22,6 @@ typedef struct FPDF_FILEWRITE_ { // int version; - // // Method: WriteBlock // Output a block of data in your custom way. // Interface Version: @@ -35,50 +36,47 @@ typedef struct FPDF_FILEWRITE_ { // 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. */ + // Flags for FPDF_SaveAsCopy() #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. +// document - Handle to document, as returned by +// FPDF_LoadDocument() or 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); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV 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. +// Same as FPDF_SaveAsCopy(), except the file version of the +// saved document can be specified by the caller. // 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, ... +// 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); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDF_SaveWithVersion(FPDF_DOCUMENT document, + FPDF_FILEWRITE* pFileWrite, + FPDF_DWORD flags, + int fileVersion); #ifdef __cplusplus } diff --git a/src/main/jni/include/fpdf_searchex.h b/src/main/jni/include/fpdf_searchex.h index a6b6e1bd..4b67786f 100644 --- a/src/main/jni/include/fpdf_searchex.h +++ b/src/main/jni/include/fpdf_searchex.h @@ -7,26 +7,33 @@ #ifndef PUBLIC_FPDF_SEARCHEX_H_ #define PUBLIC_FPDF_SEARCHEX_H_ +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" #ifdef __cplusplus extern "C" { -#endif - -// Function: FPDFText_GetCharIndexFromTextIndex -// Get the actually char index in text_page's internal char list. -// Parameters: -// text_page - Handle to a text page information structure. -// Returned by FPDFText_LoadPage function. -// nTextIndex - The index of the text in the string get from -// FPDFText_GetText. -// Return value: -// The index of the character in internal charlist. -1 for error. -DLLEXPORT int STDCALL +#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. +FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetCharIndexFromTextIndex(FPDF_TEXTPAGE text_page, int nTextIndex); +// Get the text index in |text_page| internal character list. +// +// text_page - a text page information structure. +// nCharIndex - index of the character in internal character list. +// +// Returns the index of the text returned from FPDFText_GetText(). -1 for error. +FPDF_EXPORT int FPDF_CALLCONV +FPDFText_GetTextIndexFromCharIndex(FPDF_TEXTPAGE text_page, int nCharIndex); + #ifdef __cplusplus -} -#endif +} // extern "C" +#endif // __cplusplus #endif // PUBLIC_FPDF_SEARCHEX_H_ diff --git a/src/main/jni/include/fpdf_sysfontinfo.h b/src/main/jni/include/fpdf_sysfontinfo.h index c2da74b7..936de962 100644 --- a/src/main/jni/include/fpdf_sysfontinfo.h +++ b/src/main/jni/include/fpdf_sysfontinfo.h @@ -7,6 +7,8 @@ #ifndef PUBLIC_FPDF_SYSFONTINFO_H_ #define PUBLIC_FPDF_SYSFONTINFO_H_ +// clang-format off +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" /* Character sets for the font */ @@ -17,9 +19,12 @@ #define FXFONT_HANGEUL_CHARSET 129 #define FXFONT_GB2312_CHARSET 134 #define FXFONT_CHINESEBIG5_CHARSET 136 +#define FXFONT_ARABIC_CHARSET 178 +#define FXFONT_CYRILLIC_CHARSET 204 +#define FXFONT_EASTERNEUROPEAN_CHARSET 238 /* Font pitch and family flags */ -#define FXFONT_FF_FIXEDPITCH 1 +#define FXFONT_FF_FIXEDPITCH (1 << 0) #define FXFONT_FF_ROMAN (1 << 4) #define FXFONT_FF_SCRIPT (4 << 4) @@ -32,87 +37,84 @@ 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 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 + * Comments: + * Called by PDFium during the final cleanup process. */ 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 + * when calling FPDF_AddInstalledFont(). * Return Value: * None + * Comments: + * Implementations should call FPDF_AddIntalledFont() function for + * each font found. Only TrueType/OpenType and Type1 fonts are accepted + * by PDFium. */ void (*EnumFonts)(struct _FPDF_SYSFONTINFO* pThis, void* pMapper); - /** + /* * Method: MapFont * Use the system font mapper to get a font handle from requested - *parameters + * 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. + * Required if GetFont method is not implemented. * Parameters: * pThis - Pointer to the interface structure itself * weight - Weight of the requested font. 400 is normal and - *700 is bold. + * 700 is bold. * bItalic - Italic option of the requested font, TRUE or - *FALSE. + * FALSE. * charset - Character set identifier for the requested font. - *See above defined constants. + * See above defined constants. * pitch_family - A combination of flags. See above defined - *constants. + * 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. + * only. + * bExact - Obsolete: this parameter is now ignored. * Return Value: * An opaque pointer for font handle, or NULL if system mapping is - *not supported. - **/ + * not supported. + * Comments: + * If the system supports native font mapper (like Windows), + * implementation can implement this method to get a font handle. + * Otherwise, PDFium will do the mapping and then call GetFont + * method. Only TrueType/OpenType and Type1 fonts are accepted + * by PDFium. + */ void* (*MapFont)(struct _FPDF_SYSFONTINFO* pThis, int weight, FPDF_BOOL bItalic, @@ -121,56 +123,53 @@ typedef struct _FPDF_SYSFONTINFO { 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. + * Required if MapFont method is not implemented. * Return Value: * An opaque pointer for font handle. - **/ + * Parameters: + * pThis - Pointer to the interface structure itself + * face - Typeface name in system local encoding. + * Comments: + * If the system mapping not supported, PDFium will do the font + * mapping and use this method to get a 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. + * TrueType specification), or 0 for the whole file. * buffer - The buffer receiving the font data. Can be NULL if - *not provided - * buf_size - Buffer size, can be zero if not provided + * 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. - **/ + * enough, or number of bytes written into buffer otherwise. + * Comments: + * Can read either the full font file, or a particular + * TrueType/OpenType table. + */ 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: @@ -181,19 +180,18 @@ typedef struct _FPDF_SYSFONTINFO { * 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 + * 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. - **/ + * 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: @@ -205,10 +203,10 @@ typedef struct _FPDF_SYSFONTINFO { * 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: @@ -220,20 +218,20 @@ typedef struct _FPDF_SYSFONTINFO { * 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 @@ -242,58 +240,71 @@ typedef struct FPDF_CharsetFontMap_ { * None. * Return Value: * Pointer to the Charset Font Map. - **/ -DLLEXPORT const FPDF_CharsetFontMap* STDCALL FPDF_GetDefaultTTFMap(); + */ +FPDF_EXPORT const FPDF_CharsetFontMap* FPDF_CALLCONV FPDF_GetDefaultTTFMap(); -/** +/* * Function: FPDF_AddInstalledFont - * Add a system font to the list in Foxit SDK. + * Add a system font to the list in PDFium. * Comments: * This function is only called during the system font list building - *process. + * 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); + */ +FPDF_EXPORT void FPDF_CALLCONV 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. + * Set the system font info interface into PDFium * Parameters: * pFontInfo - Pointer to a FPDF_SYSFONTINFO structure * Return Value: * None - **/ -DLLEXPORT void STDCALL FPDF_SetSystemFontInfo(FPDF_SYSFONTINFO* pFontInfo); + * Comments: + * Platform support implementation should implement required methods of + * FFDF_SYSFONTINFO interface, then call this function during PDFium + * initialization process. + */ +FPDF_EXPORT void FPDF_CALLCONV +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_FreeMemory to free the returned - *pointer. - **/ -DLLEXPORT FPDF_SYSFONTINFO* STDCALL FPDF_GetDefaultSystemFontInfo(); + * interface, or NULL if the platform doesn't have a default interface. + * Application should call FPDF_FreeDefaultSystemFontInfo to free the + * returned pointer. + * Comments: + * For some platforms, PDFium implements a default version of system + * font info interface. The default implementation can be passed to + * FPDF_SetSystemFontInfo(). + */ +FPDF_EXPORT FPDF_SYSFONTINFO* FPDF_CALLCONV FPDF_GetDefaultSystemFontInfo(); + +/* + * Function: FPDF_FreeDefaultSystemFontInfo + * Free a default system font info interface + * Parameters: + * pFontInfo - Pointer to a FPDF_SYSFONTINFO structure + * Return Value: + * None + * Comments: + * This function should be called on the output from + * FPDF_SetSystemFontInfo() once it is no longer needed. + */ +FPDF_EXPORT void FPDF_CALLCONV +FPDF_FreeDefaultSystemFontInfo(FPDF_SYSFONTINFO* pFontInfo); #ifdef __cplusplus } diff --git a/src/main/jni/include/fpdf_text.h b/src/main/jni/include/fpdf_text.h index 32cc1318..65554e4c 100644 --- a/src/main/jni/include/fpdf_text.h +++ b/src/main/jni/include/fpdf_text.h @@ -7,6 +7,8 @@ #ifndef PUBLIC_FPDF_TEXT_H_ #define PUBLIC_FPDF_TEXT_H_ +// clang-format off +// NOLINTNEXTLINE(build/include) #include "fpdfview.h" // Exported Functions @@ -18,7 +20,7 @@ extern "C" { // Prepare information about all characters in a page. // Parameters: // page - Handle to the page. Returned by FPDF_LoadPage function -// (in FPDFVIEW module). +// (in FPDFVIEW module). // Return value: // A handle to the text page information structure. // NULL if something goes wrong. @@ -26,24 +28,24 @@ extern "C" { // Application must call FPDFText_ClosePage to release the text page // information. // -DLLEXPORT FPDF_TEXTPAGE STDCALL FPDFText_LoadPage(FPDF_PAGE page); +FPDF_EXPORT FPDF_TEXTPAGE FPDF_CALLCONV 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. +// Returned by FPDFText_LoadPage function. // Return Value: // None. // -DLLEXPORT void STDCALL FPDFText_ClosePage(FPDF_TEXTPAGE text_page); +FPDF_EXPORT void FPDF_CALLCONV 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. +// 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 @@ -55,13 +57,13 @@ DLLEXPORT void STDCALL FPDFText_ClosePage(FPDF_TEXTPAGE text_page); // first character in the page // has an index value of zero. // -DLLEXPORT int STDCALL FPDFText_CountChars(FPDF_TEXTPAGE text_page); +FPDF_EXPORT int FPDF_CALLCONV 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. +// Returned by FPDFText_LoadPage function. // index - Zero-based index of the character. // Return value: // The Unicode of the particular character. @@ -69,187 +71,377 @@ DLLEXPORT int STDCALL FPDFText_CountChars(FPDF_TEXTPAGE text_page); // convert to Unicode, // the return value will be zero. // -DLLEXPORT unsigned int STDCALL FPDFText_GetUnicode(FPDF_TEXTPAGE text_page, - int index); +FPDF_EXPORT unsigned int FPDF_CALLCONV +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. +// 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"). +// 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); +FPDF_EXPORT double FPDF_CALLCONV FPDFText_GetFontSize(FPDF_TEXTPAGE text_page, + int index); + +// Experimental API. +// Function: FPDFText_GetFontInfo +// Get the font name and flags 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. +// buffer - A buffer receiving the font name. +// buflen - The length of |buffer| in bytes. +// flags - Optional pointer to an int receiving the font flags. +// These flags should be interpreted per PDF spec 1.7 +// Section 5.7.1 Font Descriptor Flags. +// Return value: +// On success, return the length of the font name, including the +// trailing NUL character, in bytes. If this length is less than or +// equal to |length|, |buffer| is set to the font name, |flags| is +// set to the font flags. |buffer| is in UTF-8 encoding. Return 0 on +// failure. +// +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDFText_GetFontInfo(FPDF_TEXTPAGE text_page, + int index, + void* buffer, + unsigned long buflen, + int* flags); + +// Experimental API. +// Function: FPDFText_GetFontWeight +// Get the font weight 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: +// On success, return the font weight of the particular character. If +// |text_page| is invalid, if |index| is out of bounds, or if the +// character's text object is undefined, return -1. +// +FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetFontWeight(FPDF_TEXTPAGE text_page, + int index); + +// Experimental API. +// Function: FPDFText_GetTextRenderMode +// Get text rendering mode of 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: +// On success, return the render mode value. A valid value is of type +// FPDF_TEXT_RENDERMODE. If |text_page| is invalid, if |index| is out +// of bounds, or if the text object is undefined, then return +// FPDF_TEXTRENDERMODE_UNKNOWN. +// +FPDF_EXPORT FPDF_TEXT_RENDERMODE FPDF_CALLCONV +FPDFText_GetTextRenderMode(FPDF_TEXTPAGE text_page, int index); + +// Experimental API. +// Function: FPDFText_GetFillColor +// Get the fill color 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. +// R - Pointer to an unsigned int number receiving the +// red value of the fill color. +// G - Pointer to an unsigned int number receiving the +// green value of the fill color. +// B - Pointer to an unsigned int number receiving the +// blue value of the fill color. +// A - Pointer to an unsigned int number receiving the +// alpha value of the fill color. +// Return value: +// Whether the call succeeded. If false, |R|, |G|, |B| and |A| are +// unchanged. +// +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFText_GetFillColor(FPDF_TEXTPAGE text_page, + int index, + unsigned int* R, + unsigned int* G, + unsigned int* B, + unsigned int* A); + +// Experimental API. +// Function: FPDFText_GetStrokeColor +// Get the stroke color 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. +// R - Pointer to an unsigned int number receiving the +// red value of the stroke color. +// G - Pointer to an unsigned int number receiving the +// green value of the stroke color. +// B - Pointer to an unsigned int number receiving the +// blue value of the stroke color. +// A - Pointer to an unsigned int number receiving the +// alpha value of the stroke color. +// Return value: +// Whether the call succeeded. If false, |R|, |G|, |B| and |A| are +// unchanged. +// +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFText_GetStrokeColor(FPDF_TEXTPAGE text_page, + int index, + unsigned int* R, + unsigned int* G, + unsigned int* B, + unsigned int* A); + +// Experimental API. +// Function: FPDFText_GetCharAngle +// Get character rotation angle. +// Parameters: +// text_page - Handle to a text page information structure. +// Returned by FPDFText_LoadPage function. +// index - Zero-based index of the character. +// Return Value: +// On success, return the angle value in radian. Value will always be +// greater or equal to 0. If |text_page| is invalid, or if |index| is +// out of bounds, then return -1. +// +FPDF_EXPORT float FPDF_CALLCONV FPDFText_GetCharAngle(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. +// 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. +// of the character box. // right - Pointer to a double number receiving right position -// of the character box. +// of the character box. // bottom - Pointer to a double number receiving bottom position -// of the character box. +// of the character box. // top - Pointer to a double number receiving top position of -// the character box. +// the character box. // Return Value: -// None. +// On success, return TRUE and fill in |left|, |right|, |bottom|, and +// |top|. If |text_page| is invalid, or if |index| is out of bounds, +// then return FALSE, and the out parameters remain unmodified. // 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); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetCharBox(FPDF_TEXTPAGE text_page, + int index, + double* left, + double* right, + double* bottom, + double* top); + +// Experimental API. +// Function: FPDFText_GetLooseCharBox +// Get a "loose" bounding box of a particular character, i.e., covering +// the entire glyph bounds, without taking the actual glyph shape into +// account. +// Parameters: +// text_page - Handle to a text page information structure. +// Returned by FPDFText_LoadPage function. +// index - Zero-based index of the character. +// rect - Pointer to a FS_RECTF receiving the character box. +// Return Value: +// On success, return TRUE and fill in |rect|. If |text_page| is +// invalid, or if |index| is out of bounds, then return FALSE, and the +// |rect| out parameter remains unmodified. +// Comments: +// All positions are measured in PDF "user space". +// +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFText_GetLooseCharBox(FPDF_TEXTPAGE text_page, int index, FS_RECTF* rect); + +// Experimental API. +// Function: FPDFText_GetMatrix +// Get the effective transformation matrix for a particular character. +// Parameters: +// text_page - Handle to a text page information structure. +// Returned by FPDFText_LoadPage(). +// index - Zero-based index of the character. +// matrix - Pointer to a FS_MATRIX receiving the transformation +// matrix. +// Return Value: +// On success, return TRUE and fill in |matrix|. If |text_page| is +// invalid, or if |index| is out of bounds, or if |matrix| is NULL, +// then return FALSE, and |matrix| remains unmodified. +// +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetMatrix(FPDF_TEXTPAGE text_page, + int index, + FS_MATRIX* matrix); + +// Function: FPDFText_GetCharOrigin +// Get origin 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. +// x - Pointer to a double number receiving x coordinate of +// the character origin. +// y - Pointer to a double number receiving y coordinate of +// the character origin. +// Return Value: +// Whether the call succeeded. If false, x and y are unchanged. +// Comments: +// All positions are measured in PDF "user space". +// +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFText_GetCharOrigin(FPDF_TEXTPAGE text_page, + int index, + double* x, + double* y); // 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. +// 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. +// detection, in point units. // yTolerance - A y-axis tolerance value for character hit -// detection, in point unit. +// detection, in point units. // 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. +// 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); +FPDF_EXPORT int FPDF_CALLCONV +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. +// 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. +// 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); +FPDF_EXPORT int FPDF_CALLCONV 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. +// 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 +// applications to detect the position on the page for a text segment, +// so proper areas can be highlighted. 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); +FPDF_EXPORT int FPDF_CALLCONV 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. +// Returned by FPDFText_LoadPage function. // rect_index - Zero-based index for the rectangle. // left - Pointer to a double value receiving the rectangle -// left boundary. +// left boundary. // top - Pointer to a double value receiving the rectangle -// top boundary. +// top boundary. // right - Pointer to a double value receiving the rectangle -// right boundary. +// right boundary. // bottom - Pointer to a double value receiving the rectangle -// bottom boundary. +// bottom boundary. // Return Value: -// None. +// On success, return TRUE and fill in |left|, |top|, |right|, and +// |bottom|. If |text_page| is invalid then return FALSE, and the out +// parameters remain unmodified. If |text_page| is valid but +// |rect_index| is out of bounds, then return FALSE and set the out +// parameters to 0. // -DLLEXPORT void STDCALL FPDFText_GetRect(FPDF_TEXTPAGE text_page, - int rect_index, - double* left, - double* top, - double* right, - double* bottom); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV 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. +// 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. +// 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 +// (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); +FPDF_EXPORT int FPDF_CALLCONV 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. +// +// If not set, it will not match case by default. +#define FPDF_MATCHCASE 0x00000001 +// If not set, it will not match the whole word by default. +#define FPDF_MATCHWHOLEWORD 0x00000002 +// If not set, it will skip past the current match to look for the next match. +#define FPDF_CONSECUTIVE 0x00000004 // Function: FPDFText_FindStart // Start a search. // Parameters: // text_page - Handle to a text page information structure. -// Returned by FPDFText_LoadPage function. +// 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. @@ -257,85 +449,83 @@ DLLEXPORT int STDCALL FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page, // 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); +FPDF_EXPORT FPDF_SCHHANDLE FPDF_CALLCONV +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. +// FPDFText_FindStart. // Return Value: // Whether a match is found. // -DLLEXPORT FPDF_BOOL STDCALL FPDFText_FindNext(FPDF_SCHHANDLE handle); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV 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. +// FPDFText_FindStart. // Return Value: // Whether a match is found. // -DLLEXPORT FPDF_BOOL STDCALL FPDFText_FindPrev(FPDF_SCHHANDLE handle); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV 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. +// FPDFText_FindStart. // Return Value: // Index for the starting character. // -DLLEXPORT int STDCALL FPDFText_GetSchResultIndex(FPDF_SCHHANDLE handle); +FPDF_EXPORT int FPDF_CALLCONV 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. +// FPDFText_FindStart. // Return Value: // Number of matched characters. // -DLLEXPORT int STDCALL FPDFText_GetSchCount(FPDF_SCHHANDLE handle); +FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetSchCount(FPDF_SCHHANDLE handle); // Function: FPDFText_FindClose // Release a search context. // Parameters: // handle - A search context handle returned by -// FPDFText_FindStart. +// FPDFText_FindStart. // Return Value: // None. // -DLLEXPORT void STDCALL FPDFText_FindClose(FPDF_SCHHANDLE handle); +FPDF_EXPORT void FPDF_CALLCONV 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. +// Returned by FPDFText_LoadPage function. // Return Value: -// A handle to the page's links information structure. +// A handle to the page's links information structure, or // 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. +// 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 "https://www.example.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); +FPDF_EXPORT FPDF_PAGELINK FPDF_CALLCONV +FPDFLink_LoadWebLinks(FPDF_TEXTPAGE text_page); // Function: FPDFLink_CountWebLinks // Count number of detected web links. @@ -344,25 +534,31 @@ DLLEXPORT FPDF_PAGELINK STDCALL FPDFLink_LoadWebLinks(FPDF_TEXTPAGE text_page); // Return Value: // Number of detected web links. // -DLLEXPORT int STDCALL FPDFLink_CountWebLinks(FPDF_PAGELINK link_page); +FPDF_EXPORT int FPDF_CALLCONV 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. -// buflen - Number of characters (not bytes) for the buffer, -// including an additional terminator. +// buffer - A unicode buffer for the result. +// buflen - Number of 16-bit code units (not bytes) for the +// buffer, including an additional terminator. // Return Value: -// If buffer is NULL or buflen is zero, return number of characters -// (not bytes and an additional terminator is also counted) needed, -// otherwise, return number of characters copied into the buffer. +// If |buffer| is NULL or |buflen| is zero, return the number of 16-bit +// code units (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 16-bit code +// units 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); +FPDF_EXPORT int FPDF_CALLCONV 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. @@ -370,10 +566,11 @@ DLLEXPORT int STDCALL FPDFLink_GetURL(FPDF_PAGELINK link_page, // link_page - Handle returned by FPDFLink_LoadWebLinks. // link_index - Zero-based index for the link. // Return Value: -// Number of rectangular areas for the link. +// 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); +FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountRects(FPDF_PAGELINK link_page, + int link_index); // Function: FPDFLink_GetRect // Fetch the boundaries of a rectangle for a link. @@ -382,23 +579,46 @@ DLLEXPORT int STDCALL FPDFLink_CountRects(FPDF_PAGELINK link_page, // 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. +// left boundary. // top - Pointer to a double value receiving the rectangle -// top boundary. +// top boundary. // right - Pointer to a double value receiving the rectangle -// right boundary. +// right boundary. // bottom - Pointer to a double value receiving the rectangle -// bottom boundary. +// bottom boundary. // Return Value: -// None. +// On success, return TRUE and fill in |left|, |top|, |right|, and +// |bottom|. If |link_page| is invalid or if |link_index| does not +// correspond to a valid link, then return FALSE, and the out +// parameters remain unmodified. +// +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetRect(FPDF_PAGELINK link_page, + int link_index, + int rect_index, + double* left, + double* top, + double* right, + double* bottom); + +// Experimental API. +// Function: FPDFLink_GetTextRange +// Fetch the start char index and char count for a link. +// Parameters: +// link_page - Handle returned by FPDFLink_LoadWebLinks. +// link_index - Zero-based index for the link. +// start_char_index - pointer to int receiving the start char index +// char_count - pointer to int receiving the char count +// Return Value: +// On success, return TRUE and fill in |start_char_index| and +// |char_count|. if |link_page| is invalid or if |link_index| does +// not correspond to a valid link, then return FALSE and the out +// parameters 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); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFLink_GetTextRange(FPDF_PAGELINK link_page, + int link_index, + int* start_char_index, + int* char_count); // Function: FPDFLink_CloseWebLinks // Release resources used by weblink feature. @@ -407,7 +627,7 @@ DLLEXPORT void STDCALL FPDFLink_GetRect(FPDF_PAGELINK link_page, // Return Value: // None. // -DLLEXPORT void STDCALL FPDFLink_CloseWebLinks(FPDF_PAGELINK link_page); +FPDF_EXPORT void FPDF_CALLCONV FPDFLink_CloseWebLinks(FPDF_PAGELINK link_page); #ifdef __cplusplus } diff --git a/src/main/jni/include/fpdf_transformpage.h b/src/main/jni/include/fpdf_transformpage.h index 569df2a7..03c26483 100644 --- a/src/main/jni/include/fpdf_transformpage.h +++ b/src/main/jni/include/fpdf_transformpage.h @@ -7,108 +7,211 @@ #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. + * + * page - Handle to a page. + * left - The left of the rectangle. + * bottom - The bottom of the rectangle. + * right - The right of the rectangle. + * top - The top of the rectangle. + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_SetMediaBox(FPDF_PAGE page, + float left, + float bottom, + float right, + float top); + +/** + * Set "CropBox" entry to the page dictionary. + * + * page - Handle to a page. + * left - The left of the rectangle. + * bottom - The bottom of the rectangle. + * right - The right of the rectangle. + * top - The top of the rectangle. + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_SetCropBox(FPDF_PAGE page, + float left, + float bottom, + float right, + float top); + +/** + * Set "BleedBox" entry to the page dictionary. + * + * page - Handle to a page. + * left - The left of the rectangle. + * bottom - The bottom of the rectangle. + * right - The right of the rectangle. + * top - The top of the rectangle. + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_SetBleedBox(FPDF_PAGE page, + float left, + float bottom, + float right, + float top); + +/** + * Set "TrimBox" entry to the page dictionary. + * + * page - Handle to a page. + * left - The left of the rectangle. + * bottom - The bottom of the rectangle. + * right - The right of the rectangle. + * top - The top of the rectangle. + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_SetTrimBox(FPDF_PAGE page, + float left, + float bottom, + float right, + float top); + +/** + * Set "ArtBox" entry to the page dictionary. + * + * page - Handle to a page. + * left - The left of the rectangle. + * bottom - The bottom of the rectangle. + * right - The right of the rectangle. + * top - The top of the rectangle. + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_SetArtBox(FPDF_PAGE page, + float left, + float bottom, + float right, + float top); + +/** + * Get "MediaBox" entry from the page dictionary. + * + * page - Handle to a page. + * left - Pointer to a float value receiving the left of the rectangle. + * bottom - Pointer to a float value receiving the bottom of the rectangle. + * right - Pointer to a float value receiving the right of the rectangle. + * top - Pointer to a float value receiving the top of the rectangle. + * + * On success, return true and write to the out parameters. Otherwise return + * false and leave the out parameters unmodified. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GetMediaBox(FPDF_PAGE page, + float* left, + float* bottom, + float* right, + float* top); + +/** + * Get "CropBox" entry from the page dictionary. + * + * page - Handle to a page. + * left - Pointer to a float value receiving the left of the rectangle. + * bottom - Pointer to a float value receiving the bottom of the rectangle. + * right - Pointer to a float value receiving the right of the rectangle. + * top - Pointer to a float value receiving the top of the rectangle. + * + * On success, return true and write to the out parameters. Otherwise return + * false and leave the out parameters unmodified. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GetCropBox(FPDF_PAGE page, + float* left, + float* bottom, + float* right, + float* top); + +/** + * Get "BleedBox" entry from the page dictionary. + * + * page - Handle to a page. + * left - Pointer to a float value receiving the left of the rectangle. + * bottom - Pointer to a float value receiving the bottom of the rectangle. + * right - Pointer to a float value receiving the right of the rectangle. + * top - Pointer to a float value receiving the top of the rectangle. + * + * On success, return true and write to the out parameters. Otherwise return + * false and leave the out parameters unmodified. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GetBleedBox(FPDF_PAGE page, + float* left, + float* bottom, + float* right, + float* top); /** -* 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); + * Get "TrimBox" entry from the page dictionary. + * + * page - Handle to a page. + * left - Pointer to a float value receiving the left of the rectangle. + * bottom - Pointer to a float value receiving the bottom of the rectangle. + * right - Pointer to a float value receiving the right of the rectangle. + * top - Pointer to a float value receiving the top of the rectangle. + * + * On success, return true and write to the out parameters. Otherwise return + * false and leave the out parameters unmodified. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GetTrimBox(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); + * Get "ArtBox" entry from the page dictionary. + * + * page - Handle to a page. + * left - Pointer to a float value receiving the left of the rectangle. + * bottom - Pointer to a float value receiving the bottom of the rectangle. + * right - Pointer to a float value receiving the right of the rectangle. + * top - Pointer to a float value receiving the top of the rectangle. + * + * On success, return true and write to the out parameters. Otherwise return + * false and leave the out parameters unmodified. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GetArtBox(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); + * Apply transforms to |page|. + * + * If |matrix| is provided it will be applied to transform the page. + * If |clipRect| is provided it will be used to clip the resulting page. + * If neither |matrix| or |clipRect| are provided this method returns |false|. + * Returns |true| if transforms are applied. + * + * This function will transform the whole page, and would take effect to all the + * objects in the page. + * + * page - Page handle. + * matrix - Transform matrix. + * clipRect - Clipping rectangle. + */ +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDFPage_TransFormWithClip(FPDF_PAGE page, + const FS_MATRIX* matrix, + const 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 + * Transform (scale, rotate, shear, move) the clip path of page object. + * page_object - Handle to a page object. Returned by + * FPDFPageObj_NewImageObj(). + * + * a - The coefficient "a" of the matrix. + * b - The coefficient "b" of the matrix. + * c - The coefficient "c" of the matrix. + * d - The coefficient "d" of the matrix. + * e - The coefficient "e" of the matrix. + * f - The coefficient "f" of the matrix. + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPageObj_TransformClipPath(FPDF_PAGEOBJECT page_object, double a, double b, @@ -117,41 +220,86 @@ FPDFPageObj_TransformClipPath(FPDF_PAGEOBJECT page_object, double e, double f); +// Experimental API. +// Get the clip path of the page object. +// +// page object - Handle to a page object. Returned by e.g. +// FPDFPage_GetObject(). +// +// Returns the handle to the clip path, or NULL on failure. The caller does not +// take ownership of the returned FPDF_CLIPPATH. Instead, it remains valid until +// FPDF_ClosePage() is called for the page containing |page_object|. +FPDF_EXPORT FPDF_CLIPPATH FPDF_CALLCONV +FPDFPageObj_GetClipPath(FPDF_PAGEOBJECT page_object); + +// Experimental API. +// Get number of paths inside |clip_path|. +// +// clip_path - handle to a clip_path. +// +// Returns the number of objects in |clip_path| or -1 on failure. +FPDF_EXPORT int FPDF_CALLCONV FPDFClipPath_CountPaths(FPDF_CLIPPATH clip_path); + +// Experimental API. +// Get number of segments inside one path of |clip_path|. +// +// clip_path - handle to a clip_path. +// path_index - index into the array of paths of the clip path. +// +// Returns the number of segments or -1 on failure. +FPDF_EXPORT int FPDF_CALLCONV +FPDFClipPath_CountPathSegments(FPDF_CLIPPATH clip_path, int path_index); + +// Experimental API. +// Get segment in one specific path of |clip_path| at index. +// +// clip_path - handle to a clip_path. +// path_index - the index of a path. +// segment_index - the index of a segment. +// +// Returns the handle to the segment, or NULL on failure. The caller does not +// take ownership of the returned FPDF_PATHSEGMENT. Instead, it remains valid +// until FPDF_ClosePage() is called for the page containing |clip_path|. +FPDF_EXPORT FPDF_PATHSEGMENT FPDF_CALLCONV +FPDFClipPath_GetPathSegment(FPDF_CLIPPATH clip_path, + int path_index, + int segment_index); + /** -* 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); + * Create a new clip path, with a rectangle inserted. + * + * Caller takes ownership of the returned FPDF_CLIPPATH. It should be freed with + * FPDF_DestroyClipPath(). + * + * left - The left of the clip box. + * bottom - The bottom of the clip box. + * right - The right of the clip box. + * top - The top of the clip box. + */ +FPDF_EXPORT FPDF_CLIPPATH FPDF_CALLCONV 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); + * Destroy the clip path. + * + * clipPath - A handle to the clip path. It will be invalid after this call. + */ +FPDF_EXPORT void FPDF_CALLCONV 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); + * Clip the page content, the page content that outside the clipping region + * become invisible. + * + * 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. + * + * page - A page handle. + * clipPath - A handle to the clip path. (Does not take ownership.) + */ +FPDF_EXPORT void FPDF_CALLCONV FPDFPage_InsertClipPath(FPDF_PAGE page, + FPDF_CLIPPATH clipPath); #ifdef __cplusplus } diff --git a/src/main/jni/include/fpdfview.h b/src/main/jni/include/fpdfview.h index 87312925..1768ebd3 100644 --- a/src/main/jni/include/fpdfview.h +++ b/src/main/jni/include/fpdfview.h @@ -5,58 +5,83 @@ // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com // NOTE: External docs refer to this file as "fpdfview.h", so do not rename -// despite lack of consitency with other public files. +// despite lack of consistency with other public files. #ifndef PUBLIC_FPDFVIEW_H_ #define PUBLIC_FPDFVIEW_H_ +// clang-format off + +#include + #if defined(_WIN32) && !defined(__WINDOWS__) #include #endif #ifdef PDF_ENABLE_XFA -// TODO: remove the #define when XFA is officially in pdfium +// PDF_USE_XFA is set in confirmation that this version of PDFium can support +// XFA forms as requested by the PDF_ENABLE_XFA setting. #define PDF_USE_XFA #endif // PDF_ENABLE_XFA -// PDF types -typedef void* FPDF_ACTION; -typedef void* FPDF_BITMAP; -typedef void* FPDF_BOOKMARK; -typedef void* FPDF_CLIPPATH; -typedef void* FPDF_DEST; -typedef void* FPDF_DOCSCHHANDLE; -typedef void* FPDF_DOCUMENT; -typedef void* FPDF_FONT; -typedef void* FPDF_HMODULE; -typedef void* FPDF_LINK; -typedef void* FPDF_MODULEMGR; -typedef void* FPDF_PAGE; -typedef void* FPDF_PAGELINK; -typedef void* FPDF_PAGEOBJECT; // Page object(text, path, etc) -typedef void* FPDF_PAGERANGE; -typedef void* FPDF_PATH; -typedef void* FPDF_SCHHANDLE; -typedef void* FPDF_TEXTPAGE; - -#ifdef PDF_ENABLE_XFA -typedef void* FPDF_STRINGHANDLE; -typedef void* FPDF_WIDGET; -#endif // PDF_ENABLE_XFA +// PDF object types +#define FPDF_OBJECT_UNKNOWN 0 +#define FPDF_OBJECT_BOOLEAN 1 +#define FPDF_OBJECT_NUMBER 2 +#define FPDF_OBJECT_STRING 3 +#define FPDF_OBJECT_NAME 4 +#define FPDF_OBJECT_ARRAY 5 +#define FPDF_OBJECT_DICTIONARY 6 +#define FPDF_OBJECT_STREAM 7 +#define FPDF_OBJECT_NULLOBJ 8 +#define FPDF_OBJECT_REFERENCE 9 + +// PDF text rendering modes +typedef enum { + FPDF_TEXTRENDERMODE_UNKNOWN = -1, + FPDF_TEXTRENDERMODE_FILL = 0, + FPDF_TEXTRENDERMODE_STROKE = 1, + FPDF_TEXTRENDERMODE_FILL_STROKE = 2, + FPDF_TEXTRENDERMODE_INVISIBLE = 3, + FPDF_TEXTRENDERMODE_FILL_CLIP = 4, + FPDF_TEXTRENDERMODE_STROKE_CLIP = 5, + FPDF_TEXTRENDERMODE_FILL_STROKE_CLIP = 6, + FPDF_TEXTRENDERMODE_CLIP = 7, + FPDF_TEXTRENDERMODE_LAST = FPDF_TEXTRENDERMODE_CLIP, +} FPDF_TEXT_RENDERMODE; + +// PDF types - use incomplete types (never completed) just for API type safety. +typedef struct fpdf_action_t__* FPDF_ACTION; +typedef struct fpdf_annotation_t__* FPDF_ANNOTATION; +typedef struct fpdf_attachment_t__* FPDF_ATTACHMENT; +typedef struct fpdf_bitmap_t__* FPDF_BITMAP; +typedef struct fpdf_bookmark_t__* FPDF_BOOKMARK; +typedef struct fpdf_clippath_t__* FPDF_CLIPPATH; +typedef struct fpdf_dest_t__* FPDF_DEST; +typedef struct fpdf_document_t__* FPDF_DOCUMENT; +typedef struct fpdf_font_t__* FPDF_FONT; +typedef struct fpdf_form_handle_t__* FPDF_FORMHANDLE; +typedef struct fpdf_javascript_action_t* FPDF_JAVASCRIPT_ACTION; +typedef struct fpdf_link_t__* FPDF_LINK; +typedef struct fpdf_page_t__* FPDF_PAGE; +typedef struct fpdf_pagelink_t__* FPDF_PAGELINK; +typedef struct fpdf_pageobject_t__* FPDF_PAGEOBJECT; // (text, path, etc.) +typedef struct fpdf_pageobjectmark_t__* FPDF_PAGEOBJECTMARK; +typedef struct fpdf_pagerange_t__* FPDF_PAGERANGE; +typedef const struct fpdf_pathsegment_t* FPDF_PATHSEGMENT; +typedef void* FPDF_RECORDER; // Passed into skia. +typedef struct fpdf_schhandle_t__* FPDF_SCHHANDLE; +typedef struct fpdf_structelement_t__* FPDF_STRUCTELEMENT; +typedef struct fpdf_structtree_t__* FPDF_STRUCTTREE; +typedef struct fpdf_textpage_t__* FPDF_TEXTPAGE; +typedef struct fpdf_widget_t__* FPDF_WIDGET; // Basic data types typedef int FPDF_BOOL; -typedef int FPDF_ERROR; +typedef int FPDF_RESULT; typedef unsigned long FPDF_DWORD; typedef float FS_FLOAT; -#ifdef PDF_ENABLE_XFA -typedef void* FPDF_LPVOID; -typedef void const* FPDF_LPCVOID; -typedef char const* FPDF_LPCSTR; -typedef int FPDF_RESULT; -#endif - // Duplex types typedef enum _FPDF_DUPLEXTYPE_ { DuplexUndefined = 0, @@ -67,7 +92,6 @@ typedef enum _FPDF_DUPLEXTYPE_ { // String types typedef unsigned short FPDF_WCHAR; -typedef unsigned char const* FPDF_LPCBYTE; // FPDFSDK may use three types of strings: byte string, wide string (UTF-16LE // encoded), and platform dependent string @@ -77,16 +101,13 @@ typedef const char* FPDF_BYTESTRING; // bytes (except surrogation), with the low byte first. typedef const unsigned short* FPDF_WIDESTRING; -#ifdef PDF_ENABLE_XFA -// Structure for a byte string. -// Note, a byte string commonly means a UTF-16LE formated string. -typedef struct _FPDF_BSTR { - // String buffer. - char* str; - // Length of the string, in bytes. - int len; +// Structure for persisting a string beyond the duration of a callback. +// Note: although represented as a char*, string may be interpreted as +// a UTF-16LE formated string. Used only by XFA callbacks. +typedef struct FPDF_BSTR_ { + char* str; // String buffer, manipulate only with FPDF_BStr_* methods. + int len; // Length of the string, in bytes. } FPDF_BSTR; -#endif // PDF_ENABLE_XFA // For Windows programmers: In most cases it's OK to treat FPDF_WIDESTRING as a // Windows unicode string, however, special care needs to be taken if you @@ -95,13 +116,16 @@ typedef struct _FPDF_BSTR { // For Linux/Unix programmers: most compiler/library environments use 4 bytes // for a Unicode character, and you have to convert between FPDF_WIDESTRING and // system wide string by yourself. -#ifdef _WIN32_WCE -typedef const unsigned short* FPDF_STRING; -#else typedef const char* FPDF_STRING; -#endif -// Matrix for transformation. +// Matrix for transformation, in the form [a b c d e f], equivalent to: +// | a b 0 | +// | c d 0 | +// | e f 1 | +// +// Translation is performed with [1 0 0 1 tx ty]. +// Scaling is performed with [sx 0 0 sy 0 0]. +// See PDF Reference 1.7, 4.2.2 Common Transformations for more. typedef struct _FS_MATRIX_ { float a; float b; @@ -126,13 +150,55 @@ typedef struct _FS_RECTF_ { // Const Pointer to FS_RECTF structure. typedef const FS_RECTF* FS_LPCRECTF; -#if defined(_WIN32) && defined(FPDFSDK_EXPORTS) -// On Windows system, functions are exported in a DLL -#define DLLEXPORT __declspec(dllexport) -#define STDCALL __stdcall +// Rectangle size. Coordinate system agnostic. +typedef struct FS_SIZEF_ { + float width; + float height; +} * FS_LPSIZEF, FS_SIZEF; + +// Const Pointer to FS_SIZEF structure. +typedef const FS_SIZEF* FS_LPCSIZEF; + +// 2D Point. Coordinate system agnostic. +typedef struct FS_POINTF_ { + float x; + float y; +} * FS_LPPOINTF, FS_POINTF; + +// Const Pointer to FS_POINTF structure. +typedef const FS_POINTF* FS_LPCPOINTF; + +// Annotation enums. +typedef int FPDF_ANNOTATION_SUBTYPE; +typedef int FPDF_ANNOT_APPEARANCEMODE; + +// Dictionary value types. +typedef int FPDF_OBJECT_TYPE; + +#if defined(COMPONENT_BUILD) +// FPDF_EXPORT should be consistent with |export| in the pdfium_fuzzer +// template in testing/fuzzers/BUILD.gn. +#if defined(WIN32) +#if defined(FPDF_IMPLEMENTATION) +#define FPDF_EXPORT __declspec(dllexport) +#else +#define FPDF_EXPORT __declspec(dllimport) +#endif // defined(FPDF_IMPLEMENTATION) +#else +#if defined(FPDF_IMPLEMENTATION) +#define FPDF_EXPORT __attribute__((visibility("default"))) +#else +#define FPDF_EXPORT +#endif // defined(FPDF_IMPLEMENTATION) +#endif // defined(WIN32) +#else +#define FPDF_EXPORT +#endif // defined(COMPONENT_BUILD) + +#if defined(WIN32) && defined(FPDFSDK_EXPORTS) +#define FPDF_CALLCONV __stdcall #else -#define DLLEXPORT -#define STDCALL +#define FPDF_CALLCONV #endif // Exported Functions @@ -148,12 +214,14 @@ extern "C" { // None. // Comments: // Convenience function to call FPDF_InitLibraryWithConfig() for -// backwards comatibility purposes. -DLLEXPORT void STDCALL FPDF_InitLibrary(); +// backwards compatibility purposes. This will be deprecated in the +// future. +FPDF_EXPORT void FPDF_CALLCONV FPDF_InitLibrary(); // Process-wide options for initializing the library. typedef struct FPDF_LIBRARY_CONFIG_ { // Version number of the interface. Currently must be 2. + // Support for version 1 will be deprecated in the future. int version; // Array of paths to scan in place of the defaults when using built-in @@ -168,9 +236,9 @@ typedef struct FPDF_LIBRARY_CONFIG_ { void* m_pIsolate; // The embedder data slot to use in the v8::Isolate to store PDFium's - // per-isolate data. The value needs to be between 0 and - // v8::Internals::kNumIsolateDataLots (exclusive). Note that 0 is fine - // for most embedders. + // per-isolate data. The value needs to be in the range + // [0, |v8::Internals::kNumIsolateDataLots|). Note that 0 is fine for most + // embedders. unsigned int m_v8EmbedderSlot; } FPDF_LIBRARY_CONFIG; @@ -183,8 +251,8 @@ typedef struct FPDF_LIBRARY_CONFIG_ { // Comments: // You have to call this function before you can call any PDF // processing functions. -DLLEXPORT void STDCALL FPDF_InitLibraryWithConfig( - const FPDF_LIBRARY_CONFIG* config); +FPDF_EXPORT void FPDF_CALLCONV +FPDF_InitLibraryWithConfig(const FPDF_LIBRARY_CONFIG* config); // Function: FPDF_DestroyLibary // Release all resources allocated by the FPDFSDK library. @@ -197,7 +265,7 @@ DLLEXPORT void STDCALL FPDF_InitLibraryWithConfig( // the library. // After this function is called, you should not call any PDF // processing functions. -DLLEXPORT void STDCALL FPDF_DestroyLibrary(); +FPDF_EXPORT void FPDF_CALLCONV FPDF_DestroyLibrary(); // Policy for accessing the local machine time. #define FPDF_POLICY_MACHINETIME_ACCESS 0 @@ -210,8 +278,57 @@ DLLEXPORT void STDCALL FPDF_DestroyLibrary(); // enable - True to enable, false to disable the policy. // Return value: // None. -DLLEXPORT void STDCALL FPDF_SetSandBoxPolicy(FPDF_DWORD policy, - FPDF_BOOL enable); +FPDF_EXPORT void FPDF_CALLCONV FPDF_SetSandBoxPolicy(FPDF_DWORD policy, + FPDF_BOOL enable); + +#if defined(_WIN32) +#if defined(PDFIUM_PRINT_TEXT_WITH_GDI) +// Pointer to a helper function to make |font| with |text| of |text_length| +// accessible when printing text with GDI. This is useful in sandboxed +// environments where PDFium's access to GDI may be restricted. +typedef void (*PDFiumEnsureTypefaceCharactersAccessible)(const LOGFONT* font, + const wchar_t* text, + size_t text_length); + +// Function: FPDF_SetTypefaceAccessibleFunc +// Set the function pointer that makes GDI fonts available in sandboxed +// environments. Experimental API. +// Parameters: +// func - A function pointer. See description above. +// Return value: +// None. +FPDF_EXPORT void FPDF_CALLCONV +FPDF_SetTypefaceAccessibleFunc(PDFiumEnsureTypefaceCharactersAccessible func); + +// Function: FPDF_SetPrintTextWithGDI +// Set whether to use GDI to draw fonts when printing on Windows. +// Experimental API. +// Parameters: +// use_gdi - Set to true to enable printing text with GDI. +// Return value: +// None. +FPDF_EXPORT void FPDF_CALLCONV FPDF_SetPrintTextWithGDI(FPDF_BOOL use_gdi); +#endif // PDFIUM_PRINT_TEXT_WITH_GDI + +// Function: FPDF_SetPrintMode +// Set printing mode when printing on Windows. +// Experimental API. +// Parameters: +// mode - FPDF_PRINTMODE_EMF to output EMF (default) +// FPDF_PRINTMODE_TEXTONLY to output text only (for charstream +// devices) +// FPDF_PRINTMODE_POSTSCRIPT2 to output level 2 PostScript into +// EMF as a series of GDI comments. +// FPDF_PRINTMODE_POSTSCRIPT3 to output level 3 PostScript into +// EMF as a series of GDI comments. +// FPDF_PRINTMODE_POSTSCRIPT2_PASSTHROUGH to output level 2 +// PostScript via ExtEscape() in PASSTHROUGH mode. +// FPDF_PRINTMODE_POSTSCRIPT3_PASSTHROUGH to output level 3 +// PostScript via ExtEscape() in PASSTHROUGH mode. +// Return value: +// True if successful, false if unsuccessful (typically invalid input). +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_SetPrintMode(int mode); +#endif // defined(_WIN32) // Function: FPDF_LoadDocument // Open and load a PDF document. @@ -219,14 +336,21 @@ DLLEXPORT void STDCALL FPDF_SetSandBoxPolicy(FPDF_DWORD policy, // file_path - Path to the PDF file (including extension). // password - A string used as the password for the PDF file. // If no password is needed, empty or NULL can be used. +// See comments below regarding the encoding. // Return value: // A handle to the loaded document, or NULL on failure. // Comments: // Loaded document can be closed by FPDF_CloseDocument(). // If this function fails, you can use FPDF_GetLastError() to retrieve // the reason why it failed. -DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path, - FPDF_BYTESTRING password); +// +// The encoding for |password| can be either UTF-8 or Latin-1. PDFs, +// depending on the security handler revision, will only accept one or +// the other encoding. If |password|'s encoding and the PDF's expected +// encoding do not match, FPDF_LoadDocument() will automatically +// convert |password| to the other encoding. +FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV +FPDF_LoadDocument(FPDF_STRING file_path, FPDF_BYTESTRING password); // Function: FPDF_LoadMemDocument // Open and load a PDF document from memory. @@ -242,13 +366,15 @@ DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path, // The loaded document can be closed by FPDF_CloseDocument. // If this function fails, you can use FPDF_GetLastError() to retrieve // the reason why it failed. +// +// See the comments for FPDF_LoadDocument() regarding the encoding for +// |password|. // Notes: // If PDFium is built with the XFA module, the application should call // FPDF_LoadXFA() function after the PDF document loaded to support XFA // fields defined in the fpdfformfill.h file. -DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf, - int size, - FPDF_BYTESTRING password); +FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV +FPDF_LoadMemDocument(const void* data_buf, int size, FPDF_BYTESTRING password); // Structure for custom file access. typedef struct { @@ -257,6 +383,7 @@ typedef struct { // A function pointer for getting a block of data from a specific position. // Position is specified by byte offset from the beginning of the file. + // The pointer to the buffer is never NULL and the size is never 0. // The position and size will never go out of range of the file length. // It may be possible for FPDFSDK to call this function multiple times for // the same position. @@ -271,87 +398,102 @@ typedef struct { void* m_Param; } FPDF_FILEACCESS; -#ifdef PDF_ENABLE_XFA -/** - * @brief Structure for file reading or writing (I/O). +/* + * Structure for file reading or writing (I/O). * - * @note This is a handler and should be implemented by callers. + * Note: This is a handler and should be implemented by callers, + * and is only used from XFA. */ -typedef struct _FPDF_FILEHANDLER { - /** - * @brief User-defined data. - * @note Callers can use this field to track controls. +typedef struct FPDF_FILEHANDLER_ { + /* + * User-defined data. + * Note: Callers can use this field to track controls. */ - FPDF_LPVOID clientData; - /** - * @brief Callback function to release the current file stream object. - * - * @param[in] clientData Pointer to user-defined data. + void* clientData; + + /* + * Callback function to release the current file stream object. * - * @return None. + * Parameters: + * clientData - Pointer to user-defined data. + * Returns: + * None. */ - void (*Release)(FPDF_LPVOID clientData); - /** - * @brief Callback function to retrieve the current file stream size. - * - * @param[in] clientData Pointer to user-defined data. + void (*Release)(void* clientData); + + /* + * Callback function to retrieve the current file stream size. * - * @return Size of file stream. + * Parameters: + * clientData - Pointer to user-defined data. + * Returns: + * Size of file stream. */ - FPDF_DWORD (*GetSize)(FPDF_LPVOID clientData); - /** - * @brief Callback function to read data from the current file stream. - * - * @param[in] clientData Pointer to user-defined data. - * @param[in] offset Offset position starts from the beginning of file - * stream. This parameter indicates reading position. - * @param[in] buffer Memory buffer to store data which are read from - * file stream. This parameter should not be NULL. - * @param[in] size Size of data which should be read from file - * stream, in bytes. The buffer indicated by the parameter buffer - * should be enough to store specified data. + FPDF_DWORD (*GetSize)(void* clientData); + + /* + * Callback function to read data from the current file stream. * - * @return 0 for success, other value for failure. + * Parameters: + * clientData - Pointer to user-defined data. + * offset - Offset position starts from the beginning of file + * stream. This parameter indicates reading position. + * buffer - Memory buffer to store data which are read from + * file stream. This parameter should not be NULL. + * size - Size of data which should be read from file stream, + * in bytes. The buffer indicated by |buffer| must be + * large enough to store specified data. + * Returns: + * 0 for success, other value for failure. */ - FPDF_RESULT (*ReadBlock)(FPDF_LPVOID clientData, FPDF_DWORD offset, FPDF_LPVOID buffer, FPDF_DWORD size); - /** - * @brief Callback function to write data into the current file stream. - * - * @param[in] clientData Pointer to user-defined data. - * @param[in] offset Offset position starts from the beginning of file - * stream. This parameter indicates writing position. - * @param[in] buffer Memory buffer contains data which is written into - * file stream. This parameter should not be NULL. - * @param[in] size Size of data which should be written into file - * stream, in bytes. + FPDF_RESULT (*ReadBlock)(void* clientData, + FPDF_DWORD offset, + void* buffer, + FPDF_DWORD size); + + /* + * Callback function to write data into the current file stream. * - * @return 0 for success, other value for failure. + * Parameters: + * clientData - Pointer to user-defined data. + * offset - Offset position starts from the beginning of file + * stream. This parameter indicates writing position. + * buffer - Memory buffer contains data which is written into + * file stream. This parameter should not be NULL. + * size - Size of data which should be written into file + * stream, in bytes. + * Returns: + * 0 for success, other value for failure. */ - FPDF_RESULT (*WriteBlock)(FPDF_LPVOID clientData, FPDF_DWORD offset, FPDF_LPCVOID buffer, FPDF_DWORD size); - /** - * @brief Callback function to flush all internal accessing buffers. - * - * @param[in] clientData Pointer to user-defined data. + FPDF_RESULT (*WriteBlock)(void* clientData, + FPDF_DWORD offset, + const void* buffer, + FPDF_DWORD size); + /* + * Callback function to flush all internal accessing buffers. * - * @return 0 for success, other value for failure. + * Parameters: + * clientData - Pointer to user-defined data. + * Returns: + * 0 for success, other value for failure. */ - FPDF_RESULT (*Flush)(FPDF_LPVOID clientData); - /** - * @brief Callback function to change file size. - * - * @details This function is called under writing mode usually. Implementer - * can determine whether to realize it based on application requests. - * - * @param[in] clientData Pointer to user-defined data. - * @param[in] size New size of file stream, in bytes. + FPDF_RESULT (*Flush)(void* clientData); + + /* + * Callback function to change file size. * - * @return 0 for success, other value for failure. + * Description: + * This function is called under writing mode usually. Implementer + * can determine whether to realize it based on application requests. + * Parameters: + * clientData - Pointer to user-defined data. + * size - New size of file stream, in bytes. + * Returns: + * 0 for success, other value for failure. */ - FPDF_RESULT (*Truncate)(FPDF_LPVOID clientData, FPDF_DWORD size); + FPDF_RESULT (*Truncate)(void* clientData, FPDF_DWORD size); +} FPDF_FILEHANDLER; -} FPDF_FILEHANDLER, *FPDF_LPFILEHANDLER; - -#endif // Function: FPDF_LoadCustomDocument // Load PDF document from a custom access descriptor. // Parameters: @@ -360,15 +502,19 @@ typedef struct _FPDF_FILEHANDLER { // Return value: // A handle to the loaded document, or NULL on failure. // Comments: -// The application must keep the file resources valid until the PDF -// document is closed. +// The application must keep the file resources |pFileAccess| points to +// valid until the returned FPDF_DOCUMENT is closed. |pFileAccess| +// itself does not need to outlive the FPDF_DOCUMENT. +// +// The loaded document can be closed with FPDF_CloseDocument(). // -// The loaded document can be closed with FPDF_CloseDocument. +// See the comments for FPDF_LoadDocument() regarding the encoding for +// |password|. // Notes: // If PDFium is built with the XFA module, the application should call // FPDF_LoadXFA() function after the PDF document loaded to support XFA // fields defined in the fpdfformfill.h file. -DLLEXPORT FPDF_DOCUMENT STDCALL +FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess, FPDF_BYTESTRING password); // Function: FPDF_GetFileVersion @@ -382,8 +528,8 @@ FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess, FPDF_BYTESTRING password); // Comments: // If the document was created by FPDF_CreateNewDocument, // then this function will always fail. -DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc, - int* fileVersion); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_GetFileVersion(FPDF_DOCUMENT doc, + int* fileVersion); #define FPDF_ERR_SUCCESS 0 // No error. #define FPDF_ERR_UNKNOWN 1 // Unknown error. @@ -406,7 +552,22 @@ DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc, // Comments: // If the previous SDK call succeeded, the return value of this // function is not defined. -DLLEXPORT unsigned long STDCALL FPDF_GetLastError(); +FPDF_EXPORT unsigned long FPDF_CALLCONV FPDF_GetLastError(); + +// Function: FPDF_DocumentHasValidCrossReferenceTable +// Whether the document's cross reference table is valid or not. +// Experimental API. +// Parameters: +// document - Handle to a document. Returned by FPDF_LoadDocument. +// Return value: +// True if the PDF parser did not encounter problems parsing the cross +// reference table. False if the parser could not parse the cross +// reference table and the table had to be rebuild from other data +// within the document. +// Comments: +// The return value can change over time as the PDF parser evolves. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDF_DocumentHasValidCrossReferenceTable(FPDF_DOCUMENT document); // Function: FPDF_GetDocPermission // Get file permission flags of the document. @@ -416,7 +577,8 @@ DLLEXPORT unsigned long STDCALL FPDF_GetLastError(); // A 32-bit integer indicating permission flags. Please refer to the // PDF Reference for detailed descriptions. If the document is not // protected, 0xffffffff will be returned. -DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document); +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDF_GetDocPermissions(FPDF_DOCUMENT document); // Function: FPDF_GetSecurityHandlerRevision // Get the revision for the security handler. @@ -426,7 +588,8 @@ DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document); // The security handler revision number. Please refer to the PDF // Reference for a detailed description. If the document is not // protected, -1 will be returned. -DLLEXPORT int STDCALL FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document); +FPDF_EXPORT int FPDF_CALLCONV +FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document); // Function: FPDF_GetPageCount // Get total number of pages in the document. @@ -434,7 +597,7 @@ DLLEXPORT int STDCALL FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document); // document - Handle to document. Returned by FPDF_LoadDocument. // Return value: // Total number of pages in the document. -DLLEXPORT int STDCALL FPDF_GetPageCount(FPDF_DOCUMENT document); +FPDF_EXPORT int FPDF_CALLCONV FPDF_GetPageCount(FPDF_DOCUMENT document); // Function: FPDF_LoadPage // Load a page inside the document. @@ -446,8 +609,18 @@ DLLEXPORT int STDCALL FPDF_GetPageCount(FPDF_DOCUMENT document); // Comments: // The loaded page can be rendered to devices using FPDF_RenderPage. // The loaded page can be closed using FPDF_ClosePage. -DLLEXPORT FPDF_PAGE STDCALL FPDF_LoadPage(FPDF_DOCUMENT document, - int page_index); +FPDF_EXPORT FPDF_PAGE FPDF_CALLCONV FPDF_LoadPage(FPDF_DOCUMENT document, + int page_index); + +// Experimental API +// Function: FPDF_GetPageWidthF +// Get page width. +// Parameters: +// page - Handle to the page. Returned by FPDF_LoadPage(). +// Return value: +// Page width (excluding non-displayable area) measured in points. +// One point is 1/72 inch (around 0.3528 mm). +FPDF_EXPORT float FPDF_CALLCONV FPDF_GetPageWidthF(FPDF_PAGE page); // Function: FPDF_GetPageWidth // Get page width. @@ -456,7 +629,20 @@ DLLEXPORT FPDF_PAGE STDCALL FPDF_LoadPage(FPDF_DOCUMENT document, // Return value: // Page width (excluding non-displayable area) measured in points. // One point is 1/72 inch (around 0.3528 mm). -DLLEXPORT double STDCALL FPDF_GetPageWidth(FPDF_PAGE page); +// Note: +// Prefer FPDF_GetPageWidthF() above. This will be deprecated in the +// future. +FPDF_EXPORT double FPDF_CALLCONV FPDF_GetPageWidth(FPDF_PAGE page); + +// Experimental API +// Function: FPDF_GetPageHeightF +// Get page height. +// Parameters: +// page - Handle to the page. Returned by FPDF_LoadPage(). +// Return value: +// Page height (excluding non-displayable area) measured in points. +// One point is 1/72 inch (around 0.3528 mm) +FPDF_EXPORT float FPDF_CALLCONV FPDF_GetPageHeightF(FPDF_PAGE page); // Function: FPDF_GetPageHeight // Get page height. @@ -465,7 +651,38 @@ DLLEXPORT double STDCALL FPDF_GetPageWidth(FPDF_PAGE page); // Return value: // Page height (excluding non-displayable area) measured in points. // One point is 1/72 inch (around 0.3528 mm) -DLLEXPORT double STDCALL FPDF_GetPageHeight(FPDF_PAGE page); +// Note: +// Prefer FPDF_GetPageHeightF() above. This will be deprecated in the +// future. +FPDF_EXPORT double FPDF_CALLCONV FPDF_GetPageHeight(FPDF_PAGE page); + +// Experimental API. +// Function: FPDF_GetPageBoundingBox +// Get the bounding box of the page. This is the intersection between +// its media box and its crop box. +// Parameters: +// page - Handle to the page. Returned by FPDF_LoadPage. +// rect - Pointer to a rect to receive the page bounding box. +// On an error, |rect| won't be filled. +// Return value: +// True for success. +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_GetPageBoundingBox(FPDF_PAGE page, + FS_RECTF* rect); + +// Experimental API. +// Function: FPDF_GetPageSizeByIndexF +// Get the size of the page at the given index. +// Parameters: +// document - Handle to document. Returned by FPDF_LoadDocument(). +// page_index - Page index, zero for the first page. +// size - Pointer to a FS_SIZEF to receive the page size. +// (in points). +// Return value: +// Non-zero for success. 0 for error (document or page not found). +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV +FPDF_GetPageSizeByIndexF(FPDF_DOCUMENT document, + int page_index, + FS_SIZEF* size); // Function: FPDF_GetPageSizeByIndex // Get the size of the page at the given index. @@ -478,10 +695,13 @@ DLLEXPORT double STDCALL FPDF_GetPageHeight(FPDF_PAGE page); // (in points). // Return value: // Non-zero for success. 0 for error (document or page not found). -DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document, - int page_index, - double* width, - double* height); +// Note: +// Prefer FPDF_GetPageSizeByIndexF() above. This will be deprecated in +// the future. +FPDF_EXPORT int FPDF_CALLCONV FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document, + int page_index, + double* width, + double* height); // Page rendering flags. They can be combined with bit-wise OR. // @@ -493,9 +713,9 @@ DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document, #define FPDF_NO_NATIVETEXT 0x04 // Grayscale output. #define FPDF_GRAYSCALE 0x08 -// Set if you want to get some debug info. +// Obsolete, has no effect, retained for compatibility. #define FPDF_DEBUG_INFO 0x80 -// Set if you don't want to catch exceptions. +// Obsolete, has no effect, retained for compatibility. #define FPDF_NO_CATCH 0x100 // Limit image cache size. #define FPDF_RENDER_LIMITEDIMAGECACHE 0x200 @@ -509,6 +729,8 @@ DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document, #define FPDF_RENDER_NO_SMOOTHIMAGE 0x2000 // Set to disable anti-aliasing on paths. #define FPDF_RENDER_NO_SMOOTHPATH 0x4000 +// Set to only render grayscale text (no images, etc). +#define FPDF_RENDER_TEXT_MASK 0x8000 // Set whether to render in a reverse Byte order, this flag is only used when // rendering to a bitmap. #define FPDF_REVERSE_BYTE_ORDER 0x10 @@ -535,14 +757,14 @@ DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document, // defined above. // Return value: // None. -DLLEXPORT void STDCALL FPDF_RenderPage(HDC dc, - FPDF_PAGE page, - int start_x, - int start_y, - int size_x, - int size_y, - int rotate, - int flags); +FPDF_EXPORT void FPDF_CALLCONV FPDF_RenderPage(HDC dc, + FPDF_PAGE page, + int start_x, + int start_y, + int size_x, + int size_y, + int rotate, + int flags); #endif // Function: FPDF_RenderPageBitmap @@ -550,7 +772,8 @@ DLLEXPORT void STDCALL FPDF_RenderPage(HDC dc, // Parameters: // bitmap - Handle to the device independent bitmap (as the // output buffer). The bitmap handle can be created -// by FPDFBitmap_Create. +// by FPDFBitmap_Create or retrieved from an image +// object by FPDFImageObj_GetBitmap. // page - Handle to the page. Returned by FPDF_LoadPage // start_x - Left pixel position of the display area in // bitmap coordinates. @@ -563,18 +786,52 @@ DLLEXPORT void STDCALL FPDF_RenderPage(HDC dc, // 1 (rotated 90 degrees clockwise) // 2 (rotated 180 degrees) // 3 (rotated 90 degrees counter-clockwise) -// flags - 0 for normal display, or combination of flags -// defined above. +// flags - 0 for normal display, or combination of the Page +// Rendering flags defined above. With the FPDF_ANNOT +// flag, it renders all annotations that do not require +// user-interaction, which are all annotations except +// widget and popup annotations. // Return value: // None. -DLLEXPORT void STDCALL FPDF_RenderPageBitmap(FPDF_BITMAP bitmap, - FPDF_PAGE page, - int start_x, - int start_y, - int size_x, - int size_y, - int rotate, - int flags); +FPDF_EXPORT void FPDF_CALLCONV FPDF_RenderPageBitmap(FPDF_BITMAP bitmap, + FPDF_PAGE page, + int start_x, + int start_y, + int size_x, + int size_y, + int rotate, + int flags); + +// Function: FPDF_RenderPageBitmapWithMatrix +// Render contents of a page to a device independent bitmap. +// Parameters: +// bitmap - Handle to the device independent bitmap (as the +// output buffer). The bitmap handle can be created +// by FPDFBitmap_Create or retrieved by +// FPDFImageObj_GetBitmap. +// page - Handle to the page. Returned by FPDF_LoadPage. +// matrix - The transform matrix, which must be invertible. +// See PDF Reference 1.7, 4.2.2 Common Transformations. +// clipping - The rect to clip to in device coords. +// flags - 0 for normal display, or combination of the Page +// Rendering flags defined above. With the FPDF_ANNOT +// flag, it renders all annotations that do not require +// user-interaction, which are all annotations except +// widget and popup annotations. +// Return value: +// None. Note that behavior is undefined if det of |matrix| is 0. +FPDF_EXPORT void FPDF_CALLCONV +FPDF_RenderPageBitmapWithMatrix(FPDF_BITMAP bitmap, + FPDF_PAGE page, + const FS_MATRIX* matrix, + const FS_RECTF* clipping, + int flags); + +#ifdef _SKIA_SUPPORT_ +FPDF_EXPORT FPDF_RECORDER FPDF_CALLCONV FPDF_RenderPageSkp(FPDF_PAGE page, + int size_x, + int size_y); +#endif // Function: FPDF_ClosePage // Close a loaded PDF page. @@ -582,7 +839,7 @@ DLLEXPORT void STDCALL FPDF_RenderPageBitmap(FPDF_BITMAP bitmap, // page - Handle to the loaded page. // Return value: // None. -DLLEXPORT void STDCALL FPDF_ClosePage(FPDF_PAGE page); +FPDF_EXPORT void FPDF_CALLCONV FPDF_ClosePage(FPDF_PAGE page); // Function: FPDF_CloseDocument // Close a loaded PDF document. @@ -590,7 +847,7 @@ DLLEXPORT void STDCALL FPDF_ClosePage(FPDF_PAGE page); // document - Handle to the loaded document. // Return value: // None. -DLLEXPORT void STDCALL FPDF_CloseDocument(FPDF_DOCUMENT document); +FPDF_EXPORT void FPDF_CALLCONV FPDF_CloseDocument(FPDF_DOCUMENT document); // Function: FPDF_DeviceToPage // Convert the screen coordinates of a point to page coordinates. @@ -614,7 +871,8 @@ DLLEXPORT void STDCALL FPDF_CloseDocument(FPDF_DOCUMENT document); // page_y - A pointer to a double receiving the converted Y // value in page coordinates. // Return value: -// None. +// Returns true if the conversion succeeds, and |page_x| and |page_y| +// successfully receives the converted coordinates. // Comments: // The page coordinate system has its origin at the left-bottom corner // of the page, with the X-axis on the bottom going to the right, and @@ -632,16 +890,16 @@ DLLEXPORT void STDCALL FPDF_CloseDocument(FPDF_DOCUMENT document); // You must make sure the start_x, start_y, size_x, size_y // and rotate parameters have exactly same values as you used in // the FPDF_RenderPage() function call. -DLLEXPORT void STDCALL FPDF_DeviceToPage(FPDF_PAGE page, - int start_x, - int start_y, - int size_x, - int size_y, - int rotate, - int device_x, - int device_y, - double* page_x, - double* page_y); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_DeviceToPage(FPDF_PAGE page, + int start_x, + int start_y, + int size_x, + int size_y, + int rotate, + int device_x, + int device_y, + double* page_x, + double* page_y); // Function: FPDF_PageToDevice // Convert the page coordinates of a point to screen coordinates. @@ -665,19 +923,20 @@ DLLEXPORT void STDCALL FPDF_DeviceToPage(FPDF_PAGE page, // device_y - A pointer to an integer receiving the result Y // value in device coordinates. // Return value: -// None. +// Returns true if the conversion succeeds, and |device_x| and +// |device_y| successfully receives the converted coordinates. // Comments: // See comments for FPDF_DeviceToPage(). -DLLEXPORT void STDCALL FPDF_PageToDevice(FPDF_PAGE page, - int start_x, - int start_y, - int size_x, - int size_y, - int rotate, - double page_x, - double page_y, - int* device_x, - int* device_y); +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_PageToDevice(FPDF_PAGE page, + int start_x, + int start_y, + int size_x, + int size_y, + int rotate, + double page_x, + double page_y, + int* device_x, + int* device_y); // Function: FPDFBitmap_Create // Create a device independent bitmap (FXDIB). @@ -707,12 +966,15 @@ DLLEXPORT void STDCALL FPDF_PageToDevice(FPDF_PAGE page, // // This function allocates enough memory for holding all pixels in the // bitmap, but it doesn't initialize the buffer. Applications can use -// FPDFBitmap_FillRect to fill the bitmap using any color. -DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width, - int height, - int alpha); +// FPDFBitmap_FillRect() to fill the bitmap using any color. If the OS +// allows it, this function can allocate up to 4 GB of memory. +FPDF_EXPORT FPDF_BITMAP FPDF_CALLCONV FPDFBitmap_Create(int width, + int height, + int alpha); // More DIB formats +// Unknown or unsupported format. +#define FPDFBitmap_Unknown 0 // Gray scale bitmap, one byte per pixel. #define FPDFBitmap_Gray 1 // 3 bytes per pixel, byte order: blue, green, red. @@ -747,11 +1009,23 @@ DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width, // If an external buffer is used, then the application should destroy // the buffer by itself. FPDFBitmap_Destroy function will not destroy // the buffer. -DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_CreateEx(int width, - int height, - int format, - void* first_scan, - int stride); +FPDF_EXPORT FPDF_BITMAP FPDF_CALLCONV FPDFBitmap_CreateEx(int width, + int height, + int format, + void* first_scan, + int stride); + +// Function: FPDFBitmap_GetFormat +// Get the format of the bitmap. +// Parameters: +// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create +// or FPDFImageObj_GetBitmap. +// Return value: +// The format of the bitmap. +// Comments: +// Only formats supported by FPDFBitmap_CreateEx are supported by this +// function; see the list of such formats above. +FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetFormat(FPDF_BITMAP bitmap); // Function: FPDFBitmap_FillRect // Fill a rectangle in a bitmap. @@ -777,17 +1051,18 @@ DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_CreateEx(int width, // background will be replaced by the source color and the alpha. // // If the alpha channel is not used, the alpha parameter is ignored. -DLLEXPORT void STDCALL FPDFBitmap_FillRect(FPDF_BITMAP bitmap, - int left, - int top, - int width, - int height, - FPDF_DWORD color); +FPDF_EXPORT void FPDF_CALLCONV FPDFBitmap_FillRect(FPDF_BITMAP bitmap, + int left, + int top, + int width, + int height, + FPDF_DWORD color); // Function: FPDFBitmap_GetBuffer // Get data buffer of a bitmap. // Parameters: -// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create. +// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create +// or FPDFImageObj_GetBitmap. // Return value: // The pointer to the first byte of the bitmap buffer. // Comments: @@ -799,44 +1074,48 @@ DLLEXPORT void STDCALL FPDFBitmap_FillRect(FPDF_BITMAP bitmap, // // The data is in BGRA format. Where the A maybe unused if alpha was // not specified. -DLLEXPORT void* STDCALL FPDFBitmap_GetBuffer(FPDF_BITMAP bitmap); +FPDF_EXPORT void* FPDF_CALLCONV FPDFBitmap_GetBuffer(FPDF_BITMAP bitmap); // Function: FPDFBitmap_GetWidth // Get width of a bitmap. // Parameters: -// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create. +// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create +// or FPDFImageObj_GetBitmap. // Return value: // The width of the bitmap in pixels. -DLLEXPORT int STDCALL FPDFBitmap_GetWidth(FPDF_BITMAP bitmap); +FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetWidth(FPDF_BITMAP bitmap); // Function: FPDFBitmap_GetHeight // Get height of a bitmap. // Parameters: -// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create. +// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create +// or FPDFImageObj_GetBitmap. // Return value: // The height of the bitmap in pixels. -DLLEXPORT int STDCALL FPDFBitmap_GetHeight(FPDF_BITMAP bitmap); +FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetHeight(FPDF_BITMAP bitmap); // Function: FPDFBitmap_GetStride // Get number of bytes for each line in the bitmap buffer. // Parameters: -// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create. +// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create +// or FPDFImageObj_GetBitmap. // Return value: // The number of bytes for each line in the bitmap buffer. // Comments: // The stride may be more than width * number of bytes per pixel. -DLLEXPORT int STDCALL FPDFBitmap_GetStride(FPDF_BITMAP bitmap); +FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetStride(FPDF_BITMAP bitmap); // Function: FPDFBitmap_Destroy // Destroy a bitmap and release all related buffers. // Parameters: -// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create. +// bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create +// or FPDFImageObj_GetBitmap. // Return value: // None. // Comments: // This function will not destroy any external buffers provided when // the bitmap was created. -DLLEXPORT void STDCALL FPDFBitmap_Destroy(FPDF_BITMAP bitmap); +FPDF_EXPORT void FPDF_CALLCONV FPDFBitmap_Destroy(FPDF_BITMAP bitmap); // Function: FPDF_VIEWERREF_GetPrintScaling // Whether the PDF document prefers to be scaled or not. @@ -844,7 +1123,7 @@ DLLEXPORT void STDCALL FPDFBitmap_Destroy(FPDF_BITMAP bitmap); // document - Handle to the loaded document. // Return value: // None. -DLLEXPORT FPDF_BOOL STDCALL +FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_VIEWERREF_GetPrintScaling(FPDF_DOCUMENT document); // Function: FPDF_VIEWERREF_GetNumCopies @@ -853,7 +1132,8 @@ FPDF_VIEWERREF_GetPrintScaling(FPDF_DOCUMENT document); // document - Handle to the loaded document. // Return value: // The number of copies to be printed. -DLLEXPORT int STDCALL FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document); +FPDF_EXPORT int FPDF_CALLCONV +FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document); // Function: FPDF_VIEWERREF_GetPrintPageRange // Page numbers to initialize print dialog box when file is printed. @@ -861,9 +1141,31 @@ DLLEXPORT int STDCALL FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document); // document - Handle to the loaded document. // Return value: // The print page range to be used for printing. -DLLEXPORT FPDF_PAGERANGE STDCALL +FPDF_EXPORT FPDF_PAGERANGE FPDF_CALLCONV FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document); +// Function: FPDF_VIEWERREF_GetPrintPageRangeCount +// Returns the number of elements in a FPDF_PAGERANGE. +// Experimental API. +// Parameters: +// pagerange - Handle to the page range. +// Return value: +// The number of elements in the page range. Returns 0 on error. +FPDF_EXPORT size_t FPDF_CALLCONV +FPDF_VIEWERREF_GetPrintPageRangeCount(FPDF_PAGERANGE pagerange); + +// Function: FPDF_VIEWERREF_GetPrintPageRangeElement +// Returns an element from a FPDF_PAGERANGE. +// Experimental API. +// Parameters: +// pagerange - Handle to the page range. +// index - Index of the element. +// Return value: +// The value of the element in the page range at a given index. +// Returns -1 on error. +FPDF_EXPORT int FPDF_CALLCONV +FPDF_VIEWERREF_GetPrintPageRangeElement(FPDF_PAGERANGE pagerange, size_t index); + // Function: FPDF_VIEWERREF_GetDuplex // Returns the paper handling option to be used when printing from // the print dialog. @@ -871,16 +1173,38 @@ FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document); // document - Handle to the loaded document. // Return value: // The paper handling option to be used when printing. -DLLEXPORT FPDF_DUPLEXTYPE STDCALL +FPDF_EXPORT FPDF_DUPLEXTYPE FPDF_CALLCONV FPDF_VIEWERREF_GetDuplex(FPDF_DOCUMENT document); +// Function: FPDF_VIEWERREF_GetName +// Gets the contents for a viewer ref, with a given key. The value must +// be of type "name". +// Parameters: +// document - Handle to the loaded document. +// key - Name of the key in the viewer pref dictionary, +// encoded in UTF-8. +// buffer - A string to write the contents of the key to. +// length - Length of the buffer. +// Return value: +// The number of bytes in the contents, including the NULL terminator. +// Thus if the return value is 0, then that indicates an error, such +// as when |document| is invalid or |buffer| is NULL. If |length| is +// less than the returned length, or |buffer| is NULL, |buffer| will +// not be modified. +FPDF_EXPORT unsigned long FPDF_CALLCONV +FPDF_VIEWERREF_GetName(FPDF_DOCUMENT document, + FPDF_BYTESTRING key, + char* buffer, + unsigned long length); + // Function: FPDF_CountNamedDests // Get the count of named destinations in the PDF document. // Parameters: // document - Handle to a document // Return value: // The count of named destinations. -DLLEXPORT FPDF_DWORD STDCALL FPDF_CountNamedDests(FPDF_DOCUMENT document); +FPDF_EXPORT FPDF_DWORD FPDF_CALLCONV +FPDF_CountNamedDests(FPDF_DOCUMENT document); // Function: FPDF_GetNamedDestByName // Get a the destination handle for the given name. @@ -889,8 +1213,8 @@ DLLEXPORT FPDF_DWORD STDCALL FPDF_CountNamedDests(FPDF_DOCUMENT document); // name - The name of a destination. // Return value: // The handle to the destination. -DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDestByName(FPDF_DOCUMENT document, - FPDF_BYTESTRING name); +FPDF_EXPORT FPDF_DEST FPDF_CALLCONV +FPDF_GetNamedDestByName(FPDF_DOCUMENT document, FPDF_BYTESTRING name); // Function: FPDF_GetNamedDest // Get the named destination by index. @@ -913,25 +1237,38 @@ DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDestByName(FPDF_DOCUMENT document, // // If buflen is not sufficiently large, it will be set to -1 upon // return. -DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDest(FPDF_DOCUMENT document, - int index, - void* buffer, - long* buflen); +FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDF_GetNamedDest(FPDF_DOCUMENT document, + int index, + void* buffer, + long* buflen); + +#ifdef PDF_ENABLE_V8 +// Function: FPDF_GetRecommendedV8Flags +// Returns a space-separated string of command line flags that are +// recommended to be passed into V8 via V8::SetFlagsFromString() +// prior to initializing the PDFium library. +// Parameters: +// None. +// Return value: +// NUL-terminated string of the form "--flag1 --flag2". +// The caller must not attempt to modify or free the result. +FPDF_EXPORT const char* FPDF_CALLCONV FPDF_GetRecommendedV8Flags(); +#endif // PDF_ENABLE_V8 #ifdef PDF_ENABLE_XFA // Function: FPDF_BStr_Init -// Helper function to initialize a byte string. -DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Init(FPDF_BSTR* str); +// Helper function to initialize a FPDF_BSTR. +FPDF_EXPORT FPDF_RESULT FPDF_CALLCONV FPDF_BStr_Init(FPDF_BSTR* bstr); // Function: FPDF_BStr_Set -// Helper function to set string data. -DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Set(FPDF_BSTR* str, - FPDF_LPCSTR bstr, - int length); +// Helper function to copy string data into the FPDF_BSTR. +FPDF_EXPORT FPDF_RESULT FPDF_CALLCONV FPDF_BStr_Set(FPDF_BSTR* bstr, + const char* cstr, + int length); // Function: FPDF_BStr_Clear -// Helper function to clear a byte string. -DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Clear(FPDF_BSTR* str); +// Helper function to clear a FPDF_BSTR. +FPDF_EXPORT FPDF_RESULT FPDF_CALLCONV FPDF_BStr_Clear(FPDF_BSTR* bstr); #endif // PDF_ENABLE_XFA #ifdef __cplusplus diff --git a/src/main/jni/lib/arm64-v8a/libc++_shared.so b/src/main/jni/lib/arm64-v8a/libc++_shared.so deleted file mode 100755 index 562430e3833389aef5d411df5055184b8abd9113..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1282687 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%0Dv$xXvpm;5}`ItzKJrgSeFHCE>On6^m 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%0Dx%Pad`Yy5;%g=-EUM&Cl(B(T4 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

pI%loc8xi~iU5erkSPsKw-sk(*cw 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 z%0A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±1nZzay^Kx8Swb`Z>3i%I*AQ z1>c$5aWin#hFtCOALW!Fl)|JY&t<8(mK2^8PJc?kV8BFAZO}c?F#J5#sh;^$POIY;5+29l(pN zb>KDNrPewp1Ct92iEU=4f#}C=VjM{^FD!{@X3Ie zuSk(_JQdfH5ASQIhNu5?EqJ?izvEHxhVN;9D2D!B@M5%AF8E6A{ZtE3?v~e+|DZL`M8SE#FCH&< zfZNwGR=9zD#xRa%;9m$ni0fd5;3tE(d`}TJg7wIL@+sKFaDGDLZYVfEvjvfXtx}Wk8qv^xj@OJWvTIF5< zUX9~s4E{^Nc|U*7^LBTTPb$wm{vHm_`+nr(xYG^ZJV}`;fd8A!t^CaHBL8k&C&`C? zU+@-OpA3ROsJK2(72`Nn2R;IQB!}kn0Qg3Cl7EqP9ra>xet(~$Ro-`zzQ)qmg7f~v z9A__h8s~A`?jM8melIHXv%vixrVAH@2n0HySU^S-{-;442sKD>Ws0{kHGB<2D3 zISZWkNuGxOMeu?nD9&<>)3OK2|Mz{E!7lv@tdz#HGCcISC`MfE>A z&sBJCA%=J^0&l@}-D2?9!FiwRQt-7OBA=!?W1^X`sk68138oXj}${W{r(?`jN_f=NQ75}FRocGmH&EfyN1>TPHLGBL= z9wVQbOUR$&+!(wH_oGAbIRLx^*Lykso56V>p(ylUgD0%xMd)!Vm-or!d8`4v#md8r z;Jhy`$GKWR`S89#^(eO-x+i(DQzYA;j}D^!z?i1^5O7s202s&$l$f=U(tS^eZm+HSk<(TyOOZ`Nu7OHTduQq|KrNJ_4^ihDJ&i z_@ZaYr@`{M5WF{Ju3Mf}+`m4C_p|a4|NGF_V_n4YZ#)Qp>p76U!P8Tec^)ru@IgGk z#6ItXm*RR0_qSc2BmXhn-{*Otk$FDNR|SZ306aWx9v`=Po_t2F`w_L^{5>*`=Wg&q zTt{V|`vUpY;k<)t=Xr;MXCV(<-%G%2K1V!gmoaeuE(6CO9zvX}QN2Q_*Tvw2*8Pzl z@F8m*@&$Mfj{6+{ycfwoj(*Gh@8HFlZ*#d^@O+&AmVn<5KGT5ygL=IO&iiJ!Kwt0@ zm0OGa^KtDoaQ?1AKlCqy&sgsk%cj;W8aQ>eFAGhxJtujnL{m2iu zpFAkE94&mXaD`dM{(W}WFPR_J1G9j1@spsuaZv* z;>>~mNbvfDC{E_jf>&ABMZaYq9GAJ=#jlY+??1+Iz6;LZ%WFls>!(QXeYJv5n!!uK z`MZZ4PaJ$YkK*M1_M+nYe(|VvzxdzK2d(R?+q_QY@^{TR&a=SzyLcSW0C@Xzq>LfX z|A6y%nmC@aH&Cw)vwbD^!|TBLy>+hFbKtz+CilaQ-_-R|@3F49lJB!R%H2(Iy)Ny> z{K@fO4qjtj$M^<3_X!$bJP&U)LOw)@_k(v#QT*JFKZEo4bfVBlN2y%?4iv}P1fb?+CQOCk0+_9go&rLgn^vK=Vl_^yT3E z{R{5TE#R5&DG$xizXi_wigTRny-WU0xF6jMeHc8?8oyVAdr=%OpnnZ~7}t}zUGm1r zpZE9XIR638-*F4U=TUIphnao6_sC~zCd*gOK)*9Me@BV+w}Hp3`SuO)LhJbc8~7mZ ze>K8?>-VYLx)&(_-3#e2{tnLjZ20{?-cqICw7BA)L?o zACv#+wUnPK=(hkLv5u#Qfsa*Fy*NKz;QXBha`U|3zZslzbQZ5A5!3T7%$wPvpz-sF;2O@`+|>I z$M?MkmpKrMvoWCcPgg#3pM30LhYkhST zc!Tv^#1-JYKMWtIo&b-oNd1uWw#w(^&)*T?IAh=;oWB6UHQ%oFAM!6wneDqXIDZeT5^-J)UULl9m+SQ)IDgkH2lK{n z;9;wO7EV&RB_{@a=i(KpfZM_OeQ^3)&$}0#zt711Y6iRs^DXCRoiEA1WksqN_s?U% z8}Xb;4eE6TcpdJ4u}=?pv30)i8aRJPcp5&N|Ch=Q>_z4Bb96_6hp=AiL*fR(8`>zJ z?eHo3ihOu~d(Oix;FZ?>+}sT5gJ)2=tltlO5dDqwb~1RYb$)#@O!n!^d1D~<358MjQ`^=Xjo=I^2UM9~UCv9>ycr_hfMXE?yVP zeT99B=s3&z^}Zv2{{9g^mvRnx64#Mx;qx+h)@f8PwTSe8W`9pU_IhJOaQ=QY`&lZt>*!51|Pk|oKKzrkN%T*Gkhk&`MW=y|81se z{S!K1zOSr+{y@d`JfA^-=KjzOUSW-+C&78&`#Sh6{E^Pr($@Q5n=7vUJKvn+D`U`~ z51z*HF&F$HaQ>c72z=I0v_3F z;2pS*%Jr=W4_U|G7Zlg$cRhG6JrCu634Jb(N8E4MQfl4bhJU1X=ls`#^Y>K?;Bz1A zao@8KeAQXxQ-I@REqD~1zr)4xbb;qu*B^3b!w2hs&dMmrn41gEv{_mSm9+e?O%h`WwJA&(l0s0RAL+64#S?{C)-A zZaw!^vLgBO_kuakSAyqT@3FoFo@r{uii5zx#j(a2=)w`M(N03V$A7UxVjZ_Z<$NPyYO! zZZ5YAoWG~c<^BrJ-vwj+9xIa%e`k~VKfyT;tn18$3&^Ku360Ys=nnv| zv7Qfa1~0IDK2qGjUW$GH7QrW5EwFVy+xsY=+)oY#kGxEArlG$ay!;iDKLy@lJ%>CB z-fgw-whO7;hTExL8Tg+A9)6M{X$F4@ywF-t{s`V<9S5scA^)(oK6wH>lBN?T9!D>M zPmNH$N>J_uc+!f0k5$Rven0&vaQ+?~xBCO&11nK|x!e!Ii*bFR73I!VC*b%GE#S0n#!%#&r%H!u&v&s(Pvd-w^H8I>?w{VT=M(FvwMO`R&7`)Fqjs(}Ba(TbOYUob{ zZ=FT?ZwLPzJh}$)KJb0>$Y{J_e+ACp_2z!K=h{?mu{EFE2F~9@ zkHUW%yvsU{tfL+v)ctlW-<&7aY_Jae-=cbPzdas& z^ad)o9{!!+gIJexzx@il%DSJJy)OAjFfMA~vl;lnqqLr6pVJlB^~&J=6wdQi(AVO) z%>DmGU$6G5w)Qjmg7tS$|KavEIUbN(aH4_Nnk7lg=%zhl(_ zpJTvh_NBa0Rz0s1JpU0Q9RCD(WPo@x=VyKLAIJ4Q9(VVFPj6-Ve-1wLGWl@cw%mYx zlGeCu1?TU*a{foaqgFrJY7zMqwNtt5e>C{uV^nTF;(q{~zi-R_KZ5i3`f$-f)VX%vHB4&JvG^>cN&_kW%PA9#j1 zkKak~LTg-aQ$+JgkM%zLev0e)oWIw`d3XuD)fz_&HzWP%4D~=R_aN|A90xfMo#2J< zkbVI5T48hY;qOJN<)#0#ANZivZ=V70z`8L6pZ|hqEi~t!jkh5GP@)^jo?#pF{skNn5sbFAWee&&6)dHzX2--qJ}`!50aexdbh6MTLGpTTuw&gWmZ zq;e;%_0>7x1IPpW-wfVst#e)lAGOBOT3eBSho#>Qe0mjf=6LGB`>ge|x+AZC=6cCN z+_*r!hLnC4{QuIw-c)=8)!(u@DW6%h>2K$5t@Qz~=TK^w8vLUg@a~l<9_FVgu6>$t zd@qH5418cs@{faWS~AO9Uq5FuL+jEl!2eHiU2frTG)`NT`rqdPU!UvM_fokS zF5X?xw>(7o;ePlM_#pZl$N7WrqtjpLuJfD;Q9e1IGoWu+ zV75yFoWB>4gwI3p>BfCw`d6O!k>U&0KC5+By?%wh2Jc^UKiuZe6ldxN$`A7c!1Ds+ z%>GS^FI3|+wJX&(gm}(ZT-U4Dx~}*Tc$Xa~{M&IJ%I!P5RQD@&-7-S{e05EJ#kGIp99p-OVLE;nKKwn$H1fYm8THS|NoGI!tK!8-upgZ;Dy3wxl_}|FH}FZSek& z$zd9?&e=uB^S?hiifjKVT%WIp&)62`rc>7d931kos<5V^0Ou4xd}c~Pf&jt0-s+_ z@!RdY4S3lP6n{DNm4f~x#dVyiR*JI#`gZ7J`w)+VKcTpe|8^_>LGY(7{<80bf4tPM zH{l<6o7$1{|D*4-z>8IwdERt)sxN