1pub const _STDINT_H: u32 = 1;
4pub const _FEATURES_H: u32 = 1;
5pub const _DEFAULT_SOURCE: u32 = 1;
6pub const __GLIBC_USE_ISOC2Y: u32 = 0;
7pub const __GLIBC_USE_ISOC23: u32 = 0;
8pub const __USE_ISOC11: u32 = 1;
9pub const __USE_ISOC99: u32 = 1;
10pub const __USE_ISOC95: u32 = 1;
11pub const __USE_POSIX_IMPLICITLY: u32 = 1;
12pub const _POSIX_SOURCE: u32 = 1;
13pub const _POSIX_C_SOURCE: u32 = 200809;
14pub const __USE_POSIX: u32 = 1;
15pub const __USE_POSIX2: u32 = 1;
16pub const __USE_POSIX199309: u32 = 1;
17pub const __USE_POSIX199506: u32 = 1;
18pub const __USE_XOPEN2K: u32 = 1;
19pub const __USE_XOPEN2K8: u32 = 1;
20pub const _ATFILE_SOURCE: u32 = 1;
21pub const __WORDSIZE: u32 = 64;
22pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
23pub const __SYSCALL_WORDSIZE: u32 = 64;
24pub const __TIMESIZE: u32 = 64;
25pub const __USE_TIME_BITS64: u32 = 1;
26pub const __USE_MISC: u32 = 1;
27pub const __USE_ATFILE: u32 = 1;
28pub const __USE_FORTIFY_LEVEL: u32 = 0;
29pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
30pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
31pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
32pub const _STDC_PREDEF_H: u32 = 1;
33pub const __STDC_IEC_559__: u32 = 1;
34pub const __STDC_IEC_60559_BFP__: u32 = 201404;
35pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
36pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
37pub const __STDC_ISO_10646__: u32 = 201706;
38pub const __GNU_LIBRARY__: u32 = 6;
39pub const __GLIBC__: u32 = 2;
40pub const __GLIBC_MINOR__: u32 = 41;
41pub const _SYS_CDEFS_H: u32 = 1;
42pub const __glibc_c99_flexarr_available: u32 = 1;
43pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
44pub const __HAVE_GENERIC_SELECTION: u32 = 1;
45pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
46pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
47pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
48pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
49pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
50pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
51pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
52pub const _BITS_TYPES_H: u32 = 1;
53pub const _BITS_TYPESIZES_H: u32 = 1;
54pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
55pub const __INO_T_MATCHES_INO64_T: u32 = 1;
56pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
57pub const __STATFS_MATCHES_STATFS64: u32 = 1;
58pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
59pub const __FD_SETSIZE: u32 = 1024;
60pub const _BITS_TIME64_H: u32 = 1;
61pub const _BITS_WCHAR_H: u32 = 1;
62pub const _BITS_STDINT_INTN_H: u32 = 1;
63pub const _BITS_STDINT_UINTN_H: u32 = 1;
64pub const _BITS_STDINT_LEAST_H: u32 = 1;
65pub const INT8_MIN: i32 = -128;
66pub const INT16_MIN: i32 = -32768;
67pub const INT32_MIN: i32 = -2147483648;
68pub const INT8_MAX: u32 = 127;
69pub const INT16_MAX: u32 = 32767;
70pub const INT32_MAX: u32 = 2147483647;
71pub const UINT8_MAX: u32 = 255;
72pub const UINT16_MAX: u32 = 65535;
73pub const UINT32_MAX: u32 = 4294967295;
74pub const INT_LEAST8_MIN: i32 = -128;
75pub const INT_LEAST16_MIN: i32 = -32768;
76pub const INT_LEAST32_MIN: i32 = -2147483648;
77pub const INT_LEAST8_MAX: u32 = 127;
78pub const INT_LEAST16_MAX: u32 = 32767;
79pub const INT_LEAST32_MAX: u32 = 2147483647;
80pub const UINT_LEAST8_MAX: u32 = 255;
81pub const UINT_LEAST16_MAX: u32 = 65535;
82pub const UINT_LEAST32_MAX: u32 = 4294967295;
83pub const INT_FAST8_MIN: i32 = -128;
84pub const INT_FAST16_MIN: i64 = -9223372036854775808;
85pub const INT_FAST32_MIN: i64 = -9223372036854775808;
86pub const INT_FAST8_MAX: u32 = 127;
87pub const INT_FAST16_MAX: u64 = 9223372036854775807;
88pub const INT_FAST32_MAX: u64 = 9223372036854775807;
89pub const UINT_FAST8_MAX: u32 = 255;
90pub const UINT_FAST16_MAX: i32 = -1;
91pub const UINT_FAST32_MAX: i32 = -1;
92pub const INTPTR_MIN: i64 = -9223372036854775808;
93pub const INTPTR_MAX: u64 = 9223372036854775807;
94pub const UINTPTR_MAX: i32 = -1;
95pub const PTRDIFF_MIN: i64 = -9223372036854775808;
96pub const PTRDIFF_MAX: u64 = 9223372036854775807;
97pub const SIG_ATOMIC_MIN: i32 = -2147483648;
98pub const SIG_ATOMIC_MAX: u32 = 2147483647;
99pub const SIZE_MAX: i32 = -1;
100pub const WINT_MIN: u32 = 0;
101pub const WINT_MAX: u32 = 4294967295;
102pub const FPDF_OBJECT_UNKNOWN: u32 = 0;
103pub const FPDF_OBJECT_BOOLEAN: u32 = 1;
104pub const FPDF_OBJECT_NUMBER: u32 = 2;
105pub const FPDF_OBJECT_STRING: u32 = 3;
106pub const FPDF_OBJECT_NAME: u32 = 4;
107pub const FPDF_OBJECT_ARRAY: u32 = 5;
108pub const FPDF_OBJECT_DICTIONARY: u32 = 6;
109pub const FPDF_OBJECT_STREAM: u32 = 7;
110pub const FPDF_OBJECT_NULLOBJ: u32 = 8;
111pub const FPDF_OBJECT_REFERENCE: u32 = 9;
112pub const FPDF_POLICY_MACHINETIME_ACCESS: u32 = 0;
113pub const FPDF_ERR_SUCCESS: u32 = 0;
114pub const FPDF_ERR_UNKNOWN: u32 = 1;
115pub const FPDF_ERR_FILE: u32 = 2;
116pub const FPDF_ERR_FORMAT: u32 = 3;
117pub const FPDF_ERR_PASSWORD: u32 = 4;
118pub const FPDF_ERR_SECURITY: u32 = 5;
119pub const FPDF_ERR_PAGE: u32 = 6;
120pub const FPDF_ERR_XFALOAD: u32 = 7;
121pub const FPDF_ERR_XFALAYOUT: u32 = 8;
122pub const FPDF_ANNOT: u32 = 1;
123pub const FPDF_LCD_TEXT: u32 = 2;
124pub const FPDF_NO_NATIVETEXT: u32 = 4;
125pub const FPDF_GRAYSCALE: u32 = 8;
126pub const FPDF_DEBUG_INFO: u32 = 128;
127pub const FPDF_NO_CATCH: u32 = 256;
128pub const FPDF_RENDER_LIMITEDIMAGECACHE: u32 = 512;
129pub const FPDF_RENDER_FORCEHALFTONE: u32 = 1024;
130pub const FPDF_PRINTING: u32 = 2048;
131pub const FPDF_RENDER_NO_SMOOTHTEXT: u32 = 4096;
132pub const FPDF_RENDER_NO_SMOOTHIMAGE: u32 = 8192;
133pub const FPDF_RENDER_NO_SMOOTHPATH: u32 = 16384;
134pub const FPDF_REVERSE_BYTE_ORDER: u32 = 16;
135pub const FPDF_CONVERT_FILL_TO_STROKE: u32 = 32;
136pub const FPDFBitmap_Unknown: u32 = 0;
137pub const FPDFBitmap_Gray: u32 = 1;
138pub const FPDFBitmap_BGR: u32 = 2;
139pub const FPDFBitmap_BGRx: u32 = 3;
140pub const FPDFBitmap_BGRA: u32 = 4;
141pub const FPDF_COLORSPACE_UNKNOWN: u32 = 0;
142pub const FPDF_COLORSPACE_DEVICEGRAY: u32 = 1;
143pub const FPDF_COLORSPACE_DEVICERGB: u32 = 2;
144pub const FPDF_COLORSPACE_DEVICECMYK: u32 = 3;
145pub const FPDF_COLORSPACE_CALGRAY: u32 = 4;
146pub const FPDF_COLORSPACE_CALRGB: u32 = 5;
147pub const FPDF_COLORSPACE_LAB: u32 = 6;
148pub const FPDF_COLORSPACE_ICCBASED: u32 = 7;
149pub const FPDF_COLORSPACE_SEPARATION: u32 = 8;
150pub const FPDF_COLORSPACE_DEVICEN: u32 = 9;
151pub const FPDF_COLORSPACE_INDEXED: u32 = 10;
152pub const FPDF_COLORSPACE_PATTERN: u32 = 11;
153pub const FPDF_PAGEOBJ_UNKNOWN: u32 = 0;
154pub const FPDF_PAGEOBJ_TEXT: u32 = 1;
155pub const FPDF_PAGEOBJ_PATH: u32 = 2;
156pub const FPDF_PAGEOBJ_IMAGE: u32 = 3;
157pub const FPDF_PAGEOBJ_SHADING: u32 = 4;
158pub const FPDF_PAGEOBJ_FORM: u32 = 5;
159pub const FPDF_SEGMENT_UNKNOWN: i32 = -1;
160pub const FPDF_SEGMENT_LINETO: u32 = 0;
161pub const FPDF_SEGMENT_BEZIERTO: u32 = 1;
162pub const FPDF_SEGMENT_MOVETO: u32 = 2;
163pub const FPDF_FILLMODE_NONE: u32 = 0;
164pub const FPDF_FILLMODE_ALTERNATE: u32 = 1;
165pub const FPDF_FILLMODE_WINDING: u32 = 2;
166pub const FPDF_FONT_TYPE1: u32 = 1;
167pub const FPDF_FONT_TRUETYPE: u32 = 2;
168pub const FPDF_LINECAP_BUTT: u32 = 0;
169pub const FPDF_LINECAP_ROUND: u32 = 1;
170pub const FPDF_LINECAP_PROJECTING_SQUARE: u32 = 2;
171pub const FPDF_LINEJOIN_MITER: u32 = 0;
172pub const FPDF_LINEJOIN_ROUND: u32 = 1;
173pub const FPDF_LINEJOIN_BEVEL: u32 = 2;
174pub const FPDF_PRINTMODE_EMF: u32 = 0;
175pub const FPDF_PRINTMODE_TEXTONLY: u32 = 1;
176pub const FPDF_PRINTMODE_POSTSCRIPT2: u32 = 2;
177pub const FPDF_PRINTMODE_POSTSCRIPT3: u32 = 3;
178pub const FPDF_PRINTMODE_POSTSCRIPT2_PASSTHROUGH: u32 = 4;
179pub const FPDF_PRINTMODE_POSTSCRIPT3_PASSTHROUGH: u32 = 5;
180pub const FPDF_PRINTMODE_EMF_IMAGE_MASKS: u32 = 6;
181pub const FPDF_PRINTMODE_POSTSCRIPT3_TYPE42: u32 = 7;
182pub const FPDF_PRINTMODE_POSTSCRIPT3_TYPE42_PASSTHROUGH: u32 = 8;
183pub const PDF_LINEARIZATION_UNKNOWN: i32 = -1;
184pub const PDF_NOT_LINEARIZED: u32 = 0;
185pub const PDF_LINEARIZED: u32 = 1;
186pub const PDF_DATA_ERROR: i32 = -1;
187pub const PDF_DATA_NOTAVAIL: u32 = 0;
188pub const PDF_DATA_AVAIL: u32 = 1;
189pub const PDF_FORM_ERROR: i32 = -1;
190pub const PDF_FORM_NOTAVAIL: u32 = 0;
191pub const PDF_FORM_AVAIL: u32 = 1;
192pub const PDF_FORM_NOTEXIST: u32 = 2;
193pub const FXFONT_ANSI_CHARSET: u32 = 0;
194pub const FXFONT_DEFAULT_CHARSET: u32 = 1;
195pub const FXFONT_SYMBOL_CHARSET: u32 = 2;
196pub const FXFONT_SHIFTJIS_CHARSET: u32 = 128;
197pub const FXFONT_HANGEUL_CHARSET: u32 = 129;
198pub const FXFONT_GB2312_CHARSET: u32 = 134;
199pub const FXFONT_CHINESEBIG5_CHARSET: u32 = 136;
200pub const FXFONT_GREEK_CHARSET: u32 = 161;
201pub const FXFONT_VIETNAMESE_CHARSET: u32 = 163;
202pub const FXFONT_HEBREW_CHARSET: u32 = 177;
203pub const FXFONT_ARABIC_CHARSET: u32 = 178;
204pub const FXFONT_CYRILLIC_CHARSET: u32 = 204;
205pub const FXFONT_THAI_CHARSET: u32 = 222;
206pub const FXFONT_EASTERNEUROPEAN_CHARSET: u32 = 238;
207pub const FXFONT_FF_FIXEDPITCH: u32 = 1;
208pub const FXFONT_FF_ROMAN: u32 = 16;
209pub const FXFONT_FF_SCRIPT: u32 = 64;
210pub const FXFONT_FW_NORMAL: u32 = 400;
211pub const FXFONT_FW_BOLD: u32 = 700;
212pub const FPDF_INCREMENTAL: u32 = 1;
213pub const FPDF_NO_INCREMENTAL: u32 = 2;
214pub const FPDF_REMOVE_SECURITY: u32 = 3;
215pub const FPDF_MATCHCASE: u32 = 1;
216pub const FPDF_MATCHWHOLEWORD: u32 = 2;
217pub const FPDF_CONSECUTIVE: u32 = 4;
218pub const _TIME_H: u32 = 1;
219pub const _BITS_TIME_H: u32 = 1;
220pub const CLOCK_REALTIME: u32 = 0;
221pub const CLOCK_MONOTONIC: u32 = 1;
222pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2;
223pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3;
224pub const CLOCK_MONOTONIC_RAW: u32 = 4;
225pub const CLOCK_REALTIME_COARSE: u32 = 5;
226pub const CLOCK_MONOTONIC_COARSE: u32 = 6;
227pub const CLOCK_BOOTTIME: u32 = 7;
228pub const CLOCK_REALTIME_ALARM: u32 = 8;
229pub const CLOCK_BOOTTIME_ALARM: u32 = 9;
230pub const CLOCK_TAI: u32 = 11;
231pub const TIMER_ABSTIME: u32 = 1;
232pub const __clock_t_defined: u32 = 1;
233pub const __time_t_defined: u32 = 1;
234pub const __struct_tm_defined: u32 = 1;
235pub const _STRUCT_TIMESPEC: u32 = 1;
236pub const _BITS_ENDIAN_H: u32 = 1;
237pub const __LITTLE_ENDIAN: u32 = 1234;
238pub const __BIG_ENDIAN: u32 = 4321;
239pub const __PDP_ENDIAN: u32 = 3412;
240pub const _BITS_ENDIANNESS_H: u32 = 1;
241pub const __BYTE_ORDER: u32 = 1234;
242pub const __FLOAT_WORD_ORDER: u32 = 1234;
243pub const __clockid_t_defined: u32 = 1;
244pub const __timer_t_defined: u32 = 1;
245pub const __itimerspec_defined: u32 = 1;
246pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
247pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
248pub const TIME_UTC: u32 = 1;
249pub const FPDF_UNSP_DOC_XFAFORM: u32 = 1;
250pub const FPDF_UNSP_DOC_PORTABLECOLLECTION: u32 = 2;
251pub const FPDF_UNSP_DOC_ATTACHMENT: u32 = 3;
252pub const FPDF_UNSP_DOC_SECURITY: u32 = 4;
253pub const FPDF_UNSP_DOC_SHAREDREVIEW: u32 = 5;
254pub const FPDF_UNSP_DOC_SHAREDFORM_ACROBAT: u32 = 6;
255pub const FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM: u32 = 7;
256pub const FPDF_UNSP_DOC_SHAREDFORM_EMAIL: u32 = 8;
257pub const FPDF_UNSP_ANNOT_3DANNOT: u32 = 11;
258pub const FPDF_UNSP_ANNOT_MOVIE: u32 = 12;
259pub const FPDF_UNSP_ANNOT_SOUND: u32 = 13;
260pub const FPDF_UNSP_ANNOT_SCREEN_MEDIA: u32 = 14;
261pub const FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA: u32 = 15;
262pub const FPDF_UNSP_ANNOT_ATTACHMENT: u32 = 16;
263pub const FPDF_UNSP_ANNOT_SIG: u32 = 17;
264pub const PAGEMODE_UNKNOWN: i32 = -1;
265pub const PAGEMODE_USENONE: u32 = 0;
266pub const PAGEMODE_USEOUTLINES: u32 = 1;
267pub const PAGEMODE_USETHUMBS: u32 = 2;
268pub const PAGEMODE_FULLSCREEN: u32 = 3;
269pub const PAGEMODE_USEOC: u32 = 4;
270pub const PAGEMODE_USEATTACHMENTS: u32 = 5;
271pub const PDFACTION_UNSUPPORTED: u32 = 0;
272pub const PDFACTION_GOTO: u32 = 1;
273pub const PDFACTION_REMOTEGOTO: u32 = 2;
274pub const PDFACTION_URI: u32 = 3;
275pub const PDFACTION_LAUNCH: u32 = 4;
276pub const PDFACTION_EMBEDDEDGOTO: u32 = 5;
277pub const PDFDEST_VIEW_UNKNOWN_MODE: u32 = 0;
278pub const PDFDEST_VIEW_XYZ: u32 = 1;
279pub const PDFDEST_VIEW_FIT: u32 = 2;
280pub const PDFDEST_VIEW_FITH: u32 = 3;
281pub const PDFDEST_VIEW_FITV: u32 = 4;
282pub const PDFDEST_VIEW_FITR: u32 = 5;
283pub const PDFDEST_VIEW_FITB: u32 = 6;
284pub const PDFDEST_VIEW_FITBH: u32 = 7;
285pub const PDFDEST_VIEW_FITBV: u32 = 8;
286pub const FORMTYPE_NONE: u32 = 0;
287pub const FORMTYPE_ACRO_FORM: u32 = 1;
288pub const FORMTYPE_XFA_FULL: u32 = 2;
289pub const FORMTYPE_XFA_FOREGROUND: u32 = 3;
290pub const FORMTYPE_COUNT: u32 = 4;
291pub const JSPLATFORM_ALERT_BUTTON_OK: u32 = 0;
292pub const JSPLATFORM_ALERT_BUTTON_OKCANCEL: u32 = 1;
293pub const JSPLATFORM_ALERT_BUTTON_YESNO: u32 = 2;
294pub const JSPLATFORM_ALERT_BUTTON_YESNOCANCEL: u32 = 3;
295pub const JSPLATFORM_ALERT_BUTTON_DEFAULT: u32 = 0;
296pub const JSPLATFORM_ALERT_ICON_ERROR: u32 = 0;
297pub const JSPLATFORM_ALERT_ICON_WARNING: u32 = 1;
298pub const JSPLATFORM_ALERT_ICON_QUESTION: u32 = 2;
299pub const JSPLATFORM_ALERT_ICON_STATUS: u32 = 3;
300pub const JSPLATFORM_ALERT_ICON_ASTERISK: u32 = 4;
301pub const JSPLATFORM_ALERT_ICON_DEFAULT: u32 = 0;
302pub const JSPLATFORM_ALERT_RETURN_OK: u32 = 1;
303pub const JSPLATFORM_ALERT_RETURN_CANCEL: u32 = 2;
304pub const JSPLATFORM_ALERT_RETURN_NO: u32 = 3;
305pub const JSPLATFORM_ALERT_RETURN_YES: u32 = 4;
306pub const JSPLATFORM_BEEP_ERROR: u32 = 0;
307pub const JSPLATFORM_BEEP_WARNING: u32 = 1;
308pub const JSPLATFORM_BEEP_QUESTION: u32 = 2;
309pub const JSPLATFORM_BEEP_STATUS: u32 = 3;
310pub const JSPLATFORM_BEEP_DEFAULT: u32 = 4;
311pub const FXCT_ARROW: u32 = 0;
312pub const FXCT_NESW: u32 = 1;
313pub const FXCT_NWSE: u32 = 2;
314pub const FXCT_VBEAM: u32 = 3;
315pub const FXCT_HBEAM: u32 = 4;
316pub const FXCT_HAND: u32 = 5;
317pub const FXFA_PAGEVIEWEVENT_POSTADDED: u32 = 1;
318pub const FXFA_PAGEVIEWEVENT_POSTREMOVED: u32 = 3;
319pub const FXFA_MENU_COPY: u32 = 1;
320pub const FXFA_MENU_CUT: u32 = 2;
321pub const FXFA_MENU_SELECTALL: u32 = 4;
322pub const FXFA_MENU_UNDO: u32 = 8;
323pub const FXFA_MENU_REDO: u32 = 16;
324pub const FXFA_MENU_PASTE: u32 = 32;
325pub const FXFA_SAVEAS_XML: u32 = 1;
326pub const FXFA_SAVEAS_XDP: u32 = 2;
327pub const FPDFDOC_AACTION_WC: u32 = 16;
328pub const FPDFDOC_AACTION_WS: u32 = 17;
329pub const FPDFDOC_AACTION_DS: u32 = 18;
330pub const FPDFDOC_AACTION_WP: u32 = 19;
331pub const FPDFDOC_AACTION_DP: u32 = 20;
332pub const FPDFPAGE_AACTION_OPEN: u32 = 0;
333pub const FPDFPAGE_AACTION_CLOSE: u32 = 1;
334pub const FPDF_FORMFIELD_UNKNOWN: u32 = 0;
335pub const FPDF_FORMFIELD_PUSHBUTTON: u32 = 1;
336pub const FPDF_FORMFIELD_CHECKBOX: u32 = 2;
337pub const FPDF_FORMFIELD_RADIOBUTTON: u32 = 3;
338pub const FPDF_FORMFIELD_COMBOBOX: u32 = 4;
339pub const FPDF_FORMFIELD_LISTBOX: u32 = 5;
340pub const FPDF_FORMFIELD_TEXTFIELD: u32 = 6;
341pub const FPDF_FORMFIELD_SIGNATURE: u32 = 7;
342pub const FPDF_FORMFIELD_XFA: u32 = 8;
343pub const FPDF_FORMFIELD_XFA_CHECKBOX: u32 = 9;
344pub const FPDF_FORMFIELD_XFA_COMBOBOX: u32 = 10;
345pub const FPDF_FORMFIELD_XFA_IMAGEFIELD: u32 = 11;
346pub const FPDF_FORMFIELD_XFA_LISTBOX: u32 = 12;
347pub const FPDF_FORMFIELD_XFA_PUSHBUTTON: u32 = 13;
348pub const FPDF_FORMFIELD_XFA_SIGNATURE: u32 = 14;
349pub const FPDF_FORMFIELD_XFA_TEXTFIELD: u32 = 15;
350pub const FPDF_FORMFIELD_COUNT: u32 = 16;
351pub const FPDF_ANNOT_UNKNOWN: u32 = 0;
352pub const FPDF_ANNOT_TEXT: u32 = 1;
353pub const FPDF_ANNOT_LINK: u32 = 2;
354pub const FPDF_ANNOT_FREETEXT: u32 = 3;
355pub const FPDF_ANNOT_LINE: u32 = 4;
356pub const FPDF_ANNOT_SQUARE: u32 = 5;
357pub const FPDF_ANNOT_CIRCLE: u32 = 6;
358pub const FPDF_ANNOT_POLYGON: u32 = 7;
359pub const FPDF_ANNOT_POLYLINE: u32 = 8;
360pub const FPDF_ANNOT_HIGHLIGHT: u32 = 9;
361pub const FPDF_ANNOT_UNDERLINE: u32 = 10;
362pub const FPDF_ANNOT_SQUIGGLY: u32 = 11;
363pub const FPDF_ANNOT_STRIKEOUT: u32 = 12;
364pub const FPDF_ANNOT_STAMP: u32 = 13;
365pub const FPDF_ANNOT_CARET: u32 = 14;
366pub const FPDF_ANNOT_INK: u32 = 15;
367pub const FPDF_ANNOT_POPUP: u32 = 16;
368pub const FPDF_ANNOT_FILEATTACHMENT: u32 = 17;
369pub const FPDF_ANNOT_SOUND: u32 = 18;
370pub const FPDF_ANNOT_MOVIE: u32 = 19;
371pub const FPDF_ANNOT_WIDGET: u32 = 20;
372pub const FPDF_ANNOT_SCREEN: u32 = 21;
373pub const FPDF_ANNOT_PRINTERMARK: u32 = 22;
374pub const FPDF_ANNOT_TRAPNET: u32 = 23;
375pub const FPDF_ANNOT_WATERMARK: u32 = 24;
376pub const FPDF_ANNOT_THREED: u32 = 25;
377pub const FPDF_ANNOT_RICHMEDIA: u32 = 26;
378pub const FPDF_ANNOT_XFAWIDGET: u32 = 27;
379pub const FPDF_ANNOT_REDACT: u32 = 28;
380pub const FPDF_ANNOT_FLAG_NONE: u32 = 0;
381pub const FPDF_ANNOT_FLAG_INVISIBLE: u32 = 1;
382pub const FPDF_ANNOT_FLAG_HIDDEN: u32 = 2;
383pub const FPDF_ANNOT_FLAG_PRINT: u32 = 4;
384pub const FPDF_ANNOT_FLAG_NOZOOM: u32 = 8;
385pub const FPDF_ANNOT_FLAG_NOROTATE: u32 = 16;
386pub const FPDF_ANNOT_FLAG_NOVIEW: u32 = 32;
387pub const FPDF_ANNOT_FLAG_READONLY: u32 = 64;
388pub const FPDF_ANNOT_FLAG_LOCKED: u32 = 128;
389pub const FPDF_ANNOT_FLAG_TOGGLENOVIEW: u32 = 256;
390pub const FPDF_ANNOT_APPEARANCEMODE_NORMAL: u32 = 0;
391pub const FPDF_ANNOT_APPEARANCEMODE_ROLLOVER: u32 = 1;
392pub const FPDF_ANNOT_APPEARANCEMODE_DOWN: u32 = 2;
393pub const FPDF_ANNOT_APPEARANCEMODE_COUNT: u32 = 3;
394pub const FPDF_FORMFLAG_NONE: u32 = 0;
395pub const FPDF_FORMFLAG_READONLY: u32 = 1;
396pub const FPDF_FORMFLAG_REQUIRED: u32 = 2;
397pub const FPDF_FORMFLAG_NOEXPORT: u32 = 4;
398pub const FPDF_FORMFLAG_TEXT_MULTILINE: u32 = 4096;
399pub const FPDF_FORMFLAG_TEXT_PASSWORD: u32 = 8192;
400pub const FPDF_FORMFLAG_CHOICE_COMBO: u32 = 131072;
401pub const FPDF_FORMFLAG_CHOICE_EDIT: u32 = 262144;
402pub const FPDF_FORMFLAG_CHOICE_MULTI_SELECT: u32 = 2097152;
403pub const FPDF_ANNOT_AACTION_KEY_STROKE: u32 = 12;
404pub const FPDF_ANNOT_AACTION_FORMAT: u32 = 13;
405pub const FPDF_ANNOT_AACTION_VALIDATE: u32 = 14;
406pub const FPDF_ANNOT_AACTION_CALCULATE: u32 = 15;
407pub const FLATTEN_FAIL: u32 = 0;
408pub const FLATTEN_SUCCESS: u32 = 1;
409pub const FLATTEN_NOTHINGTODO: u32 = 2;
410pub const FLAT_NORMALDISPLAY: u32 = 0;
411pub const FLAT_PRINT: u32 = 1;
412pub const FPDF_RENDER_READY: u32 = 0;
413pub const FPDF_RENDER_TOBECONTINUED: u32 = 1;
414pub const FPDF_RENDER_DONE: u32 = 2;
415pub const FPDF_RENDER_FAILED: u32 = 3;
416#[doc = " Convenience types."]
417pub type __u_char = ::std::os::raw::c_uchar;
418pub type __u_short = ::std::os::raw::c_ushort;
419pub type __u_int = ::std::os::raw::c_uint;
420pub type __u_long = ::std::os::raw::c_ulong;
421#[doc = " Fixed-size types, underlying types depend on word size and compiler."]
422pub type __int8_t = ::std::os::raw::c_schar;
423pub type __uint8_t = ::std::os::raw::c_uchar;
424pub type __int16_t = ::std::os::raw::c_short;
425pub type __uint16_t = ::std::os::raw::c_ushort;
426pub type __int32_t = ::std::os::raw::c_int;
427pub type __uint32_t = ::std::os::raw::c_uint;
428pub type __int64_t = ::std::os::raw::c_long;
429pub type __uint64_t = ::std::os::raw::c_ulong;
430#[doc = " Smallest types with at least a given width."]
431pub type __int_least8_t = __int8_t;
432pub type __uint_least8_t = __uint8_t;
433pub type __int_least16_t = __int16_t;
434pub type __uint_least16_t = __uint16_t;
435pub type __int_least32_t = __int32_t;
436pub type __uint_least32_t = __uint32_t;
437pub type __int_least64_t = __int64_t;
438pub type __uint_least64_t = __uint64_t;
439pub type __quad_t = ::std::os::raw::c_long;
440pub type __u_quad_t = ::std::os::raw::c_ulong;
441pub type __intmax_t = ::std::os::raw::c_long;
442pub type __uintmax_t = ::std::os::raw::c_ulong;
443pub type __dev_t = ::std::os::raw::c_ulong;
444pub type __uid_t = ::std::os::raw::c_uint;
445pub type __gid_t = ::std::os::raw::c_uint;
446pub type __ino_t = ::std::os::raw::c_ulong;
447pub type __ino64_t = ::std::os::raw::c_ulong;
448pub type __mode_t = ::std::os::raw::c_uint;
449pub type __nlink_t = ::std::os::raw::c_ulong;
450pub type __off_t = ::std::os::raw::c_long;
451pub type __off64_t = ::std::os::raw::c_long;
452pub type __pid_t = ::std::os::raw::c_int;
453#[repr(C)]
454#[derive(Debug, Copy, Clone)]
455pub struct __fsid_t {
456 pub __val: [::std::os::raw::c_int; 2usize],
457}
458#[test]
459fn bindgen_test_layout___fsid_t() {
460 const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
461 let ptr = UNINIT.as_ptr();
462 assert_eq!(
463 ::std::mem::size_of::<__fsid_t>(),
464 8usize,
465 concat!("Size of: ", stringify!(__fsid_t))
466 );
467 assert_eq!(
468 ::std::mem::align_of::<__fsid_t>(),
469 4usize,
470 concat!("Alignment of ", stringify!(__fsid_t))
471 );
472 assert_eq!(
473 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
474 0usize,
475 concat!(
476 "Offset of field: ",
477 stringify!(__fsid_t),
478 "::",
479 stringify!(__val)
480 )
481 );
482}
483pub type __clock_t = ::std::os::raw::c_long;
484pub type __rlim_t = ::std::os::raw::c_ulong;
485pub type __rlim64_t = ::std::os::raw::c_ulong;
486pub type __id_t = ::std::os::raw::c_uint;
487pub type __time_t = ::std::os::raw::c_long;
488pub type __useconds_t = ::std::os::raw::c_uint;
489pub type __suseconds_t = ::std::os::raw::c_long;
490pub type __suseconds64_t = ::std::os::raw::c_long;
491pub type __daddr_t = ::std::os::raw::c_int;
492pub type __key_t = ::std::os::raw::c_int;
493pub type __clockid_t = ::std::os::raw::c_int;
494pub type __timer_t = *mut ::std::os::raw::c_void;
495pub type __blksize_t = ::std::os::raw::c_long;
496pub type __blkcnt_t = ::std::os::raw::c_long;
497pub type __blkcnt64_t = ::std::os::raw::c_long;
498pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
499pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
500pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
501pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
502pub type __fsword_t = ::std::os::raw::c_long;
503pub type __ssize_t = ::std::os::raw::c_long;
504pub type __syscall_slong_t = ::std::os::raw::c_long;
505pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
506#[doc = " These few don't really vary by system, they always correspond\nto one of the other defined types."]
507pub type __loff_t = __off64_t;
508pub type __caddr_t = *mut ::std::os::raw::c_char;
509pub type __intptr_t = ::std::os::raw::c_long;
510pub type __socklen_t = ::std::os::raw::c_uint;
511#[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."]
512pub type __sig_atomic_t = ::std::os::raw::c_int;
513#[doc = " Signed."]
514pub type int_least8_t = __int_least8_t;
515pub type int_least16_t = __int_least16_t;
516pub type int_least32_t = __int_least32_t;
517pub type int_least64_t = __int_least64_t;
518#[doc = " Unsigned."]
519pub type uint_least8_t = __uint_least8_t;
520pub type uint_least16_t = __uint_least16_t;
521pub type uint_least32_t = __uint_least32_t;
522pub type uint_least64_t = __uint_least64_t;
523#[doc = " Signed."]
524pub type int_fast8_t = ::std::os::raw::c_schar;
525pub type int_fast16_t = ::std::os::raw::c_long;
526pub type int_fast32_t = ::std::os::raw::c_long;
527pub type int_fast64_t = ::std::os::raw::c_long;
528#[doc = " Unsigned."]
529pub type uint_fast8_t = ::std::os::raw::c_uchar;
530pub type uint_fast16_t = ::std::os::raw::c_ulong;
531pub type uint_fast32_t = ::std::os::raw::c_ulong;
532pub type uint_fast64_t = ::std::os::raw::c_ulong;
533#[doc = " Largest integral types."]
534pub type intmax_t = __intmax_t;
535pub type uintmax_t = __uintmax_t;
536pub type wchar_t = ::std::os::raw::c_int;
537#[doc = " Define 'max_align_t' to match the GCC definition."]
538#[repr(C)]
539#[repr(align(16))]
540#[derive(Debug, Copy, Clone)]
541pub struct max_align_t {
542 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
543 pub __bindgen_padding_0: u64,
544 pub __clang_max_align_nonce2: u128,
545}
546#[test]
547fn bindgen_test_layout_max_align_t() {
548 const UNINIT: ::std::mem::MaybeUninit<max_align_t> = ::std::mem::MaybeUninit::uninit();
549 let ptr = UNINIT.as_ptr();
550 assert_eq!(
551 ::std::mem::size_of::<max_align_t>(),
552 32usize,
553 concat!("Size of: ", stringify!(max_align_t))
554 );
555 assert_eq!(
556 ::std::mem::align_of::<max_align_t>(),
557 16usize,
558 concat!("Alignment of ", stringify!(max_align_t))
559 );
560 assert_eq!(
561 unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
562 0usize,
563 concat!(
564 "Offset of field: ",
565 stringify!(max_align_t),
566 "::",
567 stringify!(__clang_max_align_nonce1)
568 )
569 );
570 assert_eq!(
571 unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
572 16usize,
573 concat!(
574 "Offset of field: ",
575 stringify!(max_align_t),
576 "::",
577 stringify!(__clang_max_align_nonce2)
578 )
579 );
580}
581pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_UNKNOWN: FPDF_TEXT_RENDERMODE = -1;
582pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL: FPDF_TEXT_RENDERMODE = 0;
583pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_STROKE: FPDF_TEXT_RENDERMODE = 1;
584pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_STROKE: FPDF_TEXT_RENDERMODE = 2;
585pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_INVISIBLE: FPDF_TEXT_RENDERMODE = 3;
586pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_CLIP: FPDF_TEXT_RENDERMODE = 4;
587pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_STROKE_CLIP: FPDF_TEXT_RENDERMODE = 5;
588pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_STROKE_CLIP: FPDF_TEXT_RENDERMODE = 6;
589pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_CLIP: FPDF_TEXT_RENDERMODE = 7;
590pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_LAST: FPDF_TEXT_RENDERMODE = 7;
591#[doc = " PDF text rendering modes"]
592pub type FPDF_TEXT_RENDERMODE = ::std::os::raw::c_int;
593#[repr(C)]
594#[derive(Debug, Copy, Clone)]
595pub struct fpdf_action_t__ {
596 _unused: [u8; 0],
597}
598#[doc = " PDF types - use incomplete types (never completed) to force API type safety."]
599pub type FPDF_ACTION = *mut fpdf_action_t__;
600#[repr(C)]
601#[derive(Debug, Copy, Clone)]
602pub struct fpdf_annotation_t__ {
603 _unused: [u8; 0],
604}
605pub type FPDF_ANNOTATION = *mut fpdf_annotation_t__;
606#[repr(C)]
607#[derive(Debug, Copy, Clone)]
608pub struct fpdf_attachment_t__ {
609 _unused: [u8; 0],
610}
611pub type FPDF_ATTACHMENT = *mut fpdf_attachment_t__;
612#[repr(C)]
613#[derive(Debug, Copy, Clone)]
614pub struct fpdf_avail_t__ {
615 _unused: [u8; 0],
616}
617pub type FPDF_AVAIL = *mut fpdf_avail_t__;
618#[repr(C)]
619#[derive(Debug, Copy, Clone)]
620pub struct fpdf_bitmap_t__ {
621 _unused: [u8; 0],
622}
623pub type FPDF_BITMAP = *mut fpdf_bitmap_t__;
624#[repr(C)]
625#[derive(Debug, Copy, Clone)]
626pub struct fpdf_bookmark_t__ {
627 _unused: [u8; 0],
628}
629pub type FPDF_BOOKMARK = *mut fpdf_bookmark_t__;
630#[repr(C)]
631#[derive(Debug, Copy, Clone)]
632pub struct fpdf_clippath_t__ {
633 _unused: [u8; 0],
634}
635pub type FPDF_CLIPPATH = *mut fpdf_clippath_t__;
636#[repr(C)]
637#[derive(Debug, Copy, Clone)]
638pub struct fpdf_dest_t__ {
639 _unused: [u8; 0],
640}
641pub type FPDF_DEST = *mut fpdf_dest_t__;
642#[repr(C)]
643#[derive(Debug, Copy, Clone)]
644pub struct fpdf_document_t__ {
645 _unused: [u8; 0],
646}
647pub type FPDF_DOCUMENT = *mut fpdf_document_t__;
648#[repr(C)]
649#[derive(Debug, Copy, Clone)]
650pub struct fpdf_font_t__ {
651 _unused: [u8; 0],
652}
653pub type FPDF_FONT = *mut fpdf_font_t__;
654#[repr(C)]
655#[derive(Debug, Copy, Clone)]
656pub struct fpdf_form_handle_t__ {
657 _unused: [u8; 0],
658}
659pub type FPDF_FORMHANDLE = *mut fpdf_form_handle_t__;
660#[repr(C)]
661#[derive(Debug, Copy, Clone)]
662pub struct fpdf_glyphpath_t__ {
663 _unused: [u8; 0],
664}
665pub type FPDF_GLYPHPATH = *const fpdf_glyphpath_t__;
666#[repr(C)]
667#[derive(Debug, Copy, Clone)]
668pub struct fpdf_javascript_action_t {
669 _unused: [u8; 0],
670}
671pub type FPDF_JAVASCRIPT_ACTION = *mut fpdf_javascript_action_t;
672#[repr(C)]
673#[derive(Debug, Copy, Clone)]
674pub struct fpdf_link_t__ {
675 _unused: [u8; 0],
676}
677pub type FPDF_LINK = *mut fpdf_link_t__;
678#[repr(C)]
679#[derive(Debug, Copy, Clone)]
680pub struct fpdf_page_t__ {
681 _unused: [u8; 0],
682}
683pub type FPDF_PAGE = *mut fpdf_page_t__;
684#[repr(C)]
685#[derive(Debug, Copy, Clone)]
686pub struct fpdf_pagelink_t__ {
687 _unused: [u8; 0],
688}
689pub type FPDF_PAGELINK = *mut fpdf_pagelink_t__;
690#[repr(C)]
691#[derive(Debug, Copy, Clone)]
692pub struct fpdf_pageobject_t__ {
693 _unused: [u8; 0],
694}
695pub type FPDF_PAGEOBJECT = *mut fpdf_pageobject_t__;
696#[repr(C)]
697#[derive(Debug, Copy, Clone)]
698pub struct fpdf_pageobjectmark_t__ {
699 _unused: [u8; 0],
700}
701pub type FPDF_PAGEOBJECTMARK = *mut fpdf_pageobjectmark_t__;
702#[repr(C)]
703#[derive(Debug, Copy, Clone)]
704pub struct fpdf_pagerange_t__ {
705 _unused: [u8; 0],
706}
707pub type FPDF_PAGERANGE = *const fpdf_pagerange_t__;
708#[repr(C)]
709#[derive(Debug, Copy, Clone)]
710pub struct fpdf_pathsegment_t {
711 _unused: [u8; 0],
712}
713pub type FPDF_PATHSEGMENT = *const fpdf_pathsegment_t;
714#[repr(C)]
715#[derive(Debug, Copy, Clone)]
716pub struct fpdf_schhandle_t__ {
717 _unused: [u8; 0],
718}
719pub type FPDF_SCHHANDLE = *mut fpdf_schhandle_t__;
720#[repr(C)]
721#[derive(Debug, Copy, Clone)]
722pub struct fpdf_signature_t__ {
723 _unused: [u8; 0],
724}
725pub type FPDF_SIGNATURE = *const fpdf_signature_t__;
726pub type FPDF_SKIA_CANVAS = *mut ::std::os::raw::c_void;
727#[repr(C)]
728#[derive(Debug, Copy, Clone)]
729pub struct fpdf_structelement_t__ {
730 _unused: [u8; 0],
731}
732pub type FPDF_STRUCTELEMENT = *mut fpdf_structelement_t__;
733#[repr(C)]
734#[derive(Debug, Copy, Clone)]
735pub struct fpdf_structelement_attr_t__ {
736 _unused: [u8; 0],
737}
738pub type FPDF_STRUCTELEMENT_ATTR = *const fpdf_structelement_attr_t__;
739#[repr(C)]
740#[derive(Debug, Copy, Clone)]
741pub struct fpdf_structelement_attr_value_t__ {
742 _unused: [u8; 0],
743}
744pub type FPDF_STRUCTELEMENT_ATTR_VALUE = *const fpdf_structelement_attr_value_t__;
745#[repr(C)]
746#[derive(Debug, Copy, Clone)]
747pub struct fpdf_structtree_t__ {
748 _unused: [u8; 0],
749}
750pub type FPDF_STRUCTTREE = *mut fpdf_structtree_t__;
751#[repr(C)]
752#[derive(Debug, Copy, Clone)]
753pub struct fpdf_textpage_t__ {
754 _unused: [u8; 0],
755}
756pub type FPDF_TEXTPAGE = *mut fpdf_textpage_t__;
757#[repr(C)]
758#[derive(Debug, Copy, Clone)]
759pub struct fpdf_widget_t__ {
760 _unused: [u8; 0],
761}
762pub type FPDF_WIDGET = *mut fpdf_widget_t__;
763#[repr(C)]
764#[derive(Debug, Copy, Clone)]
765pub struct fpdf_xobject_t__ {
766 _unused: [u8; 0],
767}
768pub type FPDF_XOBJECT = *mut fpdf_xobject_t__;
769#[doc = " Basic data types"]
770pub type FPDF_BOOL = ::std::os::raw::c_int;
771pub type FPDF_RESULT = ::std::os::raw::c_int;
772pub type FPDF_DWORD = ::std::os::raw::c_ulong;
773pub type FS_FLOAT = f32;
774pub const _FPDF_DUPLEXTYPE__DuplexUndefined: _FPDF_DUPLEXTYPE_ = 0;
775pub const _FPDF_DUPLEXTYPE__Simplex: _FPDF_DUPLEXTYPE_ = 1;
776pub const _FPDF_DUPLEXTYPE__DuplexFlipShortEdge: _FPDF_DUPLEXTYPE_ = 2;
777pub const _FPDF_DUPLEXTYPE__DuplexFlipLongEdge: _FPDF_DUPLEXTYPE_ = 3;
778#[doc = " Duplex types"]
779pub type _FPDF_DUPLEXTYPE_ = ::std::os::raw::c_uint;
780#[doc = " Duplex types"]
781pub use self::_FPDF_DUPLEXTYPE_ as FPDF_DUPLEXTYPE;
782#[doc = " String types"]
783pub type FPDF_WCHAR = ::std::os::raw::c_ushort;
784#[doc = " Public PDFium API type for byte strings."]
785pub type FPDF_BYTESTRING = *const ::std::os::raw::c_char;
786#[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."]
787pub type FPDF_WIDESTRING = *const FPDF_WCHAR;
788#[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."]
789#[repr(C)]
790#[derive(Debug, Copy, Clone)]
791pub struct FPDF_BSTR_ {
792 #[doc = " String buffer, manipulate only with FPDF_BStr_* methods."]
793 pub str_: *mut ::std::os::raw::c_char,
794 #[doc = " Length of the string, in bytes."]
795 pub len: ::std::os::raw::c_int,
796}
797#[test]
798fn bindgen_test_layout_FPDF_BSTR_() {
799 const UNINIT: ::std::mem::MaybeUninit<FPDF_BSTR_> = ::std::mem::MaybeUninit::uninit();
800 let ptr = UNINIT.as_ptr();
801 assert_eq!(
802 ::std::mem::size_of::<FPDF_BSTR_>(),
803 16usize,
804 concat!("Size of: ", stringify!(FPDF_BSTR_))
805 );
806 assert_eq!(
807 ::std::mem::align_of::<FPDF_BSTR_>(),
808 8usize,
809 concat!("Alignment of ", stringify!(FPDF_BSTR_))
810 );
811 assert_eq!(
812 unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
813 0usize,
814 concat!(
815 "Offset of field: ",
816 stringify!(FPDF_BSTR_),
817 "::",
818 stringify!(str_)
819 )
820 );
821 assert_eq!(
822 unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
823 8usize,
824 concat!(
825 "Offset of field: ",
826 stringify!(FPDF_BSTR_),
827 "::",
828 stringify!(len)
829 )
830 );
831}
832#[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."]
833pub type FPDF_BSTR = FPDF_BSTR_;
834#[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."]
835pub type FPDF_STRING = *const ::std::os::raw::c_char;
836#[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."]
837#[repr(C)]
838#[derive(Debug, Copy, Clone)]
839pub struct _FS_MATRIX_ {
840 pub a: f32,
841 pub b: f32,
842 pub c: f32,
843 pub d: f32,
844 pub e: f32,
845 pub f: f32,
846}
847#[test]
848fn bindgen_test_layout__FS_MATRIX_() {
849 const UNINIT: ::std::mem::MaybeUninit<_FS_MATRIX_> = ::std::mem::MaybeUninit::uninit();
850 let ptr = UNINIT.as_ptr();
851 assert_eq!(
852 ::std::mem::size_of::<_FS_MATRIX_>(),
853 24usize,
854 concat!("Size of: ", stringify!(_FS_MATRIX_))
855 );
856 assert_eq!(
857 ::std::mem::align_of::<_FS_MATRIX_>(),
858 4usize,
859 concat!("Alignment of ", stringify!(_FS_MATRIX_))
860 );
861 assert_eq!(
862 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
863 0usize,
864 concat!(
865 "Offset of field: ",
866 stringify!(_FS_MATRIX_),
867 "::",
868 stringify!(a)
869 )
870 );
871 assert_eq!(
872 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
873 4usize,
874 concat!(
875 "Offset of field: ",
876 stringify!(_FS_MATRIX_),
877 "::",
878 stringify!(b)
879 )
880 );
881 assert_eq!(
882 unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
883 8usize,
884 concat!(
885 "Offset of field: ",
886 stringify!(_FS_MATRIX_),
887 "::",
888 stringify!(c)
889 )
890 );
891 assert_eq!(
892 unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
893 12usize,
894 concat!(
895 "Offset of field: ",
896 stringify!(_FS_MATRIX_),
897 "::",
898 stringify!(d)
899 )
900 );
901 assert_eq!(
902 unsafe { ::std::ptr::addr_of!((*ptr).e) as usize - ptr as usize },
903 16usize,
904 concat!(
905 "Offset of field: ",
906 stringify!(_FS_MATRIX_),
907 "::",
908 stringify!(e)
909 )
910 );
911 assert_eq!(
912 unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
913 20usize,
914 concat!(
915 "Offset of field: ",
916 stringify!(_FS_MATRIX_),
917 "::",
918 stringify!(f)
919 )
920 );
921}
922#[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."]
923pub type FS_MATRIX = _FS_MATRIX_;
924#[doc = " Rectangle area(float) in device or page coordinate system."]
925#[repr(C)]
926#[derive(Debug, Copy, Clone)]
927pub struct _FS_RECTF_ {
928 #[doc = " The x-coordinate of the left-top corner."]
929 pub left: f32,
930 #[doc = " The y-coordinate of the left-top corner."]
931 pub top: f32,
932 #[doc = " The x-coordinate of the right-bottom corner."]
933 pub right: f32,
934 #[doc = " The y-coordinate of the right-bottom corner."]
935 pub bottom: f32,
936}
937#[test]
938fn bindgen_test_layout__FS_RECTF_() {
939 const UNINIT: ::std::mem::MaybeUninit<_FS_RECTF_> = ::std::mem::MaybeUninit::uninit();
940 let ptr = UNINIT.as_ptr();
941 assert_eq!(
942 ::std::mem::size_of::<_FS_RECTF_>(),
943 16usize,
944 concat!("Size of: ", stringify!(_FS_RECTF_))
945 );
946 assert_eq!(
947 ::std::mem::align_of::<_FS_RECTF_>(),
948 4usize,
949 concat!("Alignment of ", stringify!(_FS_RECTF_))
950 );
951 assert_eq!(
952 unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
953 0usize,
954 concat!(
955 "Offset of field: ",
956 stringify!(_FS_RECTF_),
957 "::",
958 stringify!(left)
959 )
960 );
961 assert_eq!(
962 unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
963 4usize,
964 concat!(
965 "Offset of field: ",
966 stringify!(_FS_RECTF_),
967 "::",
968 stringify!(top)
969 )
970 );
971 assert_eq!(
972 unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
973 8usize,
974 concat!(
975 "Offset of field: ",
976 stringify!(_FS_RECTF_),
977 "::",
978 stringify!(right)
979 )
980 );
981 assert_eq!(
982 unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
983 12usize,
984 concat!(
985 "Offset of field: ",
986 stringify!(_FS_RECTF_),
987 "::",
988 stringify!(bottom)
989 )
990 );
991}
992#[doc = " Rectangle area(float) in device or page coordinate system."]
993pub type FS_LPRECTF = *mut _FS_RECTF_;
994#[doc = " Rectangle area(float) in device or page coordinate system."]
995pub type FS_RECTF = _FS_RECTF_;
996#[doc = " Const Pointer to FS_RECTF structure."]
997pub type FS_LPCRECTF = *const FS_RECTF;
998#[doc = " Rectangle size. Coordinate system agnostic."]
999#[repr(C)]
1000#[derive(Debug, Copy, Clone)]
1001pub struct FS_SIZEF_ {
1002 pub width: f32,
1003 pub height: f32,
1004}
1005#[test]
1006fn bindgen_test_layout_FS_SIZEF_() {
1007 const UNINIT: ::std::mem::MaybeUninit<FS_SIZEF_> = ::std::mem::MaybeUninit::uninit();
1008 let ptr = UNINIT.as_ptr();
1009 assert_eq!(
1010 ::std::mem::size_of::<FS_SIZEF_>(),
1011 8usize,
1012 concat!("Size of: ", stringify!(FS_SIZEF_))
1013 );
1014 assert_eq!(
1015 ::std::mem::align_of::<FS_SIZEF_>(),
1016 4usize,
1017 concat!("Alignment of ", stringify!(FS_SIZEF_))
1018 );
1019 assert_eq!(
1020 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
1021 0usize,
1022 concat!(
1023 "Offset of field: ",
1024 stringify!(FS_SIZEF_),
1025 "::",
1026 stringify!(width)
1027 )
1028 );
1029 assert_eq!(
1030 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
1031 4usize,
1032 concat!(
1033 "Offset of field: ",
1034 stringify!(FS_SIZEF_),
1035 "::",
1036 stringify!(height)
1037 )
1038 );
1039}
1040#[doc = " Rectangle size. Coordinate system agnostic."]
1041pub type FS_LPSIZEF = *mut FS_SIZEF_;
1042#[doc = " Rectangle size. Coordinate system agnostic."]
1043pub type FS_SIZEF = FS_SIZEF_;
1044#[doc = " Const Pointer to FS_SIZEF structure."]
1045pub type FS_LPCSIZEF = *const FS_SIZEF;
1046#[doc = " 2D Point. Coordinate system agnostic."]
1047#[repr(C)]
1048#[derive(Debug, Copy, Clone)]
1049pub struct FS_POINTF_ {
1050 pub x: f32,
1051 pub y: f32,
1052}
1053#[test]
1054fn bindgen_test_layout_FS_POINTF_() {
1055 const UNINIT: ::std::mem::MaybeUninit<FS_POINTF_> = ::std::mem::MaybeUninit::uninit();
1056 let ptr = UNINIT.as_ptr();
1057 assert_eq!(
1058 ::std::mem::size_of::<FS_POINTF_>(),
1059 8usize,
1060 concat!("Size of: ", stringify!(FS_POINTF_))
1061 );
1062 assert_eq!(
1063 ::std::mem::align_of::<FS_POINTF_>(),
1064 4usize,
1065 concat!("Alignment of ", stringify!(FS_POINTF_))
1066 );
1067 assert_eq!(
1068 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
1069 0usize,
1070 concat!(
1071 "Offset of field: ",
1072 stringify!(FS_POINTF_),
1073 "::",
1074 stringify!(x)
1075 )
1076 );
1077 assert_eq!(
1078 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
1079 4usize,
1080 concat!(
1081 "Offset of field: ",
1082 stringify!(FS_POINTF_),
1083 "::",
1084 stringify!(y)
1085 )
1086 );
1087}
1088#[doc = " 2D Point. Coordinate system agnostic."]
1089pub type FS_LPPOINTF = *mut FS_POINTF_;
1090#[doc = " 2D Point. Coordinate system agnostic."]
1091pub type FS_POINTF = FS_POINTF_;
1092#[doc = " Const Pointer to FS_POINTF structure."]
1093pub type FS_LPCPOINTF = *const FS_POINTF;
1094#[repr(C)]
1095#[derive(Debug, Copy, Clone)]
1096pub struct _FS_QUADPOINTSF {
1097 pub x1: FS_FLOAT,
1098 pub y1: FS_FLOAT,
1099 pub x2: FS_FLOAT,
1100 pub y2: FS_FLOAT,
1101 pub x3: FS_FLOAT,
1102 pub y3: FS_FLOAT,
1103 pub x4: FS_FLOAT,
1104 pub y4: FS_FLOAT,
1105}
1106#[test]
1107fn bindgen_test_layout__FS_QUADPOINTSF() {
1108 const UNINIT: ::std::mem::MaybeUninit<_FS_QUADPOINTSF> = ::std::mem::MaybeUninit::uninit();
1109 let ptr = UNINIT.as_ptr();
1110 assert_eq!(
1111 ::std::mem::size_of::<_FS_QUADPOINTSF>(),
1112 32usize,
1113 concat!("Size of: ", stringify!(_FS_QUADPOINTSF))
1114 );
1115 assert_eq!(
1116 ::std::mem::align_of::<_FS_QUADPOINTSF>(),
1117 4usize,
1118 concat!("Alignment of ", stringify!(_FS_QUADPOINTSF))
1119 );
1120 assert_eq!(
1121 unsafe { ::std::ptr::addr_of!((*ptr).x1) as usize - ptr as usize },
1122 0usize,
1123 concat!(
1124 "Offset of field: ",
1125 stringify!(_FS_QUADPOINTSF),
1126 "::",
1127 stringify!(x1)
1128 )
1129 );
1130 assert_eq!(
1131 unsafe { ::std::ptr::addr_of!((*ptr).y1) as usize - ptr as usize },
1132 4usize,
1133 concat!(
1134 "Offset of field: ",
1135 stringify!(_FS_QUADPOINTSF),
1136 "::",
1137 stringify!(y1)
1138 )
1139 );
1140 assert_eq!(
1141 unsafe { ::std::ptr::addr_of!((*ptr).x2) as usize - ptr as usize },
1142 8usize,
1143 concat!(
1144 "Offset of field: ",
1145 stringify!(_FS_QUADPOINTSF),
1146 "::",
1147 stringify!(x2)
1148 )
1149 );
1150 assert_eq!(
1151 unsafe { ::std::ptr::addr_of!((*ptr).y2) as usize - ptr as usize },
1152 12usize,
1153 concat!(
1154 "Offset of field: ",
1155 stringify!(_FS_QUADPOINTSF),
1156 "::",
1157 stringify!(y2)
1158 )
1159 );
1160 assert_eq!(
1161 unsafe { ::std::ptr::addr_of!((*ptr).x3) as usize - ptr as usize },
1162 16usize,
1163 concat!(
1164 "Offset of field: ",
1165 stringify!(_FS_QUADPOINTSF),
1166 "::",
1167 stringify!(x3)
1168 )
1169 );
1170 assert_eq!(
1171 unsafe { ::std::ptr::addr_of!((*ptr).y3) as usize - ptr as usize },
1172 20usize,
1173 concat!(
1174 "Offset of field: ",
1175 stringify!(_FS_QUADPOINTSF),
1176 "::",
1177 stringify!(y3)
1178 )
1179 );
1180 assert_eq!(
1181 unsafe { ::std::ptr::addr_of!((*ptr).x4) as usize - ptr as usize },
1182 24usize,
1183 concat!(
1184 "Offset of field: ",
1185 stringify!(_FS_QUADPOINTSF),
1186 "::",
1187 stringify!(x4)
1188 )
1189 );
1190 assert_eq!(
1191 unsafe { ::std::ptr::addr_of!((*ptr).y4) as usize - ptr as usize },
1192 28usize,
1193 concat!(
1194 "Offset of field: ",
1195 stringify!(_FS_QUADPOINTSF),
1196 "::",
1197 stringify!(y4)
1198 )
1199 );
1200}
1201pub type FS_QUADPOINTSF = _FS_QUADPOINTSF;
1202#[doc = " Annotation enums."]
1203pub type FPDF_ANNOTATION_SUBTYPE = ::std::os::raw::c_int;
1204pub type FPDF_ANNOT_APPEARANCEMODE = ::std::os::raw::c_int;
1205#[doc = " Dictionary value types."]
1206pub type FPDF_OBJECT_TYPE = ::std::os::raw::c_int;
1207#[doc = " Anti-Grain Geometry - https://sourceforge.net/projects/agg/"]
1208pub const FPDF_RENDERER_TYPE_FPDF_RENDERERTYPE_AGG: FPDF_RENDERER_TYPE = 0;
1209#[doc = " Skia - https://skia.org/"]
1210pub const FPDF_RENDERER_TYPE_FPDF_RENDERERTYPE_SKIA: FPDF_RENDERER_TYPE = 1;
1211#[doc = " PDF renderer types - Experimental.\n Selection of 2D graphics library to use for rendering to FPDF_BITMAPs."]
1212pub type FPDF_RENDERER_TYPE = ::std::os::raw::c_uint;
1213#[doc = " Process-wide options for initializing the library."]
1214#[repr(C)]
1215#[derive(Debug, Copy, Clone)]
1216pub struct FPDF_LIBRARY_CONFIG_ {
1217 #[doc = " Version number of the interface. Currently must be 2.\n Support for version 1 will be deprecated in the future."]
1218 pub version: ::std::os::raw::c_int,
1219 #[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."]
1220 pub m_pUserFontPaths: *mut *const ::std::os::raw::c_char,
1221 #[doc = " Pointer to the v8::Isolate to use, or NULL to force PDFium to create one."]
1222 pub m_pIsolate: *mut ::std::os::raw::c_void,
1223 #[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."]
1224 pub m_v8EmbedderSlot: ::std::os::raw::c_uint,
1225 #[doc = " Pointer to the V8::Platform to use."]
1226 pub m_pPlatform: *mut ::std::os::raw::c_void,
1227 #[doc = " Explicit specification of core renderer to use. |m_RendererType| must be\n a valid value for |FPDF_LIBRARY_CONFIG| versions of this level or higher,\n or else the initialization will fail with an immediate crash.\n Note that use of a specified |FPDF_RENDERER_TYPE| value for which the\n corresponding render library is not included in the build will similarly\n fail with an immediate crash."]
1228 pub m_RendererType: FPDF_RENDERER_TYPE,
1229}
1230#[test]
1231fn bindgen_test_layout_FPDF_LIBRARY_CONFIG_() {
1232 const UNINIT: ::std::mem::MaybeUninit<FPDF_LIBRARY_CONFIG_> = ::std::mem::MaybeUninit::uninit();
1233 let ptr = UNINIT.as_ptr();
1234 assert_eq!(
1235 ::std::mem::size_of::<FPDF_LIBRARY_CONFIG_>(),
1236 48usize,
1237 concat!("Size of: ", stringify!(FPDF_LIBRARY_CONFIG_))
1238 );
1239 assert_eq!(
1240 ::std::mem::align_of::<FPDF_LIBRARY_CONFIG_>(),
1241 8usize,
1242 concat!("Alignment of ", stringify!(FPDF_LIBRARY_CONFIG_))
1243 );
1244 assert_eq!(
1245 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
1246 0usize,
1247 concat!(
1248 "Offset of field: ",
1249 stringify!(FPDF_LIBRARY_CONFIG_),
1250 "::",
1251 stringify!(version)
1252 )
1253 );
1254 assert_eq!(
1255 unsafe { ::std::ptr::addr_of!((*ptr).m_pUserFontPaths) as usize - ptr as usize },
1256 8usize,
1257 concat!(
1258 "Offset of field: ",
1259 stringify!(FPDF_LIBRARY_CONFIG_),
1260 "::",
1261 stringify!(m_pUserFontPaths)
1262 )
1263 );
1264 assert_eq!(
1265 unsafe { ::std::ptr::addr_of!((*ptr).m_pIsolate) as usize - ptr as usize },
1266 16usize,
1267 concat!(
1268 "Offset of field: ",
1269 stringify!(FPDF_LIBRARY_CONFIG_),
1270 "::",
1271 stringify!(m_pIsolate)
1272 )
1273 );
1274 assert_eq!(
1275 unsafe { ::std::ptr::addr_of!((*ptr).m_v8EmbedderSlot) as usize - ptr as usize },
1276 24usize,
1277 concat!(
1278 "Offset of field: ",
1279 stringify!(FPDF_LIBRARY_CONFIG_),
1280 "::",
1281 stringify!(m_v8EmbedderSlot)
1282 )
1283 );
1284 assert_eq!(
1285 unsafe { ::std::ptr::addr_of!((*ptr).m_pPlatform) as usize - ptr as usize },
1286 32usize,
1287 concat!(
1288 "Offset of field: ",
1289 stringify!(FPDF_LIBRARY_CONFIG_),
1290 "::",
1291 stringify!(m_pPlatform)
1292 )
1293 );
1294 assert_eq!(
1295 unsafe { ::std::ptr::addr_of!((*ptr).m_RendererType) as usize - ptr as usize },
1296 40usize,
1297 concat!(
1298 "Offset of field: ",
1299 stringify!(FPDF_LIBRARY_CONFIG_),
1300 "::",
1301 stringify!(m_RendererType)
1302 )
1303 );
1304}
1305#[doc = " Process-wide options for initializing the library."]
1306pub type FPDF_LIBRARY_CONFIG = FPDF_LIBRARY_CONFIG_;
1307extern "C" {
1308 #[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."]
1309 pub fn FPDF_InitLibraryWithConfig(config: *const FPDF_LIBRARY_CONFIG);
1310}
1311extern "C" {
1312 #[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."]
1313 pub fn FPDF_InitLibrary();
1314}
1315extern "C" {
1316 #[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."]
1317 pub fn FPDF_DestroyLibrary();
1318}
1319extern "C" {
1320 #[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."]
1321 pub fn FPDF_SetSandBoxPolicy(policy: FPDF_DWORD, enable: FPDF_BOOL);
1322}
1323extern "C" {
1324 #[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."]
1325 pub fn FPDF_LoadDocument(file_path: FPDF_STRING, password: FPDF_BYTESTRING) -> FPDF_DOCUMENT;
1326}
1327extern "C" {
1328 #[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."]
1329 pub fn FPDF_LoadMemDocument(
1330 data_buf: *const ::std::os::raw::c_void,
1331 size: ::std::os::raw::c_int,
1332 password: FPDF_BYTESTRING,
1333 ) -> FPDF_DOCUMENT;
1334}
1335extern "C" {
1336 #[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."]
1337 pub fn FPDF_LoadMemDocument64(
1338 data_buf: *const ::std::os::raw::c_void,
1339 size: usize,
1340 password: FPDF_BYTESTRING,
1341 ) -> FPDF_DOCUMENT;
1342}
1343#[doc = " Structure for custom file access."]
1344#[repr(C)]
1345#[derive(Debug, Copy, Clone)]
1346pub struct FPDF_FILEACCESS {
1347 #[doc = " File length, in bytes."]
1348 pub m_FileLen: ::std::os::raw::c_ulong,
1349 #[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."]
1350 pub m_GetBlock: ::std::option::Option<
1351 unsafe extern "C" fn(
1352 param: *mut ::std::os::raw::c_void,
1353 position: ::std::os::raw::c_ulong,
1354 pBuf: *mut ::std::os::raw::c_uchar,
1355 size: ::std::os::raw::c_ulong,
1356 ) -> ::std::os::raw::c_int,
1357 >,
1358 #[doc = " A custom pointer for all implementation specific data. This pointer will\n be used as the first parameter to the m_GetBlock callback."]
1359 pub m_Param: *mut ::std::os::raw::c_void,
1360}
1361#[test]
1362fn bindgen_test_layout_FPDF_FILEACCESS() {
1363 const UNINIT: ::std::mem::MaybeUninit<FPDF_FILEACCESS> = ::std::mem::MaybeUninit::uninit();
1364 let ptr = UNINIT.as_ptr();
1365 assert_eq!(
1366 ::std::mem::size_of::<FPDF_FILEACCESS>(),
1367 24usize,
1368 concat!("Size of: ", stringify!(FPDF_FILEACCESS))
1369 );
1370 assert_eq!(
1371 ::std::mem::align_of::<FPDF_FILEACCESS>(),
1372 8usize,
1373 concat!("Alignment of ", stringify!(FPDF_FILEACCESS))
1374 );
1375 assert_eq!(
1376 unsafe { ::std::ptr::addr_of!((*ptr).m_FileLen) as usize - ptr as usize },
1377 0usize,
1378 concat!(
1379 "Offset of field: ",
1380 stringify!(FPDF_FILEACCESS),
1381 "::",
1382 stringify!(m_FileLen)
1383 )
1384 );
1385 assert_eq!(
1386 unsafe { ::std::ptr::addr_of!((*ptr).m_GetBlock) as usize - ptr as usize },
1387 8usize,
1388 concat!(
1389 "Offset of field: ",
1390 stringify!(FPDF_FILEACCESS),
1391 "::",
1392 stringify!(m_GetBlock)
1393 )
1394 );
1395 assert_eq!(
1396 unsafe { ::std::ptr::addr_of!((*ptr).m_Param) as usize - ptr as usize },
1397 16usize,
1398 concat!(
1399 "Offset of field: ",
1400 stringify!(FPDF_FILEACCESS),
1401 "::",
1402 stringify!(m_Param)
1403 )
1404 );
1405}
1406#[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."]
1407#[repr(C)]
1408#[derive(Debug, Copy, Clone)]
1409pub struct FPDF_FILEHANDLER_ {
1410 #[doc = " User-defined data.\n Note: Callers can use this field to track controls."]
1411 pub clientData: *mut ::std::os::raw::c_void,
1412 #[doc = " Callback function to release the current file stream object.\n\n Parameters:\n clientData - Pointer to user-defined data.\n Returns:\n None."]
1413 pub Release:
1414 ::std::option::Option<unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void)>,
1415 #[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."]
1416 pub GetSize: ::std::option::Option<
1417 unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void) -> FPDF_DWORD,
1418 >,
1419 #[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."]
1420 pub ReadBlock: ::std::option::Option<
1421 unsafe extern "C" fn(
1422 clientData: *mut ::std::os::raw::c_void,
1423 offset: FPDF_DWORD,
1424 buffer: *mut ::std::os::raw::c_void,
1425 size: FPDF_DWORD,
1426 ) -> FPDF_RESULT,
1427 >,
1428 #[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."]
1429 pub WriteBlock: ::std::option::Option<
1430 unsafe extern "C" fn(
1431 clientData: *mut ::std::os::raw::c_void,
1432 offset: FPDF_DWORD,
1433 buffer: *const ::std::os::raw::c_void,
1434 size: FPDF_DWORD,
1435 ) -> FPDF_RESULT,
1436 >,
1437 #[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."]
1438 pub Flush: ::std::option::Option<
1439 unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void) -> FPDF_RESULT,
1440 >,
1441 #[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."]
1442 pub Truncate: ::std::option::Option<
1443 unsafe extern "C" fn(
1444 clientData: *mut ::std::os::raw::c_void,
1445 size: FPDF_DWORD,
1446 ) -> FPDF_RESULT,
1447 >,
1448}
1449#[test]
1450fn bindgen_test_layout_FPDF_FILEHANDLER_() {
1451 const UNINIT: ::std::mem::MaybeUninit<FPDF_FILEHANDLER_> = ::std::mem::MaybeUninit::uninit();
1452 let ptr = UNINIT.as_ptr();
1453 assert_eq!(
1454 ::std::mem::size_of::<FPDF_FILEHANDLER_>(),
1455 56usize,
1456 concat!("Size of: ", stringify!(FPDF_FILEHANDLER_))
1457 );
1458 assert_eq!(
1459 ::std::mem::align_of::<FPDF_FILEHANDLER_>(),
1460 8usize,
1461 concat!("Alignment of ", stringify!(FPDF_FILEHANDLER_))
1462 );
1463 assert_eq!(
1464 unsafe { ::std::ptr::addr_of!((*ptr).clientData) as usize - ptr as usize },
1465 0usize,
1466 concat!(
1467 "Offset of field: ",
1468 stringify!(FPDF_FILEHANDLER_),
1469 "::",
1470 stringify!(clientData)
1471 )
1472 );
1473 assert_eq!(
1474 unsafe { ::std::ptr::addr_of!((*ptr).Release) as usize - ptr as usize },
1475 8usize,
1476 concat!(
1477 "Offset of field: ",
1478 stringify!(FPDF_FILEHANDLER_),
1479 "::",
1480 stringify!(Release)
1481 )
1482 );
1483 assert_eq!(
1484 unsafe { ::std::ptr::addr_of!((*ptr).GetSize) as usize - ptr as usize },
1485 16usize,
1486 concat!(
1487 "Offset of field: ",
1488 stringify!(FPDF_FILEHANDLER_),
1489 "::",
1490 stringify!(GetSize)
1491 )
1492 );
1493 assert_eq!(
1494 unsafe { ::std::ptr::addr_of!((*ptr).ReadBlock) as usize - ptr as usize },
1495 24usize,
1496 concat!(
1497 "Offset of field: ",
1498 stringify!(FPDF_FILEHANDLER_),
1499 "::",
1500 stringify!(ReadBlock)
1501 )
1502 );
1503 assert_eq!(
1504 unsafe { ::std::ptr::addr_of!((*ptr).WriteBlock) as usize - ptr as usize },
1505 32usize,
1506 concat!(
1507 "Offset of field: ",
1508 stringify!(FPDF_FILEHANDLER_),
1509 "::",
1510 stringify!(WriteBlock)
1511 )
1512 );
1513 assert_eq!(
1514 unsafe { ::std::ptr::addr_of!((*ptr).Flush) as usize - ptr as usize },
1515 40usize,
1516 concat!(
1517 "Offset of field: ",
1518 stringify!(FPDF_FILEHANDLER_),
1519 "::",
1520 stringify!(Flush)
1521 )
1522 );
1523 assert_eq!(
1524 unsafe { ::std::ptr::addr_of!((*ptr).Truncate) as usize - ptr as usize },
1525 48usize,
1526 concat!(
1527 "Offset of field: ",
1528 stringify!(FPDF_FILEHANDLER_),
1529 "::",
1530 stringify!(Truncate)
1531 )
1532 );
1533}
1534#[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."]
1535pub type FPDF_FILEHANDLER = FPDF_FILEHANDLER_;
1536extern "C" {
1537 #[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."]
1538 pub fn FPDF_LoadCustomDocument(
1539 pFileAccess: *mut FPDF_FILEACCESS,
1540 password: FPDF_BYTESTRING,
1541 ) -> FPDF_DOCUMENT;
1542}
1543extern "C" {
1544 #[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."]
1545 pub fn FPDF_GetFileVersion(
1546 doc: FPDF_DOCUMENT,
1547 fileVersion: *mut ::std::os::raw::c_int,
1548 ) -> FPDF_BOOL;
1549}
1550extern "C" {
1551 #[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."]
1552 pub fn FPDF_GetLastError() -> ::std::os::raw::c_ulong;
1553}
1554extern "C" {
1555 #[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."]
1556 pub fn FPDF_DocumentHasValidCrossReferenceTable(document: FPDF_DOCUMENT) -> FPDF_BOOL;
1557}
1558extern "C" {
1559 #[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."]
1560 pub fn FPDF_GetTrailerEnds(
1561 document: FPDF_DOCUMENT,
1562 buffer: *mut ::std::os::raw::c_uint,
1563 length: ::std::os::raw::c_ulong,
1564 ) -> ::std::os::raw::c_ulong;
1565}
1566extern "C" {
1567 #[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."]
1568 pub fn FPDF_GetDocPermissions(document: FPDF_DOCUMENT) -> ::std::os::raw::c_ulong;
1569}
1570extern "C" {
1571 #[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."]
1572 pub fn FPDF_GetDocUserPermissions(document: FPDF_DOCUMENT) -> ::std::os::raw::c_ulong;
1573}
1574extern "C" {
1575 #[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."]
1576 pub fn FPDF_GetSecurityHandlerRevision(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1577}
1578extern "C" {
1579 #[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."]
1580 pub fn FPDF_GetPageCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1581}
1582extern "C" {
1583 #[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."]
1584 pub fn FPDF_LoadPage(document: FPDF_DOCUMENT, page_index: ::std::os::raw::c_int) -> FPDF_PAGE;
1585}
1586extern "C" {
1587 #[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)."]
1588 pub fn FPDF_GetPageWidthF(page: FPDF_PAGE) -> f32;
1589}
1590extern "C" {
1591 #[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."]
1592 pub fn FPDF_GetPageWidth(page: FPDF_PAGE) -> f64;
1593}
1594extern "C" {
1595 #[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)"]
1596 pub fn FPDF_GetPageHeightF(page: FPDF_PAGE) -> f32;
1597}
1598extern "C" {
1599 #[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."]
1600 pub fn FPDF_GetPageHeight(page: FPDF_PAGE) -> f64;
1601}
1602extern "C" {
1603 #[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."]
1604 pub fn FPDF_GetPageBoundingBox(page: FPDF_PAGE, rect: *mut FS_RECTF) -> FPDF_BOOL;
1605}
1606extern "C" {
1607 #[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)."]
1608 pub fn FPDF_GetPageSizeByIndexF(
1609 document: FPDF_DOCUMENT,
1610 page_index: ::std::os::raw::c_int,
1611 size: *mut FS_SIZEF,
1612 ) -> FPDF_BOOL;
1613}
1614extern "C" {
1615 #[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."]
1616 pub fn FPDF_GetPageSizeByIndex(
1617 document: FPDF_DOCUMENT,
1618 page_index: ::std::os::raw::c_int,
1619 width: *mut f64,
1620 height: *mut f64,
1621 ) -> ::std::os::raw::c_int;
1622}
1623#[doc = " Struct for color scheme.\n Each should be a 32-bit value specifying the color, in 8888 ARGB format."]
1624#[repr(C)]
1625#[derive(Debug, Copy, Clone)]
1626pub struct FPDF_COLORSCHEME_ {
1627 pub path_fill_color: FPDF_DWORD,
1628 pub path_stroke_color: FPDF_DWORD,
1629 pub text_fill_color: FPDF_DWORD,
1630 pub text_stroke_color: FPDF_DWORD,
1631}
1632#[test]
1633fn bindgen_test_layout_FPDF_COLORSCHEME_() {
1634 const UNINIT: ::std::mem::MaybeUninit<FPDF_COLORSCHEME_> = ::std::mem::MaybeUninit::uninit();
1635 let ptr = UNINIT.as_ptr();
1636 assert_eq!(
1637 ::std::mem::size_of::<FPDF_COLORSCHEME_>(),
1638 32usize,
1639 concat!("Size of: ", stringify!(FPDF_COLORSCHEME_))
1640 );
1641 assert_eq!(
1642 ::std::mem::align_of::<FPDF_COLORSCHEME_>(),
1643 8usize,
1644 concat!("Alignment of ", stringify!(FPDF_COLORSCHEME_))
1645 );
1646 assert_eq!(
1647 unsafe { ::std::ptr::addr_of!((*ptr).path_fill_color) as usize - ptr as usize },
1648 0usize,
1649 concat!(
1650 "Offset of field: ",
1651 stringify!(FPDF_COLORSCHEME_),
1652 "::",
1653 stringify!(path_fill_color)
1654 )
1655 );
1656 assert_eq!(
1657 unsafe { ::std::ptr::addr_of!((*ptr).path_stroke_color) as usize - ptr as usize },
1658 8usize,
1659 concat!(
1660 "Offset of field: ",
1661 stringify!(FPDF_COLORSCHEME_),
1662 "::",
1663 stringify!(path_stroke_color)
1664 )
1665 );
1666 assert_eq!(
1667 unsafe { ::std::ptr::addr_of!((*ptr).text_fill_color) as usize - ptr as usize },
1668 16usize,
1669 concat!(
1670 "Offset of field: ",
1671 stringify!(FPDF_COLORSCHEME_),
1672 "::",
1673 stringify!(text_fill_color)
1674 )
1675 );
1676 assert_eq!(
1677 unsafe { ::std::ptr::addr_of!((*ptr).text_stroke_color) as usize - ptr as usize },
1678 24usize,
1679 concat!(
1680 "Offset of field: ",
1681 stringify!(FPDF_COLORSCHEME_),
1682 "::",
1683 stringify!(text_stroke_color)
1684 )
1685 );
1686}
1687#[doc = " Struct for color scheme.\n Each should be a 32-bit value specifying the color, in 8888 ARGB format."]
1688pub type FPDF_COLORSCHEME = FPDF_COLORSCHEME_;
1689extern "C" {
1690 #[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."]
1691 pub fn FPDF_RenderPageBitmap(
1692 bitmap: FPDF_BITMAP,
1693 page: FPDF_PAGE,
1694 start_x: ::std::os::raw::c_int,
1695 start_y: ::std::os::raw::c_int,
1696 size_x: ::std::os::raw::c_int,
1697 size_y: ::std::os::raw::c_int,
1698 rotate: ::std::os::raw::c_int,
1699 flags: ::std::os::raw::c_int,
1700 );
1701}
1702extern "C" {
1703 #[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."]
1704 pub fn FPDF_RenderPageBitmapWithMatrix(
1705 bitmap: FPDF_BITMAP,
1706 page: FPDF_PAGE,
1707 matrix: *const FS_MATRIX,
1708 clipping: *const FS_RECTF,
1709 flags: ::std::os::raw::c_int,
1710 );
1711}
1712extern "C" {
1713 #[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."]
1714 pub fn FPDF_RenderPageSkia(
1715 canvas: FPDF_SKIA_CANVAS,
1716 page: FPDF_PAGE,
1717 size_x: ::std::os::raw::c_int,
1718 size_y: ::std::os::raw::c_int,
1719 );
1720}
1721extern "C" {
1722 #[doc = " Function: FPDF_ClosePage\n Close a loaded PDF page.\n Parameters:\n page - Handle to the loaded page.\n Return value:\n None."]
1723 pub fn FPDF_ClosePage(page: FPDF_PAGE);
1724}
1725extern "C" {
1726 #[doc = " Function: FPDF_CloseDocument\n Close a loaded PDF document.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n None."]
1727 pub fn FPDF_CloseDocument(document: FPDF_DOCUMENT);
1728}
1729extern "C" {
1730 #[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."]
1731 pub fn FPDF_DeviceToPage(
1732 page: FPDF_PAGE,
1733 start_x: ::std::os::raw::c_int,
1734 start_y: ::std::os::raw::c_int,
1735 size_x: ::std::os::raw::c_int,
1736 size_y: ::std::os::raw::c_int,
1737 rotate: ::std::os::raw::c_int,
1738 device_x: ::std::os::raw::c_int,
1739 device_y: ::std::os::raw::c_int,
1740 page_x: *mut f64,
1741 page_y: *mut f64,
1742 ) -> FPDF_BOOL;
1743}
1744extern "C" {
1745 #[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()."]
1746 pub fn FPDF_PageToDevice(
1747 page: FPDF_PAGE,
1748 start_x: ::std::os::raw::c_int,
1749 start_y: ::std::os::raw::c_int,
1750 size_x: ::std::os::raw::c_int,
1751 size_y: ::std::os::raw::c_int,
1752 rotate: ::std::os::raw::c_int,
1753 page_x: f64,
1754 page_y: f64,
1755 device_x: *mut ::std::os::raw::c_int,
1756 device_y: *mut ::std::os::raw::c_int,
1757 ) -> FPDF_BOOL;
1758}
1759extern "C" {
1760 #[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."]
1761 pub fn FPDFBitmap_Create(
1762 width: ::std::os::raw::c_int,
1763 height: ::std::os::raw::c_int,
1764 alpha: ::std::os::raw::c_int,
1765 ) -> FPDF_BITMAP;
1766}
1767extern "C" {
1768 #[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."]
1769 pub fn FPDFBitmap_CreateEx(
1770 width: ::std::os::raw::c_int,
1771 height: ::std::os::raw::c_int,
1772 format: ::std::os::raw::c_int,
1773 first_scan: *mut ::std::os::raw::c_void,
1774 stride: ::std::os::raw::c_int,
1775 ) -> FPDF_BITMAP;
1776}
1777extern "C" {
1778 #[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."]
1779 pub fn FPDFBitmap_GetFormat(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1780}
1781extern "C" {
1782 #[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."]
1783 pub fn FPDFBitmap_FillRect(
1784 bitmap: FPDF_BITMAP,
1785 left: ::std::os::raw::c_int,
1786 top: ::std::os::raw::c_int,
1787 width: ::std::os::raw::c_int,
1788 height: ::std::os::raw::c_int,
1789 color: FPDF_DWORD,
1790 ) -> FPDF_BOOL;
1791}
1792extern "C" {
1793 #[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."]
1794 pub fn FPDFBitmap_GetBuffer(bitmap: FPDF_BITMAP) -> *mut ::std::os::raw::c_void;
1795}
1796extern "C" {
1797 #[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."]
1798 pub fn FPDFBitmap_GetWidth(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1799}
1800extern "C" {
1801 #[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."]
1802 pub fn FPDFBitmap_GetHeight(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1803}
1804extern "C" {
1805 #[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."]
1806 pub fn FPDFBitmap_GetStride(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1807}
1808extern "C" {
1809 #[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."]
1810 pub fn FPDFBitmap_Destroy(bitmap: FPDF_BITMAP);
1811}
1812extern "C" {
1813 #[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."]
1814 pub fn FPDF_VIEWERREF_GetPrintScaling(document: FPDF_DOCUMENT) -> FPDF_BOOL;
1815}
1816extern "C" {
1817 #[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."]
1818 pub fn FPDF_VIEWERREF_GetNumCopies(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1819}
1820extern "C" {
1821 #[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."]
1822 pub fn FPDF_VIEWERREF_GetPrintPageRange(document: FPDF_DOCUMENT) -> FPDF_PAGERANGE;
1823}
1824extern "C" {
1825 #[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."]
1826 pub fn FPDF_VIEWERREF_GetPrintPageRangeCount(pagerange: FPDF_PAGERANGE) -> usize;
1827}
1828extern "C" {
1829 #[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."]
1830 pub fn FPDF_VIEWERREF_GetPrintPageRangeElement(
1831 pagerange: FPDF_PAGERANGE,
1832 index: usize,
1833 ) -> ::std::os::raw::c_int;
1834}
1835extern "C" {
1836 #[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."]
1837 pub fn FPDF_VIEWERREF_GetDuplex(document: FPDF_DOCUMENT) -> FPDF_DUPLEXTYPE;
1838}
1839extern "C" {
1840 #[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."]
1841 pub fn FPDF_VIEWERREF_GetName(
1842 document: FPDF_DOCUMENT,
1843 key: FPDF_BYTESTRING,
1844 buffer: *mut ::std::os::raw::c_char,
1845 length: ::std::os::raw::c_ulong,
1846 ) -> ::std::os::raw::c_ulong;
1847}
1848extern "C" {
1849 #[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."]
1850 pub fn FPDF_CountNamedDests(document: FPDF_DOCUMENT) -> FPDF_DWORD;
1851}
1852extern "C" {
1853 #[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."]
1854 pub fn FPDF_GetNamedDestByName(document: FPDF_DOCUMENT, name: FPDF_BYTESTRING) -> FPDF_DEST;
1855}
1856extern "C" {
1857 #[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."]
1858 pub fn FPDF_GetNamedDest(
1859 document: FPDF_DOCUMENT,
1860 index: ::std::os::raw::c_int,
1861 buffer: *mut ::std::os::raw::c_void,
1862 buflen: *mut ::std::os::raw::c_long,
1863 ) -> FPDF_DEST;
1864}
1865extern "C" {
1866 #[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."]
1867 pub fn FPDF_GetXFAPacketCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1868}
1869extern "C" {
1870 #[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."]
1871 pub fn FPDF_GetXFAPacketName(
1872 document: FPDF_DOCUMENT,
1873 index: ::std::os::raw::c_int,
1874 buffer: *mut ::std::os::raw::c_void,
1875 buflen: ::std::os::raw::c_ulong,
1876 ) -> ::std::os::raw::c_ulong;
1877}
1878extern "C" {
1879 #[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|."]
1880 pub fn FPDF_GetXFAPacketContent(
1881 document: FPDF_DOCUMENT,
1882 index: ::std::os::raw::c_int,
1883 buffer: *mut ::std::os::raw::c_void,
1884 buflen: ::std::os::raw::c_ulong,
1885 out_buflen: *mut ::std::os::raw::c_ulong,
1886 ) -> FPDF_BOOL;
1887}
1888extern "C" {
1889 #[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."]
1890 pub fn FPDF_GetRecommendedV8Flags() -> *const ::std::os::raw::c_char;
1891}
1892extern "C" {
1893 #[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."]
1894 pub fn FPDF_GetArrayBufferAllocatorSharedInstance() -> *mut ::std::os::raw::c_void;
1895}
1896extern "C" {
1897 #[doc = " Function: FPDF_BStr_Init\n Helper function to initialize a FPDF_BSTR."]
1898 pub fn FPDF_BStr_Init(bstr: *mut FPDF_BSTR) -> FPDF_RESULT;
1899}
1900extern "C" {
1901 #[doc = " Function: FPDF_BStr_Set\n Helper function to copy string data into the FPDF_BSTR."]
1902 pub fn FPDF_BStr_Set(
1903 bstr: *mut FPDF_BSTR,
1904 cstr: *const ::std::os::raw::c_char,
1905 length: ::std::os::raw::c_int,
1906 ) -> FPDF_RESULT;
1907}
1908extern "C" {
1909 #[doc = " Function: FPDF_BStr_Clear\n Helper function to clear a FPDF_BSTR."]
1910 pub fn FPDF_BStr_Clear(bstr: *mut FPDF_BSTR) -> FPDF_RESULT;
1911}
1912#[repr(C)]
1913#[derive(Debug, Copy, Clone)]
1914pub struct FPDF_IMAGEOBJ_METADATA {
1915 #[doc = " The image width in pixels."]
1916 pub width: ::std::os::raw::c_uint,
1917 #[doc = " The image height in pixels."]
1918 pub height: ::std::os::raw::c_uint,
1919 #[doc = " The image's horizontal pixel-per-inch."]
1920 pub horizontal_dpi: f32,
1921 #[doc = " The image's vertical pixel-per-inch."]
1922 pub vertical_dpi: f32,
1923 #[doc = " The number of bits used to represent each pixel."]
1924 pub bits_per_pixel: ::std::os::raw::c_uint,
1925 #[doc = " The image's colorspace. See above for the list of FPDF_COLORSPACE_*."]
1926 pub colorspace: ::std::os::raw::c_int,
1927 #[doc = " The image's marked content ID. Useful for pairing with associated alt-text.\n A value of -1 indicates no ID."]
1928 pub marked_content_id: ::std::os::raw::c_int,
1929}
1930#[test]
1931fn bindgen_test_layout_FPDF_IMAGEOBJ_METADATA() {
1932 const UNINIT: ::std::mem::MaybeUninit<FPDF_IMAGEOBJ_METADATA> =
1933 ::std::mem::MaybeUninit::uninit();
1934 let ptr = UNINIT.as_ptr();
1935 assert_eq!(
1936 ::std::mem::size_of::<FPDF_IMAGEOBJ_METADATA>(),
1937 28usize,
1938 concat!("Size of: ", stringify!(FPDF_IMAGEOBJ_METADATA))
1939 );
1940 assert_eq!(
1941 ::std::mem::align_of::<FPDF_IMAGEOBJ_METADATA>(),
1942 4usize,
1943 concat!("Alignment of ", stringify!(FPDF_IMAGEOBJ_METADATA))
1944 );
1945 assert_eq!(
1946 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
1947 0usize,
1948 concat!(
1949 "Offset of field: ",
1950 stringify!(FPDF_IMAGEOBJ_METADATA),
1951 "::",
1952 stringify!(width)
1953 )
1954 );
1955 assert_eq!(
1956 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
1957 4usize,
1958 concat!(
1959 "Offset of field: ",
1960 stringify!(FPDF_IMAGEOBJ_METADATA),
1961 "::",
1962 stringify!(height)
1963 )
1964 );
1965 assert_eq!(
1966 unsafe { ::std::ptr::addr_of!((*ptr).horizontal_dpi) as usize - ptr as usize },
1967 8usize,
1968 concat!(
1969 "Offset of field: ",
1970 stringify!(FPDF_IMAGEOBJ_METADATA),
1971 "::",
1972 stringify!(horizontal_dpi)
1973 )
1974 );
1975 assert_eq!(
1976 unsafe { ::std::ptr::addr_of!((*ptr).vertical_dpi) as usize - ptr as usize },
1977 12usize,
1978 concat!(
1979 "Offset of field: ",
1980 stringify!(FPDF_IMAGEOBJ_METADATA),
1981 "::",
1982 stringify!(vertical_dpi)
1983 )
1984 );
1985 assert_eq!(
1986 unsafe { ::std::ptr::addr_of!((*ptr).bits_per_pixel) as usize - ptr as usize },
1987 16usize,
1988 concat!(
1989 "Offset of field: ",
1990 stringify!(FPDF_IMAGEOBJ_METADATA),
1991 "::",
1992 stringify!(bits_per_pixel)
1993 )
1994 );
1995 assert_eq!(
1996 unsafe { ::std::ptr::addr_of!((*ptr).colorspace) as usize - ptr as usize },
1997 20usize,
1998 concat!(
1999 "Offset of field: ",
2000 stringify!(FPDF_IMAGEOBJ_METADATA),
2001 "::",
2002 stringify!(colorspace)
2003 )
2004 );
2005 assert_eq!(
2006 unsafe { ::std::ptr::addr_of!((*ptr).marked_content_id) as usize - ptr as usize },
2007 24usize,
2008 concat!(
2009 "Offset of field: ",
2010 stringify!(FPDF_IMAGEOBJ_METADATA),
2011 "::",
2012 stringify!(marked_content_id)
2013 )
2014 );
2015}
2016extern "C" {
2017 #[doc = " Create a new PDF document.\n\n Returns a handle to a new document, or NULL on failure."]
2018 pub fn FPDF_CreateNewDocument() -> FPDF_DOCUMENT;
2019}
2020extern "C" {
2021 #[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."]
2022 pub fn FPDFPage_New(
2023 document: FPDF_DOCUMENT,
2024 page_index: ::std::os::raw::c_int,
2025 width: f64,
2026 height: f64,
2027 ) -> FPDF_PAGE;
2028}
2029extern "C" {
2030 #[doc = " Delete the page at |page_index|.\n\n document - handle to document.\n page_index - the index of the page to delete."]
2031 pub fn FPDFPage_Delete(document: FPDF_DOCUMENT, page_index: ::std::os::raw::c_int);
2032}
2033extern "C" {
2034 #[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"]
2035 pub fn FPDF_MovePages(
2036 document: FPDF_DOCUMENT,
2037 page_indices: *const ::std::os::raw::c_int,
2038 page_indices_len: ::std::os::raw::c_ulong,
2039 dest_page_index: ::std::os::raw::c_int,
2040 ) -> FPDF_BOOL;
2041}
2042extern "C" {
2043 #[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."]
2044 pub fn FPDFPage_GetRotation(page: FPDF_PAGE) -> ::std::os::raw::c_int;
2045}
2046extern "C" {
2047 #[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."]
2048 pub fn FPDFPage_SetRotation(page: FPDF_PAGE, rotate: ::std::os::raw::c_int);
2049}
2050extern "C" {
2051 #[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."]
2052 pub fn FPDFPage_InsertObject(page: FPDF_PAGE, page_object: FPDF_PAGEOBJECT);
2053}
2054extern "C" {
2055 #[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."]
2056 pub fn FPDFPage_RemoveObject(page: FPDF_PAGE, page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
2057}
2058extern "C" {
2059 #[doc = " Get number of page objects inside |page|.\n\n page - handle to a page.\n\n Returns the number of objects in |page|."]
2060 pub fn FPDFPage_CountObjects(page: FPDF_PAGE) -> ::std::os::raw::c_int;
2061}
2062extern "C" {
2063 #[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."]
2064 pub fn FPDFPage_GetObject(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_PAGEOBJECT;
2065}
2066extern "C" {
2067 #[doc = " Checks if |page| contains transparency.\n\n page - handle to a page.\n\n Returns TRUE if |page| contains transparency."]
2068 pub fn FPDFPage_HasTransparency(page: FPDF_PAGE) -> FPDF_BOOL;
2069}
2070extern "C" {
2071 #[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."]
2072 pub fn FPDFPage_GenerateContent(page: FPDF_PAGE) -> FPDF_BOOL;
2073}
2074extern "C" {
2075 #[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."]
2076 pub fn FPDFPageObj_Destroy(page_object: FPDF_PAGEOBJECT);
2077}
2078extern "C" {
2079 #[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."]
2080 pub fn FPDFPageObj_HasTransparency(page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
2081}
2082extern "C" {
2083 #[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."]
2084 pub fn FPDFPageObj_GetType(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2085}
2086extern "C" {
2087 #[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."]
2088 pub fn FPDFPageObj_GetIsActive(
2089 page_object: FPDF_PAGEOBJECT,
2090 active: *mut FPDF_BOOL,
2091 ) -> FPDF_BOOL;
2092}
2093extern "C" {
2094 #[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."]
2095 pub fn FPDFPageObj_SetIsActive(page_object: FPDF_PAGEOBJECT, active: FPDF_BOOL) -> FPDF_BOOL;
2096}
2097extern "C" {
2098 #[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|."]
2099 pub fn FPDFPageObj_Transform(
2100 page_object: FPDF_PAGEOBJECT,
2101 a: f64,
2102 b: f64,
2103 c: f64,
2104 d: f64,
2105 e: f64,
2106 f: f64,
2107 );
2108}
2109extern "C" {
2110 #[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."]
2111 pub fn FPDFPageObj_TransformF(
2112 page_object: FPDF_PAGEOBJECT,
2113 matrix: *const FS_MATRIX,
2114 ) -> FPDF_BOOL;
2115}
2116extern "C" {
2117 #[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."]
2118 pub fn FPDFPageObj_GetMatrix(page_object: FPDF_PAGEOBJECT, matrix: *mut FS_MATRIX)
2119 -> FPDF_BOOL;
2120}
2121extern "C" {
2122 #[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."]
2123 pub fn FPDFPageObj_SetMatrix(
2124 page_object: FPDF_PAGEOBJECT,
2125 matrix: *const FS_MATRIX,
2126 ) -> FPDF_BOOL;
2127}
2128extern "C" {
2129 #[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."]
2130 pub fn FPDFPage_TransformAnnots(
2131 page: FPDF_PAGE,
2132 a: f64,
2133 b: f64,
2134 c: f64,
2135 d: f64,
2136 e: f64,
2137 f: f64,
2138 );
2139}
2140extern "C" {
2141 #[doc = " Create a new image object.\n\n document - handle to a document.\n\n Returns a handle to a new image object."]
2142 pub fn FPDFPageObj_NewImageObj(document: FPDF_DOCUMENT) -> FPDF_PAGEOBJECT;
2143}
2144extern "C" {
2145 #[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."]
2146 pub fn FPDFPageObj_GetMarkedContentID(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2147}
2148extern "C" {
2149 #[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."]
2150 pub fn FPDFPageObj_CountMarks(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2151}
2152extern "C" {
2153 #[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."]
2154 pub fn FPDFPageObj_GetMark(
2155 page_object: FPDF_PAGEOBJECT,
2156 index: ::std::os::raw::c_ulong,
2157 ) -> FPDF_PAGEOBJECTMARK;
2158}
2159extern "C" {
2160 #[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."]
2161 pub fn FPDFPageObj_AddMark(
2162 page_object: FPDF_PAGEOBJECT,
2163 name: FPDF_BYTESTRING,
2164 ) -> FPDF_PAGEOBJECTMARK;
2165}
2166extern "C" {
2167 #[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."]
2168 pub fn FPDFPageObj_RemoveMark(
2169 page_object: FPDF_PAGEOBJECT,
2170 mark: FPDF_PAGEOBJECTMARK,
2171 ) -> FPDF_BOOL;
2172}
2173extern "C" {
2174 #[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."]
2175 pub fn FPDFPageObjMark_GetName(
2176 mark: FPDF_PAGEOBJECTMARK,
2177 buffer: *mut FPDF_WCHAR,
2178 buflen: ::std::os::raw::c_ulong,
2179 out_buflen: *mut ::std::os::raw::c_ulong,
2180 ) -> FPDF_BOOL;
2181}
2182extern "C" {
2183 #[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."]
2184 pub fn FPDFPageObjMark_CountParams(mark: FPDF_PAGEOBJECTMARK) -> ::std::os::raw::c_int;
2185}
2186extern "C" {
2187 #[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."]
2188 pub fn FPDFPageObjMark_GetParamKey(
2189 mark: FPDF_PAGEOBJECTMARK,
2190 index: ::std::os::raw::c_ulong,
2191 buffer: *mut FPDF_WCHAR,
2192 buflen: ::std::os::raw::c_ulong,
2193 out_buflen: *mut ::std::os::raw::c_ulong,
2194 ) -> FPDF_BOOL;
2195}
2196extern "C" {
2197 #[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."]
2198 pub fn FPDFPageObjMark_GetParamValueType(
2199 mark: FPDF_PAGEOBJECTMARK,
2200 key: FPDF_BYTESTRING,
2201 ) -> FPDF_OBJECT_TYPE;
2202}
2203extern "C" {
2204 #[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."]
2205 pub fn FPDFPageObjMark_GetParamIntValue(
2206 mark: FPDF_PAGEOBJECTMARK,
2207 key: FPDF_BYTESTRING,
2208 out_value: *mut ::std::os::raw::c_int,
2209 ) -> FPDF_BOOL;
2210}
2211extern "C" {
2212 #[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."]
2213 pub fn FPDFPageObjMark_GetParamStringValue(
2214 mark: FPDF_PAGEOBJECTMARK,
2215 key: FPDF_BYTESTRING,
2216 buffer: *mut FPDF_WCHAR,
2217 buflen: ::std::os::raw::c_ulong,
2218 out_buflen: *mut ::std::os::raw::c_ulong,
2219 ) -> FPDF_BOOL;
2220}
2221extern "C" {
2222 #[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."]
2223 pub fn FPDFPageObjMark_GetParamBlobValue(
2224 mark: FPDF_PAGEOBJECTMARK,
2225 key: FPDF_BYTESTRING,
2226 buffer: *mut ::std::os::raw::c_uchar,
2227 buflen: ::std::os::raw::c_ulong,
2228 out_buflen: *mut ::std::os::raw::c_ulong,
2229 ) -> FPDF_BOOL;
2230}
2231extern "C" {
2232 #[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."]
2233 pub fn FPDFPageObjMark_SetIntParam(
2234 document: FPDF_DOCUMENT,
2235 page_object: FPDF_PAGEOBJECT,
2236 mark: FPDF_PAGEOBJECTMARK,
2237 key: FPDF_BYTESTRING,
2238 value: ::std::os::raw::c_int,
2239 ) -> FPDF_BOOL;
2240}
2241extern "C" {
2242 #[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."]
2243 pub fn FPDFPageObjMark_SetStringParam(
2244 document: FPDF_DOCUMENT,
2245 page_object: FPDF_PAGEOBJECT,
2246 mark: FPDF_PAGEOBJECTMARK,
2247 key: FPDF_BYTESTRING,
2248 value: FPDF_BYTESTRING,
2249 ) -> FPDF_BOOL;
2250}
2251extern "C" {
2252 #[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."]
2253 pub fn FPDFPageObjMark_SetBlobParam(
2254 document: FPDF_DOCUMENT,
2255 page_object: FPDF_PAGEOBJECT,
2256 mark: FPDF_PAGEOBJECTMARK,
2257 key: FPDF_BYTESTRING,
2258 value: *const ::std::os::raw::c_uchar,
2259 value_len: ::std::os::raw::c_ulong,
2260 ) -> FPDF_BOOL;
2261}
2262extern "C" {
2263 #[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."]
2264 pub fn FPDFPageObjMark_RemoveParam(
2265 page_object: FPDF_PAGEOBJECT,
2266 mark: FPDF_PAGEOBJECTMARK,
2267 key: FPDF_BYTESTRING,
2268 ) -> FPDF_BOOL;
2269}
2270extern "C" {
2271 #[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."]
2272 pub fn FPDFImageObj_LoadJpegFile(
2273 pages: *mut FPDF_PAGE,
2274 count: ::std::os::raw::c_int,
2275 image_object: FPDF_PAGEOBJECT,
2276 file_access: *mut FPDF_FILEACCESS,
2277 ) -> FPDF_BOOL;
2278}
2279extern "C" {
2280 #[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."]
2281 pub fn FPDFImageObj_LoadJpegFileInline(
2282 pages: *mut FPDF_PAGE,
2283 count: ::std::os::raw::c_int,
2284 image_object: FPDF_PAGEOBJECT,
2285 file_access: *mut FPDF_FILEACCESS,
2286 ) -> FPDF_BOOL;
2287}
2288extern "C" {
2289 #[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."]
2290 pub fn FPDFImageObj_SetMatrix(
2291 image_object: FPDF_PAGEOBJECT,
2292 a: f64,
2293 b: f64,
2294 c: f64,
2295 d: f64,
2296 e: f64,
2297 f: f64,
2298 ) -> FPDF_BOOL;
2299}
2300extern "C" {
2301 #[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."]
2302 pub fn FPDFImageObj_SetBitmap(
2303 pages: *mut FPDF_PAGE,
2304 count: ::std::os::raw::c_int,
2305 image_object: FPDF_PAGEOBJECT,
2306 bitmap: FPDF_BITMAP,
2307 ) -> FPDF_BOOL;
2308}
2309extern "C" {
2310 #[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."]
2311 pub fn FPDFImageObj_GetBitmap(image_object: FPDF_PAGEOBJECT) -> FPDF_BITMAP;
2312}
2313extern "C" {
2314 #[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."]
2315 pub fn FPDFImageObj_GetRenderedBitmap(
2316 document: FPDF_DOCUMENT,
2317 page: FPDF_PAGE,
2318 image_object: FPDF_PAGEOBJECT,
2319 ) -> FPDF_BITMAP;
2320}
2321extern "C" {
2322 #[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."]
2323 pub fn FPDFImageObj_GetImageDataDecoded(
2324 image_object: FPDF_PAGEOBJECT,
2325 buffer: *mut ::std::os::raw::c_void,
2326 buflen: ::std::os::raw::c_ulong,
2327 ) -> ::std::os::raw::c_ulong;
2328}
2329extern "C" {
2330 #[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."]
2331 pub fn FPDFImageObj_GetImageDataRaw(
2332 image_object: FPDF_PAGEOBJECT,
2333 buffer: *mut ::std::os::raw::c_void,
2334 buflen: ::std::os::raw::c_ulong,
2335 ) -> ::std::os::raw::c_ulong;
2336}
2337extern "C" {
2338 #[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."]
2339 pub fn FPDFImageObj_GetImageFilterCount(image_object: FPDF_PAGEOBJECT)
2340 -> ::std::os::raw::c_int;
2341}
2342extern "C" {
2343 #[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."]
2344 pub fn FPDFImageObj_GetImageFilter(
2345 image_object: FPDF_PAGEOBJECT,
2346 index: ::std::os::raw::c_int,
2347 buffer: *mut ::std::os::raw::c_void,
2348 buflen: ::std::os::raw::c_ulong,
2349 ) -> ::std::os::raw::c_ulong;
2350}
2351extern "C" {
2352 #[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."]
2353 pub fn FPDFImageObj_GetImageMetadata(
2354 image_object: FPDF_PAGEOBJECT,
2355 page: FPDF_PAGE,
2356 metadata: *mut FPDF_IMAGEOBJ_METADATA,
2357 ) -> FPDF_BOOL;
2358}
2359extern "C" {
2360 #[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."]
2361 pub fn FPDFImageObj_GetImagePixelSize(
2362 image_object: FPDF_PAGEOBJECT,
2363 width: *mut ::std::os::raw::c_uint,
2364 height: *mut ::std::os::raw::c_uint,
2365 ) -> FPDF_BOOL;
2366}
2367extern "C" {
2368 #[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|."]
2369 pub fn FPDFImageObj_GetIccProfileDataDecoded(
2370 image_object: FPDF_PAGEOBJECT,
2371 page: FPDF_PAGE,
2372 buffer: *mut u8,
2373 buflen: usize,
2374 out_buflen: *mut usize,
2375 ) -> FPDF_BOOL;
2376}
2377extern "C" {
2378 #[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."]
2379 pub fn FPDFPageObj_CreateNewPath(x: f32, y: f32) -> FPDF_PAGEOBJECT;
2380}
2381extern "C" {
2382 #[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."]
2383 pub fn FPDFPageObj_CreateNewRect(x: f32, y: f32, w: f32, h: f32) -> FPDF_PAGEOBJECT;
2384}
2385extern "C" {
2386 #[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."]
2387 pub fn FPDFPageObj_GetBounds(
2388 page_object: FPDF_PAGEOBJECT,
2389 left: *mut f32,
2390 bottom: *mut f32,
2391 right: *mut f32,
2392 top: *mut f32,
2393 ) -> FPDF_BOOL;
2394}
2395extern "C" {
2396 #[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."]
2397 pub fn FPDFPageObj_GetRotatedBounds(
2398 page_object: FPDF_PAGEOBJECT,
2399 quad_points: *mut FS_QUADPOINTSF,
2400 ) -> FPDF_BOOL;
2401}
2402extern "C" {
2403 #[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"]
2404 pub fn FPDFPageObj_SetBlendMode(page_object: FPDF_PAGEOBJECT, blend_mode: FPDF_BYTESTRING);
2405}
2406extern "C" {
2407 #[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."]
2408 pub fn FPDFPageObj_SetStrokeColor(
2409 page_object: FPDF_PAGEOBJECT,
2410 R: ::std::os::raw::c_uint,
2411 G: ::std::os::raw::c_uint,
2412 B: ::std::os::raw::c_uint,
2413 A: ::std::os::raw::c_uint,
2414 ) -> FPDF_BOOL;
2415}
2416extern "C" {
2417 #[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."]
2418 pub fn FPDFPageObj_GetStrokeColor(
2419 page_object: FPDF_PAGEOBJECT,
2420 R: *mut ::std::os::raw::c_uint,
2421 G: *mut ::std::os::raw::c_uint,
2422 B: *mut ::std::os::raw::c_uint,
2423 A: *mut ::std::os::raw::c_uint,
2424 ) -> FPDF_BOOL;
2425}
2426extern "C" {
2427 #[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"]
2428 pub fn FPDFPageObj_SetStrokeWidth(page_object: FPDF_PAGEOBJECT, width: f32) -> FPDF_BOOL;
2429}
2430extern "C" {
2431 #[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"]
2432 pub fn FPDFPageObj_GetStrokeWidth(page_object: FPDF_PAGEOBJECT, width: *mut f32) -> FPDF_BOOL;
2433}
2434extern "C" {
2435 #[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"]
2436 pub fn FPDFPageObj_GetLineJoin(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2437}
2438extern "C" {
2439 #[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"]
2440 pub fn FPDFPageObj_SetLineJoin(
2441 page_object: FPDF_PAGEOBJECT,
2442 line_join: ::std::os::raw::c_int,
2443 ) -> FPDF_BOOL;
2444}
2445extern "C" {
2446 #[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"]
2447 pub fn FPDFPageObj_GetLineCap(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2448}
2449extern "C" {
2450 #[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"]
2451 pub fn FPDFPageObj_SetLineCap(
2452 page_object: FPDF_PAGEOBJECT,
2453 line_cap: ::std::os::raw::c_int,
2454 ) -> FPDF_BOOL;
2455}
2456extern "C" {
2457 #[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."]
2458 pub fn FPDFPageObj_SetFillColor(
2459 page_object: FPDF_PAGEOBJECT,
2460 R: ::std::os::raw::c_uint,
2461 G: ::std::os::raw::c_uint,
2462 B: ::std::os::raw::c_uint,
2463 A: ::std::os::raw::c_uint,
2464 ) -> FPDF_BOOL;
2465}
2466extern "C" {
2467 #[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."]
2468 pub fn FPDFPageObj_GetFillColor(
2469 page_object: FPDF_PAGEOBJECT,
2470 R: *mut ::std::os::raw::c_uint,
2471 G: *mut ::std::os::raw::c_uint,
2472 B: *mut ::std::os::raw::c_uint,
2473 A: *mut ::std::os::raw::c_uint,
2474 ) -> FPDF_BOOL;
2475}
2476extern "C" {
2477 #[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."]
2478 pub fn FPDFPageObj_GetDashPhase(page_object: FPDF_PAGEOBJECT, phase: *mut f32) -> FPDF_BOOL;
2479}
2480extern "C" {
2481 #[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."]
2482 pub fn FPDFPageObj_SetDashPhase(page_object: FPDF_PAGEOBJECT, phase: f32) -> FPDF_BOOL;
2483}
2484extern "C" {
2485 #[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."]
2486 pub fn FPDFPageObj_GetDashCount(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2487}
2488extern "C" {
2489 #[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."]
2490 pub fn FPDFPageObj_GetDashArray(
2491 page_object: FPDF_PAGEOBJECT,
2492 dash_array: *mut f32,
2493 dash_count: usize,
2494 ) -> FPDF_BOOL;
2495}
2496extern "C" {
2497 #[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."]
2498 pub fn FPDFPageObj_SetDashArray(
2499 page_object: FPDF_PAGEOBJECT,
2500 dash_array: *const f32,
2501 dash_count: usize,
2502 phase: f32,
2503 ) -> FPDF_BOOL;
2504}
2505extern "C" {
2506 #[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."]
2507 pub fn FPDFPath_CountSegments(path: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2508}
2509extern "C" {
2510 #[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."]
2511 pub fn FPDFPath_GetPathSegment(
2512 path: FPDF_PAGEOBJECT,
2513 index: ::std::os::raw::c_int,
2514 ) -> FPDF_PATHSEGMENT;
2515}
2516extern "C" {
2517 #[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."]
2518 pub fn FPDFPathSegment_GetPoint(
2519 segment: FPDF_PATHSEGMENT,
2520 x: *mut f32,
2521 y: *mut f32,
2522 ) -> FPDF_BOOL;
2523}
2524extern "C" {
2525 #[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."]
2526 pub fn FPDFPathSegment_GetType(segment: FPDF_PATHSEGMENT) -> ::std::os::raw::c_int;
2527}
2528extern "C" {
2529 #[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."]
2530 pub fn FPDFPathSegment_GetClose(segment: FPDF_PATHSEGMENT) -> FPDF_BOOL;
2531}
2532extern "C" {
2533 #[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"]
2534 pub fn FPDFPath_MoveTo(path: FPDF_PAGEOBJECT, x: f32, y: f32) -> FPDF_BOOL;
2535}
2536extern "C" {
2537 #[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"]
2538 pub fn FPDFPath_LineTo(path: FPDF_PAGEOBJECT, x: f32, y: f32) -> FPDF_BOOL;
2539}
2540extern "C" {
2541 #[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"]
2542 pub fn FPDFPath_BezierTo(
2543 path: FPDF_PAGEOBJECT,
2544 x1: f32,
2545 y1: f32,
2546 x2: f32,
2547 y2: f32,
2548 x3: f32,
2549 y3: f32,
2550 ) -> FPDF_BOOL;
2551}
2552extern "C" {
2553 #[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"]
2554 pub fn FPDFPath_Close(path: FPDF_PAGEOBJECT) -> FPDF_BOOL;
2555}
2556extern "C" {
2557 #[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"]
2558 pub fn FPDFPath_SetDrawMode(
2559 path: FPDF_PAGEOBJECT,
2560 fillmode: ::std::os::raw::c_int,
2561 stroke: FPDF_BOOL,
2562 ) -> FPDF_BOOL;
2563}
2564extern "C" {
2565 #[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"]
2566 pub fn FPDFPath_GetDrawMode(
2567 path: FPDF_PAGEOBJECT,
2568 fillmode: *mut ::std::os::raw::c_int,
2569 stroke: *mut FPDF_BOOL,
2570 ) -> FPDF_BOOL;
2571}
2572extern "C" {
2573 #[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"]
2574 pub fn FPDFPageObj_NewTextObj(
2575 document: FPDF_DOCUMENT,
2576 font: FPDF_BYTESTRING,
2577 font_size: f32,
2578 ) -> FPDF_PAGEOBJECT;
2579}
2580extern "C" {
2581 #[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"]
2582 pub fn FPDFText_SetText(text_object: FPDF_PAGEOBJECT, text: FPDF_WIDESTRING) -> FPDF_BOOL;
2583}
2584extern "C" {
2585 #[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"]
2586 pub fn FPDFText_SetCharcodes(
2587 text_object: FPDF_PAGEOBJECT,
2588 charcodes: *const u32,
2589 count: usize,
2590 ) -> FPDF_BOOL;
2591}
2592extern "C" {
2593 #[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"]
2594 pub fn FPDFText_LoadFont(
2595 document: FPDF_DOCUMENT,
2596 data: *const u8,
2597 size: u32,
2598 font_type: ::std::os::raw::c_int,
2599 cid: FPDF_BOOL,
2600 ) -> FPDF_FONT;
2601}
2602extern "C" {
2603 #[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."]
2604 pub fn FPDFText_LoadStandardFont(document: FPDF_DOCUMENT, font: FPDF_BYTESTRING) -> FPDF_FONT;
2605}
2606extern "C" {
2607 #[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."]
2608 pub fn FPDFText_LoadCidType2Font(
2609 document: FPDF_DOCUMENT,
2610 font_data: *const u8,
2611 font_data_size: u32,
2612 to_unicode_cmap: FPDF_BYTESTRING,
2613 cid_to_gid_map_data: *const u8,
2614 cid_to_gid_map_data_size: u32,
2615 ) -> FPDF_FONT;
2616}
2617extern "C" {
2618 #[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."]
2619 pub fn FPDFTextObj_GetFontSize(text: FPDF_PAGEOBJECT, size: *mut f32) -> FPDF_BOOL;
2620}
2621extern "C" {
2622 #[doc = " Close a loaded PDF font.\n\n font - Handle to the loaded font."]
2623 pub fn FPDFFont_Close(font: FPDF_FONT);
2624}
2625extern "C" {
2626 #[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"]
2627 pub fn FPDFPageObj_CreateTextObj(
2628 document: FPDF_DOCUMENT,
2629 font: FPDF_FONT,
2630 font_size: f32,
2631 ) -> FPDF_PAGEOBJECT;
2632}
2633extern "C" {
2634 #[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."]
2635 pub fn FPDFTextObj_GetTextRenderMode(text: FPDF_PAGEOBJECT) -> FPDF_TEXT_RENDERMODE;
2636}
2637extern "C" {
2638 #[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."]
2639 pub fn FPDFTextObj_SetTextRenderMode(
2640 text: FPDF_PAGEOBJECT,
2641 render_mode: FPDF_TEXT_RENDERMODE,
2642 ) -> FPDF_BOOL;
2643}
2644extern "C" {
2645 #[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."]
2646 pub fn FPDFTextObj_GetText(
2647 text_object: FPDF_PAGEOBJECT,
2648 text_page: FPDF_TEXTPAGE,
2649 buffer: *mut FPDF_WCHAR,
2650 length: ::std::os::raw::c_ulong,
2651 ) -> ::std::os::raw::c_ulong;
2652}
2653extern "C" {
2654 #[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."]
2655 pub fn FPDFTextObj_GetRenderedBitmap(
2656 document: FPDF_DOCUMENT,
2657 page: FPDF_PAGE,
2658 text_object: FPDF_PAGEOBJECT,
2659 scale: f32,
2660 ) -> FPDF_BITMAP;
2661}
2662extern "C" {
2663 #[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."]
2664 pub fn FPDFTextObj_GetFont(text: FPDF_PAGEOBJECT) -> FPDF_FONT;
2665}
2666extern "C" {
2667 #[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."]
2668 pub fn FPDFFont_GetBaseFontName(
2669 font: FPDF_FONT,
2670 buffer: *mut ::std::os::raw::c_char,
2671 length: usize,
2672 ) -> usize;
2673}
2674extern "C" {
2675 #[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."]
2676 pub fn FPDFFont_GetFamilyName(
2677 font: FPDF_FONT,
2678 buffer: *mut ::std::os::raw::c_char,
2679 length: usize,
2680 ) -> usize;
2681}
2682extern "C" {
2683 #[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."]
2684 pub fn FPDFFont_GetFontData(
2685 font: FPDF_FONT,
2686 buffer: *mut u8,
2687 buflen: usize,
2688 out_buflen: *mut usize,
2689 ) -> FPDF_BOOL;
2690}
2691extern "C" {
2692 #[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."]
2693 pub fn FPDFFont_GetIsEmbedded(font: FPDF_FONT) -> ::std::os::raw::c_int;
2694}
2695extern "C" {
2696 #[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."]
2697 pub fn FPDFFont_GetFlags(font: FPDF_FONT) -> ::std::os::raw::c_int;
2698}
2699extern "C" {
2700 #[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)."]
2701 pub fn FPDFFont_GetWeight(font: FPDF_FONT) -> ::std::os::raw::c_int;
2702}
2703extern "C" {
2704 #[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."]
2705 pub fn FPDFFont_GetItalicAngle(font: FPDF_FONT, angle: *mut ::std::os::raw::c_int)
2706 -> FPDF_BOOL;
2707}
2708extern "C" {
2709 #[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."]
2710 pub fn FPDFFont_GetAscent(font: FPDF_FONT, font_size: f32, ascent: *mut f32) -> FPDF_BOOL;
2711}
2712extern "C" {
2713 #[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."]
2714 pub fn FPDFFont_GetDescent(font: FPDF_FONT, font_size: f32, descent: *mut f32) -> FPDF_BOOL;
2715}
2716extern "C" {
2717 #[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."]
2718 pub fn FPDFFont_GetGlyphWidth(
2719 font: FPDF_FONT,
2720 glyph: u32,
2721 font_size: f32,
2722 width: *mut f32,
2723 ) -> FPDF_BOOL;
2724}
2725extern "C" {
2726 #[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."]
2727 pub fn FPDFFont_GetGlyphPath(font: FPDF_FONT, glyph: u32, font_size: f32) -> FPDF_GLYPHPATH;
2728}
2729extern "C" {
2730 #[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."]
2731 pub fn FPDFGlyphPath_CountGlyphSegments(glyphpath: FPDF_GLYPHPATH) -> ::std::os::raw::c_int;
2732}
2733extern "C" {
2734 #[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."]
2735 pub fn FPDFGlyphPath_GetGlyphPathSegment(
2736 glyphpath: FPDF_GLYPHPATH,
2737 index: ::std::os::raw::c_int,
2738 ) -> FPDF_PATHSEGMENT;
2739}
2740extern "C" {
2741 #[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."]
2742 pub fn FPDFFormObj_CountObjects(form_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
2743}
2744extern "C" {
2745 #[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."]
2746 pub fn FPDFFormObj_GetObject(
2747 form_object: FPDF_PAGEOBJECT,
2748 index: ::std::os::raw::c_ulong,
2749 ) -> FPDF_PAGEOBJECT;
2750}
2751#[doc = " Interface for checking whether sections of the file are available."]
2752#[repr(C)]
2753#[derive(Debug, Copy, Clone)]
2754pub struct _FX_FILEAVAIL {
2755 #[doc = " Version number of the interface. Must be 1."]
2756 pub version: ::std::os::raw::c_int,
2757 #[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."]
2758 pub IsDataAvail: ::std::option::Option<
2759 unsafe extern "C" fn(pThis: *mut _FX_FILEAVAIL, offset: usize, size: usize) -> FPDF_BOOL,
2760 >,
2761}
2762#[test]
2763fn bindgen_test_layout__FX_FILEAVAIL() {
2764 const UNINIT: ::std::mem::MaybeUninit<_FX_FILEAVAIL> = ::std::mem::MaybeUninit::uninit();
2765 let ptr = UNINIT.as_ptr();
2766 assert_eq!(
2767 ::std::mem::size_of::<_FX_FILEAVAIL>(),
2768 16usize,
2769 concat!("Size of: ", stringify!(_FX_FILEAVAIL))
2770 );
2771 assert_eq!(
2772 ::std::mem::align_of::<_FX_FILEAVAIL>(),
2773 8usize,
2774 concat!("Alignment of ", stringify!(_FX_FILEAVAIL))
2775 );
2776 assert_eq!(
2777 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
2778 0usize,
2779 concat!(
2780 "Offset of field: ",
2781 stringify!(_FX_FILEAVAIL),
2782 "::",
2783 stringify!(version)
2784 )
2785 );
2786 assert_eq!(
2787 unsafe { ::std::ptr::addr_of!((*ptr).IsDataAvail) as usize - ptr as usize },
2788 8usize,
2789 concat!(
2790 "Offset of field: ",
2791 stringify!(_FX_FILEAVAIL),
2792 "::",
2793 stringify!(IsDataAvail)
2794 )
2795 );
2796}
2797#[doc = " Interface for checking whether sections of the file are available."]
2798pub type FX_FILEAVAIL = _FX_FILEAVAIL;
2799extern "C" {
2800 #[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."]
2801 pub fn FPDFAvail_Create(
2802 file_avail: *mut FX_FILEAVAIL,
2803 file: *mut FPDF_FILEACCESS,
2804 ) -> FPDF_AVAIL;
2805}
2806extern "C" {
2807 #[doc = " Destroy the |avail| document availability provider.\n\n avail - handle to document availability provider to be destroyed."]
2808 pub fn FPDFAvail_Destroy(avail: FPDF_AVAIL);
2809}
2810#[doc = " Download hints interface. Used to receive hints for further downloading."]
2811#[repr(C)]
2812#[derive(Debug, Copy, Clone)]
2813pub struct _FX_DOWNLOADHINTS {
2814 #[doc = " Version number of the interface. Must be 1."]
2815 pub version: ::std::os::raw::c_int,
2816 #[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."]
2817 pub AddSegment: ::std::option::Option<
2818 unsafe extern "C" fn(pThis: *mut _FX_DOWNLOADHINTS, offset: usize, size: usize),
2819 >,
2820}
2821#[test]
2822fn bindgen_test_layout__FX_DOWNLOADHINTS() {
2823 const UNINIT: ::std::mem::MaybeUninit<_FX_DOWNLOADHINTS> = ::std::mem::MaybeUninit::uninit();
2824 let ptr = UNINIT.as_ptr();
2825 assert_eq!(
2826 ::std::mem::size_of::<_FX_DOWNLOADHINTS>(),
2827 16usize,
2828 concat!("Size of: ", stringify!(_FX_DOWNLOADHINTS))
2829 );
2830 assert_eq!(
2831 ::std::mem::align_of::<_FX_DOWNLOADHINTS>(),
2832 8usize,
2833 concat!("Alignment of ", stringify!(_FX_DOWNLOADHINTS))
2834 );
2835 assert_eq!(
2836 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
2837 0usize,
2838 concat!(
2839 "Offset of field: ",
2840 stringify!(_FX_DOWNLOADHINTS),
2841 "::",
2842 stringify!(version)
2843 )
2844 );
2845 assert_eq!(
2846 unsafe { ::std::ptr::addr_of!((*ptr).AddSegment) as usize - ptr as usize },
2847 8usize,
2848 concat!(
2849 "Offset of field: ",
2850 stringify!(_FX_DOWNLOADHINTS),
2851 "::",
2852 stringify!(AddSegment)
2853 )
2854 );
2855}
2856#[doc = " Download hints interface. Used to receive hints for further downloading."]
2857pub type FX_DOWNLOADHINTS = _FX_DOWNLOADHINTS;
2858extern "C" {
2859 #[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."]
2860 pub fn FPDFAvail_IsDocAvail(
2861 avail: FPDF_AVAIL,
2862 hints: *mut FX_DOWNLOADHINTS,
2863 ) -> ::std::os::raw::c_int;
2864}
2865extern "C" {
2866 #[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|."]
2867 pub fn FPDFAvail_GetDocument(avail: FPDF_AVAIL, password: FPDF_BYTESTRING) -> FPDF_DOCUMENT;
2868}
2869extern "C" {
2870 #[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."]
2871 pub fn FPDFAvail_GetFirstPageNum(doc: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
2872}
2873extern "C" {
2874 #[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."]
2875 pub fn FPDFAvail_IsPageAvail(
2876 avail: FPDF_AVAIL,
2877 page_index: ::std::os::raw::c_int,
2878 hints: *mut FX_DOWNLOADHINTS,
2879 ) -> ::std::os::raw::c_int;
2880}
2881extern "C" {
2882 #[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."]
2883 pub fn FPDFAvail_IsFormAvail(
2884 avail: FPDF_AVAIL,
2885 hints: *mut FX_DOWNLOADHINTS,
2886 ) -> ::std::os::raw::c_int;
2887}
2888extern "C" {
2889 #[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."]
2890 pub fn FPDFAvail_IsLinearized(avail: FPDF_AVAIL) -> ::std::os::raw::c_int;
2891}
2892#[doc = " Interface: FPDF_SYSFONTINFO\n Interface for getting system font information and font mapping"]
2893#[repr(C)]
2894#[derive(Debug, Copy, Clone)]
2895pub struct _FPDF_SYSFONTINFO {
2896 #[doc = " Version number of the interface. Currently must be 1."]
2897 pub version: ::std::os::raw::c_int,
2898 #[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\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."]
2899 pub Release: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO)>,
2900 #[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."]
2901 pub EnumFonts: ::std::option::Option<
2902 unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO, pMapper: *mut ::std::os::raw::c_void),
2903 >,
2904 #[doc = " Method: MapFont\n Use the system font mapper to get a font handle from requested\n parameters.\n Interface Version:\n 1\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."]
2905 pub MapFont: ::std::option::Option<
2906 unsafe extern "C" fn(
2907 pThis: *mut _FPDF_SYSFONTINFO,
2908 weight: ::std::os::raw::c_int,
2909 bItalic: FPDF_BOOL,
2910 charset: ::std::os::raw::c_int,
2911 pitch_family: ::std::os::raw::c_int,
2912 face: *const ::std::os::raw::c_char,
2913 bExact: *mut FPDF_BOOL,
2914 ) -> *mut ::std::os::raw::c_void,
2915 >,
2916 #[doc = " Method: GetFont\n Get a handle to a particular font by its internal ID\n Interface Version:\n 1\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."]
2917 pub GetFont: ::std::option::Option<
2918 unsafe extern "C" fn(
2919 pThis: *mut _FPDF_SYSFONTINFO,
2920 face: *const ::std::os::raw::c_char,
2921 ) -> *mut ::std::os::raw::c_void,
2922 >,
2923 #[doc = " Method: GetFontData\n Get font data from a font\n Interface Version:\n 1\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."]
2924 pub GetFontData: ::std::option::Option<
2925 unsafe extern "C" fn(
2926 pThis: *mut _FPDF_SYSFONTINFO,
2927 hFont: *mut ::std::os::raw::c_void,
2928 table: ::std::os::raw::c_uint,
2929 buffer: *mut ::std::os::raw::c_uchar,
2930 buf_size: ::std::os::raw::c_ulong,
2931 ) -> ::std::os::raw::c_ulong,
2932 >,
2933 #[doc = " Method: GetFaceName\n Get face name from a font handle\n Interface Version:\n 1\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."]
2934 pub GetFaceName: ::std::option::Option<
2935 unsafe extern "C" fn(
2936 pThis: *mut _FPDF_SYSFONTINFO,
2937 hFont: *mut ::std::os::raw::c_void,
2938 buffer: *mut ::std::os::raw::c_char,
2939 buf_size: ::std::os::raw::c_ulong,
2940 ) -> ::std::os::raw::c_ulong,
2941 >,
2942 #[doc = " Method: GetFontCharset\n Get character set information for a font handle\n Interface Version:\n 1\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."]
2943 pub GetFontCharset: ::std::option::Option<
2944 unsafe extern "C" fn(
2945 pThis: *mut _FPDF_SYSFONTINFO,
2946 hFont: *mut ::std::os::raw::c_void,
2947 ) -> ::std::os::raw::c_int,
2948 >,
2949 #[doc = " Method: DeleteFont\n Delete a font handle\n Interface Version:\n 1\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"]
2950 pub DeleteFont: ::std::option::Option<
2951 unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO, hFont: *mut ::std::os::raw::c_void),
2952 >,
2953}
2954#[test]
2955fn bindgen_test_layout__FPDF_SYSFONTINFO() {
2956 const UNINIT: ::std::mem::MaybeUninit<_FPDF_SYSFONTINFO> = ::std::mem::MaybeUninit::uninit();
2957 let ptr = UNINIT.as_ptr();
2958 assert_eq!(
2959 ::std::mem::size_of::<_FPDF_SYSFONTINFO>(),
2960 72usize,
2961 concat!("Size of: ", stringify!(_FPDF_SYSFONTINFO))
2962 );
2963 assert_eq!(
2964 ::std::mem::align_of::<_FPDF_SYSFONTINFO>(),
2965 8usize,
2966 concat!("Alignment of ", stringify!(_FPDF_SYSFONTINFO))
2967 );
2968 assert_eq!(
2969 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
2970 0usize,
2971 concat!(
2972 "Offset of field: ",
2973 stringify!(_FPDF_SYSFONTINFO),
2974 "::",
2975 stringify!(version)
2976 )
2977 );
2978 assert_eq!(
2979 unsafe { ::std::ptr::addr_of!((*ptr).Release) as usize - ptr as usize },
2980 8usize,
2981 concat!(
2982 "Offset of field: ",
2983 stringify!(_FPDF_SYSFONTINFO),
2984 "::",
2985 stringify!(Release)
2986 )
2987 );
2988 assert_eq!(
2989 unsafe { ::std::ptr::addr_of!((*ptr).EnumFonts) as usize - ptr as usize },
2990 16usize,
2991 concat!(
2992 "Offset of field: ",
2993 stringify!(_FPDF_SYSFONTINFO),
2994 "::",
2995 stringify!(EnumFonts)
2996 )
2997 );
2998 assert_eq!(
2999 unsafe { ::std::ptr::addr_of!((*ptr).MapFont) as usize - ptr as usize },
3000 24usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(_FPDF_SYSFONTINFO),
3004 "::",
3005 stringify!(MapFont)
3006 )
3007 );
3008 assert_eq!(
3009 unsafe { ::std::ptr::addr_of!((*ptr).GetFont) as usize - ptr as usize },
3010 32usize,
3011 concat!(
3012 "Offset of field: ",
3013 stringify!(_FPDF_SYSFONTINFO),
3014 "::",
3015 stringify!(GetFont)
3016 )
3017 );
3018 assert_eq!(
3019 unsafe { ::std::ptr::addr_of!((*ptr).GetFontData) as usize - ptr as usize },
3020 40usize,
3021 concat!(
3022 "Offset of field: ",
3023 stringify!(_FPDF_SYSFONTINFO),
3024 "::",
3025 stringify!(GetFontData)
3026 )
3027 );
3028 assert_eq!(
3029 unsafe { ::std::ptr::addr_of!((*ptr).GetFaceName) as usize - ptr as usize },
3030 48usize,
3031 concat!(
3032 "Offset of field: ",
3033 stringify!(_FPDF_SYSFONTINFO),
3034 "::",
3035 stringify!(GetFaceName)
3036 )
3037 );
3038 assert_eq!(
3039 unsafe { ::std::ptr::addr_of!((*ptr).GetFontCharset) as usize - ptr as usize },
3040 56usize,
3041 concat!(
3042 "Offset of field: ",
3043 stringify!(_FPDF_SYSFONTINFO),
3044 "::",
3045 stringify!(GetFontCharset)
3046 )
3047 );
3048 assert_eq!(
3049 unsafe { ::std::ptr::addr_of!((*ptr).DeleteFont) as usize - ptr as usize },
3050 64usize,
3051 concat!(
3052 "Offset of field: ",
3053 stringify!(_FPDF_SYSFONTINFO),
3054 "::",
3055 stringify!(DeleteFont)
3056 )
3057 );
3058}
3059#[doc = " Interface: FPDF_SYSFONTINFO\n Interface for getting system font information and font mapping"]
3060pub type FPDF_SYSFONTINFO = _FPDF_SYSFONTINFO;
3061#[doc = " Struct: FPDF_CharsetFontMap\n Provides the name of a font to use for a given charset value."]
3062#[repr(C)]
3063#[derive(Debug, Copy, Clone)]
3064pub struct FPDF_CharsetFontMap_ {
3065 #[doc = " Character Set Enum value, see FXFONT_*_CHARSET above."]
3066 pub charset: ::std::os::raw::c_int,
3067 #[doc = " Name of default font to use with that charset."]
3068 pub fontname: *const ::std::os::raw::c_char,
3069}
3070#[test]
3071fn bindgen_test_layout_FPDF_CharsetFontMap_() {
3072 const UNINIT: ::std::mem::MaybeUninit<FPDF_CharsetFontMap_> = ::std::mem::MaybeUninit::uninit();
3073 let ptr = UNINIT.as_ptr();
3074 assert_eq!(
3075 ::std::mem::size_of::<FPDF_CharsetFontMap_>(),
3076 16usize,
3077 concat!("Size of: ", stringify!(FPDF_CharsetFontMap_))
3078 );
3079 assert_eq!(
3080 ::std::mem::align_of::<FPDF_CharsetFontMap_>(),
3081 8usize,
3082 concat!("Alignment of ", stringify!(FPDF_CharsetFontMap_))
3083 );
3084 assert_eq!(
3085 unsafe { ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize },
3086 0usize,
3087 concat!(
3088 "Offset of field: ",
3089 stringify!(FPDF_CharsetFontMap_),
3090 "::",
3091 stringify!(charset)
3092 )
3093 );
3094 assert_eq!(
3095 unsafe { ::std::ptr::addr_of!((*ptr).fontname) as usize - ptr as usize },
3096 8usize,
3097 concat!(
3098 "Offset of field: ",
3099 stringify!(FPDF_CharsetFontMap_),
3100 "::",
3101 stringify!(fontname)
3102 )
3103 );
3104}
3105#[doc = " Struct: FPDF_CharsetFontMap\n Provides the name of a font to use for a given charset value."]
3106pub type FPDF_CharsetFontMap = FPDF_CharsetFontMap_;
3107extern "C" {
3108 #[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"]
3109 pub fn FPDF_GetDefaultTTFMap() -> *const FPDF_CharsetFontMap;
3110}
3111extern "C" {
3112 #[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."]
3113 pub fn FPDF_GetDefaultTTFMapCount() -> usize;
3114}
3115extern "C" {
3116 #[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."]
3117 pub fn FPDF_GetDefaultTTFMapEntry(index: usize) -> *const FPDF_CharsetFontMap;
3118}
3119extern "C" {
3120 #[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."]
3121 pub fn FPDF_AddInstalledFont(
3122 mapper: *mut ::std::os::raw::c_void,
3123 face: *const ::std::os::raw::c_char,
3124 charset: ::std::os::raw::c_int,
3125 );
3126}
3127extern "C" {
3128 #[doc = " Function: FPDF_SetSystemFontInfo\n Set the system font info interface into PDFium\n Parameters:\n pFontInfo - 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|."]
3129 pub fn FPDF_SetSystemFontInfo(pFontInfo: *mut FPDF_SYSFONTINFO);
3130}
3131extern "C" {
3132 #[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()."]
3133 pub fn FPDF_GetDefaultSystemFontInfo() -> *mut FPDF_SYSFONTINFO;
3134}
3135extern "C" {
3136 #[doc = " Function: FPDF_FreeDefaultSystemFontInfo\n Free a default system font info interface\n Parameters:\n pFontInfo - 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."]
3137 pub fn FPDF_FreeDefaultSystemFontInfo(pFontInfo: *mut FPDF_SYSFONTINFO);
3138}
3139#[doc = " Structure for custom file write"]
3140#[repr(C)]
3141#[derive(Debug, Copy, Clone)]
3142pub struct FPDF_FILEWRITE_ {
3143 #[doc = "\n Version number of the interface. Currently must be 1.\n"]
3144 pub version: ::std::os::raw::c_int,
3145 #[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 pThis - Pointer to the structure itself\n pData - 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."]
3146 pub WriteBlock: ::std::option::Option<
3147 unsafe extern "C" fn(
3148 pThis: *mut FPDF_FILEWRITE_,
3149 pData: *const ::std::os::raw::c_void,
3150 size: ::std::os::raw::c_ulong,
3151 ) -> ::std::os::raw::c_int,
3152 >,
3153}
3154#[test]
3155fn bindgen_test_layout_FPDF_FILEWRITE_() {
3156 const UNINIT: ::std::mem::MaybeUninit<FPDF_FILEWRITE_> = ::std::mem::MaybeUninit::uninit();
3157 let ptr = UNINIT.as_ptr();
3158 assert_eq!(
3159 ::std::mem::size_of::<FPDF_FILEWRITE_>(),
3160 16usize,
3161 concat!("Size of: ", stringify!(FPDF_FILEWRITE_))
3162 );
3163 assert_eq!(
3164 ::std::mem::align_of::<FPDF_FILEWRITE_>(),
3165 8usize,
3166 concat!("Alignment of ", stringify!(FPDF_FILEWRITE_))
3167 );
3168 assert_eq!(
3169 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
3170 0usize,
3171 concat!(
3172 "Offset of field: ",
3173 stringify!(FPDF_FILEWRITE_),
3174 "::",
3175 stringify!(version)
3176 )
3177 );
3178 assert_eq!(
3179 unsafe { ::std::ptr::addr_of!((*ptr).WriteBlock) as usize - ptr as usize },
3180 8usize,
3181 concat!(
3182 "Offset of field: ",
3183 stringify!(FPDF_FILEWRITE_),
3184 "::",
3185 stringify!(WriteBlock)
3186 )
3187 );
3188}
3189#[doc = " Structure for custom file write"]
3190pub type FPDF_FILEWRITE = FPDF_FILEWRITE_;
3191extern "C" {
3192 #[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 pFileWrite - A pointer to a custom file write structure.\n flags - The creating flags.\n Return value:\n TRUE for succeed, FALSE for failed.\n"]
3193 pub fn FPDF_SaveAsCopy(
3194 document: FPDF_DOCUMENT,
3195 pFileWrite: *mut FPDF_FILEWRITE,
3196 flags: FPDF_DWORD,
3197 ) -> FPDF_BOOL;
3198}
3199extern "C" {
3200 #[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 pFileWrite - A pointer to a custom file write structure.\n flags - The creating flags.\n fileVersion - 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"]
3201 pub fn FPDF_SaveWithVersion(
3202 document: FPDF_DOCUMENT,
3203 pFileWrite: *mut FPDF_FILEWRITE,
3204 flags: FPDF_DWORD,
3205 fileVersion: ::std::os::raw::c_int,
3206 ) -> FPDF_BOOL;
3207}
3208extern "C" {
3209 #[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."]
3210 pub fn FPDFDoc_GetJavaScriptActionCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
3211}
3212extern "C" {
3213 #[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()."]
3214 pub fn FPDFDoc_GetJavaScriptAction(
3215 document: FPDF_DOCUMENT,
3216 index: ::std::os::raw::c_int,
3217 ) -> FPDF_JAVASCRIPT_ACTION;
3218}
3219extern "C" {
3220 #[doc = " javascript - Handle to a JavaScript action."]
3221 pub fn FPDFDoc_CloseJavaScriptAction(javascript: FPDF_JAVASCRIPT_ACTION);
3222}
3223extern "C" {
3224 #[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."]
3225 pub fn FPDFJavaScriptAction_GetName(
3226 javascript: FPDF_JAVASCRIPT_ACTION,
3227 buffer: *mut FPDF_WCHAR,
3228 buflen: ::std::os::raw::c_ulong,
3229 ) -> ::std::os::raw::c_ulong;
3230}
3231extern "C" {
3232 #[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."]
3233 pub fn FPDFJavaScriptAction_GetScript(
3234 javascript: FPDF_JAVASCRIPT_ACTION,
3235 buffer: *mut FPDF_WCHAR,
3236 buflen: ::std::os::raw::c_ulong,
3237 ) -> ::std::os::raw::c_ulong;
3238}
3239extern "C" {
3240 #[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."]
3241 pub fn FPDFCatalog_IsTagged(document: FPDF_DOCUMENT) -> FPDF_BOOL;
3242}
3243extern "C" {
3244 #[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."]
3245 pub fn FPDFCatalog_SetLanguage(document: FPDF_DOCUMENT, language: FPDF_BYTESTRING)
3246 -> FPDF_BOOL;
3247}
3248extern "C" {
3249 #[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"]
3250 pub fn FPDFText_LoadPage(page: FPDF_PAGE) -> FPDF_TEXTPAGE;
3251}
3252extern "C" {
3253 #[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"]
3254 pub fn FPDFText_ClosePage(text_page: FPDF_TEXTPAGE);
3255}
3256extern "C" {
3257 #[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"]
3258 pub fn FPDFText_CountChars(text_page: FPDF_TEXTPAGE) -> ::std::os::raw::c_int;
3259}
3260extern "C" {
3261 #[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"]
3262 pub fn FPDFText_GetUnicode(
3263 text_page: FPDF_TEXTPAGE,
3264 index: ::std::os::raw::c_int,
3265 ) -> ::std::os::raw::c_uint;
3266}
3267extern "C" {
3268 #[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"]
3269 pub fn FPDFText_GetTextObject(
3270 text_page: FPDF_TEXTPAGE,
3271 index: ::std::os::raw::c_int,
3272 ) -> FPDF_PAGEOBJECT;
3273}
3274extern "C" {
3275 #[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"]
3276 pub fn FPDFText_IsGenerated(
3277 text_page: FPDF_TEXTPAGE,
3278 index: ::std::os::raw::c_int,
3279 ) -> ::std::os::raw::c_int;
3280}
3281extern "C" {
3282 #[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"]
3283 pub fn FPDFText_IsHyphen(
3284 text_page: FPDF_TEXTPAGE,
3285 index: ::std::os::raw::c_int,
3286 ) -> ::std::os::raw::c_int;
3287}
3288extern "C" {
3289 #[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"]
3290 pub fn FPDFText_HasUnicodeMapError(
3291 text_page: FPDF_TEXTPAGE,
3292 index: ::std::os::raw::c_int,
3293 ) -> ::std::os::raw::c_int;
3294}
3295extern "C" {
3296 #[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"]
3297 pub fn FPDFText_GetFontSize(text_page: FPDF_TEXTPAGE, index: ::std::os::raw::c_int) -> f64;
3298}
3299extern "C" {
3300 #[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"]
3301 pub fn FPDFText_GetFontInfo(
3302 text_page: FPDF_TEXTPAGE,
3303 index: ::std::os::raw::c_int,
3304 buffer: *mut ::std::os::raw::c_void,
3305 buflen: ::std::os::raw::c_ulong,
3306 flags: *mut ::std::os::raw::c_int,
3307 ) -> ::std::os::raw::c_ulong;
3308}
3309extern "C" {
3310 #[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"]
3311 pub fn FPDFText_GetFontWeight(
3312 text_page: FPDF_TEXTPAGE,
3313 index: ::std::os::raw::c_int,
3314 ) -> ::std::os::raw::c_int;
3315}
3316extern "C" {
3317 #[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"]
3318 pub fn FPDFText_GetFillColor(
3319 text_page: FPDF_TEXTPAGE,
3320 index: ::std::os::raw::c_int,
3321 R: *mut ::std::os::raw::c_uint,
3322 G: *mut ::std::os::raw::c_uint,
3323 B: *mut ::std::os::raw::c_uint,
3324 A: *mut ::std::os::raw::c_uint,
3325 ) -> FPDF_BOOL;
3326}
3327extern "C" {
3328 #[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"]
3329 pub fn FPDFText_GetStrokeColor(
3330 text_page: FPDF_TEXTPAGE,
3331 index: ::std::os::raw::c_int,
3332 R: *mut ::std::os::raw::c_uint,
3333 G: *mut ::std::os::raw::c_uint,
3334 B: *mut ::std::os::raw::c_uint,
3335 A: *mut ::std::os::raw::c_uint,
3336 ) -> FPDF_BOOL;
3337}
3338extern "C" {
3339 #[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"]
3340 pub fn FPDFText_GetCharAngle(text_page: FPDF_TEXTPAGE, index: ::std::os::raw::c_int) -> f32;
3341}
3342extern "C" {
3343 #[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"]
3344 pub fn FPDFText_GetCharBox(
3345 text_page: FPDF_TEXTPAGE,
3346 index: ::std::os::raw::c_int,
3347 left: *mut f64,
3348 right: *mut f64,
3349 bottom: *mut f64,
3350 top: *mut f64,
3351 ) -> FPDF_BOOL;
3352}
3353extern "C" {
3354 #[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"]
3355 pub fn FPDFText_GetLooseCharBox(
3356 text_page: FPDF_TEXTPAGE,
3357 index: ::std::os::raw::c_int,
3358 rect: *mut FS_RECTF,
3359 ) -> FPDF_BOOL;
3360}
3361extern "C" {
3362 #[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"]
3363 pub fn FPDFText_GetMatrix(
3364 text_page: FPDF_TEXTPAGE,
3365 index: ::std::os::raw::c_int,
3366 matrix: *mut FS_MATRIX,
3367 ) -> FPDF_BOOL;
3368}
3369extern "C" {
3370 #[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"]
3371 pub fn FPDFText_GetCharOrigin(
3372 text_page: FPDF_TEXTPAGE,
3373 index: ::std::os::raw::c_int,
3374 x: *mut f64,
3375 y: *mut f64,
3376 ) -> FPDF_BOOL;
3377}
3378extern "C" {
3379 #[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"]
3380 pub fn FPDFText_GetCharIndexAtPos(
3381 text_page: FPDF_TEXTPAGE,
3382 x: f64,
3383 y: f64,
3384 xTolerance: f64,
3385 yTolerance: f64,
3386 ) -> ::std::os::raw::c_int;
3387}
3388extern "C" {
3389 #[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"]
3390 pub fn FPDFText_GetText(
3391 text_page: FPDF_TEXTPAGE,
3392 start_index: ::std::os::raw::c_int,
3393 count: ::std::os::raw::c_int,
3394 result: *mut ::std::os::raw::c_ushort,
3395 ) -> ::std::os::raw::c_int;
3396}
3397extern "C" {
3398 #[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"]
3399 pub fn FPDFText_CountRects(
3400 text_page: FPDF_TEXTPAGE,
3401 start_index: ::std::os::raw::c_int,
3402 count: ::std::os::raw::c_int,
3403 ) -> ::std::os::raw::c_int;
3404}
3405extern "C" {
3406 #[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"]
3407 pub fn FPDFText_GetRect(
3408 text_page: FPDF_TEXTPAGE,
3409 rect_index: ::std::os::raw::c_int,
3410 left: *mut f64,
3411 top: *mut f64,
3412 right: *mut f64,
3413 bottom: *mut f64,
3414 ) -> FPDF_BOOL;
3415}
3416extern "C" {
3417 #[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"]
3418 pub fn FPDFText_GetBoundedText(
3419 text_page: FPDF_TEXTPAGE,
3420 left: f64,
3421 top: f64,
3422 right: f64,
3423 bottom: f64,
3424 buffer: *mut ::std::os::raw::c_ushort,
3425 buflen: ::std::os::raw::c_int,
3426 ) -> ::std::os::raw::c_int;
3427}
3428extern "C" {
3429 #[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"]
3430 pub fn FPDFText_FindStart(
3431 text_page: FPDF_TEXTPAGE,
3432 findwhat: FPDF_WIDESTRING,
3433 flags: ::std::os::raw::c_ulong,
3434 start_index: ::std::os::raw::c_int,
3435 ) -> FPDF_SCHHANDLE;
3436}
3437extern "C" {
3438 #[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"]
3439 pub fn FPDFText_FindNext(handle: FPDF_SCHHANDLE) -> FPDF_BOOL;
3440}
3441extern "C" {
3442 #[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"]
3443 pub fn FPDFText_FindPrev(handle: FPDF_SCHHANDLE) -> FPDF_BOOL;
3444}
3445extern "C" {
3446 #[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"]
3447 pub fn FPDFText_GetSchResultIndex(handle: FPDF_SCHHANDLE) -> ::std::os::raw::c_int;
3448}
3449extern "C" {
3450 #[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"]
3451 pub fn FPDFText_GetSchCount(handle: FPDF_SCHHANDLE) -> ::std::os::raw::c_int;
3452}
3453extern "C" {
3454 #[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"]
3455 pub fn FPDFText_FindClose(handle: FPDF_SCHHANDLE);
3456}
3457extern "C" {
3458 #[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"]
3459 pub fn FPDFLink_LoadWebLinks(text_page: FPDF_TEXTPAGE) -> FPDF_PAGELINK;
3460}
3461extern "C" {
3462 #[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"]
3463 pub fn FPDFLink_CountWebLinks(link_page: FPDF_PAGELINK) -> ::std::os::raw::c_int;
3464}
3465extern "C" {
3466 #[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"]
3467 pub fn FPDFLink_GetURL(
3468 link_page: FPDF_PAGELINK,
3469 link_index: ::std::os::raw::c_int,
3470 buffer: *mut ::std::os::raw::c_ushort,
3471 buflen: ::std::os::raw::c_int,
3472 ) -> ::std::os::raw::c_int;
3473}
3474extern "C" {
3475 #[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"]
3476 pub fn FPDFLink_CountRects(
3477 link_page: FPDF_PAGELINK,
3478 link_index: ::std::os::raw::c_int,
3479 ) -> ::std::os::raw::c_int;
3480}
3481extern "C" {
3482 #[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"]
3483 pub fn FPDFLink_GetRect(
3484 link_page: FPDF_PAGELINK,
3485 link_index: ::std::os::raw::c_int,
3486 rect_index: ::std::os::raw::c_int,
3487 left: *mut f64,
3488 top: *mut f64,
3489 right: *mut f64,
3490 bottom: *mut f64,
3491 ) -> FPDF_BOOL;
3492}
3493extern "C" {
3494 #[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"]
3495 pub fn FPDFLink_GetTextRange(
3496 link_page: FPDF_PAGELINK,
3497 link_index: ::std::os::raw::c_int,
3498 start_char_index: *mut ::std::os::raw::c_int,
3499 char_count: *mut ::std::os::raw::c_int,
3500 ) -> FPDF_BOOL;
3501}
3502extern "C" {
3503 #[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"]
3504 pub fn FPDFLink_CloseWebLinks(link_page: FPDF_PAGELINK);
3505}
3506extern "C" {
3507 #[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."]
3508 pub fn FPDFPage_SetMediaBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
3509}
3510extern "C" {
3511 #[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."]
3512 pub fn FPDFPage_SetCropBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
3513}
3514extern "C" {
3515 #[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."]
3516 pub fn FPDFPage_SetBleedBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
3517}
3518extern "C" {
3519 #[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."]
3520 pub fn FPDFPage_SetTrimBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
3521}
3522extern "C" {
3523 #[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."]
3524 pub fn FPDFPage_SetArtBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
3525}
3526extern "C" {
3527 #[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."]
3528 pub fn FPDFPage_GetMediaBox(
3529 page: FPDF_PAGE,
3530 left: *mut f32,
3531 bottom: *mut f32,
3532 right: *mut f32,
3533 top: *mut f32,
3534 ) -> FPDF_BOOL;
3535}
3536extern "C" {
3537 #[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."]
3538 pub fn FPDFPage_GetCropBox(
3539 page: FPDF_PAGE,
3540 left: *mut f32,
3541 bottom: *mut f32,
3542 right: *mut f32,
3543 top: *mut f32,
3544 ) -> FPDF_BOOL;
3545}
3546extern "C" {
3547 #[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."]
3548 pub fn FPDFPage_GetBleedBox(
3549 page: FPDF_PAGE,
3550 left: *mut f32,
3551 bottom: *mut f32,
3552 right: *mut f32,
3553 top: *mut f32,
3554 ) -> FPDF_BOOL;
3555}
3556extern "C" {
3557 #[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."]
3558 pub fn FPDFPage_GetTrimBox(
3559 page: FPDF_PAGE,
3560 left: *mut f32,
3561 bottom: *mut f32,
3562 right: *mut f32,
3563 top: *mut f32,
3564 ) -> FPDF_BOOL;
3565}
3566extern "C" {
3567 #[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."]
3568 pub fn FPDFPage_GetArtBox(
3569 page: FPDF_PAGE,
3570 left: *mut f32,
3571 bottom: *mut f32,
3572 right: *mut f32,
3573 top: *mut f32,
3574 ) -> FPDF_BOOL;
3575}
3576extern "C" {
3577 #[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."]
3578 pub fn FPDFPage_TransFormWithClip(
3579 page: FPDF_PAGE,
3580 matrix: *const FS_MATRIX,
3581 clipRect: *const FS_RECTF,
3582 ) -> FPDF_BOOL;
3583}
3584extern "C" {
3585 #[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."]
3586 pub fn FPDFPageObj_TransformClipPath(
3587 page_object: FPDF_PAGEOBJECT,
3588 a: f64,
3589 b: f64,
3590 c: f64,
3591 d: f64,
3592 e: f64,
3593 f: f64,
3594 );
3595}
3596extern "C" {
3597 #[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|."]
3598 pub fn FPDFPageObj_GetClipPath(page_object: FPDF_PAGEOBJECT) -> FPDF_CLIPPATH;
3599}
3600extern "C" {
3601 #[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."]
3602 pub fn FPDFClipPath_CountPaths(clip_path: FPDF_CLIPPATH) -> ::std::os::raw::c_int;
3603}
3604extern "C" {
3605 #[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."]
3606 pub fn FPDFClipPath_CountPathSegments(
3607 clip_path: FPDF_CLIPPATH,
3608 path_index: ::std::os::raw::c_int,
3609 ) -> ::std::os::raw::c_int;
3610}
3611extern "C" {
3612 #[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|."]
3613 pub fn FPDFClipPath_GetPathSegment(
3614 clip_path: FPDF_CLIPPATH,
3615 path_index: ::std::os::raw::c_int,
3616 segment_index: ::std::os::raw::c_int,
3617 ) -> FPDF_PATHSEGMENT;
3618}
3619extern "C" {
3620 #[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."]
3621 pub fn FPDF_CreateClipPath(left: f32, bottom: f32, right: f32, top: f32) -> FPDF_CLIPPATH;
3622}
3623extern "C" {
3624 #[doc = " Destroy the clip path.\n\n clipPath - A handle to the clip path. It will be invalid after this call."]
3625 pub fn FPDF_DestroyClipPath(clipPath: FPDF_CLIPPATH);
3626}
3627extern "C" {
3628 #[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.)"]
3629 pub fn FPDFPage_InsertClipPath(page: FPDF_PAGE, clipPath: FPDF_CLIPPATH);
3630}
3631extern "C" {
3632 #[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|."]
3633 pub fn FPDFDoc_GetAttachmentCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
3634}
3635extern "C" {
3636 #[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."]
3637 pub fn FPDFDoc_AddAttachment(document: FPDF_DOCUMENT, name: FPDF_WIDESTRING)
3638 -> FPDF_ATTACHMENT;
3639}
3640extern "C" {
3641 #[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."]
3642 pub fn FPDFDoc_GetAttachment(
3643 document: FPDF_DOCUMENT,
3644 index: ::std::os::raw::c_int,
3645 ) -> FPDF_ATTACHMENT;
3646}
3647extern "C" {
3648 #[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."]
3649 pub fn FPDFDoc_DeleteAttachment(
3650 document: FPDF_DOCUMENT,
3651 index: ::std::os::raw::c_int,
3652 ) -> FPDF_BOOL;
3653}
3654extern "C" {
3655 #[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."]
3656 pub fn FPDFAttachment_GetName(
3657 attachment: FPDF_ATTACHMENT,
3658 buffer: *mut FPDF_WCHAR,
3659 buflen: ::std::os::raw::c_ulong,
3660 ) -> ::std::os::raw::c_ulong;
3661}
3662extern "C" {
3663 #[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."]
3664 pub fn FPDFAttachment_HasKey(attachment: FPDF_ATTACHMENT, key: FPDF_BYTESTRING) -> FPDF_BOOL;
3665}
3666extern "C" {
3667 #[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."]
3668 pub fn FPDFAttachment_GetValueType(
3669 attachment: FPDF_ATTACHMENT,
3670 key: FPDF_BYTESTRING,
3671 ) -> FPDF_OBJECT_TYPE;
3672}
3673extern "C" {
3674 #[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."]
3675 pub fn FPDFAttachment_SetStringValue(
3676 attachment: FPDF_ATTACHMENT,
3677 key: FPDF_BYTESTRING,
3678 value: FPDF_WIDESTRING,
3679 ) -> FPDF_BOOL;
3680}
3681extern "C" {
3682 #[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."]
3683 pub fn FPDFAttachment_GetStringValue(
3684 attachment: FPDF_ATTACHMENT,
3685 key: FPDF_BYTESTRING,
3686 buffer: *mut FPDF_WCHAR,
3687 buflen: ::std::os::raw::c_ulong,
3688 ) -> ::std::os::raw::c_ulong;
3689}
3690extern "C" {
3691 #[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."]
3692 pub fn FPDFAttachment_SetFile(
3693 attachment: FPDF_ATTACHMENT,
3694 document: FPDF_DOCUMENT,
3695 contents: *const ::std::os::raw::c_void,
3696 len: ::std::os::raw::c_ulong,
3697 ) -> FPDF_BOOL;
3698}
3699extern "C" {
3700 #[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."]
3701 pub fn FPDFAttachment_GetFile(
3702 attachment: FPDF_ATTACHMENT,
3703 buffer: *mut ::std::os::raw::c_void,
3704 buflen: ::std::os::raw::c_ulong,
3705 out_buflen: *mut ::std::os::raw::c_ulong,
3706 ) -> FPDF_BOOL;
3707}
3708extern "C" {
3709 #[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."]
3710 pub fn FPDF_StructTree_GetForPage(page: FPDF_PAGE) -> FPDF_STRUCTTREE;
3711}
3712extern "C" {
3713 #[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."]
3714 pub fn FPDF_StructTree_Close(struct_tree: FPDF_STRUCTTREE);
3715}
3716extern "C" {
3717 #[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."]
3718 pub fn FPDF_StructTree_CountChildren(struct_tree: FPDF_STRUCTTREE) -> ::std::os::raw::c_int;
3719}
3720extern "C" {
3721 #[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."]
3722 pub fn FPDF_StructTree_GetChildAtIndex(
3723 struct_tree: FPDF_STRUCTTREE,
3724 index: ::std::os::raw::c_int,
3725 ) -> FPDF_STRUCTELEMENT;
3726}
3727extern "C" {
3728 #[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."]
3729 pub fn FPDF_StructElement_GetAltText(
3730 struct_element: FPDF_STRUCTELEMENT,
3731 buffer: *mut ::std::os::raw::c_void,
3732 buflen: ::std::os::raw::c_ulong,
3733 ) -> ::std::os::raw::c_ulong;
3734}
3735extern "C" {
3736 #[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."]
3737 pub fn FPDF_StructElement_GetActualText(
3738 struct_element: FPDF_STRUCTELEMENT,
3739 buffer: *mut ::std::os::raw::c_void,
3740 buflen: ::std::os::raw::c_ulong,
3741 ) -> ::std::os::raw::c_ulong;
3742}
3743extern "C" {
3744 #[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."]
3745 pub fn FPDF_StructElement_GetID(
3746 struct_element: FPDF_STRUCTELEMENT,
3747 buffer: *mut ::std::os::raw::c_void,
3748 buflen: ::std::os::raw::c_ulong,
3749 ) -> ::std::os::raw::c_ulong;
3750}
3751extern "C" {
3752 #[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."]
3753 pub fn FPDF_StructElement_GetLang(
3754 struct_element: FPDF_STRUCTELEMENT,
3755 buffer: *mut ::std::os::raw::c_void,
3756 buflen: ::std::os::raw::c_ulong,
3757 ) -> ::std::os::raw::c_ulong;
3758}
3759extern "C" {
3760 #[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."]
3761 pub fn FPDF_StructElement_GetStringAttribute(
3762 struct_element: FPDF_STRUCTELEMENT,
3763 attr_name: FPDF_BYTESTRING,
3764 buffer: *mut ::std::os::raw::c_void,
3765 buflen: ::std::os::raw::c_ulong,
3766 ) -> ::std::os::raw::c_ulong;
3767}
3768extern "C" {
3769 #[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."]
3770 pub fn FPDF_StructElement_GetMarkedContentID(
3771 struct_element: FPDF_STRUCTELEMENT,
3772 ) -> ::std::os::raw::c_int;
3773}
3774extern "C" {
3775 #[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."]
3776 pub fn FPDF_StructElement_GetType(
3777 struct_element: FPDF_STRUCTELEMENT,
3778 buffer: *mut ::std::os::raw::c_void,
3779 buflen: ::std::os::raw::c_ulong,
3780 ) -> ::std::os::raw::c_ulong;
3781}
3782extern "C" {
3783 #[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."]
3784 pub fn FPDF_StructElement_GetObjType(
3785 struct_element: FPDF_STRUCTELEMENT,
3786 buffer: *mut ::std::os::raw::c_void,
3787 buflen: ::std::os::raw::c_ulong,
3788 ) -> ::std::os::raw::c_ulong;
3789}
3790extern "C" {
3791 #[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."]
3792 pub fn FPDF_StructElement_GetTitle(
3793 struct_element: FPDF_STRUCTELEMENT,
3794 buffer: *mut ::std::os::raw::c_void,
3795 buflen: ::std::os::raw::c_ulong,
3796 ) -> ::std::os::raw::c_ulong;
3797}
3798extern "C" {
3799 #[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."]
3800 pub fn FPDF_StructElement_CountChildren(
3801 struct_element: FPDF_STRUCTELEMENT,
3802 ) -> ::std::os::raw::c_int;
3803}
3804extern "C" {
3805 #[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."]
3806 pub fn FPDF_StructElement_GetChildAtIndex(
3807 struct_element: FPDF_STRUCTELEMENT,
3808 index: ::std::os::raw::c_int,
3809 ) -> FPDF_STRUCTELEMENT;
3810}
3811extern "C" {
3812 #[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."]
3813 pub fn FPDF_StructElement_GetChildMarkedContentID(
3814 struct_element: FPDF_STRUCTELEMENT,
3815 index: ::std::os::raw::c_int,
3816 ) -> ::std::os::raw::c_int;
3817}
3818extern "C" {
3819 #[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."]
3820 pub fn FPDF_StructElement_GetParent(struct_element: FPDF_STRUCTELEMENT) -> FPDF_STRUCTELEMENT;
3821}
3822extern "C" {
3823 #[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."]
3824 pub fn FPDF_StructElement_GetAttributeCount(
3825 struct_element: FPDF_STRUCTELEMENT,
3826 ) -> ::std::os::raw::c_int;
3827}
3828extern "C" {
3829 #[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."]
3830 pub fn FPDF_StructElement_GetAttributeAtIndex(
3831 struct_element: FPDF_STRUCTELEMENT,
3832 index: ::std::os::raw::c_int,
3833 ) -> FPDF_STRUCTELEMENT_ATTR;
3834}
3835extern "C" {
3836 #[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."]
3837 pub fn FPDF_StructElement_Attr_GetCount(
3838 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
3839 ) -> ::std::os::raw::c_int;
3840}
3841extern "C" {
3842 #[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."]
3843 pub fn FPDF_StructElement_Attr_GetName(
3844 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
3845 index: ::std::os::raw::c_int,
3846 buffer: *mut ::std::os::raw::c_void,
3847 buflen: ::std::os::raw::c_ulong,
3848 out_buflen: *mut ::std::os::raw::c_ulong,
3849 ) -> FPDF_BOOL;
3850}
3851extern "C" {
3852 #[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."]
3853 pub fn FPDF_StructElement_Attr_GetValue(
3854 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
3855 name: FPDF_BYTESTRING,
3856 ) -> FPDF_STRUCTELEMENT_ATTR_VALUE;
3857}
3858extern "C" {
3859 #[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."]
3860 pub fn FPDF_StructElement_Attr_GetType(
3861 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3862 ) -> FPDF_OBJECT_TYPE;
3863}
3864extern "C" {
3865 #[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."]
3866 pub fn FPDF_StructElement_Attr_GetBooleanValue(
3867 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3868 out_value: *mut FPDF_BOOL,
3869 ) -> FPDF_BOOL;
3870}
3871extern "C" {
3872 #[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."]
3873 pub fn FPDF_StructElement_Attr_GetNumberValue(
3874 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3875 out_value: *mut f32,
3876 ) -> FPDF_BOOL;
3877}
3878extern "C" {
3879 #[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."]
3880 pub fn FPDF_StructElement_Attr_GetStringValue(
3881 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3882 buffer: *mut ::std::os::raw::c_void,
3883 buflen: ::std::os::raw::c_ulong,
3884 out_buflen: *mut ::std::os::raw::c_ulong,
3885 ) -> FPDF_BOOL;
3886}
3887extern "C" {
3888 #[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."]
3889 pub fn FPDF_StructElement_Attr_GetBlobValue(
3890 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3891 buffer: *mut ::std::os::raw::c_void,
3892 buflen: ::std::os::raw::c_ulong,
3893 out_buflen: *mut ::std::os::raw::c_ulong,
3894 ) -> FPDF_BOOL;
3895}
3896extern "C" {
3897 #[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."]
3898 pub fn FPDF_StructElement_Attr_CountChildren(
3899 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3900 ) -> ::std::os::raw::c_int;
3901}
3902extern "C" {
3903 #[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."]
3904 pub fn FPDF_StructElement_Attr_GetChildAtIndex(
3905 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
3906 index: ::std::os::raw::c_int,
3907 ) -> FPDF_STRUCTELEMENT_ATTR_VALUE;
3908}
3909extern "C" {
3910 #[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."]
3911 pub fn FPDF_StructElement_GetMarkedContentIdCount(
3912 struct_element: FPDF_STRUCTELEMENT,
3913 ) -> ::std::os::raw::c_int;
3914}
3915extern "C" {
3916 #[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()."]
3917 pub fn FPDF_StructElement_GetMarkedContentIdAtIndex(
3918 struct_element: FPDF_STRUCTELEMENT,
3919 index: ::std::os::raw::c_int,
3920 ) -> ::std::os::raw::c_int;
3921}
3922#[doc = " Returned by `clock'."]
3923pub type clock_t = __clock_t;
3924pub type time_t = __time_t;
3925#[doc = " ISO C `broken-down time' structure."]
3926#[repr(C)]
3927#[derive(Debug, Copy, Clone)]
3928pub struct tm {
3929 #[doc = " Seconds.\t[0-60] (1 leap second)"]
3930 pub tm_sec: ::std::os::raw::c_int,
3931 #[doc = " Minutes.\t[0-59]"]
3932 pub tm_min: ::std::os::raw::c_int,
3933 #[doc = " Hours.\t[0-23]"]
3934 pub tm_hour: ::std::os::raw::c_int,
3935 #[doc = " Day.\t\t[1-31]"]
3936 pub tm_mday: ::std::os::raw::c_int,
3937 #[doc = " Month.\t[0-11]"]
3938 pub tm_mon: ::std::os::raw::c_int,
3939 #[doc = " Year\t- 1900."]
3940 pub tm_year: ::std::os::raw::c_int,
3941 #[doc = " Day of week.\t[0-6]"]
3942 pub tm_wday: ::std::os::raw::c_int,
3943 #[doc = " Days in year.[0-365]"]
3944 pub tm_yday: ::std::os::raw::c_int,
3945 #[doc = " DST.\t\t[-1/0/1]"]
3946 pub tm_isdst: ::std::os::raw::c_int,
3947 #[doc = " Seconds east of UTC."]
3948 pub tm_gmtoff: ::std::os::raw::c_long,
3949 #[doc = " Timezone abbreviation."]
3950 pub tm_zone: *const ::std::os::raw::c_char,
3951}
3952#[test]
3953fn bindgen_test_layout_tm() {
3954 const UNINIT: ::std::mem::MaybeUninit<tm> = ::std::mem::MaybeUninit::uninit();
3955 let ptr = UNINIT.as_ptr();
3956 assert_eq!(
3957 ::std::mem::size_of::<tm>(),
3958 56usize,
3959 concat!("Size of: ", stringify!(tm))
3960 );
3961 assert_eq!(
3962 ::std::mem::align_of::<tm>(),
3963 8usize,
3964 concat!("Alignment of ", stringify!(tm))
3965 );
3966 assert_eq!(
3967 unsafe { ::std::ptr::addr_of!((*ptr).tm_sec) as usize - ptr as usize },
3968 0usize,
3969 concat!(
3970 "Offset of field: ",
3971 stringify!(tm),
3972 "::",
3973 stringify!(tm_sec)
3974 )
3975 );
3976 assert_eq!(
3977 unsafe { ::std::ptr::addr_of!((*ptr).tm_min) as usize - ptr as usize },
3978 4usize,
3979 concat!(
3980 "Offset of field: ",
3981 stringify!(tm),
3982 "::",
3983 stringify!(tm_min)
3984 )
3985 );
3986 assert_eq!(
3987 unsafe { ::std::ptr::addr_of!((*ptr).tm_hour) as usize - ptr as usize },
3988 8usize,
3989 concat!(
3990 "Offset of field: ",
3991 stringify!(tm),
3992 "::",
3993 stringify!(tm_hour)
3994 )
3995 );
3996 assert_eq!(
3997 unsafe { ::std::ptr::addr_of!((*ptr).tm_mday) as usize - ptr as usize },
3998 12usize,
3999 concat!(
4000 "Offset of field: ",
4001 stringify!(tm),
4002 "::",
4003 stringify!(tm_mday)
4004 )
4005 );
4006 assert_eq!(
4007 unsafe { ::std::ptr::addr_of!((*ptr).tm_mon) as usize - ptr as usize },
4008 16usize,
4009 concat!(
4010 "Offset of field: ",
4011 stringify!(tm),
4012 "::",
4013 stringify!(tm_mon)
4014 )
4015 );
4016 assert_eq!(
4017 unsafe { ::std::ptr::addr_of!((*ptr).tm_year) as usize - ptr as usize },
4018 20usize,
4019 concat!(
4020 "Offset of field: ",
4021 stringify!(tm),
4022 "::",
4023 stringify!(tm_year)
4024 )
4025 );
4026 assert_eq!(
4027 unsafe { ::std::ptr::addr_of!((*ptr).tm_wday) as usize - ptr as usize },
4028 24usize,
4029 concat!(
4030 "Offset of field: ",
4031 stringify!(tm),
4032 "::",
4033 stringify!(tm_wday)
4034 )
4035 );
4036 assert_eq!(
4037 unsafe { ::std::ptr::addr_of!((*ptr).tm_yday) as usize - ptr as usize },
4038 28usize,
4039 concat!(
4040 "Offset of field: ",
4041 stringify!(tm),
4042 "::",
4043 stringify!(tm_yday)
4044 )
4045 );
4046 assert_eq!(
4047 unsafe { ::std::ptr::addr_of!((*ptr).tm_isdst) as usize - ptr as usize },
4048 32usize,
4049 concat!(
4050 "Offset of field: ",
4051 stringify!(tm),
4052 "::",
4053 stringify!(tm_isdst)
4054 )
4055 );
4056 assert_eq!(
4057 unsafe { ::std::ptr::addr_of!((*ptr).tm_gmtoff) as usize - ptr as usize },
4058 40usize,
4059 concat!(
4060 "Offset of field: ",
4061 stringify!(tm),
4062 "::",
4063 stringify!(tm_gmtoff)
4064 )
4065 );
4066 assert_eq!(
4067 unsafe { ::std::ptr::addr_of!((*ptr).tm_zone) as usize - ptr as usize },
4068 48usize,
4069 concat!(
4070 "Offset of field: ",
4071 stringify!(tm),
4072 "::",
4073 stringify!(tm_zone)
4074 )
4075 );
4076}
4077#[doc = " POSIX.1b structure for a time value. This is like a `struct timeval' but\nhas nanoseconds instead of microseconds."]
4078#[repr(C)]
4079#[derive(Debug, Copy, Clone)]
4080pub struct timespec {
4081 #[doc = " Seconds."]
4082 pub tv_sec: __time_t,
4083 #[doc = " Nanoseconds."]
4084 pub tv_nsec: __syscall_slong_t,
4085}
4086#[test]
4087fn bindgen_test_layout_timespec() {
4088 const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
4089 let ptr = UNINIT.as_ptr();
4090 assert_eq!(
4091 ::std::mem::size_of::<timespec>(),
4092 16usize,
4093 concat!("Size of: ", stringify!(timespec))
4094 );
4095 assert_eq!(
4096 ::std::mem::align_of::<timespec>(),
4097 8usize,
4098 concat!("Alignment of ", stringify!(timespec))
4099 );
4100 assert_eq!(
4101 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
4102 0usize,
4103 concat!(
4104 "Offset of field: ",
4105 stringify!(timespec),
4106 "::",
4107 stringify!(tv_sec)
4108 )
4109 );
4110 assert_eq!(
4111 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
4112 8usize,
4113 concat!(
4114 "Offset of field: ",
4115 stringify!(timespec),
4116 "::",
4117 stringify!(tv_nsec)
4118 )
4119 );
4120}
4121#[doc = " Clock ID used in clock and timer functions."]
4122pub type clockid_t = __clockid_t;
4123#[doc = " Timer ID returned by `timer_create'."]
4124pub type timer_t = __timer_t;
4125#[doc = " POSIX.1b structure for timer start values and intervals."]
4126#[repr(C)]
4127#[derive(Debug, Copy, Clone)]
4128pub struct itimerspec {
4129 pub it_interval: timespec,
4130 pub it_value: timespec,
4131}
4132#[test]
4133fn bindgen_test_layout_itimerspec() {
4134 const UNINIT: ::std::mem::MaybeUninit<itimerspec> = ::std::mem::MaybeUninit::uninit();
4135 let ptr = UNINIT.as_ptr();
4136 assert_eq!(
4137 ::std::mem::size_of::<itimerspec>(),
4138 32usize,
4139 concat!("Size of: ", stringify!(itimerspec))
4140 );
4141 assert_eq!(
4142 ::std::mem::align_of::<itimerspec>(),
4143 8usize,
4144 concat!("Alignment of ", stringify!(itimerspec))
4145 );
4146 assert_eq!(
4147 unsafe { ::std::ptr::addr_of!((*ptr).it_interval) as usize - ptr as usize },
4148 0usize,
4149 concat!(
4150 "Offset of field: ",
4151 stringify!(itimerspec),
4152 "::",
4153 stringify!(it_interval)
4154 )
4155 );
4156 assert_eq!(
4157 unsafe { ::std::ptr::addr_of!((*ptr).it_value) as usize - ptr as usize },
4158 16usize,
4159 concat!(
4160 "Offset of field: ",
4161 stringify!(itimerspec),
4162 "::",
4163 stringify!(it_value)
4164 )
4165 );
4166}
4167#[repr(C)]
4168#[derive(Debug, Copy, Clone)]
4169pub struct sigevent {
4170 _unused: [u8; 0],
4171}
4172pub type pid_t = __pid_t;
4173#[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."]
4174#[repr(C)]
4175#[derive(Debug, Copy, Clone)]
4176pub struct __locale_struct {
4177 #[doc = " 13 = __LC_LAST."]
4178 pub __locales: [*mut __locale_data; 13usize],
4179 #[doc = " To increase the speed of this solution we add some special members."]
4180 pub __ctype_b: *const ::std::os::raw::c_ushort,
4181 pub __ctype_tolower: *const ::std::os::raw::c_int,
4182 pub __ctype_toupper: *const ::std::os::raw::c_int,
4183 #[doc = " Note: LC_ALL is not a valid index into this array."]
4184 pub __names: [*const ::std::os::raw::c_char; 13usize],
4185}
4186#[test]
4187fn bindgen_test_layout___locale_struct() {
4188 const UNINIT: ::std::mem::MaybeUninit<__locale_struct> = ::std::mem::MaybeUninit::uninit();
4189 let ptr = UNINIT.as_ptr();
4190 assert_eq!(
4191 ::std::mem::size_of::<__locale_struct>(),
4192 232usize,
4193 concat!("Size of: ", stringify!(__locale_struct))
4194 );
4195 assert_eq!(
4196 ::std::mem::align_of::<__locale_struct>(),
4197 8usize,
4198 concat!("Alignment of ", stringify!(__locale_struct))
4199 );
4200 assert_eq!(
4201 unsafe { ::std::ptr::addr_of!((*ptr).__locales) as usize - ptr as usize },
4202 0usize,
4203 concat!(
4204 "Offset of field: ",
4205 stringify!(__locale_struct),
4206 "::",
4207 stringify!(__locales)
4208 )
4209 );
4210 assert_eq!(
4211 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
4212 104usize,
4213 concat!(
4214 "Offset of field: ",
4215 stringify!(__locale_struct),
4216 "::",
4217 stringify!(__ctype_b)
4218 )
4219 );
4220 assert_eq!(
4221 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
4222 112usize,
4223 concat!(
4224 "Offset of field: ",
4225 stringify!(__locale_struct),
4226 "::",
4227 stringify!(__ctype_tolower)
4228 )
4229 );
4230 assert_eq!(
4231 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
4232 120usize,
4233 concat!(
4234 "Offset of field: ",
4235 stringify!(__locale_struct),
4236 "::",
4237 stringify!(__ctype_toupper)
4238 )
4239 );
4240 assert_eq!(
4241 unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr as usize },
4242 128usize,
4243 concat!(
4244 "Offset of field: ",
4245 stringify!(__locale_struct),
4246 "::",
4247 stringify!(__names)
4248 )
4249 );
4250}
4251pub type __locale_t = *mut __locale_struct;
4252pub type locale_t = __locale_t;
4253extern "C" {
4254 #[doc = " Time used by the program so far (user time + system time).\nThe result / CLOCKS_PER_SEC is program time in seconds."]
4255 pub fn clock() -> clock_t;
4256}
4257extern "C" {
4258 #[doc = " Return the current time and put it in *TIMER if TIMER is not NULL."]
4259 pub fn time(__timer: *mut time_t) -> time_t;
4260}
4261extern "C" {
4262 #[doc = " Return the difference between TIME1 and TIME0."]
4263 pub fn difftime(__time1: time_t, __time0: time_t) -> f64;
4264}
4265extern "C" {
4266 #[doc = " Return the `time_t' representation of TP and normalize TP."]
4267 pub fn mktime(__tp: *mut tm) -> time_t;
4268}
4269extern "C" {
4270 #[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."]
4271 pub fn strftime(
4272 __s: *mut ::std::os::raw::c_char,
4273 __maxsize: usize,
4274 __format: *const ::std::os::raw::c_char,
4275 __tp: *const tm,
4276 ) -> usize;
4277}
4278extern "C" {
4279 #[doc = " Similar to the two functions above but take the information from\nthe provided locale and not the global locale."]
4280 pub fn strftime_l(
4281 __s: *mut ::std::os::raw::c_char,
4282 __maxsize: usize,
4283 __format: *const ::std::os::raw::c_char,
4284 __tp: *const tm,
4285 __loc: locale_t,
4286 ) -> usize;
4287}
4288extern "C" {
4289 #[doc = " Return the `struct tm' representation of *TIMER\nin Universal Coordinated Time (aka Greenwich Mean Time)."]
4290 pub fn gmtime(__timer: *const time_t) -> *mut tm;
4291}
4292extern "C" {
4293 #[doc = " Return the `struct tm' representation\nof *TIMER in the local timezone."]
4294 pub fn localtime(__timer: *const time_t) -> *mut tm;
4295}
4296extern "C" {
4297 #[doc = " Return the `struct tm' representation of *TIMER in UTC,\nusing *TP to store the result."]
4298 pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
4299}
4300extern "C" {
4301 #[doc = " Return the `struct tm' representation of *TIMER in local time,\nusing *TP to store the result."]
4302 pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
4303}
4304extern "C" {
4305 #[doc = " Return a string of the form \"Day Mon dd hh:mm:ss yyyy\\n\"\nthat is the representation of TP in this format."]
4306 pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char;
4307}
4308extern "C" {
4309 pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char;
4310}
4311extern "C" {
4312 #[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."]
4313 pub fn asctime_r(
4314 __tp: *const tm,
4315 __buf: *mut ::std::os::raw::c_char,
4316 ) -> *mut ::std::os::raw::c_char;
4317}
4318extern "C" {
4319 pub fn ctime_r(
4320 __timer: *const time_t,
4321 __buf: *mut ::std::os::raw::c_char,
4322 ) -> *mut ::std::os::raw::c_char;
4323}
4324extern "C" {
4325 #[doc = " Current time zone abbreviations."]
4326 pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize];
4327}
4328extern "C" {
4329 #[doc = " If daylight-saving time is ever in use."]
4330 pub static mut __daylight: ::std::os::raw::c_int;
4331}
4332extern "C" {
4333 #[doc = " Seconds west of UTC."]
4334 pub static mut __timezone: ::std::os::raw::c_long;
4335}
4336extern "C" {
4337 #[doc = " Same as above."]
4338 pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize];
4339}
4340extern "C" {
4341 #[doc = " Set time conversion information from the TZ environment variable.\nIf TZ is not defined, a locale-dependent default is used."]
4342 pub fn tzset();
4343}
4344extern "C" {
4345 pub static mut daylight: ::std::os::raw::c_int;
4346}
4347extern "C" {
4348 pub static mut timezone: ::std::os::raw::c_long;
4349}
4350extern "C" {
4351 #[doc = " Like `mktime', but for TP represents Universal Time, not local time."]
4352 pub fn timegm(__tp: *mut tm) -> time_t;
4353}
4354extern "C" {
4355 #[doc = " Another name for `mktime'."]
4356 pub fn timelocal(__tp: *mut tm) -> time_t;
4357}
4358extern "C" {
4359 #[doc = " Return the number of days in YEAR."]
4360 pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4361}
4362extern "C" {
4363 #[doc = " Pause execution for a number of nanoseconds.\n\nThis function is a cancellation point and therefore not marked with\n__THROW."]
4364 pub fn nanosleep(
4365 __requested_time: *const timespec,
4366 __remaining: *mut timespec,
4367 ) -> ::std::os::raw::c_int;
4368}
4369extern "C" {
4370 #[doc = " Get resolution of clock CLOCK_ID."]
4371 pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int;
4372}
4373extern "C" {
4374 #[doc = " Get current value of clock CLOCK_ID and store it in TP."]
4375 pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int;
4376}
4377extern "C" {
4378 #[doc = " Set clock CLOCK_ID to value TP."]
4379 pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int;
4380}
4381extern "C" {
4382 pub fn clock_nanosleep(
4383 __clock_id: clockid_t,
4384 __flags: ::std::os::raw::c_int,
4385 __req: *const timespec,
4386 __rem: *mut timespec,
4387 ) -> ::std::os::raw::c_int;
4388}
4389extern "C" {
4390 #[doc = " Return clock ID for CPU-time clock."]
4391 pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int;
4392}
4393extern "C" {
4394 #[doc = " Create new per-process timer using CLOCK_ID."]
4395 pub fn timer_create(
4396 __clock_id: clockid_t,
4397 __evp: *mut sigevent,
4398 __timerid: *mut timer_t,
4399 ) -> ::std::os::raw::c_int;
4400}
4401extern "C" {
4402 #[doc = " Delete timer TIMERID."]
4403 pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int;
4404}
4405extern "C" {
4406 pub fn timer_settime(
4407 __timerid: timer_t,
4408 __flags: ::std::os::raw::c_int,
4409 __value: *const itimerspec,
4410 __ovalue: *mut itimerspec,
4411 ) -> ::std::os::raw::c_int;
4412}
4413extern "C" {
4414 #[doc = " Get current value of timer TIMERID and store it in VALUE."]
4415 pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int;
4416}
4417extern "C" {
4418 #[doc = " Get expiration overrun for timer TIMERID."]
4419 pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int;
4420}
4421extern "C" {
4422 #[doc = " Set TS to calendar time based in time base BASE."]
4423 pub fn timespec_get(
4424 __ts: *mut timespec,
4425 __base: ::std::os::raw::c_int,
4426 ) -> ::std::os::raw::c_int;
4427}
4428#[doc = " Interface for unsupported feature notifications."]
4429#[repr(C)]
4430#[derive(Debug, Copy, Clone)]
4431pub struct _UNSUPPORT_INFO {
4432 #[doc = " Version number of the interface. Must be 1."]
4433 pub version: ::std::os::raw::c_int,
4434 #[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."]
4435 pub FSDK_UnSupport_Handler: ::std::option::Option<
4436 unsafe extern "C" fn(pThis: *mut _UNSUPPORT_INFO, nType: ::std::os::raw::c_int),
4437 >,
4438}
4439#[test]
4440fn bindgen_test_layout__UNSUPPORT_INFO() {
4441 const UNINIT: ::std::mem::MaybeUninit<_UNSUPPORT_INFO> = ::std::mem::MaybeUninit::uninit();
4442 let ptr = UNINIT.as_ptr();
4443 assert_eq!(
4444 ::std::mem::size_of::<_UNSUPPORT_INFO>(),
4445 16usize,
4446 concat!("Size of: ", stringify!(_UNSUPPORT_INFO))
4447 );
4448 assert_eq!(
4449 ::std::mem::align_of::<_UNSUPPORT_INFO>(),
4450 8usize,
4451 concat!("Alignment of ", stringify!(_UNSUPPORT_INFO))
4452 );
4453 assert_eq!(
4454 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
4455 0usize,
4456 concat!(
4457 "Offset of field: ",
4458 stringify!(_UNSUPPORT_INFO),
4459 "::",
4460 stringify!(version)
4461 )
4462 );
4463 assert_eq!(
4464 unsafe { ::std::ptr::addr_of!((*ptr).FSDK_UnSupport_Handler) as usize - ptr as usize },
4465 8usize,
4466 concat!(
4467 "Offset of field: ",
4468 stringify!(_UNSUPPORT_INFO),
4469 "::",
4470 stringify!(FSDK_UnSupport_Handler)
4471 )
4472 );
4473}
4474#[doc = " Interface for unsupported feature notifications."]
4475pub type UNSUPPORT_INFO = _UNSUPPORT_INFO;
4476extern "C" {
4477 #[doc = " Setup an unsupported object handler.\n\n unsp_info - Pointer to an UNSUPPORT_INFO structure.\n\n Returns TRUE on success."]
4478 pub fn FSDK_SetUnSpObjProcessHandler(unsp_info: *mut UNSUPPORT_INFO) -> FPDF_BOOL;
4479}
4480extern "C" {
4481 #[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."]
4482 pub fn FSDK_SetTimeFunction(func: ::std::option::Option<unsafe extern "C" fn() -> time_t>);
4483}
4484extern "C" {
4485 #[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."]
4486 pub fn FSDK_SetLocaltimeFunction(
4487 func: ::std::option::Option<unsafe extern "C" fn(arg1: *const time_t) -> *mut tm>,
4488 );
4489}
4490extern "C" {
4491 #[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."]
4492 pub fn FPDFDoc_GetPageMode(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
4493}
4494extern "C" {
4495 #[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."]
4496 pub fn FPDFText_GetCharIndexFromTextIndex(
4497 text_page: FPDF_TEXTPAGE,
4498 nTextIndex: ::std::os::raw::c_int,
4499 ) -> ::std::os::raw::c_int;
4500}
4501extern "C" {
4502 #[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."]
4503 pub fn FPDFText_GetTextIndexFromCharIndex(
4504 text_page: FPDF_TEXTPAGE,
4505 nCharIndex: ::std::os::raw::c_int,
4506 ) -> ::std::os::raw::c_int;
4507}
4508pub const FPDF_FILEIDTYPE_FILEIDTYPE_PERMANENT: FPDF_FILEIDTYPE = 0;
4509pub const FPDF_FILEIDTYPE_FILEIDTYPE_CHANGING: FPDF_FILEIDTYPE = 1;
4510#[doc = " The file identifier entry type. See section 14.4 \"File Identifiers\" of the\n ISO 32000-1:2008 spec."]
4511pub type FPDF_FILEIDTYPE = ::std::os::raw::c_uint;
4512extern "C" {
4513 #[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."]
4514 pub fn FPDFBookmark_GetFirstChild(
4515 document: FPDF_DOCUMENT,
4516 bookmark: FPDF_BOOKMARK,
4517 ) -> FPDF_BOOKMARK;
4518}
4519extern "C" {
4520 #[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."]
4521 pub fn FPDFBookmark_GetNextSibling(
4522 document: FPDF_DOCUMENT,
4523 bookmark: FPDF_BOOKMARK,
4524 ) -> FPDF_BOOKMARK;
4525}
4526extern "C" {
4527 #[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."]
4528 pub fn FPDFBookmark_GetTitle(
4529 bookmark: FPDF_BOOKMARK,
4530 buffer: *mut ::std::os::raw::c_void,
4531 buflen: ::std::os::raw::c_ulong,
4532 ) -> ::std::os::raw::c_ulong;
4533}
4534extern "C" {
4535 #[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."]
4536 pub fn FPDFBookmark_GetCount(bookmark: FPDF_BOOKMARK) -> ::std::os::raw::c_int;
4537}
4538extern "C" {
4539 #[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|."]
4540 pub fn FPDFBookmark_Find(document: FPDF_DOCUMENT, title: FPDF_WIDESTRING) -> FPDF_BOOKMARK;
4541}
4542extern "C" {
4543 #[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|."]
4544 pub fn FPDFBookmark_GetDest(document: FPDF_DOCUMENT, bookmark: FPDF_BOOKMARK) -> FPDF_DEST;
4545}
4546extern "C" {
4547 #[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."]
4548 pub fn FPDFBookmark_GetAction(bookmark: FPDF_BOOKMARK) -> FPDF_ACTION;
4549}
4550extern "C" {
4551 #[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"]
4552 pub fn FPDFAction_GetType(action: FPDF_ACTION) -> ::std::os::raw::c_ulong;
4553}
4554extern "C" {
4555 #[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()."]
4556 pub fn FPDFAction_GetDest(document: FPDF_DOCUMENT, action: FPDF_ACTION) -> FPDF_DEST;
4557}
4558extern "C" {
4559 #[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."]
4560 pub fn FPDFAction_GetFilePath(
4561 action: FPDF_ACTION,
4562 buffer: *mut ::std::os::raw::c_void,
4563 buflen: ::std::os::raw::c_ulong,
4564 ) -> ::std::os::raw::c_ulong;
4565}
4566extern "C" {
4567 #[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."]
4568 pub fn FPDFAction_GetURIPath(
4569 document: FPDF_DOCUMENT,
4570 action: FPDF_ACTION,
4571 buffer: *mut ::std::os::raw::c_void,
4572 buflen: ::std::os::raw::c_ulong,
4573 ) -> ::std::os::raw::c_ulong;
4574}
4575extern "C" {
4576 #[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."]
4577 pub fn FPDFDest_GetDestPageIndex(
4578 document: FPDF_DOCUMENT,
4579 dest: FPDF_DEST,
4580 ) -> ::std::os::raw::c_int;
4581}
4582extern "C" {
4583 #[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."]
4584 pub fn FPDFDest_GetView(
4585 dest: FPDF_DEST,
4586 pNumParams: *mut ::std::os::raw::c_ulong,
4587 pParams: *mut FS_FLOAT,
4588 ) -> ::std::os::raw::c_ulong;
4589}
4590extern "C" {
4591 #[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."]
4592 pub fn FPDFDest_GetLocationInPage(
4593 dest: FPDF_DEST,
4594 hasXVal: *mut FPDF_BOOL,
4595 hasYVal: *mut FPDF_BOOL,
4596 hasZoomVal: *mut FPDF_BOOL,
4597 x: *mut FS_FLOAT,
4598 y: *mut FS_FLOAT,
4599 zoom: *mut FS_FLOAT,
4600 ) -> FPDF_BOOL;
4601}
4602extern "C" {
4603 #[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()."]
4604 pub fn FPDFLink_GetLinkAtPoint(page: FPDF_PAGE, x: f64, y: f64) -> FPDF_LINK;
4605}
4606extern "C" {
4607 #[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()."]
4608 pub fn FPDFLink_GetLinkZOrderAtPoint(page: FPDF_PAGE, x: f64, y: f64) -> ::std::os::raw::c_int;
4609}
4610extern "C" {
4611 #[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|."]
4612 pub fn FPDFLink_GetDest(document: FPDF_DOCUMENT, link: FPDF_LINK) -> FPDF_DEST;
4613}
4614extern "C" {
4615 #[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."]
4616 pub fn FPDFLink_GetAction(link: FPDF_LINK) -> FPDF_ACTION;
4617}
4618extern "C" {
4619 #[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."]
4620 pub fn FPDFLink_Enumerate(
4621 page: FPDF_PAGE,
4622 start_pos: *mut ::std::os::raw::c_int,
4623 link_annot: *mut FPDF_LINK,
4624 ) -> FPDF_BOOL;
4625}
4626extern "C" {
4627 #[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."]
4628 pub fn FPDFLink_GetAnnot(page: FPDF_PAGE, link_annot: FPDF_LINK) -> FPDF_ANNOTATION;
4629}
4630extern "C" {
4631 #[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."]
4632 pub fn FPDFLink_GetAnnotRect(link_annot: FPDF_LINK, rect: *mut FS_RECTF) -> FPDF_BOOL;
4633}
4634extern "C" {
4635 #[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."]
4636 pub fn FPDFLink_CountQuadPoints(link_annot: FPDF_LINK) -> ::std::os::raw::c_int;
4637}
4638extern "C" {
4639 #[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."]
4640 pub fn FPDFLink_GetQuadPoints(
4641 link_annot: FPDF_LINK,
4642 quad_index: ::std::os::raw::c_int,
4643 quad_points: *mut FS_QUADPOINTSF,
4644 ) -> FPDF_BOOL;
4645}
4646extern "C" {
4647 #[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."]
4648 pub fn FPDF_GetPageAAction(page: FPDF_PAGE, aa_type: ::std::os::raw::c_int) -> FPDF_ACTION;
4649}
4650extern "C" {
4651 #[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."]
4652 pub fn FPDF_GetFileIdentifier(
4653 document: FPDF_DOCUMENT,
4654 id_type: FPDF_FILEIDTYPE,
4655 buffer: *mut ::std::os::raw::c_void,
4656 buflen: ::std::os::raw::c_ulong,
4657 ) -> ::std::os::raw::c_ulong;
4658}
4659extern "C" {
4660 #[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."]
4661 pub fn FPDF_GetMetaText(
4662 document: FPDF_DOCUMENT,
4663 tag: FPDF_BYTESTRING,
4664 buffer: *mut ::std::os::raw::c_void,
4665 buflen: ::std::os::raw::c_ulong,
4666 ) -> ::std::os::raw::c_ulong;
4667}
4668extern "C" {
4669 #[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."]
4670 pub fn FPDF_GetPageLabel(
4671 document: FPDF_DOCUMENT,
4672 page_index: ::std::os::raw::c_int,
4673 buffer: *mut ::std::os::raw::c_void,
4674 buflen: ::std::os::raw::c_ulong,
4675 ) -> ::std::os::raw::c_ulong;
4676}
4677#[repr(C)]
4678#[derive(Debug, Copy, Clone)]
4679pub struct _IPDF_JsPlatform {
4680 #[doc = " Version number of the interface. Currently must be 2."]
4681 pub version: ::std::os::raw::c_int,
4682 #[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."]
4683 pub app_alert: ::std::option::Option<
4684 unsafe extern "C" fn(
4685 pThis: *mut _IPDF_JsPlatform,
4686 Msg: FPDF_WIDESTRING,
4687 Title: FPDF_WIDESTRING,
4688 Type: ::std::os::raw::c_int,
4689 Icon: ::std::os::raw::c_int,
4690 ) -> ::std::os::raw::c_int,
4691 >,
4692 #[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"]
4693 pub app_beep: ::std::option::Option<
4694 unsafe extern "C" fn(pThis: *mut _IPDF_JsPlatform, nType: ::std::os::raw::c_int),
4695 >,
4696 #[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."]
4697 pub app_response: ::std::option::Option<
4698 unsafe extern "C" fn(
4699 pThis: *mut _IPDF_JsPlatform,
4700 Question: FPDF_WIDESTRING,
4701 Title: FPDF_WIDESTRING,
4702 Default: FPDF_WIDESTRING,
4703 cLabel: FPDF_WIDESTRING,
4704 bPassword: FPDF_BOOL,
4705 response: *mut ::std::os::raw::c_void,
4706 length: ::std::os::raw::c_int,
4707 ) -> ::std::os::raw::c_int,
4708 >,
4709 #[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."]
4710 pub Doc_getFilePath: ::std::option::Option<
4711 unsafe extern "C" fn(
4712 pThis: *mut _IPDF_JsPlatform,
4713 filePath: *mut ::std::os::raw::c_void,
4714 length: ::std::os::raw::c_int,
4715 ) -> ::std::os::raw::c_int,
4716 >,
4717 #[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."]
4718 pub Doc_mail: ::std::option::Option<
4719 unsafe extern "C" fn(
4720 pThis: *mut _IPDF_JsPlatform,
4721 mailData: *mut ::std::os::raw::c_void,
4722 length: ::std::os::raw::c_int,
4723 bUI: FPDF_BOOL,
4724 To: FPDF_WIDESTRING,
4725 Subject: FPDF_WIDESTRING,
4726 CC: FPDF_WIDESTRING,
4727 BCC: FPDF_WIDESTRING,
4728 Msg: FPDF_WIDESTRING,
4729 ),
4730 >,
4731 #[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."]
4732 pub Doc_print: ::std::option::Option<
4733 unsafe extern "C" fn(
4734 pThis: *mut _IPDF_JsPlatform,
4735 bUI: FPDF_BOOL,
4736 nStart: ::std::os::raw::c_int,
4737 nEnd: ::std::os::raw::c_int,
4738 bSilent: FPDF_BOOL,
4739 bShrinkToFit: FPDF_BOOL,
4740 bPrintAsImage: FPDF_BOOL,
4741 bReverse: FPDF_BOOL,
4742 bAnnotations: FPDF_BOOL,
4743 ),
4744 >,
4745 #[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."]
4746 pub Doc_submitForm: ::std::option::Option<
4747 unsafe extern "C" fn(
4748 pThis: *mut _IPDF_JsPlatform,
4749 formData: *mut ::std::os::raw::c_void,
4750 length: ::std::os::raw::c_int,
4751 URL: FPDF_WIDESTRING,
4752 ),
4753 >,
4754 #[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."]
4755 pub Doc_gotoPage: ::std::option::Option<
4756 unsafe extern "C" fn(pThis: *mut _IPDF_JsPlatform, nPageNum: ::std::os::raw::c_int),
4757 >,
4758 #[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."]
4759 pub Field_browse: ::std::option::Option<
4760 unsafe extern "C" fn(
4761 pThis: *mut _IPDF_JsPlatform,
4762 filePath: *mut ::std::os::raw::c_void,
4763 length: ::std::os::raw::c_int,
4764 ) -> ::std::os::raw::c_int,
4765 >,
4766 #[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."]
4767 pub m_pFormfillinfo: *mut ::std::os::raw::c_void,
4768 #[doc = " Unused in v3, retain for compatibility."]
4769 pub m_isolate: *mut ::std::os::raw::c_void,
4770 #[doc = " Unused in v3, retain for compatibility."]
4771 pub m_v8EmbedderSlot: ::std::os::raw::c_uint,
4772}
4773#[test]
4774fn bindgen_test_layout__IPDF_JsPlatform() {
4775 const UNINIT: ::std::mem::MaybeUninit<_IPDF_JsPlatform> = ::std::mem::MaybeUninit::uninit();
4776 let ptr = UNINIT.as_ptr();
4777 assert_eq!(
4778 ::std::mem::size_of::<_IPDF_JsPlatform>(),
4779 104usize,
4780 concat!("Size of: ", stringify!(_IPDF_JsPlatform))
4781 );
4782 assert_eq!(
4783 ::std::mem::align_of::<_IPDF_JsPlatform>(),
4784 8usize,
4785 concat!("Alignment of ", stringify!(_IPDF_JsPlatform))
4786 );
4787 assert_eq!(
4788 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
4789 0usize,
4790 concat!(
4791 "Offset of field: ",
4792 stringify!(_IPDF_JsPlatform),
4793 "::",
4794 stringify!(version)
4795 )
4796 );
4797 assert_eq!(
4798 unsafe { ::std::ptr::addr_of!((*ptr).app_alert) as usize - ptr as usize },
4799 8usize,
4800 concat!(
4801 "Offset of field: ",
4802 stringify!(_IPDF_JsPlatform),
4803 "::",
4804 stringify!(app_alert)
4805 )
4806 );
4807 assert_eq!(
4808 unsafe { ::std::ptr::addr_of!((*ptr).app_beep) as usize - ptr as usize },
4809 16usize,
4810 concat!(
4811 "Offset of field: ",
4812 stringify!(_IPDF_JsPlatform),
4813 "::",
4814 stringify!(app_beep)
4815 )
4816 );
4817 assert_eq!(
4818 unsafe { ::std::ptr::addr_of!((*ptr).app_response) as usize - ptr as usize },
4819 24usize,
4820 concat!(
4821 "Offset of field: ",
4822 stringify!(_IPDF_JsPlatform),
4823 "::",
4824 stringify!(app_response)
4825 )
4826 );
4827 assert_eq!(
4828 unsafe { ::std::ptr::addr_of!((*ptr).Doc_getFilePath) as usize - ptr as usize },
4829 32usize,
4830 concat!(
4831 "Offset of field: ",
4832 stringify!(_IPDF_JsPlatform),
4833 "::",
4834 stringify!(Doc_getFilePath)
4835 )
4836 );
4837 assert_eq!(
4838 unsafe { ::std::ptr::addr_of!((*ptr).Doc_mail) as usize - ptr as usize },
4839 40usize,
4840 concat!(
4841 "Offset of field: ",
4842 stringify!(_IPDF_JsPlatform),
4843 "::",
4844 stringify!(Doc_mail)
4845 )
4846 );
4847 assert_eq!(
4848 unsafe { ::std::ptr::addr_of!((*ptr).Doc_print) as usize - ptr as usize },
4849 48usize,
4850 concat!(
4851 "Offset of field: ",
4852 stringify!(_IPDF_JsPlatform),
4853 "::",
4854 stringify!(Doc_print)
4855 )
4856 );
4857 assert_eq!(
4858 unsafe { ::std::ptr::addr_of!((*ptr).Doc_submitForm) as usize - ptr as usize },
4859 56usize,
4860 concat!(
4861 "Offset of field: ",
4862 stringify!(_IPDF_JsPlatform),
4863 "::",
4864 stringify!(Doc_submitForm)
4865 )
4866 );
4867 assert_eq!(
4868 unsafe { ::std::ptr::addr_of!((*ptr).Doc_gotoPage) as usize - ptr as usize },
4869 64usize,
4870 concat!(
4871 "Offset of field: ",
4872 stringify!(_IPDF_JsPlatform),
4873 "::",
4874 stringify!(Doc_gotoPage)
4875 )
4876 );
4877 assert_eq!(
4878 unsafe { ::std::ptr::addr_of!((*ptr).Field_browse) as usize - ptr as usize },
4879 72usize,
4880 concat!(
4881 "Offset of field: ",
4882 stringify!(_IPDF_JsPlatform),
4883 "::",
4884 stringify!(Field_browse)
4885 )
4886 );
4887 assert_eq!(
4888 unsafe { ::std::ptr::addr_of!((*ptr).m_pFormfillinfo) as usize - ptr as usize },
4889 80usize,
4890 concat!(
4891 "Offset of field: ",
4892 stringify!(_IPDF_JsPlatform),
4893 "::",
4894 stringify!(m_pFormfillinfo)
4895 )
4896 );
4897 assert_eq!(
4898 unsafe { ::std::ptr::addr_of!((*ptr).m_isolate) as usize - ptr as usize },
4899 88usize,
4900 concat!(
4901 "Offset of field: ",
4902 stringify!(_IPDF_JsPlatform),
4903 "::",
4904 stringify!(m_isolate)
4905 )
4906 );
4907 assert_eq!(
4908 unsafe { ::std::ptr::addr_of!((*ptr).m_v8EmbedderSlot) as usize - ptr as usize },
4909 96usize,
4910 concat!(
4911 "Offset of field: ",
4912 stringify!(_IPDF_JsPlatform),
4913 "::",
4914 stringify!(m_v8EmbedderSlot)
4915 )
4916 );
4917}
4918pub type IPDF_JSPLATFORM = _IPDF_JsPlatform;
4919#[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."]
4920pub type TimerCallback =
4921 ::std::option::Option<unsafe extern "C" fn(idEvent: ::std::os::raw::c_int)>;
4922#[doc = " Declares of a struct type to the local system time."]
4923#[repr(C)]
4924#[derive(Debug, Copy, Clone)]
4925pub struct _FPDF_SYSTEMTIME {
4926 #[doc = " years since 1900"]
4927 pub wYear: ::std::os::raw::c_ushort,
4928 #[doc = " months since January - [0,11]"]
4929 pub wMonth: ::std::os::raw::c_ushort,
4930 #[doc = " days since Sunday - [0,6]"]
4931 pub wDayOfWeek: ::std::os::raw::c_ushort,
4932 #[doc = " day of the month - [1,31]"]
4933 pub wDay: ::std::os::raw::c_ushort,
4934 #[doc = " hours since midnight - [0,23]"]
4935 pub wHour: ::std::os::raw::c_ushort,
4936 #[doc = " minutes after the hour - [0,59]"]
4937 pub wMinute: ::std::os::raw::c_ushort,
4938 #[doc = " seconds after the minute - [0,59]"]
4939 pub wSecond: ::std::os::raw::c_ushort,
4940 #[doc = " milliseconds after the second - [0,999]"]
4941 pub wMilliseconds: ::std::os::raw::c_ushort,
4942}
4943#[test]
4944fn bindgen_test_layout__FPDF_SYSTEMTIME() {
4945 const UNINIT: ::std::mem::MaybeUninit<_FPDF_SYSTEMTIME> = ::std::mem::MaybeUninit::uninit();
4946 let ptr = UNINIT.as_ptr();
4947 assert_eq!(
4948 ::std::mem::size_of::<_FPDF_SYSTEMTIME>(),
4949 16usize,
4950 concat!("Size of: ", stringify!(_FPDF_SYSTEMTIME))
4951 );
4952 assert_eq!(
4953 ::std::mem::align_of::<_FPDF_SYSTEMTIME>(),
4954 2usize,
4955 concat!("Alignment of ", stringify!(_FPDF_SYSTEMTIME))
4956 );
4957 assert_eq!(
4958 unsafe { ::std::ptr::addr_of!((*ptr).wYear) as usize - ptr as usize },
4959 0usize,
4960 concat!(
4961 "Offset of field: ",
4962 stringify!(_FPDF_SYSTEMTIME),
4963 "::",
4964 stringify!(wYear)
4965 )
4966 );
4967 assert_eq!(
4968 unsafe { ::std::ptr::addr_of!((*ptr).wMonth) as usize - ptr as usize },
4969 2usize,
4970 concat!(
4971 "Offset of field: ",
4972 stringify!(_FPDF_SYSTEMTIME),
4973 "::",
4974 stringify!(wMonth)
4975 )
4976 );
4977 assert_eq!(
4978 unsafe { ::std::ptr::addr_of!((*ptr).wDayOfWeek) as usize - ptr as usize },
4979 4usize,
4980 concat!(
4981 "Offset of field: ",
4982 stringify!(_FPDF_SYSTEMTIME),
4983 "::",
4984 stringify!(wDayOfWeek)
4985 )
4986 );
4987 assert_eq!(
4988 unsafe { ::std::ptr::addr_of!((*ptr).wDay) as usize - ptr as usize },
4989 6usize,
4990 concat!(
4991 "Offset of field: ",
4992 stringify!(_FPDF_SYSTEMTIME),
4993 "::",
4994 stringify!(wDay)
4995 )
4996 );
4997 assert_eq!(
4998 unsafe { ::std::ptr::addr_of!((*ptr).wHour) as usize - ptr as usize },
4999 8usize,
5000 concat!(
5001 "Offset of field: ",
5002 stringify!(_FPDF_SYSTEMTIME),
5003 "::",
5004 stringify!(wHour)
5005 )
5006 );
5007 assert_eq!(
5008 unsafe { ::std::ptr::addr_of!((*ptr).wMinute) as usize - ptr as usize },
5009 10usize,
5010 concat!(
5011 "Offset of field: ",
5012 stringify!(_FPDF_SYSTEMTIME),
5013 "::",
5014 stringify!(wMinute)
5015 )
5016 );
5017 assert_eq!(
5018 unsafe { ::std::ptr::addr_of!((*ptr).wSecond) as usize - ptr as usize },
5019 12usize,
5020 concat!(
5021 "Offset of field: ",
5022 stringify!(_FPDF_SYSTEMTIME),
5023 "::",
5024 stringify!(wSecond)
5025 )
5026 );
5027 assert_eq!(
5028 unsafe { ::std::ptr::addr_of!((*ptr).wMilliseconds) as usize - ptr as usize },
5029 14usize,
5030 concat!(
5031 "Offset of field: ",
5032 stringify!(_FPDF_SYSTEMTIME),
5033 "::",
5034 stringify!(wMilliseconds)
5035 )
5036 );
5037}
5038#[doc = " Declares of a struct type to the local system time."]
5039pub type FPDF_SYSTEMTIME = _FPDF_SYSTEMTIME;
5040#[repr(C)]
5041#[derive(Debug, Copy, Clone)]
5042pub struct _FPDF_FORMFILLINFO {
5043 #[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."]
5044 pub version: ::std::os::raw::c_int,
5045 #[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"]
5046 pub Release: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO)>,
5047 #[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."]
5048 pub FFI_Invalidate: ::std::option::Option<
5049 unsafe extern "C" fn(
5050 pThis: *mut _FPDF_FORMFILLINFO,
5051 page: FPDF_PAGE,
5052 left: f64,
5053 top: f64,
5054 right: f64,
5055 bottom: f64,
5056 ),
5057 >,
5058 #[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."]
5059 pub FFI_OutputSelectedRect: ::std::option::Option<
5060 unsafe extern "C" fn(
5061 pThis: *mut _FPDF_FORMFILLINFO,
5062 page: FPDF_PAGE,
5063 left: f64,
5064 top: f64,
5065 right: f64,
5066 bottom: f64,
5067 ),
5068 >,
5069 #[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."]
5070 pub FFI_SetCursor: ::std::option::Option<
5071 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, nCursorType: ::std::os::raw::c_int),
5072 >,
5073 #[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."]
5074 pub FFI_SetTimer: ::std::option::Option<
5075 unsafe extern "C" fn(
5076 pThis: *mut _FPDF_FORMFILLINFO,
5077 uElapse: ::std::os::raw::c_int,
5078 lpTimerFunc: TimerCallback,
5079 ) -> ::std::os::raw::c_int,
5080 >,
5081 #[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."]
5082 pub FFI_KillTimer: ::std::option::Option<
5083 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, nTimerID: ::std::os::raw::c_int),
5084 >,
5085 #[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."]
5086 pub FFI_GetLocalTime: ::std::option::Option<
5087 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO) -> FPDF_SYSTEMTIME,
5088 >,
5089 #[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."]
5090 pub FFI_OnChange: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO)>,
5091 #[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."]
5092 pub FFI_GetPage: ::std::option::Option<
5093 unsafe extern "C" fn(
5094 pThis: *mut _FPDF_FORMFILLINFO,
5095 document: FPDF_DOCUMENT,
5096 nPageIndex: ::std::os::raw::c_int,
5097 ) -> FPDF_PAGE,
5098 >,
5099 #[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."]
5100 pub FFI_GetCurrentPage: ::std::option::Option<
5101 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, document: FPDF_DOCUMENT) -> FPDF_PAGE,
5102 >,
5103 #[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."]
5104 pub FFI_GetRotation: ::std::option::Option<
5105 unsafe extern "C" fn(
5106 pThis: *mut _FPDF_FORMFILLINFO,
5107 page: FPDF_PAGE,
5108 ) -> ::std::os::raw::c_int,
5109 >,
5110 #[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."]
5111 pub FFI_ExecuteNamedAction: ::std::option::Option<
5112 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, namedAction: FPDF_BYTESTRING),
5113 >,
5114 #[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."]
5115 pub FFI_SetTextFieldFocus: ::std::option::Option<
5116 unsafe extern "C" fn(
5117 pThis: *mut _FPDF_FORMFILLINFO,
5118 value: FPDF_WIDESTRING,
5119 valueLen: FPDF_DWORD,
5120 is_focus: FPDF_BOOL,
5121 ),
5122 >,
5123 #[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."]
5124 pub FFI_DoURIAction: ::std::option::Option<
5125 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, bsURI: FPDF_BYTESTRING),
5126 >,
5127 #[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."]
5128 pub FFI_DoGoToAction: ::std::option::Option<
5129 unsafe extern "C" fn(
5130 pThis: *mut _FPDF_FORMFILLINFO,
5131 nPageIndex: ::std::os::raw::c_int,
5132 zoomMode: ::std::os::raw::c_int,
5133 fPosArray: *mut f32,
5134 sizeofArray: ::std::os::raw::c_int,
5135 ),
5136 >,
5137 #[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."]
5138 pub m_pJsPlatform: *mut IPDF_JSPLATFORM,
5139 #[doc = " Whether the XFA module is disabled when built with the XFA module.\n Interface Version:\n Ignored if |version| < 2."]
5140 pub xfa_disabled: FPDF_BOOL,
5141 #[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."]
5142 pub FFI_DisplayCaret: ::std::option::Option<
5143 unsafe extern "C" fn(
5144 pThis: *mut _FPDF_FORMFILLINFO,
5145 page: FPDF_PAGE,
5146 bVisible: FPDF_BOOL,
5147 left: f64,
5148 top: f64,
5149 right: f64,
5150 bottom: f64,
5151 ),
5152 >,
5153 #[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."]
5154 pub FFI_GetCurrentPageIndex: ::std::option::Option<
5155 unsafe extern "C" fn(
5156 pThis: *mut _FPDF_FORMFILLINFO,
5157 document: FPDF_DOCUMENT,
5158 ) -> ::std::os::raw::c_int,
5159 >,
5160 #[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."]
5161 pub FFI_SetCurrentPage: ::std::option::Option<
5162 unsafe extern "C" fn(
5163 pThis: *mut _FPDF_FORMFILLINFO,
5164 document: FPDF_DOCUMENT,
5165 iCurPage: ::std::os::raw::c_int,
5166 ),
5167 >,
5168 #[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."]
5169 pub FFI_GotoURL: ::std::option::Option<
5170 unsafe extern "C" fn(
5171 pThis: *mut _FPDF_FORMFILLINFO,
5172 document: FPDF_DOCUMENT,
5173 wsURL: FPDF_WIDESTRING,
5174 ),
5175 >,
5176 #[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."]
5177 pub FFI_GetPageViewRect: ::std::option::Option<
5178 unsafe extern "C" fn(
5179 pThis: *mut _FPDF_FORMFILLINFO,
5180 page: FPDF_PAGE,
5181 left: *mut f64,
5182 top: *mut f64,
5183 right: *mut f64,
5184 bottom: *mut f64,
5185 ),
5186 >,
5187 #[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."]
5188 pub FFI_PageEvent: ::std::option::Option<
5189 unsafe extern "C" fn(
5190 pThis: *mut _FPDF_FORMFILLINFO,
5191 page_count: ::std::os::raw::c_int,
5192 event_type: FPDF_DWORD,
5193 ),
5194 >,
5195 #[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."]
5196 pub FFI_PopupMenu: ::std::option::Option<
5197 unsafe extern "C" fn(
5198 pThis: *mut _FPDF_FORMFILLINFO,
5199 page: FPDF_PAGE,
5200 hWidget: FPDF_WIDGET,
5201 menuFlag: ::std::os::raw::c_int,
5202 x: f32,
5203 y: f32,
5204 ) -> FPDF_BOOL,
5205 >,
5206 #[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."]
5207 pub FFI_OpenFile: ::std::option::Option<
5208 unsafe extern "C" fn(
5209 pThis: *mut _FPDF_FORMFILLINFO,
5210 fileFlag: ::std::os::raw::c_int,
5211 wsURL: FPDF_WIDESTRING,
5212 mode: *const ::std::os::raw::c_char,
5213 ) -> *mut FPDF_FILEHANDLER,
5214 >,
5215 #[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."]
5216 pub FFI_EmailTo: ::std::option::Option<
5217 unsafe extern "C" fn(
5218 pThis: *mut _FPDF_FORMFILLINFO,
5219 fileHandler: *mut FPDF_FILEHANDLER,
5220 pTo: FPDF_WIDESTRING,
5221 pSubject: FPDF_WIDESTRING,
5222 pCC: FPDF_WIDESTRING,
5223 pBcc: FPDF_WIDESTRING,
5224 pMsg: FPDF_WIDESTRING,
5225 ),
5226 >,
5227 #[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."]
5228 pub FFI_UploadTo: ::std::option::Option<
5229 unsafe extern "C" fn(
5230 pThis: *mut _FPDF_FORMFILLINFO,
5231 fileHandler: *mut FPDF_FILEHANDLER,
5232 fileFlag: ::std::os::raw::c_int,
5233 uploadTo: FPDF_WIDESTRING,
5234 ),
5235 >,
5236 #[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."]
5237 pub FFI_GetPlatform: ::std::option::Option<
5238 unsafe extern "C" fn(
5239 pThis: *mut _FPDF_FORMFILLINFO,
5240 platform: *mut ::std::os::raw::c_void,
5241 length: ::std::os::raw::c_int,
5242 ) -> ::std::os::raw::c_int,
5243 >,
5244 #[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."]
5245 pub FFI_GetLanguage: ::std::option::Option<
5246 unsafe extern "C" fn(
5247 pThis: *mut _FPDF_FORMFILLINFO,
5248 language: *mut ::std::os::raw::c_void,
5249 length: ::std::os::raw::c_int,
5250 ) -> ::std::os::raw::c_int,
5251 >,
5252 #[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."]
5253 pub FFI_DownloadFromURL: ::std::option::Option<
5254 unsafe extern "C" fn(
5255 pThis: *mut _FPDF_FORMFILLINFO,
5256 URL: FPDF_WIDESTRING,
5257 ) -> *mut FPDF_FILEHANDLER,
5258 >,
5259 #[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."]
5260 pub FFI_PostRequestURL: ::std::option::Option<
5261 unsafe extern "C" fn(
5262 pThis: *mut _FPDF_FORMFILLINFO,
5263 wsURL: FPDF_WIDESTRING,
5264 wsData: FPDF_WIDESTRING,
5265 wsContentType: FPDF_WIDESTRING,
5266 wsEncode: FPDF_WIDESTRING,
5267 wsHeader: FPDF_WIDESTRING,
5268 response: *mut FPDF_BSTR,
5269 ) -> FPDF_BOOL,
5270 >,
5271 #[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."]
5272 pub FFI_PutRequestURL: ::std::option::Option<
5273 unsafe extern "C" fn(
5274 pThis: *mut _FPDF_FORMFILLINFO,
5275 wsURL: FPDF_WIDESTRING,
5276 wsData: FPDF_WIDESTRING,
5277 wsEncode: FPDF_WIDESTRING,
5278 ) -> FPDF_BOOL,
5279 >,
5280 #[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."]
5281 pub FFI_OnFocusChange: ::std::option::Option<
5282 unsafe extern "C" fn(
5283 param: *mut _FPDF_FORMFILLINFO,
5284 annot: FPDF_ANNOTATION,
5285 page_index: ::std::os::raw::c_int,
5286 ),
5287 >,
5288 #[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."]
5289 pub FFI_DoURIActionWithKeyboardModifier: ::std::option::Option<
5290 unsafe extern "C" fn(
5291 param: *mut _FPDF_FORMFILLINFO,
5292 uri: FPDF_BYTESTRING,
5293 modifiers: ::std::os::raw::c_int,
5294 ),
5295 >,
5296}
5297#[test]
5298fn bindgen_test_layout__FPDF_FORMFILLINFO() {
5299 const UNINIT: ::std::mem::MaybeUninit<_FPDF_FORMFILLINFO> = ::std::mem::MaybeUninit::uninit();
5300 let ptr = UNINIT.as_ptr();
5301 assert_eq!(
5302 ::std::mem::size_of::<_FPDF_FORMFILLINFO>(),
5303 280usize,
5304 concat!("Size of: ", stringify!(_FPDF_FORMFILLINFO))
5305 );
5306 assert_eq!(
5307 ::std::mem::align_of::<_FPDF_FORMFILLINFO>(),
5308 8usize,
5309 concat!("Alignment of ", stringify!(_FPDF_FORMFILLINFO))
5310 );
5311 assert_eq!(
5312 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
5313 0usize,
5314 concat!(
5315 "Offset of field: ",
5316 stringify!(_FPDF_FORMFILLINFO),
5317 "::",
5318 stringify!(version)
5319 )
5320 );
5321 assert_eq!(
5322 unsafe { ::std::ptr::addr_of!((*ptr).Release) as usize - ptr as usize },
5323 8usize,
5324 concat!(
5325 "Offset of field: ",
5326 stringify!(_FPDF_FORMFILLINFO),
5327 "::",
5328 stringify!(Release)
5329 )
5330 );
5331 assert_eq!(
5332 unsafe { ::std::ptr::addr_of!((*ptr).FFI_Invalidate) as usize - ptr as usize },
5333 16usize,
5334 concat!(
5335 "Offset of field: ",
5336 stringify!(_FPDF_FORMFILLINFO),
5337 "::",
5338 stringify!(FFI_Invalidate)
5339 )
5340 );
5341 assert_eq!(
5342 unsafe { ::std::ptr::addr_of!((*ptr).FFI_OutputSelectedRect) as usize - ptr as usize },
5343 24usize,
5344 concat!(
5345 "Offset of field: ",
5346 stringify!(_FPDF_FORMFILLINFO),
5347 "::",
5348 stringify!(FFI_OutputSelectedRect)
5349 )
5350 );
5351 assert_eq!(
5352 unsafe { ::std::ptr::addr_of!((*ptr).FFI_SetCursor) as usize - ptr as usize },
5353 32usize,
5354 concat!(
5355 "Offset of field: ",
5356 stringify!(_FPDF_FORMFILLINFO),
5357 "::",
5358 stringify!(FFI_SetCursor)
5359 )
5360 );
5361 assert_eq!(
5362 unsafe { ::std::ptr::addr_of!((*ptr).FFI_SetTimer) as usize - ptr as usize },
5363 40usize,
5364 concat!(
5365 "Offset of field: ",
5366 stringify!(_FPDF_FORMFILLINFO),
5367 "::",
5368 stringify!(FFI_SetTimer)
5369 )
5370 );
5371 assert_eq!(
5372 unsafe { ::std::ptr::addr_of!((*ptr).FFI_KillTimer) as usize - ptr as usize },
5373 48usize,
5374 concat!(
5375 "Offset of field: ",
5376 stringify!(_FPDF_FORMFILLINFO),
5377 "::",
5378 stringify!(FFI_KillTimer)
5379 )
5380 );
5381 assert_eq!(
5382 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetLocalTime) as usize - ptr as usize },
5383 56usize,
5384 concat!(
5385 "Offset of field: ",
5386 stringify!(_FPDF_FORMFILLINFO),
5387 "::",
5388 stringify!(FFI_GetLocalTime)
5389 )
5390 );
5391 assert_eq!(
5392 unsafe { ::std::ptr::addr_of!((*ptr).FFI_OnChange) as usize - ptr as usize },
5393 64usize,
5394 concat!(
5395 "Offset of field: ",
5396 stringify!(_FPDF_FORMFILLINFO),
5397 "::",
5398 stringify!(FFI_OnChange)
5399 )
5400 );
5401 assert_eq!(
5402 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetPage) as usize - ptr as usize },
5403 72usize,
5404 concat!(
5405 "Offset of field: ",
5406 stringify!(_FPDF_FORMFILLINFO),
5407 "::",
5408 stringify!(FFI_GetPage)
5409 )
5410 );
5411 assert_eq!(
5412 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetCurrentPage) as usize - ptr as usize },
5413 80usize,
5414 concat!(
5415 "Offset of field: ",
5416 stringify!(_FPDF_FORMFILLINFO),
5417 "::",
5418 stringify!(FFI_GetCurrentPage)
5419 )
5420 );
5421 assert_eq!(
5422 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetRotation) as usize - ptr as usize },
5423 88usize,
5424 concat!(
5425 "Offset of field: ",
5426 stringify!(_FPDF_FORMFILLINFO),
5427 "::",
5428 stringify!(FFI_GetRotation)
5429 )
5430 );
5431 assert_eq!(
5432 unsafe { ::std::ptr::addr_of!((*ptr).FFI_ExecuteNamedAction) as usize - ptr as usize },
5433 96usize,
5434 concat!(
5435 "Offset of field: ",
5436 stringify!(_FPDF_FORMFILLINFO),
5437 "::",
5438 stringify!(FFI_ExecuteNamedAction)
5439 )
5440 );
5441 assert_eq!(
5442 unsafe { ::std::ptr::addr_of!((*ptr).FFI_SetTextFieldFocus) as usize - ptr as usize },
5443 104usize,
5444 concat!(
5445 "Offset of field: ",
5446 stringify!(_FPDF_FORMFILLINFO),
5447 "::",
5448 stringify!(FFI_SetTextFieldFocus)
5449 )
5450 );
5451 assert_eq!(
5452 unsafe { ::std::ptr::addr_of!((*ptr).FFI_DoURIAction) as usize - ptr as usize },
5453 112usize,
5454 concat!(
5455 "Offset of field: ",
5456 stringify!(_FPDF_FORMFILLINFO),
5457 "::",
5458 stringify!(FFI_DoURIAction)
5459 )
5460 );
5461 assert_eq!(
5462 unsafe { ::std::ptr::addr_of!((*ptr).FFI_DoGoToAction) as usize - ptr as usize },
5463 120usize,
5464 concat!(
5465 "Offset of field: ",
5466 stringify!(_FPDF_FORMFILLINFO),
5467 "::",
5468 stringify!(FFI_DoGoToAction)
5469 )
5470 );
5471 assert_eq!(
5472 unsafe { ::std::ptr::addr_of!((*ptr).m_pJsPlatform) as usize - ptr as usize },
5473 128usize,
5474 concat!(
5475 "Offset of field: ",
5476 stringify!(_FPDF_FORMFILLINFO),
5477 "::",
5478 stringify!(m_pJsPlatform)
5479 )
5480 );
5481 assert_eq!(
5482 unsafe { ::std::ptr::addr_of!((*ptr).xfa_disabled) as usize - ptr as usize },
5483 136usize,
5484 concat!(
5485 "Offset of field: ",
5486 stringify!(_FPDF_FORMFILLINFO),
5487 "::",
5488 stringify!(xfa_disabled)
5489 )
5490 );
5491 assert_eq!(
5492 unsafe { ::std::ptr::addr_of!((*ptr).FFI_DisplayCaret) as usize - ptr as usize },
5493 144usize,
5494 concat!(
5495 "Offset of field: ",
5496 stringify!(_FPDF_FORMFILLINFO),
5497 "::",
5498 stringify!(FFI_DisplayCaret)
5499 )
5500 );
5501 assert_eq!(
5502 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetCurrentPageIndex) as usize - ptr as usize },
5503 152usize,
5504 concat!(
5505 "Offset of field: ",
5506 stringify!(_FPDF_FORMFILLINFO),
5507 "::",
5508 stringify!(FFI_GetCurrentPageIndex)
5509 )
5510 );
5511 assert_eq!(
5512 unsafe { ::std::ptr::addr_of!((*ptr).FFI_SetCurrentPage) as usize - ptr as usize },
5513 160usize,
5514 concat!(
5515 "Offset of field: ",
5516 stringify!(_FPDF_FORMFILLINFO),
5517 "::",
5518 stringify!(FFI_SetCurrentPage)
5519 )
5520 );
5521 assert_eq!(
5522 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GotoURL) as usize - ptr as usize },
5523 168usize,
5524 concat!(
5525 "Offset of field: ",
5526 stringify!(_FPDF_FORMFILLINFO),
5527 "::",
5528 stringify!(FFI_GotoURL)
5529 )
5530 );
5531 assert_eq!(
5532 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetPageViewRect) as usize - ptr as usize },
5533 176usize,
5534 concat!(
5535 "Offset of field: ",
5536 stringify!(_FPDF_FORMFILLINFO),
5537 "::",
5538 stringify!(FFI_GetPageViewRect)
5539 )
5540 );
5541 assert_eq!(
5542 unsafe { ::std::ptr::addr_of!((*ptr).FFI_PageEvent) as usize - ptr as usize },
5543 184usize,
5544 concat!(
5545 "Offset of field: ",
5546 stringify!(_FPDF_FORMFILLINFO),
5547 "::",
5548 stringify!(FFI_PageEvent)
5549 )
5550 );
5551 assert_eq!(
5552 unsafe { ::std::ptr::addr_of!((*ptr).FFI_PopupMenu) as usize - ptr as usize },
5553 192usize,
5554 concat!(
5555 "Offset of field: ",
5556 stringify!(_FPDF_FORMFILLINFO),
5557 "::",
5558 stringify!(FFI_PopupMenu)
5559 )
5560 );
5561 assert_eq!(
5562 unsafe { ::std::ptr::addr_of!((*ptr).FFI_OpenFile) as usize - ptr as usize },
5563 200usize,
5564 concat!(
5565 "Offset of field: ",
5566 stringify!(_FPDF_FORMFILLINFO),
5567 "::",
5568 stringify!(FFI_OpenFile)
5569 )
5570 );
5571 assert_eq!(
5572 unsafe { ::std::ptr::addr_of!((*ptr).FFI_EmailTo) as usize - ptr as usize },
5573 208usize,
5574 concat!(
5575 "Offset of field: ",
5576 stringify!(_FPDF_FORMFILLINFO),
5577 "::",
5578 stringify!(FFI_EmailTo)
5579 )
5580 );
5581 assert_eq!(
5582 unsafe { ::std::ptr::addr_of!((*ptr).FFI_UploadTo) as usize - ptr as usize },
5583 216usize,
5584 concat!(
5585 "Offset of field: ",
5586 stringify!(_FPDF_FORMFILLINFO),
5587 "::",
5588 stringify!(FFI_UploadTo)
5589 )
5590 );
5591 assert_eq!(
5592 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetPlatform) as usize - ptr as usize },
5593 224usize,
5594 concat!(
5595 "Offset of field: ",
5596 stringify!(_FPDF_FORMFILLINFO),
5597 "::",
5598 stringify!(FFI_GetPlatform)
5599 )
5600 );
5601 assert_eq!(
5602 unsafe { ::std::ptr::addr_of!((*ptr).FFI_GetLanguage) as usize - ptr as usize },
5603 232usize,
5604 concat!(
5605 "Offset of field: ",
5606 stringify!(_FPDF_FORMFILLINFO),
5607 "::",
5608 stringify!(FFI_GetLanguage)
5609 )
5610 );
5611 assert_eq!(
5612 unsafe { ::std::ptr::addr_of!((*ptr).FFI_DownloadFromURL) as usize - ptr as usize },
5613 240usize,
5614 concat!(
5615 "Offset of field: ",
5616 stringify!(_FPDF_FORMFILLINFO),
5617 "::",
5618 stringify!(FFI_DownloadFromURL)
5619 )
5620 );
5621 assert_eq!(
5622 unsafe { ::std::ptr::addr_of!((*ptr).FFI_PostRequestURL) as usize - ptr as usize },
5623 248usize,
5624 concat!(
5625 "Offset of field: ",
5626 stringify!(_FPDF_FORMFILLINFO),
5627 "::",
5628 stringify!(FFI_PostRequestURL)
5629 )
5630 );
5631 assert_eq!(
5632 unsafe { ::std::ptr::addr_of!((*ptr).FFI_PutRequestURL) as usize - ptr as usize },
5633 256usize,
5634 concat!(
5635 "Offset of field: ",
5636 stringify!(_FPDF_FORMFILLINFO),
5637 "::",
5638 stringify!(FFI_PutRequestURL)
5639 )
5640 );
5641 assert_eq!(
5642 unsafe { ::std::ptr::addr_of!((*ptr).FFI_OnFocusChange) as usize - ptr as usize },
5643 264usize,
5644 concat!(
5645 "Offset of field: ",
5646 stringify!(_FPDF_FORMFILLINFO),
5647 "::",
5648 stringify!(FFI_OnFocusChange)
5649 )
5650 );
5651 assert_eq!(
5652 unsafe {
5653 ::std::ptr::addr_of!((*ptr).FFI_DoURIActionWithKeyboardModifier) as usize - ptr as usize
5654 },
5655 272usize,
5656 concat!(
5657 "Offset of field: ",
5658 stringify!(_FPDF_FORMFILLINFO),
5659 "::",
5660 stringify!(FFI_DoURIActionWithKeyboardModifier)
5661 )
5662 );
5663}
5664pub type FPDF_FORMFILLINFO = _FPDF_FORMFILLINFO;
5665extern "C" {
5666 #[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."]
5667 pub fn FPDFDOC_InitFormFillEnvironment(
5668 document: FPDF_DOCUMENT,
5669 formInfo: *mut FPDF_FORMFILLINFO,
5670 ) -> FPDF_FORMHANDLE;
5671}
5672extern "C" {
5673 #[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."]
5674 pub fn FPDFDOC_ExitFormFillEnvironment(hHandle: FPDF_FORMHANDLE);
5675}
5676extern "C" {
5677 #[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."]
5678 pub fn FORM_OnAfterLoadPage(page: FPDF_PAGE, hHandle: FPDF_FORMHANDLE);
5679}
5680extern "C" {
5681 #[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."]
5682 pub fn FORM_OnBeforeClosePage(page: FPDF_PAGE, hHandle: FPDF_FORMHANDLE);
5683}
5684extern "C" {
5685 #[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."]
5686 pub fn FORM_DoDocumentJSAction(hHandle: FPDF_FORMHANDLE);
5687}
5688extern "C" {
5689 #[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."]
5690 pub fn FORM_DoDocumentOpenAction(hHandle: FPDF_FORMHANDLE);
5691}
5692extern "C" {
5693 #[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|."]
5694 pub fn FORM_DoDocumentAAction(hHandle: FPDF_FORMHANDLE, aaType: ::std::os::raw::c_int);
5695}
5696extern "C" {
5697 #[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."]
5698 pub fn FORM_DoPageAAction(
5699 page: FPDF_PAGE,
5700 hHandle: FPDF_FORMHANDLE,
5701 aaType: ::std::os::raw::c_int,
5702 );
5703}
5704extern "C" {
5705 #[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."]
5706 pub fn FORM_OnMouseMove(
5707 hHandle: FPDF_FORMHANDLE,
5708 page: FPDF_PAGE,
5709 modifier: ::std::os::raw::c_int,
5710 page_x: f64,
5711 page_y: f64,
5712 ) -> FPDF_BOOL;
5713}
5714extern "C" {
5715 #[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."]
5716 pub fn FORM_OnMouseWheel(
5717 hHandle: FPDF_FORMHANDLE,
5718 page: FPDF_PAGE,
5719 modifier: ::std::os::raw::c_int,
5720 page_coord: *const FS_POINTF,
5721 delta_x: ::std::os::raw::c_int,
5722 delta_y: ::std::os::raw::c_int,
5723 ) -> FPDF_BOOL;
5724}
5725extern "C" {
5726 #[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."]
5727 pub fn FORM_OnFocus(
5728 hHandle: FPDF_FORMHANDLE,
5729 page: FPDF_PAGE,
5730 modifier: ::std::os::raw::c_int,
5731 page_x: f64,
5732 page_y: f64,
5733 ) -> FPDF_BOOL;
5734}
5735extern "C" {
5736 #[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."]
5737 pub fn FORM_OnLButtonDown(
5738 hHandle: FPDF_FORMHANDLE,
5739 page: FPDF_PAGE,
5740 modifier: ::std::os::raw::c_int,
5741 page_x: f64,
5742 page_y: f64,
5743 ) -> FPDF_BOOL;
5744}
5745extern "C" {
5746 #[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."]
5747 pub fn FORM_OnRButtonDown(
5748 hHandle: FPDF_FORMHANDLE,
5749 page: FPDF_PAGE,
5750 modifier: ::std::os::raw::c_int,
5751 page_x: f64,
5752 page_y: f64,
5753 ) -> FPDF_BOOL;
5754}
5755extern "C" {
5756 #[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."]
5757 pub fn FORM_OnLButtonUp(
5758 hHandle: FPDF_FORMHANDLE,
5759 page: FPDF_PAGE,
5760 modifier: ::std::os::raw::c_int,
5761 page_x: f64,
5762 page_y: f64,
5763 ) -> FPDF_BOOL;
5764}
5765extern "C" {
5766 #[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."]
5767 pub fn FORM_OnRButtonUp(
5768 hHandle: FPDF_FORMHANDLE,
5769 page: FPDF_PAGE,
5770 modifier: ::std::os::raw::c_int,
5771 page_x: f64,
5772 page_y: f64,
5773 ) -> FPDF_BOOL;
5774}
5775extern "C" {
5776 #[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."]
5777 pub fn FORM_OnLButtonDoubleClick(
5778 hHandle: FPDF_FORMHANDLE,
5779 page: FPDF_PAGE,
5780 modifier: ::std::os::raw::c_int,
5781 page_x: f64,
5782 page_y: f64,
5783 ) -> FPDF_BOOL;
5784}
5785extern "C" {
5786 #[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."]
5787 pub fn FORM_OnKeyDown(
5788 hHandle: FPDF_FORMHANDLE,
5789 page: FPDF_PAGE,
5790 nKeyCode: ::std::os::raw::c_int,
5791 modifier: ::std::os::raw::c_int,
5792 ) -> FPDF_BOOL;
5793}
5794extern "C" {
5795 #[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."]
5796 pub fn FORM_OnKeyUp(
5797 hHandle: FPDF_FORMHANDLE,
5798 page: FPDF_PAGE,
5799 nKeyCode: ::std::os::raw::c_int,
5800 modifier: ::std::os::raw::c_int,
5801 ) -> FPDF_BOOL;
5802}
5803extern "C" {
5804 #[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."]
5805 pub fn FORM_OnChar(
5806 hHandle: FPDF_FORMHANDLE,
5807 page: FPDF_PAGE,
5808 nChar: ::std::os::raw::c_int,
5809 modifier: ::std::os::raw::c_int,
5810 ) -> FPDF_BOOL;
5811}
5812extern "C" {
5813 #[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."]
5814 pub fn FORM_GetFocusedText(
5815 hHandle: FPDF_FORMHANDLE,
5816 page: FPDF_PAGE,
5817 buffer: *mut ::std::os::raw::c_void,
5818 buflen: ::std::os::raw::c_ulong,
5819 ) -> ::std::os::raw::c_ulong;
5820}
5821extern "C" {
5822 #[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."]
5823 pub fn FORM_GetSelectedText(
5824 hHandle: FPDF_FORMHANDLE,
5825 page: FPDF_PAGE,
5826 buffer: *mut ::std::os::raw::c_void,
5827 buflen: ::std::os::raw::c_ulong,
5828 ) -> ::std::os::raw::c_ulong;
5829}
5830extern "C" {
5831 #[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."]
5832 pub fn FORM_ReplaceAndKeepSelection(
5833 hHandle: FPDF_FORMHANDLE,
5834 page: FPDF_PAGE,
5835 wsText: FPDF_WIDESTRING,
5836 );
5837}
5838extern "C" {
5839 #[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."]
5840 pub fn FORM_ReplaceSelection(
5841 hHandle: FPDF_FORMHANDLE,
5842 page: FPDF_PAGE,
5843 wsText: FPDF_WIDESTRING,
5844 );
5845}
5846extern "C" {
5847 #[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."]
5848 pub fn FORM_SelectAllText(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
5849}
5850extern "C" {
5851 #[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."]
5852 pub fn FORM_CanUndo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
5853}
5854extern "C" {
5855 #[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."]
5856 pub fn FORM_CanRedo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
5857}
5858extern "C" {
5859 #[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."]
5860 pub fn FORM_Undo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
5861}
5862extern "C" {
5863 #[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."]
5864 pub fn FORM_Redo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
5865}
5866extern "C" {
5867 #[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."]
5868 pub fn FORM_ForceToKillFocus(hHandle: FPDF_FORMHANDLE) -> FPDF_BOOL;
5869}
5870extern "C" {
5871 #[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."]
5872 pub fn FORM_GetFocusedAnnot(
5873 handle: FPDF_FORMHANDLE,
5874 page_index: *mut ::std::os::raw::c_int,
5875 annot: *mut FPDF_ANNOTATION,
5876 ) -> FPDF_BOOL;
5877}
5878extern "C" {
5879 #[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."]
5880 pub fn FORM_SetFocusedAnnot(handle: FPDF_FORMHANDLE, annot: FPDF_ANNOTATION) -> FPDF_BOOL;
5881}
5882extern "C" {
5883 #[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."]
5884 pub fn FPDFPage_HasFormFieldAtPoint(
5885 hHandle: FPDF_FORMHANDLE,
5886 page: FPDF_PAGE,
5887 page_x: f64,
5888 page_y: f64,
5889 ) -> ::std::os::raw::c_int;
5890}
5891extern "C" {
5892 #[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."]
5893 pub fn FPDFPage_FormFieldZOrderAtPoint(
5894 hHandle: FPDF_FORMHANDLE,
5895 page: FPDF_PAGE,
5896 page_x: f64,
5897 page_y: f64,
5898 ) -> ::std::os::raw::c_int;
5899}
5900extern "C" {
5901 #[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."]
5902 pub fn FPDF_SetFormFieldHighlightColor(
5903 hHandle: FPDF_FORMHANDLE,
5904 fieldType: ::std::os::raw::c_int,
5905 color: ::std::os::raw::c_ulong,
5906 );
5907}
5908extern "C" {
5909 #[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."]
5910 pub fn FPDF_SetFormFieldHighlightAlpha(
5911 hHandle: FPDF_FORMHANDLE,
5912 alpha: ::std::os::raw::c_uchar,
5913 );
5914}
5915extern "C" {
5916 #[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."]
5917 pub fn FPDF_RemoveFormFieldHighlight(hHandle: FPDF_FORMHANDLE);
5918}
5919extern "C" {
5920 #[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."]
5921 pub fn FPDF_FFLDraw(
5922 hHandle: FPDF_FORMHANDLE,
5923 bitmap: FPDF_BITMAP,
5924 page: FPDF_PAGE,
5925 start_x: ::std::os::raw::c_int,
5926 start_y: ::std::os::raw::c_int,
5927 size_x: ::std::os::raw::c_int,
5928 size_y: ::std::os::raw::c_int,
5929 rotate: ::std::os::raw::c_int,
5930 flags: ::std::os::raw::c_int,
5931 );
5932}
5933extern "C" {
5934 pub fn FPDF_FFLDrawSkia(
5935 hHandle: FPDF_FORMHANDLE,
5936 canvas: FPDF_SKIA_CANVAS,
5937 page: FPDF_PAGE,
5938 start_x: ::std::os::raw::c_int,
5939 start_y: ::std::os::raw::c_int,
5940 size_x: ::std::os::raw::c_int,
5941 size_y: ::std::os::raw::c_int,
5942 rotate: ::std::os::raw::c_int,
5943 flags: ::std::os::raw::c_int,
5944 );
5945}
5946extern "C" {
5947 #[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."]
5948 pub fn FPDF_GetFormType(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
5949}
5950extern "C" {
5951 #[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."]
5952 pub fn FORM_SetIndexSelected(
5953 hHandle: FPDF_FORMHANDLE,
5954 page: FPDF_PAGE,
5955 index: ::std::os::raw::c_int,
5956 selected: FPDF_BOOL,
5957 ) -> FPDF_BOOL;
5958}
5959extern "C" {
5960 #[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."]
5961 pub fn FORM_IsIndexSelected(
5962 hHandle: FPDF_FORMHANDLE,
5963 page: FPDF_PAGE,
5964 index: ::std::os::raw::c_int,
5965 ) -> FPDF_BOOL;
5966}
5967extern "C" {
5968 #[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."]
5969 pub fn FPDF_LoadXFA(document: FPDF_DOCUMENT) -> FPDF_BOOL;
5970}
5971extern "C" {
5972 #[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."]
5973 pub fn FPDF_ImportPagesByIndex(
5974 dest_doc: FPDF_DOCUMENT,
5975 src_doc: FPDF_DOCUMENT,
5976 page_indices: *const ::std::os::raw::c_int,
5977 length: ::std::os::raw::c_ulong,
5978 index: ::std::os::raw::c_int,
5979 ) -> FPDF_BOOL;
5980}
5981extern "C" {
5982 #[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."]
5983 pub fn FPDF_ImportPages(
5984 dest_doc: FPDF_DOCUMENT,
5985 src_doc: FPDF_DOCUMENT,
5986 pagerange: FPDF_BYTESTRING,
5987 index: ::std::os::raw::c_int,
5988 ) -> FPDF_BOOL;
5989}
5990extern "C" {
5991 #[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"]
5992 pub fn FPDF_ImportNPagesToOne(
5993 src_doc: FPDF_DOCUMENT,
5994 output_width: f32,
5995 output_height: f32,
5996 num_pages_on_x_axis: usize,
5997 num_pages_on_y_axis: usize,
5998 ) -> FPDF_DOCUMENT;
5999}
6000extern "C" {
6001 #[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."]
6002 pub fn FPDF_NewXObjectFromPage(
6003 dest_doc: FPDF_DOCUMENT,
6004 src_doc: FPDF_DOCUMENT,
6005 src_page_index: ::std::os::raw::c_int,
6006 ) -> FPDF_XOBJECT;
6007}
6008extern "C" {
6009 #[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."]
6010 pub fn FPDF_CloseXObject(xobject: FPDF_XOBJECT);
6011}
6012extern "C" {
6013 #[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."]
6014 pub fn FPDF_NewFormObjectFromXObject(xobject: FPDF_XOBJECT) -> FPDF_PAGEOBJECT;
6015}
6016extern "C" {
6017 #[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."]
6018 pub fn FPDF_CopyViewerPreferences(dest_doc: FPDF_DOCUMENT, src_doc: FPDF_DOCUMENT)
6019 -> FPDF_BOOL;
6020}
6021pub const FPDFANNOT_COLORTYPE_FPDFANNOT_COLORTYPE_Color: FPDFANNOT_COLORTYPE = 0;
6022pub const FPDFANNOT_COLORTYPE_FPDFANNOT_COLORTYPE_InteriorColor: FPDFANNOT_COLORTYPE = 1;
6023pub type FPDFANNOT_COLORTYPE = ::std::os::raw::c_uint;
6024extern "C" {
6025 #[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."]
6026 pub fn FPDFAnnot_IsSupportedSubtype(subtype: FPDF_ANNOTATION_SUBTYPE) -> FPDF_BOOL;
6027}
6028extern "C" {
6029 #[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."]
6030 pub fn FPDFPage_CreateAnnot(
6031 page: FPDF_PAGE,
6032 subtype: FPDF_ANNOTATION_SUBTYPE,
6033 ) -> FPDF_ANNOTATION;
6034}
6035extern "C" {
6036 #[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|."]
6037 pub fn FPDFPage_GetAnnotCount(page: FPDF_PAGE) -> ::std::os::raw::c_int;
6038}
6039extern "C" {
6040 #[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."]
6041 pub fn FPDFPage_GetAnnot(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_ANNOTATION;
6042}
6043extern "C" {
6044 #[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."]
6045 pub fn FPDFPage_GetAnnotIndex(page: FPDF_PAGE, annot: FPDF_ANNOTATION)
6046 -> ::std::os::raw::c_int;
6047}
6048extern "C" {
6049 #[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."]
6050 pub fn FPDFPage_CloseAnnot(annot: FPDF_ANNOTATION);
6051}
6052extern "C" {
6053 #[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."]
6054 pub fn FPDFPage_RemoveAnnot(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_BOOL;
6055}
6056extern "C" {
6057 #[doc = " Experimental API.\n Get the subtype of an annotation.\n\n annot - handle to an annotation.\n\n Returns the annotation subtype."]
6058 pub fn FPDFAnnot_GetSubtype(annot: FPDF_ANNOTATION) -> FPDF_ANNOTATION_SUBTYPE;
6059}
6060extern "C" {
6061 #[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."]
6062 pub fn FPDFAnnot_IsObjectSupportedSubtype(subtype: FPDF_ANNOTATION_SUBTYPE) -> FPDF_BOOL;
6063}
6064extern "C" {
6065 #[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."]
6066 pub fn FPDFAnnot_UpdateObject(annot: FPDF_ANNOTATION, obj: FPDF_PAGEOBJECT) -> FPDF_BOOL;
6067}
6068extern "C" {
6069 #[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."]
6070 pub fn FPDFAnnot_AddInkStroke(
6071 annot: FPDF_ANNOTATION,
6072 points: *const FS_POINTF,
6073 point_count: usize,
6074 ) -> ::std::os::raw::c_int;
6075}
6076extern "C" {
6077 #[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."]
6078 pub fn FPDFAnnot_RemoveInkList(annot: FPDF_ANNOTATION) -> FPDF_BOOL;
6079}
6080extern "C" {
6081 #[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."]
6082 pub fn FPDFAnnot_AppendObject(annot: FPDF_ANNOTATION, obj: FPDF_PAGEOBJECT) -> FPDF_BOOL;
6083}
6084extern "C" {
6085 #[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|."]
6086 pub fn FPDFAnnot_GetObjectCount(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_int;
6087}
6088extern "C" {
6089 #[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."]
6090 pub fn FPDFAnnot_GetObject(
6091 annot: FPDF_ANNOTATION,
6092 index: ::std::os::raw::c_int,
6093 ) -> FPDF_PAGEOBJECT;
6094}
6095extern "C" {
6096 #[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."]
6097 pub fn FPDFAnnot_RemoveObject(
6098 annot: FPDF_ANNOTATION,
6099 index: ::std::os::raw::c_int,
6100 ) -> FPDF_BOOL;
6101}
6102extern "C" {
6103 #[doc = " Experimental API.\n Set the color of an annotation. Fails when called on annotations with\n appearance streams already defined; instead use\n FPDFPath_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."]
6104 pub fn FPDFAnnot_SetColor(
6105 annot: FPDF_ANNOTATION,
6106 type_: FPDFANNOT_COLORTYPE,
6107 R: ::std::os::raw::c_uint,
6108 G: ::std::os::raw::c_uint,
6109 B: ::std::os::raw::c_uint,
6110 A: ::std::os::raw::c_uint,
6111 ) -> FPDF_BOOL;
6112}
6113extern "C" {
6114 #[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 FPDFPath_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."]
6115 pub fn FPDFAnnot_GetColor(
6116 annot: FPDF_ANNOTATION,
6117 type_: FPDFANNOT_COLORTYPE,
6118 R: *mut ::std::os::raw::c_uint,
6119 G: *mut ::std::os::raw::c_uint,
6120 B: *mut ::std::os::raw::c_uint,
6121 A: *mut ::std::os::raw::c_uint,
6122 ) -> FPDF_BOOL;
6123}
6124extern "C" {
6125 #[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."]
6126 pub fn FPDFAnnot_HasAttachmentPoints(annot: FPDF_ANNOTATION) -> FPDF_BOOL;
6127}
6128extern "C" {
6129 #[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."]
6130 pub fn FPDFAnnot_SetAttachmentPoints(
6131 annot: FPDF_ANNOTATION,
6132 quad_index: usize,
6133 quad_points: *const FS_QUADPOINTSF,
6134 ) -> FPDF_BOOL;
6135}
6136extern "C" {
6137 #[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."]
6138 pub fn FPDFAnnot_AppendAttachmentPoints(
6139 annot: FPDF_ANNOTATION,
6140 quad_points: *const FS_QUADPOINTSF,
6141 ) -> FPDF_BOOL;
6142}
6143extern "C" {
6144 #[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."]
6145 pub fn FPDFAnnot_CountAttachmentPoints(annot: FPDF_ANNOTATION) -> usize;
6146}
6147extern "C" {
6148 #[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."]
6149 pub fn FPDFAnnot_GetAttachmentPoints(
6150 annot: FPDF_ANNOTATION,
6151 quad_index: usize,
6152 quad_points: *mut FS_QUADPOINTSF,
6153 ) -> FPDF_BOOL;
6154}
6155extern "C" {
6156 #[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."]
6157 pub fn FPDFAnnot_SetRect(annot: FPDF_ANNOTATION, rect: *const FS_RECTF) -> FPDF_BOOL;
6158}
6159extern "C" {
6160 #[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."]
6161 pub fn FPDFAnnot_GetRect(annot: FPDF_ANNOTATION, rect: *mut FS_RECTF) -> FPDF_BOOL;
6162}
6163extern "C" {
6164 #[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."]
6165 pub fn FPDFAnnot_GetVertices(
6166 annot: FPDF_ANNOTATION,
6167 buffer: *mut FS_POINTF,
6168 length: ::std::os::raw::c_ulong,
6169 ) -> ::std::os::raw::c_ulong;
6170}
6171extern "C" {
6172 #[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."]
6173 pub fn FPDFAnnot_GetInkListCount(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_ulong;
6174}
6175extern "C" {
6176 #[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."]
6177 pub fn FPDFAnnot_GetInkListPath(
6178 annot: FPDF_ANNOTATION,
6179 path_index: ::std::os::raw::c_ulong,
6180 buffer: *mut FS_POINTF,
6181 length: ::std::os::raw::c_ulong,
6182 ) -> ::std::os::raw::c_ulong;
6183}
6184extern "C" {
6185 #[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."]
6186 pub fn FPDFAnnot_GetLine(
6187 annot: FPDF_ANNOTATION,
6188 start: *mut FS_POINTF,
6189 end: *mut FS_POINTF,
6190 ) -> FPDF_BOOL;
6191}
6192extern "C" {
6193 #[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."]
6194 pub fn FPDFAnnot_SetBorder(
6195 annot: FPDF_ANNOTATION,
6196 horizontal_radius: f32,
6197 vertical_radius: f32,
6198 border_width: f32,
6199 ) -> FPDF_BOOL;
6200}
6201extern "C" {
6202 #[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."]
6203 pub fn FPDFAnnot_GetBorder(
6204 annot: FPDF_ANNOTATION,
6205 horizontal_radius: *mut f32,
6206 vertical_radius: *mut f32,
6207 border_width: *mut f32,
6208 ) -> FPDF_BOOL;
6209}
6210extern "C" {
6211 #[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."]
6212 pub fn FPDFAnnot_GetFormAdditionalActionJavaScript(
6213 hHandle: FPDF_FORMHANDLE,
6214 annot: FPDF_ANNOTATION,
6215 event: ::std::os::raw::c_int,
6216 buffer: *mut FPDF_WCHAR,
6217 buflen: ::std::os::raw::c_ulong,
6218 ) -> ::std::os::raw::c_ulong;
6219}
6220extern "C" {
6221 #[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."]
6222 pub fn FPDFAnnot_HasKey(annot: FPDF_ANNOTATION, key: FPDF_BYTESTRING) -> FPDF_BOOL;
6223}
6224extern "C" {
6225 #[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."]
6226 pub fn FPDFAnnot_GetValueType(annot: FPDF_ANNOTATION, key: FPDF_BYTESTRING)
6227 -> FPDF_OBJECT_TYPE;
6228}
6229extern "C" {
6230 #[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."]
6231 pub fn FPDFAnnot_SetStringValue(
6232 annot: FPDF_ANNOTATION,
6233 key: FPDF_BYTESTRING,
6234 value: FPDF_WIDESTRING,
6235 ) -> FPDF_BOOL;
6236}
6237extern "C" {
6238 #[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."]
6239 pub fn FPDFAnnot_GetStringValue(
6240 annot: FPDF_ANNOTATION,
6241 key: FPDF_BYTESTRING,
6242 buffer: *mut FPDF_WCHAR,
6243 buflen: ::std::os::raw::c_ulong,
6244 ) -> ::std::os::raw::c_ulong;
6245}
6246extern "C" {
6247 #[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."]
6248 pub fn FPDFAnnot_GetNumberValue(
6249 annot: FPDF_ANNOTATION,
6250 key: FPDF_BYTESTRING,
6251 value: *mut f32,
6252 ) -> FPDF_BOOL;
6253}
6254extern "C" {
6255 #[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."]
6256 pub fn FPDFAnnot_SetAP(
6257 annot: FPDF_ANNOTATION,
6258 appearanceMode: FPDF_ANNOT_APPEARANCEMODE,
6259 value: FPDF_WIDESTRING,
6260 ) -> FPDF_BOOL;
6261}
6262extern "C" {
6263 #[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."]
6264 pub fn FPDFAnnot_GetAP(
6265 annot: FPDF_ANNOTATION,
6266 appearanceMode: FPDF_ANNOT_APPEARANCEMODE,
6267 buffer: *mut FPDF_WCHAR,
6268 buflen: ::std::os::raw::c_ulong,
6269 ) -> ::std::os::raw::c_ulong;
6270}
6271extern "C" {
6272 #[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."]
6273 pub fn FPDFAnnot_GetLinkedAnnot(
6274 annot: FPDF_ANNOTATION,
6275 key: FPDF_BYTESTRING,
6276 ) -> FPDF_ANNOTATION;
6277}
6278extern "C" {
6279 #[doc = " Experimental API.\n Get the annotation flags of |annot|.\n\n annot - handle to an annotation.\n\n Returns the annotation flags."]
6280 pub fn FPDFAnnot_GetFlags(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_int;
6281}
6282extern "C" {
6283 #[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."]
6284 pub fn FPDFAnnot_SetFlags(annot: FPDF_ANNOTATION, flags: ::std::os::raw::c_int) -> FPDF_BOOL;
6285}
6286extern "C" {
6287 #[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."]
6288 pub fn FPDFAnnot_GetFormFieldFlags(
6289 handle: FPDF_FORMHANDLE,
6290 annot: FPDF_ANNOTATION,
6291 ) -> ::std::os::raw::c_int;
6292}
6293extern "C" {
6294 #[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."]
6295 pub fn FPDFAnnot_GetFormFieldAtPoint(
6296 hHandle: FPDF_FORMHANDLE,
6297 page: FPDF_PAGE,
6298 point: *const FS_POINTF,
6299 ) -> FPDF_ANNOTATION;
6300}
6301extern "C" {
6302 #[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."]
6303 pub fn FPDFAnnot_GetFormFieldName(
6304 hHandle: FPDF_FORMHANDLE,
6305 annot: FPDF_ANNOTATION,
6306 buffer: *mut FPDF_WCHAR,
6307 buflen: ::std::os::raw::c_ulong,
6308 ) -> ::std::os::raw::c_ulong;
6309}
6310extern "C" {
6311 #[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."]
6312 pub fn FPDFAnnot_GetFormFieldAlternateName(
6313 hHandle: FPDF_FORMHANDLE,
6314 annot: FPDF_ANNOTATION,
6315 buffer: *mut FPDF_WCHAR,
6316 buflen: ::std::os::raw::c_ulong,
6317 ) -> ::std::os::raw::c_ulong;
6318}
6319extern "C" {
6320 #[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."]
6321 pub fn FPDFAnnot_GetFormFieldType(
6322 hHandle: FPDF_FORMHANDLE,
6323 annot: FPDF_ANNOTATION,
6324 ) -> ::std::os::raw::c_int;
6325}
6326extern "C" {
6327 #[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."]
6328 pub fn FPDFAnnot_GetFormFieldValue(
6329 hHandle: FPDF_FORMHANDLE,
6330 annot: FPDF_ANNOTATION,
6331 buffer: *mut FPDF_WCHAR,
6332 buflen: ::std::os::raw::c_ulong,
6333 ) -> ::std::os::raw::c_ulong;
6334}
6335extern "C" {
6336 #[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."]
6337 pub fn FPDFAnnot_GetOptionCount(
6338 hHandle: FPDF_FORMHANDLE,
6339 annot: FPDF_ANNOTATION,
6340 ) -> ::std::os::raw::c_int;
6341}
6342extern "C" {
6343 #[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."]
6344 pub fn FPDFAnnot_GetOptionLabel(
6345 hHandle: FPDF_FORMHANDLE,
6346 annot: FPDF_ANNOTATION,
6347 index: ::std::os::raw::c_int,
6348 buffer: *mut FPDF_WCHAR,
6349 buflen: ::std::os::raw::c_ulong,
6350 ) -> ::std::os::raw::c_ulong;
6351}
6352extern "C" {
6353 #[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."]
6354 pub fn FPDFAnnot_IsOptionSelected(
6355 handle: FPDF_FORMHANDLE,
6356 annot: FPDF_ANNOTATION,
6357 index: ::std::os::raw::c_int,
6358 ) -> FPDF_BOOL;
6359}
6360extern "C" {
6361 #[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."]
6362 pub fn FPDFAnnot_GetFontSize(
6363 hHandle: FPDF_FORMHANDLE,
6364 annot: FPDF_ANNOTATION,
6365 value: *mut f32,
6366 ) -> FPDF_BOOL;
6367}
6368extern "C" {
6369 #[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."]
6370 pub fn FPDFAnnot_GetFontColor(
6371 hHandle: FPDF_FORMHANDLE,
6372 annot: FPDF_ANNOTATION,
6373 R: *mut ::std::os::raw::c_uint,
6374 G: *mut ::std::os::raw::c_uint,
6375 B: *mut ::std::os::raw::c_uint,
6376 ) -> FPDF_BOOL;
6377}
6378extern "C" {
6379 #[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."]
6380 pub fn FPDFAnnot_IsChecked(hHandle: FPDF_FORMHANDLE, annot: FPDF_ANNOTATION) -> FPDF_BOOL;
6381}
6382extern "C" {
6383 #[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."]
6384 pub fn FPDFAnnot_SetFocusableSubtypes(
6385 hHandle: FPDF_FORMHANDLE,
6386 subtypes: *const FPDF_ANNOTATION_SUBTYPE,
6387 count: usize,
6388 ) -> FPDF_BOOL;
6389}
6390extern "C" {
6391 #[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."]
6392 pub fn FPDFAnnot_GetFocusableSubtypesCount(hHandle: FPDF_FORMHANDLE) -> ::std::os::raw::c_int;
6393}
6394extern "C" {
6395 #[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."]
6396 pub fn FPDFAnnot_GetFocusableSubtypes(
6397 hHandle: FPDF_FORMHANDLE,
6398 subtypes: *mut FPDF_ANNOTATION_SUBTYPE,
6399 count: usize,
6400 ) -> FPDF_BOOL;
6401}
6402extern "C" {
6403 #[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."]
6404 pub fn FPDFAnnot_GetLink(annot: FPDF_ANNOTATION) -> FPDF_LINK;
6405}
6406extern "C" {
6407 #[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."]
6408 pub fn FPDFAnnot_GetFormControlCount(
6409 hHandle: FPDF_FORMHANDLE,
6410 annot: FPDF_ANNOTATION,
6411 ) -> ::std::os::raw::c_int;
6412}
6413extern "C" {
6414 #[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."]
6415 pub fn FPDFAnnot_GetFormControlIndex(
6416 hHandle: FPDF_FORMHANDLE,
6417 annot: FPDF_ANNOTATION,
6418 ) -> ::std::os::raw::c_int;
6419}
6420extern "C" {
6421 #[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."]
6422 pub fn FPDFAnnot_GetFormFieldExportValue(
6423 hHandle: FPDF_FORMHANDLE,
6424 annot: FPDF_ANNOTATION,
6425 buffer: *mut FPDF_WCHAR,
6426 buflen: ::std::os::raw::c_ulong,
6427 ) -> ::std::os::raw::c_ulong;
6428}
6429extern "C" {
6430 #[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."]
6431 pub fn FPDFAnnot_SetURI(
6432 annot: FPDF_ANNOTATION,
6433 uri: *const ::std::os::raw::c_char,
6434 ) -> FPDF_BOOL;
6435}
6436extern "C" {
6437 #[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."]
6438 pub fn FPDFAnnot_GetFileAttachment(annot: FPDF_ANNOTATION) -> FPDF_ATTACHMENT;
6439}
6440extern "C" {
6441 #[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."]
6442 pub fn FPDFAnnot_AddFileAttachment(
6443 annot: FPDF_ANNOTATION,
6444 name: FPDF_WIDESTRING,
6445 ) -> FPDF_ATTACHMENT;
6446}
6447extern "C" {
6448 #[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."]
6449 pub fn FPDF_GetSignatureCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
6450}
6451extern "C" {
6452 #[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."]
6453 pub fn FPDF_GetSignatureObject(
6454 document: FPDF_DOCUMENT,
6455 index: ::std::os::raw::c_int,
6456 ) -> FPDF_SIGNATURE;
6457}
6458extern "C" {
6459 #[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."]
6460 pub fn FPDFSignatureObj_GetContents(
6461 signature: FPDF_SIGNATURE,
6462 buffer: *mut ::std::os::raw::c_void,
6463 length: ::std::os::raw::c_ulong,
6464 ) -> ::std::os::raw::c_ulong;
6465}
6466extern "C" {
6467 #[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."]
6468 pub fn FPDFSignatureObj_GetByteRange(
6469 signature: FPDF_SIGNATURE,
6470 buffer: *mut ::std::os::raw::c_int,
6471 length: ::std::os::raw::c_ulong,
6472 ) -> ::std::os::raw::c_ulong;
6473}
6474extern "C" {
6475 #[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."]
6476 pub fn FPDFSignatureObj_GetSubFilter(
6477 signature: FPDF_SIGNATURE,
6478 buffer: *mut ::std::os::raw::c_char,
6479 length: ::std::os::raw::c_ulong,
6480 ) -> ::std::os::raw::c_ulong;
6481}
6482extern "C" {
6483 #[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."]
6484 pub fn FPDFSignatureObj_GetReason(
6485 signature: FPDF_SIGNATURE,
6486 buffer: *mut ::std::os::raw::c_void,
6487 length: ::std::os::raw::c_ulong,
6488 ) -> ::std::os::raw::c_ulong;
6489}
6490extern "C" {
6491 #[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."]
6492 pub fn FPDFSignatureObj_GetTime(
6493 signature: FPDF_SIGNATURE,
6494 buffer: *mut ::std::os::raw::c_char,
6495 length: ::std::os::raw::c_ulong,
6496 ) -> ::std::os::raw::c_ulong;
6497}
6498extern "C" {
6499 #[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."]
6500 pub fn FPDFSignatureObj_GetDocMDPPermission(
6501 signature: FPDF_SIGNATURE,
6502 ) -> ::std::os::raw::c_uint;
6503}
6504pub const FWL_EVENTFLAG_FWL_EVENTFLAG_ShiftKey: FWL_EVENTFLAG = 1;
6505pub const FWL_EVENTFLAG_FWL_EVENTFLAG_ControlKey: FWL_EVENTFLAG = 2;
6506pub const FWL_EVENTFLAG_FWL_EVENTFLAG_AltKey: FWL_EVENTFLAG = 4;
6507pub const FWL_EVENTFLAG_FWL_EVENTFLAG_MetaKey: FWL_EVENTFLAG = 8;
6508pub const FWL_EVENTFLAG_FWL_EVENTFLAG_KeyPad: FWL_EVENTFLAG = 16;
6509pub const FWL_EVENTFLAG_FWL_EVENTFLAG_AutoRepeat: FWL_EVENTFLAG = 32;
6510pub const FWL_EVENTFLAG_FWL_EVENTFLAG_LeftButtonDown: FWL_EVENTFLAG = 64;
6511pub const FWL_EVENTFLAG_FWL_EVENTFLAG_MiddleButtonDown: FWL_EVENTFLAG = 128;
6512pub const FWL_EVENTFLAG_FWL_EVENTFLAG_RightButtonDown: FWL_EVENTFLAG = 256;
6513#[doc = " Key flags."]
6514pub type FWL_EVENTFLAG = ::std::os::raw::c_uint;
6515pub const FWL_VKEYCODE_FWL_VKEY_Back: FWL_VKEYCODE = 8;
6516pub const FWL_VKEYCODE_FWL_VKEY_Tab: FWL_VKEYCODE = 9;
6517pub const FWL_VKEYCODE_FWL_VKEY_NewLine: FWL_VKEYCODE = 10;
6518pub const FWL_VKEYCODE_FWL_VKEY_Clear: FWL_VKEYCODE = 12;
6519pub const FWL_VKEYCODE_FWL_VKEY_Return: FWL_VKEYCODE = 13;
6520pub const FWL_VKEYCODE_FWL_VKEY_Shift: FWL_VKEYCODE = 16;
6521pub const FWL_VKEYCODE_FWL_VKEY_Control: FWL_VKEYCODE = 17;
6522pub const FWL_VKEYCODE_FWL_VKEY_Menu: FWL_VKEYCODE = 18;
6523pub const FWL_VKEYCODE_FWL_VKEY_Pause: FWL_VKEYCODE = 19;
6524pub const FWL_VKEYCODE_FWL_VKEY_Capital: FWL_VKEYCODE = 20;
6525pub const FWL_VKEYCODE_FWL_VKEY_Kana: FWL_VKEYCODE = 21;
6526pub const FWL_VKEYCODE_FWL_VKEY_Hangul: FWL_VKEYCODE = 21;
6527pub const FWL_VKEYCODE_FWL_VKEY_Junja: FWL_VKEYCODE = 23;
6528pub const FWL_VKEYCODE_FWL_VKEY_Final: FWL_VKEYCODE = 24;
6529pub const FWL_VKEYCODE_FWL_VKEY_Hanja: FWL_VKEYCODE = 25;
6530pub const FWL_VKEYCODE_FWL_VKEY_Kanji: FWL_VKEYCODE = 25;
6531pub const FWL_VKEYCODE_FWL_VKEY_Escape: FWL_VKEYCODE = 27;
6532pub const FWL_VKEYCODE_FWL_VKEY_Convert: FWL_VKEYCODE = 28;
6533pub const FWL_VKEYCODE_FWL_VKEY_NonConvert: FWL_VKEYCODE = 29;
6534pub const FWL_VKEYCODE_FWL_VKEY_Accept: FWL_VKEYCODE = 30;
6535pub const FWL_VKEYCODE_FWL_VKEY_ModeChange: FWL_VKEYCODE = 31;
6536pub const FWL_VKEYCODE_FWL_VKEY_Space: FWL_VKEYCODE = 32;
6537pub const FWL_VKEYCODE_FWL_VKEY_Prior: FWL_VKEYCODE = 33;
6538pub const FWL_VKEYCODE_FWL_VKEY_Next: FWL_VKEYCODE = 34;
6539pub const FWL_VKEYCODE_FWL_VKEY_End: FWL_VKEYCODE = 35;
6540pub const FWL_VKEYCODE_FWL_VKEY_Home: FWL_VKEYCODE = 36;
6541pub const FWL_VKEYCODE_FWL_VKEY_Left: FWL_VKEYCODE = 37;
6542pub const FWL_VKEYCODE_FWL_VKEY_Up: FWL_VKEYCODE = 38;
6543pub const FWL_VKEYCODE_FWL_VKEY_Right: FWL_VKEYCODE = 39;
6544pub const FWL_VKEYCODE_FWL_VKEY_Down: FWL_VKEYCODE = 40;
6545pub const FWL_VKEYCODE_FWL_VKEY_Select: FWL_VKEYCODE = 41;
6546pub const FWL_VKEYCODE_FWL_VKEY_Print: FWL_VKEYCODE = 42;
6547pub const FWL_VKEYCODE_FWL_VKEY_Execute: FWL_VKEYCODE = 43;
6548pub const FWL_VKEYCODE_FWL_VKEY_Snapshot: FWL_VKEYCODE = 44;
6549pub const FWL_VKEYCODE_FWL_VKEY_Insert: FWL_VKEYCODE = 45;
6550pub const FWL_VKEYCODE_FWL_VKEY_Delete: FWL_VKEYCODE = 46;
6551pub const FWL_VKEYCODE_FWL_VKEY_Help: FWL_VKEYCODE = 47;
6552pub const FWL_VKEYCODE_FWL_VKEY_0: FWL_VKEYCODE = 48;
6553pub const FWL_VKEYCODE_FWL_VKEY_1: FWL_VKEYCODE = 49;
6554pub const FWL_VKEYCODE_FWL_VKEY_2: FWL_VKEYCODE = 50;
6555pub const FWL_VKEYCODE_FWL_VKEY_3: FWL_VKEYCODE = 51;
6556pub const FWL_VKEYCODE_FWL_VKEY_4: FWL_VKEYCODE = 52;
6557pub const FWL_VKEYCODE_FWL_VKEY_5: FWL_VKEYCODE = 53;
6558pub const FWL_VKEYCODE_FWL_VKEY_6: FWL_VKEYCODE = 54;
6559pub const FWL_VKEYCODE_FWL_VKEY_7: FWL_VKEYCODE = 55;
6560pub const FWL_VKEYCODE_FWL_VKEY_8: FWL_VKEYCODE = 56;
6561pub const FWL_VKEYCODE_FWL_VKEY_9: FWL_VKEYCODE = 57;
6562pub const FWL_VKEYCODE_FWL_VKEY_A: FWL_VKEYCODE = 65;
6563pub const FWL_VKEYCODE_FWL_VKEY_B: FWL_VKEYCODE = 66;
6564pub const FWL_VKEYCODE_FWL_VKEY_C: FWL_VKEYCODE = 67;
6565pub const FWL_VKEYCODE_FWL_VKEY_D: FWL_VKEYCODE = 68;
6566pub const FWL_VKEYCODE_FWL_VKEY_E: FWL_VKEYCODE = 69;
6567pub const FWL_VKEYCODE_FWL_VKEY_F: FWL_VKEYCODE = 70;
6568pub const FWL_VKEYCODE_FWL_VKEY_G: FWL_VKEYCODE = 71;
6569pub const FWL_VKEYCODE_FWL_VKEY_H: FWL_VKEYCODE = 72;
6570pub const FWL_VKEYCODE_FWL_VKEY_I: FWL_VKEYCODE = 73;
6571pub const FWL_VKEYCODE_FWL_VKEY_J: FWL_VKEYCODE = 74;
6572pub const FWL_VKEYCODE_FWL_VKEY_K: FWL_VKEYCODE = 75;
6573pub const FWL_VKEYCODE_FWL_VKEY_L: FWL_VKEYCODE = 76;
6574pub const FWL_VKEYCODE_FWL_VKEY_M: FWL_VKEYCODE = 77;
6575pub const FWL_VKEYCODE_FWL_VKEY_N: FWL_VKEYCODE = 78;
6576pub const FWL_VKEYCODE_FWL_VKEY_O: FWL_VKEYCODE = 79;
6577pub const FWL_VKEYCODE_FWL_VKEY_P: FWL_VKEYCODE = 80;
6578pub const FWL_VKEYCODE_FWL_VKEY_Q: FWL_VKEYCODE = 81;
6579pub const FWL_VKEYCODE_FWL_VKEY_R: FWL_VKEYCODE = 82;
6580pub const FWL_VKEYCODE_FWL_VKEY_S: FWL_VKEYCODE = 83;
6581pub const FWL_VKEYCODE_FWL_VKEY_T: FWL_VKEYCODE = 84;
6582pub const FWL_VKEYCODE_FWL_VKEY_U: FWL_VKEYCODE = 85;
6583pub const FWL_VKEYCODE_FWL_VKEY_V: FWL_VKEYCODE = 86;
6584pub const FWL_VKEYCODE_FWL_VKEY_W: FWL_VKEYCODE = 87;
6585pub const FWL_VKEYCODE_FWL_VKEY_X: FWL_VKEYCODE = 88;
6586pub const FWL_VKEYCODE_FWL_VKEY_Y: FWL_VKEYCODE = 89;
6587pub const FWL_VKEYCODE_FWL_VKEY_Z: FWL_VKEYCODE = 90;
6588pub const FWL_VKEYCODE_FWL_VKEY_LWin: FWL_VKEYCODE = 91;
6589pub const FWL_VKEYCODE_FWL_VKEY_Command: FWL_VKEYCODE = 91;
6590pub const FWL_VKEYCODE_FWL_VKEY_RWin: FWL_VKEYCODE = 92;
6591pub const FWL_VKEYCODE_FWL_VKEY_Apps: FWL_VKEYCODE = 93;
6592pub const FWL_VKEYCODE_FWL_VKEY_Sleep: FWL_VKEYCODE = 95;
6593pub const FWL_VKEYCODE_FWL_VKEY_NumPad0: FWL_VKEYCODE = 96;
6594pub const FWL_VKEYCODE_FWL_VKEY_NumPad1: FWL_VKEYCODE = 97;
6595pub const FWL_VKEYCODE_FWL_VKEY_NumPad2: FWL_VKEYCODE = 98;
6596pub const FWL_VKEYCODE_FWL_VKEY_NumPad3: FWL_VKEYCODE = 99;
6597pub const FWL_VKEYCODE_FWL_VKEY_NumPad4: FWL_VKEYCODE = 100;
6598pub const FWL_VKEYCODE_FWL_VKEY_NumPad5: FWL_VKEYCODE = 101;
6599pub const FWL_VKEYCODE_FWL_VKEY_NumPad6: FWL_VKEYCODE = 102;
6600pub const FWL_VKEYCODE_FWL_VKEY_NumPad7: FWL_VKEYCODE = 103;
6601pub const FWL_VKEYCODE_FWL_VKEY_NumPad8: FWL_VKEYCODE = 104;
6602pub const FWL_VKEYCODE_FWL_VKEY_NumPad9: FWL_VKEYCODE = 105;
6603pub const FWL_VKEYCODE_FWL_VKEY_Multiply: FWL_VKEYCODE = 106;
6604pub const FWL_VKEYCODE_FWL_VKEY_Add: FWL_VKEYCODE = 107;
6605pub const FWL_VKEYCODE_FWL_VKEY_Separator: FWL_VKEYCODE = 108;
6606pub const FWL_VKEYCODE_FWL_VKEY_Subtract: FWL_VKEYCODE = 109;
6607pub const FWL_VKEYCODE_FWL_VKEY_Decimal: FWL_VKEYCODE = 110;
6608pub const FWL_VKEYCODE_FWL_VKEY_Divide: FWL_VKEYCODE = 111;
6609pub const FWL_VKEYCODE_FWL_VKEY_F1: FWL_VKEYCODE = 112;
6610pub const FWL_VKEYCODE_FWL_VKEY_F2: FWL_VKEYCODE = 113;
6611pub const FWL_VKEYCODE_FWL_VKEY_F3: FWL_VKEYCODE = 114;
6612pub const FWL_VKEYCODE_FWL_VKEY_F4: FWL_VKEYCODE = 115;
6613pub const FWL_VKEYCODE_FWL_VKEY_F5: FWL_VKEYCODE = 116;
6614pub const FWL_VKEYCODE_FWL_VKEY_F6: FWL_VKEYCODE = 117;
6615pub const FWL_VKEYCODE_FWL_VKEY_F7: FWL_VKEYCODE = 118;
6616pub const FWL_VKEYCODE_FWL_VKEY_F8: FWL_VKEYCODE = 119;
6617pub const FWL_VKEYCODE_FWL_VKEY_F9: FWL_VKEYCODE = 120;
6618pub const FWL_VKEYCODE_FWL_VKEY_F10: FWL_VKEYCODE = 121;
6619pub const FWL_VKEYCODE_FWL_VKEY_F11: FWL_VKEYCODE = 122;
6620pub const FWL_VKEYCODE_FWL_VKEY_F12: FWL_VKEYCODE = 123;
6621pub const FWL_VKEYCODE_FWL_VKEY_F13: FWL_VKEYCODE = 124;
6622pub const FWL_VKEYCODE_FWL_VKEY_F14: FWL_VKEYCODE = 125;
6623pub const FWL_VKEYCODE_FWL_VKEY_F15: FWL_VKEYCODE = 126;
6624pub const FWL_VKEYCODE_FWL_VKEY_F16: FWL_VKEYCODE = 127;
6625pub const FWL_VKEYCODE_FWL_VKEY_F17: FWL_VKEYCODE = 128;
6626pub const FWL_VKEYCODE_FWL_VKEY_F18: FWL_VKEYCODE = 129;
6627pub const FWL_VKEYCODE_FWL_VKEY_F19: FWL_VKEYCODE = 130;
6628pub const FWL_VKEYCODE_FWL_VKEY_F20: FWL_VKEYCODE = 131;
6629pub const FWL_VKEYCODE_FWL_VKEY_F21: FWL_VKEYCODE = 132;
6630pub const FWL_VKEYCODE_FWL_VKEY_F22: FWL_VKEYCODE = 133;
6631pub const FWL_VKEYCODE_FWL_VKEY_F23: FWL_VKEYCODE = 134;
6632pub const FWL_VKEYCODE_FWL_VKEY_F24: FWL_VKEYCODE = 135;
6633pub const FWL_VKEYCODE_FWL_VKEY_NunLock: FWL_VKEYCODE = 144;
6634pub const FWL_VKEYCODE_FWL_VKEY_Scroll: FWL_VKEYCODE = 145;
6635pub const FWL_VKEYCODE_FWL_VKEY_LShift: FWL_VKEYCODE = 160;
6636pub const FWL_VKEYCODE_FWL_VKEY_RShift: FWL_VKEYCODE = 161;
6637pub const FWL_VKEYCODE_FWL_VKEY_LControl: FWL_VKEYCODE = 162;
6638pub const FWL_VKEYCODE_FWL_VKEY_RControl: FWL_VKEYCODE = 163;
6639pub const FWL_VKEYCODE_FWL_VKEY_LMenu: FWL_VKEYCODE = 164;
6640pub const FWL_VKEYCODE_FWL_VKEY_RMenu: FWL_VKEYCODE = 165;
6641pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Back: FWL_VKEYCODE = 166;
6642pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Forward: FWL_VKEYCODE = 167;
6643pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Refresh: FWL_VKEYCODE = 168;
6644pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Stop: FWL_VKEYCODE = 169;
6645pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Search: FWL_VKEYCODE = 170;
6646pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Favorites: FWL_VKEYCODE = 171;
6647pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Home: FWL_VKEYCODE = 172;
6648pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Mute: FWL_VKEYCODE = 173;
6649pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Down: FWL_VKEYCODE = 174;
6650pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Up: FWL_VKEYCODE = 175;
6651pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_NEXT_Track: FWL_VKEYCODE = 176;
6652pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_PREV_Track: FWL_VKEYCODE = 177;
6653pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_Stop: FWL_VKEYCODE = 178;
6654pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_PLAY_Pause: FWL_VKEYCODE = 179;
6655pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_Mail: FWL_VKEYCODE = 180;
6656pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_MEDIA_Select: FWL_VKEYCODE = 181;
6657pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_APP1: FWL_VKEYCODE = 182;
6658pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_APP2: FWL_VKEYCODE = 183;
6659pub const FWL_VKEYCODE_FWL_VKEY_OEM_1: FWL_VKEYCODE = 186;
6660pub const FWL_VKEYCODE_FWL_VKEY_OEM_Plus: FWL_VKEYCODE = 187;
6661pub const FWL_VKEYCODE_FWL_VKEY_OEM_Comma: FWL_VKEYCODE = 188;
6662pub const FWL_VKEYCODE_FWL_VKEY_OEM_Minus: FWL_VKEYCODE = 189;
6663pub const FWL_VKEYCODE_FWL_VKEY_OEM_Period: FWL_VKEYCODE = 190;
6664pub const FWL_VKEYCODE_FWL_VKEY_OEM_2: FWL_VKEYCODE = 191;
6665pub const FWL_VKEYCODE_FWL_VKEY_OEM_3: FWL_VKEYCODE = 192;
6666pub const FWL_VKEYCODE_FWL_VKEY_OEM_4: FWL_VKEYCODE = 219;
6667pub const FWL_VKEYCODE_FWL_VKEY_OEM_5: FWL_VKEYCODE = 220;
6668pub const FWL_VKEYCODE_FWL_VKEY_OEM_6: FWL_VKEYCODE = 221;
6669pub const FWL_VKEYCODE_FWL_VKEY_OEM_7: FWL_VKEYCODE = 222;
6670pub const FWL_VKEYCODE_FWL_VKEY_OEM_8: FWL_VKEYCODE = 223;
6671pub const FWL_VKEYCODE_FWL_VKEY_OEM_102: FWL_VKEYCODE = 226;
6672pub const FWL_VKEYCODE_FWL_VKEY_ProcessKey: FWL_VKEYCODE = 229;
6673pub const FWL_VKEYCODE_FWL_VKEY_Packet: FWL_VKEYCODE = 231;
6674pub const FWL_VKEYCODE_FWL_VKEY_Attn: FWL_VKEYCODE = 246;
6675pub const FWL_VKEYCODE_FWL_VKEY_Crsel: FWL_VKEYCODE = 247;
6676pub const FWL_VKEYCODE_FWL_VKEY_Exsel: FWL_VKEYCODE = 248;
6677pub const FWL_VKEYCODE_FWL_VKEY_Ereof: FWL_VKEYCODE = 249;
6678pub const FWL_VKEYCODE_FWL_VKEY_Play: FWL_VKEYCODE = 250;
6679pub const FWL_VKEYCODE_FWL_VKEY_Zoom: FWL_VKEYCODE = 251;
6680pub const FWL_VKEYCODE_FWL_VKEY_NoName: FWL_VKEYCODE = 252;
6681pub const FWL_VKEYCODE_FWL_VKEY_PA1: FWL_VKEYCODE = 253;
6682pub const FWL_VKEYCODE_FWL_VKEY_OEM_Clear: FWL_VKEYCODE = 254;
6683pub const FWL_VKEYCODE_FWL_VKEY_Unknown: FWL_VKEYCODE = 0;
6684#[doc = " Virtual keycodes."]
6685pub type FWL_VKEYCODE = ::std::os::raw::c_uint;
6686extern "C" {
6687 #[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."]
6688 pub fn FPDFPage_GetDecodedThumbnailData(
6689 page: FPDF_PAGE,
6690 buffer: *mut ::std::os::raw::c_void,
6691 buflen: ::std::os::raw::c_ulong,
6692 ) -> ::std::os::raw::c_ulong;
6693}
6694extern "C" {
6695 #[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."]
6696 pub fn FPDFPage_GetRawThumbnailData(
6697 page: FPDF_PAGE,
6698 buffer: *mut ::std::os::raw::c_void,
6699 buflen: ::std::os::raw::c_ulong,
6700 ) -> ::std::os::raw::c_ulong;
6701}
6702extern "C" {
6703 #[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."]
6704 pub fn FPDFPage_GetThumbnailAsBitmap(page: FPDF_PAGE) -> FPDF_BITMAP;
6705}
6706extern "C" {
6707 #[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."]
6708 pub fn FPDFPage_Flatten(page: FPDF_PAGE, nFlag: ::std::os::raw::c_int)
6709 -> ::std::os::raw::c_int;
6710}
6711#[doc = " IFPDF_RENDERINFO interface."]
6712#[repr(C)]
6713#[derive(Debug, Copy, Clone)]
6714pub struct _IFSDK_PAUSE {
6715 #[doc = " Version number of the interface. Currently must be 1."]
6716 pub version: ::std::os::raw::c_int,
6717 #[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."]
6718 pub NeedToPauseNow:
6719 ::std::option::Option<unsafe extern "C" fn(pThis: *mut _IFSDK_PAUSE) -> FPDF_BOOL>,
6720 #[doc = " A user defined data pointer, used by user's application. Can be NULL."]
6721 pub user: *mut ::std::os::raw::c_void,
6722}
6723#[test]
6724fn bindgen_test_layout__IFSDK_PAUSE() {
6725 const UNINIT: ::std::mem::MaybeUninit<_IFSDK_PAUSE> = ::std::mem::MaybeUninit::uninit();
6726 let ptr = UNINIT.as_ptr();
6727 assert_eq!(
6728 ::std::mem::size_of::<_IFSDK_PAUSE>(),
6729 24usize,
6730 concat!("Size of: ", stringify!(_IFSDK_PAUSE))
6731 );
6732 assert_eq!(
6733 ::std::mem::align_of::<_IFSDK_PAUSE>(),
6734 8usize,
6735 concat!("Alignment of ", stringify!(_IFSDK_PAUSE))
6736 );
6737 assert_eq!(
6738 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
6739 0usize,
6740 concat!(
6741 "Offset of field: ",
6742 stringify!(_IFSDK_PAUSE),
6743 "::",
6744 stringify!(version)
6745 )
6746 );
6747 assert_eq!(
6748 unsafe { ::std::ptr::addr_of!((*ptr).NeedToPauseNow) as usize - ptr as usize },
6749 8usize,
6750 concat!(
6751 "Offset of field: ",
6752 stringify!(_IFSDK_PAUSE),
6753 "::",
6754 stringify!(NeedToPauseNow)
6755 )
6756 );
6757 assert_eq!(
6758 unsafe { ::std::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
6759 16usize,
6760 concat!(
6761 "Offset of field: ",
6762 stringify!(_IFSDK_PAUSE),
6763 "::",
6764 stringify!(user)
6765 )
6766 );
6767}
6768#[doc = " IFPDF_RENDERINFO interface."]
6769pub type IFSDK_PAUSE = _IFSDK_PAUSE;
6770extern "C" {
6771 #[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."]
6772 pub fn FPDF_RenderPageBitmapWithColorScheme_Start(
6773 bitmap: FPDF_BITMAP,
6774 page: FPDF_PAGE,
6775 start_x: ::std::os::raw::c_int,
6776 start_y: ::std::os::raw::c_int,
6777 size_x: ::std::os::raw::c_int,
6778 size_y: ::std::os::raw::c_int,
6779 rotate: ::std::os::raw::c_int,
6780 flags: ::std::os::raw::c_int,
6781 color_scheme: *const FPDF_COLORSCHEME,
6782 pause: *mut IFSDK_PAUSE,
6783 ) -> ::std::os::raw::c_int;
6784}
6785extern "C" {
6786 #[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."]
6787 pub fn FPDF_RenderPageBitmap_Start(
6788 bitmap: FPDF_BITMAP,
6789 page: FPDF_PAGE,
6790 start_x: ::std::os::raw::c_int,
6791 start_y: ::std::os::raw::c_int,
6792 size_x: ::std::os::raw::c_int,
6793 size_y: ::std::os::raw::c_int,
6794 rotate: ::std::os::raw::c_int,
6795 flags: ::std::os::raw::c_int,
6796 pause: *mut IFSDK_PAUSE,
6797 ) -> ::std::os::raw::c_int;
6798}
6799extern "C" {
6800 #[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."]
6801 pub fn FPDF_RenderPage_Continue(
6802 page: FPDF_PAGE,
6803 pause: *mut IFSDK_PAUSE,
6804 ) -> ::std::os::raw::c_int;
6805}
6806extern "C" {
6807 #[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."]
6808 pub fn FPDF_RenderPage_Close(page: FPDF_PAGE);
6809}
6810#[doc = " 13 = __LC_LAST."]
6811#[repr(C)]
6812#[derive(Debug, Copy, Clone)]
6813pub struct __locale_data {
6814 pub _address: u8,
6815}