1pub const FPDF_OBJECT_UNKNOWN: u32 = 0;
4pub const FPDF_OBJECT_BOOLEAN: u32 = 1;
5pub const FPDF_OBJECT_NUMBER: u32 = 2;
6pub const FPDF_OBJECT_STRING: u32 = 3;
7pub const FPDF_OBJECT_NAME: u32 = 4;
8pub const FPDF_OBJECT_ARRAY: u32 = 5;
9pub const FPDF_OBJECT_DICTIONARY: u32 = 6;
10pub const FPDF_OBJECT_STREAM: u32 = 7;
11pub const FPDF_OBJECT_NULLOBJ: u32 = 8;
12pub const FPDF_OBJECT_REFERENCE: u32 = 9;
13pub const FPDF_POLICY_MACHINETIME_ACCESS: u32 = 0;
14pub const FPDF_ERR_SUCCESS: u32 = 0;
15pub const FPDF_ERR_UNKNOWN: u32 = 1;
16pub const FPDF_ERR_FILE: u32 = 2;
17pub const FPDF_ERR_FORMAT: u32 = 3;
18pub const FPDF_ERR_PASSWORD: u32 = 4;
19pub const FPDF_ERR_SECURITY: u32 = 5;
20pub const FPDF_ERR_PAGE: u32 = 6;
21pub const FPDF_ERR_XFALOAD: u32 = 7;
22pub const FPDF_ERR_XFALAYOUT: u32 = 8;
23pub const FPDF_ANNOT: u32 = 1;
24pub const FPDF_LCD_TEXT: u32 = 2;
25pub const FPDF_NO_NATIVETEXT: u32 = 4;
26pub const FPDF_GRAYSCALE: u32 = 8;
27pub const FPDF_DEBUG_INFO: u32 = 128;
28pub const FPDF_NO_CATCH: u32 = 256;
29pub const FPDF_RENDER_LIMITEDIMAGECACHE: u32 = 512;
30pub const FPDF_RENDER_FORCEHALFTONE: u32 = 1024;
31pub const FPDF_PRINTING: u32 = 2048;
32pub const FPDF_RENDER_NO_SMOOTHTEXT: u32 = 4096;
33pub const FPDF_RENDER_NO_SMOOTHIMAGE: u32 = 8192;
34pub const FPDF_RENDER_NO_SMOOTHPATH: u32 = 16384;
35pub const FPDF_REVERSE_BYTE_ORDER: u32 = 16;
36pub const FPDF_CONVERT_FILL_TO_STROKE: u32 = 32;
37pub const FPDFBitmap_Unknown: u32 = 0;
38pub const FPDFBitmap_Gray: u32 = 1;
39pub const FPDFBitmap_BGR: u32 = 2;
40pub const FPDFBitmap_BGRx: u32 = 3;
41pub const FPDFBitmap_BGRA: u32 = 4;
42pub const FPDFBitmap_BGRA_Premul: u32 = 5;
43pub const FPDF_RENDER_READY: u32 = 0;
44pub const FPDF_RENDER_TOBECONTINUED: u32 = 1;
45pub const FPDF_RENDER_DONE: u32 = 2;
46pub const FPDF_RENDER_FAILED: u32 = 3;
47pub const PDF_LINEARIZATION_UNKNOWN: i32 = -1;
48pub const PDF_NOT_LINEARIZED: u32 = 0;
49pub const PDF_LINEARIZED: u32 = 1;
50pub const PDF_DATA_ERROR: i32 = -1;
51pub const PDF_DATA_NOTAVAIL: u32 = 0;
52pub const PDF_DATA_AVAIL: u32 = 1;
53pub const PDF_FORM_ERROR: i32 = -1;
54pub const PDF_FORM_NOTAVAIL: u32 = 0;
55pub const PDF_FORM_AVAIL: u32 = 1;
56pub const PDF_FORM_NOTEXIST: u32 = 2;
57pub const _STDINT_H: u32 = 1;
58pub const _FEATURES_H: u32 = 1;
59pub const _DEFAULT_SOURCE: u32 = 1;
60pub const __GLIBC_USE_ISOC2Y: u32 = 0;
61pub const __GLIBC_USE_ISOC23: u32 = 0;
62pub const __USE_ISOC11: u32 = 1;
63pub const __USE_ISOC99: u32 = 1;
64pub const __USE_ISOC95: u32 = 1;
65pub const __USE_POSIX_IMPLICITLY: u32 = 1;
66pub const _POSIX_SOURCE: u32 = 1;
67pub const _POSIX_C_SOURCE: u32 = 202405;
68pub const __USE_POSIX: u32 = 1;
69pub const __USE_POSIX2: u32 = 1;
70pub const __USE_POSIX199309: u32 = 1;
71pub const __USE_POSIX199506: u32 = 1;
72pub const __USE_XOPEN2K: u32 = 1;
73pub const __USE_XOPEN2K8: u32 = 1;
74pub const _ATFILE_SOURCE: u32 = 1;
75pub const __USE_XOPEN2K24: u32 = 1;
76pub const __WORDSIZE: u32 = 64;
77pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
78pub const __SYSCALL_WORDSIZE: u32 = 64;
79pub const __TIMESIZE: u32 = 64;
80pub const __USE_TIME_BITS64: u32 = 1;
81pub const __USE_MISC: u32 = 1;
82pub const __USE_ATFILE: u32 = 1;
83pub const __USE_FORTIFY_LEVEL: u32 = 0;
84pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
85pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
86pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
87pub const _STDC_PREDEF_H: u32 = 1;
88pub const __STDC_IEC_559__: u32 = 1;
89pub const __STDC_IEC_60559_BFP__: u32 = 201404;
90pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
91pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
92pub const __STDC_ISO_10646__: u32 = 201706;
93pub const __GNU_LIBRARY__: u32 = 6;
94pub const __GLIBC__: u32 = 2;
95pub const __GLIBC_MINOR__: u32 = 43;
96pub const _SYS_CDEFS_H: u32 = 1;
97pub const __glibc_c99_flexarr_available: u32 = 1;
98pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
99pub const __HAVE_GENERIC_SELECTION: u32 = 1;
100pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
101pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
102pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
103pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
104pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
105pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
106pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
107pub const _BITS_TYPES_H: u32 = 1;
108pub const _BITS_TYPESIZES_H: u32 = 1;
109pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
110pub const __INO_T_MATCHES_INO64_T: u32 = 1;
111pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
112pub const __STATFS_MATCHES_STATFS64: u32 = 1;
113pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
114pub const __FD_SETSIZE: u32 = 1024;
115pub const _BITS_TIME64_H: u32 = 1;
116pub const _BITS_WCHAR_H: u32 = 1;
117pub const _BITS_STDINT_INTN_H: u32 = 1;
118pub const _BITS_STDINT_UINTN_H: u32 = 1;
119pub const _BITS_STDINT_LEAST_H: u32 = 1;
120pub const INT8_MIN: i32 = -128;
121pub const INT16_MIN: i32 = -32768;
122pub const INT32_MIN: i32 = -2147483648;
123pub const INT8_MAX: u32 = 127;
124pub const INT16_MAX: u32 = 32767;
125pub const INT32_MAX: u32 = 2147483647;
126pub const UINT8_MAX: u32 = 255;
127pub const UINT16_MAX: u32 = 65535;
128pub const UINT32_MAX: u32 = 4294967295;
129pub const INT_LEAST8_MIN: i32 = -128;
130pub const INT_LEAST16_MIN: i32 = -32768;
131pub const INT_LEAST32_MIN: i32 = -2147483648;
132pub const INT_LEAST8_MAX: u32 = 127;
133pub const INT_LEAST16_MAX: u32 = 32767;
134pub const INT_LEAST32_MAX: u32 = 2147483647;
135pub const UINT_LEAST8_MAX: u32 = 255;
136pub const UINT_LEAST16_MAX: u32 = 65535;
137pub const UINT_LEAST32_MAX: u32 = 4294967295;
138pub const INT_FAST8_MIN: i32 = -128;
139pub const INT_FAST16_MIN: i64 = -9223372036854775808;
140pub const INT_FAST32_MIN: i64 = -9223372036854775808;
141pub const INT_FAST8_MAX: u32 = 127;
142pub const INT_FAST16_MAX: u64 = 9223372036854775807;
143pub const INT_FAST32_MAX: u64 = 9223372036854775807;
144pub const UINT_FAST8_MAX: u32 = 255;
145pub const UINT_FAST16_MAX: i32 = -1;
146pub const UINT_FAST32_MAX: i32 = -1;
147pub const INTPTR_MIN: i64 = -9223372036854775808;
148pub const INTPTR_MAX: u64 = 9223372036854775807;
149pub const UINTPTR_MAX: i32 = -1;
150pub const PTRDIFF_MIN: i64 = -9223372036854775808;
151pub const PTRDIFF_MAX: u64 = 9223372036854775807;
152pub const SIG_ATOMIC_MIN: i32 = -2147483648;
153pub const SIG_ATOMIC_MAX: u32 = 2147483647;
154pub const SIZE_MAX: i32 = -1;
155pub const WINT_MIN: u32 = 0;
156pub const WINT_MAX: u32 = 4294967295;
157pub const FXFONT_ANSI_CHARSET: u32 = 0;
158pub const FXFONT_DEFAULT_CHARSET: u32 = 1;
159pub const FXFONT_SYMBOL_CHARSET: u32 = 2;
160pub const FXFONT_SHIFTJIS_CHARSET: u32 = 128;
161pub const FXFONT_HANGEUL_CHARSET: u32 = 129;
162pub const FXFONT_GB2312_CHARSET: u32 = 134;
163pub const FXFONT_CHINESEBIG5_CHARSET: u32 = 136;
164pub const FXFONT_GREEK_CHARSET: u32 = 161;
165pub const FXFONT_VIETNAMESE_CHARSET: u32 = 163;
166pub const FXFONT_HEBREW_CHARSET: u32 = 177;
167pub const FXFONT_ARABIC_CHARSET: u32 = 178;
168pub const FXFONT_CYRILLIC_CHARSET: u32 = 204;
169pub const FXFONT_THAI_CHARSET: u32 = 222;
170pub const FXFONT_EASTERNEUROPEAN_CHARSET: u32 = 238;
171pub const FXFONT_FF_FIXEDPITCH: u32 = 1;
172pub const FXFONT_FF_ROMAN: u32 = 16;
173pub const FXFONT_FF_SCRIPT: u32 = 64;
174pub const FXFONT_FW_NORMAL: u32 = 400;
175pub const FXFONT_FW_BOLD: u32 = 700;
176pub const FPDF_MATCHCASE: u32 = 1;
177pub const FPDF_MATCHWHOLEWORD: u32 = 2;
178pub const FPDF_CONSECUTIVE: u32 = 4;
179pub const FPDF_COLORSPACE_UNKNOWN: u32 = 0;
180pub const FPDF_COLORSPACE_DEVICEGRAY: u32 = 1;
181pub const FPDF_COLORSPACE_DEVICERGB: u32 = 2;
182pub const FPDF_COLORSPACE_DEVICECMYK: u32 = 3;
183pub const FPDF_COLORSPACE_CALGRAY: u32 = 4;
184pub const FPDF_COLORSPACE_CALRGB: u32 = 5;
185pub const FPDF_COLORSPACE_LAB: u32 = 6;
186pub const FPDF_COLORSPACE_ICCBASED: u32 = 7;
187pub const FPDF_COLORSPACE_SEPARATION: u32 = 8;
188pub const FPDF_COLORSPACE_DEVICEN: u32 = 9;
189pub const FPDF_COLORSPACE_INDEXED: u32 = 10;
190pub const FPDF_COLORSPACE_PATTERN: u32 = 11;
191pub const FPDF_PAGEOBJ_UNKNOWN: u32 = 0;
192pub const FPDF_PAGEOBJ_TEXT: u32 = 1;
193pub const FPDF_PAGEOBJ_PATH: u32 = 2;
194pub const FPDF_PAGEOBJ_IMAGE: u32 = 3;
195pub const FPDF_PAGEOBJ_SHADING: u32 = 4;
196pub const FPDF_PAGEOBJ_FORM: u32 = 5;
197pub const FPDF_SEGMENT_UNKNOWN: i32 = -1;
198pub const FPDF_SEGMENT_LINETO: u32 = 0;
199pub const FPDF_SEGMENT_BEZIERTO: u32 = 1;
200pub const FPDF_SEGMENT_MOVETO: u32 = 2;
201pub const FPDF_FILLMODE_NONE: u32 = 0;
202pub const FPDF_FILLMODE_ALTERNATE: u32 = 1;
203pub const FPDF_FILLMODE_WINDING: u32 = 2;
204pub const FPDF_FONT_TYPE1: u32 = 1;
205pub const FPDF_FONT_TRUETYPE: u32 = 2;
206pub const FPDF_LINECAP_BUTT: u32 = 0;
207pub const FPDF_LINECAP_ROUND: u32 = 1;
208pub const FPDF_LINECAP_PROJECTING_SQUARE: u32 = 2;
209pub const FPDF_LINEJOIN_MITER: u32 = 0;
210pub const FPDF_LINEJOIN_ROUND: u32 = 1;
211pub const FPDF_LINEJOIN_BEVEL: u32 = 2;
212pub const FPDF_PRINTMODE_EMF: u32 = 0;
213pub const FPDF_PRINTMODE_TEXTONLY: u32 = 1;
214pub const FPDF_PRINTMODE_POSTSCRIPT2: u32 = 2;
215pub const FPDF_PRINTMODE_POSTSCRIPT3: u32 = 3;
216pub const FPDF_PRINTMODE_POSTSCRIPT2_PASSTHROUGH: u32 = 4;
217pub const FPDF_PRINTMODE_POSTSCRIPT3_PASSTHROUGH: u32 = 5;
218pub const FPDF_PRINTMODE_EMF_IMAGE_MASKS: u32 = 6;
219pub const FPDF_PRINTMODE_POSTSCRIPT3_TYPE42: u32 = 7;
220pub const FPDF_PRINTMODE_POSTSCRIPT3_TYPE42_PASSTHROUGH: u32 = 8;
221pub const FLATTEN_FAIL: u32 = 0;
222pub const FLATTEN_SUCCESS: u32 = 1;
223pub const FLATTEN_NOTHINGTODO: u32 = 2;
224pub const FLAT_NORMALDISPLAY: u32 = 0;
225pub const FLAT_PRINT: u32 = 1;
226pub const _TIME_H: u32 = 1;
227pub const _BITS_TIME_H: u32 = 1;
228pub const CLOCK_REALTIME: u32 = 0;
229pub const CLOCK_MONOTONIC: u32 = 1;
230pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2;
231pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3;
232pub const CLOCK_MONOTONIC_RAW: u32 = 4;
233pub const CLOCK_REALTIME_COARSE: u32 = 5;
234pub const CLOCK_MONOTONIC_COARSE: u32 = 6;
235pub const CLOCK_BOOTTIME: u32 = 7;
236pub const CLOCK_REALTIME_ALARM: u32 = 8;
237pub const CLOCK_BOOTTIME_ALARM: u32 = 9;
238pub const CLOCK_TAI: u32 = 11;
239pub const TIMER_ABSTIME: u32 = 1;
240pub const __clock_t_defined: u32 = 1;
241pub const __time_t_defined: u32 = 1;
242pub const __struct_tm_defined: u32 = 1;
243pub const _STRUCT_TIMESPEC: u32 = 1;
244pub const _BITS_ENDIAN_H: u32 = 1;
245pub const __LITTLE_ENDIAN: u32 = 1234;
246pub const __BIG_ENDIAN: u32 = 4321;
247pub const __PDP_ENDIAN: u32 = 3412;
248pub const _BITS_ENDIANNESS_H: u32 = 1;
249pub const __BYTE_ORDER: u32 = 1234;
250pub const __FLOAT_WORD_ORDER: u32 = 1234;
251pub const __clockid_t_defined: u32 = 1;
252pub const __timer_t_defined: u32 = 1;
253pub const __itimerspec_defined: u32 = 1;
254pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
255pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
256pub const TIME_UTC: u32 = 1;
257pub const FPDF_UNSP_DOC_XFAFORM: u32 = 1;
258pub const FPDF_UNSP_DOC_PORTABLECOLLECTION: u32 = 2;
259pub const FPDF_UNSP_DOC_ATTACHMENT: u32 = 3;
260pub const FPDF_UNSP_DOC_SECURITY: u32 = 4;
261pub const FPDF_UNSP_DOC_SHAREDREVIEW: u32 = 5;
262pub const FPDF_UNSP_DOC_SHAREDFORM_ACROBAT: u32 = 6;
263pub const FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM: u32 = 7;
264pub const FPDF_UNSP_DOC_SHAREDFORM_EMAIL: u32 = 8;
265pub const FPDF_UNSP_ANNOT_3DANNOT: u32 = 11;
266pub const FPDF_UNSP_ANNOT_MOVIE: u32 = 12;
267pub const FPDF_UNSP_ANNOT_SOUND: u32 = 13;
268pub const FPDF_UNSP_ANNOT_SCREEN_MEDIA: u32 = 14;
269pub const FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA: u32 = 15;
270pub const FPDF_UNSP_ANNOT_ATTACHMENT: u32 = 16;
271pub const FPDF_UNSP_ANNOT_SIG: u32 = 17;
272pub const PAGEMODE_UNKNOWN: i32 = -1;
273pub const PAGEMODE_USENONE: u32 = 0;
274pub const PAGEMODE_USEOUTLINES: u32 = 1;
275pub const PAGEMODE_USETHUMBS: u32 = 2;
276pub const PAGEMODE_FULLSCREEN: u32 = 3;
277pub const PAGEMODE_USEOC: u32 = 4;
278pub const PAGEMODE_USEATTACHMENTS: u32 = 5;
279pub const FORMTYPE_NONE: u32 = 0;
280pub const FORMTYPE_ACRO_FORM: u32 = 1;
281pub const FORMTYPE_XFA_FULL: u32 = 2;
282pub const FORMTYPE_XFA_FOREGROUND: u32 = 3;
283pub const FORMTYPE_COUNT: u32 = 4;
284pub const JSPLATFORM_ALERT_BUTTON_OK: u32 = 0;
285pub const JSPLATFORM_ALERT_BUTTON_OKCANCEL: u32 = 1;
286pub const JSPLATFORM_ALERT_BUTTON_YESNO: u32 = 2;
287pub const JSPLATFORM_ALERT_BUTTON_YESNOCANCEL: u32 = 3;
288pub const JSPLATFORM_ALERT_BUTTON_DEFAULT: u32 = 0;
289pub const JSPLATFORM_ALERT_ICON_ERROR: u32 = 0;
290pub const JSPLATFORM_ALERT_ICON_WARNING: u32 = 1;
291pub const JSPLATFORM_ALERT_ICON_QUESTION: u32 = 2;
292pub const JSPLATFORM_ALERT_ICON_STATUS: u32 = 3;
293pub const JSPLATFORM_ALERT_ICON_ASTERISK: u32 = 4;
294pub const JSPLATFORM_ALERT_ICON_DEFAULT: u32 = 0;
295pub const JSPLATFORM_ALERT_RETURN_OK: u32 = 1;
296pub const JSPLATFORM_ALERT_RETURN_CANCEL: u32 = 2;
297pub const JSPLATFORM_ALERT_RETURN_NO: u32 = 3;
298pub const JSPLATFORM_ALERT_RETURN_YES: u32 = 4;
299pub const JSPLATFORM_BEEP_ERROR: u32 = 0;
300pub const JSPLATFORM_BEEP_WARNING: u32 = 1;
301pub const JSPLATFORM_BEEP_QUESTION: u32 = 2;
302pub const JSPLATFORM_BEEP_STATUS: u32 = 3;
303pub const JSPLATFORM_BEEP_DEFAULT: u32 = 4;
304pub const FXCT_ARROW: u32 = 0;
305pub const FXCT_NESW: u32 = 1;
306pub const FXCT_NWSE: u32 = 2;
307pub const FXCT_VBEAM: u32 = 3;
308pub const FXCT_HBEAM: u32 = 4;
309pub const FXCT_HAND: u32 = 5;
310pub const FXFA_PAGEVIEWEVENT_POSTADDED: u32 = 1;
311pub const FXFA_PAGEVIEWEVENT_POSTREMOVED: u32 = 3;
312pub const FXFA_MENU_COPY: u32 = 1;
313pub const FXFA_MENU_CUT: u32 = 2;
314pub const FXFA_MENU_SELECTALL: u32 = 4;
315pub const FXFA_MENU_UNDO: u32 = 8;
316pub const FXFA_MENU_REDO: u32 = 16;
317pub const FXFA_MENU_PASTE: u32 = 32;
318pub const FXFA_SAVEAS_XML: u32 = 1;
319pub const FXFA_SAVEAS_XDP: u32 = 2;
320pub const FPDFDOC_AACTION_WC: u32 = 16;
321pub const FPDFDOC_AACTION_WS: u32 = 17;
322pub const FPDFDOC_AACTION_DS: u32 = 18;
323pub const FPDFDOC_AACTION_WP: u32 = 19;
324pub const FPDFDOC_AACTION_DP: u32 = 20;
325pub const FPDFPAGE_AACTION_OPEN: u32 = 0;
326pub const FPDFPAGE_AACTION_CLOSE: u32 = 1;
327pub const FPDF_FORMFIELD_UNKNOWN: u32 = 0;
328pub const FPDF_FORMFIELD_PUSHBUTTON: u32 = 1;
329pub const FPDF_FORMFIELD_CHECKBOX: u32 = 2;
330pub const FPDF_FORMFIELD_RADIOBUTTON: u32 = 3;
331pub const FPDF_FORMFIELD_COMBOBOX: u32 = 4;
332pub const FPDF_FORMFIELD_LISTBOX: u32 = 5;
333pub const FPDF_FORMFIELD_TEXTFIELD: u32 = 6;
334pub const FPDF_FORMFIELD_SIGNATURE: u32 = 7;
335pub const FPDF_FORMFIELD_XFA: u32 = 8;
336pub const FPDF_FORMFIELD_XFA_CHECKBOX: u32 = 9;
337pub const FPDF_FORMFIELD_XFA_COMBOBOX: u32 = 10;
338pub const FPDF_FORMFIELD_XFA_IMAGEFIELD: u32 = 11;
339pub const FPDF_FORMFIELD_XFA_LISTBOX: u32 = 12;
340pub const FPDF_FORMFIELD_XFA_PUSHBUTTON: u32 = 13;
341pub const FPDF_FORMFIELD_XFA_SIGNATURE: u32 = 14;
342pub const FPDF_FORMFIELD_XFA_TEXTFIELD: u32 = 15;
343pub const FPDF_FORMFIELD_COUNT: u32 = 16;
344pub const FPDF_ANNOT_UNKNOWN: u32 = 0;
345pub const FPDF_ANNOT_TEXT: u32 = 1;
346pub const FPDF_ANNOT_LINK: u32 = 2;
347pub const FPDF_ANNOT_FREETEXT: u32 = 3;
348pub const FPDF_ANNOT_LINE: u32 = 4;
349pub const FPDF_ANNOT_SQUARE: u32 = 5;
350pub const FPDF_ANNOT_CIRCLE: u32 = 6;
351pub const FPDF_ANNOT_POLYGON: u32 = 7;
352pub const FPDF_ANNOT_POLYLINE: u32 = 8;
353pub const FPDF_ANNOT_HIGHLIGHT: u32 = 9;
354pub const FPDF_ANNOT_UNDERLINE: u32 = 10;
355pub const FPDF_ANNOT_SQUIGGLY: u32 = 11;
356pub const FPDF_ANNOT_STRIKEOUT: u32 = 12;
357pub const FPDF_ANNOT_STAMP: u32 = 13;
358pub const FPDF_ANNOT_CARET: u32 = 14;
359pub const FPDF_ANNOT_INK: u32 = 15;
360pub const FPDF_ANNOT_POPUP: u32 = 16;
361pub const FPDF_ANNOT_FILEATTACHMENT: u32 = 17;
362pub const FPDF_ANNOT_SOUND: u32 = 18;
363pub const FPDF_ANNOT_MOVIE: u32 = 19;
364pub const FPDF_ANNOT_WIDGET: u32 = 20;
365pub const FPDF_ANNOT_SCREEN: u32 = 21;
366pub const FPDF_ANNOT_PRINTERMARK: u32 = 22;
367pub const FPDF_ANNOT_TRAPNET: u32 = 23;
368pub const FPDF_ANNOT_WATERMARK: u32 = 24;
369pub const FPDF_ANNOT_THREED: u32 = 25;
370pub const FPDF_ANNOT_RICHMEDIA: u32 = 26;
371pub const FPDF_ANNOT_XFAWIDGET: u32 = 27;
372pub const FPDF_ANNOT_REDACT: u32 = 28;
373pub const FPDF_ANNOT_FLAG_NONE: u32 = 0;
374pub const FPDF_ANNOT_FLAG_INVISIBLE: u32 = 1;
375pub const FPDF_ANNOT_FLAG_HIDDEN: u32 = 2;
376pub const FPDF_ANNOT_FLAG_PRINT: u32 = 4;
377pub const FPDF_ANNOT_FLAG_NOZOOM: u32 = 8;
378pub const FPDF_ANNOT_FLAG_NOROTATE: u32 = 16;
379pub const FPDF_ANNOT_FLAG_NOVIEW: u32 = 32;
380pub const FPDF_ANNOT_FLAG_READONLY: u32 = 64;
381pub const FPDF_ANNOT_FLAG_LOCKED: u32 = 128;
382pub const FPDF_ANNOT_FLAG_TOGGLENOVIEW: u32 = 256;
383pub const FPDF_ANNOT_APPEARANCEMODE_NORMAL: u32 = 0;
384pub const FPDF_ANNOT_APPEARANCEMODE_ROLLOVER: u32 = 1;
385pub const FPDF_ANNOT_APPEARANCEMODE_DOWN: u32 = 2;
386pub const FPDF_ANNOT_APPEARANCEMODE_COUNT: u32 = 3;
387pub const FPDF_FORMFLAG_NONE: u32 = 0;
388pub const FPDF_FORMFLAG_READONLY: u32 = 1;
389pub const FPDF_FORMFLAG_REQUIRED: u32 = 2;
390pub const FPDF_FORMFLAG_NOEXPORT: u32 = 4;
391pub const FPDF_FORMFLAG_TEXT_MULTILINE: u32 = 4096;
392pub const FPDF_FORMFLAG_TEXT_PASSWORD: u32 = 8192;
393pub const FPDF_FORMFLAG_CHOICE_COMBO: u32 = 131072;
394pub const FPDF_FORMFLAG_CHOICE_EDIT: u32 = 262144;
395pub const FPDF_FORMFLAG_CHOICE_MULTI_SELECT: u32 = 2097152;
396pub const FPDF_ANNOT_AACTION_KEY_STROKE: u32 = 12;
397pub const FPDF_ANNOT_AACTION_FORMAT: u32 = 13;
398pub const FPDF_ANNOT_AACTION_VALIDATE: u32 = 14;
399pub const FPDF_ANNOT_AACTION_CALCULATE: u32 = 15;
400pub const PDFACTION_UNSUPPORTED: u32 = 0;
401pub const PDFACTION_GOTO: u32 = 1;
402pub const PDFACTION_REMOTEGOTO: u32 = 2;
403pub const PDFACTION_URI: u32 = 3;
404pub const PDFACTION_LAUNCH: u32 = 4;
405pub const PDFACTION_EMBEDDEDGOTO: u32 = 5;
406pub const PDFDEST_VIEW_UNKNOWN_MODE: u32 = 0;
407pub const PDFDEST_VIEW_XYZ: u32 = 1;
408pub const PDFDEST_VIEW_FIT: u32 = 2;
409pub const PDFDEST_VIEW_FITH: u32 = 3;
410pub const PDFDEST_VIEW_FITV: u32 = 4;
411pub const PDFDEST_VIEW_FITR: u32 = 5;
412pub const PDFDEST_VIEW_FITB: u32 = 6;
413pub const PDFDEST_VIEW_FITBH: u32 = 7;
414pub const PDFDEST_VIEW_FITBV: u32 = 8;
415pub const FPDF_INCREMENTAL: u32 = 1;
416pub const FPDF_NO_INCREMENTAL: u32 = 2;
417pub const FPDF_REMOVE_SECURITY_DEPRECATED: u32 = 3;
418pub const FPDF_REMOVE_SECURITY: u32 = 4;
419pub const FPDF_SUBSET_NEW_FONTS: u32 = 8;
420pub type wchar_t = ::std::os::raw::c_int;
421#[doc = " Define 'max_align_t' to match the GCC definition."]
422#[repr(C)]
423#[repr(align(16))]
424#[derive(Debug, Copy, Clone)]
425pub struct max_align_t {
426 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
427 pub __bindgen_padding_0: u64,
428 pub __clang_max_align_nonce2: u128,
429}
430pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_UNKNOWN: FPDF_TEXT_RENDERMODE = -1;
431pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL: FPDF_TEXT_RENDERMODE = 0;
432pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_STROKE: FPDF_TEXT_RENDERMODE = 1;
433pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_STROKE: FPDF_TEXT_RENDERMODE = 2;
434pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_INVISIBLE: FPDF_TEXT_RENDERMODE = 3;
435pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_CLIP: FPDF_TEXT_RENDERMODE = 4;
436pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_STROKE_CLIP: FPDF_TEXT_RENDERMODE = 5;
437pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_STROKE_CLIP: FPDF_TEXT_RENDERMODE = 6;
438pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_CLIP: FPDF_TEXT_RENDERMODE = 7;
439pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_LAST: FPDF_TEXT_RENDERMODE = 7;
440#[doc = " PDF text rendering modes"]
441pub type FPDF_TEXT_RENDERMODE = ::std::os::raw::c_int;
442#[repr(C)]
443#[derive(Debug, Copy, Clone)]
444pub struct fpdf_action_t__ {
445 _unused: [u8; 0],
446}
447#[doc = " PDF types - use incomplete types (never completed) to force API type safety."]
448pub type FPDF_ACTION = *mut fpdf_action_t__;
449#[repr(C)]
450#[derive(Debug, Copy, Clone)]
451pub struct fpdf_annotation_t__ {
452 _unused: [u8; 0],
453}
454pub type FPDF_ANNOTATION = *mut fpdf_annotation_t__;
455#[repr(C)]
456#[derive(Debug, Copy, Clone)]
457pub struct fpdf_attachment_t__ {
458 _unused: [u8; 0],
459}
460pub type FPDF_ATTACHMENT = *mut fpdf_attachment_t__;
461#[repr(C)]
462#[derive(Debug, Copy, Clone)]
463pub struct fpdf_avail_t__ {
464 _unused: [u8; 0],
465}
466pub type FPDF_AVAIL = *mut fpdf_avail_t__;
467#[repr(C)]
468#[derive(Debug, Copy, Clone)]
469pub struct fpdf_bitmap_t__ {
470 _unused: [u8; 0],
471}
472pub type FPDF_BITMAP = *mut fpdf_bitmap_t__;
473#[repr(C)]
474#[derive(Debug, Copy, Clone)]
475pub struct fpdf_bookmark_t__ {
476 _unused: [u8; 0],
477}
478pub type FPDF_BOOKMARK = *mut fpdf_bookmark_t__;
479#[repr(C)]
480#[derive(Debug, Copy, Clone)]
481pub struct fpdf_clippath_t__ {
482 _unused: [u8; 0],
483}
484pub type FPDF_CLIPPATH = *mut fpdf_clippath_t__;
485#[repr(C)]
486#[derive(Debug, Copy, Clone)]
487pub struct fpdf_dest_t__ {
488 _unused: [u8; 0],
489}
490pub type FPDF_DEST = *mut fpdf_dest_t__;
491#[repr(C)]
492#[derive(Debug, Copy, Clone)]
493pub struct fpdf_document_t__ {
494 _unused: [u8; 0],
495}
496pub type FPDF_DOCUMENT = *mut fpdf_document_t__;
497#[repr(C)]
498#[derive(Debug, Copy, Clone)]
499pub struct fpdf_font_t__ {
500 _unused: [u8; 0],
501}
502pub type FPDF_FONT = *mut fpdf_font_t__;
503#[repr(C)]
504#[derive(Debug, Copy, Clone)]
505pub struct fpdf_form_handle_t__ {
506 _unused: [u8; 0],
507}
508pub type FPDF_FORMHANDLE = *mut fpdf_form_handle_t__;
509#[repr(C)]
510#[derive(Debug, Copy, Clone)]
511pub struct fpdf_glyphpath_t__ {
512 _unused: [u8; 0],
513}
514pub type FPDF_GLYPHPATH = *const fpdf_glyphpath_t__;
515#[repr(C)]
516#[derive(Debug, Copy, Clone)]
517pub struct fpdf_javascript_action_t {
518 _unused: [u8; 0],
519}
520pub type FPDF_JAVASCRIPT_ACTION = *mut fpdf_javascript_action_t;
521#[repr(C)]
522#[derive(Debug, Copy, Clone)]
523pub struct fpdf_link_t__ {
524 _unused: [u8; 0],
525}
526pub type FPDF_LINK = *mut fpdf_link_t__;
527#[repr(C)]
528#[derive(Debug, Copy, Clone)]
529pub struct fpdf_page_t__ {
530 _unused: [u8; 0],
531}
532pub type FPDF_PAGE = *mut fpdf_page_t__;
533#[repr(C)]
534#[derive(Debug, Copy, Clone)]
535pub struct fpdf_pagelink_t__ {
536 _unused: [u8; 0],
537}
538pub type FPDF_PAGELINK = *mut fpdf_pagelink_t__;
539#[repr(C)]
540#[derive(Debug, Copy, Clone)]
541pub struct fpdf_pageobject_t__ {
542 _unused: [u8; 0],
543}
544pub type FPDF_PAGEOBJECT = *mut fpdf_pageobject_t__;
545#[repr(C)]
546#[derive(Debug, Copy, Clone)]
547pub struct fpdf_pageobjectmark_t__ {
548 _unused: [u8; 0],
549}
550pub type FPDF_PAGEOBJECTMARK = *mut fpdf_pageobjectmark_t__;
551#[repr(C)]
552#[derive(Debug, Copy, Clone)]
553pub struct fpdf_pagerange_t__ {
554 _unused: [u8; 0],
555}
556pub type FPDF_PAGERANGE = *const fpdf_pagerange_t__;
557#[repr(C)]
558#[derive(Debug, Copy, Clone)]
559pub struct fpdf_pathsegment_t {
560 _unused: [u8; 0],
561}
562pub type FPDF_PATHSEGMENT = *const fpdf_pathsegment_t;
563#[repr(C)]
564#[derive(Debug, Copy, Clone)]
565pub struct fpdf_schhandle_t__ {
566 _unused: [u8; 0],
567}
568pub type FPDF_SCHHANDLE = *mut fpdf_schhandle_t__;
569#[repr(C)]
570#[derive(Debug, Copy, Clone)]
571pub struct fpdf_signature_t__ {
572 _unused: [u8; 0],
573}
574pub type FPDF_SIGNATURE = *const fpdf_signature_t__;
575pub type FPDF_SKIA_CANVAS = *mut ::std::os::raw::c_void;
576#[repr(C)]
577#[derive(Debug, Copy, Clone)]
578pub struct fpdf_structelement_t__ {
579 _unused: [u8; 0],
580}
581pub type FPDF_STRUCTELEMENT = *mut fpdf_structelement_t__;
582#[repr(C)]
583#[derive(Debug, Copy, Clone)]
584pub struct fpdf_structelement_attr_t__ {
585 _unused: [u8; 0],
586}
587pub type FPDF_STRUCTELEMENT_ATTR = *const fpdf_structelement_attr_t__;
588#[repr(C)]
589#[derive(Debug, Copy, Clone)]
590pub struct fpdf_structelement_attr_value_t__ {
591 _unused: [u8; 0],
592}
593pub type FPDF_STRUCTELEMENT_ATTR_VALUE = *const fpdf_structelement_attr_value_t__;
594#[repr(C)]
595#[derive(Debug, Copy, Clone)]
596pub struct fpdf_structtree_t__ {
597 _unused: [u8; 0],
598}
599pub type FPDF_STRUCTTREE = *mut fpdf_structtree_t__;
600#[repr(C)]
601#[derive(Debug, Copy, Clone)]
602pub struct fpdf_textpage_t__ {
603 _unused: [u8; 0],
604}
605pub type FPDF_TEXTPAGE = *mut fpdf_textpage_t__;
606#[repr(C)]
607#[derive(Debug, Copy, Clone)]
608pub struct fpdf_widget_t__ {
609 _unused: [u8; 0],
610}
611pub type FPDF_WIDGET = *mut fpdf_widget_t__;
612#[repr(C)]
613#[derive(Debug, Copy, Clone)]
614pub struct fpdf_xobject_t__ {
615 _unused: [u8; 0],
616}
617pub type FPDF_XOBJECT = *mut fpdf_xobject_t__;
618#[doc = " Basic data types"]
619pub type FPDF_BOOL = ::std::os::raw::c_int;
620pub type FPDF_RESULT = ::std::os::raw::c_int;
621pub type FPDF_DWORD = ::std::os::raw::c_ulong;
622pub type FS_FLOAT = f32;
623pub const _FPDF_DUPLEXTYPE__DuplexUndefined: _FPDF_DUPLEXTYPE_ = 0;
624pub const _FPDF_DUPLEXTYPE__Simplex: _FPDF_DUPLEXTYPE_ = 1;
625pub const _FPDF_DUPLEXTYPE__DuplexFlipShortEdge: _FPDF_DUPLEXTYPE_ = 2;
626pub const _FPDF_DUPLEXTYPE__DuplexFlipLongEdge: _FPDF_DUPLEXTYPE_ = 3;
627#[doc = " Duplex types"]
628pub type _FPDF_DUPLEXTYPE_ = ::std::os::raw::c_uint;
629#[doc = " Duplex types"]
630pub use self::_FPDF_DUPLEXTYPE_ as FPDF_DUPLEXTYPE;
631#[doc = " String types"]
632pub type FPDF_WCHAR = ::std::os::raw::c_ushort;
633#[doc = " Public PDFium API type for byte strings."]
634pub type FPDF_BYTESTRING = *const ::std::os::raw::c_char;
635#[doc = " The public PDFium API always uses UTF-16LE encoded wide strings, each\n character uses 2 bytes (except surrogation), with the low byte first."]
636pub type FPDF_WIDESTRING = *const FPDF_WCHAR;
637#[doc = " Structure for persisting a string beyond the duration of a callback.\n Note: although represented as a char*, string may be interpreted as\n a UTF-16LE formated string. Used only by XFA callbacks."]
638#[repr(C)]
639#[derive(Debug, Copy, Clone)]
640pub struct FPDF_BSTR_ {
641 #[doc = " String buffer, manipulate only with FPDF_BStr_* methods."]
642 pub str_: *mut ::std::os::raw::c_char,
643 #[doc = " Length of the string, in bytes."]
644 pub len: ::std::os::raw::c_int,
645}
646#[doc = " Structure for persisting a string beyond the duration of a callback.\n Note: although represented as a char*, string may be interpreted as\n a UTF-16LE formated string. Used only by XFA callbacks."]
647pub type FPDF_BSTR = FPDF_BSTR_;
648#[doc = " For Windows programmers: In most cases it's OK to treat FPDF_WIDESTRING as a\n Windows unicode string, however, special care needs to be taken if you\n expect to process Unicode larger than 0xffff.\n\n For Linux/Unix programmers: most compiler/library environments use 4 bytes\n for a Unicode character, and you have to convert between FPDF_WIDESTRING and\n system wide string by yourself."]
649pub type FPDF_STRING = *const ::std::os::raw::c_char;
650#[doc = " Matrix for transformation, in the form [a b c d e f], equivalent to:\n | a b 0 |\n | c d 0 |\n | e f 1 |\n\n Translation is performed with [1 0 0 1 tx ty].\n Scaling is performed with [sx 0 0 sy 0 0].\n See PDF Reference 1.7, 4.2.2 Common Transformations for more."]
651#[repr(C)]
652#[derive(Debug, Copy, Clone)]
653pub struct _FS_MATRIX_ {
654 pub a: f32,
655 pub b: f32,
656 pub c: f32,
657 pub d: f32,
658 pub e: f32,
659 pub f: f32,
660}
661#[doc = " Matrix for transformation, in the form [a b c d e f], equivalent to:\n | a b 0 |\n | c d 0 |\n | e f 1 |\n\n Translation is performed with [1 0 0 1 tx ty].\n Scaling is performed with [sx 0 0 sy 0 0].\n See PDF Reference 1.7, 4.2.2 Common Transformations for more."]
662pub type FS_MATRIX = _FS_MATRIX_;
663#[doc = " Rectangle area(float) in device or page coordinate system."]
664#[repr(C)]
665#[derive(Debug, Copy, Clone)]
666pub struct _FS_RECTF_ {
667 #[doc = " The x-coordinate of the left-top corner."]
668 pub left: f32,
669 #[doc = " The y-coordinate of the left-top corner."]
670 pub top: f32,
671 #[doc = " The x-coordinate of the right-bottom corner."]
672 pub right: f32,
673 #[doc = " The y-coordinate of the right-bottom corner."]
674 pub bottom: f32,
675}
676#[doc = " Rectangle area(float) in device or page coordinate system."]
677pub type FS_LPRECTF = *mut _FS_RECTF_;
678#[doc = " Rectangle area(float) in device or page coordinate system."]
679pub type FS_RECTF = _FS_RECTF_;
680#[doc = " Const Pointer to FS_RECTF structure."]
681pub type FS_LPCRECTF = *const FS_RECTF;
682#[doc = " Rectangle size. Coordinate system agnostic."]
683#[repr(C)]
684#[derive(Debug, Copy, Clone)]
685pub struct FS_SIZEF_ {
686 pub width: f32,
687 pub height: f32,
688}
689#[doc = " Rectangle size. Coordinate system agnostic."]
690pub type FS_LPSIZEF = *mut FS_SIZEF_;
691#[doc = " Rectangle size. Coordinate system agnostic."]
692pub type FS_SIZEF = FS_SIZEF_;
693#[doc = " Const Pointer to FS_SIZEF structure."]
694pub type FS_LPCSIZEF = *const FS_SIZEF;
695#[doc = " 2D Point. Coordinate system agnostic."]
696#[repr(C)]
697#[derive(Debug, Copy, Clone)]
698pub struct FS_POINTF_ {
699 pub x: f32,
700 pub y: f32,
701}
702#[doc = " 2D Point. Coordinate system agnostic."]
703pub type FS_LPPOINTF = *mut FS_POINTF_;
704#[doc = " 2D Point. Coordinate system agnostic."]
705pub type FS_POINTF = FS_POINTF_;
706#[doc = " Const Pointer to FS_POINTF structure."]
707pub type FS_LPCPOINTF = *const FS_POINTF;
708#[repr(C)]
709#[derive(Debug, Copy, Clone)]
710pub struct _FS_QUADPOINTSF {
711 pub x1: FS_FLOAT,
712 pub y1: FS_FLOAT,
713 pub x2: FS_FLOAT,
714 pub y2: FS_FLOAT,
715 pub x3: FS_FLOAT,
716 pub y3: FS_FLOAT,
717 pub x4: FS_FLOAT,
718 pub y4: FS_FLOAT,
719}
720pub type FS_QUADPOINTSF = _FS_QUADPOINTSF;
721#[doc = " Annotation enums."]
722pub type FPDF_ANNOTATION_SUBTYPE = ::std::os::raw::c_int;
723pub type FPDF_ANNOT_APPEARANCEMODE = ::std::os::raw::c_int;
724#[doc = " Dictionary value types."]
725pub type FPDF_OBJECT_TYPE = ::std::os::raw::c_int;
726#[doc = " Anti-Grain Geometry - https://sourceforge.net/projects/agg/"]
727pub const FPDF_RENDERER_TYPE_FPDF_RENDERERTYPE_AGG: FPDF_RENDERER_TYPE = 0;
728#[doc = " Skia - https://skia.org/"]
729pub const FPDF_RENDERER_TYPE_FPDF_RENDERERTYPE_SKIA: FPDF_RENDERER_TYPE = 1;
730#[doc = " PDF renderer types - Experimental.\n Selection of 2D graphics library to use for rendering to FPDF_BITMAPs."]
731pub type FPDF_RENDERER_TYPE = ::std::os::raw::c_uint;
732#[doc = " FreeType - https://freetype.org/"]
733pub const FPDF_FONT_BACKEND_TYPE_FPDF_FONTBACKENDTYPE_FREETYPE: FPDF_FONT_BACKEND_TYPE = 0;
734#[doc = " Fontations - https://github.com/googlefonts/fontations/"]
735pub const FPDF_FONT_BACKEND_TYPE_FPDF_FONTBACKENDTYPE_FONTATIONS: FPDF_FONT_BACKEND_TYPE = 1;
736#[doc = " PDF font library types - Experimental.\n Selection of font backend library to use."]
737pub type FPDF_FONT_BACKEND_TYPE = ::std::os::raw::c_uint;
738#[doc = " Process-wide options for initializing the library."]
739#[repr(C)]
740#[derive(Debug, Copy, Clone)]
741pub struct FPDF_LIBRARY_CONFIG_ {
742 #[doc = " Version number of the interface. Currently must be 2.\n Support for version 1 will be deprecated in the future."]
743 pub version: ::std::os::raw::c_int,
744 #[doc = " Array of paths to scan in place of the defaults when using built-in\n FXGE font loading code. The array is terminated by a NULL pointer.\n The Array may be NULL itself to use the default paths. May be ignored\n entirely depending upon the platform."]
745 pub m_pUserFontPaths: *mut *const ::std::os::raw::c_char,
746 #[doc = " Pointer to the v8::Isolate to use, or NULL to force PDFium to create one."]
747 pub m_pIsolate: *mut ::std::os::raw::c_void,
748 #[doc = " The embedder data slot to use in the v8::Isolate to store PDFium's\n per-isolate data. The value needs to be in the range\n [0, |v8::Internals::kNumIsolateDataLots|). Note that 0 is fine for most\n embedders."]
749 pub m_v8EmbedderSlot: ::std::os::raw::c_uint,
750 #[doc = " Pointer to the V8::Platform to use."]
751 pub m_pPlatform: *mut ::std::os::raw::c_void,
752 #[doc = " Explicit specification of 2D graphics rendering library to use.\n |m_RendererType| must be a valid value for |FPDF_LIBRARY_CONFIG| versions\n of this level or higher, or else the initialization will fail with an\n immediate crash.\n Note that use of a specified |FPDF_RENDERER_TYPE| value for which the\n corresponding 2D graphics rendering library is not included in the build\n will similarly fail with an immediate crash."]
753 pub m_RendererType: FPDF_RENDERER_TYPE,
754 #[doc = " Explicit specification of font library to use when |m_RendererType| is set\n to |FPDF_RENDERERTYPE_SKIA|.\n |m_FontLibraryType| must be a valid value for |FPDF_LIBRARY_CONFIG|\n versions of this level or higher, or else the initialization will fail with\n an immediate crash.\n Note that use of a specified |FPDF_FONT_BACKEND_TYPE| value for which the\n corresponding font library is not included in the build will similarly fail\n with an immediate crash."]
755 pub m_FontLibraryType: FPDF_FONT_BACKEND_TYPE,
756}
757#[doc = " Process-wide options for initializing the library."]
758pub type FPDF_LIBRARY_CONFIG = FPDF_LIBRARY_CONFIG_;
759unsafe extern "C" {
760 #[doc = " Function: FPDF_InitLibraryWithConfig\n Initialize the PDFium library and allocate global resources for it.\n Parameters:\n config - configuration information as above.\n Return value:\n None.\n Comments:\n You have to call this function before you can call any PDF\n processing functions."]
761 pub fn FPDF_InitLibraryWithConfig(config: *const FPDF_LIBRARY_CONFIG);
762}
763unsafe extern "C" {
764 #[doc = " Function: FPDF_InitLibrary\n Initialize the PDFium library (alternative form).\n Parameters:\n None\n Return value:\n None.\n Comments:\n Convenience function to call FPDF_InitLibraryWithConfig() with a\n default configuration for backwards compatibility purposes. New\n code should call FPDF_InitLibraryWithConfig() instead. This will\n be deprecated in the future."]
765 pub fn FPDF_InitLibrary();
766}
767unsafe extern "C" {
768 #[doc = " Function: FPDF_DestroyLibrary\n Release global resources allocated to the PDFium library by\n FPDF_InitLibrary() or FPDF_InitLibraryWithConfig().\n Parameters:\n None.\n Return value:\n None.\n Comments:\n After this function is called, you must not call any PDF\n processing functions.\n\n Calling this function does not automatically close other\n objects. It is recommended to close other objects before\n closing the library with this function."]
769 pub fn FPDF_DestroyLibrary();
770}
771unsafe extern "C" {
772 #[doc = " Function: FPDF_SetSandBoxPolicy\n Set the policy for the sandbox environment.\n Parameters:\n policy - The specified policy for setting, for example:\n FPDF_POLICY_MACHINETIME_ACCESS.\n enable - True to enable, false to disable the policy.\n Return value:\n None."]
773 pub fn FPDF_SetSandBoxPolicy(policy: FPDF_DWORD, enable: FPDF_BOOL);
774}
775unsafe extern "C" {
776 #[doc = " Function: FPDF_LoadDocument\n Open and load a PDF document.\n Parameters:\n file_path - Path to the PDF file (including extension).\n password - A string used as the password for the PDF file.\n If no password is needed, empty or NULL can be used.\n See comments below regarding the encoding.\n Return value:\n A handle to the loaded document, or NULL on failure.\n Comments:\n Loaded document can be closed by FPDF_CloseDocument().\n If this function fails, you can use FPDF_GetLastError() to retrieve\n the reason why it failed.\n\n The encoding for |file_path| is UTF-8.\n\n The encoding for |password| can be either UTF-8 or Latin-1. PDFs,\n depending on the security handler revision, will only accept one or\n the other encoding. If |password|'s encoding and the PDF's expected\n encoding do not match, FPDF_LoadDocument() will automatically\n convert |password| to the other encoding."]
777 pub fn FPDF_LoadDocument(file_path: FPDF_STRING, password: FPDF_BYTESTRING) -> FPDF_DOCUMENT;
778}
779unsafe extern "C" {
780 #[doc = " Function: FPDF_LoadMemDocument\n Open and load a PDF document from memory.\n Parameters:\n data_buf - Pointer to a buffer containing the PDF document.\n size - Number of bytes in the PDF document.\n password - A string used as the password for the PDF file.\n If no password is needed, empty or NULL can be used.\n Return value:\n A handle to the loaded document, or NULL on failure.\n Comments:\n The memory buffer must remain valid when the document is open.\n The loaded document can be closed by FPDF_CloseDocument.\n If this function fails, you can use FPDF_GetLastError() to retrieve\n the reason why it failed.\n\n See the comments for FPDF_LoadDocument() regarding the encoding for\n |password|.\n Notes:\n If PDFium is built with the XFA module, the application should call\n FPDF_LoadXFA() function after the PDF document loaded to support XFA\n fields defined in the fpdfformfill.h file."]
781 pub fn FPDF_LoadMemDocument(
782 data_buf: *const ::std::os::raw::c_void,
783 size: ::std::os::raw::c_int,
784 password: FPDF_BYTESTRING,
785 ) -> FPDF_DOCUMENT;
786}
787unsafe extern "C" {
788 #[doc = " Experimental API.\n Function: FPDF_LoadMemDocument64\n Open and load a PDF document from memory.\n Parameters:\n data_buf - Pointer to a buffer containing the PDF document.\n size - Number of bytes in the PDF document.\n password - A string used as the password for the PDF file.\n If no password is needed, empty or NULL can be used.\n Return value:\n A handle to the loaded document, or NULL on failure.\n Comments:\n The memory buffer must remain valid when the document is open.\n The loaded document can be closed by FPDF_CloseDocument.\n If this function fails, you can use FPDF_GetLastError() to retrieve\n the reason why it failed.\n\n See the comments for FPDF_LoadDocument() regarding the encoding for\n |password|.\n Notes:\n If PDFium is built with the XFA module, the application should call\n FPDF_LoadXFA() function after the PDF document loaded to support XFA\n fields defined in the fpdfformfill.h file."]
789 pub fn FPDF_LoadMemDocument64(
790 data_buf: *const ::std::os::raw::c_void,
791 size: usize,
792 password: FPDF_BYTESTRING,
793 ) -> FPDF_DOCUMENT;
794}
795#[doc = " Structure for custom file access."]
796#[repr(C)]
797#[derive(Debug, Copy, Clone)]
798pub struct FPDF_FILEACCESS {
799 #[doc = " File length, in bytes."]
800 pub m_FileLen: ::std::os::raw::c_ulong,
801 #[doc = " A function pointer for getting a block of data from a specific position.\n Position is specified by byte offset from the beginning of the file.\n The pointer to the buffer is never NULL and the size is never 0.\n The position and size will never go out of range of the file length.\n It may be possible for PDFium to call this function multiple times for\n the same position.\n Return value: should be non-zero if successful, zero for error."]
802 pub m_GetBlock: ::std::option::Option<
803 unsafe extern "C" fn(
804 param: *mut ::std::os::raw::c_void,
805 position: ::std::os::raw::c_ulong,
806 pBuf: *mut ::std::os::raw::c_uchar,
807 size: ::std::os::raw::c_ulong,
808 ) -> ::std::os::raw::c_int,
809 >,
810 #[doc = " A custom pointer for all implementation specific data. This pointer will\n be used as the first parameter to the m_GetBlock callback."]
811 pub m_Param: *mut ::std::os::raw::c_void,
812}
813#[doc = " Structure for file reading or writing (I/O).\n\n Note: This is a handler and should be implemented by callers,\n and is only used from XFA."]
814#[repr(C)]
815#[derive(Debug, Copy, Clone)]
816pub struct FPDF_FILEHANDLER_ {
817 #[doc = " User-defined data.\n Note: Callers can use this field to track controls."]
818 pub clientData: *mut ::std::os::raw::c_void,
819 #[doc = " Callback function to release the current file stream object.\n\n Parameters:\n clientData - Pointer to user-defined data.\n Returns:\n None."]
820 pub Release:
821 ::std::option::Option<unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void)>,
822 #[doc = " Callback function to retrieve the current file stream size.\n\n Parameters:\n clientData - Pointer to user-defined data.\n Returns:\n Size of file stream."]
823 pub GetSize: ::std::option::Option<
824 unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void) -> FPDF_DWORD,
825 >,
826 #[doc = " Callback function to read data from the current file stream.\n\n Parameters:\n clientData - Pointer to user-defined data.\n offset - Offset position starts from the beginning of file\n stream. This parameter indicates reading position.\n buffer - Memory buffer to store data which are read from\n file stream. This parameter should not be NULL.\n size - Size of data which should be read from file stream,\n in bytes. The buffer indicated by |buffer| must be\n large enough to store specified data.\n Returns:\n 0 for success, other value for failure."]
827 pub ReadBlock: ::std::option::Option<
828 unsafe extern "C" fn(
829 clientData: *mut ::std::os::raw::c_void,
830 offset: FPDF_DWORD,
831 buffer: *mut ::std::os::raw::c_void,
832 size: FPDF_DWORD,
833 ) -> FPDF_RESULT,
834 >,
835 #[doc = " Callback function to write data into the current file stream.\n\n Parameters:\n clientData - Pointer to user-defined data.\n offset - Offset position starts from the beginning of file\n stream. This parameter indicates writing position.\n buffer - Memory buffer contains data which is written into\n file stream. This parameter should not be NULL.\n size - Size of data which should be written into file\n stream, in bytes.\n Returns:\n 0 for success, other value for failure."]
836 pub WriteBlock: ::std::option::Option<
837 unsafe extern "C" fn(
838 clientData: *mut ::std::os::raw::c_void,
839 offset: FPDF_DWORD,
840 buffer: *const ::std::os::raw::c_void,
841 size: FPDF_DWORD,
842 ) -> FPDF_RESULT,
843 >,
844 #[doc = " Callback function to flush all internal accessing buffers.\n\n Parameters:\n clientData - Pointer to user-defined data.\n Returns:\n 0 for success, other value for failure."]
845 pub Flush: ::std::option::Option<
846 unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void) -> FPDF_RESULT,
847 >,
848 #[doc = " Callback function to change file size.\n\n Description:\n This function is called under writing mode usually. Implementer\n can determine whether to realize it based on application requests.\n Parameters:\n clientData - Pointer to user-defined data.\n size - New size of file stream, in bytes.\n Returns:\n 0 for success, other value for failure."]
849 pub Truncate: ::std::option::Option<
850 unsafe extern "C" fn(
851 clientData: *mut ::std::os::raw::c_void,
852 size: FPDF_DWORD,
853 ) -> FPDF_RESULT,
854 >,
855}
856#[doc = " Structure for file reading or writing (I/O).\n\n Note: This is a handler and should be implemented by callers,\n and is only used from XFA."]
857pub type FPDF_FILEHANDLER = FPDF_FILEHANDLER_;
858unsafe extern "C" {
859 #[doc = " Function: FPDF_LoadCustomDocument\n Load PDF document from a custom access descriptor.\n Parameters:\n pFileAccess - A structure for accessing the file.\n password - Optional password for decrypting the PDF file.\n Return value:\n A handle to the loaded document, or NULL on failure.\n Comments:\n The application must keep the file resources |pFileAccess| points to\n valid until the returned FPDF_DOCUMENT is closed. |pFileAccess|\n itself does not need to outlive the FPDF_DOCUMENT.\n\n The loaded document can be closed with FPDF_CloseDocument().\n\n See the comments for FPDF_LoadDocument() regarding the encoding for\n |password|.\n Notes:\n If PDFium is built with the XFA module, the application should call\n FPDF_LoadXFA() function after the PDF document loaded to support XFA\n fields defined in the fpdfformfill.h file."]
860 pub fn FPDF_LoadCustomDocument(
861 pFileAccess: *mut FPDF_FILEACCESS,
862 password: FPDF_BYTESTRING,
863 ) -> FPDF_DOCUMENT;
864}
865unsafe extern "C" {
866 #[doc = " Function: FPDF_GetFileVersion\n Get the file version of the given PDF document.\n Parameters:\n doc - Handle to a document.\n fileVersion - The PDF file version. File version: 14 for 1.4, 15\n for 1.5, ...\n Return value:\n True if succeeds, false otherwise.\n Comments:\n If the document was created by FPDF_CreateNewDocument,\n then this function will always fail."]
867 pub fn FPDF_GetFileVersion(
868 doc: FPDF_DOCUMENT,
869 fileVersion: *mut ::std::os::raw::c_int,
870 ) -> FPDF_BOOL;
871}
872unsafe extern "C" {
873 #[doc = " Function: FPDF_GetLastError\n Get last error code when a function fails.\n Parameters:\n None.\n Return value:\n A 32-bit integer indicating error code as defined above.\n Comments:\n If the previous SDK call succeeded, the return value of this\n function is not defined. This function only works in conjunction\n with APIs that mention FPDF_GetLastError() in their documentation."]
874 pub fn FPDF_GetLastError() -> ::std::os::raw::c_ulong;
875}
876unsafe extern "C" {
877 #[doc = " Experimental API.\n Function: FPDF_DocumentHasValidCrossReferenceTable\n Whether the document's cross reference table is valid or not.\n Parameters:\n document - Handle to a document. Returned by FPDF_LoadDocument.\n Return value:\n True if the PDF parser did not encounter problems parsing the cross\n reference table. False if the parser could not parse the cross\n reference table and the table had to be rebuild from other data\n within the document.\n Comments:\n The return value can change over time as the PDF parser evolves."]
878 pub fn FPDF_DocumentHasValidCrossReferenceTable(document: FPDF_DOCUMENT) -> FPDF_BOOL;
879}
880unsafe extern "C" {
881 #[doc = " Experimental API.\n Function: FPDF_GetTrailerEnds\n Get the byte offsets of trailer ends.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument().\n buffer - The address of a buffer that receives the\n byte offsets.\n length - The size, in ints, of |buffer|.\n Return value:\n Returns the number of ints in the buffer on success, 0 on error.\n\n |buffer| is an array of integers that describes the exact byte offsets of the\n trailer ends in the document. If |length| is less than the returned length,\n or |document| or |buffer| is NULL, |buffer| will not be modified."]
882 pub fn FPDF_GetTrailerEnds(
883 document: FPDF_DOCUMENT,
884 buffer: *mut ::std::os::raw::c_uint,
885 length: ::std::os::raw::c_ulong,
886 ) -> ::std::os::raw::c_ulong;
887}
888unsafe extern "C" {
889 #[doc = " Function: FPDF_GetDocPermissions\n Get file permission flags of the document.\n Parameters:\n document - Handle to a document. Returned by FPDF_LoadDocument.\n Return value:\n A 32-bit integer indicating permission flags. Please refer to the\n PDF Reference for detailed descriptions. If the document is not\n protected or was unlocked by the owner, 0xffffffff will be returned."]
890 pub fn FPDF_GetDocPermissions(document: FPDF_DOCUMENT) -> ::std::os::raw::c_ulong;
891}
892unsafe extern "C" {
893 #[doc = " Function: FPDF_GetDocUserPermissions\n Get user file permission flags of the document.\n Parameters:\n document - Handle to a document. Returned by FPDF_LoadDocument.\n Return value:\n A 32-bit integer indicating permission flags. Please refer to the\n PDF Reference for detailed descriptions. If the document is not\n protected, 0xffffffff will be returned. Always returns user\n permissions, even if the document was unlocked by the owner."]
894 pub fn FPDF_GetDocUserPermissions(document: FPDF_DOCUMENT) -> ::std::os::raw::c_ulong;
895}
896unsafe extern "C" {
897 #[doc = " Function: FPDF_GetSecurityHandlerRevision\n Get the revision for the security handler.\n Parameters:\n document - Handle to a document. Returned by FPDF_LoadDocument.\n Return value:\n The security handler revision number. Please refer to the PDF\n Reference for a detailed description. If the document is not\n protected, -1 will be returned."]
898 pub fn FPDF_GetSecurityHandlerRevision(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
899}
900unsafe extern "C" {
901 #[doc = " Function: FPDF_GetPageCount\n Get total number of pages in the document.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument.\n Return value:\n Total number of pages in the document."]
902 pub fn FPDF_GetPageCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
903}
904unsafe extern "C" {
905 #[doc = " Function: FPDF_LoadPage\n Load a page inside the document.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument\n page_index - Index number of the page. 0 for the first page.\n Return value:\n A handle to the loaded page, or NULL if page load fails.\n Comments:\n The loaded page can be rendered to devices using FPDF_RenderPage.\n The loaded page can be closed using FPDF_ClosePage."]
906 pub fn FPDF_LoadPage(document: FPDF_DOCUMENT, page_index: ::std::os::raw::c_int) -> FPDF_PAGE;
907}
908unsafe extern "C" {
909 #[doc = " Experimental API\n Function: FPDF_GetPageWidthF\n Get page width.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage().\n Return value:\n Page width (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm).\n Comments:\n Changing the rotation of |page| affects the return value."]
910 pub fn FPDF_GetPageWidthF(page: FPDF_PAGE) -> f32;
911}
912unsafe extern "C" {
913 #[doc = " Function: FPDF_GetPageWidth\n Get page width.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n Return value:\n Page width (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm).\n Note:\n Prefer FPDF_GetPageWidthF() above. This will be deprecated in the\n future.\n Comments:\n Changing the rotation of |page| affects the return value."]
914 pub fn FPDF_GetPageWidth(page: FPDF_PAGE) -> f64;
915}
916unsafe extern "C" {
917 #[doc = " Experimental API\n Function: FPDF_GetPageHeightF\n Get page height.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage().\n Return value:\n Page height (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm)\n Comments:\n Changing the rotation of |page| affects the return value."]
918 pub fn FPDF_GetPageHeightF(page: FPDF_PAGE) -> f32;
919}
920unsafe extern "C" {
921 #[doc = " Function: FPDF_GetPageHeight\n Get page height.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n Return value:\n Page height (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm)\n Note:\n Prefer FPDF_GetPageHeightF() above. This will be deprecated in the\n future.\n Comments:\n Changing the rotation of |page| affects the return value."]
922 pub fn FPDF_GetPageHeight(page: FPDF_PAGE) -> f64;
923}
924unsafe extern "C" {
925 #[doc = " Experimental API.\n Function: FPDF_GetPageBoundingBox\n Get the bounding box of the page. This is the intersection between\n its media box and its crop box.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n rect - Pointer to a rect to receive the page bounding box.\n On an error, |rect| won't be filled.\n Return value:\n True for success."]
926 pub fn FPDF_GetPageBoundingBox(page: FPDF_PAGE, rect: *mut FS_RECTF) -> FPDF_BOOL;
927}
928unsafe extern "C" {
929 #[doc = " Experimental API.\n Function: FPDF_GetPageSizeByIndexF\n Get the size of the page at the given index.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument().\n page_index - Page index, zero for the first page.\n size - Pointer to a FS_SIZEF to receive the page size.\n (in points).\n Return value:\n Non-zero for success. 0 for error (document or page not found)."]
930 pub fn FPDF_GetPageSizeByIndexF(
931 document: FPDF_DOCUMENT,
932 page_index: ::std::os::raw::c_int,
933 size: *mut FS_SIZEF,
934 ) -> FPDF_BOOL;
935}
936unsafe extern "C" {
937 #[doc = " Function: FPDF_GetPageSizeByIndex\n Get the size of the page at the given index.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument.\n page_index - Page index, zero for the first page.\n width - Pointer to a double to receive the page width\n (in points).\n height - Pointer to a double to receive the page height\n (in points).\n Return value:\n Non-zero for success. 0 for error (document or page not found).\n Note:\n Prefer FPDF_GetPageSizeByIndexF() above. This will be deprecated in\n the future."]
938 pub fn FPDF_GetPageSizeByIndex(
939 document: FPDF_DOCUMENT,
940 page_index: ::std::os::raw::c_int,
941 width: *mut f64,
942 height: *mut f64,
943 ) -> ::std::os::raw::c_int;
944}
945#[doc = " Struct for color scheme.\n Each should be a 32-bit value specifying the color, in 8888 ARGB format."]
946#[repr(C)]
947#[derive(Debug, Copy, Clone)]
948pub struct FPDF_COLORSCHEME_ {
949 pub path_fill_color: FPDF_DWORD,
950 pub path_stroke_color: FPDF_DWORD,
951 pub text_fill_color: FPDF_DWORD,
952 pub text_stroke_color: FPDF_DWORD,
953}
954#[doc = " Struct for color scheme.\n Each should be a 32-bit value specifying the color, in 8888 ARGB format."]
955pub type FPDF_COLORSCHEME = FPDF_COLORSCHEME_;
956unsafe extern "C" {
957 #[doc = " Function: FPDF_RenderPageBitmap\n Render contents of a page to a device independent bitmap.\n Parameters:\n bitmap - Handle to the device independent bitmap (as the\n output buffer). The bitmap handle can be created\n by FPDFBitmap_Create or retrieved from an image\n object by FPDFImageObj_GetBitmap.\n page - Handle to the page. Returned by FPDF_LoadPage\n start_x - Left pixel position of the display area in\n bitmap coordinates.\n start_y - Top pixel position of the display area in bitmap\n coordinates.\n size_x - Horizontal size (in pixels) for displaying the page.\n size_y - Vertical size (in pixels) for displaying the page.\n rotate - Page orientation:\n 0 (normal)\n 1 (rotated 90 degrees clockwise)\n 2 (rotated 180 degrees)\n 3 (rotated 90 degrees counter-clockwise)\n flags - 0 for normal display, or combination of the Page\n Rendering flags defined above. With the FPDF_ANNOT\n flag, it renders all annotations that do not require\n user-interaction, which are all annotations except\n widget and popup annotations.\n Return value:\n None."]
958 pub fn FPDF_RenderPageBitmap(
959 bitmap: FPDF_BITMAP,
960 page: FPDF_PAGE,
961 start_x: ::std::os::raw::c_int,
962 start_y: ::std::os::raw::c_int,
963 size_x: ::std::os::raw::c_int,
964 size_y: ::std::os::raw::c_int,
965 rotate: ::std::os::raw::c_int,
966 flags: ::std::os::raw::c_int,
967 );
968}
969unsafe extern "C" {
970 #[doc = " Function: FPDF_RenderPageBitmapWithMatrix\n Render contents of a page to a device independent bitmap.\n Parameters:\n bitmap - Handle to the device independent bitmap (as the\n output buffer). The bitmap handle can be created\n by FPDFBitmap_Create or retrieved by\n FPDFImageObj_GetBitmap.\n page - Handle to the page. Returned by FPDF_LoadPage.\n matrix - The transform matrix, which must be invertible.\n See PDF Reference 1.7, 4.2.2 Common Transformations.\n clipping - The rect to clip to in device coords.\n flags - 0 for normal display, or combination of the Page\n Rendering flags defined above. With the FPDF_ANNOT\n flag, it renders all annotations that do not require\n user-interaction, which are all annotations except\n widget and popup annotations.\n Return value:\n None. Note that behavior is undefined if det of |matrix| is 0."]
971 pub fn FPDF_RenderPageBitmapWithMatrix(
972 bitmap: FPDF_BITMAP,
973 page: FPDF_PAGE,
974 matrix: *const FS_MATRIX,
975 clipping: *const FS_RECTF,
976 flags: ::std::os::raw::c_int,
977 );
978}
979unsafe extern "C" {
980 #[doc = " Experimental API.\n Function: FPDF_RenderPageSkia\n Render contents of a page to a Skia SkCanvas.\n Parameters:\n canvas - SkCanvas to render to.\n page - Handle to the page.\n size_x - Horizontal size (in pixels) for displaying the page.\n size_y - Vertical size (in pixels) for displaying the page.\n Return value:\n None."]
981 pub fn FPDF_RenderPageSkia(
982 canvas: FPDF_SKIA_CANVAS,
983 page: FPDF_PAGE,
984 size_x: ::std::os::raw::c_int,
985 size_y: ::std::os::raw::c_int,
986 );
987}
988unsafe extern "C" {
989 #[doc = " Function: FPDF_ClosePage\n Close a loaded PDF page.\n Parameters:\n page - Handle to the loaded page.\n Return value:\n None."]
990 pub fn FPDF_ClosePage(page: FPDF_PAGE);
991}
992unsafe extern "C" {
993 #[doc = " Function: FPDF_CloseDocument\n Close a loaded PDF document.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n None."]
994 pub fn FPDF_CloseDocument(document: FPDF_DOCUMENT);
995}
996unsafe extern "C" {
997 #[doc = " Function: FPDF_DeviceToPage\n Convert the screen coordinates of a point to page coordinates.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n start_x - Left pixel position of the display area in\n device coordinates.\n start_y - Top pixel position of the display area in device\n coordinates.\n size_x - Horizontal size (in pixels) for displaying the page.\n size_y - Vertical size (in pixels) for displaying the page.\n rotate - Page orientation:\n 0 (normal)\n 1 (rotated 90 degrees clockwise)\n 2 (rotated 180 degrees)\n 3 (rotated 90 degrees counter-clockwise)\n device_x - X value in device coordinates to be converted.\n device_y - Y value in device coordinates to be converted.\n page_x - A pointer to a double receiving the converted X\n value in page coordinates.\n page_y - A pointer to a double receiving the converted Y\n value in page coordinates.\n Return value:\n Returns true if the conversion succeeds, and |page_x| and |page_y|\n successfully receives the converted coordinates.\n Comments:\n The page coordinate system has its origin at the left-bottom corner\n of the page, with the X-axis on the bottom going to the right, and\n the Y-axis on the left side going up.\n\n NOTE: this coordinate system can be altered when you zoom, scroll,\n or rotate a page, however, a point on the page should always have\n the same coordinate values in the page coordinate system.\n\n The device coordinate system is device dependent. For screen device,\n its origin is at the left-top corner of the window. However this\n origin can be altered by the Windows coordinate transformation\n utilities.\n\n You must make sure the start_x, start_y, size_x, size_y\n and rotate parameters have exactly same values as you used in\n the FPDF_RenderPage() function call."]
998 pub fn FPDF_DeviceToPage(
999 page: FPDF_PAGE,
1000 start_x: ::std::os::raw::c_int,
1001 start_y: ::std::os::raw::c_int,
1002 size_x: ::std::os::raw::c_int,
1003 size_y: ::std::os::raw::c_int,
1004 rotate: ::std::os::raw::c_int,
1005 device_x: ::std::os::raw::c_int,
1006 device_y: ::std::os::raw::c_int,
1007 page_x: *mut f64,
1008 page_y: *mut f64,
1009 ) -> FPDF_BOOL;
1010}
1011unsafe extern "C" {
1012 #[doc = " Function: FPDF_PageToDevice\n Convert the page coordinates of a point to screen coordinates.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n start_x - Left pixel position of the display area in\n device coordinates.\n start_y - Top pixel position of the display area in device\n coordinates.\n size_x - Horizontal size (in pixels) for displaying the page.\n size_y - Vertical size (in pixels) for displaying the page.\n rotate - Page orientation:\n 0 (normal)\n 1 (rotated 90 degrees clockwise)\n 2 (rotated 180 degrees)\n 3 (rotated 90 degrees counter-clockwise)\n page_x - X value in page coordinates.\n page_y - Y value in page coordinate.\n device_x - A pointer to an integer receiving the result X\n value in device coordinates.\n device_y - A pointer to an integer receiving the result Y\n value in device coordinates.\n Return value:\n Returns true if the conversion succeeds, and |device_x| and\n |device_y| successfully receives the converted coordinates.\n Comments:\n See comments for FPDF_DeviceToPage()."]
1013 pub fn FPDF_PageToDevice(
1014 page: FPDF_PAGE,
1015 start_x: ::std::os::raw::c_int,
1016 start_y: ::std::os::raw::c_int,
1017 size_x: ::std::os::raw::c_int,
1018 size_y: ::std::os::raw::c_int,
1019 rotate: ::std::os::raw::c_int,
1020 page_x: f64,
1021 page_y: f64,
1022 device_x: *mut ::std::os::raw::c_int,
1023 device_y: *mut ::std::os::raw::c_int,
1024 ) -> FPDF_BOOL;
1025}
1026unsafe extern "C" {
1027 #[doc = " Function: FPDFBitmap_Create\n Create a device independent bitmap (FXDIB).\n Parameters:\n width - The number of pixels in width for the bitmap.\n Must be greater than 0.\n height - The number of pixels in height for the bitmap.\n Must be greater than 0.\n alpha - A flag indicating whether the alpha channel is used.\n Non-zero for using alpha, zero for not using.\n Return value:\n The created bitmap handle, or NULL if a parameter error or out of\n memory.\n Comments:\n The bitmap always uses 4 bytes per pixel. The first byte is always\n double word aligned.\n\n The byte order is BGRx (the last byte unused if no alpha channel) or\n BGRA.\n\n The pixels in a horizontal line are stored side by side, with the\n left most pixel stored first (with lower memory address).\n Each line uses width * 4 bytes.\n\n Lines are stored one after another, with the top most line stored\n first. There is no gap between adjacent lines.\n\n This function allocates enough memory for holding all pixels in the\n bitmap, but it doesn't initialize the buffer. Applications can use\n FPDFBitmap_FillRect() to fill the bitmap using any color. If the OS\n allows it, this function can allocate up to 4 GB of memory."]
1028 pub fn FPDFBitmap_Create(
1029 width: ::std::os::raw::c_int,
1030 height: ::std::os::raw::c_int,
1031 alpha: ::std::os::raw::c_int,
1032 ) -> FPDF_BITMAP;
1033}
1034unsafe extern "C" {
1035 #[doc = " Function: FPDFBitmap_CreateEx\n Create a device independent bitmap (FXDIB)\n Parameters:\n width - The number of pixels in width for the bitmap.\n Must be greater than 0.\n height - The number of pixels in height for the bitmap.\n Must be greater than 0.\n format - A number indicating for bitmap format, as defined\n above.\n first_scan - A pointer to the first byte of the first line if\n using an external buffer. If this parameter is NULL,\n then a new buffer will be created.\n stride - Number of bytes for each scan line. The value must\n be 0 or greater. When the value is 0,\n FPDFBitmap_CreateEx() will automatically calculate\n the appropriate value using |width| and |format|.\n When using an external buffer, it is recommended for\n the caller to pass in the value.\n When not using an external buffer, it is recommended\n for the caller to pass in 0.\n Return value:\n The bitmap handle, or NULL if parameter error or out of memory.\n Comments:\n Similar to FPDFBitmap_Create function, but allows for more formats\n and an external buffer is supported. The bitmap created by this\n function can be used in any place that a FPDF_BITMAP handle is\n required.\n\n If an external buffer is used, then the caller should destroy the\n buffer. FPDFBitmap_Destroy() will not destroy the buffer.\n\n It is recommended to use FPDFBitmap_GetStride() to get the stride\n value."]
1036 pub fn FPDFBitmap_CreateEx(
1037 width: ::std::os::raw::c_int,
1038 height: ::std::os::raw::c_int,
1039 format: ::std::os::raw::c_int,
1040 first_scan: *mut ::std::os::raw::c_void,
1041 stride: ::std::os::raw::c_int,
1042 ) -> FPDF_BITMAP;
1043}
1044unsafe extern "C" {
1045 #[doc = " Function: FPDFBitmap_GetFormat\n Get the format of the bitmap.\n Parameters:\n bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create\n or FPDFImageObj_GetBitmap.\n Return value:\n The format of the bitmap.\n Comments:\n Only formats supported by FPDFBitmap_CreateEx are supported by this\n function; see the list of such formats above."]
1046 pub fn FPDFBitmap_GetFormat(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1047}
1048unsafe extern "C" {
1049 #[doc = " Function: FPDFBitmap_FillRect\n Fill a rectangle in a bitmap.\n Parameters:\n bitmap - The handle to the bitmap. Returned by\n FPDFBitmap_Create.\n left - The left position. Starting from 0 at the\n left-most pixel.\n top - The top position. Starting from 0 at the\n top-most line.\n width - Width in pixels to be filled.\n height - Height in pixels to be filled.\n color - A 32-bit value specifing the color, in 8888 ARGB\n format.\n Return value:\n Returns whether the operation succeeded or not.\n Comments:\n This function sets the color and (optionally) alpha value in the\n specified region of the bitmap.\n\n NOTE: If the alpha channel is used, this function does NOT\n composite the background with the source color, instead the\n background will be replaced by the source color and the alpha.\n\n If the alpha channel is not used, the alpha parameter is ignored."]
1050 pub fn FPDFBitmap_FillRect(
1051 bitmap: FPDF_BITMAP,
1052 left: ::std::os::raw::c_int,
1053 top: ::std::os::raw::c_int,
1054 width: ::std::os::raw::c_int,
1055 height: ::std::os::raw::c_int,
1056 color: FPDF_DWORD,
1057 ) -> FPDF_BOOL;
1058}
1059unsafe extern "C" {
1060 #[doc = " Function: FPDFBitmap_GetBuffer\n Get data buffer of a bitmap.\n Parameters:\n bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create\n or FPDFImageObj_GetBitmap.\n Return value:\n The pointer to the first byte of the bitmap buffer.\n Comments:\n The stride may be more than width * number of bytes per pixel\n\n Applications can use this function to get the bitmap buffer pointer,\n then manipulate any color and/or alpha values for any pixels in the\n bitmap.\n\n Use FPDFBitmap_GetFormat() to find out the format of the data."]
1061 pub fn FPDFBitmap_GetBuffer(bitmap: FPDF_BITMAP) -> *mut ::std::os::raw::c_void;
1062}
1063unsafe extern "C" {
1064 #[doc = " Function: FPDFBitmap_GetWidth\n Get width of a bitmap.\n Parameters:\n bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create\n or FPDFImageObj_GetBitmap.\n Return value:\n The width of the bitmap in pixels."]
1065 pub fn FPDFBitmap_GetWidth(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1066}
1067unsafe extern "C" {
1068 #[doc = " Function: FPDFBitmap_GetHeight\n Get height of a bitmap.\n Parameters:\n bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create\n or FPDFImageObj_GetBitmap.\n Return value:\n The height of the bitmap in pixels."]
1069 pub fn FPDFBitmap_GetHeight(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1070}
1071unsafe extern "C" {
1072 #[doc = " Function: FPDFBitmap_GetStride\n Get number of bytes for each line in the bitmap buffer.\n Parameters:\n bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create\n or FPDFImageObj_GetBitmap.\n Return value:\n The number of bytes for each line in the bitmap buffer.\n Comments:\n The stride may be more than width * number of bytes per pixel."]
1073 pub fn FPDFBitmap_GetStride(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1074}
1075unsafe extern "C" {
1076 #[doc = " Function: FPDFBitmap_Destroy\n Destroy a bitmap and release all related buffers.\n Parameters:\n bitmap - Handle to the bitmap. Returned by FPDFBitmap_Create\n or FPDFImageObj_GetBitmap.\n Return value:\n None.\n Comments:\n This function will not destroy any external buffers provided when\n the bitmap was created."]
1077 pub fn FPDFBitmap_Destroy(bitmap: FPDF_BITMAP);
1078}
1079unsafe extern "C" {
1080 #[doc = " Function: FPDF_VIEWERREF_GetPrintScaling\n Whether the PDF document prefers to be scaled or not.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n None."]
1081 pub fn FPDF_VIEWERREF_GetPrintScaling(document: FPDF_DOCUMENT) -> FPDF_BOOL;
1082}
1083unsafe extern "C" {
1084 #[doc = " Function: FPDF_VIEWERREF_GetNumCopies\n Returns the number of copies to be printed.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n The number of copies to be printed."]
1085 pub fn FPDF_VIEWERREF_GetNumCopies(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1086}
1087unsafe extern "C" {
1088 #[doc = " Function: FPDF_VIEWERREF_GetPrintPageRange\n Page numbers to initialize print dialog box when file is printed.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n The print page range to be used for printing."]
1089 pub fn FPDF_VIEWERREF_GetPrintPageRange(document: FPDF_DOCUMENT) -> FPDF_PAGERANGE;
1090}
1091unsafe extern "C" {
1092 #[doc = " Experimental API.\n Function: FPDF_VIEWERREF_GetPrintPageRangeCount\n Returns the number of elements in a FPDF_PAGERANGE.\n Parameters:\n pagerange - Handle to the page range.\n Return value:\n The number of elements in the page range. Returns 0 on error."]
1093 pub fn FPDF_VIEWERREF_GetPrintPageRangeCount(pagerange: FPDF_PAGERANGE) -> usize;
1094}
1095unsafe extern "C" {
1096 #[doc = " Experimental API.\n Function: FPDF_VIEWERREF_GetPrintPageRangeElement\n Returns an element from a FPDF_PAGERANGE.\n Parameters:\n pagerange - Handle to the page range.\n index - Index of the element.\n Return value:\n The value of the element in the page range at a given index.\n Returns -1 on error."]
1097 pub fn FPDF_VIEWERREF_GetPrintPageRangeElement(
1098 pagerange: FPDF_PAGERANGE,
1099 index: usize,
1100 ) -> ::std::os::raw::c_int;
1101}
1102unsafe extern "C" {
1103 #[doc = " Function: FPDF_VIEWERREF_GetDuplex\n Returns the paper handling option to be used when printing from\n the print dialog.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n The paper handling option to be used when printing."]
1104 pub fn FPDF_VIEWERREF_GetDuplex(document: FPDF_DOCUMENT) -> FPDF_DUPLEXTYPE;
1105}
1106unsafe extern "C" {
1107 #[doc = " Function: FPDF_VIEWERREF_GetName\n Gets the contents for a viewer ref, with a given key. The value must\n be of type \"name\".\n Parameters:\n document - Handle to the loaded document.\n key - Name of the key in the viewer pref dictionary,\n encoded in UTF-8.\n buffer - Caller-allocate buffer to receive the key, or NULL\n - to query the required length.\n length - Length of the buffer.\n Return value:\n The number of bytes in the contents, including the NULL terminator.\n Thus if the return value is 0, then that indicates an error, such\n as when |document| is invalid. If |length| is less than the required\n length, or |buffer| is NULL, |buffer| will not be modified."]
1108 pub fn FPDF_VIEWERREF_GetName(
1109 document: FPDF_DOCUMENT,
1110 key: FPDF_BYTESTRING,
1111 buffer: *mut ::std::os::raw::c_char,
1112 length: ::std::os::raw::c_ulong,
1113 ) -> ::std::os::raw::c_ulong;
1114}
1115unsafe extern "C" {
1116 #[doc = " Function: FPDF_CountNamedDests\n Get the count of named destinations in the PDF document.\n Parameters:\n document - Handle to a document\n Return value:\n The count of named destinations."]
1117 pub fn FPDF_CountNamedDests(document: FPDF_DOCUMENT) -> FPDF_DWORD;
1118}
1119unsafe extern "C" {
1120 #[doc = " Function: FPDF_GetNamedDestByName\n Get a the destination handle for the given name.\n Parameters:\n document - Handle to the loaded document.\n name - The name of a destination.\n Return value:\n The handle to the destination."]
1121 pub fn FPDF_GetNamedDestByName(document: FPDF_DOCUMENT, name: FPDF_BYTESTRING) -> FPDF_DEST;
1122}
1123unsafe extern "C" {
1124 #[doc = " Function: FPDF_GetNamedDest\n Get the named destination by index.\n Parameters:\n document - Handle to a document\n index - The index of a named destination.\n buffer - The buffer to store the destination name,\n used as wchar_t*.\n buflen [in/out] - Size of the buffer in bytes on input,\n length of the result in bytes on output\n or -1 if the buffer is too small.\n Return value:\n The destination handle for a given index, or NULL if there is no\n named destination corresponding to |index|.\n Comments:\n Call this function twice to get the name of the named destination:\n 1) First time pass in |buffer| as NULL and get buflen.\n 2) Second time pass in allocated |buffer| and buflen to retrieve\n |buffer|, which should be used as wchar_t*.\n\n If buflen is not sufficiently large, it will be set to -1 upon\n return."]
1125 pub fn FPDF_GetNamedDest(
1126 document: FPDF_DOCUMENT,
1127 index: ::std::os::raw::c_int,
1128 buffer: *mut ::std::os::raw::c_void,
1129 buflen: *mut ::std::os::raw::c_long,
1130 ) -> FPDF_DEST;
1131}
1132unsafe extern "C" {
1133 #[doc = " Experimental API.\n Function: FPDF_GetXFAPacketCount\n Get the number of valid packets in the XFA entry.\n Parameters:\n document - Handle to the document.\n Return value:\n The number of valid packets, or -1 on error."]
1134 pub fn FPDF_GetXFAPacketCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1135}
1136unsafe extern "C" {
1137 #[doc = " Experimental API.\n Function: FPDF_GetXFAPacketName\n Get the name of a packet in the XFA array.\n Parameters:\n document - Handle to the document.\n index - Index number of the packet. 0 for the first packet.\n buffer - Buffer for holding the name of the XFA packet.\n buflen - Length of |buffer| in bytes.\n Return value:\n The length of the packet name in bytes, or 0 on error.\n\n |document| must be valid and |index| must be in the range [0, N), where N is\n the value returned by FPDF_GetXFAPacketCount().\n |buffer| is only modified if it is non-NULL and |buflen| is greater than or\n equal to the length of the packet name. The packet name includes a\n terminating NUL character. |buffer| is unmodified on error."]
1138 pub fn FPDF_GetXFAPacketName(
1139 document: FPDF_DOCUMENT,
1140 index: ::std::os::raw::c_int,
1141 buffer: *mut ::std::os::raw::c_void,
1142 buflen: ::std::os::raw::c_ulong,
1143 ) -> ::std::os::raw::c_ulong;
1144}
1145unsafe extern "C" {
1146 #[doc = " Experimental API.\n Function: FPDF_GetXFAPacketContent\n Get the content of a packet in the XFA array.\n Parameters:\n document - Handle to the document.\n index - Index number of the packet. 0 for the first packet.\n buffer - Buffer for holding the content of the XFA packet.\n buflen - Length of |buffer| in bytes.\n out_buflen - Pointer to the variable that will receive the minimum\n buffer size needed to contain the content of the XFA\n packet.\n Return value:\n Whether the operation succeeded or not.\n\n |document| must be valid and |index| must be in the range [0, N), where N is\n the value returned by FPDF_GetXFAPacketCount(). |out_buflen| must not be\n NULL. When the aforementioned arguments are valid, the operation succeeds,\n and |out_buflen| receives the content size. |buffer| is only modified if\n |buffer| is non-null and long enough to contain the content. Callers must\n check both the return value and the input |buflen| is no less than the\n returned |out_buflen| before using the data in |buffer|."]
1147 pub fn FPDF_GetXFAPacketContent(
1148 document: FPDF_DOCUMENT,
1149 index: ::std::os::raw::c_int,
1150 buffer: *mut ::std::os::raw::c_void,
1151 buflen: ::std::os::raw::c_ulong,
1152 out_buflen: *mut ::std::os::raw::c_ulong,
1153 ) -> FPDF_BOOL;
1154}
1155unsafe extern "C" {
1156 #[doc = " Function: FPDF_GetRecommendedV8Flags\n Returns a space-separated string of command line flags that are\n recommended to be passed into V8 via V8::SetFlagsFromString()\n prior to initializing the PDFium library.\n Parameters:\n None.\n Return value:\n NUL-terminated string of the form \"--flag1 --flag2\".\n The caller must not attempt to modify or free the result."]
1157 pub fn FPDF_GetRecommendedV8Flags() -> *const ::std::os::raw::c_char;
1158}
1159unsafe extern "C" {
1160 #[doc = " Experimental API.\n Function: FPDF_GetArrayBufferAllocatorSharedInstance()\n Helper function for initializing V8 isolates that will\n use PDFium's internal memory management.\n Parameters:\n None.\n Return Value:\n Pointer to a suitable v8::ArrayBuffer::Allocator, returned\n as void for C compatibility.\n Notes:\n Use is optional, but allows external creation of isolates\n matching the ones PDFium will make when none is provided\n via |FPDF_LIBRARY_CONFIG::m_pIsolate|.\n\n Can only be called when the library is in an uninitialized or\n destroyed state."]
1161 pub fn FPDF_GetArrayBufferAllocatorSharedInstance() -> *mut ::std::os::raw::c_void;
1162}
1163unsafe extern "C" {
1164 #[doc = " Function: FPDF_BStr_Init\n Helper function to initialize a FPDF_BSTR."]
1165 pub fn FPDF_BStr_Init(bstr: *mut FPDF_BSTR) -> FPDF_RESULT;
1166}
1167unsafe extern "C" {
1168 #[doc = " Function: FPDF_BStr_Set\n Helper function to copy string data into the FPDF_BSTR."]
1169 pub fn FPDF_BStr_Set(
1170 bstr: *mut FPDF_BSTR,
1171 cstr: *const ::std::os::raw::c_char,
1172 length: ::std::os::raw::c_int,
1173 ) -> FPDF_RESULT;
1174}
1175unsafe extern "C" {
1176 #[doc = " Function: FPDF_BStr_Clear\n Helper function to clear a FPDF_BSTR."]
1177 pub fn FPDF_BStr_Clear(bstr: *mut FPDF_BSTR) -> FPDF_RESULT;
1178}
1179unsafe extern "C" {
1180 #[doc = " Experimental API.\n\n Determine if |document| represents a tagged PDF.\n\n For the definition of tagged PDF, See (see 10.7 \"Tagged PDF\" in PDF\n Reference 1.7).\n\n document - handle to a document.\n\n Returns |true| iff |document| is a tagged PDF."]
1181 pub fn FPDFCatalog_IsTagged(document: FPDF_DOCUMENT) -> FPDF_BOOL;
1182}
1183unsafe extern "C" {
1184 #[doc = " Experimental API.\n Gets the language of |document| from the catalog's /Lang entry.\n\n document - handle to a document.\n buffer - a buffer for the language string. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the language string, including the\n trailing NUL character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified.\n\n If |document| has no /Lang entry, an empty string is written to |buffer| and\n 2 is returned. On error, nothing is written to |buffer| and 0 is returned."]
1185 pub fn FPDFCatalog_GetLanguage(
1186 document: FPDF_DOCUMENT,
1187 buffer: *mut FPDF_WCHAR,
1188 buflen: ::std::os::raw::c_ulong,
1189 ) -> ::std::os::raw::c_ulong;
1190}
1191unsafe extern "C" {
1192 #[doc = " Experimental API.\n Sets the language of |document| to |language|.\n\n document - handle to a document.\n language - the language to set to.\n\n Returns TRUE on success."]
1193 pub fn FPDFCatalog_SetLanguage(document: FPDF_DOCUMENT, language: FPDF_WIDESTRING)
1194 -> FPDF_BOOL;
1195}
1196#[doc = " IFPDF_RENDERINFO interface."]
1197#[repr(C)]
1198#[derive(Debug, Copy, Clone)]
1199pub struct _IFSDK_PAUSE {
1200 #[doc = " Version number of the interface. Currently must be 1."]
1201 pub version: ::std::os::raw::c_int,
1202 #[doc = " Method: NeedToPauseNow\n Check if we need to pause a progressive process now.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n Return Value:\n Non-zero for pause now, 0 for continue."]
1203 pub NeedToPauseNow:
1204 ::std::option::Option<unsafe extern "C" fn(pThis: *mut _IFSDK_PAUSE) -> FPDF_BOOL>,
1205 #[doc = " A user defined data pointer, used by user's application. Can be NULL."]
1206 pub user: *mut ::std::os::raw::c_void,
1207}
1208#[doc = " IFPDF_RENDERINFO interface."]
1209pub type IFSDK_PAUSE = _IFSDK_PAUSE;
1210unsafe extern "C" {
1211 #[doc = " Experimental API.\n Function: FPDF_RenderPageBitmapWithColorScheme_Start\n Start to render page contents to a device independent bitmap\n progressively with a specified color scheme for the content.\n Parameters:\n bitmap - Handle to the device independent bitmap (as the\n output buffer). Bitmap handle can be created by\n FPDFBitmap_Create function.\n page - Handle to the page as returned by FPDF_LoadPage\n function.\n start_x - Left pixel position of the display area in the\n bitmap coordinate.\n start_y - Top pixel position of the display area in the\n bitmap coordinate.\n size_x - Horizontal size (in pixels) for displaying the\n page.\n size_y - Vertical size (in pixels) for displaying the page.\n rotate - Page orientation: 0 (normal), 1 (rotated 90\n degrees clockwise), 2 (rotated 180 degrees),\n 3 (rotated 90 degrees counter-clockwise).\n flags - 0 for normal display, or combination of flags\n defined in fpdfview.h. With FPDF_ANNOT flag, it\n renders all annotations that does not require\n user-interaction, which are all annotations except\n widget and popup annotations.\n color_scheme - Color scheme to be used in rendering the |page|.\n If null, this function will work similar to\n FPDF_RenderPageBitmap_Start().\n pause - The IFSDK_PAUSE interface. A callback mechanism\n allowing the page rendering process.\n Return value:\n Rendering Status. See flags for progressive process status for the\n details."]
1212 pub fn FPDF_RenderPageBitmapWithColorScheme_Start(
1213 bitmap: FPDF_BITMAP,
1214 page: FPDF_PAGE,
1215 start_x: ::std::os::raw::c_int,
1216 start_y: ::std::os::raw::c_int,
1217 size_x: ::std::os::raw::c_int,
1218 size_y: ::std::os::raw::c_int,
1219 rotate: ::std::os::raw::c_int,
1220 flags: ::std::os::raw::c_int,
1221 color_scheme: *const FPDF_COLORSCHEME,
1222 pause: *mut IFSDK_PAUSE,
1223 ) -> ::std::os::raw::c_int;
1224}
1225unsafe extern "C" {
1226 #[doc = " Function: FPDF_RenderPageBitmap_Start\n Start to render page contents to a device independent bitmap\n progressively.\n Parameters:\n bitmap - Handle to the device independent bitmap (as the\n output buffer). Bitmap handle can be created by\n FPDFBitmap_Create().\n page - Handle to the page, as returned by FPDF_LoadPage().\n start_x - Left pixel position of the display area in the\n bitmap coordinates.\n start_y - Top pixel position of the display area in the bitmap\n coordinates.\n size_x - Horizontal size (in pixels) for displaying the page.\n size_y - Vertical size (in pixels) for displaying the page.\n rotate - Page orientation: 0 (normal), 1 (rotated 90 degrees\n clockwise), 2 (rotated 180 degrees), 3 (rotated 90\n degrees counter-clockwise).\n flags - 0 for normal display, or combination of flags\n defined in fpdfview.h. With FPDF_ANNOT flag, it\n renders all annotations that does not require\n user-interaction, which are all annotations except\n widget and popup annotations.\n pause - The IFSDK_PAUSE interface.A callback mechanism\n allowing the page rendering process\n Return value:\n Rendering Status. See flags for progressive process status for the\n details."]
1227 pub fn FPDF_RenderPageBitmap_Start(
1228 bitmap: FPDF_BITMAP,
1229 page: FPDF_PAGE,
1230 start_x: ::std::os::raw::c_int,
1231 start_y: ::std::os::raw::c_int,
1232 size_x: ::std::os::raw::c_int,
1233 size_y: ::std::os::raw::c_int,
1234 rotate: ::std::os::raw::c_int,
1235 flags: ::std::os::raw::c_int,
1236 pause: *mut IFSDK_PAUSE,
1237 ) -> ::std::os::raw::c_int;
1238}
1239unsafe extern "C" {
1240 #[doc = " Function: FPDF_RenderPage_Continue\n Continue rendering a PDF page.\n Parameters:\n page - Handle to the page, as returned by FPDF_LoadPage().\n pause - The IFSDK_PAUSE interface (a callback mechanism\n allowing the page rendering process to be paused\n before it's finished). This can be NULL if you\n don't want to pause.\n Return value:\n The rendering status. See flags for progressive process status for\n the details."]
1241 pub fn FPDF_RenderPage_Continue(
1242 page: FPDF_PAGE,
1243 pause: *mut IFSDK_PAUSE,
1244 ) -> ::std::os::raw::c_int;
1245}
1246unsafe extern "C" {
1247 #[doc = " Function: FPDF_RenderPage_Close\n Release the resource allocate during page rendering. Need to be\n called after finishing rendering or\n cancel the rendering.\n Parameters:\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return value:\n None."]
1248 pub fn FPDF_RenderPage_Close(page: FPDF_PAGE);
1249}
1250unsafe extern "C" {
1251 #[doc = " Experimental API.\n Function: FPDF_GetSignatureCount\n Get total number of signatures in the document.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument().\n Return value:\n Total number of signatures in the document on success, -1 on error."]
1252 pub fn FPDF_GetSignatureCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1253}
1254unsafe extern "C" {
1255 #[doc = " Experimental API.\n Function: FPDF_GetSignatureObject\n Get the Nth signature of the document.\n Parameters:\n document - Handle to document. Returned by FPDF_LoadDocument().\n index - Index into the array of signatures of the document.\n Return value:\n Returns the handle to the signature, or NULL on failure. The caller\n does not take ownership of the returned FPDF_SIGNATURE. Instead, it\n remains valid until FPDF_CloseDocument() is called for the document."]
1256 pub fn FPDF_GetSignatureObject(
1257 document: FPDF_DOCUMENT,
1258 index: ::std::os::raw::c_int,
1259 ) -> FPDF_SIGNATURE;
1260}
1261unsafe extern "C" {
1262 #[doc = " Experimental API.\n Function: FPDFSignatureObj_GetContents\n Get the contents of a signature object.\n Parameters:\n signature - Handle to the signature object. Returned by\n FPDF_GetSignatureObject().\n buffer - The address of a buffer that receives the contents.\n length - The size, in bytes, of |buffer|.\n Return value:\n Returns the number of bytes in the contents on success, 0 on error.\n\n For public-key signatures, |buffer| is either a DER-encoded PKCS#1 binary or\n a DER-encoded PKCS#7 binary. If |length| is less than the returned length, or\n |buffer| is NULL, |buffer| will not be modified."]
1263 pub fn FPDFSignatureObj_GetContents(
1264 signature: FPDF_SIGNATURE,
1265 buffer: *mut ::std::os::raw::c_void,
1266 length: ::std::os::raw::c_ulong,
1267 ) -> ::std::os::raw::c_ulong;
1268}
1269unsafe extern "C" {
1270 #[doc = " Experimental API.\n Function: FPDFSignatureObj_GetByteRange\n Get the byte range of a signature object.\n Parameters:\n signature - Handle to the signature object. Returned by\n FPDF_GetSignatureObject().\n buffer - The address of a buffer that receives the\n byte range.\n length - The size, in ints, of |buffer|.\n Return value:\n Returns the number of ints in the byte range on\n success, 0 on error.\n\n |buffer| is an array of pairs of integers (starting byte offset,\n length in bytes) that describes the exact byte range for the digest\n calculation. If |length| is less than the returned length, or\n |buffer| is NULL, |buffer| will not be modified."]
1271 pub fn FPDFSignatureObj_GetByteRange(
1272 signature: FPDF_SIGNATURE,
1273 buffer: *mut ::std::os::raw::c_int,
1274 length: ::std::os::raw::c_ulong,
1275 ) -> ::std::os::raw::c_ulong;
1276}
1277unsafe extern "C" {
1278 #[doc = " Experimental API.\n Function: FPDFSignatureObj_GetSubFilter\n Get the encoding of the value of a signature object.\n Parameters:\n signature - Handle to the signature object. Returned by\n FPDF_GetSignatureObject().\n buffer - The address of a buffer that receives the encoding.\n length - The size, in bytes, of |buffer|.\n Return value:\n Returns the number of bytes in the encoding name (including the\n trailing NUL character) on success, 0 on error.\n\n The |buffer| is always encoded in 7-bit ASCII. If |length| is less than the\n returned length, or |buffer| is NULL, |buffer| will not be modified."]
1279 pub fn FPDFSignatureObj_GetSubFilter(
1280 signature: FPDF_SIGNATURE,
1281 buffer: *mut ::std::os::raw::c_char,
1282 length: ::std::os::raw::c_ulong,
1283 ) -> ::std::os::raw::c_ulong;
1284}
1285unsafe extern "C" {
1286 #[doc = " Experimental API.\n Function: FPDFSignatureObj_GetReason\n Get the reason (comment) of the signature object.\n Parameters:\n signature - Handle to the signature object. Returned by\n FPDF_GetSignatureObject().\n buffer - The address of a buffer that receives the reason.\n length - The size, in bytes, of |buffer|.\n Return value:\n Returns the number of bytes in the reason on success, 0 on error.\n\n Regardless of the platform, the |buffer| is always in UTF-16LE encoding. The\n string is terminated by a UTF16 NUL character. If |length| is less than the\n returned length, or |buffer| is NULL, |buffer| will not be modified."]
1287 pub fn FPDFSignatureObj_GetReason(
1288 signature: FPDF_SIGNATURE,
1289 buffer: *mut ::std::os::raw::c_void,
1290 length: ::std::os::raw::c_ulong,
1291 ) -> ::std::os::raw::c_ulong;
1292}
1293unsafe extern "C" {
1294 #[doc = " Experimental API.\n Function: FPDFSignatureObj_GetTime\n Get the time of signing of a signature object.\n Parameters:\n signature - Handle to the signature object. Returned by\n FPDF_GetSignatureObject().\n buffer - The address of a buffer that receives the time.\n length - The size, in bytes, of |buffer|.\n Return value:\n Returns the number of bytes in the encoding name (including the\n trailing NUL character) on success, 0 on error.\n\n The |buffer| is always encoded in 7-bit ASCII. If |length| is less than the\n returned length, or |buffer| is NULL, |buffer| will not be modified.\n\n The format of time is expected to be D:YYYYMMDDHHMMSS+XX'YY', i.e. it's\n percision is seconds, with timezone information. This value should be used\n only when the time of signing is not available in the (PKCS#7 binary)\n signature."]
1295 pub fn FPDFSignatureObj_GetTime(
1296 signature: FPDF_SIGNATURE,
1297 buffer: *mut ::std::os::raw::c_char,
1298 length: ::std::os::raw::c_ulong,
1299 ) -> ::std::os::raw::c_ulong;
1300}
1301unsafe extern "C" {
1302 #[doc = " Experimental API.\n Function: FPDFSignatureObj_GetDocMDPPermission\n Get the DocMDP permission of a signature object.\n Parameters:\n signature - Handle to the signature object. Returned by\n FPDF_GetSignatureObject().\n Return value:\n Returns the permission (1, 2 or 3) on success, 0 on error."]
1303 pub fn FPDFSignatureObj_GetDocMDPPermission(
1304 signature: FPDF_SIGNATURE,
1305 ) -> ::std::os::raw::c_uint;
1306}
1307#[doc = " Interface for checking whether sections of the file are available."]
1308#[repr(C)]
1309#[derive(Debug, Copy, Clone)]
1310pub struct _FX_FILEAVAIL {
1311 #[doc = " Version number of the interface. Must be 1."]
1312 pub version: ::std::os::raw::c_int,
1313 #[doc = " Reports if the specified data section is currently available. A section is\n available if all bytes in the section are available.\n\n Interface Version: 1\n Implementation Required: Yes\n\n pThis - pointer to the interface structure.\n offset - the offset of the data section in the file.\n size - the size of the data section.\n\n Returns true if the specified data section at |offset| of |size|\n is available."]
1314 pub IsDataAvail: ::std::option::Option<
1315 unsafe extern "C" fn(pThis: *mut _FX_FILEAVAIL, offset: usize, size: usize) -> FPDF_BOOL,
1316 >,
1317}
1318#[doc = " Interface for checking whether sections of the file are available."]
1319pub type FX_FILEAVAIL = _FX_FILEAVAIL;
1320unsafe extern "C" {
1321 #[doc = " Create a document availability provider.\n\n file_avail - pointer to file availability interface.\n file - pointer to a file access interface.\n\n Returns a handle to the document availability provider, or NULL on error.\n\n FPDFAvail_Destroy() must be called when done with the availability provider."]
1322 pub fn FPDFAvail_Create(
1323 file_avail: *mut FX_FILEAVAIL,
1324 file: *mut FPDF_FILEACCESS,
1325 ) -> FPDF_AVAIL;
1326}
1327unsafe extern "C" {
1328 #[doc = " Destroy the |avail| document availability provider.\n\n avail - handle to document availability provider to be destroyed."]
1329 pub fn FPDFAvail_Destroy(avail: FPDF_AVAIL);
1330}
1331#[doc = " Download hints interface. Used to receive hints for further downloading."]
1332#[repr(C)]
1333#[derive(Debug, Copy, Clone)]
1334pub struct _FX_DOWNLOADHINTS {
1335 #[doc = " Version number of the interface. Must be 1."]
1336 pub version: ::std::os::raw::c_int,
1337 #[doc = " Add a section to be downloaded.\n\n Interface Version: 1\n Implementation Required: Yes\n\n pThis - pointer to the interface structure.\n offset - the offset of the hint reported to be downloaded.\n size - the size of the hint reported to be downloaded.\n\n The |offset| and |size| of the section may not be unique. Part of the\n section might be already available. The download manager must deal with\n overlapping sections."]
1338 pub AddSegment: ::std::option::Option<
1339 unsafe extern "C" fn(pThis: *mut _FX_DOWNLOADHINTS, offset: usize, size: usize),
1340 >,
1341}
1342#[doc = " Download hints interface. Used to receive hints for further downloading."]
1343pub type FX_DOWNLOADHINTS = _FX_DOWNLOADHINTS;
1344unsafe extern "C" {
1345 #[doc = " Checks if the document is ready for loading, if not, gets download hints.\n\n avail - handle to document availability provider.\n hints - pointer to a download hints interface.\n\n Returns one of:\n PDF_DATA_ERROR: A common error is returned. Data availability unknown.\n PDF_DATA_NOTAVAIL: Data not yet available.\n PDF_DATA_AVAIL: Data available.\n\n Applications should call this function whenever new data arrives, and process\n all the generated download hints, if any, until the function returns\n |PDF_DATA_ERROR| or |PDF_DATA_AVAIL|.\n if hints is nullptr, the function just check current document availability.\n\n Once all data is available, call FPDFAvail_GetDocument() to get a document\n handle."]
1346 pub fn FPDFAvail_IsDocAvail(
1347 avail: FPDF_AVAIL,
1348 hints: *mut FX_DOWNLOADHINTS,
1349 ) -> ::std::os::raw::c_int;
1350}
1351unsafe extern "C" {
1352 #[doc = " Get document from the availability provider.\n\n avail - handle to document availability provider.\n password - password for decrypting the PDF file. Optional.\n\n Returns a handle to the document.\n\n When FPDFAvail_IsDocAvail() returns TRUE, call FPDFAvail_GetDocument() to\n retrieve the document handle.\n See the comments for FPDF_LoadDocument() regarding the encoding for\n |password|."]
1353 pub fn FPDFAvail_GetDocument(avail: FPDF_AVAIL, password: FPDF_BYTESTRING) -> FPDF_DOCUMENT;
1354}
1355unsafe extern "C" {
1356 #[doc = " Get the page number for the first available page in a linearized PDF.\n\n doc - document handle.\n\n Returns the zero-based index for the first available page.\n\n For most linearized PDFs, the first available page will be the first page,\n however, some PDFs might make another page the first available page.\n For non-linearized PDFs, this function will always return zero."]
1357 pub fn FPDFAvail_GetFirstPageNum(doc: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1358}
1359unsafe extern "C" {
1360 #[doc = " Check if |page_index| is ready for loading, if not, get the\n |FX_DOWNLOADHINTS|.\n\n avail - handle to document availability provider.\n page_index - index number of the page. Zero for the first page.\n hints - pointer to a download hints interface. Populated if\n |page_index| is not available.\n\n Returns one of:\n PDF_DATA_ERROR: A common error is returned. Data availability unknown.\n PDF_DATA_NOTAVAIL: Data not yet available.\n PDF_DATA_AVAIL: Data available.\n\n This function can be called only after FPDFAvail_GetDocument() is called.\n Applications should call this function whenever new data arrives and process\n all the generated download |hints|, if any, until this function returns\n |PDF_DATA_ERROR| or |PDF_DATA_AVAIL|. Applications can then perform page\n loading.\n if hints is nullptr, the function just check current availability of\n specified page."]
1361 pub fn FPDFAvail_IsPageAvail(
1362 avail: FPDF_AVAIL,
1363 page_index: ::std::os::raw::c_int,
1364 hints: *mut FX_DOWNLOADHINTS,
1365 ) -> ::std::os::raw::c_int;
1366}
1367unsafe extern "C" {
1368 #[doc = " Check if form data is ready for initialization, if not, get the\n |FX_DOWNLOADHINTS|.\n\n avail - handle to document availability provider.\n hints - pointer to a download hints interface. Populated if form is not\n ready for initialization.\n\n Returns one of:\n PDF_FORM_ERROR: A common eror, in general incorrect parameters.\n PDF_FORM_NOTAVAIL: Data not available.\n PDF_FORM_AVAIL: Data available.\n PDF_FORM_NOTEXIST: No form data.\n\n This function can be called only after FPDFAvail_GetDocument() is called.\n The application should call this function whenever new data arrives and\n process all the generated download |hints|, if any, until the function\n |PDF_FORM_ERROR|, |PDF_FORM_AVAIL| or |PDF_FORM_NOTEXIST|.\n if hints is nullptr, the function just check current form availability.\n\n Applications can then perform page loading. It is recommend to call\n FPDFDOC_InitFormFillEnvironment() when |PDF_FORM_AVAIL| is returned."]
1369 pub fn FPDFAvail_IsFormAvail(
1370 avail: FPDF_AVAIL,
1371 hints: *mut FX_DOWNLOADHINTS,
1372 ) -> ::std::os::raw::c_int;
1373}
1374unsafe extern "C" {
1375 #[doc = " Check whether a document is a linearized PDF.\n\n avail - handle to document availability provider.\n\n Returns one of:\n PDF_LINEARIZED\n PDF_NOT_LINEARIZED\n PDF_LINEARIZATION_UNKNOWN\n\n FPDFAvail_IsLinearized() will return |PDF_LINEARIZED| or |PDF_NOT_LINEARIZED|\n when we have 1k of data. If the files size less than 1k, it returns\n |PDF_LINEARIZATION_UNKNOWN| as there is insufficient information to determine\n if the PDF is linearlized."]
1376 pub fn FPDFAvail_IsLinearized(avail: FPDF_AVAIL) -> ::std::os::raw::c_int;
1377}
1378#[doc = " Convenience types."]
1379pub type __u_char = ::std::os::raw::c_uchar;
1380pub type __u_short = ::std::os::raw::c_ushort;
1381pub type __u_int = ::std::os::raw::c_uint;
1382pub type __u_long = ::std::os::raw::c_ulong;
1383#[doc = " Fixed-size types, underlying types depend on word size and compiler."]
1384pub type __int8_t = ::std::os::raw::c_schar;
1385pub type __uint8_t = ::std::os::raw::c_uchar;
1386pub type __int16_t = ::std::os::raw::c_short;
1387pub type __uint16_t = ::std::os::raw::c_ushort;
1388pub type __int32_t = ::std::os::raw::c_int;
1389pub type __uint32_t = ::std::os::raw::c_uint;
1390pub type __int64_t = ::std::os::raw::c_long;
1391pub type __uint64_t = ::std::os::raw::c_ulong;
1392#[doc = " Smallest types with at least a given width."]
1393pub type __int_least8_t = __int8_t;
1394pub type __uint_least8_t = __uint8_t;
1395pub type __int_least16_t = __int16_t;
1396pub type __uint_least16_t = __uint16_t;
1397pub type __int_least32_t = __int32_t;
1398pub type __uint_least32_t = __uint32_t;
1399pub type __int_least64_t = __int64_t;
1400pub type __uint_least64_t = __uint64_t;
1401pub type __quad_t = ::std::os::raw::c_long;
1402pub type __u_quad_t = ::std::os::raw::c_ulong;
1403pub type __intmax_t = ::std::os::raw::c_long;
1404pub type __uintmax_t = ::std::os::raw::c_ulong;
1405pub type __dev_t = ::std::os::raw::c_ulong;
1406pub type __uid_t = ::std::os::raw::c_uint;
1407pub type __gid_t = ::std::os::raw::c_uint;
1408pub type __ino_t = ::std::os::raw::c_ulong;
1409pub type __ino64_t = ::std::os::raw::c_ulong;
1410pub type __mode_t = ::std::os::raw::c_uint;
1411pub type __nlink_t = ::std::os::raw::c_ulong;
1412pub type __off_t = ::std::os::raw::c_long;
1413pub type __off64_t = ::std::os::raw::c_long;
1414pub type __pid_t = ::std::os::raw::c_int;
1415#[repr(C)]
1416#[derive(Debug, Copy, Clone)]
1417pub struct __fsid_t {
1418 pub __val: [::std::os::raw::c_int; 2usize],
1419}
1420pub type __clock_t = ::std::os::raw::c_long;
1421pub type __rlim_t = ::std::os::raw::c_ulong;
1422pub type __rlim64_t = ::std::os::raw::c_ulong;
1423pub type __id_t = ::std::os::raw::c_uint;
1424pub type __time_t = ::std::os::raw::c_long;
1425pub type __useconds_t = ::std::os::raw::c_uint;
1426pub type __suseconds_t = ::std::os::raw::c_long;
1427pub type __suseconds64_t = ::std::os::raw::c_long;
1428pub type __daddr_t = ::std::os::raw::c_int;
1429pub type __key_t = ::std::os::raw::c_int;
1430pub type __clockid_t = ::std::os::raw::c_int;
1431pub type __timer_t = *mut ::std::os::raw::c_void;
1432pub type __blksize_t = ::std::os::raw::c_long;
1433pub type __blkcnt_t = ::std::os::raw::c_long;
1434pub type __blkcnt64_t = ::std::os::raw::c_long;
1435pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
1436pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
1437pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
1438pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
1439pub type __fsword_t = ::std::os::raw::c_long;
1440pub type __ssize_t = ::std::os::raw::c_long;
1441pub type __syscall_slong_t = ::std::os::raw::c_long;
1442pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
1443#[doc = " These few don't really vary by system, they always correspond\nto one of the other defined types."]
1444pub type __loff_t = __off64_t;
1445pub type __caddr_t = *mut ::std::os::raw::c_char;
1446pub type __intptr_t = ::std::os::raw::c_long;
1447pub type __socklen_t = ::std::os::raw::c_uint;
1448#[doc = " C99: An integer type that can be accessed as an atomic entity,\neven in the presence of asynchronous interrupts.\nIt is not currently necessary for this to be machine-specific."]
1449pub type __sig_atomic_t = ::std::os::raw::c_int;
1450#[doc = " Signed."]
1451pub type int_least8_t = __int_least8_t;
1452pub type int_least16_t = __int_least16_t;
1453pub type int_least32_t = __int_least32_t;
1454pub type int_least64_t = __int_least64_t;
1455#[doc = " Unsigned."]
1456pub type uint_least8_t = __uint_least8_t;
1457pub type uint_least16_t = __uint_least16_t;
1458pub type uint_least32_t = __uint_least32_t;
1459pub type uint_least64_t = __uint_least64_t;
1460#[doc = " Signed."]
1461pub type int_fast8_t = ::std::os::raw::c_schar;
1462pub type int_fast16_t = ::std::os::raw::c_long;
1463pub type int_fast32_t = ::std::os::raw::c_long;
1464pub type int_fast64_t = ::std::os::raw::c_long;
1465#[doc = " Unsigned."]
1466pub type uint_fast8_t = ::std::os::raw::c_uchar;
1467pub type uint_fast16_t = ::std::os::raw::c_ulong;
1468pub type uint_fast32_t = ::std::os::raw::c_ulong;
1469pub type uint_fast64_t = ::std::os::raw::c_ulong;
1470#[doc = " Largest integral types."]
1471pub type intmax_t = __intmax_t;
1472pub type uintmax_t = __uintmax_t;
1473unsafe extern "C" {
1474 #[doc = " Experimental API.\n Gets the decoded data from the thumbnail of |page| if it exists.\n This only modifies |buffer| if |buflen| less than or equal to the\n size of the decoded data. Returns the size of the decoded\n data or 0 if thumbnail DNE. Optional, pass null to just retrieve\n the size of the buffer needed.\n\n page - handle to a page.\n buffer - buffer for holding the decoded image data.\n buflen - length of the buffer in bytes."]
1475 pub fn FPDFPage_GetDecodedThumbnailData(
1476 page: FPDF_PAGE,
1477 buffer: *mut ::std::os::raw::c_void,
1478 buflen: ::std::os::raw::c_ulong,
1479 ) -> ::std::os::raw::c_ulong;
1480}
1481unsafe extern "C" {
1482 #[doc = " Experimental API.\n Gets the raw data from the thumbnail of |page| if it exists.\n This only modifies |buffer| if |buflen| is less than or equal to\n the size of the raw data. Returns the size of the raw data or 0\n if thumbnail DNE. Optional, pass null to just retrieve the size\n of the buffer needed.\n\n page - handle to a page.\n buffer - buffer for holding the raw image data.\n buflen - length of the buffer in bytes."]
1483 pub fn FPDFPage_GetRawThumbnailData(
1484 page: FPDF_PAGE,
1485 buffer: *mut ::std::os::raw::c_void,
1486 buflen: ::std::os::raw::c_ulong,
1487 ) -> ::std::os::raw::c_ulong;
1488}
1489unsafe extern "C" {
1490 #[doc = " Experimental API.\n Returns the thumbnail of |page| as a FPDF_BITMAP. Returns a nullptr\n if unable to access the thumbnail's stream.\n\n page - handle to a page."]
1491 pub fn FPDFPage_GetThumbnailAsBitmap(page: FPDF_PAGE) -> FPDF_BITMAP;
1492}
1493#[doc = " Interface: FPDF_SYSFONTINFO\n Interface for getting system font information and font mapping"]
1494#[repr(C)]
1495#[derive(Debug, Copy, Clone)]
1496pub struct _FPDF_SYSFONTINFO {
1497 #[doc = " Version number of the interface. Currently must be 1 or 2.\n Version 1: Traditional behavior - calls EnumFonts during initialization.\n Version 2: Per-request behavior - skips EnumFonts, relies on MapFont.\n Experimental: Subject to change based on feedback."]
1498 pub version: ::std::os::raw::c_int,
1499 #[doc = " Method: Release\n Give implementation a chance to release any data after the\n interface is no longer used.\n Interface Version:\n 1 and 2\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n Return Value:\n None\n Comments:\n Called by PDFium during the final cleanup process."]
1500 pub Release: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO)>,
1501 #[doc = " Method: EnumFonts\n Enumerate all fonts installed on the system\n Interface Version:\n 1\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n pMapper - An opaque pointer to internal font mapper, used\n when calling FPDF_AddInstalledFont().\n Return Value:\n None\n Comments:\n Implementations should call FPDF_AddInstalledFont() function for\n each font found. Only TrueType/OpenType and Type1 fonts are\n accepted by PDFium.\n NOTE: This method will not be called when version is set to 2.\n Version 2 relies entirely on MapFont() for per-request matching."]
1502 pub EnumFonts: ::std::option::Option<
1503 unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO, pMapper: *mut ::std::os::raw::c_void),
1504 >,
1505 #[doc = " Method: MapFont\n Use the system font mapper to get a font handle from requested\n parameters.\n Interface Version:\n 1 and 2\n Implementation Required:\n Required if GetFont method is not implemented.\n Parameters:\n pThis - Pointer to the interface structure itself\n weight - Weight of the requested font. 400 is normal and\n 700 is bold.\n bItalic - Italic option of the requested font, TRUE or\n FALSE.\n charset - Character set identifier for the requested font.\n See above defined constants.\n pitch_family - A combination of flags. See above defined\n constants.\n face - Typeface name. Currently use system local encoding\n only.\n bExact - Obsolete: this parameter is now ignored.\n Return Value:\n An opaque pointer for font handle, or NULL if system mapping is\n not supported.\n Comments:\n If the system supports native font mapper (like Windows),\n implementation can implement this method to get a font handle.\n Otherwise, PDFium will do the mapping and then call GetFont\n method. Only TrueType/OpenType and Type1 fonts are accepted\n by PDFium."]
1506 pub MapFont: ::std::option::Option<
1507 unsafe extern "C" fn(
1508 pThis: *mut _FPDF_SYSFONTINFO,
1509 weight: ::std::os::raw::c_int,
1510 bItalic: FPDF_BOOL,
1511 charset: ::std::os::raw::c_int,
1512 pitch_family: ::std::os::raw::c_int,
1513 face: *const ::std::os::raw::c_char,
1514 bExact: *mut FPDF_BOOL,
1515 ) -> *mut ::std::os::raw::c_void,
1516 >,
1517 #[doc = " Method: GetFont\n Get a handle to a particular font by its internal ID\n Interface Version:\n 1 and 2\n Implementation Required:\n Required if MapFont method is not implemented.\n Return Value:\n An opaque pointer for font handle.\n Parameters:\n pThis - Pointer to the interface structure itself\n face - Typeface name in system local encoding.\n Comments:\n If the system mapping not supported, PDFium will do the font\n mapping and use this method to get a font handle."]
1518 pub GetFont: ::std::option::Option<
1519 unsafe extern "C" fn(
1520 pThis: *mut _FPDF_SYSFONTINFO,
1521 face: *const ::std::os::raw::c_char,
1522 ) -> *mut ::std::os::raw::c_void,
1523 >,
1524 #[doc = " Method: GetFontData\n Get font data from a font\n Interface Version:\n 1 and 2\n Implementation Required:\n Yes\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n table - TrueType/OpenType table identifier (refer to\n TrueType specification), or 0 for the whole file.\n buffer - The buffer receiving the font data. Can be NULL if\n not provided.\n buf_size - Buffer size, can be zero if not provided.\n Return Value:\n Number of bytes needed, if buffer not provided or not large\n enough, or number of bytes written into buffer otherwise.\n Comments:\n Can read either the full font file, or a particular\n TrueType/OpenType table."]
1525 pub GetFontData: ::std::option::Option<
1526 unsafe extern "C" fn(
1527 pThis: *mut _FPDF_SYSFONTINFO,
1528 hFont: *mut ::std::os::raw::c_void,
1529 table: ::std::os::raw::c_uint,
1530 buffer: *mut ::std::os::raw::c_uchar,
1531 buf_size: ::std::os::raw::c_ulong,
1532 ) -> ::std::os::raw::c_ulong,
1533 >,
1534 #[doc = " Method: GetFaceName\n Get face name from a font handle\n Interface Version:\n 1 and 2\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n buffer - The buffer receiving the face name. Can be NULL if\n not provided\n buf_size - Buffer size, can be zero if not provided\n Return Value:\n Number of bytes needed, if buffer not provided or not large\n enough, or number of bytes written into buffer otherwise."]
1535 pub GetFaceName: ::std::option::Option<
1536 unsafe extern "C" fn(
1537 pThis: *mut _FPDF_SYSFONTINFO,
1538 hFont: *mut ::std::os::raw::c_void,
1539 buffer: *mut ::std::os::raw::c_char,
1540 buf_size: ::std::os::raw::c_ulong,
1541 ) -> ::std::os::raw::c_ulong,
1542 >,
1543 #[doc = " Method: GetFontCharset\n Get character set information for a font handle\n Interface Version:\n 1 and 2\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n Return Value:\n Character set identifier. See defined constants above."]
1544 pub GetFontCharset: ::std::option::Option<
1545 unsafe extern "C" fn(
1546 pThis: *mut _FPDF_SYSFONTINFO,
1547 hFont: *mut ::std::os::raw::c_void,
1548 ) -> ::std::os::raw::c_int,
1549 >,
1550 #[doc = " Method: DeleteFont\n Delete a font handle\n Interface Version:\n 1 and 2\n Implementation Required:\n Yes\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n Return Value:\n None"]
1551 pub DeleteFont: ::std::option::Option<
1552 unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO, hFont: *mut ::std::os::raw::c_void),
1553 >,
1554}
1555#[doc = " Interface: FPDF_SYSFONTINFO\n Interface for getting system font information and font mapping"]
1556pub type FPDF_SYSFONTINFO = _FPDF_SYSFONTINFO;
1557#[doc = " Struct: FPDF_CharsetFontMap\n Provides the name of a font to use for a given charset value."]
1558#[repr(C)]
1559#[derive(Debug, Copy, Clone)]
1560pub struct FPDF_CharsetFontMap_ {
1561 #[doc = " Character Set Enum value, see FXFONT_*_CHARSET above."]
1562 pub charset: ::std::os::raw::c_int,
1563 #[doc = " Name of default font to use with that charset."]
1564 pub fontname: *const ::std::os::raw::c_char,
1565}
1566#[doc = " Struct: FPDF_CharsetFontMap\n Provides the name of a font to use for a given charset value."]
1567pub type FPDF_CharsetFontMap = FPDF_CharsetFontMap_;
1568unsafe extern "C" {
1569 #[doc = " Function: FPDF_GetDefaultTTFMap\n Returns a pointer to the default character set to TT Font name map. The\n map is an array of FPDF_CharsetFontMap structs, with its end indicated\n by a { -1, NULL } entry.\n Parameters:\n None.\n Return Value:\n Pointer to the Charset Font Map.\n Note:\n Once FPDF_GetDefaultTTFMapCount() and FPDF_GetDefaultTTFMapEntry() are no\n longer experimental, this API will be marked as deprecated.\n See https://crbug.com/348468114"]
1570 pub fn FPDF_GetDefaultTTFMap() -> *const FPDF_CharsetFontMap;
1571}
1572unsafe extern "C" {
1573 #[doc = " Experimental API.\n\n Function: FPDF_GetDefaultTTFMapCount\n Returns the number of entries in the default character set to TT Font name\n map.\n Parameters:\n None.\n Return Value:\n The number of entries in the map."]
1574 pub fn FPDF_GetDefaultTTFMapCount() -> usize;
1575}
1576unsafe extern "C" {
1577 #[doc = " Experimental API.\n\n Function: FPDF_GetDefaultTTFMapEntry\n Returns an entry in the default character set to TT Font name map.\n Parameters:\n index - The index to the entry in the map to retrieve.\n Return Value:\n A pointer to the entry, if it is in the map, or NULL if the index is out\n of bounds."]
1578 pub fn FPDF_GetDefaultTTFMapEntry(index: usize) -> *const FPDF_CharsetFontMap;
1579}
1580unsafe extern "C" {
1581 #[doc = " Function: FPDF_AddInstalledFont\n Add a system font to the list in PDFium.\n Comments:\n This function is only called during the system font list building\n process.\n Parameters:\n mapper - Opaque pointer to Foxit font mapper\n face - The font face name\n charset - Font character set. See above defined constants.\n Return Value:\n None."]
1582 pub fn FPDF_AddInstalledFont(
1583 mapper: *mut ::std::os::raw::c_void,
1584 face: *const ::std::os::raw::c_char,
1585 charset: ::std::os::raw::c_int,
1586 );
1587}
1588unsafe extern "C" {
1589 #[doc = " Function: FPDF_SetSystemFontInfo\n Set the system font info interface into PDFium\n Parameters:\n font_info - Pointer to a FPDF_SYSFONTINFO structure\n Return Value:\n None\n Comments:\n Platform support implementation should implement required methods of\n FFDF_SYSFONTINFO interface, then call this function during PDFium\n initialization process.\n\n Call this with NULL to tell PDFium to stop using a previously set\n |FPDF_SYSFONTINFO|."]
1590 pub fn FPDF_SetSystemFontInfo(font_info: *mut FPDF_SYSFONTINFO);
1591}
1592unsafe extern "C" {
1593 #[doc = " Function: FPDF_GetDefaultSystemFontInfo\n Get default system font info interface for current platform\n Parameters:\n None\n Return Value:\n Pointer to a FPDF_SYSFONTINFO structure describing the default\n interface, or NULL if the platform doesn't have a default interface.\n Application should call FPDF_FreeDefaultSystemFontInfo to free the\n returned pointer.\n Comments:\n For some platforms, PDFium implements a default version of system\n font info interface. The default implementation can be passed to\n FPDF_SetSystemFontInfo()."]
1594 pub fn FPDF_GetDefaultSystemFontInfo() -> *mut FPDF_SYSFONTINFO;
1595}
1596unsafe extern "C" {
1597 #[doc = " Function: FPDF_FreeDefaultSystemFontInfo\n Free a default system font info interface\n Parameters:\n font_info - Pointer to a FPDF_SYSFONTINFO structure\n Return Value:\n None\n Comments:\n This function should be called on the output from\n FPDF_GetDefaultSystemFontInfo() once it is no longer needed."]
1598 pub fn FPDF_FreeDefaultSystemFontInfo(font_info: *mut FPDF_SYSFONTINFO);
1599}
1600unsafe extern "C" {
1601 #[doc = " Function: FPDFText_LoadPage\n Prepare information about all characters in a page.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage function\n (in FPDFVIEW module).\n Return value:\n A handle to the text page information structure.\n NULL if something goes wrong.\n Comments:\n Application must call FPDFText_ClosePage to release the text page\n information.\n"]
1602 pub fn FPDFText_LoadPage(page: FPDF_PAGE) -> FPDF_TEXTPAGE;
1603}
1604unsafe extern "C" {
1605 #[doc = " Function: FPDFText_ClosePage\n Release all resources allocated for a text page information\n structure.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n Return Value:\n None.\n"]
1606 pub fn FPDFText_ClosePage(text_page: FPDF_TEXTPAGE);
1607}
1608unsafe extern "C" {
1609 #[doc = " Function: FPDFText_CountChars\n Get number of characters in a page.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n Return value:\n Number of characters in the page. Return -1 for error.\n Generated characters, like additional space characters, new line\n characters, are also counted.\n Comments:\n Characters in a page form a \"stream\", inside the stream, each\n character has an index.\n We will use the index parameters in many of FPDFTEXT functions. The\n first character in the page\n has an index value of zero.\n"]
1610 pub fn FPDFText_CountChars(text_page: FPDF_TEXTPAGE) -> ::std::os::raw::c_int;
1611}
1612unsafe extern "C" {
1613 #[doc = " Function: FPDFText_GetUnicode\n Get Unicode of a character in a page.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n The Unicode of the particular character.\n If a character is not encoded in Unicode and Foxit engine can't\n convert to Unicode,\n the return value will be zero.\n"]
1614 pub fn FPDFText_GetUnicode(
1615 text_page: FPDF_TEXTPAGE,
1616 index: ::std::os::raw::c_int,
1617 ) -> ::std::os::raw::c_uint;
1618}
1619unsafe extern "C" {
1620 #[doc = " Experimental API.\n Function: FPDFText_GetTextObject\n Get the FPDF_PAGEOBJECT associated with a given character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n The associated text object for the character at |index|, or NULL on\n error. The returned text object, if non-null, is of type\n |FPDF_PAGEOBJ_TEXT|. The caller does not own the returned object.\n"]
1621 pub fn FPDFText_GetTextObject(
1622 text_page: FPDF_TEXTPAGE,
1623 index: ::std::os::raw::c_int,
1624 ) -> FPDF_PAGEOBJECT;
1625}
1626unsafe extern "C" {
1627 #[doc = " Experimental API.\n Function: FPDFText_IsGenerated\n Get if a character in a page is generated by PDFium.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n 1 if the character is generated by PDFium.\n 0 if the character is not generated by PDFium.\n -1 if there was an error.\n"]
1628 pub fn FPDFText_IsGenerated(
1629 text_page: FPDF_TEXTPAGE,
1630 index: ::std::os::raw::c_int,
1631 ) -> ::std::os::raw::c_int;
1632}
1633unsafe extern "C" {
1634 #[doc = " Experimental API.\n Function: FPDFText_IsHyphen\n Get if a character in a page is a hyphen.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n 1 if the character is a hyphen.\n 0 if the character is not a hyphen.\n -1 if there was an error.\n"]
1635 pub fn FPDFText_IsHyphen(
1636 text_page: FPDF_TEXTPAGE,
1637 index: ::std::os::raw::c_int,
1638 ) -> ::std::os::raw::c_int;
1639}
1640unsafe extern "C" {
1641 #[doc = " Experimental API.\n Function: FPDFText_HasUnicodeMapError\n Get if a character in a page has an invalid unicode mapping.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n 1 if the character has an invalid unicode mapping.\n 0 if the character has no known unicode mapping issues.\n -1 if there was an error.\n"]
1642 pub fn FPDFText_HasUnicodeMapError(
1643 text_page: FPDF_TEXTPAGE,
1644 index: ::std::os::raw::c_int,
1645 ) -> ::std::os::raw::c_int;
1646}
1647unsafe extern "C" {
1648 #[doc = " Function: FPDFText_GetFontSize\n Get the font size of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n The font size of the particular character, measured in points (about\n 1/72 inch). This is the typographic size of the font (so called\n \"em size\").\n"]
1649 pub fn FPDFText_GetFontSize(text_page: FPDF_TEXTPAGE, index: ::std::os::raw::c_int) -> f64;
1650}
1651unsafe extern "C" {
1652 #[doc = " Experimental API.\n Function: FPDFText_GetFontInfo\n Get the font name and flags of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n buffer - A buffer receiving the font name.\n buflen - The length of |buffer| in bytes.\n flags - Optional pointer to an int receiving the font flags.\n These flags should be interpreted per PDF spec 1.7\n Section 5.7.1 Font Descriptor Flags.\n Return value:\n On success, return the length of the font name, including the\n trailing NUL character, in bytes. If this length is less than or\n equal to |length|, |buffer| is set to the font name, |flags| is\n set to the font flags. |buffer| is in UTF-8 encoding. Return 0 on\n failure.\n"]
1653 pub fn FPDFText_GetFontInfo(
1654 text_page: FPDF_TEXTPAGE,
1655 index: ::std::os::raw::c_int,
1656 buffer: *mut ::std::os::raw::c_void,
1657 buflen: ::std::os::raw::c_ulong,
1658 flags: *mut ::std::os::raw::c_int,
1659 ) -> ::std::os::raw::c_ulong;
1660}
1661unsafe extern "C" {
1662 #[doc = " Experimental API.\n Function: FPDFText_GetFontWeight\n Get the font weight of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return value:\n On success, return the font weight of the particular character. If\n |text_page| is invalid, if |index| is out of bounds, or if the\n character's text object is undefined, return -1.\n"]
1663 pub fn FPDFText_GetFontWeight(
1664 text_page: FPDF_TEXTPAGE,
1665 index: ::std::os::raw::c_int,
1666 ) -> ::std::os::raw::c_int;
1667}
1668unsafe extern "C" {
1669 #[doc = " Experimental API.\n Function: FPDFText_GetFillColor\n Get the fill color of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n R - Pointer to an unsigned int number receiving the\n red value of the fill color.\n G - Pointer to an unsigned int number receiving the\n green value of the fill color.\n B - Pointer to an unsigned int number receiving the\n blue value of the fill color.\n A - Pointer to an unsigned int number receiving the\n alpha value of the fill color.\n Return value:\n Whether the call succeeded. If false, |R|, |G|, |B| and |A| are\n unchanged.\n"]
1670 pub fn FPDFText_GetFillColor(
1671 text_page: FPDF_TEXTPAGE,
1672 index: ::std::os::raw::c_int,
1673 R: *mut ::std::os::raw::c_uint,
1674 G: *mut ::std::os::raw::c_uint,
1675 B: *mut ::std::os::raw::c_uint,
1676 A: *mut ::std::os::raw::c_uint,
1677 ) -> FPDF_BOOL;
1678}
1679unsafe extern "C" {
1680 #[doc = " Experimental API.\n Function: FPDFText_GetStrokeColor\n Get the stroke color of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n R - Pointer to an unsigned int number receiving the\n red value of the stroke color.\n G - Pointer to an unsigned int number receiving the\n green value of the stroke color.\n B - Pointer to an unsigned int number receiving the\n blue value of the stroke color.\n A - Pointer to an unsigned int number receiving the\n alpha value of the stroke color.\n Return value:\n Whether the call succeeded. If false, |R|, |G|, |B| and |A| are\n unchanged.\n"]
1681 pub fn FPDFText_GetStrokeColor(
1682 text_page: FPDF_TEXTPAGE,
1683 index: ::std::os::raw::c_int,
1684 R: *mut ::std::os::raw::c_uint,
1685 G: *mut ::std::os::raw::c_uint,
1686 B: *mut ::std::os::raw::c_uint,
1687 A: *mut ::std::os::raw::c_uint,
1688 ) -> FPDF_BOOL;
1689}
1690unsafe extern "C" {
1691 #[doc = " Experimental API.\n Function: FPDFText_GetCharAngle\n Get character rotation angle.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n Return Value:\n On success, return the angle value in radian. Value will always be\n greater or equal to 0. If |text_page| is invalid, or if |index| is\n out of bounds, then return -1.\n"]
1692 pub fn FPDFText_GetCharAngle(text_page: FPDF_TEXTPAGE, index: ::std::os::raw::c_int) -> f32;
1693}
1694unsafe extern "C" {
1695 #[doc = " Function: FPDFText_GetCharBox\n Get bounding box of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n left - Pointer to a double number receiving left position\n of the character box.\n right - Pointer to a double number receiving right position\n of the character box.\n bottom - Pointer to a double number receiving bottom position\n of the character box.\n top - Pointer to a double number receiving top position of\n the character box.\n Return Value:\n On success, return TRUE and fill in |left|, |right|, |bottom|, and\n |top|. If |text_page| is invalid, or if |index| is out of bounds,\n then return FALSE, and the out parameters remain unmodified.\n Comments:\n All positions are measured in PDF \"user space\".\n"]
1696 pub fn FPDFText_GetCharBox(
1697 text_page: FPDF_TEXTPAGE,
1698 index: ::std::os::raw::c_int,
1699 left: *mut f64,
1700 right: *mut f64,
1701 bottom: *mut f64,
1702 top: *mut f64,
1703 ) -> FPDF_BOOL;
1704}
1705unsafe extern "C" {
1706 #[doc = " Experimental API.\n Function: FPDFText_GetLooseCharBox\n Get a \"loose\" bounding box of a particular character, i.e., covering\n the entire glyph bounds, without taking the actual glyph shape into\n account.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n rect - Pointer to a FS_RECTF receiving the character box.\n Return Value:\n On success, return TRUE and fill in |rect|. If |text_page| is\n invalid, or if |index| is out of bounds, then return FALSE, and the\n |rect| out parameter remains unmodified.\n Comments:\n All positions are measured in PDF \"user space\".\n"]
1707 pub fn FPDFText_GetLooseCharBox(
1708 text_page: FPDF_TEXTPAGE,
1709 index: ::std::os::raw::c_int,
1710 rect: *mut FS_RECTF,
1711 ) -> FPDF_BOOL;
1712}
1713unsafe extern "C" {
1714 #[doc = " Experimental API.\n Function: FPDFText_GetMatrix\n Get the effective transformation matrix for a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage().\n index - Zero-based index of the character.\n matrix - Pointer to a FS_MATRIX receiving the transformation\n matrix.\n Return Value:\n On success, return TRUE and fill in |matrix|. If |text_page| is\n invalid, or if |index| is out of bounds, or if |matrix| is NULL,\n then return FALSE, and |matrix| remains unmodified.\n"]
1715 pub fn FPDFText_GetMatrix(
1716 text_page: FPDF_TEXTPAGE,
1717 index: ::std::os::raw::c_int,
1718 matrix: *mut FS_MATRIX,
1719 ) -> FPDF_BOOL;
1720}
1721unsafe extern "C" {
1722 #[doc = " Function: FPDFText_GetCharOrigin\n Get origin of a particular character.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n index - Zero-based index of the character.\n x - Pointer to a double number receiving x coordinate of\n the character origin.\n y - Pointer to a double number receiving y coordinate of\n the character origin.\n Return Value:\n Whether the call succeeded. If false, x and y are unchanged.\n Comments:\n All positions are measured in PDF \"user space\".\n"]
1723 pub fn FPDFText_GetCharOrigin(
1724 text_page: FPDF_TEXTPAGE,
1725 index: ::std::os::raw::c_int,
1726 x: *mut f64,
1727 y: *mut f64,
1728 ) -> FPDF_BOOL;
1729}
1730unsafe extern "C" {
1731 #[doc = " Function: FPDFText_GetCharIndexAtPos\n Get the index of a character at or nearby a certain position on the\n page.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n x - X position in PDF \"user space\".\n y - Y position in PDF \"user space\".\n xTolerance - An x-axis tolerance value for character hit\n detection, in point units.\n yTolerance - A y-axis tolerance value for character hit\n detection, in point units.\n Return Value:\n The zero-based index of the character at, or nearby the point (x,y).\n If there is no character at or nearby the point, return value will\n be -1. If an error occurs, -3 will be returned.\n"]
1732 pub fn FPDFText_GetCharIndexAtPos(
1733 text_page: FPDF_TEXTPAGE,
1734 x: f64,
1735 y: f64,
1736 xTolerance: f64,
1737 yTolerance: f64,
1738 ) -> ::std::os::raw::c_int;
1739}
1740unsafe extern "C" {
1741 #[doc = " Function: FPDFText_GetText\n Extract unicode text string from the page.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n start_index - Index for the start characters.\n count - Number of UCS-2 values to be extracted.\n result - A buffer (allocated by application) receiving the\n extracted UCS-2 values. The buffer must be able to\n hold `count` UCS-2 values plus a terminator.\n Return Value:\n Number of characters written into the result buffer, including the\n trailing terminator.\n Comments:\n This function ignores characters without UCS-2 representations.\n It considers all characters on the page, even those that are not\n visible when the page has a cropbox. To filter out the characters\n outside of the cropbox, use FPDF_GetPageBoundingBox() and\n FPDFText_GetCharBox().\n"]
1742 pub fn FPDFText_GetText(
1743 text_page: FPDF_TEXTPAGE,
1744 start_index: ::std::os::raw::c_int,
1745 count: ::std::os::raw::c_int,
1746 result: *mut ::std::os::raw::c_ushort,
1747 ) -> ::std::os::raw::c_int;
1748}
1749unsafe extern "C" {
1750 #[doc = " Function: FPDFText_CountRects\n Counts number of rectangular areas occupied by a segment of text,\n and caches the result for subsequent FPDFText_GetRect() calls.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n start_index - Index for the start character.\n count - Number of characters, or -1 for all remaining.\n Return value:\n Number of rectangles, 0 if text_page is null, or -1 on bad\n start_index.\n Comments:\n This function, along with FPDFText_GetRect can be used by\n applications to detect the position on the page for a text segment,\n so proper areas can be highlighted. The FPDFText_* functions will\n automatically merge small character boxes into bigger one if those\n characters are on the same line and use same font settings.\n"]
1751 pub fn FPDFText_CountRects(
1752 text_page: FPDF_TEXTPAGE,
1753 start_index: ::std::os::raw::c_int,
1754 count: ::std::os::raw::c_int,
1755 ) -> ::std::os::raw::c_int;
1756}
1757unsafe extern "C" {
1758 #[doc = " Function: FPDFText_GetRect\n Get a rectangular area from the result generated by\n FPDFText_CountRects.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n rect_index - Zero-based index for the rectangle.\n left - Pointer to a double value receiving the rectangle\n left boundary.\n top - Pointer to a double value receiving the rectangle\n top boundary.\n right - Pointer to a double value receiving the rectangle\n right boundary.\n bottom - Pointer to a double value receiving the rectangle\n bottom boundary.\n Return Value:\n On success, return TRUE and fill in |left|, |top|, |right|, and\n |bottom|. If |text_page| is invalid then return FALSE, and the out\n parameters remain unmodified. If |text_page| is valid but\n |rect_index| is out of bounds, then return FALSE and set the out\n parameters to 0.\n"]
1759 pub fn FPDFText_GetRect(
1760 text_page: FPDF_TEXTPAGE,
1761 rect_index: ::std::os::raw::c_int,
1762 left: *mut f64,
1763 top: *mut f64,
1764 right: *mut f64,
1765 bottom: *mut f64,
1766 ) -> FPDF_BOOL;
1767}
1768unsafe extern "C" {
1769 #[doc = " Function: FPDFText_GetBoundedText\n Extract unicode text within a rectangular boundary on the page.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n left - Left boundary.\n top - Top boundary.\n right - Right boundary.\n bottom - Bottom boundary.\n buffer - Caller-allocated buffer to receive UTF-16 values.\n buflen - Number of UTF-16 values (not bytes) that `buffer`\n is capable of holding.\n Return Value:\n If buffer is NULL or buflen is zero, return number of UTF-16\n values (not bytes) of text present within the rectangle, excluding\n a terminating NUL. Generally you should pass a buffer at least one\n larger than this if you want a terminating NUL, which will be\n provided if space is available. Otherwise, return number of UTF-16\n values copied into the buffer, including the terminating NUL when\n space for it is available.\n Comment:\n If the buffer is too small, as much text as will fit is copied into\n it. May return a split surrogate in that case.\n"]
1770 pub fn FPDFText_GetBoundedText(
1771 text_page: FPDF_TEXTPAGE,
1772 left: f64,
1773 top: f64,
1774 right: f64,
1775 bottom: f64,
1776 buffer: *mut ::std::os::raw::c_ushort,
1777 buflen: ::std::os::raw::c_int,
1778 ) -> ::std::os::raw::c_int;
1779}
1780unsafe extern "C" {
1781 #[doc = " Function: FPDFText_FindStart\n Start a search.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n findwhat - A unicode match pattern.\n flags - Option flags.\n start_index - Start from this character. -1 for end of the page.\n Return Value:\n A handle for the search context. FPDFText_FindClose must be called\n to release this handle.\n"]
1782 pub fn FPDFText_FindStart(
1783 text_page: FPDF_TEXTPAGE,
1784 findwhat: FPDF_WIDESTRING,
1785 flags: ::std::os::raw::c_ulong,
1786 start_index: ::std::os::raw::c_int,
1787 ) -> FPDF_SCHHANDLE;
1788}
1789unsafe extern "C" {
1790 #[doc = " Function: FPDFText_FindNext\n Search in the direction from page start to end.\n Parameters:\n handle - A search context handle returned by\n FPDFText_FindStart.\n Return Value:\n Whether a match is found.\n"]
1791 pub fn FPDFText_FindNext(handle: FPDF_SCHHANDLE) -> FPDF_BOOL;
1792}
1793unsafe extern "C" {
1794 #[doc = " Function: FPDFText_FindPrev\n Search in the direction from page end to start.\n Parameters:\n handle - A search context handle returned by\n FPDFText_FindStart.\n Return Value:\n Whether a match is found.\n"]
1795 pub fn FPDFText_FindPrev(handle: FPDF_SCHHANDLE) -> FPDF_BOOL;
1796}
1797unsafe extern "C" {
1798 #[doc = " Function: FPDFText_GetSchResultIndex\n Get the starting character index of the search result.\n Parameters:\n handle - A search context handle returned by\n FPDFText_FindStart.\n Return Value:\n Index for the starting character.\n"]
1799 pub fn FPDFText_GetSchResultIndex(handle: FPDF_SCHHANDLE) -> ::std::os::raw::c_int;
1800}
1801unsafe extern "C" {
1802 #[doc = " Function: FPDFText_GetSchCount\n Get the number of matched characters in the search result.\n Parameters:\n handle - A search context handle returned by\n FPDFText_FindStart.\n Return Value:\n Number of matched characters.\n"]
1803 pub fn FPDFText_GetSchCount(handle: FPDF_SCHHANDLE) -> ::std::os::raw::c_int;
1804}
1805unsafe extern "C" {
1806 #[doc = " Function: FPDFText_FindClose\n Release a search context.\n Parameters:\n handle - A search context handle returned by\n FPDFText_FindStart.\n Return Value:\n None.\n"]
1807 pub fn FPDFText_FindClose(handle: FPDF_SCHHANDLE);
1808}
1809unsafe extern "C" {
1810 #[doc = " Function: FPDFLink_LoadWebLinks\n Prepare information about weblinks in a page.\n Parameters:\n text_page - Handle to a text page information structure.\n Returned by FPDFText_LoadPage function.\n Return Value:\n A handle to the page's links information structure, or\n NULL if something goes wrong.\n Comments:\n Weblinks are those links implicitly embedded in PDF pages. PDF also\n has a type of annotation called \"link\" (FPDFTEXT doesn't deal with\n that kind of link). FPDFTEXT weblink feature is useful for\n automatically detecting links in the page contents. For example,\n things like \"https://www.example.com\" will be detected, so\n applications can allow user to click on those characters to activate\n the link, even the PDF doesn't come with link annotations.\n\n FPDFLink_CloseWebLinks must be called to release resources.\n"]
1811 pub fn FPDFLink_LoadWebLinks(text_page: FPDF_TEXTPAGE) -> FPDF_PAGELINK;
1812}
1813unsafe extern "C" {
1814 #[doc = " Function: FPDFLink_CountWebLinks\n Count number of detected web links.\n Parameters:\n link_page - Handle returned by FPDFLink_LoadWebLinks.\n Return Value:\n Number of detected web links.\n"]
1815 pub fn FPDFLink_CountWebLinks(link_page: FPDF_PAGELINK) -> ::std::os::raw::c_int;
1816}
1817unsafe extern "C" {
1818 #[doc = " Function: FPDFLink_GetURL\n Fetch the URL information for a detected web link.\n Parameters:\n link_page - Handle returned by FPDFLink_LoadWebLinks.\n link_index - Zero-based index for the link.\n buffer - A unicode buffer for the result.\n buflen - Number of 16-bit code units (not bytes) for the\n buffer, including an additional terminator.\n Return Value:\n If |buffer| is NULL or |buflen| is zero, return the number of 16-bit\n code units (not bytes) needed to buffer the result (an additional\n terminator is included in this count).\n Otherwise, copy the result into |buffer|, truncating at |buflen| if\n the result is too large to fit, and return the number of 16-bit code\n units actually copied into the buffer (the additional terminator is\n also included in this count).\n If |link_index| does not correspond to a valid link, then the result\n is an empty string.\n"]
1819 pub fn FPDFLink_GetURL(
1820 link_page: FPDF_PAGELINK,
1821 link_index: ::std::os::raw::c_int,
1822 buffer: *mut ::std::os::raw::c_ushort,
1823 buflen: ::std::os::raw::c_int,
1824 ) -> ::std::os::raw::c_int;
1825}
1826unsafe extern "C" {
1827 #[doc = " Function: FPDFLink_CountRects\n Count number of rectangular areas for the link.\n Parameters:\n link_page - Handle returned by FPDFLink_LoadWebLinks.\n link_index - Zero-based index for the link.\n Return Value:\n Number of rectangular areas for the link. If |link_index| does\n not correspond to a valid link, then 0 is returned.\n"]
1828 pub fn FPDFLink_CountRects(
1829 link_page: FPDF_PAGELINK,
1830 link_index: ::std::os::raw::c_int,
1831 ) -> ::std::os::raw::c_int;
1832}
1833unsafe extern "C" {
1834 #[doc = " Function: FPDFLink_GetRect\n Fetch the boundaries of a rectangle for a link.\n Parameters:\n link_page - Handle returned by FPDFLink_LoadWebLinks.\n link_index - Zero-based index for the link.\n rect_index - Zero-based index for a rectangle.\n left - Pointer to a double value receiving the rectangle\n left boundary.\n top - Pointer to a double value receiving the rectangle\n top boundary.\n right - Pointer to a double value receiving the rectangle\n right boundary.\n bottom - Pointer to a double value receiving the rectangle\n bottom boundary.\n Return Value:\n On success, return TRUE and fill in |left|, |top|, |right|, and\n |bottom|. If |link_page| is invalid or if |link_index| does not\n correspond to a valid link, then return FALSE, and the out\n parameters remain unmodified.\n"]
1835 pub fn FPDFLink_GetRect(
1836 link_page: FPDF_PAGELINK,
1837 link_index: ::std::os::raw::c_int,
1838 rect_index: ::std::os::raw::c_int,
1839 left: *mut f64,
1840 top: *mut f64,
1841 right: *mut f64,
1842 bottom: *mut f64,
1843 ) -> FPDF_BOOL;
1844}
1845unsafe extern "C" {
1846 #[doc = " Experimental API.\n Function: FPDFLink_GetTextRange\n Fetch the start char index and char count for a link.\n Parameters:\n link_page - Handle returned by FPDFLink_LoadWebLinks.\n link_index - Zero-based index for the link.\n start_char_index - pointer to int receiving the start char index\n char_count - pointer to int receiving the char count\n Return Value:\n On success, return TRUE and fill in |start_char_index| and\n |char_count|. if |link_page| is invalid or if |link_index| does\n not correspond to a valid link, then return FALSE and the out\n parameters remain unmodified.\n"]
1847 pub fn FPDFLink_GetTextRange(
1848 link_page: FPDF_PAGELINK,
1849 link_index: ::std::os::raw::c_int,
1850 start_char_index: *mut ::std::os::raw::c_int,
1851 char_count: *mut ::std::os::raw::c_int,
1852 ) -> FPDF_BOOL;
1853}
1854unsafe extern "C" {
1855 #[doc = " Function: FPDFLink_CloseWebLinks\n Release resources used by weblink feature.\n Parameters:\n link_page - Handle returned by FPDFLink_LoadWebLinks.\n Return Value:\n None.\n"]
1856 pub fn FPDFLink_CloseWebLinks(link_page: FPDF_PAGELINK);
1857}
1858#[repr(C)]
1859#[derive(Debug, Copy, Clone)]
1860pub struct FPDF_IMAGEOBJ_METADATA {
1861 #[doc = " The image width in pixels."]
1862 pub width: ::std::os::raw::c_uint,
1863 #[doc = " The image height in pixels."]
1864 pub height: ::std::os::raw::c_uint,
1865 #[doc = " The image's horizontal pixel-per-inch."]
1866 pub horizontal_dpi: f32,
1867 #[doc = " The image's vertical pixel-per-inch."]
1868 pub vertical_dpi: f32,
1869 #[doc = " The number of bits used to represent each pixel."]
1870 pub bits_per_pixel: ::std::os::raw::c_uint,
1871 #[doc = " The image's colorspace. See above for the list of FPDF_COLORSPACE_*."]
1872 pub colorspace: ::std::os::raw::c_int,
1873 #[doc = " The image's marked content ID. Useful for pairing with associated alt-text.\n A value of -1 indicates no ID."]
1874 pub marked_content_id: ::std::os::raw::c_int,
1875}
1876unsafe extern "C" {
1877 #[doc = " Create a new PDF document.\n\n Returns a handle to a new document, or NULL on failure."]
1878 pub fn FPDF_CreateNewDocument() -> FPDF_DOCUMENT;
1879}
1880unsafe extern "C" {
1881 #[doc = " Create a new PDF page.\n\n document - handle to document.\n page_index - suggested 0-based index of the page to create. If it is larger\n than document's current last index(L), the created page index\n is the next available index -- L+1.\n width - the page width in points.\n height - the page height in points.\n\n Returns the handle to the new page or NULL on failure.\n\n The page should be closed with FPDF_ClosePage() when finished as\n with any other page in the document."]
1882 pub fn FPDFPage_New(
1883 document: FPDF_DOCUMENT,
1884 page_index: ::std::os::raw::c_int,
1885 width: f64,
1886 height: f64,
1887 ) -> FPDF_PAGE;
1888}
1889unsafe extern "C" {
1890 #[doc = " Delete the page at |page_index|.\n\n document - handle to document.\n page_index - the index of the page to delete."]
1891 pub fn FPDFPage_Delete(document: FPDF_DOCUMENT, page_index: ::std::os::raw::c_int);
1892}
1893unsafe extern "C" {
1894 #[doc = " Experimental API.\n Move the given pages to a new index position.\n\n page_indices - the ordered list of pages to move. No duplicates allowed.\n page_indices_len - the number of elements in |page_indices|\n dest_page_index - the new index position to which the pages in\n |page_indices| are moved.\n\n Returns TRUE on success. If it returns FALSE, the document may be left in an\n indeterminate state.\n\n Example: The PDF document starts out with pages [A, B, C, D], with indices\n [0, 1, 2, 3].\n\n > Move(doc, [3, 2], 2, 1); // returns true\n > // The document has pages [A, D, C, B].\n >\n > Move(doc, [0, 4, 3], 3, 1); // returns false\n > // Returned false because index 4 is out of range.\n >\n > Move(doc, [0, 3, 1], 3, 2); // returns false\n > // Returned false because index 2 is out of range for 3 page indices.\n >\n > Move(doc, [2, 2], 2, 0); // returns false\n > // Returned false because [2, 2] contains duplicates.\n"]
1895 pub fn FPDF_MovePages(
1896 document: FPDF_DOCUMENT,
1897 page_indices: *const ::std::os::raw::c_int,
1898 page_indices_len: ::std::os::raw::c_ulong,
1899 dest_page_index: ::std::os::raw::c_int,
1900 ) -> FPDF_BOOL;
1901}
1902unsafe extern "C" {
1903 #[doc = " Get the rotation of |page|.\n\n page - handle to a page\n\n Returns one of the following indicating the page rotation:\n 0 - No rotation.\n 1 - Rotated 90 degrees clockwise.\n 2 - Rotated 180 degrees clockwise.\n 3 - Rotated 270 degrees clockwise."]
1904 pub fn FPDFPage_GetRotation(page: FPDF_PAGE) -> ::std::os::raw::c_int;
1905}
1906unsafe extern "C" {
1907 #[doc = " Set rotation for |page|.\n\n page - handle to a page.\n rotate - the rotation value, one of:\n 0 - No rotation.\n 1 - Rotated 90 degrees clockwise.\n 2 - Rotated 180 degrees clockwise.\n 3 - Rotated 270 degrees clockwise."]
1908 pub fn FPDFPage_SetRotation(page: FPDF_PAGE, rotate: ::std::os::raw::c_int);
1909}
1910unsafe extern "C" {
1911 #[doc = " Insert |page_object| into |page|.\n\n page - handle to a page\n page_object - handle to a page object. The |page_object| will be\n automatically freed."]
1912 pub fn FPDFPage_InsertObject(page: FPDF_PAGE, page_object: FPDF_PAGEOBJECT);
1913}
1914unsafe extern "C" {
1915 #[doc = " Insert |page_object| into |page| at the specified |index|.\n\n page - handle to a page\n page_object - handle to a page object as previously obtained by\n FPDFPageObj_CreateNew{Path|Rect}() or\n FPDFPageObj_New{Text|Image}Obj(). Ownership of the object\n is transferred back to PDFium.\n index - the index position to insert the object at. If index equals\n the current object count, the object will be appended to the\n end. If index is greater than the object count, the function\n will fail and return false.\n\n Returns true if successful."]
1916 pub fn FPDFPage_InsertObjectAtIndex(
1917 page: FPDF_PAGE,
1918 page_object: FPDF_PAGEOBJECT,
1919 index: usize,
1920 ) -> FPDF_BOOL;
1921}
1922unsafe extern "C" {
1923 #[doc = " Experimental API.\n Remove |page_object| from |page|.\n\n page - handle to a page\n page_object - handle to a page object to be removed.\n\n Returns TRUE on success.\n\n Ownership is transferred to the caller. Call FPDFPageObj_Destroy() to free\n it.\n Note that when removing a |page_object| of type FPDF_PAGEOBJ_TEXT, all\n FPDF_TEXTPAGE handles for |page| are no longer valid."]
1924 pub fn FPDFPage_RemoveObject(page: FPDF_PAGE, page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
1925}
1926unsafe extern "C" {
1927 #[doc = " Get number of page objects inside |page|.\n\n page - handle to a page.\n\n Returns the number of objects in |page|."]
1928 pub fn FPDFPage_CountObjects(page: FPDF_PAGE) -> ::std::os::raw::c_int;
1929}
1930unsafe extern "C" {
1931 #[doc = " Get object in |page| at |index|.\n\n page - handle to a page.\n index - the index of a page object.\n\n Returns the handle to the page object, or NULL on failed."]
1932 pub fn FPDFPage_GetObject(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_PAGEOBJECT;
1933}
1934unsafe extern "C" {
1935 #[doc = " Checks if |page| contains transparency.\n\n page - handle to a page.\n\n Returns TRUE if |page| contains transparency."]
1936 pub fn FPDFPage_HasTransparency(page: FPDF_PAGE) -> FPDF_BOOL;
1937}
1938unsafe extern "C" {
1939 #[doc = " Generate the content of |page|.\n\n page - handle to a page.\n\n Returns TRUE on success.\n\n Before you save the page to a file, or reload the page, you must call\n |FPDFPage_GenerateContent| or any changes to |page| will be lost."]
1940 pub fn FPDFPage_GenerateContent(page: FPDF_PAGE) -> FPDF_BOOL;
1941}
1942unsafe extern "C" {
1943 #[doc = " Destroy |page_object| by releasing its resources. |page_object| must have\n been created by FPDFPageObj_CreateNew{Path|Rect}() or\n FPDFPageObj_New{Text|Image}Obj(). This function must be called on\n newly-created objects if they are not added to a page through\n FPDFPage_InsertObject() or to an annotation through FPDFAnnot_AppendObject().\n\n page_object - handle to a page object."]
1944 pub fn FPDFPageObj_Destroy(page_object: FPDF_PAGEOBJECT);
1945}
1946unsafe extern "C" {
1947 #[doc = " Checks if |page_object| contains transparency.\n\n page_object - handle to a page object.\n\n Returns TRUE if |page_object| contains transparency."]
1948 pub fn FPDFPageObj_HasTransparency(page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
1949}
1950unsafe extern "C" {
1951 #[doc = " Get type of |page_object|.\n\n page_object - handle to a page object.\n\n Returns one of the FPDF_PAGEOBJ_* values on success, FPDF_PAGEOBJ_UNKNOWN on\n error."]
1952 pub fn FPDFPageObj_GetType(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
1953}
1954unsafe extern "C" {
1955 #[doc = " Experimental API.\n Gets active state for |page_object| within page.\n\n page_object - handle to a page object.\n active - pointer to variable that will receive if the page object is\n active. This is a required parameter. Not filled if FALSE\n is returned.\n\n For page objects where |active| is filled with FALSE, the |page_object| is\n treated as if it wasn't in the document even though it is still held\n internally.\n\n Returns TRUE if the operation succeeded, FALSE if it failed."]
1956 pub fn FPDFPageObj_GetIsActive(
1957 page_object: FPDF_PAGEOBJECT,
1958 active: *mut FPDF_BOOL,
1959 ) -> FPDF_BOOL;
1960}
1961unsafe extern "C" {
1962 #[doc = " Experimental API.\n Sets if |page_object| is active within page.\n\n page_object - handle to a page object.\n active - a boolean specifying if the object is active.\n\n Returns TRUE on success.\n\n Page objects all start in the active state by default, and remain in that\n state unless this function is called.\n\n When |active| is false, this makes the |page_object| be treated as if it\n wasn't in the document even though it is still held internally."]
1963 pub fn FPDFPageObj_SetIsActive(page_object: FPDF_PAGEOBJECT, active: FPDF_BOOL) -> FPDF_BOOL;
1964}
1965unsafe extern "C" {
1966 #[doc = " Transform |page_object| by the given matrix.\n\n page_object - handle to a page object.\n a - matrix value.\n b - matrix value.\n c - matrix value.\n d - matrix value.\n e - matrix value.\n f - matrix value.\n\n The matrix is composed as:\n |a c e|\n |b d f|\n and can be used to scale, rotate, shear and translate the |page_object|."]
1967 pub fn FPDFPageObj_Transform(
1968 page_object: FPDF_PAGEOBJECT,
1969 a: f64,
1970 b: f64,
1971 c: f64,
1972 d: f64,
1973 e: f64,
1974 f: f64,
1975 );
1976}
1977unsafe extern "C" {
1978 #[doc = " Experimental API.\n Transform |page_object| by the given matrix.\n\n page_object - handle to a page object.\n matrix - the transform matrix.\n\n Returns TRUE on success.\n\n This can be used to scale, rotate, shear and translate the |page_object|.\n It is an improved version of FPDFPageObj_Transform() that does not do\n unnecessary double to float conversions, and only uses 1 parameter for the\n matrix. It also returns whether the operation succeeded or not."]
1979 pub fn FPDFPageObj_TransformF(
1980 page_object: FPDF_PAGEOBJECT,
1981 matrix: *const FS_MATRIX,
1982 ) -> FPDF_BOOL;
1983}
1984unsafe extern "C" {
1985 #[doc = " Experimental API.\n Get the transform matrix of a page object.\n\n page_object - handle to a page object.\n matrix - pointer to struct to receive the matrix value.\n\n The matrix is composed as:\n |a c e|\n |b d f|\n and used to scale, rotate, shear and translate the page object.\n\n For page objects outside form objects, the matrix values are relative to the\n page that contains it.\n For page objects inside form objects, the matrix values are relative to the\n form that contains it.\n\n Returns TRUE on success."]
1986 pub fn FPDFPageObj_GetMatrix(page_object: FPDF_PAGEOBJECT, matrix: *mut FS_MATRIX)
1987 -> FPDF_BOOL;
1988}
1989unsafe extern "C" {
1990 #[doc = " Experimental API.\n Set the transform matrix of a page object.\n\n page_object - handle to a page object.\n matrix - pointer to struct with the matrix value.\n\n The matrix is composed as:\n |a c e|\n |b d f|\n and can be used to scale, rotate, shear and translate the page object.\n\n Returns TRUE on success."]
1991 pub fn FPDFPageObj_SetMatrix(
1992 page_object: FPDF_PAGEOBJECT,
1993 matrix: *const FS_MATRIX,
1994 ) -> FPDF_BOOL;
1995}
1996unsafe extern "C" {
1997 #[doc = " Transform all annotations in |page|.\n\n page - handle to a page.\n a - matrix value.\n b - matrix value.\n c - matrix value.\n d - matrix value.\n e - matrix value.\n f - matrix value.\n\n The matrix is composed as:\n |a c e|\n |b d f|\n and can be used to scale, rotate, shear and translate the |page| annotations."]
1998 pub fn FPDFPage_TransformAnnots(
1999 page: FPDF_PAGE,
2000 a: f64,
2001 b: f64,
2002 c: f64,
2003 d: f64,
2004 e: f64,
2005 f: f64,
2006 );
2007}
2008unsafe extern "C" {
2009 #[doc = " Create a new image object.\n\n document - handle to a document.\n\n Returns a handle to a new image object."]
2010 pub fn FPDFPageObj_NewImageObj(document: FPDF_DOCUMENT) -> FPDF_PAGEOBJECT;
2011}
2012unsafe extern "C" {
2013 #[doc = " Experimental API.\n Get the marked content ID for the object.\n\n page_object - handle to a page object.\n\n Returns the page object's marked content ID, or -1 on error."]
2014 pub fn FPDFPageObj_GetMarkedContentID(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2015}
2016unsafe extern "C" {
2017 #[doc = " Experimental API.\n Get number of content marks in |page_object|.\n\n page_object - handle to a page object.\n\n Returns the number of content marks in |page_object|, or -1 in case of\n failure."]
2018 pub fn FPDFPageObj_CountMarks(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2019}
2020unsafe extern "C" {
2021 #[doc = " Experimental API.\n Get content mark in |page_object| at |index|.\n\n page_object - handle to a page object.\n index - the index of a page object.\n\n Returns the handle to the content mark, or NULL on failure. The handle is\n still owned by the library, and it should not be freed directly. It becomes\n invalid if the page object is destroyed, either directly or indirectly by\n unloading the page."]
2022 pub fn FPDFPageObj_GetMark(
2023 page_object: FPDF_PAGEOBJECT,
2024 index: ::std::os::raw::c_ulong,
2025 ) -> FPDF_PAGEOBJECTMARK;
2026}
2027unsafe extern "C" {
2028 #[doc = " Experimental API.\n Add a new content mark to a |page_object|.\n\n page_object - handle to a page object.\n name - the name (tag) of the mark.\n\n Returns the handle to the content mark, or NULL on failure. The handle is\n still owned by the library, and it should not be freed directly. It becomes\n invalid if the page object is destroyed, either directly or indirectly by\n unloading the page."]
2029 pub fn FPDFPageObj_AddMark(
2030 page_object: FPDF_PAGEOBJECT,
2031 name: FPDF_BYTESTRING,
2032 ) -> FPDF_PAGEOBJECTMARK;
2033}
2034unsafe extern "C" {
2035 #[doc = " Experimental API.\n Removes a content |mark| from a |page_object|.\n The mark handle will be invalid after the removal.\n\n page_object - handle to a page object.\n mark - handle to a content mark in that object to remove.\n\n Returns TRUE if the operation succeeded, FALSE if it failed."]
2036 pub fn FPDFPageObj_RemoveMark(
2037 page_object: FPDF_PAGEOBJECT,
2038 mark: FPDF_PAGEOBJECTMARK,
2039 ) -> FPDF_BOOL;
2040}
2041unsafe extern "C" {
2042 #[doc = " Experimental API.\n Get the name of a content mark.\n\n mark - handle to a content mark.\n buffer - buffer for holding the returned name in UTF-16LE. This is only\n modified if |buflen| is large enough to store the name.\n Optional, pass null to just retrieve the size of the buffer\n needed.\n buflen - length of the buffer in bytes.\n out_buflen - pointer to variable that will receive the minimum buffer size\n in bytes to contain the name. This is a required parameter.\n Not filled if FALSE is returned.\n\n Returns TRUE if the operation succeeded, FALSE if it failed."]
2043 pub fn FPDFPageObjMark_GetName(
2044 mark: FPDF_PAGEOBJECTMARK,
2045 buffer: *mut FPDF_WCHAR,
2046 buflen: ::std::os::raw::c_ulong,
2047 out_buflen: *mut ::std::os::raw::c_ulong,
2048 ) -> FPDF_BOOL;
2049}
2050unsafe extern "C" {
2051 #[doc = " Experimental API.\n Get the number of key/value pair parameters in |mark|.\n\n mark - handle to a content mark.\n\n Returns the number of key/value pair parameters |mark|, or -1 in case of\n failure."]
2052 pub fn FPDFPageObjMark_CountParams(mark: FPDF_PAGEOBJECTMARK) -> ::std::os::raw::c_int;
2053}
2054unsafe extern "C" {
2055 #[doc = " Experimental API.\n Get the key of a property in a content mark.\n\n mark - handle to a content mark.\n index - index of the property.\n buffer - buffer for holding the returned key in UTF-16LE. This is only\n modified if |buflen| is large enough to store the key.\n Optional, pass null to just retrieve the size of the buffer\n needed.\n buflen - length of the buffer in bytes.\n out_buflen - pointer to variable that will receive the minimum buffer size\n in bytes to contain the name. This is a required parameter.\n Not filled if FALSE is returned.\n\n Returns TRUE if the operation was successful, FALSE otherwise."]
2056 pub fn FPDFPageObjMark_GetParamKey(
2057 mark: FPDF_PAGEOBJECTMARK,
2058 index: ::std::os::raw::c_ulong,
2059 buffer: *mut FPDF_WCHAR,
2060 buflen: ::std::os::raw::c_ulong,
2061 out_buflen: *mut ::std::os::raw::c_ulong,
2062 ) -> FPDF_BOOL;
2063}
2064unsafe extern "C" {
2065 #[doc = " Experimental API.\n Get the type of the value of a property in a content mark by key.\n\n mark - handle to a content mark.\n key - string key of the property.\n\n Returns the type of the value, or FPDF_OBJECT_UNKNOWN in case of failure."]
2066 pub fn FPDFPageObjMark_GetParamValueType(
2067 mark: FPDF_PAGEOBJECTMARK,
2068 key: FPDF_BYTESTRING,
2069 ) -> FPDF_OBJECT_TYPE;
2070}
2071unsafe extern "C" {
2072 #[doc = " Experimental API.\n Get the value of a number property in a content mark by key as int.\n FPDFPageObjMark_GetParamValueType() should have returned FPDF_OBJECT_NUMBER\n for this property.\n\n mark - handle to a content mark.\n key - string key of the property.\n out_value - pointer to variable that will receive the value. Not filled if\n false is returned.\n\n Returns TRUE if the key maps to a number value, FALSE otherwise."]
2073 pub fn FPDFPageObjMark_GetParamIntValue(
2074 mark: FPDF_PAGEOBJECTMARK,
2075 key: FPDF_BYTESTRING,
2076 out_value: *mut ::std::os::raw::c_int,
2077 ) -> FPDF_BOOL;
2078}
2079unsafe extern "C" {
2080 #[doc = " Experimental API.\n Get the value of a number property in a content mark by key as float.\n FPDFPageObjMark_GetParamValueType() should have returned FPDF_OBJECT_NUMBER\n for this property.\n\n mark - handle to a content mark.\n key - string key of the property.\n out_value - pointer to variable that will receive the value. Not filled if\n false is returned.\n\n Returns TRUE if the key maps to a number value, FALSE otherwise."]
2081 pub fn FPDFPageObjMark_GetParamFloatValue(
2082 mark: FPDF_PAGEOBJECTMARK,
2083 key: FPDF_BYTESTRING,
2084 out_value: *mut f32,
2085 ) -> FPDF_BOOL;
2086}
2087unsafe extern "C" {
2088 #[doc = " Experimental API.\n Get the value of a string property in a content mark by key.\n\n mark - handle to a content mark.\n key - string key of the property.\n buffer - buffer for holding the returned value in UTF-16LE. This is\n only modified if |buflen| is large enough to store the value.\n Optional, pass null to just retrieve the size of the buffer\n needed.\n buflen - length of the buffer in bytes.\n out_buflen - pointer to variable that will receive the minimum buffer size\n in bytes to contain the name. This is a required parameter.\n Not filled if FALSE is returned.\n\n Returns TRUE if the key maps to a string/blob value, FALSE otherwise."]
2089 pub fn FPDFPageObjMark_GetParamStringValue(
2090 mark: FPDF_PAGEOBJECTMARK,
2091 key: FPDF_BYTESTRING,
2092 buffer: *mut FPDF_WCHAR,
2093 buflen: ::std::os::raw::c_ulong,
2094 out_buflen: *mut ::std::os::raw::c_ulong,
2095 ) -> FPDF_BOOL;
2096}
2097unsafe extern "C" {
2098 #[doc = " Experimental API.\n Get the value of a blob property in a content mark by key.\n\n mark - handle to a content mark.\n key - string key of the property.\n buffer - buffer for holding the returned value. This is only modified\n if |buflen| is large enough to store the value.\n Optional, pass null to just retrieve the size of the buffer\n needed.\n buflen - length of the buffer in bytes.\n out_buflen - pointer to variable that will receive the minimum buffer size\n in bytes to contain the name. This is a required parameter.\n Not filled if FALSE is returned.\n\n Returns TRUE if the key maps to a string/blob value, FALSE otherwise."]
2099 pub fn FPDFPageObjMark_GetParamBlobValue(
2100 mark: FPDF_PAGEOBJECTMARK,
2101 key: FPDF_BYTESTRING,
2102 buffer: *mut ::std::os::raw::c_uchar,
2103 buflen: ::std::os::raw::c_ulong,
2104 out_buflen: *mut ::std::os::raw::c_ulong,
2105 ) -> FPDF_BOOL;
2106}
2107unsafe extern "C" {
2108 #[doc = " Experimental API.\n Set the value of an int property in a content mark by key. If a parameter\n with key |key| exists, its value is set to |value|. Otherwise, it is added as\n a new parameter.\n\n document - handle to the document.\n page_object - handle to the page object with the mark.\n mark - handle to a content mark.\n key - string key of the property.\n value - int value to set.\n\n Returns TRUE if the operation succeeded, FALSE otherwise."]
2109 pub fn FPDFPageObjMark_SetIntParam(
2110 document: FPDF_DOCUMENT,
2111 page_object: FPDF_PAGEOBJECT,
2112 mark: FPDF_PAGEOBJECTMARK,
2113 key: FPDF_BYTESTRING,
2114 value: ::std::os::raw::c_int,
2115 ) -> FPDF_BOOL;
2116}
2117unsafe extern "C" {
2118 #[doc = " Experimental API.\n Set the value of a float property in a content mark by key. If a parameter\n with key |key| exists, its value is set to |value|. Otherwise, it is added as\n a new parameter.\n\n document - handle to the document.\n page_object - handle to the page object with the mark.\n mark - handle to a content mark.\n key - string key of the property.\n value - float value to set.\n\n Returns TRUE if the operation succeeded, FALSE otherwise."]
2119 pub fn FPDFPageObjMark_SetFloatParam(
2120 document: FPDF_DOCUMENT,
2121 page_object: FPDF_PAGEOBJECT,
2122 mark: FPDF_PAGEOBJECTMARK,
2123 key: FPDF_BYTESTRING,
2124 value: f32,
2125 ) -> FPDF_BOOL;
2126}
2127unsafe extern "C" {
2128 #[doc = " Experimental API.\n Set the value of a string property in a content mark by key. If a parameter\n with key |key| exists, its value is set to |value|. Otherwise, it is added as\n a new parameter.\n\n document - handle to the document.\n page_object - handle to the page object with the mark.\n mark - handle to a content mark.\n key - string key of the property.\n value - string value to set.\n\n Returns TRUE if the operation succeeded, FALSE otherwise."]
2129 pub fn FPDFPageObjMark_SetStringParam(
2130 document: FPDF_DOCUMENT,
2131 page_object: FPDF_PAGEOBJECT,
2132 mark: FPDF_PAGEOBJECTMARK,
2133 key: FPDF_BYTESTRING,
2134 value: FPDF_BYTESTRING,
2135 ) -> FPDF_BOOL;
2136}
2137unsafe extern "C" {
2138 #[doc = " Experimental API.\n Set the value of a blob property in a content mark by key. If a parameter\n with key |key| exists, its value is set to |value|. Otherwise, it is added as\n a new parameter.\n\n document - handle to the document.\n page_object - handle to the page object with the mark.\n mark - handle to a content mark.\n key - string key of the property.\n value - pointer to blob value to set.\n value_len - size in bytes of |value|.\n\n Returns TRUE if the operation succeeded, FALSE otherwise."]
2139 pub fn FPDFPageObjMark_SetBlobParam(
2140 document: FPDF_DOCUMENT,
2141 page_object: FPDF_PAGEOBJECT,
2142 mark: FPDF_PAGEOBJECTMARK,
2143 key: FPDF_BYTESTRING,
2144 value: *const ::std::os::raw::c_uchar,
2145 value_len: ::std::os::raw::c_ulong,
2146 ) -> FPDF_BOOL;
2147}
2148unsafe extern "C" {
2149 #[doc = " Experimental API.\n Removes a property from a content mark by key.\n\n page_object - handle to the page object with the mark.\n mark - handle to a content mark.\n key - string key of the property.\n\n Returns TRUE if the operation succeeded, FALSE otherwise."]
2150 pub fn FPDFPageObjMark_RemoveParam(
2151 page_object: FPDF_PAGEOBJECT,
2152 mark: FPDF_PAGEOBJECTMARK,
2153 key: FPDF_BYTESTRING,
2154 ) -> FPDF_BOOL;
2155}
2156unsafe extern "C" {
2157 #[doc = " Load an image from a JPEG image file and then set it into |image_object|.\n\n pages - pointer to the start of all loaded pages, may be NULL.\n count - number of |pages|, may be 0.\n image_object - handle to an image object.\n file_access - file access handler which specifies the JPEG image file.\n\n Returns TRUE on success.\n\n The image object might already have an associated image, which is shared and\n cached by the loaded pages. In that case, we need to clear the cached image\n for all the loaded pages. Pass |pages| and page count (|count|) to this API\n to clear the image cache. If the image is not previously shared, or NULL is a\n valid |pages| value."]
2158 pub fn FPDFImageObj_LoadJpegFile(
2159 pages: *mut FPDF_PAGE,
2160 count: ::std::os::raw::c_int,
2161 image_object: FPDF_PAGEOBJECT,
2162 file_access: *mut FPDF_FILEACCESS,
2163 ) -> FPDF_BOOL;
2164}
2165unsafe extern "C" {
2166 #[doc = " Load an image from a JPEG image file and then set it into |image_object|.\n\n pages - pointer to the start of all loaded pages, may be NULL.\n count - number of |pages|, may be 0.\n image_object - handle to an image object.\n file_access - file access handler which specifies the JPEG image file.\n\n Returns TRUE on success.\n\n The image object might already have an associated image, which is shared and\n cached by the loaded pages. In that case, we need to clear the cached image\n for all the loaded pages. Pass |pages| and page count (|count|) to this API\n to clear the image cache. If the image is not previously shared, or NULL is a\n valid |pages| value. This function loads the JPEG image inline, so the image\n content is copied to the file. This allows |file_access| and its associated\n data to be deleted after this function returns."]
2167 pub fn FPDFImageObj_LoadJpegFileInline(
2168 pages: *mut FPDF_PAGE,
2169 count: ::std::os::raw::c_int,
2170 image_object: FPDF_PAGEOBJECT,
2171 file_access: *mut FPDF_FILEACCESS,
2172 ) -> FPDF_BOOL;
2173}
2174unsafe extern "C" {
2175 #[doc = " TODO(thestig): Start deprecating this once FPDFPageObj_SetMatrix() is stable.\n\n Set the transform matrix of |image_object|.\n\n image_object - handle to an image object.\n a - matrix value.\n b - matrix value.\n c - matrix value.\n d - matrix value.\n e - matrix value.\n f - matrix value.\n\n The matrix is composed as:\n |a c e|\n |b d f|\n and can be used to scale, rotate, shear and translate the |image_object|.\n\n Returns TRUE on success."]
2176 pub fn FPDFImageObj_SetMatrix(
2177 image_object: FPDF_PAGEOBJECT,
2178 a: f64,
2179 b: f64,
2180 c: f64,
2181 d: f64,
2182 e: f64,
2183 f: f64,
2184 ) -> FPDF_BOOL;
2185}
2186unsafe extern "C" {
2187 #[doc = " Set |bitmap| to |image_object|.\n\n pages - pointer to the start of all loaded pages, may be NULL.\n count - number of |pages|, may be 0.\n image_object - handle to an image object.\n bitmap - handle of the bitmap.\n\n Returns TRUE on success."]
2188 pub fn FPDFImageObj_SetBitmap(
2189 pages: *mut FPDF_PAGE,
2190 count: ::std::os::raw::c_int,
2191 image_object: FPDF_PAGEOBJECT,
2192 bitmap: FPDF_BITMAP,
2193 ) -> FPDF_BOOL;
2194}
2195unsafe extern "C" {
2196 #[doc = " Get a bitmap rasterization of |image_object|. FPDFImageObj_GetBitmap() only\n operates on |image_object| and does not take the associated image mask into\n account. It also ignores the matrix for |image_object|.\n The returned bitmap will be owned by the caller, and FPDFBitmap_Destroy()\n must be called on the returned bitmap when it is no longer needed.\n\n image_object - handle to an image object.\n\n Returns the bitmap."]
2197 pub fn FPDFImageObj_GetBitmap(image_object: FPDF_PAGEOBJECT) -> FPDF_BITMAP;
2198}
2199unsafe extern "C" {
2200 #[doc = " Experimental API.\n Get a bitmap rasterization of |image_object| that takes the image mask and\n image matrix into account. To render correctly, the caller must provide the\n |document| associated with |image_object|. If there is a |page| associated\n with |image_object|, the caller should provide that as well.\n The returned bitmap will be owned by the caller, and FPDFBitmap_Destroy()\n must be called on the returned bitmap when it is no longer needed.\n\n document - handle to a document associated with |image_object|.\n page - handle to an optional page associated with |image_object|.\n image_object - handle to an image object.\n\n Returns the bitmap or NULL on failure."]
2201 pub fn FPDFImageObj_GetRenderedBitmap(
2202 document: FPDF_DOCUMENT,
2203 page: FPDF_PAGE,
2204 image_object: FPDF_PAGEOBJECT,
2205 ) -> FPDF_BITMAP;
2206}
2207unsafe extern "C" {
2208 #[doc = " Get the decoded image data of |image_object|. The decoded data is the\n uncompressed image data, i.e. the raw image data after having all filters\n applied. |buffer| is only modified if |buflen| is longer than the length of\n the decoded image data.\n\n image_object - handle to an image object.\n buffer - buffer for holding the decoded image data.\n buflen - length of the buffer in bytes.\n\n Returns the length of the decoded image data."]
2209 pub fn FPDFImageObj_GetImageDataDecoded(
2210 image_object: FPDF_PAGEOBJECT,
2211 buffer: *mut ::std::os::raw::c_void,
2212 buflen: ::std::os::raw::c_ulong,
2213 ) -> ::std::os::raw::c_ulong;
2214}
2215unsafe extern "C" {
2216 #[doc = " Get the raw image data of |image_object|. The raw data is the image data as\n stored in the PDF without applying any filters. |buffer| is only modified if\n |buflen| is longer than the length of the raw image data.\n\n image_object - handle to an image object.\n buffer - buffer for holding the raw image data.\n buflen - length of the buffer in bytes.\n\n Returns the length of the raw image data."]
2217 pub fn FPDFImageObj_GetImageDataRaw(
2218 image_object: FPDF_PAGEOBJECT,
2219 buffer: *mut ::std::os::raw::c_void,
2220 buflen: ::std::os::raw::c_ulong,
2221 ) -> ::std::os::raw::c_ulong;
2222}
2223unsafe extern "C" {
2224 #[doc = " Get the number of filters (i.e. decoders) of the image in |image_object|.\n\n image_object - handle to an image object.\n\n Returns the number of |image_object|'s filters."]
2225 pub fn FPDFImageObj_GetImageFilterCount(image_object: FPDF_PAGEOBJECT)
2226 -> ::std::os::raw::c_int;
2227}
2228unsafe extern "C" {
2229 #[doc = " Get the filter at |index| of |image_object|'s list of filters. Note that the\n filters need to be applied in order, i.e. the first filter should be applied\n first, then the second, etc. |buffer| is only modified if |buflen| is longer\n than the length of the filter string.\n\n image_object - handle to an image object.\n index - the index of the filter requested.\n buffer - buffer for holding filter string, encoded in UTF-8.\n buflen - length of the buffer.\n\n Returns the length of the filter string."]
2230 pub fn FPDFImageObj_GetImageFilter(
2231 image_object: FPDF_PAGEOBJECT,
2232 index: ::std::os::raw::c_int,
2233 buffer: *mut ::std::os::raw::c_void,
2234 buflen: ::std::os::raw::c_ulong,
2235 ) -> ::std::os::raw::c_ulong;
2236}
2237unsafe extern "C" {
2238 #[doc = " Get the image metadata of |image_object|, including dimension, DPI, bits per\n pixel, and colorspace. If the |image_object| is not an image object or if it\n does not have an image, then the return value will be false. Otherwise,\n failure to retrieve any specific parameter would result in its value being 0.\n\n image_object - handle to an image object.\n page - handle to the page that |image_object| is on. Required for\n retrieving the image's bits per pixel and colorspace.\n metadata - receives the image metadata; must not be NULL.\n\n Returns true if successful."]
2239 pub fn FPDFImageObj_GetImageMetadata(
2240 image_object: FPDF_PAGEOBJECT,
2241 page: FPDF_PAGE,
2242 metadata: *mut FPDF_IMAGEOBJ_METADATA,
2243 ) -> FPDF_BOOL;
2244}
2245unsafe extern "C" {
2246 #[doc = " Experimental API.\n Get the image size in pixels. Faster method to get only image size.\n\n image_object - handle to an image object.\n width - receives the image width in pixels; must not be NULL.\n height - receives the image height in pixels; must not be NULL.\n\n Returns true if successful."]
2247 pub fn FPDFImageObj_GetImagePixelSize(
2248 image_object: FPDF_PAGEOBJECT,
2249 width: *mut ::std::os::raw::c_uint,
2250 height: *mut ::std::os::raw::c_uint,
2251 ) -> FPDF_BOOL;
2252}
2253unsafe extern "C" {
2254 #[doc = " Experimental API.\n Get ICC profile decoded data of |image_object|. If the |image_object| is not\n an image object or if it does not have an image, then the return value will\n be false. It also returns false if the |image_object| has no ICC profile.\n |buffer| is only modified if ICC profile exists and |buflen| is longer than\n the length of the ICC profile decoded data.\n\n image_object - handle to an image object; must not be NULL.\n page - handle to the page containing |image_object|; must not be\n NULL. Required for retrieving the image's colorspace.\n buffer - Buffer to receive ICC profile data; may be NULL if querying\n required size via |out_buflen|.\n buflen - Length of the buffer in bytes. Ignored if |buffer| is NULL.\n out_buflen - Pointer to receive the ICC profile data size in bytes; must\n not be NULL. Will be set if this API returns true.\n\n Returns true if |out_buflen| is not null and an ICC profile exists for the\n given |image_object|."]
2255 pub fn FPDFImageObj_GetIccProfileDataDecoded(
2256 image_object: FPDF_PAGEOBJECT,
2257 page: FPDF_PAGE,
2258 buffer: *mut u8,
2259 buflen: usize,
2260 out_buflen: *mut usize,
2261 ) -> FPDF_BOOL;
2262}
2263unsafe extern "C" {
2264 #[doc = " Create a new path object at an initial position.\n\n x - initial horizontal position.\n y - initial vertical position.\n\n Returns a handle to a new path object."]
2265 pub fn FPDFPageObj_CreateNewPath(x: f32, y: f32) -> FPDF_PAGEOBJECT;
2266}
2267unsafe extern "C" {
2268 #[doc = " Create a closed path consisting of a rectangle.\n\n x - horizontal position for the left boundary of the rectangle.\n y - vertical position for the bottom boundary of the rectangle.\n w - width of the rectangle.\n h - height of the rectangle.\n\n Returns a handle to the new path object."]
2269 pub fn FPDFPageObj_CreateNewRect(x: f32, y: f32, w: f32, h: f32) -> FPDF_PAGEOBJECT;
2270}
2271unsafe extern "C" {
2272 #[doc = " Get the bounding box of |page_object|.\n\n page_object - handle to a page object.\n left - pointer where the left coordinate will be stored\n bottom - pointer where the bottom coordinate will be stored\n right - pointer where the right coordinate will be stored\n top - pointer where the top coordinate will be stored\n\n On success, returns TRUE and fills in the 4 coordinates."]
2273 pub fn FPDFPageObj_GetBounds(
2274 page_object: FPDF_PAGEOBJECT,
2275 left: *mut f32,
2276 bottom: *mut f32,
2277 right: *mut f32,
2278 top: *mut f32,
2279 ) -> FPDF_BOOL;
2280}
2281unsafe extern "C" {
2282 #[doc = " Experimental API.\n Get the quad points that bounds |page_object|.\n\n page_object - handle to a page object.\n quad_points - pointer where the quadrilateral points will be stored.\n\n On success, returns TRUE and fills in |quad_points|.\n\n Similar to FPDFPageObj_GetBounds(), this returns the bounds of a page\n object. When the object is rotated by a non-multiple of 90 degrees, this API\n returns a tighter bound that cannot be represented with just the 4 sides of\n a rectangle.\n\n Currently only works the following |page_object| types: FPDF_PAGEOBJ_TEXT and\n FPDF_PAGEOBJ_IMAGE."]
2283 pub fn FPDFPageObj_GetRotatedBounds(
2284 page_object: FPDF_PAGEOBJECT,
2285 quad_points: *mut FS_QUADPOINTSF,
2286 ) -> FPDF_BOOL;
2287}
2288unsafe extern "C" {
2289 #[doc = " Set the blend mode of |page_object|.\n\n page_object - handle to a page object.\n blend_mode - string containing the blend mode.\n\n Blend mode can be one of following: Color, ColorBurn, ColorDodge, Darken,\n Difference, Exclusion, HardLight, Hue, Lighten, Luminosity, Multiply, Normal,\n Overlay, Saturation, Screen, SoftLight"]
2290 pub fn FPDFPageObj_SetBlendMode(page_object: FPDF_PAGEOBJECT, blend_mode: FPDF_BYTESTRING);
2291}
2292unsafe extern "C" {
2293 #[doc = " Set the stroke RGBA of a page object. Range of values: 0 - 255.\n\n page_object - the handle to the page object.\n R - the red component for the object's stroke color.\n G - the green component for the object's stroke color.\n B - the blue component for the object's stroke color.\n A - the stroke alpha for the object.\n\n Returns TRUE on success."]
2294 pub fn FPDFPageObj_SetStrokeColor(
2295 page_object: FPDF_PAGEOBJECT,
2296 R: ::std::os::raw::c_uint,
2297 G: ::std::os::raw::c_uint,
2298 B: ::std::os::raw::c_uint,
2299 A: ::std::os::raw::c_uint,
2300 ) -> FPDF_BOOL;
2301}
2302unsafe extern "C" {
2303 #[doc = " Get the stroke RGBA of a page object. Range of values: 0 - 255.\n\n page_object - the handle to the page object.\n R - the red component of the path stroke color.\n G - the green component of the object's stroke color.\n B - the blue component of the object's stroke color.\n A - the stroke alpha of the object.\n\n Returns TRUE on success."]
2304 pub fn FPDFPageObj_GetStrokeColor(
2305 page_object: FPDF_PAGEOBJECT,
2306 R: *mut ::std::os::raw::c_uint,
2307 G: *mut ::std::os::raw::c_uint,
2308 B: *mut ::std::os::raw::c_uint,
2309 A: *mut ::std::os::raw::c_uint,
2310 ) -> FPDF_BOOL;
2311}
2312unsafe extern "C" {
2313 #[doc = " Set the stroke width of a page object.\n\n path - the handle to the page object.\n width - the width of the stroke.\n\n Returns TRUE on success"]
2314 pub fn FPDFPageObj_SetStrokeWidth(page_object: FPDF_PAGEOBJECT, width: f32) -> FPDF_BOOL;
2315}
2316unsafe extern "C" {
2317 #[doc = " Get the stroke width of a page object.\n\n path - the handle to the page object.\n width - the width of the stroke.\n\n Returns TRUE on success"]
2318 pub fn FPDFPageObj_GetStrokeWidth(page_object: FPDF_PAGEOBJECT, width: *mut f32) -> FPDF_BOOL;
2319}
2320unsafe extern "C" {
2321 #[doc = " Get the line join of |page_object|.\n\n page_object - handle to a page object.\n\n Returns the line join, or -1 on failure.\n Line join can be one of following: FPDF_LINEJOIN_MITER, FPDF_LINEJOIN_ROUND,\n FPDF_LINEJOIN_BEVEL"]
2322 pub fn FPDFPageObj_GetLineJoin(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2323}
2324unsafe extern "C" {
2325 #[doc = " Set the line join of |page_object|.\n\n page_object - handle to a page object.\n line_join - line join\n\n Line join can be one of following: FPDF_LINEJOIN_MITER, FPDF_LINEJOIN_ROUND,\n FPDF_LINEJOIN_BEVEL"]
2326 pub fn FPDFPageObj_SetLineJoin(
2327 page_object: FPDF_PAGEOBJECT,
2328 line_join: ::std::os::raw::c_int,
2329 ) -> FPDF_BOOL;
2330}
2331unsafe extern "C" {
2332 #[doc = " Get the line cap of |page_object|.\n\n page_object - handle to a page object.\n\n Returns the line cap, or -1 on failure.\n Line cap can be one of following: FPDF_LINECAP_BUTT, FPDF_LINECAP_ROUND,\n FPDF_LINECAP_PROJECTING_SQUARE"]
2333 pub fn FPDFPageObj_GetLineCap(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2334}
2335unsafe extern "C" {
2336 #[doc = " Set the line cap of |page_object|.\n\n page_object - handle to a page object.\n line_cap - line cap\n\n Line cap can be one of following: FPDF_LINECAP_BUTT, FPDF_LINECAP_ROUND,\n FPDF_LINECAP_PROJECTING_SQUARE"]
2337 pub fn FPDFPageObj_SetLineCap(
2338 page_object: FPDF_PAGEOBJECT,
2339 line_cap: ::std::os::raw::c_int,
2340 ) -> FPDF_BOOL;
2341}
2342unsafe extern "C" {
2343 #[doc = " Set the fill RGBA of a page object. Range of values: 0 - 255.\n\n page_object - the handle to the page object.\n R - the red component for the object's fill color.\n G - the green component for the object's fill color.\n B - the blue component for the object's fill color.\n A - the fill alpha for the object.\n\n Returns TRUE on success."]
2344 pub fn FPDFPageObj_SetFillColor(
2345 page_object: FPDF_PAGEOBJECT,
2346 R: ::std::os::raw::c_uint,
2347 G: ::std::os::raw::c_uint,
2348 B: ::std::os::raw::c_uint,
2349 A: ::std::os::raw::c_uint,
2350 ) -> FPDF_BOOL;
2351}
2352unsafe extern "C" {
2353 #[doc = " Get the fill RGBA of a page object. Range of values: 0 - 255.\n\n page_object - the handle to the page object.\n R - the red component of the object's fill color.\n G - the green component of the object's fill color.\n B - the blue component of the object's fill color.\n A - the fill alpha of the object.\n\n Returns TRUE on success."]
2354 pub fn FPDFPageObj_GetFillColor(
2355 page_object: FPDF_PAGEOBJECT,
2356 R: *mut ::std::os::raw::c_uint,
2357 G: *mut ::std::os::raw::c_uint,
2358 B: *mut ::std::os::raw::c_uint,
2359 A: *mut ::std::os::raw::c_uint,
2360 ) -> FPDF_BOOL;
2361}
2362unsafe extern "C" {
2363 #[doc = " Experimental API.\n Get the line dash |phase| of |page_object|.\n\n page_object - handle to a page object.\n phase - pointer where the dashing phase will be stored.\n\n Returns TRUE on success."]
2364 pub fn FPDFPageObj_GetDashPhase(page_object: FPDF_PAGEOBJECT, phase: *mut f32) -> FPDF_BOOL;
2365}
2366unsafe extern "C" {
2367 #[doc = " Experimental API.\n Set the line dash phase of |page_object|.\n\n page_object - handle to a page object.\n phase - line dash phase.\n\n Returns TRUE on success."]
2368 pub fn FPDFPageObj_SetDashPhase(page_object: FPDF_PAGEOBJECT, phase: f32) -> FPDF_BOOL;
2369}
2370unsafe extern "C" {
2371 #[doc = " Experimental API.\n Get the line dash array of |page_object|.\n\n page_object - handle to a page object.\n\n Returns the line dash array size or -1 on failure."]
2372 pub fn FPDFPageObj_GetDashCount(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2373}
2374unsafe extern "C" {
2375 #[doc = " Experimental API.\n Get the line dash array of |page_object|.\n\n page_object - handle to a page object.\n dash_array - pointer where the dashing array will be stored.\n dash_count - number of elements in |dash_array|.\n\n Returns TRUE on success."]
2376 pub fn FPDFPageObj_GetDashArray(
2377 page_object: FPDF_PAGEOBJECT,
2378 dash_array: *mut f32,
2379 dash_count: usize,
2380 ) -> FPDF_BOOL;
2381}
2382unsafe extern "C" {
2383 #[doc = " Experimental API.\n Set the line dash array of |page_object|.\n\n page_object - handle to a page object.\n dash_array - the dash array.\n dash_count - number of elements in |dash_array|.\n phase - the line dash phase.\n\n Returns TRUE on success."]
2384 pub fn FPDFPageObj_SetDashArray(
2385 page_object: FPDF_PAGEOBJECT,
2386 dash_array: *const f32,
2387 dash_count: usize,
2388 phase: f32,
2389 ) -> FPDF_BOOL;
2390}
2391unsafe extern "C" {
2392 #[doc = " Get number of segments inside |path|.\n\n path - handle to a path.\n\n A segment is a command, created by e.g. FPDFPath_MoveTo(),\n FPDFPath_LineTo() or FPDFPath_BezierTo().\n\n Returns the number of objects in |path| or -1 on failure."]
2393 pub fn FPDFPath_CountSegments(path: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2394}
2395unsafe extern "C" {
2396 #[doc = " Get segment in |path| at |index|.\n\n path - handle to a path.\n index - the index of a segment.\n\n Returns the handle to the segment, or NULL on faiure."]
2397 pub fn FPDFPath_GetPathSegment(
2398 path: FPDF_PAGEOBJECT,
2399 index: ::std::os::raw::c_int,
2400 ) -> FPDF_PATHSEGMENT;
2401}
2402unsafe extern "C" {
2403 #[doc = " Get coordinates of |segment|.\n\n segment - handle to a segment.\n x - the horizontal position of the segment.\n y - the vertical position of the segment.\n\n Returns TRUE on success, otherwise |x| and |y| is not set."]
2404 pub fn FPDFPathSegment_GetPoint(
2405 segment: FPDF_PATHSEGMENT,
2406 x: *mut f32,
2407 y: *mut f32,
2408 ) -> FPDF_BOOL;
2409}
2410unsafe extern "C" {
2411 #[doc = " Get type of |segment|.\n\n segment - handle to a segment.\n\n Returns one of the FPDF_SEGMENT_* values on success,\n FPDF_SEGMENT_UNKNOWN on error."]
2412 pub fn FPDFPathSegment_GetType(segment: FPDF_PATHSEGMENT) -> ::std::os::raw::c_int;
2413}
2414unsafe extern "C" {
2415 #[doc = " Gets if the |segment| closes the current subpath of a given path.\n\n segment - handle to a segment.\n\n Returns close flag for non-NULL segment, FALSE otherwise."]
2416 pub fn FPDFPathSegment_GetClose(segment: FPDF_PATHSEGMENT) -> FPDF_BOOL;
2417}
2418unsafe extern "C" {
2419 #[doc = " Move a path's current point.\n\n path - the handle to the path object.\n x - the horizontal position of the new current point.\n y - the vertical position of the new current point.\n\n Note that no line will be created between the previous current point and the\n new one.\n\n Returns TRUE on success"]
2420 pub fn FPDFPath_MoveTo(path: FPDF_PAGEOBJECT, x: f32, y: f32) -> FPDF_BOOL;
2421}
2422unsafe extern "C" {
2423 #[doc = " Add a line between the current point and a new point in the path.\n\n path - the handle to the path object.\n x - the horizontal position of the new point.\n y - the vertical position of the new point.\n\n The path's current point is changed to (x, y).\n\n Returns TRUE on success"]
2424 pub fn FPDFPath_LineTo(path: FPDF_PAGEOBJECT, x: f32, y: f32) -> FPDF_BOOL;
2425}
2426unsafe extern "C" {
2427 #[doc = " Add a cubic Bezier curve to the given path, starting at the current point.\n\n path - the handle to the path object.\n x1 - the horizontal position of the first Bezier control point.\n y1 - the vertical position of the first Bezier control point.\n x2 - the horizontal position of the second Bezier control point.\n y2 - the vertical position of the second Bezier control point.\n x3 - the horizontal position of the ending point of the Bezier curve.\n y3 - the vertical position of the ending point of the Bezier curve.\n\n Returns TRUE on success"]
2428 pub fn FPDFPath_BezierTo(
2429 path: FPDF_PAGEOBJECT,
2430 x1: f32,
2431 y1: f32,
2432 x2: f32,
2433 y2: f32,
2434 x3: f32,
2435 y3: f32,
2436 ) -> FPDF_BOOL;
2437}
2438unsafe extern "C" {
2439 #[doc = " Close the current subpath of a given path.\n\n path - the handle to the path object.\n\n This will add a line between the current point and the initial point of the\n subpath, thus terminating the current subpath.\n\n Returns TRUE on success"]
2440 pub fn FPDFPath_Close(path: FPDF_PAGEOBJECT) -> FPDF_BOOL;
2441}
2442unsafe extern "C" {
2443 #[doc = " Set the drawing mode of a path.\n\n path - the handle to the path object.\n fillmode - the filling mode to be set: one of the FPDF_FILLMODE_* flags.\n stroke - a boolean specifying if the path should be stroked or not.\n\n Returns TRUE on success"]
2444 pub fn FPDFPath_SetDrawMode(
2445 path: FPDF_PAGEOBJECT,
2446 fillmode: ::std::os::raw::c_int,
2447 stroke: FPDF_BOOL,
2448 ) -> FPDF_BOOL;
2449}
2450unsafe extern "C" {
2451 #[doc = " Get the drawing mode of a path.\n\n path - the handle to the path object.\n fillmode - the filling mode of the path: one of the FPDF_FILLMODE_* flags.\n stroke - a boolean specifying if the path is stroked or not.\n\n Returns TRUE on success"]
2452 pub fn FPDFPath_GetDrawMode(
2453 path: FPDF_PAGEOBJECT,
2454 fillmode: *mut ::std::os::raw::c_int,
2455 stroke: *mut FPDF_BOOL,
2456 ) -> FPDF_BOOL;
2457}
2458unsafe extern "C" {
2459 #[doc = " Create a new text object using one of the standard PDF fonts.\n\n document - handle to the document.\n font - string containing the font name, without spaces.\n font_size - the font size for the new text object.\n\n Returns a handle to a new text object, or NULL on failure"]
2460 pub fn FPDFPageObj_NewTextObj(
2461 document: FPDF_DOCUMENT,
2462 font: FPDF_BYTESTRING,
2463 font_size: f32,
2464 ) -> FPDF_PAGEOBJECT;
2465}
2466unsafe extern "C" {
2467 #[doc = " Set the text for a text object. If it had text, it will be replaced.\n\n text_object - handle to the text object.\n text - the UTF-16LE encoded string containing the text to be added.\n\n Returns TRUE on success"]
2468 pub fn FPDFText_SetText(text_object: FPDF_PAGEOBJECT, text: FPDF_WIDESTRING) -> FPDF_BOOL;
2469}
2470unsafe extern "C" {
2471 #[doc = " Experimental API.\n Set the text using charcodes for a text object. If it had text, it will be\n replaced.\n\n text_object - handle to the text object.\n charcodes - pointer to an array of charcodes to be added.\n count - number of elements in |charcodes|.\n\n Returns TRUE on success"]
2472 pub fn FPDFText_SetCharcodes(
2473 text_object: FPDF_PAGEOBJECT,
2474 charcodes: *const u32,
2475 count: usize,
2476 ) -> FPDF_BOOL;
2477}
2478unsafe extern "C" {
2479 #[doc = " Returns a font object loaded from a stream of data. The font is loaded\n into the document. Various font data structures, such as the ToUnicode data,\n are auto-generated based on the inputs.\n\n document - handle to the document.\n data - the stream of font data, which will be copied by the font object.\n size - the size of the font data, in bytes.\n font_type - FPDF_FONT_TYPE1 or FPDF_FONT_TRUETYPE depending on the font type.\n cid - a boolean specifying if the font is a CID font or not.\n\n The loaded font can be closed using FPDFFont_Close().\n\n Returns NULL on failure"]
2480 pub fn FPDFText_LoadFont(
2481 document: FPDF_DOCUMENT,
2482 data: *const u8,
2483 size: u32,
2484 font_type: ::std::os::raw::c_int,
2485 cid: FPDF_BOOL,
2486 ) -> FPDF_FONT;
2487}
2488unsafe extern "C" {
2489 #[doc = " Experimental API.\n Loads one of the standard 14 fonts per PDF spec 1.7 page 416. The preferred\n way of using font style is using a dash to separate the name from the style,\n for example 'Helvetica-BoldItalic'.\n\n document - handle to the document.\n font - string containing the font name, without spaces.\n\n The loaded font can be closed using FPDFFont_Close().\n\n Returns NULL on failure."]
2490 pub fn FPDFText_LoadStandardFont(document: FPDF_DOCUMENT, font: FPDF_BYTESTRING) -> FPDF_FONT;
2491}
2492unsafe extern "C" {
2493 #[doc = " Experimental API.\n Returns a font object loaded from a stream of data for a type 2 CID font. The\n font is loaded into the document. Unlike FPDFText_LoadFont(), the ToUnicode\n data and the CIDToGIDMap data are caller provided, instead of auto-generated.\n\n document - handle to the document.\n font_data - the stream of font data, which will be copied by\n the font object.\n font_data_size - the size of the font data, in bytes.\n to_unicode_cmap - the ToUnicode data.\n cid_to_gid_map_data - the stream of CIDToGIDMap data.\n cid_to_gid_map_data_size - the size of the CIDToGIDMap data, in bytes.\n\n The loaded font can be closed using FPDFFont_Close().\n\n Returns NULL on failure."]
2494 pub fn FPDFText_LoadCidType2Font(
2495 document: FPDF_DOCUMENT,
2496 font_data: *const u8,
2497 font_data_size: u32,
2498 to_unicode_cmap: FPDF_BYTESTRING,
2499 cid_to_gid_map_data: *const u8,
2500 cid_to_gid_map_data_size: u32,
2501 ) -> FPDF_FONT;
2502}
2503unsafe extern "C" {
2504 #[doc = " Get the font size of a text object.\n\n text - handle to a text.\n size - pointer to the font size of the text object, measured in points\n (about 1/72 inch)\n\n Returns TRUE on success."]
2505 pub fn FPDFTextObj_GetFontSize(text: FPDF_PAGEOBJECT, size: *mut f32) -> FPDF_BOOL;
2506}
2507unsafe extern "C" {
2508 #[doc = " Close a loaded PDF font.\n\n font - Handle to the loaded font."]
2509 pub fn FPDFFont_Close(font: FPDF_FONT);
2510}
2511unsafe extern "C" {
2512 #[doc = " Create a new text object using a loaded font.\n\n document - handle to the document.\n font - handle to the font object.\n font_size - the font size for the new text object.\n\n Returns a handle to a new text object, or NULL on failure"]
2513 pub fn FPDFPageObj_CreateTextObj(
2514 document: FPDF_DOCUMENT,
2515 font: FPDF_FONT,
2516 font_size: f32,
2517 ) -> FPDF_PAGEOBJECT;
2518}
2519unsafe extern "C" {
2520 #[doc = " Get the text rendering mode of a text object.\n\n text - the handle to the text object.\n\n Returns one of the known FPDF_TEXT_RENDERMODE enum values on success,\n FPDF_TEXTRENDERMODE_UNKNOWN on error."]
2521 pub fn FPDFTextObj_GetTextRenderMode(text: FPDF_PAGEOBJECT) -> FPDF_TEXT_RENDERMODE;
2522}
2523unsafe extern "C" {
2524 #[doc = " Experimental API.\n Set the text rendering mode of a text object.\n\n text - the handle to the text object.\n render_mode - the FPDF_TEXT_RENDERMODE enum value to be set (cannot set to\n FPDF_TEXTRENDERMODE_UNKNOWN).\n\n Returns TRUE on success."]
2525 pub fn FPDFTextObj_SetTextRenderMode(
2526 text: FPDF_PAGEOBJECT,
2527 render_mode: FPDF_TEXT_RENDERMODE,
2528 ) -> FPDF_BOOL;
2529}
2530unsafe extern "C" {
2531 #[doc = " Get the text of a text object.\n\n text_object - the handle to the text object.\n text_page - the handle to the text page.\n buffer - the address of a buffer that receives the text.\n length - the size, in bytes, of |buffer|.\n\n Returns the number of bytes in the text (including the trailing NUL\n character) on success, 0 on error.\n\n Regardless of the platform, the |buffer| is always in UTF-16LE encoding.\n If |length| is less than the returned length, or |buffer| is NULL, |buffer|\n will not be modified."]
2532 pub fn FPDFTextObj_GetText(
2533 text_object: FPDF_PAGEOBJECT,
2534 text_page: FPDF_TEXTPAGE,
2535 buffer: *mut FPDF_WCHAR,
2536 length: ::std::os::raw::c_ulong,
2537 ) -> ::std::os::raw::c_ulong;
2538}
2539unsafe extern "C" {
2540 #[doc = " Experimental API.\n Get a bitmap rasterization of |text_object|. To render correctly, the caller\n must provide the |document| associated with |text_object|. If there is a\n |page| associated with |text_object|, the caller should provide that as well.\n The returned bitmap will be owned by the caller, and FPDFBitmap_Destroy()\n must be called on the returned bitmap when it is no longer needed.\n\n document - handle to a document associated with |text_object|.\n page - handle to an optional page associated with |text_object|.\n text_object - handle to a text object.\n scale - the scaling factor, which must be greater than 0.\n\n Returns the bitmap or NULL on failure."]
2541 pub fn FPDFTextObj_GetRenderedBitmap(
2542 document: FPDF_DOCUMENT,
2543 page: FPDF_PAGE,
2544 text_object: FPDF_PAGEOBJECT,
2545 scale: f32,
2546 ) -> FPDF_BITMAP;
2547}
2548unsafe extern "C" {
2549 #[doc = " Experimental API.\n Get the font of a text object.\n\n text - the handle to the text object.\n\n Returns a handle to the font object held by |text| which retains ownership."]
2550 pub fn FPDFTextObj_GetFont(text: FPDF_PAGEOBJECT) -> FPDF_FONT;
2551}
2552unsafe extern "C" {
2553 #[doc = " Experimental API.\n Get the base name of a font.\n\n font - the handle to the font object.\n buffer - the address of a buffer that receives the base font name.\n length - the size, in bytes, of |buffer|.\n\n Returns the number of bytes in the base name (including the trailing NUL\n character) on success, 0 on error. The base name is typically the font's\n PostScript name. See descriptions of \"BaseFont\" in ISO 32000-1:2008 spec.\n\n Regardless of the platform, the |buffer| is always in UTF-8 encoding.\n If |length| is less than the returned length, or |buffer| is NULL, |buffer|\n will not be modified."]
2554 pub fn FPDFFont_GetBaseFontName(
2555 font: FPDF_FONT,
2556 buffer: *mut ::std::os::raw::c_char,
2557 length: usize,
2558 ) -> usize;
2559}
2560unsafe extern "C" {
2561 #[doc = " Experimental API.\n Get the family name of a font.\n\n font - the handle to the font object.\n buffer - the address of a buffer that receives the font name.\n length - the size, in bytes, of |buffer|.\n\n Returns the number of bytes in the family name (including the trailing NUL\n character) on success, 0 on error.\n\n Regardless of the platform, the |buffer| is always in UTF-8 encoding.\n If |length| is less than the returned length, or |buffer| is NULL, |buffer|\n will not be modified."]
2562 pub fn FPDFFont_GetFamilyName(
2563 font: FPDF_FONT,
2564 buffer: *mut ::std::os::raw::c_char,
2565 length: usize,
2566 ) -> usize;
2567}
2568unsafe extern "C" {
2569 #[doc = " Experimental API.\n Get the decoded data from the |font| object.\n\n font - The handle to the font object. (Required)\n buffer - The address of a buffer that receives the font data.\n buflen - Length of the buffer.\n out_buflen - Pointer to variable that will receive the minimum buffer size\n to contain the font data. Not filled if the return value is\n FALSE. (Required)\n\n Returns TRUE on success. In which case, |out_buflen| will be filled, and\n |buffer| will be filled if it is large enough. Returns FALSE if any of the\n required parameters are null.\n\n The decoded data is the uncompressed font data. i.e. the raw font data after\n having all stream filters applied, when the data is embedded.\n\n If the font is not embedded, then this API will instead return the data for\n the substitution font it is using."]
2570 pub fn FPDFFont_GetFontData(
2571 font: FPDF_FONT,
2572 buffer: *mut u8,
2573 buflen: usize,
2574 out_buflen: *mut usize,
2575 ) -> FPDF_BOOL;
2576}
2577unsafe extern "C" {
2578 #[doc = " Experimental API.\n Get whether |font| is embedded or not.\n\n font - the handle to the font object.\n\n Returns 1 if the font is embedded, 0 if it not, and -1 on failure."]
2579 pub fn FPDFFont_GetIsEmbedded(font: FPDF_FONT) -> ::std::os::raw::c_int;
2580}
2581unsafe extern "C" {
2582 #[doc = " Experimental API.\n Get the descriptor flags of a font.\n\n font - the handle to the font object.\n\n Returns the bit flags specifying various characteristics of the font as\n defined in ISO 32000-1:2008, table 123, -1 on failure."]
2583 pub fn FPDFFont_GetFlags(font: FPDF_FONT) -> ::std::os::raw::c_int;
2584}
2585unsafe extern "C" {
2586 #[doc = " Experimental API.\n Get the font weight of a font.\n\n font - the handle to the font object.\n\n Returns the font weight, -1 on failure.\n Typical values are 400 (normal) and 700 (bold)."]
2587 pub fn FPDFFont_GetWeight(font: FPDF_FONT) -> ::std::os::raw::c_int;
2588}
2589unsafe extern "C" {
2590 #[doc = " Experimental API.\n Get the italic angle of a font.\n\n font - the handle to the font object.\n angle - pointer where the italic angle will be stored\n\n The italic angle of a |font| is defined as degrees counterclockwise\n from vertical. For a font that slopes to the right, this will be negative.\n\n Returns TRUE on success; |angle| unmodified on failure."]
2591 pub fn FPDFFont_GetItalicAngle(font: FPDF_FONT, angle: *mut ::std::os::raw::c_int)
2592 -> FPDF_BOOL;
2593}
2594unsafe extern "C" {
2595 #[doc = " Experimental API.\n Get ascent distance of a font.\n\n font - the handle to the font object.\n font_size - the size of the |font|.\n ascent - pointer where the font ascent will be stored\n\n Ascent is the maximum distance in points above the baseline reached by the\n glyphs of the |font|. One point is 1/72 inch (around 0.3528 mm).\n\n Returns TRUE on success; |ascent| unmodified on failure."]
2596 pub fn FPDFFont_GetAscent(font: FPDF_FONT, font_size: f32, ascent: *mut f32) -> FPDF_BOOL;
2597}
2598unsafe extern "C" {
2599 #[doc = " Experimental API.\n Get descent distance of a font.\n\n font - the handle to the font object.\n font_size - the size of the |font|.\n descent - pointer where the font descent will be stored\n\n Descent is the maximum distance in points below the baseline reached by the\n glyphs of the |font|. One point is 1/72 inch (around 0.3528 mm).\n\n Returns TRUE on success; |descent| unmodified on failure."]
2600 pub fn FPDFFont_GetDescent(font: FPDF_FONT, font_size: f32, descent: *mut f32) -> FPDF_BOOL;
2601}
2602unsafe extern "C" {
2603 #[doc = " Experimental API.\n Get the width of a glyph in a font.\n\n font - the handle to the font object.\n glyph - the glyph.\n font_size - the size of the font.\n width - pointer where the glyph width will be stored\n\n Glyph width is the distance from the end of the prior glyph to the next\n glyph. This will be the vertical distance for vertical writing.\n\n Returns TRUE on success; |width| unmodified on failure."]
2604 pub fn FPDFFont_GetGlyphWidth(
2605 font: FPDF_FONT,
2606 glyph: u32,
2607 font_size: f32,
2608 width: *mut f32,
2609 ) -> FPDF_BOOL;
2610}
2611unsafe extern "C" {
2612 #[doc = " Experimental API.\n Get the glyphpath describing how to draw a font glyph.\n\n font - the handle to the font object.\n glyph - the glyph being drawn.\n font_size - the size of the font.\n\n Returns the handle to the segment, or NULL on faiure."]
2613 pub fn FPDFFont_GetGlyphPath(font: FPDF_FONT, glyph: u32, font_size: f32) -> FPDF_GLYPHPATH;
2614}
2615unsafe extern "C" {
2616 #[doc = " Experimental API.\n Get number of segments inside glyphpath.\n\n glyphpath - handle to a glyph path.\n\n Returns the number of objects in |glyphpath| or -1 on failure."]
2617 pub fn FPDFGlyphPath_CountGlyphSegments(glyphpath: FPDF_GLYPHPATH) -> ::std::os::raw::c_int;
2618}
2619unsafe extern "C" {
2620 #[doc = " Experimental API.\n Get segment in glyphpath at index.\n\n glyphpath - handle to a glyph path.\n index - the index of a segment.\n\n Returns the handle to the segment, or NULL on faiure."]
2621 pub fn FPDFGlyphPath_GetGlyphPathSegment(
2622 glyphpath: FPDF_GLYPHPATH,
2623 index: ::std::os::raw::c_int,
2624 ) -> FPDF_PATHSEGMENT;
2625}
2626unsafe extern "C" {
2627 #[doc = " Get number of page objects inside |form_object|.\n\n form_object - handle to a form object.\n\n Returns the number of objects in |form_object| on success, -1 on error."]
2628 pub fn FPDFFormObj_CountObjects(form_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2629}
2630unsafe extern "C" {
2631 #[doc = " Get page object in |form_object| at |index|.\n\n form_object - handle to a form object.\n index - the 0-based index of a page object.\n\n Returns the handle to the page object, or NULL on error."]
2632 pub fn FPDFFormObj_GetObject(
2633 form_object: FPDF_PAGEOBJECT,
2634 index: ::std::os::raw::c_ulong,
2635 ) -> FPDF_PAGEOBJECT;
2636}
2637unsafe extern "C" {
2638 #[doc = " Experimental API.\n\n Remove |page_object| from |form_object|.\n\n form_object - handle to a form object.\n page_object - handle to a page object to be removed from the form.\n\n Returns TRUE on success.\n\n Ownership of the removed |page_object| is transferred to the caller.\n Call FPDFPageObj_Destroy() on the removed page_object to free it."]
2639 pub fn FPDFFormObj_RemoveObject(
2640 form_object: FPDF_PAGEOBJECT,
2641 page_object: FPDF_PAGEOBJECT,
2642 ) -> FPDF_BOOL;
2643}
2644unsafe extern "C" {
2645 #[doc = " Experimental API.\n Get the number of JavaScript actions in |document|.\n\n document - handle to a document.\n\n Returns the number of JavaScript actions in |document| or -1 on error."]
2646 pub fn FPDFDoc_GetJavaScriptActionCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
2647}
2648unsafe extern "C" {
2649 #[doc = " Experimental API.\n Get the JavaScript action at |index| in |document|.\n\n document - handle to a document.\n index - the index of the requested JavaScript action.\n\n Returns the handle to the JavaScript action, or NULL on failure.\n Caller owns the returned handle and must close it with\n FPDFDoc_CloseJavaScriptAction()."]
2650 pub fn FPDFDoc_GetJavaScriptAction(
2651 document: FPDF_DOCUMENT,
2652 index: ::std::os::raw::c_int,
2653 ) -> FPDF_JAVASCRIPT_ACTION;
2654}
2655unsafe extern "C" {
2656 #[doc = " javascript - Handle to a JavaScript action."]
2657 pub fn FPDFDoc_CloseJavaScriptAction(javascript: FPDF_JAVASCRIPT_ACTION);
2658}
2659unsafe extern "C" {
2660 #[doc = " Experimental API.\n Get the name from the |javascript| handle. |buffer| is only modified if\n |buflen| is longer than the length of the name. On errors, |buffer| is\n unmodified and the returned length is 0.\n\n javascript - handle to an JavaScript action.\n buffer - buffer for holding the name, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the JavaScript action name in bytes."]
2661 pub fn FPDFJavaScriptAction_GetName(
2662 javascript: FPDF_JAVASCRIPT_ACTION,
2663 buffer: *mut FPDF_WCHAR,
2664 buflen: ::std::os::raw::c_ulong,
2665 ) -> ::std::os::raw::c_ulong;
2666}
2667unsafe extern "C" {
2668 #[doc = " Experimental API.\n Get the script from the |javascript| handle. |buffer| is only modified if\n |buflen| is longer than the length of the script. On errors, |buffer| is\n unmodified and the returned length is 0.\n\n javascript - handle to an JavaScript action.\n buffer - buffer for holding the name, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the JavaScript action name in bytes."]
2669 pub fn FPDFJavaScriptAction_GetScript(
2670 javascript: FPDF_JAVASCRIPT_ACTION,
2671 buffer: *mut FPDF_WCHAR,
2672 buflen: ::std::os::raw::c_ulong,
2673 ) -> ::std::os::raw::c_ulong;
2674}
2675unsafe extern "C" {
2676 #[doc = " Function: FPDF_StructTree_GetForPage\n Get the structure tree for a page.\n Parameters:\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return value:\n A handle to the structure tree or NULL on error. The caller owns the\n returned handle and must use FPDF_StructTree_Close() to release it.\n The handle should be released before |page| gets released."]
2677 pub fn FPDF_StructTree_GetForPage(page: FPDF_PAGE) -> FPDF_STRUCTTREE;
2678}
2679unsafe extern "C" {
2680 #[doc = " Function: FPDF_StructTree_Close\n Release a resource allocated by FPDF_StructTree_GetForPage().\n Parameters:\n struct_tree - Handle to the structure tree, as returned by\n FPDF_StructTree_LoadPage().\n Return value:\n None."]
2681 pub fn FPDF_StructTree_Close(struct_tree: FPDF_STRUCTTREE);
2682}
2683unsafe extern "C" {
2684 #[doc = " Function: FPDF_StructTree_CountChildren\n Count the number of children for the structure tree.\n Parameters:\n struct_tree - Handle to the structure tree, as returned by\n FPDF_StructTree_LoadPage().\n Return value:\n The number of children, or -1 on error."]
2685 pub fn FPDF_StructTree_CountChildren(struct_tree: FPDF_STRUCTTREE) -> ::std::os::raw::c_int;
2686}
2687unsafe extern "C" {
2688 #[doc = " Function: FPDF_StructTree_GetChildAtIndex\n Get a child in the structure tree.\n Parameters:\n struct_tree - Handle to the structure tree, as returned by\n FPDF_StructTree_LoadPage().\n index - The index for the child, 0-based.\n Return value:\n The child at the n-th index or NULL on error. The caller does not\n own the handle. The handle remains valid as long as |struct_tree|\n remains valid.\n Comments:\n The |index| must be less than the FPDF_StructTree_CountChildren()\n return value."]
2689 pub fn FPDF_StructTree_GetChildAtIndex(
2690 struct_tree: FPDF_STRUCTTREE,
2691 index: ::std::os::raw::c_int,
2692 ) -> FPDF_STRUCTELEMENT;
2693}
2694unsafe extern "C" {
2695 #[doc = " Function: FPDF_StructElement_GetAltText\n Get the alt text for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output the alt text. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the alt text, including the terminating NUL\n character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2696 pub fn FPDF_StructElement_GetAltText(
2697 struct_element: FPDF_STRUCTELEMENT,
2698 buffer: *mut ::std::os::raw::c_void,
2699 buflen: ::std::os::raw::c_ulong,
2700 ) -> ::std::os::raw::c_ulong;
2701}
2702unsafe extern "C" {
2703 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetActualText\n Get the actual text for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output the actual text. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the actual text, including the terminating\n NUL character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2704 pub fn FPDF_StructElement_GetActualText(
2705 struct_element: FPDF_STRUCTELEMENT,
2706 buffer: *mut ::std::os::raw::c_void,
2707 buflen: ::std::os::raw::c_ulong,
2708 ) -> ::std::os::raw::c_ulong;
2709}
2710unsafe extern "C" {
2711 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetExpansion\n Get the expansion of an abbreviation or acronym for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output the expansion text. May be\n NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the expansion text, including the terminating\n NUL character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2712 pub fn FPDF_StructElement_GetExpansion(
2713 struct_element: FPDF_STRUCTELEMENT,
2714 buffer: *mut ::std::os::raw::c_void,
2715 buflen: ::std::os::raw::c_ulong,
2716 ) -> ::std::os::raw::c_ulong;
2717}
2718unsafe extern "C" {
2719 #[doc = " Function: FPDF_StructElement_GetID\n Get the ID for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output the ID string. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the ID string, including the terminating NUL\n character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2720 pub fn FPDF_StructElement_GetID(
2721 struct_element: FPDF_STRUCTELEMENT,
2722 buffer: *mut ::std::os::raw::c_void,
2723 buflen: ::std::os::raw::c_ulong,
2724 ) -> ::std::os::raw::c_ulong;
2725}
2726unsafe extern "C" {
2727 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetLang\n Get the case-insensitive IETF BCP 47 language code for an element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output the lang string. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the ID string, including the terminating NUL\n character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2728 pub fn FPDF_StructElement_GetLang(
2729 struct_element: FPDF_STRUCTELEMENT,
2730 buffer: *mut ::std::os::raw::c_void,
2731 buflen: ::std::os::raw::c_ulong,
2732 ) -> ::std::os::raw::c_ulong;
2733}
2734unsafe extern "C" {
2735 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetStringAttribute\n Get a struct element attribute of type \"name\" or \"string\".\n Parameters:\n struct_element - Handle to the struct element.\n attr_name - The name of the attribute to retrieve.\n buffer - A buffer for output. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the attribute value, including the\n terminating NUL character. The number of bytes is returned\n regardless of the |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2736 pub fn FPDF_StructElement_GetStringAttribute(
2737 struct_element: FPDF_STRUCTELEMENT,
2738 attr_name: FPDF_BYTESTRING,
2739 buffer: *mut ::std::os::raw::c_void,
2740 buflen: ::std::os::raw::c_ulong,
2741 ) -> ::std::os::raw::c_ulong;
2742}
2743unsafe extern "C" {
2744 #[doc = " Function: FPDF_StructElement_GetMarkedContentID\n Get the marked content ID for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n Return value:\n The marked content ID of the element. If no ID exists, returns\n -1.\n Comments:\n FPDF_StructElement_GetMarkedContentIdAtIndex() may be able to\n extract more marked content IDs out of |struct_element|. This API\n may be deprecated in the future."]
2745 pub fn FPDF_StructElement_GetMarkedContentID(
2746 struct_element: FPDF_STRUCTELEMENT,
2747 ) -> ::std::os::raw::c_int;
2748}
2749unsafe extern "C" {
2750 #[doc = " Function: FPDF_StructElement_GetType\n Get the type (/S) for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the type, including the terminating NUL\n character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2751 pub fn FPDF_StructElement_GetType(
2752 struct_element: FPDF_STRUCTELEMENT,
2753 buffer: *mut ::std::os::raw::c_void,
2754 buflen: ::std::os::raw::c_ulong,
2755 ) -> ::std::os::raw::c_ulong;
2756}
2757unsafe extern "C" {
2758 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetObjType\n Get the object type (/Type) for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the object type, including the terminating\n NUL character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2759 pub fn FPDF_StructElement_GetObjType(
2760 struct_element: FPDF_STRUCTELEMENT,
2761 buffer: *mut ::std::os::raw::c_void,
2762 buflen: ::std::os::raw::c_ulong,
2763 ) -> ::std::os::raw::c_ulong;
2764}
2765unsafe extern "C" {
2766 #[doc = " Function: FPDF_StructElement_GetTitle\n Get the title (/T) for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output. May be NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the title, including the terminating NUL\n character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
2767 pub fn FPDF_StructElement_GetTitle(
2768 struct_element: FPDF_STRUCTELEMENT,
2769 buffer: *mut ::std::os::raw::c_void,
2770 buflen: ::std::os::raw::c_ulong,
2771 ) -> ::std::os::raw::c_ulong;
2772}
2773unsafe extern "C" {
2774 #[doc = " Function: FPDF_StructElement_CountChildren\n Count the number of children for the structure element.\n Parameters:\n struct_element - Handle to the struct element.\n Return value:\n The number of children, or -1 on error."]
2775 pub fn FPDF_StructElement_CountChildren(
2776 struct_element: FPDF_STRUCTELEMENT,
2777 ) -> ::std::os::raw::c_int;
2778}
2779unsafe extern "C" {
2780 #[doc = " Function: FPDF_StructElement_GetChildAtIndex\n Get a child in the structure element.\n Parameters:\n struct_element - Handle to the struct element.\n index - The index for the child, 0-based.\n Return value:\n The child at the n-th index or NULL on error.\n Comments:\n If the child exists but is not an element, then this function will\n return NULL. This will also return NULL for out of bounds indices.\n The |index| must be less than the FPDF_StructElement_CountChildren()\n return value."]
2781 pub fn FPDF_StructElement_GetChildAtIndex(
2782 struct_element: FPDF_STRUCTELEMENT,
2783 index: ::std::os::raw::c_int,
2784 ) -> FPDF_STRUCTELEMENT;
2785}
2786unsafe extern "C" {
2787 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetChildMarkedContentID\n Get the child's content id\n Parameters:\n struct_element - Handle to the struct element.\n index - The index for the child, 0-based.\n Return value:\n The marked content ID of the child. If no ID exists, returns -1.\n Comments:\n If the child exists but is not a stream or object, then this\n function will return -1. This will also return -1 for out of bounds\n indices. Compared to FPDF_StructElement_GetMarkedContentIdAtIndex,\n it is scoped to the current page.\n The |index| must be less than the FPDF_StructElement_CountChildren()\n return value."]
2788 pub fn FPDF_StructElement_GetChildMarkedContentID(
2789 struct_element: FPDF_STRUCTELEMENT,
2790 index: ::std::os::raw::c_int,
2791 ) -> ::std::os::raw::c_int;
2792}
2793unsafe extern "C" {
2794 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetParent\n Get the parent of the structure element.\n Parameters:\n struct_element - Handle to the struct element.\n Return value:\n The parent structure element or NULL on error.\n Comments:\n If structure element is StructTreeRoot, then this function will\n return NULL."]
2795 pub fn FPDF_StructElement_GetParent(struct_element: FPDF_STRUCTELEMENT) -> FPDF_STRUCTELEMENT;
2796}
2797unsafe extern "C" {
2798 #[doc = " Function: FPDF_StructElement_GetAttributeCount\n Count the number of attributes for the structure element.\n Parameters:\n struct_element - Handle to the struct element.\n Return value:\n The number of attributes, or -1 on error."]
2799 pub fn FPDF_StructElement_GetAttributeCount(
2800 struct_element: FPDF_STRUCTELEMENT,
2801 ) -> ::std::os::raw::c_int;
2802}
2803unsafe extern "C" {
2804 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetAttributeAtIndex\n Get an attribute object in the structure element.\n Parameters:\n struct_element - Handle to the struct element.\n index - The index for the attribute object, 0-based.\n Return value:\n The attribute object at the n-th index or NULL on error.\n Comments:\n If the attribute object exists but is not a dict, then this\n function will return NULL. This will also return NULL for out of\n bounds indices. The caller does not own the handle. The handle\n remains valid as long as |struct_element| remains valid.\n The |index| must be less than the\n FPDF_StructElement_GetAttributeCount() return value."]
2805 pub fn FPDF_StructElement_GetAttributeAtIndex(
2806 struct_element: FPDF_STRUCTELEMENT,
2807 index: ::std::os::raw::c_int,
2808 ) -> FPDF_STRUCTELEMENT_ATTR;
2809}
2810unsafe extern "C" {
2811 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetCount\n Count the number of attributes in a structure element attribute map.\n Parameters:\n struct_attribute - Handle to the struct element attribute.\n Return value:\n The number of attributes, or -1 on error."]
2812 pub fn FPDF_StructElement_Attr_GetCount(
2813 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
2814 ) -> ::std::os::raw::c_int;
2815}
2816unsafe extern "C" {
2817 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetName\n Get the name of an attribute in a structure element attribute map.\n Parameters:\n struct_attribute - Handle to the struct element attribute.\n index - The index of attribute in the map.\n buffer - A buffer for output. May be NULL. This is only\n modified if |buflen| is longer than the length\n of the key. Optional, pass null to just\n retrieve the size of the buffer needed.\n buflen - The length of the buffer.\n out_buflen - A pointer to variable that will receive the\n minimum buffer size to contain the key. Not\n filled if FALSE is returned.\n Return value:\n TRUE if the operation was successful, FALSE otherwise."]
2818 pub fn FPDF_StructElement_Attr_GetName(
2819 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
2820 index: ::std::os::raw::c_int,
2821 buffer: *mut ::std::os::raw::c_void,
2822 buflen: ::std::os::raw::c_ulong,
2823 out_buflen: *mut ::std::os::raw::c_ulong,
2824 ) -> FPDF_BOOL;
2825}
2826unsafe extern "C" {
2827 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetValue\n Get a handle to a value for an attribute in a structure element\n attribute map.\n Parameters:\n struct_attribute - Handle to the struct element attribute.\n name - The attribute name.\n Return value:\n Returns a handle to the value associated with the input, if any.\n Returns NULL on failure. The caller does not own the handle.\n The handle remains valid as long as |struct_attribute| remains\n valid."]
2828 pub fn FPDF_StructElement_Attr_GetValue(
2829 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
2830 name: FPDF_BYTESTRING,
2831 ) -> FPDF_STRUCTELEMENT_ATTR_VALUE;
2832}
2833unsafe extern "C" {
2834 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetType\n Get the type of an attribute in a structure element attribute map.\n Parameters:\n value - Handle to the value.\n Return value:\n Returns the type of the value, or FPDF_OBJECT_UNKNOWN in case of\n failure. Note that this will never return FPDF_OBJECT_REFERENCE, as\n references are always dereferenced."]
2835 pub fn FPDF_StructElement_Attr_GetType(
2836 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2837 ) -> FPDF_OBJECT_TYPE;
2838}
2839unsafe extern "C" {
2840 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetBooleanValue\n Get the value of a boolean attribute in an attribute map as\n FPDF_BOOL. FPDF_StructElement_Attr_GetType() should have returned\n FPDF_OBJECT_BOOLEAN for this property.\n Parameters:\n value - Handle to the value.\n out_value - A pointer to variable that will receive the value. Not\n filled if false is returned.\n Return value:\n Returns TRUE if the attribute maps to a boolean value, FALSE\n otherwise."]
2841 pub fn FPDF_StructElement_Attr_GetBooleanValue(
2842 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2843 out_value: *mut FPDF_BOOL,
2844 ) -> FPDF_BOOL;
2845}
2846unsafe extern "C" {
2847 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetNumberValue\n Get the value of a number attribute in an attribute map as float.\n FPDF_StructElement_Attr_GetType() should have returned\n FPDF_OBJECT_NUMBER for this property.\n Parameters:\n value - Handle to the value.\n out_value - A pointer to variable that will receive the value. Not\n filled if false is returned.\n Return value:\n Returns TRUE if the attribute maps to a number value, FALSE\n otherwise."]
2848 pub fn FPDF_StructElement_Attr_GetNumberValue(
2849 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2850 out_value: *mut f32,
2851 ) -> FPDF_BOOL;
2852}
2853unsafe extern "C" {
2854 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetStringValue\n Get the value of a string attribute in an attribute map as string.\n FPDF_StructElement_Attr_GetType() should have returned\n FPDF_OBJECT_STRING or FPDF_OBJECT_NAME for this property.\n Parameters:\n value - Handle to the value.\n buffer - A buffer for holding the returned key in UTF-16LE.\n This is only modified if |buflen| is longer than the\n length of the key. Optional, pass null to just\n retrieve the size of the buffer needed.\n buflen - The length of the buffer.\n out_buflen - A pointer to variable that will receive the minimum\n buffer size to contain the key. Not filled if FALSE is\n returned.\n Return value:\n Returns TRUE if the attribute maps to a string value, FALSE\n otherwise."]
2855 pub fn FPDF_StructElement_Attr_GetStringValue(
2856 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2857 buffer: *mut ::std::os::raw::c_void,
2858 buflen: ::std::os::raw::c_ulong,
2859 out_buflen: *mut ::std::os::raw::c_ulong,
2860 ) -> FPDF_BOOL;
2861}
2862unsafe extern "C" {
2863 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetBlobValue\n Get the value of a blob attribute in an attribute map as string.\n Parameters:\n value - Handle to the value.\n buffer - A buffer for holding the returned value. This is only\n modified if |buflen| is at least as long as the length\n of the value. Optional, pass null to just retrieve the\n size of the buffer needed.\n buflen - The length of the buffer.\n out_buflen - A pointer to variable that will receive the minimum\n buffer size to contain the key. Not filled if FALSE is\n returned.\n Return value:\n Returns TRUE if the attribute maps to a string value, FALSE\n otherwise."]
2864 pub fn FPDF_StructElement_Attr_GetBlobValue(
2865 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2866 buffer: *mut ::std::os::raw::c_void,
2867 buflen: ::std::os::raw::c_ulong,
2868 out_buflen: *mut ::std::os::raw::c_ulong,
2869 ) -> FPDF_BOOL;
2870}
2871unsafe extern "C" {
2872 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_CountChildren\n Count the number of children values in an attribute.\n Parameters:\n value - Handle to the value.\n Return value:\n The number of children, or -1 on error."]
2873 pub fn FPDF_StructElement_Attr_CountChildren(
2874 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2875 ) -> ::std::os::raw::c_int;
2876}
2877unsafe extern "C" {
2878 #[doc = " Experimental API.\n Function: FPDF_StructElement_Attr_GetChildAtIndex\n Get a child from an attribute.\n Parameters:\n value - Handle to the value.\n index - The index for the child, 0-based.\n Return value:\n The child at the n-th index or NULL on error.\n Comments:\n The |index| must be less than the\n FPDF_StructElement_Attr_CountChildren() return value."]
2879 pub fn FPDF_StructElement_Attr_GetChildAtIndex(
2880 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
2881 index: ::std::os::raw::c_int,
2882 ) -> FPDF_STRUCTELEMENT_ATTR_VALUE;
2883}
2884unsafe extern "C" {
2885 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetMarkedContentIdCount\n Get the count of marked content ids for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n Return value:\n The count of marked content ids or -1 if none exists."]
2886 pub fn FPDF_StructElement_GetMarkedContentIdCount(
2887 struct_element: FPDF_STRUCTELEMENT,
2888 ) -> ::std::os::raw::c_int;
2889}
2890unsafe extern "C" {
2891 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetMarkedContentIdAtIndex\n Get the marked content id at a given index for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n index - The index of the marked content id, 0-based.\n Return value:\n The marked content ID of the element. If no ID exists, returns\n -1.\n Comments:\n The |index| must be less than the\n FPDF_StructElement_GetMarkedContentIdCount() return value.\n This will likely supersede FPDF_StructElement_GetMarkedContentID()."]
2892 pub fn FPDF_StructElement_GetMarkedContentIdAtIndex(
2893 struct_element: FPDF_STRUCTELEMENT,
2894 index: ::std::os::raw::c_int,
2895 ) -> ::std::os::raw::c_int;
2896}
2897unsafe extern "C" {
2898 #[doc = " Get the character index in |text_page| internal character list.\n\n text_page - a text page information structure.\n nTextIndex - index of the text returned from FPDFText_GetText().\n\n Returns the index of the character in internal character list. -1 for error."]
2899 pub fn FPDFText_GetCharIndexFromTextIndex(
2900 text_page: FPDF_TEXTPAGE,
2901 nTextIndex: ::std::os::raw::c_int,
2902 ) -> ::std::os::raw::c_int;
2903}
2904unsafe extern "C" {
2905 #[doc = " Get the text index in |text_page| internal character list.\n\n text_page - a text page information structure.\n nCharIndex - index of the character in internal character list.\n\n Returns the index of the text returned from FPDFText_GetText(). -1 for error."]
2906 pub fn FPDFText_GetTextIndexFromCharIndex(
2907 text_page: FPDF_TEXTPAGE,
2908 nCharIndex: ::std::os::raw::c_int,
2909 ) -> ::std::os::raw::c_int;
2910}
2911unsafe extern "C" {
2912 #[doc = " Flatten annotations and form fields into the page contents.\n\n page - handle to the page.\n nFlag - One of the |FLAT_*| values denoting the page usage.\n\n Returns one of the |FLATTEN_*| values.\n\n Currently, all failures return |FLATTEN_FAIL| with no indication of the\n cause."]
2913 pub fn FPDFPage_Flatten(page: FPDF_PAGE, nFlag: ::std::os::raw::c_int)
2914 -> ::std::os::raw::c_int;
2915}
2916unsafe extern "C" {
2917 #[doc = " Experimental API.\n Import pages to a FPDF_DOCUMENT.\n\n dest_doc - The destination document for the pages.\n src_doc - The document to be imported.\n page_indices - An array of page indices to be imported. The first page is\n zero. If |page_indices| is NULL, all pages from |src_doc|\n are imported.\n length - The length of the |page_indices| array.\n index - The page index at which to insert the first imported page\n into |dest_doc|. The first page is zero.\n\n Returns TRUE on success. Returns FALSE if any pages in |page_indices| is\n invalid."]
2918 pub fn FPDF_ImportPagesByIndex(
2919 dest_doc: FPDF_DOCUMENT,
2920 src_doc: FPDF_DOCUMENT,
2921 page_indices: *const ::std::os::raw::c_int,
2922 length: ::std::os::raw::c_ulong,
2923 index: ::std::os::raw::c_int,
2924 ) -> FPDF_BOOL;
2925}
2926unsafe extern "C" {
2927 #[doc = " Import pages to a FPDF_DOCUMENT.\n\n dest_doc - The destination document for the pages.\n src_doc - The document to be imported.\n pagerange - A page range string, Such as \"1,3,5-7\". The first page is one.\n If |pagerange| is NULL, all pages from |src_doc| are imported.\n index - The page index at which to insert the first imported page into\n |dest_doc|. The first page is zero.\n\n Returns TRUE on success. Returns FALSE if any pages in |pagerange| is\n invalid or if |pagerange| cannot be read."]
2928 pub fn FPDF_ImportPages(
2929 dest_doc: FPDF_DOCUMENT,
2930 src_doc: FPDF_DOCUMENT,
2931 pagerange: FPDF_BYTESTRING,
2932 index: ::std::os::raw::c_int,
2933 ) -> FPDF_BOOL;
2934}
2935unsafe extern "C" {
2936 #[doc = " Experimental API.\n Create a new document from |src_doc|. The pages of |src_doc| will be\n combined to provide |num_pages_on_x_axis x num_pages_on_y_axis| pages per\n |output_doc| page.\n\n src_doc - The document to be imported.\n output_width - The output page width in PDF \"user space\" units.\n output_height - The output page height in PDF \"user space\" units.\n num_pages_on_x_axis - The number of pages on X Axis.\n num_pages_on_y_axis - The number of pages on Y Axis.\n\n Return value:\n A handle to the created document, or NULL on failure.\n\n Comments:\n number of pages per page = num_pages_on_x_axis * num_pages_on_y_axis\n"]
2937 pub fn FPDF_ImportNPagesToOne(
2938 src_doc: FPDF_DOCUMENT,
2939 output_width: f32,
2940 output_height: f32,
2941 num_pages_on_x_axis: usize,
2942 num_pages_on_y_axis: usize,
2943 ) -> FPDF_DOCUMENT;
2944}
2945unsafe extern "C" {
2946 #[doc = " Experimental API.\n Create a template to generate form xobjects from |src_doc|'s page at\n |src_page_index|, for use in |dest_doc|.\n\n Returns a handle on success, or NULL on failure. Caller owns the newly\n created object."]
2947 pub fn FPDF_NewXObjectFromPage(
2948 dest_doc: FPDF_DOCUMENT,
2949 src_doc: FPDF_DOCUMENT,
2950 src_page_index: ::std::os::raw::c_int,
2951 ) -> FPDF_XOBJECT;
2952}
2953unsafe extern "C" {
2954 #[doc = " Experimental API.\n Close an FPDF_XOBJECT handle created by FPDF_NewXObjectFromPage().\n FPDF_PAGEOBJECTs created from the FPDF_XOBJECT handle are not affected."]
2955 pub fn FPDF_CloseXObject(xobject: FPDF_XOBJECT);
2956}
2957unsafe extern "C" {
2958 #[doc = " Experimental API.\n Create a new form object from an FPDF_XOBJECT object.\n\n Returns a new form object on success, or NULL on failure. Caller owns the\n newly created object."]
2959 pub fn FPDF_NewFormObjectFromXObject(xobject: FPDF_XOBJECT) -> FPDF_PAGEOBJECT;
2960}
2961unsafe extern "C" {
2962 #[doc = " Copy the viewer preferences from |src_doc| into |dest_doc|.\n\n dest_doc - Document to write the viewer preferences into.\n src_doc - Document to read the viewer preferences from.\n\n Returns TRUE on success."]
2963 pub fn FPDF_CopyViewerPreferences(dest_doc: FPDF_DOCUMENT, src_doc: FPDF_DOCUMENT)
2964 -> FPDF_BOOL;
2965}
2966unsafe extern "C" {
2967 #[doc = " Set \"MediaBox\" entry to the page dictionary.\n\n page - Handle to a page.\n left - The left of the rectangle.\n bottom - The bottom of the rectangle.\n right - The right of the rectangle.\n top - The top of the rectangle."]
2968 pub fn FPDFPage_SetMediaBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2969}
2970unsafe extern "C" {
2971 #[doc = " Set \"CropBox\" entry to the page dictionary.\n\n page - Handle to a page.\n left - The left of the rectangle.\n bottom - The bottom of the rectangle.\n right - The right of the rectangle.\n top - The top of the rectangle."]
2972 pub fn FPDFPage_SetCropBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2973}
2974unsafe extern "C" {
2975 #[doc = " Set \"BleedBox\" entry to the page dictionary.\n\n page - Handle to a page.\n left - The left of the rectangle.\n bottom - The bottom of the rectangle.\n right - The right of the rectangle.\n top - The top of the rectangle."]
2976 pub fn FPDFPage_SetBleedBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2977}
2978unsafe extern "C" {
2979 #[doc = " Set \"TrimBox\" entry to the page dictionary.\n\n page - Handle to a page.\n left - The left of the rectangle.\n bottom - The bottom of the rectangle.\n right - The right of the rectangle.\n top - The top of the rectangle."]
2980 pub fn FPDFPage_SetTrimBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2981}
2982unsafe extern "C" {
2983 #[doc = " Set \"ArtBox\" entry to the page dictionary.\n\n page - Handle to a page.\n left - The left of the rectangle.\n bottom - The bottom of the rectangle.\n right - The right of the rectangle.\n top - The top of the rectangle."]
2984 pub fn FPDFPage_SetArtBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2985}
2986unsafe extern "C" {
2987 #[doc = " Get \"MediaBox\" entry from the page dictionary.\n\n page - Handle to a page.\n left - Pointer to a float value receiving the left of the rectangle.\n bottom - Pointer to a float value receiving the bottom of the rectangle.\n right - Pointer to a float value receiving the right of the rectangle.\n top - Pointer to a float value receiving the top of the rectangle.\n\n On success, return true and write to the out parameters. Otherwise return\n false and leave the out parameters unmodified."]
2988 pub fn FPDFPage_GetMediaBox(
2989 page: FPDF_PAGE,
2990 left: *mut f32,
2991 bottom: *mut f32,
2992 right: *mut f32,
2993 top: *mut f32,
2994 ) -> FPDF_BOOL;
2995}
2996unsafe extern "C" {
2997 #[doc = " Get \"CropBox\" entry from the page dictionary.\n\n page - Handle to a page.\n left - Pointer to a float value receiving the left of the rectangle.\n bottom - Pointer to a float value receiving the bottom of the rectangle.\n right - Pointer to a float value receiving the right of the rectangle.\n top - Pointer to a float value receiving the top of the rectangle.\n\n On success, return true and write to the out parameters. Otherwise return\n false and leave the out parameters unmodified."]
2998 pub fn FPDFPage_GetCropBox(
2999 page: FPDF_PAGE,
3000 left: *mut f32,
3001 bottom: *mut f32,
3002 right: *mut f32,
3003 top: *mut f32,
3004 ) -> FPDF_BOOL;
3005}
3006unsafe extern "C" {
3007 #[doc = " Get \"BleedBox\" entry from the page dictionary.\n\n page - Handle to a page.\n left - Pointer to a float value receiving the left of the rectangle.\n bottom - Pointer to a float value receiving the bottom of the rectangle.\n right - Pointer to a float value receiving the right of the rectangle.\n top - Pointer to a float value receiving the top of the rectangle.\n\n On success, return true and write to the out parameters. Otherwise return\n false and leave the out parameters unmodified."]
3008 pub fn FPDFPage_GetBleedBox(
3009 page: FPDF_PAGE,
3010 left: *mut f32,
3011 bottom: *mut f32,
3012 right: *mut f32,
3013 top: *mut f32,
3014 ) -> FPDF_BOOL;
3015}
3016unsafe extern "C" {
3017 #[doc = " Get \"TrimBox\" entry from the page dictionary.\n\n page - Handle to a page.\n left - Pointer to a float value receiving the left of the rectangle.\n bottom - Pointer to a float value receiving the bottom of the rectangle.\n right - Pointer to a float value receiving the right of the rectangle.\n top - Pointer to a float value receiving the top of the rectangle.\n\n On success, return true and write to the out parameters. Otherwise return\n false and leave the out parameters unmodified."]
3018 pub fn FPDFPage_GetTrimBox(
3019 page: FPDF_PAGE,
3020 left: *mut f32,
3021 bottom: *mut f32,
3022 right: *mut f32,
3023 top: *mut f32,
3024 ) -> FPDF_BOOL;
3025}
3026unsafe extern "C" {
3027 #[doc = " Get \"ArtBox\" entry from the page dictionary.\n\n page - Handle to a page.\n left - Pointer to a float value receiving the left of the rectangle.\n bottom - Pointer to a float value receiving the bottom of the rectangle.\n right - Pointer to a float value receiving the right of the rectangle.\n top - Pointer to a float value receiving the top of the rectangle.\n\n On success, return true and write to the out parameters. Otherwise return\n false and leave the out parameters unmodified."]
3028 pub fn FPDFPage_GetArtBox(
3029 page: FPDF_PAGE,
3030 left: *mut f32,
3031 bottom: *mut f32,
3032 right: *mut f32,
3033 top: *mut f32,
3034 ) -> FPDF_BOOL;
3035}
3036unsafe extern "C" {
3037 #[doc = " Apply transforms to |page|.\n\n If |matrix| is provided it will be applied to transform the page.\n If |clipRect| is provided it will be used to clip the resulting page.\n If neither |matrix| or |clipRect| are provided this method returns |false|.\n Returns |true| if transforms are applied.\n\n This function will transform the whole page, and would take effect to all the\n objects in the page.\n\n page - Page handle.\n matrix - Transform matrix.\n clipRect - Clipping rectangle."]
3038 pub fn FPDFPage_TransFormWithClip(
3039 page: FPDF_PAGE,
3040 matrix: *const FS_MATRIX,
3041 clipRect: *const FS_RECTF,
3042 ) -> FPDF_BOOL;
3043}
3044unsafe extern "C" {
3045 #[doc = " Transform (scale, rotate, shear, move) the clip path of page object.\n page_object - Handle to a page object. Returned by\n FPDFPageObj_NewImageObj().\n\n a - The coefficient \"a\" of the matrix.\n b - The coefficient \"b\" of the matrix.\n c - The coefficient \"c\" of the matrix.\n d - The coefficient \"d\" of the matrix.\n e - The coefficient \"e\" of the matrix.\n f - The coefficient \"f\" of the matrix."]
3046 pub fn FPDFPageObj_TransformClipPath(
3047 page_object: FPDF_PAGEOBJECT,
3048 a: f64,
3049 b: f64,
3050 c: f64,
3051 d: f64,
3052 e: f64,
3053 f: f64,
3054 );
3055}
3056unsafe extern "C" {
3057 #[doc = " Experimental API.\n Get the clip path of the page object.\n\n page object - Handle to a page object. Returned by e.g.\n FPDFPage_GetObject().\n\n Returns the handle to the clip path, or NULL on failure. The caller does not\n take ownership of the returned FPDF_CLIPPATH. Instead, it remains valid until\n FPDF_ClosePage() is called for the page containing |page_object|."]
3058 pub fn FPDFPageObj_GetClipPath(page_object: FPDF_PAGEOBJECT) -> FPDF_CLIPPATH;
3059}
3060unsafe extern "C" {
3061 #[doc = " Experimental API.\n Get number of paths inside |clip_path|.\n\n clip_path - handle to a clip_path.\n\n Returns the number of objects in |clip_path| or -1 on failure."]
3062 pub fn FPDFClipPath_CountPaths(clip_path: FPDF_CLIPPATH) -> ::std::os::raw::c_int;
3063}
3064unsafe extern "C" {
3065 #[doc = " Experimental API.\n Get number of segments inside one path of |clip_path|.\n\n clip_path - handle to a clip_path.\n path_index - index into the array of paths of the clip path.\n\n Returns the number of segments or -1 on failure."]
3066 pub fn FPDFClipPath_CountPathSegments(
3067 clip_path: FPDF_CLIPPATH,
3068 path_index: ::std::os::raw::c_int,
3069 ) -> ::std::os::raw::c_int;
3070}
3071unsafe extern "C" {
3072 #[doc = " Experimental API.\n Get segment in one specific path of |clip_path| at index.\n\n clip_path - handle to a clip_path.\n path_index - the index of a path.\n segment_index - the index of a segment.\n\n Returns the handle to the segment, or NULL on failure. The caller does not\n take ownership of the returned FPDF_PATHSEGMENT. Instead, it remains valid\n until FPDF_ClosePage() is called for the page containing |clip_path|."]
3073 pub fn FPDFClipPath_GetPathSegment(
3074 clip_path: FPDF_CLIPPATH,
3075 path_index: ::std::os::raw::c_int,
3076 segment_index: ::std::os::raw::c_int,
3077 ) -> FPDF_PATHSEGMENT;
3078}
3079unsafe extern "C" {
3080 #[doc = " Create a new clip path, with a rectangle inserted.\n\n Caller takes ownership of the returned FPDF_CLIPPATH. It should be freed with\n FPDF_DestroyClipPath().\n\n left - The left of the clip box.\n bottom - The bottom of the clip box.\n right - The right of the clip box.\n top - The top of the clip box."]
3081 pub fn FPDF_CreateClipPath(left: f32, bottom: f32, right: f32, top: f32) -> FPDF_CLIPPATH;
3082}
3083unsafe extern "C" {
3084 #[doc = " Destroy the clip path.\n\n clipPath - A handle to the clip path. It will be invalid after this call."]
3085 pub fn FPDF_DestroyClipPath(clipPath: FPDF_CLIPPATH);
3086}
3087unsafe extern "C" {
3088 #[doc = " Clip the page content, the page content that outside the clipping region\n become invisible.\n\n A clip path will be inserted before the page content stream or content array.\n In this way, the page content will be clipped by this clip path.\n\n page - A page handle.\n clipPath - A handle to the clip path. (Does not take ownership.)"]
3089 pub fn FPDFPage_InsertClipPath(page: FPDF_PAGE, clipPath: FPDF_CLIPPATH);
3090}
3091#[doc = " Returned by `clock'."]
3092pub type clock_t = __clock_t;
3093pub type time_t = __time_t;
3094#[doc = " ISO C `broken-down time' structure."]
3095#[repr(C)]
3096#[derive(Debug, Copy, Clone)]
3097pub struct tm {
3098 #[doc = " Seconds.\t[0-60] (1 leap second)"]
3099 pub tm_sec: ::std::os::raw::c_int,
3100 #[doc = " Minutes.\t[0-59]"]
3101 pub tm_min: ::std::os::raw::c_int,
3102 #[doc = " Hours.\t[0-23]"]
3103 pub tm_hour: ::std::os::raw::c_int,
3104 #[doc = " Day.\t\t[1-31]"]
3105 pub tm_mday: ::std::os::raw::c_int,
3106 #[doc = " Month.\t[0-11]"]
3107 pub tm_mon: ::std::os::raw::c_int,
3108 #[doc = " Year\t- 1900."]
3109 pub tm_year: ::std::os::raw::c_int,
3110 #[doc = " Day of week.\t[0-6]"]
3111 pub tm_wday: ::std::os::raw::c_int,
3112 #[doc = " Days in year.[0-365]"]
3113 pub tm_yday: ::std::os::raw::c_int,
3114 #[doc = " DST.\t\t[-1/0/1]"]
3115 pub tm_isdst: ::std::os::raw::c_int,
3116 #[doc = " Seconds east of UTC."]
3117 pub tm_gmtoff: ::std::os::raw::c_long,
3118 #[doc = " Timezone abbreviation."]
3119 pub tm_zone: *const ::std::os::raw::c_char,
3120}
3121#[doc = " POSIX.1b structure for a time value. This is like a `struct timeval' but\nhas nanoseconds instead of microseconds."]
3122#[repr(C)]
3123#[derive(Debug, Copy, Clone)]
3124pub struct timespec {
3125 #[doc = " Seconds."]
3126 pub tv_sec: __time_t,
3127 #[doc = " Nanoseconds."]
3128 pub tv_nsec: __syscall_slong_t,
3129}
3130#[doc = " Clock ID used in clock and timer functions."]
3131pub type clockid_t = __clockid_t;
3132#[doc = " Timer ID returned by `timer_create'."]
3133pub type timer_t = __timer_t;
3134#[doc = " POSIX.1b structure for timer start values and intervals."]
3135#[repr(C)]
3136#[derive(Debug, Copy, Clone)]
3137pub struct itimerspec {
3138 pub it_interval: timespec,
3139 pub it_value: timespec,
3140}
3141#[repr(C)]
3142#[derive(Debug, Copy, Clone)]
3143pub struct sigevent {
3144 _unused: [u8; 0],
3145}
3146pub type pid_t = __pid_t;
3147#[doc = " POSIX.1-2008: the locale_t type, representing a locale context\n(implementation-namespace version). This type should be treated\nas opaque by applications; some details are exposed for the sake of\nefficiency in e.g. ctype functions."]
3148#[repr(C)]
3149#[derive(Debug, Copy, Clone)]
3150pub struct __locale_struct {
3151 #[doc = " 13 = __LC_LAST."]
3152 pub __locales: [*mut __locale_data; 13usize],
3153 #[doc = " To increase the speed of this solution we add some special members."]
3154 pub __ctype_b: *const ::std::os::raw::c_ushort,
3155 pub __ctype_tolower: *const ::std::os::raw::c_int,
3156 pub __ctype_toupper: *const ::std::os::raw::c_int,
3157 #[doc = " Note: LC_ALL is not a valid index into this array."]
3158 pub __names: [*const ::std::os::raw::c_char; 13usize],
3159}
3160pub type __locale_t = *mut __locale_struct;
3161pub type locale_t = __locale_t;
3162unsafe extern "C" {
3163 #[doc = " Time used by the program so far (user time + system time).\nThe result / CLOCKS_PER_SEC is program time in seconds."]
3164 pub fn clock() -> clock_t;
3165}
3166unsafe extern "C" {
3167 #[doc = " Return the current time and put it in *TIMER if TIMER is not NULL."]
3168 pub fn time(__timer: *mut time_t) -> time_t;
3169}
3170unsafe extern "C" {
3171 #[doc = " Return the difference between TIME1 and TIME0."]
3172 pub fn difftime(__time1: time_t, __time0: time_t) -> f64;
3173}
3174unsafe extern "C" {
3175 #[doc = " Return the `time_t' representation of TP and normalize TP."]
3176 pub fn mktime(__tp: *mut tm) -> time_t;
3177}
3178unsafe extern "C" {
3179 #[doc = " Format TP into S according to FORMAT.\nWrite no more than MAXSIZE characters and return the number\nof characters written, or 0 if it would exceed MAXSIZE."]
3180 pub fn strftime(
3181 __s: *mut ::std::os::raw::c_char,
3182 __maxsize: usize,
3183 __format: *const ::std::os::raw::c_char,
3184 __tp: *const tm,
3185 ) -> usize;
3186}
3187unsafe extern "C" {
3188 #[doc = " Similar to the two functions above but take the information from\nthe provided locale and not the global locale."]
3189 pub fn strftime_l(
3190 __s: *mut ::std::os::raw::c_char,
3191 __maxsize: usize,
3192 __format: *const ::std::os::raw::c_char,
3193 __tp: *const tm,
3194 __loc: locale_t,
3195 ) -> usize;
3196}
3197unsafe extern "C" {
3198 #[doc = " Return the `struct tm' representation of *TIMER\nin Universal Coordinated Time (aka Greenwich Mean Time)."]
3199 pub fn gmtime(__timer: *const time_t) -> *mut tm;
3200}
3201unsafe extern "C" {
3202 #[doc = " Return the `struct tm' representation\nof *TIMER in the local timezone."]
3203 pub fn localtime(__timer: *const time_t) -> *mut tm;
3204}
3205unsafe extern "C" {
3206 #[doc = " Return the `struct tm' representation of *TIMER in UTC,\nusing *TP to store the result."]
3207 pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
3208}
3209unsafe extern "C" {
3210 #[doc = " Return the `struct tm' representation of *TIMER in local time,\nusing *TP to store the result."]
3211 pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
3212}
3213unsafe extern "C" {
3214 #[doc = " Return a string of the form \"Day Mon dd hh:mm:ss yyyy\\n\"\nthat is the representation of TP in this format."]
3215 pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char;
3216}
3217unsafe extern "C" {
3218 pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char;
3219}
3220unsafe extern "C" {
3221 #[doc = " Return in BUF a string of the form \"Day Mon dd hh:mm:ss yyyy\\n\"\nthat is the representation of TP in this format."]
3222 pub fn asctime_r(
3223 __tp: *const tm,
3224 __buf: *mut ::std::os::raw::c_char,
3225 ) -> *mut ::std::os::raw::c_char;
3226}
3227unsafe extern "C" {
3228 pub fn ctime_r(
3229 __timer: *const time_t,
3230 __buf: *mut ::std::os::raw::c_char,
3231 ) -> *mut ::std::os::raw::c_char;
3232}
3233unsafe extern "C" {
3234 #[doc = " Current time zone abbreviations."]
3235 pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize];
3236}
3237unsafe extern "C" {
3238 #[doc = " If daylight-saving time is ever in use."]
3239 pub static mut __daylight: ::std::os::raw::c_int;
3240}
3241unsafe extern "C" {
3242 #[doc = " Seconds west of UTC."]
3243 pub static mut __timezone: ::std::os::raw::c_long;
3244}
3245unsafe extern "C" {
3246 #[doc = " Same as above."]
3247 pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize];
3248}
3249unsafe extern "C" {
3250 #[doc = " Set time conversion information from the TZ environment variable.\nIf TZ is not defined, a locale-dependent default is used."]
3251 pub fn tzset();
3252}
3253unsafe extern "C" {
3254 pub static mut daylight: ::std::os::raw::c_int;
3255}
3256unsafe extern "C" {
3257 pub static mut timezone: ::std::os::raw::c_long;
3258}
3259unsafe extern "C" {
3260 #[doc = " Like `mktime', but for TP represents Universal Time, not local time."]
3261 pub fn timegm(__tp: *mut tm) -> time_t;
3262}
3263unsafe extern "C" {
3264 #[doc = " Another name for `mktime'."]
3265 pub fn timelocal(__tp: *mut tm) -> time_t;
3266}
3267unsafe extern "C" {
3268 #[doc = " Return the number of days in YEAR."]
3269 pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3270}
3271unsafe extern "C" {
3272 #[doc = " Pause execution for a number of nanoseconds.\n\nThis function is a cancellation point and therefore not marked with\n__THROW."]
3273 pub fn nanosleep(
3274 __requested_time: *const timespec,
3275 __remaining: *mut timespec,
3276 ) -> ::std::os::raw::c_int;
3277}
3278unsafe extern "C" {
3279 #[doc = " Get resolution of clock CLOCK_ID."]
3280 pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int;
3281}
3282unsafe extern "C" {
3283 #[doc = " Get current value of clock CLOCK_ID and store it in TP."]
3284 pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int;
3285}
3286unsafe extern "C" {
3287 #[doc = " Set clock CLOCK_ID to value TP."]
3288 pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int;
3289}
3290unsafe extern "C" {
3291 pub fn clock_nanosleep(
3292 __clock_id: clockid_t,
3293 __flags: ::std::os::raw::c_int,
3294 __req: *const timespec,
3295 __rem: *mut timespec,
3296 ) -> ::std::os::raw::c_int;
3297}
3298unsafe extern "C" {
3299 #[doc = " Return clock ID for CPU-time clock."]
3300 pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int;
3301}
3302unsafe extern "C" {
3303 #[doc = " Create new per-process timer using CLOCK_ID."]
3304 pub fn timer_create(
3305 __clock_id: clockid_t,
3306 __evp: *mut sigevent,
3307 __timerid: *mut timer_t,
3308 ) -> ::std::os::raw::c_int;
3309}
3310unsafe extern "C" {
3311 #[doc = " Delete timer TIMERID."]
3312 pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int;
3313}
3314unsafe extern "C" {
3315 pub fn timer_settime(
3316 __timerid: timer_t,
3317 __flags: ::std::os::raw::c_int,
3318 __value: *const itimerspec,
3319 __ovalue: *mut itimerspec,
3320 ) -> ::std::os::raw::c_int;
3321}
3322unsafe extern "C" {
3323 #[doc = " Get current value of timer TIMERID and store it in VALUE."]
3324 pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int;
3325}
3326unsafe extern "C" {
3327 #[doc = " Get expiration overrun for timer TIMERID."]
3328 pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int;
3329}
3330unsafe extern "C" {
3331 #[doc = " Set TS to calendar time based in time base BASE."]
3332 pub fn timespec_get(
3333 __ts: *mut timespec,
3334 __base: ::std::os::raw::c_int,
3335 ) -> ::std::os::raw::c_int;
3336}
3337#[doc = " Interface for unsupported feature notifications."]
3338#[repr(C)]
3339#[derive(Debug, Copy, Clone)]
3340pub struct _UNSUPPORT_INFO {
3341 #[doc = " Version number of the interface. Must be 1."]
3342 pub version: ::std::os::raw::c_int,
3343 #[doc = " Unsupported object notification function.\n Interface Version: 1\n Implementation Required: Yes\n\n pThis - pointer to the interface structure.\n nType - the type of unsupported object. One of the |FPDF_UNSP_*| entries."]
3344 pub FSDK_UnSupport_Handler: ::std::option::Option<
3345 unsafe extern "C" fn(pThis: *mut _UNSUPPORT_INFO, nType: ::std::os::raw::c_int),
3346 >,
3347}
3348#[doc = " Interface for unsupported feature notifications."]
3349pub type UNSUPPORT_INFO = _UNSUPPORT_INFO;
3350unsafe extern "C" {
3351 #[doc = " Setup an unsupported object handler.\n\n unsp_info - Pointer to an UNSUPPORT_INFO structure.\n\n Returns TRUE on success."]
3352 pub fn FSDK_SetUnSpObjProcessHandler(unsp_info: *mut UNSUPPORT_INFO) -> FPDF_BOOL;
3353}
3354unsafe extern "C" {
3355 #[doc = " Set replacement function for calls to time().\n\n This API is intended to be used only for testing, thus may cause PDFium to\n behave poorly in production environments.\n\n func - Function pointer to alternate implementation of time(), or\n NULL to restore to actual time() call itself."]
3356 pub fn FSDK_SetTimeFunction(func: ::std::option::Option<unsafe extern "C" fn() -> time_t>);
3357}
3358unsafe extern "C" {
3359 #[doc = " Set replacement function for calls to localtime().\n\n This API is intended to be used only for testing, thus may cause PDFium to\n behave poorly in production environments.\n\n func - Function pointer to alternate implementation of localtime(), or\n NULL to restore to actual localtime() call itself."]
3360 pub fn FSDK_SetLocaltimeFunction(
3361 func: ::std::option::Option<unsafe extern "C" fn(arg1: *const time_t) -> *mut tm>,
3362 );
3363}
3364unsafe extern "C" {
3365 #[doc = " Get the document's PageMode.\n\n doc - Handle to document.\n\n Returns one of the |PAGEMODE_*| flags defined above.\n\n The page mode defines how the document should be initially displayed."]
3366 pub fn FPDFDoc_GetPageMode(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
3367}
3368#[repr(C)]
3369#[derive(Debug, Copy, Clone)]
3370pub struct _IPDF_JsPlatform {
3371 #[doc = " Version number of the interface. Currently must be 2."]
3372 pub version: ::std::os::raw::c_int,
3373 #[doc = " Method: app_alert\n Pop up a dialog to show warning or hint.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n Msg - A string containing the message to be displayed.\n Title - The title of the dialog.\n Type - The type of button group, one of the\n JSPLATFORM_ALERT_BUTTON_* values above.\n nIcon - The type of the icon, one of the\n JSPLATFORM_ALERT_ICON_* above.\n Return Value:\n Option selected by user in dialogue, one of the\n JSPLATFORM_ALERT_RETURN_* values above."]
3374 pub app_alert: ::std::option::Option<
3375 unsafe extern "C" fn(
3376 pThis: *mut _IPDF_JsPlatform,
3377 Msg: FPDF_WIDESTRING,
3378 Title: FPDF_WIDESTRING,
3379 Type: ::std::os::raw::c_int,
3380 Icon: ::std::os::raw::c_int,
3381 ) -> ::std::os::raw::c_int,
3382 >,
3383 #[doc = " Method: app_beep\n Causes the system to play a sound.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n nType - The sound type, see JSPLATFORM_BEEP_TYPE_*\n above.\n Return Value:\n None"]
3384 pub app_beep: ::std::option::Option<
3385 unsafe extern "C" fn(pThis: *mut _IPDF_JsPlatform, nType: ::std::os::raw::c_int),
3386 >,
3387 #[doc = " Method: app_response\n Displays a dialog box containing a question and an entry field for\n the user to reply to the question.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n Question - The question to be posed to the user.\n Title - The title of the dialog box.\n Default - A default value for the answer to the question. If\n not specified, no default value is presented.\n cLabel - A short string to appear in front of and on the\n same line as the edit text field.\n bPassword - If true, indicates that the user's response should\n be shown as asterisks (*) or bullets (?) to mask\n the response, which might be sensitive information.\n response - A string buffer allocated by PDFium, to receive the\n user's response.\n length - The length of the buffer in bytes. Currently, it is\n always 2048.\n Return Value:\n Number of bytes the complete user input would actually require, not\n including trailing zeros, regardless of the value of the length\n parameter or the presence of the response buffer.\n Comments:\n No matter on what platform, the response buffer should be always\n written using UTF-16LE encoding. If a response buffer is\n present and the size of the user input exceeds the capacity of the\n buffer as specified by the length parameter, only the\n first \"length\" bytes of the user input are to be written to the\n buffer."]
3388 pub app_response: ::std::option::Option<
3389 unsafe extern "C" fn(
3390 pThis: *mut _IPDF_JsPlatform,
3391 Question: FPDF_WIDESTRING,
3392 Title: FPDF_WIDESTRING,
3393 Default: FPDF_WIDESTRING,
3394 cLabel: FPDF_WIDESTRING,
3395 bPassword: FPDF_BOOL,
3396 response: *mut ::std::os::raw::c_void,
3397 length: ::std::os::raw::c_int,
3398 ) -> ::std::os::raw::c_int,
3399 >,
3400 #[doc = " Method: Doc_getFilePath\n Get the file path of the current document.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n filePath - The string buffer to receive the file path. Can\n be NULL.\n length - The length of the buffer, number of bytes. Can\n be 0.\n Return Value:\n Number of bytes the filePath consumes, including trailing zeros.\n Comments:\n The filePath should always be provided in the local encoding.\n The return value always indicated number of bytes required for\n the buffer, even when there is no buffer specified, or the buffer\n size is less than required. In this case, the buffer will not\n be modified."]
3401 pub Doc_getFilePath: ::std::option::Option<
3402 unsafe extern "C" fn(
3403 pThis: *mut _IPDF_JsPlatform,
3404 filePath: *mut ::std::os::raw::c_void,
3405 length: ::std::os::raw::c_int,
3406 ) -> ::std::os::raw::c_int,
3407 >,
3408 #[doc = " Method: Doc_mail\n Mails the data buffer as an attachment to all recipients, with or\n without user interaction.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n mailData - Pointer to the data buffer to be sent. Can be NULL.\n length - The size,in bytes, of the buffer pointed by\n mailData parameter. Can be 0.\n bUI - If true, the rest of the parameters are used in a\n compose-new-message window that is displayed to the\n user. If false, the cTo parameter is required and\n all others are optional.\n To - A semicolon-delimited list of recipients for the\n message.\n Subject - The subject of the message. The length limit is\n 64 KB.\n CC - A semicolon-delimited list of CC recipients for\n the message.\n BCC - A semicolon-delimited list of BCC recipients for\n the message.\n Msg - The content of the message. The length limit is\n 64 KB.\n Return Value:\n None.\n Comments:\n If the parameter mailData is NULL or length is 0, the current\n document will be mailed as an attachment to all recipients."]
3409 pub Doc_mail: ::std::option::Option<
3410 unsafe extern "C" fn(
3411 pThis: *mut _IPDF_JsPlatform,
3412 mailData: *mut ::std::os::raw::c_void,
3413 length: ::std::os::raw::c_int,
3414 bUI: FPDF_BOOL,
3415 To: FPDF_WIDESTRING,
3416 Subject: FPDF_WIDESTRING,
3417 CC: FPDF_WIDESTRING,
3418 BCC: FPDF_WIDESTRING,
3419 Msg: FPDF_WIDESTRING,
3420 ),
3421 >,
3422 #[doc = " Method: Doc_print\n Prints all or a specific number of pages of the document.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n bUI - If true, will cause a UI to be presented to the\n user to obtain printing information and confirm\n the action.\n nStart - A 0-based index that defines the start of an\n inclusive range of pages.\n nEnd - A 0-based index that defines the end of an\n inclusive page range.\n bSilent - If true, suppresses the cancel dialog box while\n the document is printing. The default is false.\n bShrinkToFit - If true, the page is shrunk (if necessary) to\n fit within the imageable area of the printed page.\n bPrintAsImage - If true, print pages as an image.\n bReverse - If true, print from nEnd to nStart.\n bAnnotations - If true (the default), annotations are\n printed.\n Return Value:\n None."]
3423 pub Doc_print: ::std::option::Option<
3424 unsafe extern "C" fn(
3425 pThis: *mut _IPDF_JsPlatform,
3426 bUI: FPDF_BOOL,
3427 nStart: ::std::os::raw::c_int,
3428 nEnd: ::std::os::raw::c_int,
3429 bSilent: FPDF_BOOL,
3430 bShrinkToFit: FPDF_BOOL,
3431 bPrintAsImage: FPDF_BOOL,
3432 bReverse: FPDF_BOOL,
3433 bAnnotations: FPDF_BOOL,
3434 ),
3435 >,
3436 #[doc = " Method: Doc_submitForm\n Send the form data to a specified URL.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n formData - Pointer to the data buffer to be sent.\n length - The size,in bytes, of the buffer pointed by\n formData parameter.\n URL - The URL to send to.\n Return Value:\n None."]
3437 pub Doc_submitForm: ::std::option::Option<
3438 unsafe extern "C" fn(
3439 pThis: *mut _IPDF_JsPlatform,
3440 formData: *mut ::std::os::raw::c_void,
3441 length: ::std::os::raw::c_int,
3442 URL: FPDF_WIDESTRING,
3443 ),
3444 >,
3445 #[doc = " Method: Doc_gotoPage\n Jump to a specified page.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself\n nPageNum - The specified page number, zero for the first page.\n Return Value:\n None."]
3446 pub Doc_gotoPage: ::std::option::Option<
3447 unsafe extern "C" fn(pThis: *mut _IPDF_JsPlatform, nPageNum: ::std::os::raw::c_int),
3448 >,
3449 #[doc = " Method: Field_browse\n Show a file selection dialog, and return the selected file path.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n filePath - Pointer to the data buffer to receive the file\n path. Can be NULL.\n length - The length of the buffer, in bytes. Can be 0.\n Return Value:\n Number of bytes the filePath consumes, including trailing zeros.\n Comments:\n The filePath should always be provided in local encoding."]
3450 pub Field_browse: ::std::option::Option<
3451 unsafe extern "C" fn(
3452 pThis: *mut _IPDF_JsPlatform,
3453 filePath: *mut ::std::os::raw::c_void,
3454 length: ::std::os::raw::c_int,
3455 ) -> ::std::os::raw::c_int,
3456 >,
3457 #[doc = " Pointer for embedder-specific data. Unused by PDFium, and despite\n its name, can be any data the embedder desires, though traditionally\n a FPDF_FORMFILLINFO interface."]
3458 pub m_pFormfillinfo: *mut ::std::os::raw::c_void,
3459 #[doc = " Unused in v3, retain for compatibility."]
3460 pub m_isolate: *mut ::std::os::raw::c_void,
3461 #[doc = " Unused in v3, retain for compatibility."]
3462 pub m_v8EmbedderSlot: ::std::os::raw::c_uint,
3463}
3464pub type IPDF_JSPLATFORM = _IPDF_JsPlatform;
3465#[doc = " Function signature for the callback function passed to the FFI_SetTimer\n method.\n Parameters:\n idEvent - Identifier of the timer.\n Return value:\n None."]
3466pub type TimerCallback =
3467 ::std::option::Option<unsafe extern "C" fn(idEvent: ::std::os::raw::c_int)>;
3468#[doc = " Declares of a struct type to the local system time."]
3469#[repr(C)]
3470#[derive(Debug, Copy, Clone)]
3471pub struct _FPDF_SYSTEMTIME {
3472 #[doc = " years since 1900"]
3473 pub wYear: ::std::os::raw::c_ushort,
3474 #[doc = " months since January - [0,11]"]
3475 pub wMonth: ::std::os::raw::c_ushort,
3476 #[doc = " days since Sunday - [0,6]"]
3477 pub wDayOfWeek: ::std::os::raw::c_ushort,
3478 #[doc = " day of the month - [1,31]"]
3479 pub wDay: ::std::os::raw::c_ushort,
3480 #[doc = " hours since midnight - [0,23]"]
3481 pub wHour: ::std::os::raw::c_ushort,
3482 #[doc = " minutes after the hour - [0,59]"]
3483 pub wMinute: ::std::os::raw::c_ushort,
3484 #[doc = " seconds after the minute - [0,59]"]
3485 pub wSecond: ::std::os::raw::c_ushort,
3486 #[doc = " milliseconds after the second - [0,999]"]
3487 pub wMilliseconds: ::std::os::raw::c_ushort,
3488}
3489#[doc = " Declares of a struct type to the local system time."]
3490pub type FPDF_SYSTEMTIME = _FPDF_SYSTEMTIME;
3491#[repr(C)]
3492#[derive(Debug, Copy, Clone)]
3493pub struct _FPDF_FORMFILLINFO {
3494 #[doc = " Version number of the interface.\n Version 1 contains stable interfaces. Version 2 has additional\n experimental interfaces.\n When PDFium is built without the XFA module, version can be 1 or 2.\n With version 1, only stable interfaces are called. With version 2,\n additional experimental interfaces are also called.\n When PDFium is built with the XFA module, version must be 2.\n All the XFA related interfaces are experimental. If PDFium is built with\n the XFA module and version 1 then none of the XFA related interfaces\n would be called. When PDFium is built with XFA module then the version\n must be 2."]
3495 pub version: ::std::os::raw::c_int,
3496 #[doc = " Method: Release\n Give the implementation a chance to release any resources after the\n interface is no longer used.\n Interface Version:\n 1\n Implementation Required:\n No\n Comments:\n Called by PDFium during the final cleanup process.\n Parameters:\n pThis - Pointer to the interface structure itself\n Return Value:\n None"]
3497 pub Release: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO)>,
3498 #[doc = " Method: FFI_Invalidate\n Invalidate the client area within the specified rectangle.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n page - Handle to the page. Returned by FPDF_LoadPage().\n left - Left position of the client area in PDF page\n coordinates.\n top - Top position of the client area in PDF page\n coordinates.\n right - Right position of the client area in PDF page\n coordinates.\n bottom - Bottom position of the client area in PDF page\n coordinates.\n Return Value:\n None.\n Comments:\n All positions are measured in PDF \"user space\".\n Implementation should call FPDF_RenderPageBitmap() for repainting\n the specified page area."]
3499 pub FFI_Invalidate: ::std::option::Option<
3500 unsafe extern "C" fn(
3501 pThis: *mut _FPDF_FORMFILLINFO,
3502 page: FPDF_PAGE,
3503 left: f64,
3504 top: f64,
3505 right: f64,
3506 bottom: f64,
3507 ),
3508 >,
3509 #[doc = " Method: FFI_OutputSelectedRect\n When the user selects text in form fields with the mouse, this\n callback function will be invoked with the selected areas.\n Interface Version:\n 1\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself.\n page - Handle to the page. Returned by FPDF_LoadPage()/\n left - Left position of the client area in PDF page\n coordinates.\n top - Top position of the client area in PDF page\n coordinates.\n right - Right position of the client area in PDF page\n coordinates.\n bottom - Bottom position of the client area in PDF page\n coordinates.\n Return Value:\n None.\n Comments:\n This callback function is useful for implementing special text\n selection effects. An implementation should first record the\n returned rectangles, then draw them one by one during the next\n painting period. Lastly, it should remove all the recorded\n rectangles when finished painting."]
3510 pub FFI_OutputSelectedRect: ::std::option::Option<
3511 unsafe extern "C" fn(
3512 pThis: *mut _FPDF_FORMFILLINFO,
3513 page: FPDF_PAGE,
3514 left: f64,
3515 top: f64,
3516 right: f64,
3517 bottom: f64,
3518 ),
3519 >,
3520 #[doc = " Method: FFI_SetCursor\n Set the Cursor shape.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n nCursorType - Cursor type, see Flags for Cursor type for details.\n Return value:\n None."]
3521 pub FFI_SetCursor: ::std::option::Option<
3522 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, nCursorType: ::std::os::raw::c_int),
3523 >,
3524 #[doc = " Method: FFI_SetTimer\n This method installs a system timer. An interval value is specified,\n and every time that interval elapses, the system must call into the\n callback function with the timer ID as returned by this function.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n uElapse - Specifies the time-out value, in milliseconds.\n lpTimerFunc - A pointer to the callback function-TimerCallback.\n Return value:\n The timer identifier of the new timer if the function is successful.\n An application passes this value to the FFI_KillTimer method to kill\n the timer. Nonzero if it is successful; otherwise, it is zero."]
3525 pub FFI_SetTimer: ::std::option::Option<
3526 unsafe extern "C" fn(
3527 pThis: *mut _FPDF_FORMFILLINFO,
3528 uElapse: ::std::os::raw::c_int,
3529 lpTimerFunc: TimerCallback,
3530 ) -> ::std::os::raw::c_int,
3531 >,
3532 #[doc = " Method: FFI_KillTimer\n This method uninstalls a system timer, as set by an earlier call to\n FFI_SetTimer.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n nTimerID - The timer ID returned by FFI_SetTimer function.\n Return value:\n None."]
3533 pub FFI_KillTimer: ::std::option::Option<
3534 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, nTimerID: ::std::os::raw::c_int),
3535 >,
3536 #[doc = " Method: FFI_GetLocalTime\n This method receives the current local time on the system.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n Return value:\n The local time. See FPDF_SYSTEMTIME above for details.\n Note: Unused."]
3537 pub FFI_GetLocalTime: ::std::option::Option<
3538 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO) -> FPDF_SYSTEMTIME,
3539 >,
3540 #[doc = " Method: FFI_OnChange\n This method will be invoked to notify the implementation when the\n value of any FormField on the document had been changed.\n Interface Version:\n 1\n Implementation Required:\n no\n Parameters:\n pThis - Pointer to the interface structure itself.\n Return value:\n None."]
3541 pub FFI_OnChange: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO)>,
3542 #[doc = " Method: FFI_GetPage\n This method receives the page handle associated with a specified\n page index.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n document - Handle to document. Returned by FPDF_LoadDocument().\n nPageIndex - Index number of the page. 0 for the first page.\n Return value:\n Handle to the page, as previously returned to the implementation by\n FPDF_LoadPage().\n Comments:\n The implementation is expected to keep track of the page handles it\n receives from PDFium, and their mappings to page numbers. In some\n cases, the document-level JavaScript action may refer to a page\n which hadn't been loaded yet. To successfully run the Javascript\n action, the implementation needs to load the page."]
3543 pub FFI_GetPage: ::std::option::Option<
3544 unsafe extern "C" fn(
3545 pThis: *mut _FPDF_FORMFILLINFO,
3546 document: FPDF_DOCUMENT,
3547 nPageIndex: ::std::os::raw::c_int,
3548 ) -> FPDF_PAGE,
3549 >,
3550 #[doc = " Method: FFI_GetCurrentPage\n This method receives the handle to the current page.\n Interface Version:\n 1\n Implementation Required:\n Yes when V8 support is present, otherwise unused.\n Parameters:\n pThis - Pointer to the interface structure itself.\n document - Handle to document. Returned by FPDF_LoadDocument().\n Return value:\n Handle to the page. Returned by FPDF_LoadPage().\n Comments:\n PDFium doesn't keep keep track of the \"current page\" (e.g. the one\n that is most visible on screen), so it must ask the embedder for\n this information."]
3551 pub FFI_GetCurrentPage: ::std::option::Option<
3552 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, document: FPDF_DOCUMENT) -> FPDF_PAGE,
3553 >,
3554 #[doc = " Method: FFI_GetRotation\n This method receives currently rotation of the page view.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n page - Handle to page, as returned by FPDF_LoadPage().\n Return value:\n A number to indicate the page rotation in 90 degree increments\n in a clockwise direction:\n 0 - 0 degrees\n 1 - 90 degrees\n 2 - 180 degrees\n 3 - 270 degrees\n Note: Unused."]
3555 pub FFI_GetRotation: ::std::option::Option<
3556 unsafe extern "C" fn(
3557 pThis: *mut _FPDF_FORMFILLINFO,
3558 page: FPDF_PAGE,
3559 ) -> ::std::os::raw::c_int,
3560 >,
3561 #[doc = " Method: FFI_ExecuteNamedAction\n This method will execute a named action.\n Interface Version:\n 1\n Implementation Required:\n yes\n Parameters:\n pThis - Pointer to the interface structure itself.\n namedAction - A byte string which indicates the named action,\n terminated by 0.\n Return value:\n None.\n Comments:\n See ISO 32000-1:2008, section 12.6.4.11 for descriptions of the\n standard named actions, but note that a document may supply any\n name of its choosing."]
3562 pub FFI_ExecuteNamedAction: ::std::option::Option<
3563 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, namedAction: FPDF_BYTESTRING),
3564 >,
3565 #[doc = " Method: FFI_SetTextFieldFocus\n Called when a text field is getting or losing focus.\n Interface Version:\n 1\n Implementation Required:\n no\n Parameters:\n pThis - Pointer to the interface structure itself.\n value - The string value of the form field, in UTF-16LE\n format.\n valueLen - The length of the string value. This is the\n number of characters, not bytes.\n is_focus - True if the form field is getting focus, false\n if the form field is losing focus.\n Return value:\n None.\n Comments:\n Only supports text fields and combobox fields."]
3566 pub FFI_SetTextFieldFocus: ::std::option::Option<
3567 unsafe extern "C" fn(
3568 pThis: *mut _FPDF_FORMFILLINFO,
3569 value: FPDF_WIDESTRING,
3570 valueLen: FPDF_DWORD,
3571 is_focus: FPDF_BOOL,
3572 ),
3573 >,
3574 #[doc = " Method: FFI_DoURIAction\n Ask the implementation to navigate to a uniform resource identifier.\n Interface Version:\n 1\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself.\n bsURI - A byte string which indicates the uniform\n resource identifier, terminated by 0.\n Return value:\n None.\n Comments:\n If the embedder is version 2 or higher and have implementation for\n FFI_DoURIActionWithKeyboardModifier, then\n FFI_DoURIActionWithKeyboardModifier takes precedence over\n FFI_DoURIAction.\n See the URI actions description of <<PDF Reference, version 1.7>>\n for more details."]
3575 pub FFI_DoURIAction: ::std::option::Option<
3576 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, bsURI: FPDF_BYTESTRING),
3577 >,
3578 #[doc = " Method: FFI_DoGoToAction\n This action changes the view to a specified destination.\n Interface Version:\n 1\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself.\n nPageIndex - The index of the PDF page.\n zoomMode - The zoom mode for viewing page. See below.\n fPosArray - The float array which carries the position info.\n sizeofArray - The size of float array.\n PDFZoom values:\n - XYZ = 1\n - FITPAGE = 2\n - FITHORZ = 3\n - FITVERT = 4\n - FITRECT = 5\n - FITBBOX = 6\n - FITBHORZ = 7\n - FITBVERT = 8\n Return value:\n None.\n Comments:\n See the Destinations description of <<PDF Reference, version 1.7>>\n in 8.2.1 for more details."]
3579 pub FFI_DoGoToAction: ::std::option::Option<
3580 unsafe extern "C" fn(
3581 pThis: *mut _FPDF_FORMFILLINFO,
3582 nPageIndex: ::std::os::raw::c_int,
3583 zoomMode: ::std::os::raw::c_int,
3584 fPosArray: *mut f32,
3585 sizeofArray: ::std::os::raw::c_int,
3586 ),
3587 >,
3588 #[doc = " Pointer to IPDF_JSPLATFORM interface.\n Unused if PDFium is built without V8 support. Otherwise, if NULL, then\n JavaScript will be prevented from executing while rendering the document."]
3589 pub m_pJsPlatform: *mut IPDF_JSPLATFORM,
3590 #[doc = " Whether the XFA module is disabled when built with the XFA module.\n Interface Version:\n Ignored if |version| < 2."]
3591 pub xfa_disabled: FPDF_BOOL,
3592 #[doc = " Method: FFI_DisplayCaret\n This method will show the caret at specified position.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n page - Handle to page. Returned by FPDF_LoadPage().\n left - Left position of the client area in PDF page\n coordinates.\n top - Top position of the client area in PDF page\n coordinates.\n right - Right position of the client area in PDF page\n coordinates.\n bottom - Bottom position of the client area in PDF page\n coordinates.\n Return value:\n None."]
3593 pub FFI_DisplayCaret: ::std::option::Option<
3594 unsafe extern "C" fn(
3595 pThis: *mut _FPDF_FORMFILLINFO,
3596 page: FPDF_PAGE,
3597 bVisible: FPDF_BOOL,
3598 left: f64,
3599 top: f64,
3600 right: f64,
3601 bottom: f64,
3602 ),
3603 >,
3604 #[doc = " Method: FFI_GetCurrentPageIndex\n This method will get the current page index.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n document - Handle to document from FPDF_LoadDocument().\n Return value:\n The index of current page."]
3605 pub FFI_GetCurrentPageIndex: ::std::option::Option<
3606 unsafe extern "C" fn(
3607 pThis: *mut _FPDF_FORMFILLINFO,
3608 document: FPDF_DOCUMENT,
3609 ) -> ::std::os::raw::c_int,
3610 >,
3611 #[doc = " Method: FFI_SetCurrentPage\n This method will set the current page.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n document - Handle to document from FPDF_LoadDocument().\n iCurPage - The index of the PDF page.\n Return value:\n None."]
3612 pub FFI_SetCurrentPage: ::std::option::Option<
3613 unsafe extern "C" fn(
3614 pThis: *mut _FPDF_FORMFILLINFO,
3615 document: FPDF_DOCUMENT,
3616 iCurPage: ::std::os::raw::c_int,
3617 ),
3618 >,
3619 #[doc = " Method: FFI_GotoURL\n This method will navigate to the specified URL.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n document - Handle to document from FPDF_LoadDocument().\n wsURL - The string value of the URL, in UTF-16LE format.\n Return value:\n None."]
3620 pub FFI_GotoURL: ::std::option::Option<
3621 unsafe extern "C" fn(
3622 pThis: *mut _FPDF_FORMFILLINFO,
3623 document: FPDF_DOCUMENT,
3624 wsURL: FPDF_WIDESTRING,
3625 ),
3626 >,
3627 #[doc = " Method: FFI_GetPageViewRect\n This method will get the current page view rectangle.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n page - Handle to page. Returned by FPDF_LoadPage().\n left - The pointer to receive left position of the page\n view area in PDF page coordinates.\n top - The pointer to receive top position of the page\n view area in PDF page coordinates.\n right - The pointer to receive right position of the\n page view area in PDF page coordinates.\n bottom - The pointer to receive bottom position of the\n page view area in PDF page coordinates.\n Return value:\n None."]
3628 pub FFI_GetPageViewRect: ::std::option::Option<
3629 unsafe extern "C" fn(
3630 pThis: *mut _FPDF_FORMFILLINFO,
3631 page: FPDF_PAGE,
3632 left: *mut f64,
3633 top: *mut f64,
3634 right: *mut f64,
3635 bottom: *mut f64,
3636 ),
3637 >,
3638 #[doc = " Method: FFI_PageEvent\n This method fires when pages have been added to or deleted from\n the XFA document.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n page_count - The number of pages to be added or deleted.\n event_type - See FXFA_PAGEVIEWEVENT_* above.\n Return value:\n None.\n Comments:\n The pages to be added or deleted always start from the last page\n of document. This means that if parameter page_count is 2 and\n event type is FXFA_PAGEVIEWEVENT_POSTADDED, 2 new pages have been\n appended to the tail of document; If page_count is 2 and\n event type is FXFA_PAGEVIEWEVENT_POSTREMOVED, the last 2 pages\n have been deleted."]
3639 pub FFI_PageEvent: ::std::option::Option<
3640 unsafe extern "C" fn(
3641 pThis: *mut _FPDF_FORMFILLINFO,
3642 page_count: ::std::os::raw::c_int,
3643 event_type: FPDF_DWORD,
3644 ),
3645 >,
3646 #[doc = " Method: FFI_PopupMenu\n This method will track the right context menu for XFA fields.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n page - Handle to page. Returned by FPDF_LoadPage().\n hWidget - Always null, exists for compatibility.\n menuFlag - The menu flags. Please refer to macro definition\n of FXFA_MENU_XXX and this can be one or a\n combination of these macros.\n x - X position of the client area in PDF page\n coordinates.\n y - Y position of the client area in PDF page\n coordinates.\n Return value:\n TRUE indicates success; otherwise false."]
3647 pub FFI_PopupMenu: ::std::option::Option<
3648 unsafe extern "C" fn(
3649 pThis: *mut _FPDF_FORMFILLINFO,
3650 page: FPDF_PAGE,
3651 hWidget: FPDF_WIDGET,
3652 menuFlag: ::std::os::raw::c_int,
3653 x: f32,
3654 y: f32,
3655 ) -> FPDF_BOOL,
3656 >,
3657 #[doc = " Method: FFI_OpenFile\n This method will open the specified file with the specified mode.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n fileFlag - The file flag. Please refer to macro definition\n of FXFA_SAVEAS_XXX and use one of these macros.\n wsURL - The string value of the file URL, in UTF-16LE\n format.\n mode - The mode for open file, e.g. \"rb\" or \"wb\".\n Return value:\n The handle to FPDF_FILEHANDLER."]
3658 pub FFI_OpenFile: ::std::option::Option<
3659 unsafe extern "C" fn(
3660 pThis: *mut _FPDF_FORMFILLINFO,
3661 fileFlag: ::std::os::raw::c_int,
3662 wsURL: FPDF_WIDESTRING,
3663 mode: *const ::std::os::raw::c_char,
3664 ) -> *mut FPDF_FILEHANDLER,
3665 >,
3666 #[doc = " Method: FFI_EmailTo\n This method will email the specified file stream to the specified\n contact.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n pFileHandler - Handle to the FPDF_FILEHANDLER.\n pTo - A semicolon-delimited list of recipients for the\n message,in UTF-16LE format.\n pSubject - The subject of the message,in UTF-16LE format.\n pCC - A semicolon-delimited list of CC recipients for\n the message,in UTF-16LE format.\n pBcc - A semicolon-delimited list of BCC recipients for\n the message,in UTF-16LE format.\n pMsg - Pointer to the data buffer to be sent.Can be\n NULL,in UTF-16LE format.\n Return value:\n None."]
3667 pub FFI_EmailTo: ::std::option::Option<
3668 unsafe extern "C" fn(
3669 pThis: *mut _FPDF_FORMFILLINFO,
3670 fileHandler: *mut FPDF_FILEHANDLER,
3671 pTo: FPDF_WIDESTRING,
3672 pSubject: FPDF_WIDESTRING,
3673 pCC: FPDF_WIDESTRING,
3674 pBcc: FPDF_WIDESTRING,
3675 pMsg: FPDF_WIDESTRING,
3676 ),
3677 >,
3678 #[doc = " Method: FFI_UploadTo\n This method will upload the specified file stream to the\n specified URL.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n pFileHandler - Handle to the FPDF_FILEHANDLER.\n fileFlag - The file flag. Please refer to macro definition\n of FXFA_SAVEAS_XXX and use one of these macros.\n uploadTo - Pointer to the URL path, in UTF-16LE format.\n Return value:\n None."]
3679 pub FFI_UploadTo: ::std::option::Option<
3680 unsafe extern "C" fn(
3681 pThis: *mut _FPDF_FORMFILLINFO,
3682 fileHandler: *mut FPDF_FILEHANDLER,
3683 fileFlag: ::std::os::raw::c_int,
3684 uploadTo: FPDF_WIDESTRING,
3685 ),
3686 >,
3687 #[doc = " Method: FFI_GetPlatform\n This method will get the current platform.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n platform - Pointer to the data buffer to receive the\n platform,in UTF-16LE format. Can be NULL.\n length - The length of the buffer in bytes. Can be\n 0 to query the required size.\n Return value:\n The length of the buffer, number of bytes."]
3688 pub FFI_GetPlatform: ::std::option::Option<
3689 unsafe extern "C" fn(
3690 pThis: *mut _FPDF_FORMFILLINFO,
3691 platform: *mut ::std::os::raw::c_void,
3692 length: ::std::os::raw::c_int,
3693 ) -> ::std::os::raw::c_int,
3694 >,
3695 #[doc = " Method: FFI_GetLanguage\n This method will get the current language.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n language - Pointer to the data buffer to receive the\n current language. Can be NULL.\n length - The length of the buffer in bytes. Can be\n 0 to query the required size.\n Return value:\n The length of the buffer, number of bytes."]
3696 pub FFI_GetLanguage: ::std::option::Option<
3697 unsafe extern "C" fn(
3698 pThis: *mut _FPDF_FORMFILLINFO,
3699 language: *mut ::std::os::raw::c_void,
3700 length: ::std::os::raw::c_int,
3701 ) -> ::std::os::raw::c_int,
3702 >,
3703 #[doc = " Method: FFI_DownloadFromURL\n This method will download the specified file from the URL.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n URL - The string value of the file URL, in UTF-16LE\n format.\n Return value:\n The handle to FPDF_FILEHANDLER."]
3704 pub FFI_DownloadFromURL: ::std::option::Option<
3705 unsafe extern "C" fn(
3706 pThis: *mut _FPDF_FORMFILLINFO,
3707 URL: FPDF_WIDESTRING,
3708 ) -> *mut FPDF_FILEHANDLER,
3709 >,
3710 #[doc = " Method: FFI_PostRequestURL\n This method will post the request to the server URL.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n wsURL - The string value of the server URL, in UTF-16LE\n format.\n wsData - The post data,in UTF-16LE format.\n wsContentType - The content type of the request data, in\n UTF-16LE format.\n wsEncode - The encode type, in UTF-16LE format.\n wsHeader - The request header,in UTF-16LE format.\n response - Pointer to the FPDF_BSTR to receive the response\n data from the server, in UTF-16LE format.\n Return value:\n TRUE indicates success, otherwise FALSE."]
3711 pub FFI_PostRequestURL: ::std::option::Option<
3712 unsafe extern "C" fn(
3713 pThis: *mut _FPDF_FORMFILLINFO,
3714 wsURL: FPDF_WIDESTRING,
3715 wsData: FPDF_WIDESTRING,
3716 wsContentType: FPDF_WIDESTRING,
3717 wsEncode: FPDF_WIDESTRING,
3718 wsHeader: FPDF_WIDESTRING,
3719 response: *mut FPDF_BSTR,
3720 ) -> FPDF_BOOL,
3721 >,
3722 #[doc = " Method: FFI_PutRequestURL\n This method will put the request to the server URL.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n Required for XFA, otherwise set to NULL.\n Parameters:\n pThis - Pointer to the interface structure itself.\n wsURL - The string value of the server URL, in UTF-16LE\n format.\n wsData - The put data, in UTF-16LE format.\n wsEncode - The encode type, in UTR-16LE format.\n Return value:\n TRUE indicates success, otherwise FALSE."]
3723 pub FFI_PutRequestURL: ::std::option::Option<
3724 unsafe extern "C" fn(
3725 pThis: *mut _FPDF_FORMFILLINFO,
3726 wsURL: FPDF_WIDESTRING,
3727 wsData: FPDF_WIDESTRING,
3728 wsEncode: FPDF_WIDESTRING,
3729 ) -> FPDF_BOOL,
3730 >,
3731 #[doc = " Method: FFI_OnFocusChange\n Called when the focused annotation is updated.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n No\n Parameters:\n param - Pointer to the interface structure itself.\n annot - The focused annotation.\n page_index - Index number of the page which contains the\n focused annotation. 0 for the first page.\n Return value:\n None.\n Comments:\n This callback function is useful for implementing any view based\n action such as scrolling the annotation rect into view. The\n embedder should not copy and store the annot as its scope is\n limited to this call only."]
3732 pub FFI_OnFocusChange: ::std::option::Option<
3733 unsafe extern "C" fn(
3734 param: *mut _FPDF_FORMFILLINFO,
3735 annot: FPDF_ANNOTATION,
3736 page_index: ::std::os::raw::c_int,
3737 ),
3738 >,
3739 #[doc = " Method: FFI_DoURIActionWithKeyboardModifier\n Ask the implementation to navigate to a uniform resource identifier\n with the specified modifiers.\n Interface Version:\n Ignored if |version| < 2.\n Implementation Required:\n No\n Parameters:\n param - Pointer to the interface structure itself.\n uri - A byte string which indicates the uniform\n resource identifier, terminated by 0.\n modifiers - Keyboard modifier that indicates which of\n the virtual keys are down, if any.\n Return value:\n None.\n Comments:\n If the embedder who is version 2 and does not implement this API,\n then a call will be redirected to FFI_DoURIAction.\n See the URI actions description of <<PDF Reference, version 1.7>>\n for more details."]
3740 pub FFI_DoURIActionWithKeyboardModifier: ::std::option::Option<
3741 unsafe extern "C" fn(
3742 param: *mut _FPDF_FORMFILLINFO,
3743 uri: FPDF_BYTESTRING,
3744 modifiers: ::std::os::raw::c_int,
3745 ),
3746 >,
3747}
3748pub type FPDF_FORMFILLINFO = _FPDF_FORMFILLINFO;
3749unsafe extern "C" {
3750 #[doc = " Function: FPDFDOC_InitFormFillEnvironment\n Initialize form fill environment.\n Parameters:\n document - Handle to document from FPDF_LoadDocument().\n formInfo - Pointer to a FPDF_FORMFILLINFO structure.\n Return Value:\n Handle to the form fill module, or NULL on failure.\n Comments:\n This function should be called before any form fill operation.\n The FPDF_FORMFILLINFO passed in via |formInfo| must remain valid until\n the returned FPDF_FORMHANDLE is closed."]
3751 pub fn FPDFDOC_InitFormFillEnvironment(
3752 document: FPDF_DOCUMENT,
3753 formInfo: *mut FPDF_FORMFILLINFO,
3754 ) -> FPDF_FORMHANDLE;
3755}
3756unsafe extern "C" {
3757 #[doc = " Function: FPDFDOC_ExitFormFillEnvironment\n Take ownership of |hHandle| and exit form fill environment.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n None.\n Comments:\n This function is a no-op when |hHandle| is null."]
3758 pub fn FPDFDOC_ExitFormFillEnvironment(hHandle: FPDF_FORMHANDLE);
3759}
3760unsafe extern "C" {
3761 #[doc = " Function: FORM_OnAfterLoadPage\n This method is required for implementing all the form related\n functions. Should be invoked after user successfully loaded a\n PDF page, and FPDFDOC_InitFormFillEnvironment() has been invoked.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n None."]
3762 pub fn FORM_OnAfterLoadPage(page: FPDF_PAGE, hHandle: FPDF_FORMHANDLE);
3763}
3764unsafe extern "C" {
3765 #[doc = " Function: FORM_OnBeforeClosePage\n This method is required for implementing all the form related\n functions. Should be invoked before user closes the PDF page.\n Parameters:\n page - Handle to the page, as returned by FPDF_LoadPage().\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n None."]
3766 pub fn FORM_OnBeforeClosePage(page: FPDF_PAGE, hHandle: FPDF_FORMHANDLE);
3767}
3768unsafe extern "C" {
3769 #[doc = " Function: FORM_DoDocumentJSAction\n This method is required for performing document-level JavaScript\n actions. It should be invoked after the PDF document has been loaded.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n None.\n Comments:\n If there is document-level JavaScript action embedded in the\n document, this method will execute the JavaScript action. Otherwise,\n the method will do nothing."]
3770 pub fn FORM_DoDocumentJSAction(hHandle: FPDF_FORMHANDLE);
3771}
3772unsafe extern "C" {
3773 #[doc = " Function: FORM_DoDocumentOpenAction\n This method is required for performing open-action when the document\n is opened.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n None.\n Comments:\n This method will do nothing if there are no open-actions embedded\n in the document."]
3774 pub fn FORM_DoDocumentOpenAction(hHandle: FPDF_FORMHANDLE);
3775}
3776unsafe extern "C" {
3777 #[doc = " Function: FORM_DoDocumentAAction\n This method is required for performing the document's\n additional-action.\n Parameters:\n hHandle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment.\n aaType - The type of the additional-actions which defined\n above.\n Return Value:\n None.\n Comments:\n This method will do nothing if there is no document\n additional-action corresponding to the specified |aaType|."]
3778 pub fn FORM_DoDocumentAAction(hHandle: FPDF_FORMHANDLE, aaType: ::std::os::raw::c_int);
3779}
3780unsafe extern "C" {
3781 #[doc = " Function: FORM_DoPageAAction\n This method is required for performing the page object's\n additional-action when opened or closed.\n Parameters:\n page - Handle to the page, as returned by FPDF_LoadPage().\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n aaType - The type of the page object's additional-actions\n which defined above.\n Return Value:\n None.\n Comments:\n This method will do nothing if no additional-action corresponding\n to the specified |aaType| exists."]
3782 pub fn FORM_DoPageAAction(
3783 page: FPDF_PAGE,
3784 hHandle: FPDF_FORMHANDLE,
3785 aaType: ::std::os::raw::c_int,
3786 );
3787}
3788unsafe extern "C" {
3789 #[doc = " Function: FORM_OnMouseMove\n Call this member function when the mouse cursor moves.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n modifier - Indicates whether various virtual keys are down.\n page_x - Specifies the x-coordinate of the cursor in PDF user\n space.\n page_y - Specifies the y-coordinate of the cursor in PDF user\n space.\n Return Value:\n True indicates success; otherwise false."]
3790 pub fn FORM_OnMouseMove(
3791 hHandle: FPDF_FORMHANDLE,
3792 page: FPDF_PAGE,
3793 modifier: ::std::os::raw::c_int,
3794 page_x: f64,
3795 page_y: f64,
3796 ) -> FPDF_BOOL;
3797}
3798unsafe extern "C" {
3799 #[doc = " Experimental API\n Function: FORM_OnMouseWheel\n Call this member function when the user scrolls the mouse wheel.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n modifier - Indicates whether various virtual keys are down.\n page_coord - Specifies the coordinates of the cursor in PDF user\n space.\n delta_x - Specifies the amount of wheel movement on the x-axis,\n in units of platform-agnostic wheel deltas. Negative\n values mean left.\n delta_y - Specifies the amount of wheel movement on the y-axis,\n in units of platform-agnostic wheel deltas. Negative\n values mean down.\n Return Value:\n True indicates success; otherwise false.\n Comments:\n For |delta_x| and |delta_y|, the caller must normalize\n platform-specific wheel deltas. e.g. On Windows, a delta value of 240\n for a WM_MOUSEWHEEL event normalizes to 2, since Windows defines\n WHEEL_DELTA as 120."]
3800 pub fn FORM_OnMouseWheel(
3801 hHandle: FPDF_FORMHANDLE,
3802 page: FPDF_PAGE,
3803 modifier: ::std::os::raw::c_int,
3804 page_coord: *const FS_POINTF,
3805 delta_x: ::std::os::raw::c_int,
3806 delta_y: ::std::os::raw::c_int,
3807 ) -> FPDF_BOOL;
3808}
3809unsafe extern "C" {
3810 #[doc = " Function: FORM_OnFocus\n This function focuses the form annotation at a given point. If the\n annotation at the point already has focus, nothing happens. If there\n is no annotation at the point, removes form focus.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n modifier - Indicates whether various virtual keys are down.\n page_x - Specifies the x-coordinate of the cursor in PDF user\n space.\n page_y - Specifies the y-coordinate of the cursor in PDF user\n space.\n Return Value:\n True if there is an annotation at the given point and it has focus."]
3811 pub fn FORM_OnFocus(
3812 hHandle: FPDF_FORMHANDLE,
3813 page: FPDF_PAGE,
3814 modifier: ::std::os::raw::c_int,
3815 page_x: f64,
3816 page_y: f64,
3817 ) -> FPDF_BOOL;
3818}
3819unsafe extern "C" {
3820 #[doc = " Function: FORM_OnLButtonDown\n Call this member function when the user presses the left\n mouse button.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n modifier - Indicates whether various virtual keys are down.\n page_x - Specifies the x-coordinate of the cursor in PDF user\n space.\n page_y - Specifies the y-coordinate of the cursor in PDF user\n space.\n Return Value:\n True indicates success; otherwise false."]
3821 pub fn FORM_OnLButtonDown(
3822 hHandle: FPDF_FORMHANDLE,
3823 page: FPDF_PAGE,
3824 modifier: ::std::os::raw::c_int,
3825 page_x: f64,
3826 page_y: f64,
3827 ) -> FPDF_BOOL;
3828}
3829unsafe extern "C" {
3830 #[doc = " Function: FORM_OnRButtonDown\n Same as above, execpt for the right mouse button.\n Comments:\n At the present time, has no effect except in XFA builds, but is\n included for the sake of symmetry."]
3831 pub fn FORM_OnRButtonDown(
3832 hHandle: FPDF_FORMHANDLE,
3833 page: FPDF_PAGE,
3834 modifier: ::std::os::raw::c_int,
3835 page_x: f64,
3836 page_y: f64,
3837 ) -> FPDF_BOOL;
3838}
3839unsafe extern "C" {
3840 #[doc = " Function: FORM_OnLButtonUp\n Call this member function when the user releases the left\n mouse button.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n modifier - Indicates whether various virtual keys are down.\n page_x - Specifies the x-coordinate of the cursor in device.\n page_y - Specifies the y-coordinate of the cursor in device.\n Return Value:\n True indicates success; otherwise false."]
3841 pub fn FORM_OnLButtonUp(
3842 hHandle: FPDF_FORMHANDLE,
3843 page: FPDF_PAGE,
3844 modifier: ::std::os::raw::c_int,
3845 page_x: f64,
3846 page_y: f64,
3847 ) -> FPDF_BOOL;
3848}
3849unsafe extern "C" {
3850 #[doc = " Function: FORM_OnRButtonUp\n Same as above, execpt for the right mouse button.\n Comments:\n At the present time, has no effect except in XFA builds, but is\n included for the sake of symmetry."]
3851 pub fn FORM_OnRButtonUp(
3852 hHandle: FPDF_FORMHANDLE,
3853 page: FPDF_PAGE,
3854 modifier: ::std::os::raw::c_int,
3855 page_x: f64,
3856 page_y: f64,
3857 ) -> FPDF_BOOL;
3858}
3859unsafe extern "C" {
3860 #[doc = " Function: FORM_OnLButtonDoubleClick\n Call this member function when the user double clicks the\n left mouse button.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n modifier - Indicates whether various virtual keys are down.\n page_x - Specifies the x-coordinate of the cursor in PDF user\n space.\n page_y - Specifies the y-coordinate of the cursor in PDF user\n space.\n Return Value:\n True indicates success; otherwise false."]
3861 pub fn FORM_OnLButtonDoubleClick(
3862 hHandle: FPDF_FORMHANDLE,
3863 page: FPDF_PAGE,
3864 modifier: ::std::os::raw::c_int,
3865 page_x: f64,
3866 page_y: f64,
3867 ) -> FPDF_BOOL;
3868}
3869unsafe extern "C" {
3870 #[doc = " Function: FORM_OnKeyDown\n Call this member function when a nonsystem key is pressed.\n Parameters:\n hHandle - Handle to the form fill module, aseturned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n nKeyCode - The virtual-key code of the given key (see\n fpdf_fwlevent.h for virtual key codes).\n modifier - Mask of key flags (see fpdf_fwlevent.h for key\n flag values).\n Return Value:\n True indicates success; otherwise false."]
3871 pub fn FORM_OnKeyDown(
3872 hHandle: FPDF_FORMHANDLE,
3873 page: FPDF_PAGE,
3874 nKeyCode: ::std::os::raw::c_int,
3875 modifier: ::std::os::raw::c_int,
3876 ) -> FPDF_BOOL;
3877}
3878unsafe extern "C" {
3879 #[doc = " Function: FORM_OnKeyUp\n Call this member function when a nonsystem key is released.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n nKeyCode - The virtual-key code of the given key (see\n fpdf_fwlevent.h for virtual key codes).\n modifier - Mask of key flags (see fpdf_fwlevent.h for key\n flag values).\n Return Value:\n True indicates success; otherwise false.\n Comments:\n Currently unimplemented and always returns false. PDFium reserves this\n API and may implement it in the future on an as-needed basis."]
3880 pub fn FORM_OnKeyUp(
3881 hHandle: FPDF_FORMHANDLE,
3882 page: FPDF_PAGE,
3883 nKeyCode: ::std::os::raw::c_int,
3884 modifier: ::std::os::raw::c_int,
3885 ) -> FPDF_BOOL;
3886}
3887unsafe extern "C" {
3888 #[doc = " Function: FORM_OnChar\n Call this member function when a keystroke translates to a\n nonsystem character.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n nChar - The character code value itself.\n modifier - Mask of key flags (see fpdf_fwlevent.h for key\n flag values).\n Return Value:\n True indicates success; otherwise false."]
3889 pub fn FORM_OnChar(
3890 hHandle: FPDF_FORMHANDLE,
3891 page: FPDF_PAGE,
3892 nChar: ::std::os::raw::c_int,
3893 modifier: ::std::os::raw::c_int,
3894 ) -> FPDF_BOOL;
3895}
3896unsafe extern "C" {
3897 #[doc = " Experimental API\n Function: FORM_GetFocusedText\n Call this function to obtain the text within the current focused\n field, if any.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n buffer - Buffer for holding the form text, encoded in\n UTF-16LE. If NULL, |buffer| is not modified.\n buflen - Length of |buffer| in bytes. If |buflen| is less\n than the length of the form text string, |buffer| is\n not modified.\n Return Value:\n Length in bytes for the text in the focused field."]
3898 pub fn FORM_GetFocusedText(
3899 hHandle: FPDF_FORMHANDLE,
3900 page: FPDF_PAGE,
3901 buffer: *mut ::std::os::raw::c_void,
3902 buflen: ::std::os::raw::c_ulong,
3903 ) -> ::std::os::raw::c_ulong;
3904}
3905unsafe extern "C" {
3906 #[doc = " Function: FORM_GetSelectedText\n Call this function to obtain selected text within a form text\n field or form combobox text field.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n buffer - Buffer for holding the selected text, encoded in\n UTF-16LE. If NULL, |buffer| is not modified.\n buflen - Length of |buffer| in bytes. If |buflen| is less\n than the length of the selected text string,\n |buffer| is not modified.\n Return Value:\n Length in bytes of selected text in form text field or form combobox\n text field."]
3907 pub fn FORM_GetSelectedText(
3908 hHandle: FPDF_FORMHANDLE,
3909 page: FPDF_PAGE,
3910 buffer: *mut ::std::os::raw::c_void,
3911 buflen: ::std::os::raw::c_ulong,
3912 ) -> ::std::os::raw::c_ulong;
3913}
3914unsafe extern "C" {
3915 #[doc = " Experimental API\n Function: FORM_ReplaceAndKeepSelection\n Call this function to replace the selected text in a form\n text field or user-editable form combobox text field with another\n text string (which can be empty or non-empty). If there is no\n selected text, this function will append the replacement text after\n the current caret position. After the insertion, the inserted text\n will be selected.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as Returned by FPDF_LoadPage().\n wsText - The text to be inserted, in UTF-16LE format.\n Return Value:\n None."]
3916 pub fn FORM_ReplaceAndKeepSelection(
3917 hHandle: FPDF_FORMHANDLE,
3918 page: FPDF_PAGE,
3919 wsText: FPDF_WIDESTRING,
3920 );
3921}
3922unsafe extern "C" {
3923 #[doc = " Function: FORM_ReplaceSelection\n Call this function to replace the selected text in a form\n text field or user-editable form combobox text field with another\n text string (which can be empty or non-empty). If there is no\n selected text, this function will append the replacement text after\n the current caret position. After the insertion, the selection range\n will be set to empty.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as Returned by FPDF_LoadPage().\n wsText - The text to be inserted, in UTF-16LE format.\n Return Value:\n None."]
3924 pub fn FORM_ReplaceSelection(
3925 hHandle: FPDF_FORMHANDLE,
3926 page: FPDF_PAGE,
3927 wsText: FPDF_WIDESTRING,
3928 );
3929}
3930unsafe extern "C" {
3931 #[doc = " Experimental API\n Function: FORM_SelectAllText\n Call this function to select all the text within the currently focused\n form text field or form combobox text field.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return Value:\n Whether the operation succeeded or not."]
3932 pub fn FORM_SelectAllText(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
3933}
3934unsafe extern "C" {
3935 #[doc = " Function: FORM_CanUndo\n Find out if it is possible for the current focused widget in a given\n form to perform an undo operation.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return Value:\n True if it is possible to undo."]
3936 pub fn FORM_CanUndo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
3937}
3938unsafe extern "C" {
3939 #[doc = " Function: FORM_CanRedo\n Find out if it is possible for the current focused widget in a given\n form to perform a redo operation.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return Value:\n True if it is possible to redo."]
3940 pub fn FORM_CanRedo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
3941}
3942unsafe extern "C" {
3943 #[doc = " Function: FORM_Undo\n Make the current focused widget perform an undo operation.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return Value:\n True if the undo operation succeeded."]
3944 pub fn FORM_Undo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
3945}
3946unsafe extern "C" {
3947 #[doc = " Function: FORM_Redo\n Make the current focused widget perform a redo operation.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page, as returned by FPDF_LoadPage().\n Return Value:\n True if the redo operation succeeded."]
3948 pub fn FORM_Redo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
3949}
3950unsafe extern "C" {
3951 #[doc = " Function: FORM_ForceToKillFocus.\n Call this member function to force to kill the focus of the form\n field which has focus. If it would kill the focus of a form field,\n save the value of form field if was changed by theuser.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n True indicates success; otherwise false."]
3952 pub fn FORM_ForceToKillFocus(hHandle: FPDF_FORMHANDLE) -> FPDF_BOOL;
3953}
3954unsafe extern "C" {
3955 #[doc = " Experimental API.\n Function: FORM_GetFocusedAnnot.\n Call this member function to get the currently focused annotation.\n Parameters:\n handle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n page_index - Buffer to hold the index number of the page which\n contains the focused annotation. 0 for the first page.\n Can't be NULL.\n annot - Buffer to hold the focused annotation. Can't be NULL.\n Return Value:\n On success, return true and write to the out parameters. Otherwise\n return false and leave the out parameters unmodified.\n Comments:\n Not currently supported for XFA forms - will report no focused\n annotation.\n Must call FPDFPage_CloseAnnot() when the annotation returned in |annot|\n by this function is no longer needed.\n This will return true and set |page_index| to -1 and |annot| to NULL,\n if there is no focused annotation."]
3956 pub fn FORM_GetFocusedAnnot(
3957 handle: FPDF_FORMHANDLE,
3958 page_index: *mut ::std::os::raw::c_int,
3959 annot: *mut FPDF_ANNOTATION,
3960 ) -> FPDF_BOOL;
3961}
3962unsafe extern "C" {
3963 #[doc = " Experimental API.\n Function: FORM_SetFocusedAnnot.\n Call this member function to set the currently focused annotation.\n Parameters:\n handle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - Handle to an annotation.\n Return Value:\n True indicates success; otherwise false.\n Comments:\n |annot| can't be NULL. To kill focus, use FORM_ForceToKillFocus()\n instead."]
3964 pub fn FORM_SetFocusedAnnot(handle: FPDF_FORMHANDLE, annot: FPDF_ANNOTATION) -> FPDF_BOOL;
3965}
3966unsafe extern "C" {
3967 #[doc = " Function: FPDFPage_HasFormFieldAtPoint\n Get the form field type by point.\n Parameters:\n hHandle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page. Returned by FPDF_LoadPage().\n page_x - X position in PDF \"user space\".\n page_y - Y position in PDF \"user space\".\n Return Value:\n Return the type of the form field; -1 indicates no field.\n See field types above."]
3968 pub fn FPDFPage_HasFormFieldAtPoint(
3969 hHandle: FPDF_FORMHANDLE,
3970 page: FPDF_PAGE,
3971 page_x: f64,
3972 page_y: f64,
3973 ) -> ::std::os::raw::c_int;
3974}
3975unsafe extern "C" {
3976 #[doc = " Function: FPDFPage_FormFieldZOrderAtPoint\n Get the form field z-order by point.\n Parameters:\n hHandle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment().\n page - Handle to the page. Returned by FPDF_LoadPage().\n page_x - X position in PDF \"user space\".\n page_y - Y position in PDF \"user space\".\n Return Value:\n Return the z-order of the form field; -1 indicates no field.\n Higher numbers are closer to the front."]
3977 pub fn FPDFPage_FormFieldZOrderAtPoint(
3978 hHandle: FPDF_FORMHANDLE,
3979 page: FPDF_PAGE,
3980 page_x: f64,
3981 page_y: f64,
3982 ) -> ::std::os::raw::c_int;
3983}
3984unsafe extern "C" {
3985 #[doc = " Function: FPDF_SetFormFieldHighlightColor\n Set the highlight color of the specified (or all) form fields\n in the document.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n doc - Handle to the document, as returned by\n FPDF_LoadDocument().\n fieldType - A 32-bit integer indicating the type of a form\n field (defined above).\n color - The highlight color of the form field. Constructed by\n 0xxxrrggbb.\n Return Value:\n None.\n Comments:\n When the parameter fieldType is set to FPDF_FORMFIELD_UNKNOWN, the\n highlight color will be applied to all the form fields in the\n document.\n Please refresh the client window to show the highlight immediately\n if necessary."]
3986 pub fn FPDF_SetFormFieldHighlightColor(
3987 hHandle: FPDF_FORMHANDLE,
3988 fieldType: ::std::os::raw::c_int,
3989 color: ::std::os::raw::c_ulong,
3990 );
3991}
3992unsafe extern "C" {
3993 #[doc = " Function: FPDF_SetFormFieldHighlightAlpha\n Set the transparency of the form field highlight color in the\n document.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n doc - Handle to the document, as returaned by\n FPDF_LoadDocument().\n alpha - The transparency of the form field highlight color,\n between 0-255.\n Return Value:\n None."]
3994 pub fn FPDF_SetFormFieldHighlightAlpha(
3995 hHandle: FPDF_FORMHANDLE,
3996 alpha: ::std::os::raw::c_uchar,
3997 );
3998}
3999unsafe extern "C" {
4000 #[doc = " Function: FPDF_RemoveFormFieldHighlight\n Remove the form field highlight color in the document.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n Return Value:\n None.\n Comments:\n Please refresh the client window to remove the highlight immediately\n if necessary."]
4001 pub fn FPDF_RemoveFormFieldHighlight(hHandle: FPDF_FORMHANDLE);
4002}
4003unsafe extern "C" {
4004 #[doc = " Function: FPDF_FFLDraw\n Render FormFields and popup window on a page to a device independent\n bitmap.\n Parameters:\n hHandle - Handle to the form fill module, as returned by\n FPDFDOC_InitFormFillEnvironment().\n bitmap - Handle to the device independent bitmap (as the\n output buffer). Bitmap handles can be created by\n FPDFBitmap_Create().\n page - Handle to the page, as returned by FPDF_LoadPage().\n start_x - Left pixel position of the display area in the\n device coordinates.\n start_y - Top pixel position of the display area in the device\n coordinates.\n size_x - Horizontal size (in pixels) for displaying the page.\n size_y - Vertical size (in pixels) for displaying the page.\n rotate - Page orientation: 0 (normal), 1 (rotated 90 degrees\n clockwise), 2 (rotated 180 degrees), 3 (rotated 90\n degrees counter-clockwise).\n flags - 0 for normal display, or combination of flags\n defined above.\n Return Value:\n None.\n Comments:\n This function is designed to render annotations that are\n user-interactive, which are widget annotations (for FormFields) and\n popup annotations.\n With the FPDF_ANNOT flag, this function will render a popup annotation\n when users mouse-hover on a non-widget annotation. Regardless of\n FPDF_ANNOT flag, this function will always render widget annotations\n for FormFields.\n In order to implement the FormFill functions, implementation should\n call this function after rendering functions, such as\n FPDF_RenderPageBitmap() or FPDF_RenderPageBitmap_Start(), have\n finished rendering the page contents."]
4005 pub fn FPDF_FFLDraw(
4006 hHandle: FPDF_FORMHANDLE,
4007 bitmap: FPDF_BITMAP,
4008 page: FPDF_PAGE,
4009 start_x: ::std::os::raw::c_int,
4010 start_y: ::std::os::raw::c_int,
4011 size_x: ::std::os::raw::c_int,
4012 size_y: ::std::os::raw::c_int,
4013 rotate: ::std::os::raw::c_int,
4014 flags: ::std::os::raw::c_int,
4015 );
4016}
4017unsafe extern "C" {
4018 pub fn FPDF_FFLDrawSkia(
4019 hHandle: FPDF_FORMHANDLE,
4020 canvas: FPDF_SKIA_CANVAS,
4021 page: FPDF_PAGE,
4022 start_x: ::std::os::raw::c_int,
4023 start_y: ::std::os::raw::c_int,
4024 size_x: ::std::os::raw::c_int,
4025 size_y: ::std::os::raw::c_int,
4026 rotate: ::std::os::raw::c_int,
4027 flags: ::std::os::raw::c_int,
4028 );
4029}
4030unsafe extern "C" {
4031 #[doc = " Experimental API\n Function: FPDF_GetFormType\n Returns the type of form contained in the PDF document.\n Parameters:\n document - Handle to document.\n Return Value:\n Integer value representing one of the FORMTYPE_ values.\n Comments:\n If |document| is NULL, then the return value is FORMTYPE_NONE."]
4032 pub fn FPDF_GetFormType(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
4033}
4034unsafe extern "C" {
4035 #[doc = " Experimental API\n Function: FORM_SetIndexSelected\n Selects/deselects the value at the given |index| of the focused\n annotation.\n Parameters:\n hHandle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment.\n page - Handle to the page. Returned by FPDF_LoadPage\n index - 0-based index of value to be set as\n selected/unselected\n selected - true to select, false to deselect\n Return Value:\n TRUE if the operation succeeded.\n FALSE if the operation failed or widget is not a supported type.\n Comments:\n Intended for use with listbox/combobox widget types. Comboboxes\n have at most a single value selected at a time which cannot be\n deselected. Deselect on a combobox is a no-op that returns false.\n Default implementation is a no-op that will return false for\n other types.\n Not currently supported for XFA forms - will return false."]
4036 pub fn FORM_SetIndexSelected(
4037 hHandle: FPDF_FORMHANDLE,
4038 page: FPDF_PAGE,
4039 index: ::std::os::raw::c_int,
4040 selected: FPDF_BOOL,
4041 ) -> FPDF_BOOL;
4042}
4043unsafe extern "C" {
4044 #[doc = " Experimental API\n Function: FORM_IsIndexSelected\n Returns whether or not the value at |index| of the focused\n annotation is currently selected.\n Parameters:\n hHandle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment.\n page - Handle to the page. Returned by FPDF_LoadPage\n index - 0-based Index of value to check\n Return Value:\n TRUE if value at |index| is currently selected.\n FALSE if value at |index| is not selected or widget is not a\n supported type.\n Comments:\n Intended for use with listbox/combobox widget types. Default\n implementation is a no-op that will return false for other types.\n Not currently supported for XFA forms - will return false."]
4045 pub fn FORM_IsIndexSelected(
4046 hHandle: FPDF_FORMHANDLE,
4047 page: FPDF_PAGE,
4048 index: ::std::os::raw::c_int,
4049 ) -> FPDF_BOOL;
4050}
4051unsafe extern "C" {
4052 #[doc = " Function: FPDF_LoadXFA\n If the document consists of XFA fields, call this method to\n attempt to load XFA fields.\n Parameters:\n document - Handle to document from FPDF_LoadDocument().\n Return Value:\n TRUE upon success, otherwise FALSE. If XFA support is not built\n into PDFium, performs no action and always returns FALSE."]
4053 pub fn FPDF_LoadXFA(document: FPDF_DOCUMENT) -> FPDF_BOOL;
4054}
4055pub const FPDFANNOT_COLORTYPE_FPDFANNOT_COLORTYPE_Color: FPDFANNOT_COLORTYPE = 0;
4056pub const FPDFANNOT_COLORTYPE_FPDFANNOT_COLORTYPE_InteriorColor: FPDFANNOT_COLORTYPE = 1;
4057pub type FPDFANNOT_COLORTYPE = ::std::os::raw::c_uint;
4058unsafe extern "C" {
4059 #[doc = " Experimental API.\n Check if an annotation subtype is currently supported for creation.\n Currently supported subtypes:\n - circle\n - fileattachment\n - freetext\n - highlight\n - ink\n - link\n - popup\n - square,\n - squiggly\n - stamp\n - strikeout\n - text\n - underline\n\n subtype - the subtype to be checked.\n\n Returns true if this subtype supported."]
4060 pub fn FPDFAnnot_IsSupportedSubtype(subtype: FPDF_ANNOTATION_SUBTYPE) -> FPDF_BOOL;
4061}
4062unsafe extern "C" {
4063 #[doc = " Experimental API.\n Create an annotation in |page| of the subtype |subtype|. If the specified\n subtype is illegal or unsupported, then a new annotation will not be created.\n Must call FPDFPage_CloseAnnot() when the annotation returned by this\n function is no longer needed.\n\n page - handle to a page.\n subtype - the subtype of the new annotation.\n\n Returns a handle to the new annotation object, or NULL on failure."]
4064 pub fn FPDFPage_CreateAnnot(
4065 page: FPDF_PAGE,
4066 subtype: FPDF_ANNOTATION_SUBTYPE,
4067 ) -> FPDF_ANNOTATION;
4068}
4069unsafe extern "C" {
4070 #[doc = " Experimental API.\n Get the number of annotations in |page|.\n\n page - handle to a page.\n\n Returns the number of annotations in |page|."]
4071 pub fn FPDFPage_GetAnnotCount(page: FPDF_PAGE) -> ::std::os::raw::c_int;
4072}
4073unsafe extern "C" {
4074 #[doc = " Experimental API.\n Get annotation in |page| at |index|. Must call FPDFPage_CloseAnnot() when the\n annotation returned by this function is no longer needed.\n\n page - handle to a page.\n index - the index of the annotation.\n\n Returns a handle to the annotation object, or NULL on failure."]
4075 pub fn FPDFPage_GetAnnot(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_ANNOTATION;
4076}
4077unsafe extern "C" {
4078 #[doc = " Experimental API.\n Get the index of |annot| in |page|. This is the opposite of\n FPDFPage_GetAnnot().\n\n page - handle to the page that the annotation is on.\n annot - handle to an annotation.\n\n Returns the index of |annot|, or -1 on failure."]
4079 pub fn FPDFPage_GetAnnotIndex(page: FPDF_PAGE, annot: FPDF_ANNOTATION)
4080 -> ::std::os::raw::c_int;
4081}
4082unsafe extern "C" {
4083 #[doc = " Experimental API.\n Close an annotation. Must be called when the annotation returned by\n FPDFPage_CreateAnnot() or FPDFPage_GetAnnot() is no longer needed. This\n function does not remove the annotation from the document.\n\n annot - handle to an annotation."]
4084 pub fn FPDFPage_CloseAnnot(annot: FPDF_ANNOTATION);
4085}
4086unsafe extern "C" {
4087 #[doc = " Experimental API.\n Remove the annotation in |page| at |index|.\n\n page - handle to a page.\n index - the index of the annotation.\n\n Returns true if successful."]
4088 pub fn FPDFPage_RemoveAnnot(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_BOOL;
4089}
4090unsafe extern "C" {
4091 #[doc = " Experimental API.\n Get the subtype of an annotation.\n\n annot - handle to an annotation.\n\n Returns the annotation subtype."]
4092 pub fn FPDFAnnot_GetSubtype(annot: FPDF_ANNOTATION) -> FPDF_ANNOTATION_SUBTYPE;
4093}
4094unsafe extern "C" {
4095 #[doc = " Experimental API.\n Check if an annotation subtype is currently supported for object extraction,\n update, and removal.\n Currently supported subtypes: ink and stamp.\n\n subtype - the subtype to be checked.\n\n Returns true if this subtype supported."]
4096 pub fn FPDFAnnot_IsObjectSupportedSubtype(subtype: FPDF_ANNOTATION_SUBTYPE) -> FPDF_BOOL;
4097}
4098unsafe extern "C" {
4099 #[doc = " Experimental API.\n Update |obj| in |annot|. |obj| must be in |annot| already and must have\n been retrieved by FPDFAnnot_GetObject(). Currently, only ink and stamp\n annotations are supported by this API. Also note that only path, image, and\n text objects have APIs for modification; see FPDFPath_*(), FPDFText_*(), and\n FPDFImageObj_*().\n\n annot - handle to an annotation.\n obj - handle to the object that |annot| needs to update.\n\n Return true if successful."]
4100 pub fn FPDFAnnot_UpdateObject(annot: FPDF_ANNOTATION, obj: FPDF_PAGEOBJECT) -> FPDF_BOOL;
4101}
4102unsafe extern "C" {
4103 #[doc = " Experimental API.\n Add a new InkStroke, represented by an array of points, to the InkList of\n |annot|. The API creates an InkList if one doesn't already exist in |annot|.\n This API works only for ink annotations. Please refer to ISO 32000-1:2008\n spec, section 12.5.6.13.\n\n annot - handle to an annotation.\n points - pointer to a FS_POINTF array representing input points.\n point_count - number of elements in |points| array. This should not exceed\n the maximum value that can be represented by an int32_t).\n\n Returns the 0-based index at which the new InkStroke is added in the InkList\n of the |annot|. Returns -1 on failure."]
4104 pub fn FPDFAnnot_AddInkStroke(
4105 annot: FPDF_ANNOTATION,
4106 points: *const FS_POINTF,
4107 point_count: usize,
4108 ) -> ::std::os::raw::c_int;
4109}
4110unsafe extern "C" {
4111 #[doc = " Experimental API.\n Removes an InkList in |annot|.\n This API works only for ink annotations.\n\n annot - handle to an annotation.\n\n Return true on successful removal of /InkList entry from context of the\n non-null ink |annot|. Returns false on failure."]
4112 pub fn FPDFAnnot_RemoveInkList(annot: FPDF_ANNOTATION) -> FPDF_BOOL;
4113}
4114unsafe extern "C" {
4115 #[doc = " Experimental API.\n Add |obj| to |annot|. |obj| must have been created by\n FPDFPageObj_CreateNew{Path|Rect}() or FPDFPageObj_New{Text|Image}Obj(), and\n will be owned by |annot|. Note that an |obj| cannot belong to more than one\n |annot|. Currently, only ink and stamp annotations are supported by this API.\n Also note that only path, image, and text objects have APIs for creation.\n\n annot - handle to an annotation.\n obj - handle to the object that is to be added to |annot|.\n\n Return true if successful."]
4116 pub fn FPDFAnnot_AppendObject(annot: FPDF_ANNOTATION, obj: FPDF_PAGEOBJECT) -> FPDF_BOOL;
4117}
4118unsafe extern "C" {
4119 #[doc = " Experimental API.\n Get the total number of objects in |annot|, including path objects, text\n objects, external objects, image objects, and shading objects.\n\n annot - handle to an annotation.\n\n Returns the number of objects in |annot|."]
4120 pub fn FPDFAnnot_GetObjectCount(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_int;
4121}
4122unsafe extern "C" {
4123 #[doc = " Experimental API.\n Get the object in |annot| at |index|.\n\n annot - handle to an annotation.\n index - the index of the object.\n\n Return a handle to the object, or NULL on failure."]
4124 pub fn FPDFAnnot_GetObject(
4125 annot: FPDF_ANNOTATION,
4126 index: ::std::os::raw::c_int,
4127 ) -> FPDF_PAGEOBJECT;
4128}
4129unsafe extern "C" {
4130 #[doc = " Experimental API.\n Remove the object in |annot| at |index|.\n\n annot - handle to an annotation.\n index - the index of the object to be removed.\n\n Return true if successful."]
4131 pub fn FPDFAnnot_RemoveObject(
4132 annot: FPDF_ANNOTATION,
4133 index: ::std::os::raw::c_int,
4134 ) -> FPDF_BOOL;
4135}
4136unsafe extern "C" {
4137 #[doc = " Experimental API.\n Set the color of an annotation. Fails when called on annotations with\n appearance streams already defined; instead use\n FPDFPageObj_Set{Stroke|Fill}Color().\n\n annot - handle to an annotation.\n type - type of the color to be set.\n R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.\n A - buffer to hold the opacity. Ranges from 0 to 255.\n\n Returns true if successful."]
4138 pub fn FPDFAnnot_SetColor(
4139 annot: FPDF_ANNOTATION,
4140 type_: FPDFANNOT_COLORTYPE,
4141 R: ::std::os::raw::c_uint,
4142 G: ::std::os::raw::c_uint,
4143 B: ::std::os::raw::c_uint,
4144 A: ::std::os::raw::c_uint,
4145 ) -> FPDF_BOOL;
4146}
4147unsafe extern "C" {
4148 #[doc = " Experimental API.\n Get the color of an annotation. If no color is specified, default to yellow\n for highlight annotation, black for all else. Fails when called on\n annotations with appearance streams already defined; instead use\n FPDFPageObj_Get{Stroke|Fill}Color().\n\n annot - handle to an annotation.\n type - type of the color requested.\n R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.\n A - buffer to hold the opacity. Ranges from 0 to 255.\n\n Returns true if successful."]
4149 pub fn FPDFAnnot_GetColor(
4150 annot: FPDF_ANNOTATION,
4151 type_: FPDFANNOT_COLORTYPE,
4152 R: *mut ::std::os::raw::c_uint,
4153 G: *mut ::std::os::raw::c_uint,
4154 B: *mut ::std::os::raw::c_uint,
4155 A: *mut ::std::os::raw::c_uint,
4156 ) -> FPDF_BOOL;
4157}
4158unsafe extern "C" {
4159 #[doc = " Experimental API.\n Check if the annotation is of a type that has attachment points\n (i.e. quadpoints). Quadpoints are the vertices of the rectangle that\n encompasses the texts affected by the annotation. They provide the\n coordinates in the page where the annotation is attached. Only text markup\n annotations (i.e. highlight, strikeout, squiggly, and underline) and link\n annotations have quadpoints.\n\n annot - handle to an annotation.\n\n Returns true if the annotation is of a type that has quadpoints, false\n otherwise."]
4160 pub fn FPDFAnnot_HasAttachmentPoints(annot: FPDF_ANNOTATION) -> FPDF_BOOL;
4161}
4162unsafe extern "C" {
4163 #[doc = " Experimental API.\n Replace the attachment points (i.e. quadpoints) set of an annotation at\n |quad_index|. This index needs to be within the result of\n FPDFAnnot_CountAttachmentPoints().\n If the annotation's appearance stream is defined and this annotation is of a\n type with quadpoints, then update the bounding box too if the new quadpoints\n define a bigger one.\n\n annot - handle to an annotation.\n quad_index - index of the set of quadpoints.\n quad_points - the quadpoints to be set.\n\n Returns true if successful."]
4164 pub fn FPDFAnnot_SetAttachmentPoints(
4165 annot: FPDF_ANNOTATION,
4166 quad_index: usize,
4167 quad_points: *const FS_QUADPOINTSF,
4168 ) -> FPDF_BOOL;
4169}
4170unsafe extern "C" {
4171 #[doc = " Experimental API.\n Append to the list of attachment points (i.e. quadpoints) of an annotation.\n If the annotation's appearance stream is defined and this annotation is of a\n type with quadpoints, then update the bounding box too if the new quadpoints\n define a bigger one.\n\n annot - handle to an annotation.\n quad_points - the quadpoints to be set.\n\n Returns true if successful."]
4172 pub fn FPDFAnnot_AppendAttachmentPoints(
4173 annot: FPDF_ANNOTATION,
4174 quad_points: *const FS_QUADPOINTSF,
4175 ) -> FPDF_BOOL;
4176}
4177unsafe extern "C" {
4178 #[doc = " Experimental API.\n Get the number of sets of quadpoints of an annotation.\n\n annot - handle to an annotation.\n\n Returns the number of sets of quadpoints, or 0 on failure."]
4179 pub fn FPDFAnnot_CountAttachmentPoints(annot: FPDF_ANNOTATION) -> usize;
4180}
4181unsafe extern "C" {
4182 #[doc = " Experimental API.\n Get the attachment points (i.e. quadpoints) of an annotation.\n\n annot - handle to an annotation.\n quad_index - index of the set of quadpoints.\n quad_points - receives the quadpoints; must not be NULL.\n\n Returns true if successful."]
4183 pub fn FPDFAnnot_GetAttachmentPoints(
4184 annot: FPDF_ANNOTATION,
4185 quad_index: usize,
4186 quad_points: *mut FS_QUADPOINTSF,
4187 ) -> FPDF_BOOL;
4188}
4189unsafe extern "C" {
4190 #[doc = " Experimental API.\n Set the annotation rectangle defining the location of the annotation. If the\n annotation's appearance stream is defined and this annotation is of a type\n without quadpoints, then update the bounding box too if the new rectangle\n defines a bigger one.\n\n annot - handle to an annotation.\n rect - the annotation rectangle to be set.\n\n Returns true if successful."]
4191 pub fn FPDFAnnot_SetRect(annot: FPDF_ANNOTATION, rect: *const FS_RECTF) -> FPDF_BOOL;
4192}
4193unsafe extern "C" {
4194 #[doc = " Experimental API.\n Get the annotation rectangle defining the location of the annotation.\n\n annot - handle to an annotation.\n rect - receives the rectangle; must not be NULL.\n\n Returns true if successful."]
4195 pub fn FPDFAnnot_GetRect(annot: FPDF_ANNOTATION, rect: *mut FS_RECTF) -> FPDF_BOOL;
4196}
4197unsafe extern "C" {
4198 #[doc = " Experimental API.\n Get the vertices of a polygon or polyline annotation. |buffer| is an array of\n points of the annotation. If |length| is less than the returned length, or\n |annot| or |buffer| is NULL, |buffer| will not be modified.\n\n annot - handle to an annotation, as returned by e.g. FPDFPage_GetAnnot()\n buffer - buffer for holding the points.\n length - length of the buffer in points.\n\n Returns the number of points if the annotation is of type polygon or\n polyline, 0 otherwise."]
4199 pub fn FPDFAnnot_GetVertices(
4200 annot: FPDF_ANNOTATION,
4201 buffer: *mut FS_POINTF,
4202 length: ::std::os::raw::c_ulong,
4203 ) -> ::std::os::raw::c_ulong;
4204}
4205unsafe extern "C" {
4206 #[doc = " Experimental API.\n Get the number of paths in the ink list of an ink annotation.\n\n annot - handle to an annotation, as returned by e.g. FPDFPage_GetAnnot()\n\n Returns the number of paths in the ink list if the annotation is of type ink,\n 0 otherwise."]
4207 pub fn FPDFAnnot_GetInkListCount(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_ulong;
4208}
4209unsafe extern "C" {
4210 #[doc = " Experimental API.\n Get a path in the ink list of an ink annotation. |buffer| is an array of\n points of the path. If |length| is less than the returned length, or |annot|\n or |buffer| is NULL, |buffer| will not be modified.\n\n annot - handle to an annotation, as returned by e.g. FPDFPage_GetAnnot()\n path_index - index of the path\n buffer - buffer for holding the points.\n length - length of the buffer in points.\n\n Returns the number of points of the path if the annotation is of type ink, 0\n otherwise."]
4211 pub fn FPDFAnnot_GetInkListPath(
4212 annot: FPDF_ANNOTATION,
4213 path_index: ::std::os::raw::c_ulong,
4214 buffer: *mut FS_POINTF,
4215 length: ::std::os::raw::c_ulong,
4216 ) -> ::std::os::raw::c_ulong;
4217}
4218unsafe extern "C" {
4219 #[doc = " Experimental API.\n Get the starting and ending coordinates of a line annotation.\n\n annot - handle to an annotation, as returned by e.g. FPDFPage_GetAnnot()\n start - starting point\n end - ending point\n\n Returns true if the annotation is of type line, |start| and |end| are not\n NULL, false otherwise."]
4220 pub fn FPDFAnnot_GetLine(
4221 annot: FPDF_ANNOTATION,
4222 start: *mut FS_POINTF,
4223 end: *mut FS_POINTF,
4224 ) -> FPDF_BOOL;
4225}
4226unsafe extern "C" {
4227 #[doc = " Experimental API.\n Set the characteristics of the annotation's border (rounded rectangle).\n\n annot - handle to an annotation\n horizontal_radius - horizontal corner radius, in default user space units\n vertical_radius - vertical corner radius, in default user space units\n border_width - border width, in default user space units\n\n Returns true if setting the border for |annot| succeeds, false otherwise.\n\n If |annot| contains an appearance stream that overrides the border values,\n then the appearance stream will be removed on success."]
4228 pub fn FPDFAnnot_SetBorder(
4229 annot: FPDF_ANNOTATION,
4230 horizontal_radius: f32,
4231 vertical_radius: f32,
4232 border_width: f32,
4233 ) -> FPDF_BOOL;
4234}
4235unsafe extern "C" {
4236 #[doc = " Experimental API.\n Get the characteristics of the annotation's border (rounded rectangle).\n\n annot - handle to an annotation\n horizontal_radius - horizontal corner radius, in default user space units\n vertical_radius - vertical corner radius, in default user space units\n border_width - border width, in default user space units\n\n Returns true if |horizontal_radius|, |vertical_radius| and |border_width| are\n not NULL, false otherwise."]
4237 pub fn FPDFAnnot_GetBorder(
4238 annot: FPDF_ANNOTATION,
4239 horizontal_radius: *mut f32,
4240 vertical_radius: *mut f32,
4241 border_width: *mut f32,
4242 ) -> FPDF_BOOL;
4243}
4244unsafe extern "C" {
4245 #[doc = " Experimental API.\n Get the JavaScript of an event of the annotation's additional actions.\n |buffer| is only modified if |buflen| is large enough to hold the whole\n JavaScript string. If |buflen| is smaller, the total size of the JavaScript\n is still returned, but nothing is copied. If there is no JavaScript for\n |event| in |annot|, an empty string is written to |buf| and 2 is returned,\n denoting the size of the null terminator in the buffer. On other errors,\n nothing is written to |buffer| and 0 is returned.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n event - event type, one of the FPDF_ANNOT_AACTION_* values.\n buffer - buffer for holding the value string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes, including the 2-byte\n null terminator."]
4246 pub fn FPDFAnnot_GetFormAdditionalActionJavaScript(
4247 hHandle: FPDF_FORMHANDLE,
4248 annot: FPDF_ANNOTATION,
4249 event: ::std::os::raw::c_int,
4250 buffer: *mut FPDF_WCHAR,
4251 buflen: ::std::os::raw::c_ulong,
4252 ) -> ::std::os::raw::c_ulong;
4253}
4254unsafe extern "C" {
4255 #[doc = " Experimental API.\n Check if |annot|'s dictionary has |key| as a key.\n\n annot - handle to an annotation.\n key - the key to look for, encoded in UTF-8.\n\n Returns true if |key| exists."]
4256 pub fn FPDFAnnot_HasKey(annot: FPDF_ANNOTATION, key: FPDF_BYTESTRING) -> FPDF_BOOL;
4257}
4258unsafe extern "C" {
4259 #[doc = " Experimental API.\n Get the type of the value corresponding to |key| in |annot|'s dictionary.\n\n annot - handle to an annotation.\n key - the key to look for, encoded in UTF-8.\n\n Returns the type of the dictionary value."]
4260 pub fn FPDFAnnot_GetValueType(annot: FPDF_ANNOTATION, key: FPDF_BYTESTRING)
4261 -> FPDF_OBJECT_TYPE;
4262}
4263unsafe extern "C" {
4264 #[doc = " Experimental API.\n Set the string value corresponding to |key| in |annot|'s dictionary,\n overwriting the existing value if any. The value type would be\n FPDF_OBJECT_STRING after this function call succeeds.\n\n annot - handle to an annotation.\n key - the key to the dictionary entry to be set, encoded in UTF-8.\n value - the string value to be set, encoded in UTF-16LE.\n\n Returns true if successful."]
4265 pub fn FPDFAnnot_SetStringValue(
4266 annot: FPDF_ANNOTATION,
4267 key: FPDF_BYTESTRING,
4268 value: FPDF_WIDESTRING,
4269 ) -> FPDF_BOOL;
4270}
4271unsafe extern "C" {
4272 #[doc = " Experimental API.\n Get the string value corresponding to |key| in |annot|'s dictionary. |buffer|\n is only modified if |buflen| is longer than the length of contents. Note that\n if |key| does not exist in the dictionary or if |key|'s corresponding value\n in the dictionary is not a string (i.e. the value is not of type\n FPDF_OBJECT_STRING or FPDF_OBJECT_NAME), then an empty string would be copied\n to |buffer| and the return value would be 2. On other errors, nothing would\n be added to |buffer| and the return value would be 0.\n\n annot - handle to an annotation.\n key - the key to the requested dictionary entry, encoded in UTF-8.\n buffer - buffer for holding the value string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes."]
4273 pub fn FPDFAnnot_GetStringValue(
4274 annot: FPDF_ANNOTATION,
4275 key: FPDF_BYTESTRING,
4276 buffer: *mut FPDF_WCHAR,
4277 buflen: ::std::os::raw::c_ulong,
4278 ) -> ::std::os::raw::c_ulong;
4279}
4280unsafe extern "C" {
4281 #[doc = " Experimental API.\n Get the float value corresponding to |key| in |annot|'s dictionary. Writes\n value to |value| and returns True if |key| exists in the dictionary and\n |key|'s corresponding value is a number (FPDF_OBJECT_NUMBER), False\n otherwise.\n\n annot - handle to an annotation.\n key - the key to the requested dictionary entry, encoded in UTF-8.\n value - receives the value, must not be NULL.\n\n Returns True if value found, False otherwise."]
4282 pub fn FPDFAnnot_GetNumberValue(
4283 annot: FPDF_ANNOTATION,
4284 key: FPDF_BYTESTRING,
4285 value: *mut f32,
4286 ) -> FPDF_BOOL;
4287}
4288unsafe extern "C" {
4289 #[doc = " Experimental API.\n Set the AP (appearance string) in |annot|'s dictionary for a given\n |appearanceMode|.\n\n annot - handle to an annotation.\n appearanceMode - the appearance mode (normal, rollover or down) for which\n to get the AP.\n value - the string value to be set, encoded in UTF-16LE. If\n nullptr is passed, the AP is cleared for that mode. If the\n mode is Normal, APs for all modes are cleared.\n\n Returns true if successful."]
4290 pub fn FPDFAnnot_SetAP(
4291 annot: FPDF_ANNOTATION,
4292 appearanceMode: FPDF_ANNOT_APPEARANCEMODE,
4293 value: FPDF_WIDESTRING,
4294 ) -> FPDF_BOOL;
4295}
4296unsafe extern "C" {
4297 #[doc = " Experimental API.\n Get the AP (appearance string) from |annot|'s dictionary for a given\n |appearanceMode|.\n |buffer| is only modified if |buflen| is large enough to hold the whole AP\n string. If |buflen| is smaller, the total size of the AP is still returned,\n but nothing is copied.\n If there is no appearance stream for |annot| in |appearanceMode|, an empty\n string is written to |buf| and 2 is returned.\n On other errors, nothing is written to |buffer| and 0 is returned.\n\n annot - handle to an annotation.\n appearanceMode - the appearance mode (normal, rollover or down) for which\n to get the AP.\n buffer - buffer for holding the value string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes."]
4298 pub fn FPDFAnnot_GetAP(
4299 annot: FPDF_ANNOTATION,
4300 appearanceMode: FPDF_ANNOT_APPEARANCEMODE,
4301 buffer: *mut FPDF_WCHAR,
4302 buflen: ::std::os::raw::c_ulong,
4303 ) -> ::std::os::raw::c_ulong;
4304}
4305unsafe extern "C" {
4306 #[doc = " Experimental API.\n Get the annotation corresponding to |key| in |annot|'s dictionary. Common\n keys for linking annotations include \"IRT\" and \"Popup\". Must call\n FPDFPage_CloseAnnot() when the annotation returned by this function is no\n longer needed.\n\n annot - handle to an annotation.\n key - the key to the requested dictionary entry, encoded in UTF-8.\n\n Returns a handle to the linked annotation object, or NULL on failure."]
4307 pub fn FPDFAnnot_GetLinkedAnnot(
4308 annot: FPDF_ANNOTATION,
4309 key: FPDF_BYTESTRING,
4310 ) -> FPDF_ANNOTATION;
4311}
4312unsafe extern "C" {
4313 #[doc = " Experimental API.\n Get the annotation flags of |annot|.\n\n annot - handle to an annotation.\n\n Returns the annotation flags."]
4314 pub fn FPDFAnnot_GetFlags(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_int;
4315}
4316unsafe extern "C" {
4317 #[doc = " Experimental API.\n Set the |annot|'s flags to be of the value |flags|.\n\n annot - handle to an annotation.\n flags - the flag values to be set.\n\n Returns true if successful."]
4318 pub fn FPDFAnnot_SetFlags(annot: FPDF_ANNOTATION, flags: ::std::os::raw::c_int) -> FPDF_BOOL;
4319}
4320unsafe extern "C" {
4321 #[doc = " Experimental API.\n Get the annotation flags of |annot|.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n\n Returns the annotation flags specific to interactive forms."]
4322 pub fn FPDFAnnot_GetFormFieldFlags(
4323 handle: FPDF_FORMHANDLE,
4324 annot: FPDF_ANNOTATION,
4325 ) -> ::std::os::raw::c_int;
4326}
4327unsafe extern "C" {
4328 #[doc = " Experimental API.\n Sets the form field flags for an interactive form annotation.\n\n handle - the handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n flags - the form field flags to be set.\n\n Returns true if successful."]
4329 pub fn FPDFAnnot_SetFormFieldFlags(
4330 handle: FPDF_FORMHANDLE,
4331 annot: FPDF_ANNOTATION,
4332 flags: ::std::os::raw::c_int,
4333 ) -> FPDF_BOOL;
4334}
4335unsafe extern "C" {
4336 #[doc = " Experimental API.\n Retrieves an interactive form annotation whose rectangle contains a given\n point on a page. Must call FPDFPage_CloseAnnot() when the annotation returned\n is no longer needed.\n\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n page - handle to the page, returned by FPDF_LoadPage function.\n point - position in PDF \"user space\".\n\n Returns the interactive form annotation whose rectangle contains the given\n coordinates on the page. If there is no such annotation, return NULL."]
4337 pub fn FPDFAnnot_GetFormFieldAtPoint(
4338 hHandle: FPDF_FORMHANDLE,
4339 page: FPDF_PAGE,
4340 point: *const FS_POINTF,
4341 ) -> FPDF_ANNOTATION;
4342}
4343unsafe extern "C" {
4344 #[doc = " Experimental API.\n Gets the name of |annot|, which is an interactive form annotation.\n |buffer| is only modified if |buflen| is longer than the length of contents.\n In case of error, nothing will be added to |buffer| and the return value will\n be 0. Note that return value of empty string is 2 for \"\\0\\0\".\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n buffer - buffer for holding the name string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes."]
4345 pub fn FPDFAnnot_GetFormFieldName(
4346 hHandle: FPDF_FORMHANDLE,
4347 annot: FPDF_ANNOTATION,
4348 buffer: *mut FPDF_WCHAR,
4349 buflen: ::std::os::raw::c_ulong,
4350 ) -> ::std::os::raw::c_ulong;
4351}
4352unsafe extern "C" {
4353 #[doc = " Experimental API.\n Gets the alternate name of |annot|, which is an interactive form annotation.\n |buffer| is only modified if |buflen| is longer than the length of contents.\n In case of error, nothing will be added to |buffer| and the return value will\n be 0. Note that return value of empty string is 2 for \"\\0\\0\".\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n buffer - buffer for holding the alternate name string, encoded in\n UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes."]
4354 pub fn FPDFAnnot_GetFormFieldAlternateName(
4355 hHandle: FPDF_FORMHANDLE,
4356 annot: FPDF_ANNOTATION,
4357 buffer: *mut FPDF_WCHAR,
4358 buflen: ::std::os::raw::c_ulong,
4359 ) -> ::std::os::raw::c_ulong;
4360}
4361unsafe extern "C" {
4362 #[doc = " Experimental API.\n Gets the form field type of |annot|, which is an interactive form annotation.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n\n Returns the type of the form field (one of the FPDF_FORMFIELD_* values) on\n success. Returns -1 on error.\n See field types in fpdf_formfill.h."]
4363 pub fn FPDFAnnot_GetFormFieldType(
4364 hHandle: FPDF_FORMHANDLE,
4365 annot: FPDF_ANNOTATION,
4366 ) -> ::std::os::raw::c_int;
4367}
4368unsafe extern "C" {
4369 #[doc = " Experimental API.\n Gets the value of |annot|, which is an interactive form annotation.\n |buffer| is only modified if |buflen| is longer than the length of contents.\n In case of error, nothing will be added to |buffer| and the return value will\n be 0. Note that return value of empty string is 2 for \"\\0\\0\".\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n buffer - buffer for holding the value string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes."]
4370 pub fn FPDFAnnot_GetFormFieldValue(
4371 hHandle: FPDF_FORMHANDLE,
4372 annot: FPDF_ANNOTATION,
4373 buffer: *mut FPDF_WCHAR,
4374 buflen: ::std::os::raw::c_ulong,
4375 ) -> ::std::os::raw::c_ulong;
4376}
4377unsafe extern "C" {
4378 #[doc = " Experimental API.\n Get the number of options in the |annot|'s \"Opt\" dictionary. Intended for\n use with listbox and combobox widget annotations.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n\n Returns the number of options in \"Opt\" dictionary on success. Return value\n will be -1 if annotation does not have an \"Opt\" dictionary or other error."]
4379 pub fn FPDFAnnot_GetOptionCount(
4380 hHandle: FPDF_FORMHANDLE,
4381 annot: FPDF_ANNOTATION,
4382 ) -> ::std::os::raw::c_int;
4383}
4384unsafe extern "C" {
4385 #[doc = " Experimental API.\n Get the string value for the label of the option at |index| in |annot|'s\n \"Opt\" dictionary. Intended for use with listbox and combobox widget\n annotations. |buffer| is only modified if |buflen| is longer than the length\n of contents. If index is out of range or in case of other error, nothing\n will be added to |buffer| and the return value will be 0. Note that\n return value of empty string is 2 for \"\\0\\0\".\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n index - numeric index of the option in the \"Opt\" array\n buffer - buffer for holding the value string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes.\n If |annot| does not have an \"Opt\" array, |index| is out of range or if any\n other error occurs, returns 0."]
4386 pub fn FPDFAnnot_GetOptionLabel(
4387 hHandle: FPDF_FORMHANDLE,
4388 annot: FPDF_ANNOTATION,
4389 index: ::std::os::raw::c_int,
4390 buffer: *mut FPDF_WCHAR,
4391 buflen: ::std::os::raw::c_ulong,
4392 ) -> ::std::os::raw::c_ulong;
4393}
4394unsafe extern "C" {
4395 #[doc = " Experimental API.\n Determine whether or not the option at |index| in |annot|'s \"Opt\" dictionary\n is selected. Intended for use with listbox and combobox widget annotations.\n\n handle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n index - numeric index of the option in the \"Opt\" array.\n\n Returns true if the option at |index| in |annot|'s \"Opt\" dictionary is\n selected, false otherwise."]
4396 pub fn FPDFAnnot_IsOptionSelected(
4397 handle: FPDF_FORMHANDLE,
4398 annot: FPDF_ANNOTATION,
4399 index: ::std::os::raw::c_int,
4400 ) -> FPDF_BOOL;
4401}
4402unsafe extern "C" {
4403 #[doc = " Experimental API.\n Get the float value of the font size for an |annot| with variable text.\n If 0, the font is to be auto-sized: its size is computed as a function of\n the height of the annotation rectangle.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n value - Required. Float which will be set to font size on success.\n\n Returns true if the font size was set in |value|, false on error or if\n |value| not provided."]
4404 pub fn FPDFAnnot_GetFontSize(
4405 hHandle: FPDF_FORMHANDLE,
4406 annot: FPDF_ANNOTATION,
4407 value: *mut f32,
4408 ) -> FPDF_BOOL;
4409}
4410unsafe extern "C" {
4411 #[doc = " Experimental API.\n Set the text color of an annotation.\n\n handle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n R - the red component for the text color.\n G - the green component for the text color.\n B - the blue component for the text color.\n\n Returns true if successful.\n\n Currently supported subtypes: freetext.\n The range for the color components is 0 to 255."]
4412 pub fn FPDFAnnot_SetFontColor(
4413 handle: FPDF_FORMHANDLE,
4414 annot: FPDF_ANNOTATION,
4415 R: ::std::os::raw::c_uint,
4416 G: ::std::os::raw::c_uint,
4417 B: ::std::os::raw::c_uint,
4418 ) -> FPDF_BOOL;
4419}
4420unsafe extern "C" {
4421 #[doc = " Experimental API.\n Get the RGB value of the font color for an |annot| with variable text.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.\n\n Returns true if the font color was set, false on error or if the font\n color was not provided."]
4422 pub fn FPDFAnnot_GetFontColor(
4423 hHandle: FPDF_FORMHANDLE,
4424 annot: FPDF_ANNOTATION,
4425 R: *mut ::std::os::raw::c_uint,
4426 G: *mut ::std::os::raw::c_uint,
4427 B: *mut ::std::os::raw::c_uint,
4428 ) -> FPDF_BOOL;
4429}
4430unsafe extern "C" {
4431 #[doc = " Experimental API.\n Determine if |annot| is a form widget that is checked. Intended for use with\n checkbox and radio button widgets.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n\n Returns true if |annot| is a form widget and is checked, false otherwise."]
4432 pub fn FPDFAnnot_IsChecked(hHandle: FPDF_FORMHANDLE, annot: FPDF_ANNOTATION) -> FPDF_BOOL;
4433}
4434unsafe extern "C" {
4435 #[doc = " Experimental API.\n Set the list of focusable annotation subtypes. Annotations of subtype\n FPDF_ANNOT_WIDGET are by default focusable. New subtypes set using this API\n will override the existing subtypes.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n subtypes - list of annotation subtype which can be tabbed over.\n count - total number of annotation subtype in list.\n Returns true if list of annotation subtype is set successfully, false\n otherwise."]
4436 pub fn FPDFAnnot_SetFocusableSubtypes(
4437 hHandle: FPDF_FORMHANDLE,
4438 subtypes: *const FPDF_ANNOTATION_SUBTYPE,
4439 count: usize,
4440 ) -> FPDF_BOOL;
4441}
4442unsafe extern "C" {
4443 #[doc = " Experimental API.\n Get the count of focusable annotation subtypes as set by host\n for a |hHandle|.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n Returns the count of focusable annotation subtypes or -1 on error.\n Note : Annotations of type FPDF_ANNOT_WIDGET are by default focusable."]
4444 pub fn FPDFAnnot_GetFocusableSubtypesCount(hHandle: FPDF_FORMHANDLE) -> ::std::os::raw::c_int;
4445}
4446unsafe extern "C" {
4447 #[doc = " Experimental API.\n Get the list of focusable annotation subtype as set by host.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n subtypes - receives the list of annotation subtype which can be tabbed\n over. Caller must have allocated |subtypes| more than or\n equal to the count obtained from\n FPDFAnnot_GetFocusableSubtypesCount() API.\n count - size of |subtypes|.\n Returns true on success and set list of annotation subtype to |subtypes|,\n false otherwise.\n Note : Annotations of type FPDF_ANNOT_WIDGET are by default focusable."]
4448 pub fn FPDFAnnot_GetFocusableSubtypes(
4449 hHandle: FPDF_FORMHANDLE,
4450 subtypes: *mut FPDF_ANNOTATION_SUBTYPE,
4451 count: usize,
4452 ) -> FPDF_BOOL;
4453}
4454unsafe extern "C" {
4455 #[doc = " Experimental API.\n Gets FPDF_LINK object for |annot|. Intended to use for link annotations.\n\n annot - handle to an annotation.\n\n Returns FPDF_LINK from the FPDF_ANNOTATION and NULL on failure,\n if the input annot is NULL or input annot's subtype is not link."]
4456 pub fn FPDFAnnot_GetLink(annot: FPDF_ANNOTATION) -> FPDF_LINK;
4457}
4458unsafe extern "C" {
4459 #[doc = " Experimental API.\n Gets the count of annotations in the |annot|'s control group.\n A group of interactive form annotations is collectively called a form\n control group. Here, |annot|, an interactive form annotation, should be\n either a radio button or a checkbox.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n\n Returns number of controls in its control group or -1 on error."]
4460 pub fn FPDFAnnot_GetFormControlCount(
4461 hHandle: FPDF_FORMHANDLE,
4462 annot: FPDF_ANNOTATION,
4463 ) -> ::std::os::raw::c_int;
4464}
4465unsafe extern "C" {
4466 #[doc = " Experimental API.\n Gets the index of |annot| in |annot|'s control group.\n A group of interactive form annotations is collectively called a form\n control group. Here, |annot|, an interactive form annotation, should be\n either a radio button or a checkbox.\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n\n Returns index of a given |annot| in its control group or -1 on error."]
4467 pub fn FPDFAnnot_GetFormControlIndex(
4468 hHandle: FPDF_FORMHANDLE,
4469 annot: FPDF_ANNOTATION,
4470 ) -> ::std::os::raw::c_int;
4471}
4472unsafe extern "C" {
4473 #[doc = " Experimental API.\n Gets the export value of |annot| which is an interactive form annotation.\n Intended for use with radio button and checkbox widget annotations.\n |buffer| is only modified if |buflen| is longer than the length of contents.\n In case of error, nothing will be added to |buffer| and the return value\n will be 0. Note that return value of empty string is 2 for \"\\0\\0\".\n\n hHandle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n buffer - buffer for holding the value string, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the string value in bytes."]
4474 pub fn FPDFAnnot_GetFormFieldExportValue(
4475 hHandle: FPDF_FORMHANDLE,
4476 annot: FPDF_ANNOTATION,
4477 buffer: *mut FPDF_WCHAR,
4478 buflen: ::std::os::raw::c_ulong,
4479 ) -> ::std::os::raw::c_ulong;
4480}
4481unsafe extern "C" {
4482 #[doc = " Experimental API.\n Add a URI action to |annot|, overwriting the existing action, if any.\n\n annot - handle to a link annotation.\n uri - the URI to be set, encoded in 7-bit ASCII.\n\n Returns true if successful."]
4483 pub fn FPDFAnnot_SetURI(
4484 annot: FPDF_ANNOTATION,
4485 uri: *const ::std::os::raw::c_char,
4486 ) -> FPDF_BOOL;
4487}
4488unsafe extern "C" {
4489 #[doc = " Experimental API.\n Get the attachment from |annot|.\n\n annot - handle to a file annotation.\n\n Returns the handle to the attachment object, or NULL on failure."]
4490 pub fn FPDFAnnot_GetFileAttachment(annot: FPDF_ANNOTATION) -> FPDF_ATTACHMENT;
4491}
4492unsafe extern "C" {
4493 #[doc = " Experimental API.\n Add an embedded file with |name| to |annot|.\n\n annot - handle to a file annotation.\n name - name of the new attachment.\n\n Returns a handle to the new attachment object, or NULL on failure."]
4494 pub fn FPDFAnnot_AddFileAttachment(
4495 annot: FPDF_ANNOTATION,
4496 name: FPDF_WIDESTRING,
4497 ) -> FPDF_ATTACHMENT;
4498}
4499unsafe extern "C" {
4500 #[doc = " Experimental API.\n Get the number of embedded files in |document|.\n\n document - handle to a document.\n\n Returns the number of embedded files in |document|."]
4501 pub fn FPDFDoc_GetAttachmentCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
4502}
4503unsafe extern "C" {
4504 #[doc = " Experimental API.\n Add an embedded file with |name| in |document|. If |name| is empty, or if\n |name| is the name of a existing embedded file in |document|, or if\n |document|'s embedded file name tree is too deep (i.e. |document| has too\n many embedded files already), then a new attachment will not be added.\n\n document - handle to a document.\n name - name of the new attachment.\n\n Returns a handle to the new attachment object, or NULL on failure."]
4505 pub fn FPDFDoc_AddAttachment(document: FPDF_DOCUMENT, name: FPDF_WIDESTRING)
4506 -> FPDF_ATTACHMENT;
4507}
4508unsafe extern "C" {
4509 #[doc = " Experimental API.\n Get the embedded attachment at |index| in |document|. Note that the returned\n attachment handle is only valid while |document| is open.\n\n document - handle to a document.\n index - the index of the requested embedded file.\n\n Returns the handle to the attachment object, or NULL on failure."]
4510 pub fn FPDFDoc_GetAttachment(
4511 document: FPDF_DOCUMENT,
4512 index: ::std::os::raw::c_int,
4513 ) -> FPDF_ATTACHMENT;
4514}
4515unsafe extern "C" {
4516 #[doc = " Experimental API.\n Delete the embedded attachment at |index| in |document|. Note that this does\n not remove the attachment data from the PDF file; it simply removes the\n file's entry in the embedded files name tree so that it does not appear in\n the attachment list. This behavior may change in the future.\n\n document - handle to a document.\n index - the index of the embedded file to be deleted.\n\n Returns true if successful."]
4517 pub fn FPDFDoc_DeleteAttachment(
4518 document: FPDF_DOCUMENT,
4519 index: ::std::os::raw::c_int,
4520 ) -> FPDF_BOOL;
4521}
4522unsafe extern "C" {
4523 #[doc = " Experimental API.\n Get the name of the |attachment| file. |buffer| is only modified if |buflen|\n is longer than the length of the file name. On errors, |buffer| is unmodified\n and the returned length is 0.\n\n attachment - handle to an attachment.\n buffer - buffer for holding the file name, encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the file name in bytes."]
4524 pub fn FPDFAttachment_GetName(
4525 attachment: FPDF_ATTACHMENT,
4526 buffer: *mut FPDF_WCHAR,
4527 buflen: ::std::os::raw::c_ulong,
4528 ) -> ::std::os::raw::c_ulong;
4529}
4530unsafe extern "C" {
4531 #[doc = " Experimental API.\n Check if the params dictionary of |attachment| has |key| as a key.\n\n attachment - handle to an attachment.\n key - the key to look for, encoded in UTF-8.\n\n Returns true if |key| exists."]
4532 pub fn FPDFAttachment_HasKey(attachment: FPDF_ATTACHMENT, key: FPDF_BYTESTRING) -> FPDF_BOOL;
4533}
4534unsafe extern "C" {
4535 #[doc = " Experimental API.\n Get the type of the value corresponding to |key| in the params dictionary of\n the embedded |attachment|.\n\n attachment - handle to an attachment.\n key - the key to look for, encoded in UTF-8.\n\n Returns the type of the dictionary value."]
4536 pub fn FPDFAttachment_GetValueType(
4537 attachment: FPDF_ATTACHMENT,
4538 key: FPDF_BYTESTRING,
4539 ) -> FPDF_OBJECT_TYPE;
4540}
4541unsafe extern "C" {
4542 #[doc = " Experimental API.\n Set the string value corresponding to |key| in the params dictionary of the\n embedded file |attachment|, overwriting the existing value if any. The value\n type should be FPDF_OBJECT_STRING after this function call succeeds.\n\n attachment - handle to an attachment.\n key - the key to the dictionary entry, encoded in UTF-8.\n value - the string value to be set, encoded in UTF-16LE.\n\n Returns true if successful."]
4543 pub fn FPDFAttachment_SetStringValue(
4544 attachment: FPDF_ATTACHMENT,
4545 key: FPDF_BYTESTRING,
4546 value: FPDF_WIDESTRING,
4547 ) -> FPDF_BOOL;
4548}
4549unsafe extern "C" {
4550 #[doc = " Experimental API.\n Get the string value corresponding to |key| in the params dictionary of the\n embedded file |attachment|. |buffer| is only modified if |buflen| is longer\n than the length of the string value. Note that if |key| does not exist in the\n dictionary or if |key|'s corresponding value in the dictionary is not a\n string (i.e. the value is not of type FPDF_OBJECT_STRING or\n FPDF_OBJECT_NAME), then an empty string would be copied to |buffer| and the\n return value would be 2. On other errors, nothing would be added to |buffer|\n and the return value would be 0.\n\n attachment - handle to an attachment.\n key - the key to the requested string value, encoded in UTF-8.\n buffer - buffer for holding the string value encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the dictionary value string in bytes."]
4551 pub fn FPDFAttachment_GetStringValue(
4552 attachment: FPDF_ATTACHMENT,
4553 key: FPDF_BYTESTRING,
4554 buffer: *mut FPDF_WCHAR,
4555 buflen: ::std::os::raw::c_ulong,
4556 ) -> ::std::os::raw::c_ulong;
4557}
4558unsafe extern "C" {
4559 #[doc = " Experimental API.\n Set the file data of |attachment|, overwriting the existing file data if any.\n The creation date and checksum will be updated, while all other dictionary\n entries will be deleted. Note that only contents with |len| smaller than\n INT_MAX is supported.\n\n attachment - handle to an attachment.\n contents - buffer holding the file data to write to |attachment|.\n len - length of file data in bytes.\n\n Returns true if successful."]
4560 pub fn FPDFAttachment_SetFile(
4561 attachment: FPDF_ATTACHMENT,
4562 document: FPDF_DOCUMENT,
4563 contents: *const ::std::os::raw::c_void,
4564 len: ::std::os::raw::c_ulong,
4565 ) -> FPDF_BOOL;
4566}
4567unsafe extern "C" {
4568 #[doc = " Experimental API.\n Get the file data of |attachment|.\n When the attachment file data is readable, true is returned, and |out_buflen|\n is updated to indicate the file data size. |buffer| is only modified if\n |buflen| is non-null and long enough to contain the entire file data. Callers\n must check both the return value and the input |buflen| is no less than the\n returned |out_buflen| before using the data.\n\n Otherwise, when the attachment file data is unreadable or when |out_buflen|\n is null, false is returned and |buffer| and |out_buflen| remain unmodified.\n\n attachment - handle to an attachment.\n buffer - buffer for holding the file data from |attachment|.\n buflen - length of the buffer in bytes.\n out_buflen - pointer to the variable that will receive the minimum buffer\n size to contain the file data of |attachment|.\n\n Returns true on success, false otherwise."]
4569 pub fn FPDFAttachment_GetFile(
4570 attachment: FPDF_ATTACHMENT,
4571 buffer: *mut ::std::os::raw::c_void,
4572 buflen: ::std::os::raw::c_ulong,
4573 out_buflen: *mut ::std::os::raw::c_ulong,
4574 ) -> FPDF_BOOL;
4575}
4576unsafe extern "C" {
4577 #[doc = " Experimental API.\n Get the MIME type (Subtype) of the embedded file |attachment|. |buffer| is\n only modified if |buflen| is longer than the length of the MIME type string.\n If the Subtype is not found or if there is no file stream, an empty string\n would be copied to |buffer| and the return value would be 2. On other errors,\n nothing would be added to |buffer| and the return value would be 0.\n\n attachment - handle to an attachment.\n buffer - buffer for holding the MIME type string encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the MIME type string in bytes."]
4578 pub fn FPDFAttachment_GetSubtype(
4579 attachment: FPDF_ATTACHMENT,
4580 buffer: *mut FPDF_WCHAR,
4581 buflen: ::std::os::raw::c_ulong,
4582 ) -> ::std::os::raw::c_ulong;
4583}
4584pub const FWL_EVENTFLAG_FWL_EVENTFLAG_ShiftKey: FWL_EVENTFLAG = 1;
4585pub const FWL_EVENTFLAG_FWL_EVENTFLAG_ControlKey: FWL_EVENTFLAG = 2;
4586pub const FWL_EVENTFLAG_FWL_EVENTFLAG_AltKey: FWL_EVENTFLAG = 4;
4587pub const FWL_EVENTFLAG_FWL_EVENTFLAG_MetaKey: FWL_EVENTFLAG = 8;
4588pub const FWL_EVENTFLAG_FWL_EVENTFLAG_KeyPad: FWL_EVENTFLAG = 16;
4589pub const FWL_EVENTFLAG_FWL_EVENTFLAG_AutoRepeat: FWL_EVENTFLAG = 32;
4590pub const FWL_EVENTFLAG_FWL_EVENTFLAG_LeftButtonDown: FWL_EVENTFLAG = 64;
4591pub const FWL_EVENTFLAG_FWL_EVENTFLAG_MiddleButtonDown: FWL_EVENTFLAG = 128;
4592pub const FWL_EVENTFLAG_FWL_EVENTFLAG_RightButtonDown: FWL_EVENTFLAG = 256;
4593#[doc = " Key flags."]
4594pub type FWL_EVENTFLAG = ::std::os::raw::c_uint;
4595pub const FWL_VKEYCODE_FWL_VKEY_Back: FWL_VKEYCODE = 8;
4596pub const FWL_VKEYCODE_FWL_VKEY_Tab: FWL_VKEYCODE = 9;
4597pub const FWL_VKEYCODE_FWL_VKEY_NewLine: FWL_VKEYCODE = 10;
4598pub const FWL_VKEYCODE_FWL_VKEY_Clear: FWL_VKEYCODE = 12;
4599pub const FWL_VKEYCODE_FWL_VKEY_Return: FWL_VKEYCODE = 13;
4600pub const FWL_VKEYCODE_FWL_VKEY_Shift: FWL_VKEYCODE = 16;
4601pub const FWL_VKEYCODE_FWL_VKEY_Control: FWL_VKEYCODE = 17;
4602pub const FWL_VKEYCODE_FWL_VKEY_Menu: FWL_VKEYCODE = 18;
4603pub const FWL_VKEYCODE_FWL_VKEY_Pause: FWL_VKEYCODE = 19;
4604pub const FWL_VKEYCODE_FWL_VKEY_Capital: FWL_VKEYCODE = 20;
4605pub const FWL_VKEYCODE_FWL_VKEY_Kana: FWL_VKEYCODE = 21;
4606pub const FWL_VKEYCODE_FWL_VKEY_Hangul: FWL_VKEYCODE = 21;
4607pub const FWL_VKEYCODE_FWL_VKEY_Junja: FWL_VKEYCODE = 23;
4608pub const FWL_VKEYCODE_FWL_VKEY_Final: FWL_VKEYCODE = 24;
4609pub const FWL_VKEYCODE_FWL_VKEY_Hanja: FWL_VKEYCODE = 25;
4610pub const FWL_VKEYCODE_FWL_VKEY_Kanji: FWL_VKEYCODE = 25;
4611pub const FWL_VKEYCODE_FWL_VKEY_Escape: FWL_VKEYCODE = 27;
4612pub const FWL_VKEYCODE_FWL_VKEY_Convert: FWL_VKEYCODE = 28;
4613pub const FWL_VKEYCODE_FWL_VKEY_NonConvert: FWL_VKEYCODE = 29;
4614pub const FWL_VKEYCODE_FWL_VKEY_Accept: FWL_VKEYCODE = 30;
4615pub const FWL_VKEYCODE_FWL_VKEY_ModeChange: FWL_VKEYCODE = 31;
4616pub const FWL_VKEYCODE_FWL_VKEY_Space: FWL_VKEYCODE = 32;
4617pub const FWL_VKEYCODE_FWL_VKEY_Prior: FWL_VKEYCODE = 33;
4618pub const FWL_VKEYCODE_FWL_VKEY_Next: FWL_VKEYCODE = 34;
4619pub const FWL_VKEYCODE_FWL_VKEY_End: FWL_VKEYCODE = 35;
4620pub const FWL_VKEYCODE_FWL_VKEY_Home: FWL_VKEYCODE = 36;
4621pub const FWL_VKEYCODE_FWL_VKEY_Left: FWL_VKEYCODE = 37;
4622pub const FWL_VKEYCODE_FWL_VKEY_Up: FWL_VKEYCODE = 38;
4623pub const FWL_VKEYCODE_FWL_VKEY_Right: FWL_VKEYCODE = 39;
4624pub const FWL_VKEYCODE_FWL_VKEY_Down: FWL_VKEYCODE = 40;
4625pub const FWL_VKEYCODE_FWL_VKEY_Select: FWL_VKEYCODE = 41;
4626pub const FWL_VKEYCODE_FWL_VKEY_Print: FWL_VKEYCODE = 42;
4627pub const FWL_VKEYCODE_FWL_VKEY_Execute: FWL_VKEYCODE = 43;
4628pub const FWL_VKEYCODE_FWL_VKEY_Snapshot: FWL_VKEYCODE = 44;
4629pub const FWL_VKEYCODE_FWL_VKEY_Insert: FWL_VKEYCODE = 45;
4630pub const FWL_VKEYCODE_FWL_VKEY_Delete: FWL_VKEYCODE = 46;
4631pub const FWL_VKEYCODE_FWL_VKEY_Help: FWL_VKEYCODE = 47;
4632pub const FWL_VKEYCODE_FWL_VKEY_0: FWL_VKEYCODE = 48;
4633pub const FWL_VKEYCODE_FWL_VKEY_1: FWL_VKEYCODE = 49;
4634pub const FWL_VKEYCODE_FWL_VKEY_2: FWL_VKEYCODE = 50;
4635pub const FWL_VKEYCODE_FWL_VKEY_3: FWL_VKEYCODE = 51;
4636pub const FWL_VKEYCODE_FWL_VKEY_4: FWL_VKEYCODE = 52;
4637pub const FWL_VKEYCODE_FWL_VKEY_5: FWL_VKEYCODE = 53;
4638pub const FWL_VKEYCODE_FWL_VKEY_6: FWL_VKEYCODE = 54;
4639pub const FWL_VKEYCODE_FWL_VKEY_7: FWL_VKEYCODE = 55;
4640pub const FWL_VKEYCODE_FWL_VKEY_8: FWL_VKEYCODE = 56;
4641pub const FWL_VKEYCODE_FWL_VKEY_9: FWL_VKEYCODE = 57;
4642pub const FWL_VKEYCODE_FWL_VKEY_A: FWL_VKEYCODE = 65;
4643pub const FWL_VKEYCODE_FWL_VKEY_B: FWL_VKEYCODE = 66;
4644pub const FWL_VKEYCODE_FWL_VKEY_C: FWL_VKEYCODE = 67;
4645pub const FWL_VKEYCODE_FWL_VKEY_D: FWL_VKEYCODE = 68;
4646pub const FWL_VKEYCODE_FWL_VKEY_E: FWL_VKEYCODE = 69;
4647pub const FWL_VKEYCODE_FWL_VKEY_F: FWL_VKEYCODE = 70;
4648pub const FWL_VKEYCODE_FWL_VKEY_G: FWL_VKEYCODE = 71;
4649pub const FWL_VKEYCODE_FWL_VKEY_H: FWL_VKEYCODE = 72;
4650pub const FWL_VKEYCODE_FWL_VKEY_I: FWL_VKEYCODE = 73;
4651pub const FWL_VKEYCODE_FWL_VKEY_J: FWL_VKEYCODE = 74;
4652pub const FWL_VKEYCODE_FWL_VKEY_K: FWL_VKEYCODE = 75;
4653pub const FWL_VKEYCODE_FWL_VKEY_L: FWL_VKEYCODE = 76;
4654pub const FWL_VKEYCODE_FWL_VKEY_M: FWL_VKEYCODE = 77;
4655pub const FWL_VKEYCODE_FWL_VKEY_N: FWL_VKEYCODE = 78;
4656pub const FWL_VKEYCODE_FWL_VKEY_O: FWL_VKEYCODE = 79;
4657pub const FWL_VKEYCODE_FWL_VKEY_P: FWL_VKEYCODE = 80;
4658pub const FWL_VKEYCODE_FWL_VKEY_Q: FWL_VKEYCODE = 81;
4659pub const FWL_VKEYCODE_FWL_VKEY_R: FWL_VKEYCODE = 82;
4660pub const FWL_VKEYCODE_FWL_VKEY_S: FWL_VKEYCODE = 83;
4661pub const FWL_VKEYCODE_FWL_VKEY_T: FWL_VKEYCODE = 84;
4662pub const FWL_VKEYCODE_FWL_VKEY_U: FWL_VKEYCODE = 85;
4663pub const FWL_VKEYCODE_FWL_VKEY_V: FWL_VKEYCODE = 86;
4664pub const FWL_VKEYCODE_FWL_VKEY_W: FWL_VKEYCODE = 87;
4665pub const FWL_VKEYCODE_FWL_VKEY_X: FWL_VKEYCODE = 88;
4666pub const FWL_VKEYCODE_FWL_VKEY_Y: FWL_VKEYCODE = 89;
4667pub const FWL_VKEYCODE_FWL_VKEY_Z: FWL_VKEYCODE = 90;
4668pub const FWL_VKEYCODE_FWL_VKEY_LWin: FWL_VKEYCODE = 91;
4669pub const FWL_VKEYCODE_FWL_VKEY_Command: FWL_VKEYCODE = 91;
4670pub const FWL_VKEYCODE_FWL_VKEY_RWin: FWL_VKEYCODE = 92;
4671pub const FWL_VKEYCODE_FWL_VKEY_Apps: FWL_VKEYCODE = 93;
4672pub const FWL_VKEYCODE_FWL_VKEY_Sleep: FWL_VKEYCODE = 95;
4673pub const FWL_VKEYCODE_FWL_VKEY_NumPad0: FWL_VKEYCODE = 96;
4674pub const FWL_VKEYCODE_FWL_VKEY_NumPad1: FWL_VKEYCODE = 97;
4675pub const FWL_VKEYCODE_FWL_VKEY_NumPad2: FWL_VKEYCODE = 98;
4676pub const FWL_VKEYCODE_FWL_VKEY_NumPad3: FWL_VKEYCODE = 99;
4677pub const FWL_VKEYCODE_FWL_VKEY_NumPad4: FWL_VKEYCODE = 100;
4678pub const FWL_VKEYCODE_FWL_VKEY_NumPad5: FWL_VKEYCODE = 101;
4679pub const FWL_VKEYCODE_FWL_VKEY_NumPad6: FWL_VKEYCODE = 102;
4680pub const FWL_VKEYCODE_FWL_VKEY_NumPad7: FWL_VKEYCODE = 103;
4681pub const FWL_VKEYCODE_FWL_VKEY_NumPad8: FWL_VKEYCODE = 104;
4682pub const FWL_VKEYCODE_FWL_VKEY_NumPad9: FWL_VKEYCODE = 105;
4683pub const FWL_VKEYCODE_FWL_VKEY_Multiply: FWL_VKEYCODE = 106;
4684pub const FWL_VKEYCODE_FWL_VKEY_Add: FWL_VKEYCODE = 107;
4685pub const FWL_VKEYCODE_FWL_VKEY_Separator: FWL_VKEYCODE = 108;
4686pub const FWL_VKEYCODE_FWL_VKEY_Subtract: FWL_VKEYCODE = 109;
4687pub const FWL_VKEYCODE_FWL_VKEY_Decimal: FWL_VKEYCODE = 110;
4688pub const FWL_VKEYCODE_FWL_VKEY_Divide: FWL_VKEYCODE = 111;
4689pub const FWL_VKEYCODE_FWL_VKEY_F1: FWL_VKEYCODE = 112;
4690pub const FWL_VKEYCODE_FWL_VKEY_F2: FWL_VKEYCODE = 113;
4691pub const FWL_VKEYCODE_FWL_VKEY_F3: FWL_VKEYCODE = 114;
4692pub const FWL_VKEYCODE_FWL_VKEY_F4: FWL_VKEYCODE = 115;
4693pub const FWL_VKEYCODE_FWL_VKEY_F5: FWL_VKEYCODE = 116;
4694pub const FWL_VKEYCODE_FWL_VKEY_F6: FWL_VKEYCODE = 117;
4695pub const FWL_VKEYCODE_FWL_VKEY_F7: FWL_VKEYCODE = 118;
4696pub const FWL_VKEYCODE_FWL_VKEY_F8: FWL_VKEYCODE = 119;
4697pub const FWL_VKEYCODE_FWL_VKEY_F9: FWL_VKEYCODE = 120;
4698pub const FWL_VKEYCODE_FWL_VKEY_F10: FWL_VKEYCODE = 121;
4699pub const FWL_VKEYCODE_FWL_VKEY_F11: FWL_VKEYCODE = 122;
4700pub const FWL_VKEYCODE_FWL_VKEY_F12: FWL_VKEYCODE = 123;
4701pub const FWL_VKEYCODE_FWL_VKEY_F13: FWL_VKEYCODE = 124;
4702pub const FWL_VKEYCODE_FWL_VKEY_F14: FWL_VKEYCODE = 125;
4703pub const FWL_VKEYCODE_FWL_VKEY_F15: FWL_VKEYCODE = 126;
4704pub const FWL_VKEYCODE_FWL_VKEY_F16: FWL_VKEYCODE = 127;
4705pub const FWL_VKEYCODE_FWL_VKEY_F17: FWL_VKEYCODE = 128;
4706pub const FWL_VKEYCODE_FWL_VKEY_F18: FWL_VKEYCODE = 129;
4707pub const FWL_VKEYCODE_FWL_VKEY_F19: FWL_VKEYCODE = 130;
4708pub const FWL_VKEYCODE_FWL_VKEY_F20: FWL_VKEYCODE = 131;
4709pub const FWL_VKEYCODE_FWL_VKEY_F21: FWL_VKEYCODE = 132;
4710pub const FWL_VKEYCODE_FWL_VKEY_F22: FWL_VKEYCODE = 133;
4711pub const FWL_VKEYCODE_FWL_VKEY_F23: FWL_VKEYCODE = 134;
4712pub const FWL_VKEYCODE_FWL_VKEY_F24: FWL_VKEYCODE = 135;
4713pub const FWL_VKEYCODE_FWL_VKEY_NunLock: FWL_VKEYCODE = 144;
4714pub const FWL_VKEYCODE_FWL_VKEY_Scroll: FWL_VKEYCODE = 145;
4715pub const FWL_VKEYCODE_FWL_VKEY_LShift: FWL_VKEYCODE = 160;
4716pub const FWL_VKEYCODE_FWL_VKEY_RShift: FWL_VKEYCODE = 161;
4717pub const FWL_VKEYCODE_FWL_VKEY_LControl: FWL_VKEYCODE = 162;
4718pub const FWL_VKEYCODE_FWL_VKEY_RControl: FWL_VKEYCODE = 163;
4719pub const FWL_VKEYCODE_FWL_VKEY_LMenu: FWL_VKEYCODE = 164;
4720pub const FWL_VKEYCODE_FWL_VKEY_RMenu: FWL_VKEYCODE = 165;
4721pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Back: FWL_VKEYCODE = 166;
4722pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Forward: FWL_VKEYCODE = 167;
4723pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Refresh: FWL_VKEYCODE = 168;
4724pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Stop: FWL_VKEYCODE = 169;
4725pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Search: FWL_VKEYCODE = 170;
4726pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Favorites: FWL_VKEYCODE = 171;
4727pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Home: FWL_VKEYCODE = 172;
4728pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Mute: FWL_VKEYCODE = 173;
4729pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Down: FWL_VKEYCODE = 174;
4730pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Up: FWL_VKEYCODE = 175;
4731pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_NEXT_Track: FWL_VKEYCODE = 176;
4732pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_PREV_Track: FWL_VKEYCODE = 177;
4733pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_Stop: FWL_VKEYCODE = 178;
4734pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_PLAY_Pause: FWL_VKEYCODE = 179;
4735pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_Mail: FWL_VKEYCODE = 180;
4736pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_MEDIA_Select: FWL_VKEYCODE = 181;
4737pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_APP1: FWL_VKEYCODE = 182;
4738pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_APP2: FWL_VKEYCODE = 183;
4739pub const FWL_VKEYCODE_FWL_VKEY_OEM_1: FWL_VKEYCODE = 186;
4740pub const FWL_VKEYCODE_FWL_VKEY_OEM_Plus: FWL_VKEYCODE = 187;
4741pub const FWL_VKEYCODE_FWL_VKEY_OEM_Comma: FWL_VKEYCODE = 188;
4742pub const FWL_VKEYCODE_FWL_VKEY_OEM_Minus: FWL_VKEYCODE = 189;
4743pub const FWL_VKEYCODE_FWL_VKEY_OEM_Period: FWL_VKEYCODE = 190;
4744pub const FWL_VKEYCODE_FWL_VKEY_OEM_2: FWL_VKEYCODE = 191;
4745pub const FWL_VKEYCODE_FWL_VKEY_OEM_3: FWL_VKEYCODE = 192;
4746pub const FWL_VKEYCODE_FWL_VKEY_OEM_4: FWL_VKEYCODE = 219;
4747pub const FWL_VKEYCODE_FWL_VKEY_OEM_5: FWL_VKEYCODE = 220;
4748pub const FWL_VKEYCODE_FWL_VKEY_OEM_6: FWL_VKEYCODE = 221;
4749pub const FWL_VKEYCODE_FWL_VKEY_OEM_7: FWL_VKEYCODE = 222;
4750pub const FWL_VKEYCODE_FWL_VKEY_OEM_8: FWL_VKEYCODE = 223;
4751pub const FWL_VKEYCODE_FWL_VKEY_OEM_102: FWL_VKEYCODE = 226;
4752pub const FWL_VKEYCODE_FWL_VKEY_ProcessKey: FWL_VKEYCODE = 229;
4753pub const FWL_VKEYCODE_FWL_VKEY_Packet: FWL_VKEYCODE = 231;
4754pub const FWL_VKEYCODE_FWL_VKEY_Attn: FWL_VKEYCODE = 246;
4755pub const FWL_VKEYCODE_FWL_VKEY_Crsel: FWL_VKEYCODE = 247;
4756pub const FWL_VKEYCODE_FWL_VKEY_Exsel: FWL_VKEYCODE = 248;
4757pub const FWL_VKEYCODE_FWL_VKEY_Ereof: FWL_VKEYCODE = 249;
4758pub const FWL_VKEYCODE_FWL_VKEY_Play: FWL_VKEYCODE = 250;
4759pub const FWL_VKEYCODE_FWL_VKEY_Zoom: FWL_VKEYCODE = 251;
4760pub const FWL_VKEYCODE_FWL_VKEY_NoName: FWL_VKEYCODE = 252;
4761pub const FWL_VKEYCODE_FWL_VKEY_PA1: FWL_VKEYCODE = 253;
4762pub const FWL_VKEYCODE_FWL_VKEY_OEM_Clear: FWL_VKEYCODE = 254;
4763pub const FWL_VKEYCODE_FWL_VKEY_Unknown: FWL_VKEYCODE = 0;
4764#[doc = " Virtual keycodes."]
4765pub type FWL_VKEYCODE = ::std::os::raw::c_uint;
4766pub const FPDF_FILEIDTYPE_FILEIDTYPE_PERMANENT: FPDF_FILEIDTYPE = 0;
4767pub const FPDF_FILEIDTYPE_FILEIDTYPE_CHANGING: FPDF_FILEIDTYPE = 1;
4768#[doc = " The file identifier entry type. See section 14.4 \"File Identifiers\" of the\n ISO 32000-1:2008 spec."]
4769pub type FPDF_FILEIDTYPE = ::std::os::raw::c_uint;
4770unsafe extern "C" {
4771 #[doc = " Get the first child of |bookmark|, or the first top-level bookmark item.\n\n document - handle to the document.\n bookmark - handle to the current bookmark. Pass NULL for the first top\n level item.\n\n Returns a handle to the first child of |bookmark| or the first top-level\n bookmark item. NULL if no child or top-level bookmark found.\n Note that another name for the bookmarks is the document outline, as\n described in ISO 32000-1:2008, section 12.3.3."]
4772 pub fn FPDFBookmark_GetFirstChild(
4773 document: FPDF_DOCUMENT,
4774 bookmark: FPDF_BOOKMARK,
4775 ) -> FPDF_BOOKMARK;
4776}
4777unsafe extern "C" {
4778 #[doc = " Get the next sibling of |bookmark|.\n\n document - handle to the document.\n bookmark - handle to the current bookmark.\n\n Returns a handle to the next sibling of |bookmark|, or NULL if this is the\n last bookmark at this level.\n\n Note that the caller is responsible for handling circular bookmark\n references, as may arise from malformed documents."]
4779 pub fn FPDFBookmark_GetNextSibling(
4780 document: FPDF_DOCUMENT,
4781 bookmark: FPDF_BOOKMARK,
4782 ) -> FPDF_BOOKMARK;
4783}
4784unsafe extern "C" {
4785 #[doc = " Get the title of |bookmark|.\n\n bookmark - handle to the bookmark.\n buffer - buffer for the title. May be NULL.\n buflen - the length of the buffer in bytes. May be 0.\n\n Returns the number of bytes in the title, including the terminating NUL\n character. The number of bytes is returned regardless of the |buffer| and\n |buflen| parameters.\n\n Regardless of the platform, the |buffer| is always in UTF-16LE encoding. The\n string is terminated by a UTF16 NUL character. If |buflen| is less than the\n required length, or |buffer| is NULL, |buffer| will not be modified."]
4786 pub fn FPDFBookmark_GetTitle(
4787 bookmark: FPDF_BOOKMARK,
4788 buffer: *mut ::std::os::raw::c_void,
4789 buflen: ::std::os::raw::c_ulong,
4790 ) -> ::std::os::raw::c_ulong;
4791}
4792unsafe extern "C" {
4793 #[doc = " Experimental API.\n Get the number of chlidren of |bookmark|.\n\n bookmark - handle to the bookmark.\n\n Returns a signed integer that represents the number of sub-items the given\n bookmark has. If the value is positive, child items shall be shown by default\n (open state). If the value is negative, child items shall be hidden by\n default (closed state). Please refer to PDF 32000-1:2008, Table 153.\n Returns 0 if the bookmark has no children or is invalid."]
4794 pub fn FPDFBookmark_GetCount(bookmark: FPDF_BOOKMARK) -> ::std::os::raw::c_int;
4795}
4796unsafe extern "C" {
4797 #[doc = " Find the bookmark with |title| in |document|.\n\n document - handle to the document.\n title - the UTF-16LE encoded Unicode title for which to search.\n\n Returns the handle to the bookmark, or NULL if |title| can't be found.\n\n FPDFBookmark_Find() will always return the first bookmark found even if\n multiple bookmarks have the same |title|."]
4798 pub fn FPDFBookmark_Find(document: FPDF_DOCUMENT, title: FPDF_WIDESTRING) -> FPDF_BOOKMARK;
4799}
4800unsafe extern "C" {
4801 #[doc = " Get the destination associated with |bookmark|.\n\n document - handle to the document.\n bookmark - handle to the bookmark.\n\n Returns the handle to the destination data, or NULL if no destination is\n associated with |bookmark|."]
4802 pub fn FPDFBookmark_GetDest(document: FPDF_DOCUMENT, bookmark: FPDF_BOOKMARK) -> FPDF_DEST;
4803}
4804unsafe extern "C" {
4805 #[doc = " Get the action associated with |bookmark|.\n\n bookmark - handle to the bookmark.\n\n Returns the handle to the action data, or NULL if no action is associated\n with |bookmark|.\n If this function returns a valid handle, it is valid as long as |bookmark| is\n valid.\n If this function returns NULL, FPDFBookmark_GetDest() should be called to get\n the |bookmark| destination data."]
4806 pub fn FPDFBookmark_GetAction(bookmark: FPDF_BOOKMARK) -> FPDF_ACTION;
4807}
4808unsafe extern "C" {
4809 #[doc = " Get the type of |action|.\n\n action - handle to the action.\n\n Returns one of:\n PDFACTION_UNSUPPORTED\n PDFACTION_GOTO\n PDFACTION_REMOTEGOTO\n PDFACTION_URI\n PDFACTION_LAUNCH"]
4810 pub fn FPDFAction_GetType(action: FPDF_ACTION) -> ::std::os::raw::c_ulong;
4811}
4812unsafe extern "C" {
4813 #[doc = " Get the destination of |action|.\n\n document - handle to the document.\n action - handle to the action. |action| must be a |PDFACTION_GOTO| or\n |PDFACTION_REMOTEGOTO|.\n\n Returns a handle to the destination data, or NULL on error, typically\n because the arguments were bad or the action was of the wrong type.\n\n In the case of |PDFACTION_REMOTEGOTO|, you must first call\n FPDFAction_GetFilePath(), then load the document at that path, then pass\n the document handle from that document as |document| to FPDFAction_GetDest()."]
4814 pub fn FPDFAction_GetDest(document: FPDF_DOCUMENT, action: FPDF_ACTION) -> FPDF_DEST;
4815}
4816unsafe extern "C" {
4817 #[doc = " Get the file path of |action|.\n\n action - handle to the action. |action| must be a |PDFACTION_LAUNCH| or\n |PDFACTION_REMOTEGOTO|.\n buffer - a buffer for output the path string. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the file path, including the trailing NUL\n character, or 0 on error, typically because the arguments were bad or the\n action was of the wrong type.\n\n Regardless of the platform, the |buffer| is always in UTF-8 encoding.\n If |buflen| is less than the returned length, or |buffer| is NULL, |buffer|\n will not be modified."]
4818 pub fn FPDFAction_GetFilePath(
4819 action: FPDF_ACTION,
4820 buffer: *mut ::std::os::raw::c_void,
4821 buflen: ::std::os::raw::c_ulong,
4822 ) -> ::std::os::raw::c_ulong;
4823}
4824unsafe extern "C" {
4825 #[doc = " Get the URI path of |action|.\n\n document - handle to the document.\n action - handle to the action. Must be a |PDFACTION_URI|.\n buffer - a buffer for the path string. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the URI path, including the trailing NUL\n character, or 0 on error, typically because the arguments were bad or the\n action was of the wrong type.\n\n The |buffer| may contain badly encoded data. The caller should validate the\n output. e.g. Check to see if it is UTF-8.\n\n If |buflen| is less than the returned length, or |buffer| is NULL, |buffer|\n will not be modified.\n\n Historically, the documentation for this API claimed |buffer| is always\n encoded in 7-bit ASCII, but did not actually enforce it.\n https://pdfium.googlesource.com/pdfium.git/+/d609e84cee2e14a18333247485af91df48a40592\n added that enforcement, but that did not work well for real world PDFs that\n used UTF-8. As of this writing, this API reverted back to its original\n behavior prior to commit d609e84cee."]
4826 pub fn FPDFAction_GetURIPath(
4827 document: FPDF_DOCUMENT,
4828 action: FPDF_ACTION,
4829 buffer: *mut ::std::os::raw::c_void,
4830 buflen: ::std::os::raw::c_ulong,
4831 ) -> ::std::os::raw::c_ulong;
4832}
4833unsafe extern "C" {
4834 #[doc = " Get the page index of |dest|.\n\n document - handle to the document.\n dest - handle to the destination.\n\n Returns the 0-based page index containing |dest|. Returns -1 on error."]
4835 pub fn FPDFDest_GetDestPageIndex(
4836 document: FPDF_DOCUMENT,
4837 dest: FPDF_DEST,
4838 ) -> ::std::os::raw::c_int;
4839}
4840unsafe extern "C" {
4841 #[doc = " Experimental API.\n Get the view (fit type) specified by |dest|.\n\n dest - handle to the destination.\n pNumParams - receives the number of view parameters, which is at most 4.\n pParams - buffer to write the view parameters. Must be at least 4\n FS_FLOATs long.\n Returns one of the PDFDEST_VIEW_* constants, PDFDEST_VIEW_UNKNOWN_MODE if\n |dest| does not specify a view."]
4842 pub fn FPDFDest_GetView(
4843 dest: FPDF_DEST,
4844 pNumParams: *mut ::std::os::raw::c_ulong,
4845 pParams: *mut FS_FLOAT,
4846 ) -> ::std::os::raw::c_ulong;
4847}
4848unsafe extern "C" {
4849 #[doc = " Get the (x, y, zoom) location of |dest| in the destination page, if the\n destination is in [page /XYZ x y zoom] syntax.\n\n dest - handle to the destination.\n hasXVal - out parameter; true if the x value is not null\n hasYVal - out parameter; true if the y value is not null\n hasZoomVal - out parameter; true if the zoom value is not null\n x - out parameter; the x coordinate, in page coordinates.\n y - out parameter; the y coordinate, in page coordinates.\n zoom - out parameter; the zoom value.\n Returns TRUE on successfully reading the /XYZ value.\n\n Note the [x, y, zoom] values are only set if the corresponding hasXVal,\n hasYVal or hasZoomVal flags are true."]
4850 pub fn FPDFDest_GetLocationInPage(
4851 dest: FPDF_DEST,
4852 hasXVal: *mut FPDF_BOOL,
4853 hasYVal: *mut FPDF_BOOL,
4854 hasZoomVal: *mut FPDF_BOOL,
4855 x: *mut FS_FLOAT,
4856 y: *mut FS_FLOAT,
4857 zoom: *mut FS_FLOAT,
4858 ) -> FPDF_BOOL;
4859}
4860unsafe extern "C" {
4861 #[doc = " Find a link at point (|x|,|y|) on |page|.\n\n page - handle to the document page.\n x - the x coordinate, in the page coordinate system.\n y - the y coordinate, in the page coordinate system.\n\n Returns a handle to the link, or NULL if no link found at the given point.\n\n You can convert coordinates from screen coordinates to page coordinates using\n FPDF_DeviceToPage()."]
4862 pub fn FPDFLink_GetLinkAtPoint(page: FPDF_PAGE, x: f64, y: f64) -> FPDF_LINK;
4863}
4864unsafe extern "C" {
4865 #[doc = " Find the Z-order of link at point (|x|,|y|) on |page|.\n\n page - handle to the document page.\n x - the x coordinate, in the page coordinate system.\n y - the y coordinate, in the page coordinate system.\n\n Returns the Z-order of the link, or -1 if no link found at the given point.\n Larger Z-order numbers are closer to the front.\n\n You can convert coordinates from screen coordinates to page coordinates using\n FPDF_DeviceToPage()."]
4866 pub fn FPDFLink_GetLinkZOrderAtPoint(page: FPDF_PAGE, x: f64, y: f64) -> ::std::os::raw::c_int;
4867}
4868unsafe extern "C" {
4869 #[doc = " Get destination info for |link|.\n\n document - handle to the document.\n link - handle to the link.\n\n Returns a handle to the destination, or NULL if there is no destination\n associated with the link. In this case, you should call FPDFLink_GetAction()\n to retrieve the action associated with |link|."]
4870 pub fn FPDFLink_GetDest(document: FPDF_DOCUMENT, link: FPDF_LINK) -> FPDF_DEST;
4871}
4872unsafe extern "C" {
4873 #[doc = " Get action info for |link|.\n\n link - handle to the link.\n\n Returns a handle to the action associated to |link|, or NULL if no action.\n If this function returns a valid handle, it is valid as long as |link| is\n valid."]
4874 pub fn FPDFLink_GetAction(link: FPDF_LINK) -> FPDF_ACTION;
4875}
4876unsafe extern "C" {
4877 #[doc = " Enumerates all the link annotations in |page|.\n\n page - handle to the page.\n start_pos - the start position, should initially be 0 and is updated with\n the next start position on return.\n link_annot - the link handle for |startPos|.\n\n Returns TRUE on success."]
4878 pub fn FPDFLink_Enumerate(
4879 page: FPDF_PAGE,
4880 start_pos: *mut ::std::os::raw::c_int,
4881 link_annot: *mut FPDF_LINK,
4882 ) -> FPDF_BOOL;
4883}
4884unsafe extern "C" {
4885 #[doc = " Experimental API.\n Gets FPDF_ANNOTATION object for |link_annot|.\n\n page - handle to the page in which FPDF_LINK object is present.\n link_annot - handle to link annotation.\n\n Returns FPDF_ANNOTATION from the FPDF_LINK and NULL on failure,\n if the input link annot or page is NULL."]
4886 pub fn FPDFLink_GetAnnot(page: FPDF_PAGE, link_annot: FPDF_LINK) -> FPDF_ANNOTATION;
4887}
4888unsafe extern "C" {
4889 #[doc = " Get the rectangle for |link_annot|.\n\n link_annot - handle to the link annotation.\n rect - the annotation rectangle.\n\n Returns true on success."]
4890 pub fn FPDFLink_GetAnnotRect(link_annot: FPDF_LINK, rect: *mut FS_RECTF) -> FPDF_BOOL;
4891}
4892unsafe extern "C" {
4893 #[doc = " Get the count of quadrilateral points to the |link_annot|.\n\n link_annot - handle to the link annotation.\n\n Returns the count of quadrilateral points."]
4894 pub fn FPDFLink_CountQuadPoints(link_annot: FPDF_LINK) -> ::std::os::raw::c_int;
4895}
4896unsafe extern "C" {
4897 #[doc = " Get the quadrilateral points for the specified |quad_index| in |link_annot|.\n\n link_annot - handle to the link annotation.\n quad_index - the specified quad point index.\n quad_points - receives the quadrilateral points.\n\n Returns true on success."]
4898 pub fn FPDFLink_GetQuadPoints(
4899 link_annot: FPDF_LINK,
4900 quad_index: ::std::os::raw::c_int,
4901 quad_points: *mut FS_QUADPOINTSF,
4902 ) -> FPDF_BOOL;
4903}
4904unsafe extern "C" {
4905 #[doc = " Experimental API\n Gets an additional-action from |page|.\n\n page - handle to the page, as returned by FPDF_LoadPage().\n aa_type - the type of the page object's addtional-action, defined\n in public/fpdf_formfill.h\n\n Returns the handle to the action data, or NULL if there is no\n additional-action of type |aa_type|.\n If this function returns a valid handle, it is valid as long as |page| is\n valid."]
4906 pub fn FPDF_GetPageAAction(page: FPDF_PAGE, aa_type: ::std::os::raw::c_int) -> FPDF_ACTION;
4907}
4908unsafe extern "C" {
4909 #[doc = " Experimental API.\n Get the file identifer defined in the trailer of |document|.\n\n document - handle to the document.\n id_type - the file identifier type to retrieve.\n buffer - a buffer for the file identifier. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the file identifier, including the NUL\n terminator.\n\n The |buffer| is always a byte string. The |buffer| is followed by a NUL\n terminator. If |buflen| is less than the returned length, or |buffer| is\n NULL, |buffer| will not be modified."]
4910 pub fn FPDF_GetFileIdentifier(
4911 document: FPDF_DOCUMENT,
4912 id_type: FPDF_FILEIDTYPE,
4913 buffer: *mut ::std::os::raw::c_void,
4914 buflen: ::std::os::raw::c_ulong,
4915 ) -> ::std::os::raw::c_ulong;
4916}
4917unsafe extern "C" {
4918 #[doc = " Get meta-data |tag| content from |document|.\n\n document - handle to the document.\n tag - the tag to retrieve. The tag can be one of:\n Title, Author, Subject, Keywords, Creator, Producer,\n CreationDate, or ModDate.\n For detailed explanations of these tags and their respective\n values, please refer to PDF Reference 1.6, section 10.2.1,\n 'Document Information Dictionary'.\n buffer - a buffer for the tag. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the tag, including trailing zeros.\n\n The |buffer| is always encoded in UTF-16LE. The |buffer| is followed by two\n bytes of zeros indicating the end of the string. If |buflen| is less than\n the returned length, or |buffer| is NULL, |buffer| will not be modified.\n\n For linearized files, FPDFAvail_IsFormAvail must be called before this, and\n it must have returned PDF_FORM_AVAIL or PDF_FORM_NOTEXIST. Before that, there\n is no guarantee the metadata has been loaded."]
4919 pub fn FPDF_GetMetaText(
4920 document: FPDF_DOCUMENT,
4921 tag: FPDF_BYTESTRING,
4922 buffer: *mut ::std::os::raw::c_void,
4923 buflen: ::std::os::raw::c_ulong,
4924 ) -> ::std::os::raw::c_ulong;
4925}
4926unsafe extern "C" {
4927 #[doc = " Get the page label for |page_index| from |document|.\n\n document - handle to the document.\n page_index - the 0-based index of the page.\n buffer - a buffer for the page label. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the page label, including trailing zeros.\n\n The |buffer| is always encoded in UTF-16LE. The |buffer| is followed by two\n bytes of zeros indicating the end of the string. If |buflen| is less than\n the returned length, or |buffer| is NULL, |buffer| will not be modified."]
4928 pub fn FPDF_GetPageLabel(
4929 document: FPDF_DOCUMENT,
4930 page_index: ::std::os::raw::c_int,
4931 buffer: *mut ::std::os::raw::c_void,
4932 buflen: ::std::os::raw::c_ulong,
4933 ) -> ::std::os::raw::c_ulong;
4934}
4935#[doc = " Structure for custom file write"]
4936#[repr(C)]
4937#[derive(Debug, Copy, Clone)]
4938pub struct FPDF_FILEWRITE_ {
4939 #[doc = "\n Version number of the interface. Currently must be 1.\n"]
4940 pub version: ::std::os::raw::c_int,
4941 #[doc = " Method: WriteBlock\n Output a block of data in your custom way.\n Interface Version:\n 1\n Implementation Required:\n Yes\n Comments:\n Called by function FPDF_SaveDocument\n Parameters:\n self - Pointer to the structure itself\n data - Pointer to a buffer to output\n size - The size of the buffer.\n Return value:\n Should be non-zero if successful, zero for error."]
4942 pub WriteBlock: ::std::option::Option<
4943 unsafe extern "C" fn(
4944 self_: *mut FPDF_FILEWRITE_,
4945 data: *const ::std::os::raw::c_void,
4946 size: ::std::os::raw::c_ulong,
4947 ) -> ::std::os::raw::c_int,
4948 >,
4949}
4950#[doc = " Structure for custom file write"]
4951pub type FPDF_FILEWRITE = FPDF_FILEWRITE_;
4952unsafe extern "C" {
4953 #[doc = " Function: FPDF_SaveAsCopy\n Saves the copy of specified document in custom way.\n Parameters:\n document - Handle to document, as returned by\n FPDF_LoadDocument() or FPDF_CreateNewDocument().\n file_write - A pointer to a custom file write structure.\n flags - Flags above that affect how the PDF gets saved.\n Pass in 0 when there are no flags.\n Return value:\n TRUE for succeed, FALSE for failed.\n"]
4954 pub fn FPDF_SaveAsCopy(
4955 document: FPDF_DOCUMENT,
4956 file_write: *mut FPDF_FILEWRITE,
4957 flags: FPDF_DWORD,
4958 ) -> FPDF_BOOL;
4959}
4960unsafe extern "C" {
4961 #[doc = " Function: FPDF_SaveWithVersion\n Same as FPDF_SaveAsCopy(), except the file version of the\n saved document can be specified by the caller.\n Parameters:\n document - Handle to document.\n file_write - A pointer to a custom file write structure.\n flags - The creating flags.\n file_version - The PDF file version. File version: 14 for 1.4,\n 15 for 1.5, ...\n Return value:\n TRUE if succeed, FALSE if failed.\n"]
4962 pub fn FPDF_SaveWithVersion(
4963 document: FPDF_DOCUMENT,
4964 file_write: *mut FPDF_FILEWRITE,
4965 flags: FPDF_DWORD,
4966 file_version: ::std::os::raw::c_int,
4967 ) -> FPDF_BOOL;
4968}
4969#[doc = " 13 = __LC_LAST."]
4970#[repr(C)]
4971#[derive(Debug, Copy, Clone)]
4972pub struct __locale_data {
4973 pub _address: u8,
4974}