1pub const _TIME_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 = 202405;
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 __USE_XOPEN2K24: u32 = 1;
22pub const __WORDSIZE: u32 = 64;
23pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
24#[doc = " Both x86-64 and x32 use the 64-bit system call interface."]
25pub const __SYSCALL_WORDSIZE: u32 = 64;
26#[doc = " For others, time size is word size."]
27pub const __TIMESIZE: u32 = 64;
28pub const __USE_TIME_BITS64: u32 = 1;
29pub const __USE_MISC: u32 = 1;
30pub const __USE_ATFILE: u32 = 1;
31pub const __USE_FORTIFY_LEVEL: u32 = 0;
32pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
33pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
34pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
35pub const _STDC_PREDEF_H: u32 = 1;
36pub const __STDC_IEC_559__: u32 = 1;
37pub const __STDC_IEC_60559_BFP__: u32 = 201404;
38pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
39pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
40#[doc = " wchar_t uses Unicode 10.0.0. Version 10.0 of the Unicode Standard is\nsynchronized with ISO/IEC 10646:2017, fifth edition, plus\nthe following additions from Amendment 1 to the fifth edition:\n- 56 emoji characters\n- 285 hentaigana\n- 3 additional Zanabazar Square characters"]
41pub const __STDC_ISO_10646__: u32 = 201706;
42pub const __GNU_LIBRARY__: u32 = 6;
43#[doc = " Major and minor version number of the GNU C library package. Use\nthese macros to test for features in specific releases."]
44pub const __GLIBC__: u32 = 2;
45pub const __GLIBC_MINOR__: u32 = 44;
46pub const _SYS_CDEFS_H: u32 = 1;
47pub const __glibc_c99_flexarr_available: u32 = 1;
48#[doc = " long double is distinct from double, so there is nothing to\ndefine here."]
49pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
50pub const __HAVE_GENERIC_SELECTION: u32 = 1;
51pub const _BITS_TIME_H: u32 = 1;
52pub const _BITS_TYPES_H: u32 = 1;
53pub const _BITS_TYPESIZES_H: u32 = 1;
54#[doc = " Tell the libc code that off_t and off64_t are actually the same type\nfor all ABI purposes, even if possibly expressed as different base types\nfor C type-checking purposes."]
55pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
56#[doc = " Same for ino_t and ino64_t."]
57pub const __INO_T_MATCHES_INO64_T: u32 = 1;
58#[doc = " And for __rlim_t and __rlim64_t."]
59pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
60#[doc = " And for fsblkcnt_t, fsblkcnt64_t, fsfilcnt_t and fsfilcnt64_t."]
61pub const __STATFS_MATCHES_STATFS64: u32 = 1;
62#[doc = " And for getitimer, setitimer and rusage"]
63pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
64#[doc = " Number of descriptors that can fit in an `fd_set'."]
65pub const __FD_SETSIZE: u32 = 1024;
66pub const _BITS_TIME64_H: u32 = 1;
67#[doc = " Identifier for system-wide realtime clock."]
68pub const CLOCK_REALTIME: u32 = 0;
69#[doc = " Monotonic system-wide clock."]
70pub const CLOCK_MONOTONIC: u32 = 1;
71#[doc = " High-resolution timer from the CPU."]
72pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2;
73#[doc = " Thread-specific CPU-time clock."]
74pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3;
75#[doc = " Monotonic system-wide clock, not adjusted for frequency scaling."]
76pub const CLOCK_MONOTONIC_RAW: u32 = 4;
77#[doc = " Identifier for system-wide realtime clock, updated only on ticks."]
78pub const CLOCK_REALTIME_COARSE: u32 = 5;
79#[doc = " Monotonic system-wide clock, updated only on ticks."]
80pub const CLOCK_MONOTONIC_COARSE: u32 = 6;
81#[doc = " Monotonic system-wide clock that includes time spent in suspension."]
82pub const CLOCK_BOOTTIME: u32 = 7;
83#[doc = " Like CLOCK_REALTIME but also wakes suspended system."]
84pub const CLOCK_REALTIME_ALARM: u32 = 8;
85#[doc = " Like CLOCK_BOOTTIME but also wakes suspended system."]
86pub const CLOCK_BOOTTIME_ALARM: u32 = 9;
87#[doc = " Like CLOCK_REALTIME but in International Atomic Time."]
88pub const CLOCK_TAI: u32 = 11;
89#[doc = " Flag to indicate time is absolute."]
90pub const TIMER_ABSTIME: u32 = 1;
91pub const __clock_t_defined: u32 = 1;
92pub const __time_t_defined: u32 = 1;
93pub const __struct_tm_defined: u32 = 1;
94pub const _STRUCT_TIMESPEC: u32 = 1;
95pub const _BITS_ENDIAN_H: u32 = 1;
96#[doc = " Definitions for byte order, according to significance of bytes,\nfrom low addresses to high addresses. The value is what you get by\nputting '4' in the most significant byte, '3' in the second most\nsignificant byte, '2' in the second least significant byte, and '1'\nin the least significant byte, and then writing down one digit for\neach byte, starting with the byte at the lowest address at the left,\nand proceeding to the byte with the highest address at the right."]
97pub const __LITTLE_ENDIAN: u32 = 1234;
98pub const __BIG_ENDIAN: u32 = 4321;
99pub const __PDP_ENDIAN: u32 = 3412;
100pub const _BITS_ENDIANNESS_H: u32 = 1;
101#[doc = " i386/x86_64 are little-endian."]
102pub const __BYTE_ORDER: u32 = 1234;
103pub const __FLOAT_WORD_ORDER: u32 = 1234;
104pub const __clockid_t_defined: u32 = 1;
105pub const __timer_t_defined: u32 = 1;
106pub const __itimerspec_defined: u32 = 1;
107pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
108pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
109#[doc = " Time base values for timespec_get."]
110pub const TIME_UTC: u32 = 1;
111#[doc = " PDF object types"]
112pub const FPDF_OBJECT_UNKNOWN: u32 = 0;
113pub const FPDF_OBJECT_BOOLEAN: u32 = 1;
114pub const FPDF_OBJECT_NUMBER: u32 = 2;
115pub const FPDF_OBJECT_STRING: u32 = 3;
116pub const FPDF_OBJECT_NAME: u32 = 4;
117pub const FPDF_OBJECT_ARRAY: u32 = 5;
118pub const FPDF_OBJECT_DICTIONARY: u32 = 6;
119pub const FPDF_OBJECT_STREAM: u32 = 7;
120pub const FPDF_OBJECT_NULLOBJ: u32 = 8;
121pub const FPDF_OBJECT_REFERENCE: u32 = 9;
122#[doc = " Policy for accessing the local machine time."]
123pub const FPDF_POLICY_MACHINETIME_ACCESS: u32 = 0;
124#[doc = " No error."]
125pub const FPDF_ERR_SUCCESS: u32 = 0;
126#[doc = " Unknown error."]
127pub const FPDF_ERR_UNKNOWN: u32 = 1;
128#[doc = " File not found or could not be opened."]
129pub const FPDF_ERR_FILE: u32 = 2;
130#[doc = " File not in PDF format or corrupted."]
131pub const FPDF_ERR_FORMAT: u32 = 3;
132#[doc = " Password required or incorrect password."]
133pub const FPDF_ERR_PASSWORD: u32 = 4;
134#[doc = " Unsupported security scheme."]
135pub const FPDF_ERR_SECURITY: u32 = 5;
136#[doc = " Page not found or content error."]
137pub const FPDF_ERR_PAGE: u32 = 6;
138#[doc = " Load XFA error."]
139pub const FPDF_ERR_XFALOAD: u32 = 7;
140#[doc = " Layout XFA error."]
141pub const FPDF_ERR_XFALAYOUT: u32 = 8;
142#[doc = " Page rendering flags. They can be combined with bit-wise OR.\n\n Set if annotations are to be rendered."]
143pub const FPDF_ANNOT: u32 = 1;
144#[doc = " Set if using text rendering optimized for LCD display. This flag will only\n take effect if anti-aliasing is enabled for text."]
145pub const FPDF_LCD_TEXT: u32 = 2;
146#[doc = " Don't use the native text output available on some platforms"]
147pub const FPDF_NO_NATIVETEXT: u32 = 4;
148#[doc = " Grayscale output."]
149pub const FPDF_GRAYSCALE: u32 = 8;
150#[doc = " Obsolete, has no effect, retained for compatibility."]
151pub const FPDF_DEBUG_INFO: u32 = 128;
152#[doc = " Obsolete, has no effect, retained for compatibility."]
153pub const FPDF_NO_CATCH: u32 = 256;
154#[doc = " Limit image cache size."]
155pub const FPDF_RENDER_LIMITEDIMAGECACHE: u32 = 512;
156#[doc = " Always use halftone for image stretching."]
157pub const FPDF_RENDER_FORCEHALFTONE: u32 = 1024;
158#[doc = " Render for printing."]
159pub const FPDF_PRINTING: u32 = 2048;
160#[doc = " Set to disable anti-aliasing on text. This flag will also disable LCD\n optimization for text rendering."]
161pub const FPDF_RENDER_NO_SMOOTHTEXT: u32 = 4096;
162#[doc = " Set to disable anti-aliasing on images."]
163pub const FPDF_RENDER_NO_SMOOTHIMAGE: u32 = 8192;
164#[doc = " Set to disable anti-aliasing on paths."]
165pub const FPDF_RENDER_NO_SMOOTHPATH: u32 = 16384;
166#[doc = " Set whether to render in a reverse Byte order, this flag is only used when\n rendering to a bitmap."]
167pub const FPDF_REVERSE_BYTE_ORDER: u32 = 16;
168#[doc = " Set whether fill paths need to be stroked. This flag is only used when\n FPDF_COLORSCHEME is passed in, since with a single fill color for paths the\n boundaries of adjacent fill paths are less visible."]
169pub const FPDF_CONVERT_FILL_TO_STROKE: u32 = 32;
170#[doc = " More DIB formats\n Unknown or unsupported format.\n All of the colors are listed in order of LSB to MSB."]
171pub const FPDFBitmap_Unknown: u32 = 0;
172#[doc = " Gray scale bitmap, one byte per pixel."]
173pub const FPDFBitmap_Gray: u32 = 1;
174#[doc = " 3 bytes per pixel, byte order: blue, green, red."]
175pub const FPDFBitmap_BGR: u32 = 2;
176#[doc = " 4 bytes per pixel, byte order: blue, green, red, unused."]
177pub const FPDFBitmap_BGRx: u32 = 3;
178#[doc = " 4 bytes per pixel, byte order: blue, green, red, alpha.\n Pixel components are independent of alpha."]
179pub const FPDFBitmap_BGRA: u32 = 4;
180#[doc = " 4 bytes per pixel, byte order: blue, green, red, alpha.\n Pixel components are premultiplied by alpha.\n Note that this is experimental and only supported when rendering with\n |FPDF_RENDERER_TYPE| is set to |FPDF_RENDERERTYPE_SKIA|."]
181pub const FPDFBitmap_BGRA_Premul: u32 = 5;
182#[doc = " Unsupported XFA form."]
183pub const FPDF_UNSP_DOC_XFAFORM: u32 = 1;
184#[doc = " Unsupported portable collection."]
185pub const FPDF_UNSP_DOC_PORTABLECOLLECTION: u32 = 2;
186#[doc = " Unsupported attachment."]
187pub const FPDF_UNSP_DOC_ATTACHMENT: u32 = 3;
188#[doc = " Unsupported security."]
189pub const FPDF_UNSP_DOC_SECURITY: u32 = 4;
190#[doc = " Unsupported shared review."]
191pub const FPDF_UNSP_DOC_SHAREDREVIEW: u32 = 5;
192#[doc = " Unsupported shared form, acrobat."]
193pub const FPDF_UNSP_DOC_SHAREDFORM_ACROBAT: u32 = 6;
194#[doc = " Unsupported shared form, filesystem."]
195pub const FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM: u32 = 7;
196#[doc = " Unsupported shared form, email."]
197pub const FPDF_UNSP_DOC_SHAREDFORM_EMAIL: u32 = 8;
198#[doc = " Unsupported 3D annotation."]
199pub const FPDF_UNSP_ANNOT_3DANNOT: u32 = 11;
200#[doc = " Unsupported movie annotation."]
201pub const FPDF_UNSP_ANNOT_MOVIE: u32 = 12;
202#[doc = " Unsupported sound annotation."]
203pub const FPDF_UNSP_ANNOT_SOUND: u32 = 13;
204#[doc = " Unsupported screen media annotation."]
205pub const FPDF_UNSP_ANNOT_SCREEN_MEDIA: u32 = 14;
206#[doc = " Unsupported screen rich media annotation."]
207pub const FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA: u32 = 15;
208#[doc = " Unsupported attachment annotation."]
209pub const FPDF_UNSP_ANNOT_ATTACHMENT: u32 = 16;
210#[doc = " Unsupported signature annotation."]
211pub const FPDF_UNSP_ANNOT_SIG: u32 = 17;
212#[doc = " Unknown page mode."]
213pub const PAGEMODE_UNKNOWN: i32 = -1;
214#[doc = " Document outline, and thumbnails hidden."]
215pub const PAGEMODE_USENONE: u32 = 0;
216#[doc = " Document outline visible."]
217pub const PAGEMODE_USEOUTLINES: u32 = 1;
218#[doc = " Thumbnail images visible."]
219pub const PAGEMODE_USETHUMBS: u32 = 2;
220#[doc = " Full-screen mode, no menu bar, window controls, or other decorations visible."]
221pub const PAGEMODE_FULLSCREEN: u32 = 3;
222#[doc = " Optional content group panel visible."]
223pub const PAGEMODE_USEOC: u32 = 4;
224#[doc = " Attachments panel visible."]
225pub const PAGEMODE_USEATTACHMENTS: u32 = 5;
226#[doc = " Unsupported action type."]
227pub const PDFACTION_UNSUPPORTED: u32 = 0;
228#[doc = " Go to a destination within current document."]
229pub const PDFACTION_GOTO: u32 = 1;
230#[doc = " Go to a destination within another document."]
231pub const PDFACTION_REMOTEGOTO: u32 = 2;
232#[doc = " URI, including web pages and other Internet resources."]
233pub const PDFACTION_URI: u32 = 3;
234#[doc = " Launch an application or open a file."]
235pub const PDFACTION_LAUNCH: u32 = 4;
236#[doc = " Go to a destination in an embedded file."]
237pub const PDFACTION_EMBEDDEDGOTO: u32 = 5;
238#[doc = " View destination fit types. See pdfmark reference v9, page 48."]
239pub const PDFDEST_VIEW_UNKNOWN_MODE: u32 = 0;
240pub const PDFDEST_VIEW_XYZ: u32 = 1;
241pub const PDFDEST_VIEW_FIT: u32 = 2;
242pub const PDFDEST_VIEW_FITH: u32 = 3;
243pub const PDFDEST_VIEW_FITV: u32 = 4;
244pub const PDFDEST_VIEW_FITR: u32 = 5;
245pub const PDFDEST_VIEW_FITB: u32 = 6;
246pub const PDFDEST_VIEW_FITBH: u32 = 7;
247pub const PDFDEST_VIEW_FITBV: u32 = 8;
248#[doc = " Character sets for the font"]
249pub const FXFONT_ANSI_CHARSET: u32 = 0;
250pub const FXFONT_DEFAULT_CHARSET: u32 = 1;
251pub const FXFONT_SYMBOL_CHARSET: u32 = 2;
252pub const FXFONT_SHIFTJIS_CHARSET: u32 = 128;
253pub const FXFONT_HANGEUL_CHARSET: u32 = 129;
254pub const FXFONT_GB2312_CHARSET: u32 = 134;
255pub const FXFONT_CHINESEBIG5_CHARSET: u32 = 136;
256pub const FXFONT_GREEK_CHARSET: u32 = 161;
257pub const FXFONT_VIETNAMESE_CHARSET: u32 = 163;
258pub const FXFONT_HEBREW_CHARSET: u32 = 177;
259pub const FXFONT_ARABIC_CHARSET: u32 = 178;
260pub const FXFONT_CYRILLIC_CHARSET: u32 = 204;
261pub const FXFONT_THAI_CHARSET: u32 = 222;
262pub const FXFONT_EASTERNEUROPEAN_CHARSET: u32 = 238;
263#[doc = " Font pitch and family flags"]
264pub const FXFONT_FF_FIXEDPITCH: u32 = 1;
265pub const FXFONT_FF_ROMAN: u32 = 16;
266pub const FXFONT_FF_SCRIPT: u32 = 64;
267#[doc = " Typical weight values"]
268pub const FXFONT_FW_NORMAL: u32 = 400;
269pub const FXFONT_FW_BOLD: u32 = 700;
270#[doc = " Document contains no forms"]
271pub const FORMTYPE_NONE: u32 = 0;
272#[doc = " Forms are specified using AcroForm spec"]
273pub const FORMTYPE_ACRO_FORM: u32 = 1;
274#[doc = " Forms are specified using entire XFA spec"]
275pub const FORMTYPE_XFA_FULL: u32 = 2;
276#[doc = " Forms are specified using the XFAF subset\n of XFA spec"]
277pub const FORMTYPE_XFA_FOREGROUND: u32 = 3;
278#[doc = " The number of form types"]
279pub const FORMTYPE_COUNT: u32 = 4;
280#[doc = " OK button"]
281pub const JSPLATFORM_ALERT_BUTTON_OK: u32 = 0;
282#[doc = " OK & Cancel buttons"]
283pub const JSPLATFORM_ALERT_BUTTON_OKCANCEL: u32 = 1;
284#[doc = " Yes & No buttons"]
285pub const JSPLATFORM_ALERT_BUTTON_YESNO: u32 = 2;
286#[doc = " Yes, No & Cancel buttons"]
287pub const JSPLATFORM_ALERT_BUTTON_YESNOCANCEL: u32 = 3;
288pub const JSPLATFORM_ALERT_BUTTON_DEFAULT: u32 = 0;
289#[doc = " Error"]
290pub const JSPLATFORM_ALERT_ICON_ERROR: u32 = 0;
291#[doc = " Warning"]
292pub const JSPLATFORM_ALERT_ICON_WARNING: u32 = 1;
293#[doc = " Question"]
294pub const JSPLATFORM_ALERT_ICON_QUESTION: u32 = 2;
295#[doc = " Status"]
296pub const JSPLATFORM_ALERT_ICON_STATUS: u32 = 3;
297#[doc = " Asterisk"]
298pub const JSPLATFORM_ALERT_ICON_ASTERISK: u32 = 4;
299pub const JSPLATFORM_ALERT_ICON_DEFAULT: u32 = 0;
300#[doc = " OK"]
301pub const JSPLATFORM_ALERT_RETURN_OK: u32 = 1;
302#[doc = " Cancel"]
303pub const JSPLATFORM_ALERT_RETURN_CANCEL: u32 = 2;
304#[doc = " No"]
305pub const JSPLATFORM_ALERT_RETURN_NO: u32 = 3;
306#[doc = " Yes"]
307pub const JSPLATFORM_ALERT_RETURN_YES: u32 = 4;
308#[doc = " Error"]
309pub const JSPLATFORM_BEEP_ERROR: u32 = 0;
310#[doc = " Warning"]
311pub const JSPLATFORM_BEEP_WARNING: u32 = 1;
312#[doc = " Question"]
313pub const JSPLATFORM_BEEP_QUESTION: u32 = 2;
314#[doc = " Status"]
315pub const JSPLATFORM_BEEP_STATUS: u32 = 3;
316#[doc = " Default"]
317pub const JSPLATFORM_BEEP_DEFAULT: u32 = 4;
318#[doc = " Flags for Cursor type"]
319pub const FXCT_ARROW: u32 = 0;
320pub const FXCT_NESW: u32 = 1;
321pub const FXCT_NWSE: u32 = 2;
322pub const FXCT_VBEAM: u32 = 3;
323pub const FXCT_HBEAM: u32 = 4;
324pub const FXCT_HAND: u32 = 5;
325#[doc = " After a new pageview is added."]
326pub const FXFA_PAGEVIEWEVENT_POSTADDED: u32 = 1;
327#[doc = " After a pageview is removed."]
328pub const FXFA_PAGEVIEWEVENT_POSTREMOVED: u32 = 3;
329#[doc = " Definitions for Right Context Menu Features Of XFA Fields"]
330pub const FXFA_MENU_COPY: u32 = 1;
331pub const FXFA_MENU_CUT: u32 = 2;
332pub const FXFA_MENU_SELECTALL: u32 = 4;
333pub const FXFA_MENU_UNDO: u32 = 8;
334pub const FXFA_MENU_REDO: u32 = 16;
335pub const FXFA_MENU_PASTE: u32 = 32;
336#[doc = " Definitions for File Type."]
337pub const FXFA_SAVEAS_XML: u32 = 1;
338pub const FXFA_SAVEAS_XDP: u32 = 2;
339#[doc = " Additional actions type of document:\n WC, before closing document, JavaScript action.\n WS, before saving document, JavaScript action.\n DS, after saving document, JavaScript action.\n WP, before printing document, JavaScript action.\n DP, after printing document, JavaScript action."]
340pub const FPDFDOC_AACTION_WC: u32 = 16;
341pub const FPDFDOC_AACTION_WS: u32 = 17;
342pub const FPDFDOC_AACTION_DS: u32 = 18;
343pub const FPDFDOC_AACTION_WP: u32 = 19;
344pub const FPDFDOC_AACTION_DP: u32 = 20;
345#[doc = " Additional-action types of page object:\n OPEN (/O) -- An action to be performed when the page is opened\n CLOSE (/C) -- An action to be performed when the page is closed"]
346pub const FPDFPAGE_AACTION_OPEN: u32 = 0;
347pub const FPDFPAGE_AACTION_CLOSE: u32 = 1;
348#[doc = " Unknown."]
349pub const FPDF_FORMFIELD_UNKNOWN: u32 = 0;
350#[doc = " push button type."]
351pub const FPDF_FORMFIELD_PUSHBUTTON: u32 = 1;
352#[doc = " check box type."]
353pub const FPDF_FORMFIELD_CHECKBOX: u32 = 2;
354#[doc = " radio button type."]
355pub const FPDF_FORMFIELD_RADIOBUTTON: u32 = 3;
356#[doc = " combo box type."]
357pub const FPDF_FORMFIELD_COMBOBOX: u32 = 4;
358#[doc = " list box type."]
359pub const FPDF_FORMFIELD_LISTBOX: u32 = 5;
360#[doc = " text field type."]
361pub const FPDF_FORMFIELD_TEXTFIELD: u32 = 6;
362#[doc = " text field type."]
363pub const FPDF_FORMFIELD_SIGNATURE: u32 = 7;
364#[doc = " Generic XFA type."]
365pub const FPDF_FORMFIELD_XFA: u32 = 8;
366#[doc = " XFA check box type."]
367pub const FPDF_FORMFIELD_XFA_CHECKBOX: u32 = 9;
368#[doc = " XFA combo box type."]
369pub const FPDF_FORMFIELD_XFA_COMBOBOX: u32 = 10;
370#[doc = " XFA image field type."]
371pub const FPDF_FORMFIELD_XFA_IMAGEFIELD: u32 = 11;
372#[doc = " XFA list box type."]
373pub const FPDF_FORMFIELD_XFA_LISTBOX: u32 = 12;
374#[doc = " XFA push button type."]
375pub const FPDF_FORMFIELD_XFA_PUSHBUTTON: u32 = 13;
376#[doc = " XFA signture field type."]
377pub const FPDF_FORMFIELD_XFA_SIGNATURE: u32 = 14;
378#[doc = " XFA text field type."]
379pub const FPDF_FORMFIELD_XFA_TEXTFIELD: u32 = 15;
380pub const FPDF_FORMFIELD_COUNT: u32 = 16;
381#[doc = " Flags for FPDF_SaveAsCopy().\n FPDF_INCREMENTAL and FPDF_NO_INCREMENTAL cannot be used together."]
382pub const FPDF_INCREMENTAL: u32 = 1;
383pub const FPDF_NO_INCREMENTAL: u32 = 2;
384#[doc = " Deprecated. Use FPDF_REMOVE_SECURITY instead.\n TODO(crbug.com/42270430): Remove FPDF_REMOVE_SECURITY_DEPRECATED."]
385pub const FPDF_REMOVE_SECURITY_DEPRECATED: u32 = 3;
386pub const FPDF_REMOVE_SECURITY: u32 = 4;
387#[doc = " Experimental. Subsets any embedded font files for new text objects added to\n the document."]
388pub const FPDF_SUBSET_NEW_FONTS: u32 = 8;
389pub const _STDINT_H: u32 = 1;
390pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
391pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
392pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
393pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
394pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
395pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
396pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
397pub const _BITS_WCHAR_H: u32 = 1;
398pub const _BITS_STDINT_INTN_H: u32 = 1;
399pub const _BITS_STDINT_UINTN_H: u32 = 1;
400pub const _BITS_STDINT_LEAST_H: u32 = 1;
401#[doc = " Minimum of signed integral types."]
402pub const INT8_MIN: i32 = -128;
403pub const INT16_MIN: i32 = -32768;
404pub const INT32_MIN: i32 = -2147483648;
405#[doc = " Maximum of signed integral types."]
406pub const INT8_MAX: u32 = 127;
407pub const INT16_MAX: u32 = 32767;
408pub const INT32_MAX: u32 = 2147483647;
409#[doc = " Maximum of unsigned integral types."]
410pub const UINT8_MAX: u32 = 255;
411pub const UINT16_MAX: u32 = 65535;
412pub const UINT32_MAX: u32 = 4294967295;
413#[doc = " Minimum of signed integral types having a minimum size."]
414pub const INT_LEAST8_MIN: i32 = -128;
415pub const INT_LEAST16_MIN: i32 = -32768;
416pub const INT_LEAST32_MIN: i32 = -2147483648;
417#[doc = " Maximum of signed integral types having a minimum size."]
418pub const INT_LEAST8_MAX: u32 = 127;
419pub const INT_LEAST16_MAX: u32 = 32767;
420pub const INT_LEAST32_MAX: u32 = 2147483647;
421#[doc = " Maximum of unsigned integral types having a minimum size."]
422pub const UINT_LEAST8_MAX: u32 = 255;
423pub const UINT_LEAST16_MAX: u32 = 65535;
424pub const UINT_LEAST32_MAX: u32 = 4294967295;
425#[doc = " Minimum of fast signed integral types having a minimum size."]
426pub const INT_FAST8_MIN: i32 = -128;
427pub const INT_FAST16_MIN: i64 = -9223372036854775808;
428pub const INT_FAST32_MIN: i64 = -9223372036854775808;
429#[doc = " Maximum of fast signed integral types having a minimum size."]
430pub const INT_FAST8_MAX: u32 = 127;
431pub const INT_FAST16_MAX: u64 = 9223372036854775807;
432pub const INT_FAST32_MAX: u64 = 9223372036854775807;
433#[doc = " Maximum of fast unsigned integral types having a minimum size."]
434pub const UINT_FAST8_MAX: u32 = 255;
435pub const UINT_FAST16_MAX: i32 = -1;
436pub const UINT_FAST32_MAX: i32 = -1;
437pub const INTPTR_MIN: i64 = -9223372036854775808;
438pub const INTPTR_MAX: u64 = 9223372036854775807;
439pub const UINTPTR_MAX: i32 = -1;
440pub const PTRDIFF_MIN: i64 = -9223372036854775808;
441pub const PTRDIFF_MAX: u64 = 9223372036854775807;
442#[doc = " Limits of `sig_atomic_t'."]
443pub const SIG_ATOMIC_MIN: i32 = -2147483648;
444pub const SIG_ATOMIC_MAX: u32 = 2147483647;
445pub const SIZE_MAX: i32 = -1;
446#[doc = " Limits of `wint_t'."]
447pub const WINT_MIN: u32 = 0;
448pub const WINT_MAX: u32 = 4294967295;
449#[doc = " Refer to PDF Reference version 1.7 table 4.12 for all color space families."]
450pub const FPDF_COLORSPACE_UNKNOWN: u32 = 0;
451pub const FPDF_COLORSPACE_DEVICEGRAY: u32 = 1;
452pub const FPDF_COLORSPACE_DEVICERGB: u32 = 2;
453pub const FPDF_COLORSPACE_DEVICECMYK: u32 = 3;
454pub const FPDF_COLORSPACE_CALGRAY: u32 = 4;
455pub const FPDF_COLORSPACE_CALRGB: u32 = 5;
456pub const FPDF_COLORSPACE_LAB: u32 = 6;
457pub const FPDF_COLORSPACE_ICCBASED: u32 = 7;
458pub const FPDF_COLORSPACE_SEPARATION: u32 = 8;
459pub const FPDF_COLORSPACE_DEVICEN: u32 = 9;
460pub const FPDF_COLORSPACE_INDEXED: u32 = 10;
461pub const FPDF_COLORSPACE_PATTERN: u32 = 11;
462#[doc = " The page object constants."]
463pub const FPDF_PAGEOBJ_UNKNOWN: u32 = 0;
464pub const FPDF_PAGEOBJ_TEXT: u32 = 1;
465pub const FPDF_PAGEOBJ_PATH: u32 = 2;
466pub const FPDF_PAGEOBJ_IMAGE: u32 = 3;
467pub const FPDF_PAGEOBJ_SHADING: u32 = 4;
468pub const FPDF_PAGEOBJ_FORM: u32 = 5;
469#[doc = " The path segment constants."]
470pub const FPDF_SEGMENT_UNKNOWN: i32 = -1;
471pub const FPDF_SEGMENT_LINETO: u32 = 0;
472pub const FPDF_SEGMENT_BEZIERTO: u32 = 1;
473pub const FPDF_SEGMENT_MOVETO: u32 = 2;
474pub const FPDF_FILLMODE_NONE: u32 = 0;
475pub const FPDF_FILLMODE_ALTERNATE: u32 = 1;
476pub const FPDF_FILLMODE_WINDING: u32 = 2;
477pub const FPDF_FONT_TYPE1: u32 = 1;
478pub const FPDF_FONT_TRUETYPE: u32 = 2;
479pub const FPDF_LINECAP_BUTT: u32 = 0;
480pub const FPDF_LINECAP_ROUND: u32 = 1;
481pub const FPDF_LINECAP_PROJECTING_SQUARE: u32 = 2;
482pub const FPDF_LINEJOIN_MITER: u32 = 0;
483pub const FPDF_LINEJOIN_ROUND: u32 = 1;
484pub const FPDF_LINEJOIN_BEVEL: u32 = 2;
485#[doc = " See FPDF_SetPrintMode() for descriptions."]
486pub const FPDF_PRINTMODE_EMF: u32 = 0;
487pub const FPDF_PRINTMODE_TEXTONLY: u32 = 1;
488pub const FPDF_PRINTMODE_POSTSCRIPT2: u32 = 2;
489pub const FPDF_PRINTMODE_POSTSCRIPT3: u32 = 3;
490pub const FPDF_PRINTMODE_POSTSCRIPT2_PASSTHROUGH: u32 = 4;
491pub const FPDF_PRINTMODE_POSTSCRIPT3_PASSTHROUGH: u32 = 5;
492pub const FPDF_PRINTMODE_EMF_IMAGE_MASKS: u32 = 6;
493pub const FPDF_PRINTMODE_POSTSCRIPT3_TYPE42: u32 = 7;
494pub const FPDF_PRINTMODE_POSTSCRIPT3_TYPE42_PASSTHROUGH: u32 = 8;
495#[doc = " Flags for progressive process status."]
496pub const FPDF_RENDER_READY: u32 = 0;
497pub const FPDF_RENDER_TOBECONTINUED: u32 = 1;
498pub const FPDF_RENDER_DONE: u32 = 2;
499pub const FPDF_RENDER_FAILED: u32 = 3;
500pub const FPDF_ANNOT_UNKNOWN: u32 = 0;
501pub const FPDF_ANNOT_TEXT: u32 = 1;
502pub const FPDF_ANNOT_LINK: u32 = 2;
503pub const FPDF_ANNOT_FREETEXT: u32 = 3;
504pub const FPDF_ANNOT_LINE: u32 = 4;
505pub const FPDF_ANNOT_SQUARE: u32 = 5;
506pub const FPDF_ANNOT_CIRCLE: u32 = 6;
507pub const FPDF_ANNOT_POLYGON: u32 = 7;
508pub const FPDF_ANNOT_POLYLINE: u32 = 8;
509pub const FPDF_ANNOT_HIGHLIGHT: u32 = 9;
510pub const FPDF_ANNOT_UNDERLINE: u32 = 10;
511pub const FPDF_ANNOT_SQUIGGLY: u32 = 11;
512pub const FPDF_ANNOT_STRIKEOUT: u32 = 12;
513pub const FPDF_ANNOT_STAMP: u32 = 13;
514pub const FPDF_ANNOT_CARET: u32 = 14;
515pub const FPDF_ANNOT_INK: u32 = 15;
516pub const FPDF_ANNOT_POPUP: u32 = 16;
517pub const FPDF_ANNOT_FILEATTACHMENT: u32 = 17;
518pub const FPDF_ANNOT_SOUND: u32 = 18;
519pub const FPDF_ANNOT_MOVIE: u32 = 19;
520pub const FPDF_ANNOT_WIDGET: u32 = 20;
521pub const FPDF_ANNOT_SCREEN: u32 = 21;
522pub const FPDF_ANNOT_PRINTERMARK: u32 = 22;
523pub const FPDF_ANNOT_TRAPNET: u32 = 23;
524pub const FPDF_ANNOT_WATERMARK: u32 = 24;
525pub const FPDF_ANNOT_THREED: u32 = 25;
526pub const FPDF_ANNOT_RICHMEDIA: u32 = 26;
527pub const FPDF_ANNOT_XFAWIDGET: u32 = 27;
528pub const FPDF_ANNOT_REDACT: u32 = 28;
529#[doc = " Refer to PDF Reference (6th edition) table 8.16 for all annotation flags."]
530pub const FPDF_ANNOT_FLAG_NONE: u32 = 0;
531pub const FPDF_ANNOT_FLAG_INVISIBLE: u32 = 1;
532pub const FPDF_ANNOT_FLAG_HIDDEN: u32 = 2;
533pub const FPDF_ANNOT_FLAG_PRINT: u32 = 4;
534pub const FPDF_ANNOT_FLAG_NOZOOM: u32 = 8;
535pub const FPDF_ANNOT_FLAG_NOROTATE: u32 = 16;
536pub const FPDF_ANNOT_FLAG_NOVIEW: u32 = 32;
537pub const FPDF_ANNOT_FLAG_READONLY: u32 = 64;
538pub const FPDF_ANNOT_FLAG_LOCKED: u32 = 128;
539pub const FPDF_ANNOT_FLAG_TOGGLENOVIEW: u32 = 256;
540pub const FPDF_ANNOT_APPEARANCEMODE_NORMAL: u32 = 0;
541pub const FPDF_ANNOT_APPEARANCEMODE_ROLLOVER: u32 = 1;
542pub const FPDF_ANNOT_APPEARANCEMODE_DOWN: u32 = 2;
543pub const FPDF_ANNOT_APPEARANCEMODE_COUNT: u32 = 3;
544#[doc = " Refer to PDF Reference version 1.7 table 8.70 for field flags common to all\n interactive form field types."]
545pub const FPDF_FORMFLAG_NONE: u32 = 0;
546pub const FPDF_FORMFLAG_READONLY: u32 = 1;
547pub const FPDF_FORMFLAG_REQUIRED: u32 = 2;
548pub const FPDF_FORMFLAG_NOEXPORT: u32 = 4;
549#[doc = " Refer to PDF Reference version 1.7 table 8.77 for field flags specific to\n interactive form text fields."]
550pub const FPDF_FORMFLAG_TEXT_MULTILINE: u32 = 4096;
551pub const FPDF_FORMFLAG_TEXT_PASSWORD: u32 = 8192;
552#[doc = " Refer to PDF Reference version 1.7 table 8.79 for field flags specific to\n interactive form choice fields."]
553pub const FPDF_FORMFLAG_CHOICE_COMBO: u32 = 131072;
554pub const FPDF_FORMFLAG_CHOICE_EDIT: u32 = 262144;
555pub const FPDF_FORMFLAG_CHOICE_MULTI_SELECT: u32 = 2097152;
556#[doc = " Additional actions type of form field:\n K, on key stroke, JavaScript action.\n F, on format, JavaScript action.\n V, on validate, JavaScript action.\n C, on calculate, JavaScript action."]
557pub const FPDF_ANNOT_AACTION_KEY_STROKE: u32 = 12;
558pub const FPDF_ANNOT_AACTION_FORMAT: u32 = 13;
559pub const FPDF_ANNOT_AACTION_VALIDATE: u32 = 14;
560pub const FPDF_ANNOT_AACTION_CALCULATE: u32 = 15;
561#[doc = " Flags used by FPDFText_FindStart function.\n\n If not set, it will not match case by default."]
562pub const FPDF_MATCHCASE: u32 = 1;
563#[doc = " If not set, it will not match the whole word by default."]
564pub const FPDF_MATCHWHOLEWORD: u32 = 2;
565#[doc = " If not set, it will skip past the current match to look for the next match."]
566pub const FPDF_CONSECUTIVE: u32 = 4;
567#[doc = " Flatten operation failed."]
568pub const FLATTEN_FAIL: u32 = 0;
569#[doc = " Flatten operation succeed."]
570pub const FLATTEN_SUCCESS: u32 = 1;
571#[doc = " Nothing to be flattened."]
572pub const FLATTEN_NOTHINGTODO: u32 = 2;
573#[doc = " Flatten for normal display."]
574pub const FLAT_NORMALDISPLAY: u32 = 0;
575#[doc = " Flatten for print."]
576pub const FLAT_PRINT: u32 = 1;
577pub const PDF_LINEARIZATION_UNKNOWN: i32 = -1;
578pub const PDF_NOT_LINEARIZED: u32 = 0;
579pub const PDF_LINEARIZED: u32 = 1;
580pub const PDF_DATA_ERROR: i32 = -1;
581pub const PDF_DATA_NOTAVAIL: u32 = 0;
582pub const PDF_DATA_AVAIL: u32 = 1;
583pub const PDF_FORM_ERROR: i32 = -1;
584pub const PDF_FORM_NOTAVAIL: u32 = 0;
585pub const PDF_FORM_AVAIL: u32 = 1;
586pub const PDF_FORM_NOTEXIST: u32 = 2;
587#[doc = " Convenience types."]
588pub type __u_char = ::std::os::raw::c_uchar;
589pub type __u_short = ::std::os::raw::c_ushort;
590pub type __u_int = ::std::os::raw::c_uint;
591pub type __u_long = ::std::os::raw::c_ulong;
592#[doc = " Fixed-size types, underlying types depend on word size and compiler."]
593pub type __int8_t = ::std::os::raw::c_schar;
594pub type __uint8_t = ::std::os::raw::c_uchar;
595pub type __int16_t = ::std::os::raw::c_short;
596pub type __uint16_t = ::std::os::raw::c_ushort;
597pub type __int32_t = ::std::os::raw::c_int;
598pub type __uint32_t = ::std::os::raw::c_uint;
599pub type __int64_t = ::std::os::raw::c_long;
600pub type __uint64_t = ::std::os::raw::c_ulong;
601#[doc = " Smallest types with at least a given width."]
602pub type __int_least8_t = __int8_t;
603pub type __uint_least8_t = __uint8_t;
604pub type __int_least16_t = __int16_t;
605pub type __uint_least16_t = __uint16_t;
606pub type __int_least32_t = __int32_t;
607pub type __uint_least32_t = __uint32_t;
608pub type __int_least64_t = __int64_t;
609pub type __uint_least64_t = __uint64_t;
610pub type __quad_t = ::std::os::raw::c_long;
611pub type __u_quad_t = ::std::os::raw::c_ulong;
612pub type __intmax_t = ::std::os::raw::c_long;
613pub type __uintmax_t = ::std::os::raw::c_ulong;
614pub type __dev_t = ::std::os::raw::c_ulong;
615pub type __uid_t = ::std::os::raw::c_uint;
616pub type __gid_t = ::std::os::raw::c_uint;
617pub type __ino_t = ::std::os::raw::c_ulong;
618pub type __ino64_t = ::std::os::raw::c_ulong;
619pub type __mode_t = ::std::os::raw::c_uint;
620pub type __nlink_t = ::std::os::raw::c_ulong;
621pub type __off_t = ::std::os::raw::c_long;
622pub type __off64_t = ::std::os::raw::c_long;
623pub type __pid_t = ::std::os::raw::c_int;
624#[repr(C)]
625#[derive(Debug, Copy, Clone)]
626pub struct __fsid_t {
627 pub __val: [::std::os::raw::c_int; 2usize],
628}
629pub type __clock_t = ::std::os::raw::c_long;
630pub type __rlim_t = ::std::os::raw::c_ulong;
631pub type __rlim64_t = ::std::os::raw::c_ulong;
632pub type __id_t = ::std::os::raw::c_uint;
633pub type __time_t = ::std::os::raw::c_long;
634pub type __useconds_t = ::std::os::raw::c_uint;
635pub type __suseconds_t = ::std::os::raw::c_long;
636pub type __suseconds64_t = ::std::os::raw::c_long;
637pub type __daddr_t = ::std::os::raw::c_int;
638pub type __key_t = ::std::os::raw::c_int;
639pub type __clockid_t = ::std::os::raw::c_int;
640pub type __timer_t = *mut ::std::os::raw::c_void;
641pub type __blksize_t = ::std::os::raw::c_long;
642pub type __blkcnt_t = ::std::os::raw::c_long;
643pub type __blkcnt64_t = ::std::os::raw::c_long;
644pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
645pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
646pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
647pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
648pub type __fsword_t = ::std::os::raw::c_long;
649pub type __ssize_t = ::std::os::raw::c_long;
650pub type __syscall_slong_t = ::std::os::raw::c_long;
651pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
652#[doc = " These few don't really vary by system, they always correspond\nto one of the other defined types."]
653pub type __loff_t = __off64_t;
654pub type __caddr_t = *mut ::std::os::raw::c_char;
655pub type __intptr_t = ::std::os::raw::c_long;
656pub type __socklen_t = ::std::os::raw::c_uint;
657#[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."]
658pub type __sig_atomic_t = ::std::os::raw::c_int;
659#[doc = " Returned by `clock'."]
660pub type clock_t = __clock_t;
661pub type time_t = __time_t;
662#[doc = " ISO C `broken-down time' structure."]
663#[repr(C)]
664#[derive(Debug, Copy, Clone)]
665pub struct tm {
666 #[doc = " Seconds.\t[0-60] (1 leap second)"]
667 pub tm_sec: ::std::os::raw::c_int,
668 #[doc = " Minutes.\t[0-59]"]
669 pub tm_min: ::std::os::raw::c_int,
670 #[doc = " Hours.\t[0-23]"]
671 pub tm_hour: ::std::os::raw::c_int,
672 #[doc = " Day.\t\t[1-31]"]
673 pub tm_mday: ::std::os::raw::c_int,
674 #[doc = " Month.\t[0-11]"]
675 pub tm_mon: ::std::os::raw::c_int,
676 #[doc = " Year\t- 1900."]
677 pub tm_year: ::std::os::raw::c_int,
678 #[doc = " Day of week.\t[0-6]"]
679 pub tm_wday: ::std::os::raw::c_int,
680 #[doc = " Days in year.[0-365]"]
681 pub tm_yday: ::std::os::raw::c_int,
682 #[doc = " DST.\t\t[-1/0/1]"]
683 pub tm_isdst: ::std::os::raw::c_int,
684 #[doc = " Seconds east of UTC."]
685 pub tm_gmtoff: ::std::os::raw::c_long,
686 #[doc = " Timezone abbreviation."]
687 pub tm_zone: *const ::std::os::raw::c_char,
688}
689#[doc = " POSIX.1b structure for a time value. This is like a `struct timeval' but\nhas nanoseconds instead of microseconds."]
690#[repr(C)]
691#[derive(Debug, Copy, Clone)]
692pub struct timespec {
693 #[doc = " Seconds."]
694 pub tv_sec: __time_t,
695 #[doc = " Nanoseconds."]
696 pub tv_nsec: __syscall_slong_t,
697}
698#[doc = " Clock ID used in clock and timer functions."]
699pub type clockid_t = __clockid_t;
700#[doc = " Timer ID returned by `timer_create'."]
701pub type timer_t = __timer_t;
702#[doc = " POSIX.1b structure for timer start values and intervals."]
703#[repr(C)]
704#[derive(Debug, Copy, Clone)]
705pub struct itimerspec {
706 pub it_interval: timespec,
707 pub it_value: timespec,
708}
709#[repr(C)]
710#[derive(Debug)]
711pub struct sigevent {
712 _unused: [u8; 0],
713}
714pub type pid_t = __pid_t;
715#[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."]
716#[repr(C)]
717#[derive(Debug, Copy, Clone)]
718pub struct __locale_struct {
719 #[doc = " 13 = __LC_LAST."]
720 pub __locales: [*mut __locale_data; 13usize],
721 #[doc = " To increase the speed of this solution we add some special members."]
722 pub __ctype_b: *const ::std::os::raw::c_ushort,
723 pub __ctype_tolower: *const ::std::os::raw::c_int,
724 pub __ctype_toupper: *const ::std::os::raw::c_int,
725 #[doc = " Note: LC_ALL is not a valid index into this array."]
726 pub __names: [*const ::std::os::raw::c_char; 13usize],
727}
728pub type __locale_t = *mut __locale_struct;
729pub type locale_t = __locale_t;
730unsafe extern "C" {
731 #[doc = " Time used by the program so far (user time + system time).\nThe result / CLOCKS_PER_SEC is program time in seconds."]
732 pub fn clock() -> clock_t;
733}
734unsafe extern "C" {
735 #[doc = " Return the current time and put it in *TIMER if TIMER is not NULL."]
736 pub fn time(__timer: *mut time_t) -> time_t;
737}
738unsafe extern "C" {
739 #[doc = " Return the difference between TIME1 and TIME0."]
740 pub fn difftime(__time1: time_t, __time0: time_t) -> f64;
741}
742unsafe extern "C" {
743 #[doc = " Return the `time_t' representation of TP and normalize TP."]
744 pub fn mktime(__tp: *mut tm) -> time_t;
745}
746unsafe extern "C" {
747 #[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."]
748 pub fn strftime(
749 __s: *mut ::std::os::raw::c_char,
750 __maxsize: usize,
751 __format: *const ::std::os::raw::c_char,
752 __tp: *const tm,
753 ) -> usize;
754}
755unsafe extern "C" {
756 #[doc = " Similar to the two functions above but take the information from\nthe provided locale and not the global locale."]
757 pub fn strftime_l(
758 __s: *mut ::std::os::raw::c_char,
759 __maxsize: usize,
760 __format: *const ::std::os::raw::c_char,
761 __tp: *const tm,
762 __loc: locale_t,
763 ) -> usize;
764}
765unsafe extern "C" {
766 #[doc = " Return the `struct tm' representation of *TIMER\nin Universal Coordinated Time (aka Greenwich Mean Time)."]
767 pub fn gmtime(__timer: *const time_t) -> *mut tm;
768}
769unsafe extern "C" {
770 #[doc = " Return the `struct tm' representation\nof *TIMER in the local timezone."]
771 pub fn localtime(__timer: *const time_t) -> *mut tm;
772}
773unsafe extern "C" {
774 #[doc = " Return the `struct tm' representation of *TIMER in UTC,\nusing *TP to store the result."]
775 pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
776}
777unsafe extern "C" {
778 #[doc = " Return the `struct tm' representation of *TIMER in local time,\nusing *TP to store the result."]
779 pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
780}
781unsafe extern "C" {
782 #[doc = " Return a string of the form \"Day Mon dd hh:mm:ss yyyy\\n\"\nthat is the representation of TP in this format."]
783 pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char;
784}
785unsafe extern "C" {
786 pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char;
787}
788unsafe extern "C" {
789 #[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."]
790 pub fn asctime_r(
791 __tp: *const tm,
792 __buf: *mut ::std::os::raw::c_char,
793 ) -> *mut ::std::os::raw::c_char;
794}
795unsafe extern "C" {
796 pub fn ctime_r(
797 __timer: *const time_t,
798 __buf: *mut ::std::os::raw::c_char,
799 ) -> *mut ::std::os::raw::c_char;
800}
801unsafe extern "C" {
802 #[doc = " Current time zone abbreviations."]
803 pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize];
804}
805unsafe extern "C" {
806 #[doc = " If daylight-saving time is ever in use."]
807 pub static mut __daylight: ::std::os::raw::c_int;
808}
809unsafe extern "C" {
810 #[doc = " Seconds west of UTC."]
811 pub static mut __timezone: ::std::os::raw::c_long;
812}
813unsafe extern "C" {
814 #[doc = " Same as above."]
815 pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize];
816}
817unsafe extern "C" {
818 #[doc = " Set time conversion information from the TZ environment variable.\nIf TZ is not defined, a locale-dependent default is used."]
819 pub fn tzset();
820}
821unsafe extern "C" {
822 pub static mut daylight: ::std::os::raw::c_int;
823}
824unsafe extern "C" {
825 pub static mut timezone: ::std::os::raw::c_long;
826}
827unsafe extern "C" {
828 #[doc = " Like `mktime', but for TP represents Universal Time, not local time."]
829 pub fn timegm(__tp: *mut tm) -> time_t;
830}
831unsafe extern "C" {
832 #[doc = " Another name for `mktime'."]
833 pub fn timelocal(__tp: *mut tm) -> time_t;
834}
835unsafe extern "C" {
836 #[doc = " Return the number of days in YEAR."]
837 pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
838}
839unsafe extern "C" {
840 #[doc = " Pause execution for a number of nanoseconds.\n\nThis function is a cancellation point and therefore not marked with\n__THROW."]
841 pub fn nanosleep(
842 __requested_time: *const timespec,
843 __remaining: *mut timespec,
844 ) -> ::std::os::raw::c_int;
845}
846unsafe extern "C" {
847 #[doc = " Get resolution of clock CLOCK_ID."]
848 pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int;
849}
850unsafe extern "C" {
851 #[doc = " Get current value of clock CLOCK_ID and store it in TP."]
852 pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int;
853}
854unsafe extern "C" {
855 #[doc = " Set clock CLOCK_ID to value TP."]
856 pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int;
857}
858unsafe extern "C" {
859 pub fn clock_nanosleep(
860 __clock_id: clockid_t,
861 __flags: ::std::os::raw::c_int,
862 __req: *const timespec,
863 __rem: *mut timespec,
864 ) -> ::std::os::raw::c_int;
865}
866unsafe extern "C" {
867 #[doc = " Return clock ID for CPU-time clock."]
868 pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int;
869}
870unsafe extern "C" {
871 #[doc = " Create new per-process timer using CLOCK_ID."]
872 pub fn timer_create(
873 __clock_id: clockid_t,
874 __evp: *mut sigevent,
875 __timerid: *mut timer_t,
876 ) -> ::std::os::raw::c_int;
877}
878unsafe extern "C" {
879 #[doc = " Delete timer TIMERID."]
880 pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int;
881}
882unsafe extern "C" {
883 pub fn timer_settime(
884 __timerid: timer_t,
885 __flags: ::std::os::raw::c_int,
886 __value: *const itimerspec,
887 __ovalue: *mut itimerspec,
888 ) -> ::std::os::raw::c_int;
889}
890unsafe extern "C" {
891 #[doc = " Get current value of timer TIMERID and store it in VALUE."]
892 pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int;
893}
894unsafe extern "C" {
895 #[doc = " Get expiration overrun for timer TIMERID."]
896 pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int;
897}
898unsafe extern "C" {
899 #[doc = " Set TS to calendar time based in time base BASE."]
900 pub fn timespec_get(
901 __ts: *mut timespec,
902 __base: ::std::os::raw::c_int,
903 ) -> ::std::os::raw::c_int;
904}
905pub type wchar_t = ::std::os::raw::c_int;
906#[doc = " Define 'max_align_t' to match the GCC definition."]
907#[repr(C)]
908#[repr(align(16))]
909#[derive(Debug, Copy, Clone)]
910pub struct max_align_t {
911 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
912 pub __clang_max_align_nonce2: u128,
913}
914pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_UNKNOWN: FPDF_TEXT_RENDERMODE = -1;
915pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL: FPDF_TEXT_RENDERMODE = 0;
916pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_STROKE: FPDF_TEXT_RENDERMODE = 1;
917pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_STROKE: FPDF_TEXT_RENDERMODE = 2;
918pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_INVISIBLE: FPDF_TEXT_RENDERMODE = 3;
919pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_CLIP: FPDF_TEXT_RENDERMODE = 4;
920pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_STROKE_CLIP: FPDF_TEXT_RENDERMODE = 5;
921pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_FILL_STROKE_CLIP: FPDF_TEXT_RENDERMODE = 6;
922pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_CLIP: FPDF_TEXT_RENDERMODE = 7;
923pub const FPDF_TEXT_RENDERMODE_FPDF_TEXTRENDERMODE_LAST: FPDF_TEXT_RENDERMODE = 7;
924#[doc = " PDF text rendering modes"]
925pub type FPDF_TEXT_RENDERMODE = ::std::os::raw::c_int;
926#[repr(C)]
927#[derive(Debug)]
928pub struct fpdf_action_t__ {
929 _unused: [u8; 0],
930}
931#[doc = " PDF types - use incomplete types (never completed) to force API type safety."]
932pub type FPDF_ACTION = *mut fpdf_action_t__;
933#[repr(C)]
934#[derive(Debug)]
935pub struct fpdf_annotation_t__ {
936 _unused: [u8; 0],
937}
938pub type FPDF_ANNOTATION = *mut fpdf_annotation_t__;
939#[repr(C)]
940#[derive(Debug)]
941pub struct fpdf_attachment_t__ {
942 _unused: [u8; 0],
943}
944pub type FPDF_ATTACHMENT = *mut fpdf_attachment_t__;
945#[repr(C)]
946#[derive(Debug)]
947pub struct fpdf_avail_t__ {
948 _unused: [u8; 0],
949}
950pub type FPDF_AVAIL = *mut fpdf_avail_t__;
951#[repr(C)]
952#[derive(Debug)]
953pub struct fpdf_bitmap_t__ {
954 _unused: [u8; 0],
955}
956pub type FPDF_BITMAP = *mut fpdf_bitmap_t__;
957#[repr(C)]
958#[derive(Debug)]
959pub struct fpdf_bookmark_t__ {
960 _unused: [u8; 0],
961}
962pub type FPDF_BOOKMARK = *mut fpdf_bookmark_t__;
963#[repr(C)]
964#[derive(Debug)]
965pub struct fpdf_clippath_t__ {
966 _unused: [u8; 0],
967}
968pub type FPDF_CLIPPATH = *mut fpdf_clippath_t__;
969#[repr(C)]
970#[derive(Debug)]
971pub struct fpdf_dest_t__ {
972 _unused: [u8; 0],
973}
974pub type FPDF_DEST = *mut fpdf_dest_t__;
975#[repr(C)]
976#[derive(Debug)]
977pub struct fpdf_document_t__ {
978 _unused: [u8; 0],
979}
980pub type FPDF_DOCUMENT = *mut fpdf_document_t__;
981#[repr(C)]
982#[derive(Debug)]
983pub struct fpdf_font_t__ {
984 _unused: [u8; 0],
985}
986pub type FPDF_FONT = *mut fpdf_font_t__;
987#[repr(C)]
988#[derive(Debug)]
989pub struct fpdf_form_handle_t__ {
990 _unused: [u8; 0],
991}
992pub type FPDF_FORMHANDLE = *mut fpdf_form_handle_t__;
993#[repr(C)]
994#[derive(Debug)]
995pub struct fpdf_glyphpath_t__ {
996 _unused: [u8; 0],
997}
998pub type FPDF_GLYPHPATH = *const fpdf_glyphpath_t__;
999#[repr(C)]
1000#[derive(Debug)]
1001pub struct fpdf_javascript_action_t {
1002 _unused: [u8; 0],
1003}
1004pub type FPDF_JAVASCRIPT_ACTION = *mut fpdf_javascript_action_t;
1005#[repr(C)]
1006#[derive(Debug)]
1007pub struct fpdf_link_t__ {
1008 _unused: [u8; 0],
1009}
1010pub type FPDF_LINK = *mut fpdf_link_t__;
1011#[repr(C)]
1012#[derive(Debug)]
1013pub struct fpdf_page_t__ {
1014 _unused: [u8; 0],
1015}
1016pub type FPDF_PAGE = *mut fpdf_page_t__;
1017#[repr(C)]
1018#[derive(Debug)]
1019pub struct fpdf_pagelink_t__ {
1020 _unused: [u8; 0],
1021}
1022pub type FPDF_PAGELINK = *mut fpdf_pagelink_t__;
1023#[repr(C)]
1024#[derive(Debug)]
1025pub struct fpdf_pageobject_t__ {
1026 _unused: [u8; 0],
1027}
1028pub type FPDF_PAGEOBJECT = *mut fpdf_pageobject_t__;
1029#[repr(C)]
1030#[derive(Debug)]
1031pub struct fpdf_pageobjectmark_t__ {
1032 _unused: [u8; 0],
1033}
1034pub type FPDF_PAGEOBJECTMARK = *mut fpdf_pageobjectmark_t__;
1035#[repr(C)]
1036#[derive(Debug)]
1037pub struct fpdf_pagerange_t__ {
1038 _unused: [u8; 0],
1039}
1040pub type FPDF_PAGERANGE = *const fpdf_pagerange_t__;
1041#[repr(C)]
1042#[derive(Debug)]
1043pub struct fpdf_pathsegment_t {
1044 _unused: [u8; 0],
1045}
1046pub type FPDF_PATHSEGMENT = *const fpdf_pathsegment_t;
1047#[repr(C)]
1048#[derive(Debug)]
1049pub struct fpdf_schhandle_t__ {
1050 _unused: [u8; 0],
1051}
1052pub type FPDF_SCHHANDLE = *mut fpdf_schhandle_t__;
1053#[repr(C)]
1054#[derive(Debug)]
1055pub struct fpdf_signature_t__ {
1056 _unused: [u8; 0],
1057}
1058pub type FPDF_SIGNATURE = *const fpdf_signature_t__;
1059pub type FPDF_SKIA_CANVAS = *mut ::std::os::raw::c_void;
1060#[repr(C)]
1061#[derive(Debug)]
1062pub struct fpdf_structelement_t__ {
1063 _unused: [u8; 0],
1064}
1065pub type FPDF_STRUCTELEMENT = *mut fpdf_structelement_t__;
1066#[repr(C)]
1067#[derive(Debug)]
1068pub struct fpdf_structelement_attr_t__ {
1069 _unused: [u8; 0],
1070}
1071pub type FPDF_STRUCTELEMENT_ATTR = *const fpdf_structelement_attr_t__;
1072#[repr(C)]
1073#[derive(Debug)]
1074pub struct fpdf_structelement_attr_value_t__ {
1075 _unused: [u8; 0],
1076}
1077pub type FPDF_STRUCTELEMENT_ATTR_VALUE = *const fpdf_structelement_attr_value_t__;
1078#[repr(C)]
1079#[derive(Debug)]
1080pub struct fpdf_structtree_t__ {
1081 _unused: [u8; 0],
1082}
1083pub type FPDF_STRUCTTREE = *mut fpdf_structtree_t__;
1084#[repr(C)]
1085#[derive(Debug)]
1086pub struct fpdf_textpage_t__ {
1087 _unused: [u8; 0],
1088}
1089pub type FPDF_TEXTPAGE = *mut fpdf_textpage_t__;
1090#[repr(C)]
1091#[derive(Debug)]
1092pub struct fpdf_widget_t__ {
1093 _unused: [u8; 0],
1094}
1095pub type FPDF_WIDGET = *mut fpdf_widget_t__;
1096#[repr(C)]
1097#[derive(Debug)]
1098pub struct fpdf_xobject_t__ {
1099 _unused: [u8; 0],
1100}
1101pub type FPDF_XOBJECT = *mut fpdf_xobject_t__;
1102#[doc = " Basic data types"]
1103pub type FPDF_BOOL = ::std::os::raw::c_int;
1104pub type FPDF_RESULT = ::std::os::raw::c_int;
1105pub type FPDF_DWORD = ::std::os::raw::c_ulong;
1106pub type FS_FLOAT = f32;
1107pub const _FPDF_DUPLEXTYPE__DuplexUndefined: _FPDF_DUPLEXTYPE_ = 0;
1108pub const _FPDF_DUPLEXTYPE__Simplex: _FPDF_DUPLEXTYPE_ = 1;
1109pub const _FPDF_DUPLEXTYPE__DuplexFlipShortEdge: _FPDF_DUPLEXTYPE_ = 2;
1110pub const _FPDF_DUPLEXTYPE__DuplexFlipLongEdge: _FPDF_DUPLEXTYPE_ = 3;
1111#[doc = " Duplex types"]
1112pub type _FPDF_DUPLEXTYPE_ = ::std::os::raw::c_uint;
1113use std::ffi::c_float;
1114
1115#[doc = " Duplex types"]
1116pub use self::_FPDF_DUPLEXTYPE_ as FPDF_DUPLEXTYPE;
1117#[doc = " String types"]
1118pub type FPDF_WCHAR = ::std::os::raw::c_ushort;
1119#[doc = " Public PDFium API type for byte strings."]
1120pub type FPDF_BYTESTRING = *const ::std::os::raw::c_char;
1121#[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."]
1122pub type FPDF_WIDESTRING = *const FPDF_WCHAR;
1123#[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."]
1124#[repr(C)]
1125#[derive(Debug, Copy, Clone)]
1126pub struct FPDF_BSTR_ {
1127 #[doc = " String buffer, manipulate only with FPDF_BStr_* methods."]
1128 pub str_: *mut ::std::os::raw::c_char,
1129 #[doc = " Length of the string, in bytes."]
1130 pub len: ::std::os::raw::c_int,
1131}
1132#[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."]
1133pub type FPDF_BSTR = FPDF_BSTR_;
1134#[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."]
1135pub type FPDF_STRING = *const ::std::os::raw::c_char;
1136#[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."]
1137#[repr(C)]
1138#[derive(Debug, Copy, Clone)]
1139pub struct _FS_MATRIX_ {
1140 pub a: f32,
1141 pub b: f32,
1142 pub c: f32,
1143 pub d: f32,
1144 pub e: f32,
1145 pub f: f32,
1146}
1147#[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."]
1148pub type FS_MATRIX = _FS_MATRIX_;
1149#[doc = " Rectangle area(float) in device or page coordinate system."]
1150#[repr(C)]
1151#[derive(Debug, Copy, Clone)]
1152pub struct _FS_RECTF_ {
1153 #[doc = " The x-coordinate of the left-top corner."]
1154 pub left: f32,
1155 #[doc = " The y-coordinate of the left-top corner."]
1156 pub top: f32,
1157 #[doc = " The x-coordinate of the right-bottom corner."]
1158 pub right: f32,
1159 #[doc = " The y-coordinate of the right-bottom corner."]
1160 pub bottom: f32,
1161}
1162#[doc = " Rectangle area(float) in device or page coordinate system."]
1163pub type FS_LPRECTF = *mut _FS_RECTF_;
1164#[doc = " Rectangle area(float) in device or page coordinate system."]
1165pub type FS_RECTF = _FS_RECTF_;
1166#[doc = " Const Pointer to FS_RECTF structure."]
1167pub type FS_LPCRECTF = *const FS_RECTF;
1168#[doc = " Rectangle size. Coordinate system agnostic."]
1169#[repr(C)]
1170#[derive(Debug, Copy, Clone)]
1171pub struct FS_SIZEF_ {
1172 pub width: f32,
1173 pub height: f32,
1174}
1175#[doc = " Rectangle size. Coordinate system agnostic."]
1176pub type FS_LPSIZEF = *mut FS_SIZEF_;
1177#[doc = " Rectangle size. Coordinate system agnostic."]
1178pub type FS_SIZEF = FS_SIZEF_;
1179#[doc = " Const Pointer to FS_SIZEF structure."]
1180pub type FS_LPCSIZEF = *const FS_SIZEF;
1181#[doc = " 2D Point. Coordinate system agnostic."]
1182#[repr(C)]
1183#[derive(Debug, Copy, Clone)]
1184pub struct FS_POINTF_ {
1185 pub x: f32,
1186 pub y: f32,
1187}
1188#[doc = " 2D Point. Coordinate system agnostic."]
1189pub type FS_LPPOINTF = *mut FS_POINTF_;
1190#[doc = " 2D Point. Coordinate system agnostic."]
1191pub type FS_POINTF = FS_POINTF_;
1192#[doc = " Const Pointer to FS_POINTF structure."]
1193pub type FS_LPCPOINTF = *const FS_POINTF;
1194#[repr(C)]
1195#[derive(Debug, Copy, Clone)]
1196pub struct _FS_QUADPOINTSF {
1197 pub x1: FS_FLOAT,
1198 pub y1: FS_FLOAT,
1199 pub x2: FS_FLOAT,
1200 pub y2: FS_FLOAT,
1201 pub x3: FS_FLOAT,
1202 pub y3: FS_FLOAT,
1203 pub x4: FS_FLOAT,
1204 pub y4: FS_FLOAT,
1205}
1206pub type FS_QUADPOINTSF = _FS_QUADPOINTSF;
1207#[doc = " Annotation enums."]
1208pub type FPDF_ANNOTATION_SUBTYPE = ::std::os::raw::c_int;
1209pub type FPDF_ANNOT_APPEARANCEMODE = ::std::os::raw::c_int;
1210#[doc = " Dictionary value types."]
1211pub type FPDF_OBJECT_TYPE = ::std::os::raw::c_int;
1212#[doc = " Anti-Grain Geometry - https://sourceforge.net/projects/agg/"]
1213pub const FPDF_RENDERER_TYPE_FPDF_RENDERERTYPE_AGG: FPDF_RENDERER_TYPE = 0;
1214#[doc = " Skia - https://skia.org/"]
1215pub const FPDF_RENDERER_TYPE_FPDF_RENDERERTYPE_SKIA: FPDF_RENDERER_TYPE = 1;
1216#[doc = " PDF renderer types - Experimental.\n Selection of 2D graphics library to use for rendering to FPDF_BITMAPs."]
1217pub type FPDF_RENDERER_TYPE = ::std::os::raw::c_uint;
1218#[doc = " FreeType - https://freetype.org/"]
1219pub const FPDF_FONT_BACKEND_TYPE_FPDF_FONTBACKENDTYPE_FREETYPE: FPDF_FONT_BACKEND_TYPE = 0;
1220#[doc = " Fontations - https://github.com/googlefonts/fontations/"]
1221pub const FPDF_FONT_BACKEND_TYPE_FPDF_FONTBACKENDTYPE_FONTATIONS: FPDF_FONT_BACKEND_TYPE = 1;
1222#[doc = " PDF font library types - Experimental.\n Selection of font backend library to use."]
1223pub type FPDF_FONT_BACKEND_TYPE = ::std::os::raw::c_uint;
1224#[doc = " Process-wide options for initializing the library."]
1225#[repr(C)]
1226#[derive(Debug, Copy, Clone)]
1227pub struct FPDF_LIBRARY_CONFIG_ {
1228 #[doc = " Version number of the interface. Currently must be 2.\n Support for version 1 will be deprecated in the future."]
1229 pub version: ::std::os::raw::c_int,
1230 #[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."]
1231 pub m_pUserFontPaths: *mut *const ::std::os::raw::c_char,
1232 #[doc = " Pointer to the v8::Isolate to use, or NULL to force PDFium to create one."]
1233 pub m_pIsolate: *mut ::std::os::raw::c_void,
1234 #[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."]
1235 pub m_v8EmbedderSlot: ::std::os::raw::c_uint,
1236 #[doc = " Pointer to the V8::Platform to use."]
1237 pub m_pPlatform: *mut ::std::os::raw::c_void,
1238 #[doc = " Explicit specification of 2D graphics rendering library to use.\n |m_RendererType| must be a valid value for |FPDF_LIBRARY_CONFIG| versions\n of this level or higher, or else the initialization will fail with an\n immediate crash.\n Note that use of a specified |FPDF_RENDERER_TYPE| value for which the\n corresponding 2D graphics rendering library is not included in the build\n will similarly fail with an immediate crash."]
1239 pub m_RendererType: FPDF_RENDERER_TYPE,
1240 #[doc = " Explicit specification of font library to use.\n |m_FontLibraryType| must be a valid value for |FPDF_LIBRARY_CONFIG|\n versions of this level or higher, or else the initialization will fail with\n an immediate crash.\n Note that use of a specified |FPDF_FONT_BACKEND_TYPE| value for which the\n corresponding font library is not included in the build will similarly fail\n with an immediate crash."]
1241 pub m_FontLibraryType: FPDF_FONT_BACKEND_TYPE,
1242 #[doc = " Boolean to specify whether the experimental PDF 2.0 /BrotliDecode filter\n is enabled. For setting the bool to true to have an effect, PDFium must be\n built with |PDF_ENABLE_BROTLI|."]
1243 pub m_BrotliEnabled: FPDF_BOOL,
1244 #[doc = " Boolean to specify whether PDFium creates a dedicated v8::Isolate for each\n document. When true, |m_pIsolate| must be NULL."]
1245 pub m_IsolatePerDocument: FPDF_BOOL,
1246}
1247#[doc = " Process-wide options for initializing the library."]
1248pub type FPDF_LIBRARY_CONFIG = FPDF_LIBRARY_CONFIG_;
1249unsafe extern "C" {
1250 #[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."]
1251 pub fn FPDF_InitLibraryWithConfig(config: *const FPDF_LIBRARY_CONFIG);
1252}
1253unsafe extern "C" {
1254 #[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."]
1255 pub fn FPDF_InitLibrary();
1256}
1257unsafe extern "C" {
1258 #[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."]
1259 pub fn FPDF_DestroyLibrary();
1260}
1261unsafe extern "C" {
1262 #[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."]
1263 pub fn FPDF_SetSandBoxPolicy(policy: FPDF_DWORD, enable: FPDF_BOOL);
1264}
1265unsafe extern "C" {
1266 #[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."]
1267 pub fn FPDF_LoadDocument(file_path: FPDF_STRING, password: FPDF_BYTESTRING) -> FPDF_DOCUMENT;
1268}
1269unsafe extern "C" {
1270 #[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."]
1271 pub fn FPDF_LoadMemDocument(
1272 data_buf: *const ::std::os::raw::c_void,
1273 size: ::std::os::raw::c_int,
1274 password: FPDF_BYTESTRING,
1275 ) -> FPDF_DOCUMENT;
1276}
1277unsafe extern "C" {
1278 #[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."]
1279 pub fn FPDF_LoadMemDocument64(
1280 data_buf: *const ::std::os::raw::c_void,
1281 size: usize,
1282 password: FPDF_BYTESTRING,
1283 ) -> FPDF_DOCUMENT;
1284}
1285#[doc = " Structure for custom file access."]
1286#[repr(C)]
1287#[derive(Debug, Copy, Clone)]
1288pub struct FPDF_FILEACCESS {
1289 #[doc = " File length, in bytes."]
1290 pub m_FileLen: ::std::os::raw::c_ulong,
1291 #[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."]
1292 pub m_GetBlock: ::std::option::Option<
1293 unsafe extern "C" fn(
1294 param: *mut ::std::os::raw::c_void,
1295 position: ::std::os::raw::c_ulong,
1296 pBuf: *mut ::std::os::raw::c_uchar,
1297 size: ::std::os::raw::c_ulong,
1298 ) -> ::std::os::raw::c_int,
1299 >,
1300 #[doc = " A custom pointer for all implementation specific data. This pointer will\n be used as the first parameter to the m_GetBlock callback."]
1301 pub m_Param: *mut ::std::os::raw::c_void,
1302}
1303#[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."]
1304#[repr(C)]
1305#[derive(Debug, Copy, Clone)]
1306pub struct FPDF_FILEHANDLER_ {
1307 #[doc = " User-defined data.\n Note: Callers can use this field to track controls."]
1308 pub clientData: *mut ::std::os::raw::c_void,
1309 #[doc = " Callback function to release the current file stream object.\n\n Parameters:\n clientData - Pointer to user-defined data.\n Returns:\n None."]
1310 pub Release:
1311 ::std::option::Option<unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void)>,
1312 #[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."]
1313 pub GetSize: ::std::option::Option<
1314 unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void) -> FPDF_DWORD,
1315 >,
1316 #[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."]
1317 pub ReadBlock: ::std::option::Option<
1318 unsafe extern "C" fn(
1319 clientData: *mut ::std::os::raw::c_void,
1320 offset: FPDF_DWORD,
1321 buffer: *mut ::std::os::raw::c_void,
1322 size: FPDF_DWORD,
1323 ) -> FPDF_RESULT,
1324 >,
1325 #[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."]
1326 pub WriteBlock: ::std::option::Option<
1327 unsafe extern "C" fn(
1328 clientData: *mut ::std::os::raw::c_void,
1329 offset: FPDF_DWORD,
1330 buffer: *const ::std::os::raw::c_void,
1331 size: FPDF_DWORD,
1332 ) -> FPDF_RESULT,
1333 >,
1334 #[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."]
1335 pub Flush: ::std::option::Option<
1336 unsafe extern "C" fn(clientData: *mut ::std::os::raw::c_void) -> FPDF_RESULT,
1337 >,
1338 #[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."]
1339 pub Truncate: ::std::option::Option<
1340 unsafe extern "C" fn(
1341 clientData: *mut ::std::os::raw::c_void,
1342 size: FPDF_DWORD,
1343 ) -> FPDF_RESULT,
1344 >,
1345}
1346#[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."]
1347pub type FPDF_FILEHANDLER = FPDF_FILEHANDLER_;
1348unsafe extern "C" {
1349 #[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."]
1350 pub fn FPDF_LoadCustomDocument(
1351 pFileAccess: *mut FPDF_FILEACCESS,
1352 password: FPDF_BYTESTRING,
1353 ) -> FPDF_DOCUMENT;
1354}
1355unsafe extern "C" {
1356 #[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."]
1357 pub fn FPDF_GetFileVersion(
1358 doc: FPDF_DOCUMENT,
1359 fileVersion: *mut ::std::os::raw::c_int,
1360 ) -> FPDF_BOOL;
1361}
1362unsafe extern "C" {
1363 #[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."]
1364 pub fn FPDF_GetLastError() -> ::std::os::raw::c_ulong;
1365}
1366unsafe extern "C" {
1367 #[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."]
1368 pub fn FPDF_DocumentHasValidCrossReferenceTable(document: FPDF_DOCUMENT) -> FPDF_BOOL;
1369}
1370unsafe extern "C" {
1371 #[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."]
1372 pub fn FPDF_GetTrailerEnds(
1373 document: FPDF_DOCUMENT,
1374 buffer: *mut ::std::os::raw::c_uint,
1375 length: ::std::os::raw::c_ulong,
1376 ) -> ::std::os::raw::c_ulong;
1377}
1378unsafe extern "C" {
1379 #[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."]
1380 pub fn FPDF_GetDocPermissions(document: FPDF_DOCUMENT) -> ::std::os::raw::c_ulong;
1381}
1382unsafe extern "C" {
1383 #[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."]
1384 pub fn FPDF_GetDocUserPermissions(document: FPDF_DOCUMENT) -> ::std::os::raw::c_ulong;
1385}
1386unsafe extern "C" {
1387 #[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."]
1388 pub fn FPDF_GetSecurityHandlerRevision(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1389}
1390unsafe extern "C" {
1391 #[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."]
1392 pub fn FPDF_GetPageCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1393}
1394unsafe extern "C" {
1395 #[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."]
1396 pub fn FPDF_LoadPage(document: FPDF_DOCUMENT, page_index: ::std::os::raw::c_int) -> FPDF_PAGE;
1397}
1398unsafe extern "C" {
1399 #[doc = " Experimental API\n Function: FPDF_GetPageWidthF\n Get page width.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage().\n Return value:\n Page width (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm).\n Comments:\n Changing the rotation of |page| affects the return value."]
1400 pub fn FPDF_GetPageWidthF(page: FPDF_PAGE) -> f32;
1401}
1402unsafe extern "C" {
1403 #[doc = " Function: FPDF_GetPageWidth\n Get page width.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n Return value:\n Page width (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm).\n Note:\n Prefer FPDF_GetPageWidthF() above. This will be deprecated in the\n future.\n Comments:\n Changing the rotation of |page| affects the return value."]
1404 pub fn FPDF_GetPageWidth(page: FPDF_PAGE) -> f64;
1405}
1406unsafe extern "C" {
1407 #[doc = " Experimental API\n Function: FPDF_GetPageHeightF\n Get page height.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage().\n Return value:\n Page height (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm)\n Comments:\n Changing the rotation of |page| affects the return value."]
1408 pub fn FPDF_GetPageHeightF(page: FPDF_PAGE) -> f32;
1409}
1410unsafe extern "C" {
1411 #[doc = " Function: FPDF_GetPageHeight\n Get page height.\n Parameters:\n page - Handle to the page. Returned by FPDF_LoadPage.\n Return value:\n Page height (excluding non-displayable area) measured in points.\n One point is 1/72 inch (around 0.3528 mm)\n Note:\n Prefer FPDF_GetPageHeightF() above. This will be deprecated in the\n future.\n Comments:\n Changing the rotation of |page| affects the return value."]
1412 pub fn FPDF_GetPageHeight(page: FPDF_PAGE) -> f64;
1413}
1414unsafe extern "C" {
1415 #[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."]
1416 pub fn FPDF_GetPageBoundingBox(page: FPDF_PAGE, rect: *mut FS_RECTF) -> FPDF_BOOL;
1417}
1418unsafe extern "C" {
1419 #[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)."]
1420 pub fn FPDF_GetPageSizeByIndexF(
1421 document: FPDF_DOCUMENT,
1422 page_index: ::std::os::raw::c_int,
1423 size: *mut FS_SIZEF,
1424 ) -> FPDF_BOOL;
1425}
1426unsafe extern "C" {
1427 #[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."]
1428 pub fn FPDF_GetPageSizeByIndex(
1429 document: FPDF_DOCUMENT,
1430 page_index: ::std::os::raw::c_int,
1431 width: *mut f64,
1432 height: *mut f64,
1433 ) -> ::std::os::raw::c_int;
1434}
1435#[doc = " Struct for color scheme.\n Each should be a 32-bit value specifying the color, in 8888 ARGB format."]
1436#[repr(C)]
1437#[derive(Debug, Copy, Clone)]
1438pub struct FPDF_COLORSCHEME_ {
1439 pub path_fill_color: FPDF_DWORD,
1440 pub path_stroke_color: FPDF_DWORD,
1441 pub text_fill_color: FPDF_DWORD,
1442 pub text_stroke_color: FPDF_DWORD,
1443}
1444#[doc = " Struct for color scheme.\n Each should be a 32-bit value specifying the color, in 8888 ARGB format."]
1445pub type FPDF_COLORSCHEME = FPDF_COLORSCHEME_;
1446unsafe extern "C" {
1447 #[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."]
1448 pub fn FPDF_RenderPageBitmap(
1449 bitmap: FPDF_BITMAP,
1450 page: FPDF_PAGE,
1451 start_x: ::std::os::raw::c_int,
1452 start_y: ::std::os::raw::c_int,
1453 size_x: ::std::os::raw::c_int,
1454 size_y: ::std::os::raw::c_int,
1455 rotate: ::std::os::raw::c_int,
1456 flags: ::std::os::raw::c_int,
1457 );
1458}
1459unsafe extern "C" {
1460 #[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."]
1461 pub fn FPDF_RenderPageBitmapWithMatrix(
1462 bitmap: FPDF_BITMAP,
1463 page: FPDF_PAGE,
1464 matrix: *const FS_MATRIX,
1465 clipping: *const FS_RECTF,
1466 flags: ::std::os::raw::c_int,
1467 );
1468}
1469unsafe extern "C" {
1470 #[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."]
1471 pub fn FPDF_RenderPageSkia(
1472 canvas: FPDF_SKIA_CANVAS,
1473 page: FPDF_PAGE,
1474 size_x: ::std::os::raw::c_int,
1475 size_y: ::std::os::raw::c_int,
1476 );
1477}
1478unsafe extern "C" {
1479 #[doc = " Function: FPDF_ClosePage\n Close a loaded PDF page.\n Parameters:\n page - Handle to the loaded page.\n Return value:\n None."]
1480 pub fn FPDF_ClosePage(page: FPDF_PAGE);
1481}
1482unsafe extern "C" {
1483 #[doc = " Function: FPDF_CloseDocument\n Close a loaded PDF document.\n Parameters:\n document - Handle to the loaded document.\n Return value:\n None."]
1484 pub fn FPDF_CloseDocument(document: FPDF_DOCUMENT);
1485}
1486unsafe extern "C" {
1487 #[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."]
1488 pub fn FPDF_DeviceToPage(
1489 page: FPDF_PAGE,
1490 start_x: ::std::os::raw::c_int,
1491 start_y: ::std::os::raw::c_int,
1492 size_x: ::std::os::raw::c_int,
1493 size_y: ::std::os::raw::c_int,
1494 rotate: ::std::os::raw::c_int,
1495 device_x: ::std::os::raw::c_int,
1496 device_y: ::std::os::raw::c_int,
1497 page_x: *mut f64,
1498 page_y: *mut f64,
1499 ) -> FPDF_BOOL;
1500}
1501unsafe extern "C" {
1502 #[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()."]
1503 pub fn FPDF_PageToDevice(
1504 page: FPDF_PAGE,
1505 start_x: ::std::os::raw::c_int,
1506 start_y: ::std::os::raw::c_int,
1507 size_x: ::std::os::raw::c_int,
1508 size_y: ::std::os::raw::c_int,
1509 rotate: ::std::os::raw::c_int,
1510 page_x: f64,
1511 page_y: f64,
1512 device_x: *mut ::std::os::raw::c_int,
1513 device_y: *mut ::std::os::raw::c_int,
1514 ) -> FPDF_BOOL;
1515}
1516unsafe extern "C" {
1517 #[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."]
1518 pub fn FPDFBitmap_Create(
1519 width: ::std::os::raw::c_int,
1520 height: ::std::os::raw::c_int,
1521 alpha: ::std::os::raw::c_int,
1522 ) -> FPDF_BITMAP;
1523}
1524unsafe extern "C" {
1525 #[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."]
1526 pub fn FPDFBitmap_CreateEx(
1527 width: ::std::os::raw::c_int,
1528 height: ::std::os::raw::c_int,
1529 format: ::std::os::raw::c_int,
1530 first_scan: *mut ::std::os::raw::c_void,
1531 stride: ::std::os::raw::c_int,
1532 ) -> FPDF_BITMAP;
1533}
1534unsafe extern "C" {
1535 #[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."]
1536 pub fn FPDFBitmap_GetFormat(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1537}
1538unsafe extern "C" {
1539 #[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."]
1540 pub fn FPDFBitmap_FillRect(
1541 bitmap: FPDF_BITMAP,
1542 left: ::std::os::raw::c_int,
1543 top: ::std::os::raw::c_int,
1544 width: ::std::os::raw::c_int,
1545 height: ::std::os::raw::c_int,
1546 color: FPDF_DWORD,
1547 ) -> FPDF_BOOL;
1548}
1549unsafe extern "C" {
1550 #[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."]
1551 pub fn FPDFBitmap_GetBuffer(bitmap: FPDF_BITMAP) -> *mut ::std::os::raw::c_void;
1552}
1553unsafe extern "C" {
1554 #[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."]
1555 pub fn FPDFBitmap_GetWidth(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1556}
1557unsafe extern "C" {
1558 #[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."]
1559 pub fn FPDFBitmap_GetHeight(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1560}
1561unsafe extern "C" {
1562 #[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."]
1563 pub fn FPDFBitmap_GetStride(bitmap: FPDF_BITMAP) -> ::std::os::raw::c_int;
1564}
1565unsafe extern "C" {
1566 #[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."]
1567 pub fn FPDFBitmap_Destroy(bitmap: FPDF_BITMAP);
1568}
1569unsafe extern "C" {
1570 #[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."]
1571 pub fn FPDF_VIEWERREF_GetPrintScaling(document: FPDF_DOCUMENT) -> FPDF_BOOL;
1572}
1573unsafe extern "C" {
1574 #[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."]
1575 pub fn FPDF_VIEWERREF_GetNumCopies(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1576}
1577unsafe extern "C" {
1578 #[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."]
1579 pub fn FPDF_VIEWERREF_GetPrintPageRange(document: FPDF_DOCUMENT) -> FPDF_PAGERANGE;
1580}
1581unsafe extern "C" {
1582 #[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."]
1583 pub fn FPDF_VIEWERREF_GetPrintPageRangeCount(pagerange: FPDF_PAGERANGE) -> usize;
1584}
1585unsafe extern "C" {
1586 #[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."]
1587 pub fn FPDF_VIEWERREF_GetPrintPageRangeElement(
1588 pagerange: FPDF_PAGERANGE,
1589 index: usize,
1590 ) -> ::std::os::raw::c_int;
1591}
1592unsafe extern "C" {
1593 #[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."]
1594 pub fn FPDF_VIEWERREF_GetDuplex(document: FPDF_DOCUMENT) -> FPDF_DUPLEXTYPE;
1595}
1596unsafe extern "C" {
1597 #[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."]
1598 pub fn FPDF_VIEWERREF_GetName(
1599 document: FPDF_DOCUMENT,
1600 key: FPDF_BYTESTRING,
1601 buffer: *mut ::std::os::raw::c_char,
1602 length: ::std::os::raw::c_ulong,
1603 ) -> ::std::os::raw::c_ulong;
1604}
1605unsafe extern "C" {
1606 #[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."]
1607 pub fn FPDF_CountNamedDests(document: FPDF_DOCUMENT) -> FPDF_DWORD;
1608}
1609unsafe extern "C" {
1610 #[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."]
1611 pub fn FPDF_GetNamedDestByName(document: FPDF_DOCUMENT, name: FPDF_BYTESTRING) -> FPDF_DEST;
1612}
1613unsafe extern "C" {
1614 #[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."]
1615 pub fn FPDF_GetNamedDest(
1616 document: FPDF_DOCUMENT,
1617 index: ::std::os::raw::c_int,
1618 buffer: *mut ::std::os::raw::c_void,
1619 buflen: *mut ::std::os::raw::c_long,
1620 ) -> FPDF_DEST;
1621}
1622unsafe extern "C" {
1623 #[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."]
1624 pub fn FPDF_GetXFAPacketCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1625}
1626unsafe extern "C" {
1627 #[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."]
1628 pub fn FPDF_GetXFAPacketName(
1629 document: FPDF_DOCUMENT,
1630 index: ::std::os::raw::c_int,
1631 buffer: *mut ::std::os::raw::c_void,
1632 buflen: ::std::os::raw::c_ulong,
1633 ) -> ::std::os::raw::c_ulong;
1634}
1635unsafe extern "C" {
1636 #[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|."]
1637 pub fn FPDF_GetXFAPacketContent(
1638 document: FPDF_DOCUMENT,
1639 index: ::std::os::raw::c_int,
1640 buffer: *mut ::std::os::raw::c_void,
1641 buflen: ::std::os::raw::c_ulong,
1642 out_buflen: *mut ::std::os::raw::c_ulong,
1643 ) -> FPDF_BOOL;
1644}
1645unsafe extern "C" {
1646 #[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."]
1647 pub fn FPDF_GetRecommendedV8Flags() -> *const ::std::os::raw::c_char;
1648}
1649unsafe extern "C" {
1650 #[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."]
1651 pub fn FPDF_GetArrayBufferAllocatorSharedInstance() -> *mut ::std::os::raw::c_void;
1652}
1653unsafe extern "C" {
1654 #[doc = " Function: FPDF_BStr_Init\n Helper function to initialize a FPDF_BSTR."]
1655 pub fn FPDF_BStr_Init(bstr: *mut FPDF_BSTR) -> FPDF_RESULT;
1656}
1657unsafe extern "C" {
1658 #[doc = " Function: FPDF_BStr_Set\n Helper function to copy string data into the FPDF_BSTR."]
1659 pub fn FPDF_BStr_Set(
1660 bstr: *mut FPDF_BSTR,
1661 cstr: *const ::std::os::raw::c_char,
1662 length: ::std::os::raw::c_int,
1663 ) -> FPDF_RESULT;
1664}
1665unsafe extern "C" {
1666 #[doc = " Function: FPDF_BStr_Clear\n Helper function to clear a FPDF_BSTR."]
1667 pub fn FPDF_BStr_Clear(bstr: *mut FPDF_BSTR) -> FPDF_RESULT;
1668}
1669#[doc = " Interface for unsupported feature notifications."]
1670#[repr(C)]
1671#[derive(Debug, Copy, Clone)]
1672pub struct _UNSUPPORT_INFO {
1673 #[doc = " Version number of the interface. Must be 1."]
1674 pub version: ::std::os::raw::c_int,
1675 #[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."]
1676 pub FSDK_UnSupport_Handler: ::std::option::Option<
1677 unsafe extern "C" fn(pThis: *mut _UNSUPPORT_INFO, nType: ::std::os::raw::c_int),
1678 >,
1679}
1680#[doc = " Interface for unsupported feature notifications."]
1681pub type UNSUPPORT_INFO = _UNSUPPORT_INFO;
1682unsafe extern "C" {
1683 #[doc = " Setup an unsupported object handler.\n\n unsp_info - Pointer to an UNSUPPORT_INFO structure.\n\n Returns TRUE on success."]
1684 pub fn FSDK_SetUnSpObjProcessHandler(unsp_info: *mut UNSUPPORT_INFO) -> FPDF_BOOL;
1685}
1686unsafe extern "C" {
1687 #[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."]
1688 pub fn FSDK_SetTimeFunction(func: ::std::option::Option<unsafe extern "C" fn() -> time_t>);
1689}
1690unsafe extern "C" {
1691 #[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."]
1692 pub fn FSDK_SetLocaltimeFunction(
1693 func: ::std::option::Option<unsafe extern "C" fn(arg1: *const time_t) -> *mut tm>,
1694 );
1695}
1696unsafe extern "C" {
1697 #[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."]
1698 pub fn FPDFDoc_GetPageMode(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
1699}
1700pub const FPDF_FILEIDTYPE_FILEIDTYPE_PERMANENT: FPDF_FILEIDTYPE = 0;
1701pub const FPDF_FILEIDTYPE_FILEIDTYPE_CHANGING: FPDF_FILEIDTYPE = 1;
1702#[doc = " The file identifier entry type. See section 14.4 \"File Identifiers\" of the\n ISO 32000-1:2008 spec."]
1703pub type FPDF_FILEIDTYPE = ::std::os::raw::c_uint;
1704unsafe extern "C" {
1705 #[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."]
1706 pub fn FPDFBookmark_GetFirstChild(
1707 document: FPDF_DOCUMENT,
1708 bookmark: FPDF_BOOKMARK,
1709 ) -> FPDF_BOOKMARK;
1710}
1711unsafe extern "C" {
1712 #[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."]
1713 pub fn FPDFBookmark_GetNextSibling(
1714 document: FPDF_DOCUMENT,
1715 bookmark: FPDF_BOOKMARK,
1716 ) -> FPDF_BOOKMARK;
1717}
1718unsafe extern "C" {
1719 #[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."]
1720 pub fn FPDFBookmark_GetTitle(
1721 bookmark: FPDF_BOOKMARK,
1722 buffer: *mut ::std::os::raw::c_void,
1723 buflen: ::std::os::raw::c_ulong,
1724 ) -> ::std::os::raw::c_ulong;
1725}
1726unsafe extern "C" {
1727 #[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."]
1728 pub fn FPDFBookmark_GetCount(bookmark: FPDF_BOOKMARK) -> ::std::os::raw::c_int;
1729}
1730unsafe extern "C" {
1731 #[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|."]
1732 pub fn FPDFBookmark_Find(document: FPDF_DOCUMENT, title: FPDF_WIDESTRING) -> FPDF_BOOKMARK;
1733}
1734unsafe extern "C" {
1735 #[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|."]
1736 pub fn FPDFBookmark_GetDest(document: FPDF_DOCUMENT, bookmark: FPDF_BOOKMARK) -> FPDF_DEST;
1737}
1738unsafe extern "C" {
1739 #[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."]
1740 pub fn FPDFBookmark_GetAction(bookmark: FPDF_BOOKMARK) -> FPDF_ACTION;
1741}
1742unsafe extern "C" {
1743 #[doc = " Experimental API.\n Get the color of a bookmark.\n\n bookmark - handle to a bookmark.\n R - pointer to a float to receive the red component [0.0 - 1.0].\n G - pointer to a float to receive the green component [0.0 - 1.0].\n B - pointer to a float to receive the blue component [0.0 - 1.0].\n\n Returns TRUE on success, in which case |R|, |G|, and |B| are updated.\n Returns FALSE on failure, if the bookmark is invalid, output for R, G and B\n aren't in the range or if the bookmark does not specify a color."]
1744 pub fn FPDFBookmark_GetColor(
1745 bookmark: FPDF_BOOKMARK,
1746 R: *mut c_float,
1747 G: *mut c_float,
1748 B: *mut c_float,
1749 ) -> FPDF_BOOL;
1750}
1751unsafe extern "C" {
1752 #[doc = " Experimental API.\n Get the text style of a bookmark.\n\n bookmark - handle to a bookmark.\n\n Returns the style as an integer, in line with ISO 32000-1:2008 Table 154.\n The first bit is used to represent if the text is italic and the second\n bit is used to represent if the text is bold. Returns 0 if the bookmark\n doesn't have styling or if the handle is invalid. Parsing this value to\n apply styles remains the responsibility of the embedder."]
1753 pub fn FPDFBookmark_GetStyle(bookmark: FPDF_BOOKMARK) -> ::std::os::raw::c_int;
1754}
1755unsafe extern "C" {
1756 #[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"]
1757 pub fn FPDFAction_GetType(action: FPDF_ACTION) -> ::std::os::raw::c_ulong;
1758}
1759unsafe extern "C" {
1760 #[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()."]
1761 pub fn FPDFAction_GetDest(document: FPDF_DOCUMENT, action: FPDF_ACTION) -> FPDF_DEST;
1762}
1763unsafe extern "C" {
1764 #[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."]
1765 pub fn FPDFAction_GetFilePath(
1766 action: FPDF_ACTION,
1767 buffer: *mut ::std::os::raw::c_void,
1768 buflen: ::std::os::raw::c_ulong,
1769 ) -> ::std::os::raw::c_ulong;
1770}
1771unsafe extern "C" {
1772 #[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."]
1773 pub fn FPDFAction_GetURIPath(
1774 document: FPDF_DOCUMENT,
1775 action: FPDF_ACTION,
1776 buffer: *mut ::std::os::raw::c_void,
1777 buflen: ::std::os::raw::c_ulong,
1778 ) -> ::std::os::raw::c_ulong;
1779}
1780unsafe extern "C" {
1781 #[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."]
1782 pub fn FPDFDest_GetDestPageIndex(
1783 document: FPDF_DOCUMENT,
1784 dest: FPDF_DEST,
1785 ) -> ::std::os::raw::c_int;
1786}
1787unsafe extern "C" {
1788 #[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."]
1789 pub fn FPDFDest_GetView(
1790 dest: FPDF_DEST,
1791 pNumParams: *mut ::std::os::raw::c_ulong,
1792 pParams: *mut FS_FLOAT,
1793 ) -> ::std::os::raw::c_ulong;
1794}
1795unsafe extern "C" {
1796 #[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."]
1797 pub fn FPDFDest_GetLocationInPage(
1798 dest: FPDF_DEST,
1799 hasXVal: *mut FPDF_BOOL,
1800 hasYVal: *mut FPDF_BOOL,
1801 hasZoomVal: *mut FPDF_BOOL,
1802 x: *mut FS_FLOAT,
1803 y: *mut FS_FLOAT,
1804 zoom: *mut FS_FLOAT,
1805 ) -> FPDF_BOOL;
1806}
1807unsafe extern "C" {
1808 #[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()."]
1809 pub fn FPDFLink_GetLinkAtPoint(page: FPDF_PAGE, x: f64, y: f64) -> FPDF_LINK;
1810}
1811unsafe extern "C" {
1812 #[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()."]
1813 pub fn FPDFLink_GetLinkZOrderAtPoint(page: FPDF_PAGE, x: f64, y: f64) -> ::std::os::raw::c_int;
1814}
1815unsafe extern "C" {
1816 #[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|."]
1817 pub fn FPDFLink_GetDest(document: FPDF_DOCUMENT, link: FPDF_LINK) -> FPDF_DEST;
1818}
1819unsafe extern "C" {
1820 #[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."]
1821 pub fn FPDFLink_GetAction(link: FPDF_LINK) -> FPDF_ACTION;
1822}
1823unsafe extern "C" {
1824 #[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."]
1825 pub fn FPDFLink_Enumerate(
1826 page: FPDF_PAGE,
1827 start_pos: *mut ::std::os::raw::c_int,
1828 link_annot: *mut FPDF_LINK,
1829 ) -> FPDF_BOOL;
1830}
1831unsafe extern "C" {
1832 #[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."]
1833 pub fn FPDFLink_GetAnnot(page: FPDF_PAGE, link_annot: FPDF_LINK) -> FPDF_ANNOTATION;
1834}
1835unsafe extern "C" {
1836 #[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."]
1837 pub fn FPDFLink_GetAnnotRect(link_annot: FPDF_LINK, rect: *mut FS_RECTF) -> FPDF_BOOL;
1838}
1839unsafe extern "C" {
1840 #[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."]
1841 pub fn FPDFLink_CountQuadPoints(link_annot: FPDF_LINK) -> ::std::os::raw::c_int;
1842}
1843unsafe extern "C" {
1844 #[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."]
1845 pub fn FPDFLink_GetQuadPoints(
1846 link_annot: FPDF_LINK,
1847 quad_index: ::std::os::raw::c_int,
1848 quad_points: *mut FS_QUADPOINTSF,
1849 ) -> FPDF_BOOL;
1850}
1851unsafe extern "C" {
1852 #[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."]
1853 pub fn FPDF_GetPageAAction(page: FPDF_PAGE, aa_type: ::std::os::raw::c_int) -> FPDF_ACTION;
1854}
1855unsafe extern "C" {
1856 #[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."]
1857 pub fn FPDF_GetFileIdentifier(
1858 document: FPDF_DOCUMENT,
1859 id_type: FPDF_FILEIDTYPE,
1860 buffer: *mut ::std::os::raw::c_void,
1861 buflen: ::std::os::raw::c_ulong,
1862 ) -> ::std::os::raw::c_ulong;
1863}
1864unsafe extern "C" {
1865 #[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, on success.\n Returns 0 if |document| or |tag| is NULL. Returns 0 if |document| does not\n have an /Info dictionary. Returns 2 for an empty string if |tag| is not in\n the /Info dictionary,\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."]
1866 pub fn FPDF_GetMetaText(
1867 document: FPDF_DOCUMENT,
1868 tag: FPDF_BYTESTRING,
1869 buffer: *mut ::std::os::raw::c_void,
1870 buflen: ::std::os::raw::c_ulong,
1871 ) -> ::std::os::raw::c_ulong;
1872}
1873unsafe extern "C" {
1874 #[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."]
1875 pub fn FPDF_GetPageLabel(
1876 document: FPDF_DOCUMENT,
1877 page_index: ::std::os::raw::c_int,
1878 buffer: *mut ::std::os::raw::c_void,
1879 buflen: ::std::os::raw::c_ulong,
1880 ) -> ::std::os::raw::c_ulong;
1881}
1882unsafe extern "C" {
1883 #[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."]
1884 pub fn FPDF_ImportPagesByIndex(
1885 dest_doc: FPDF_DOCUMENT,
1886 src_doc: FPDF_DOCUMENT,
1887 page_indices: *const ::std::os::raw::c_int,
1888 length: ::std::os::raw::c_ulong,
1889 index: ::std::os::raw::c_int,
1890 ) -> FPDF_BOOL;
1891}
1892unsafe extern "C" {
1893 #[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."]
1894 pub fn FPDF_ImportPages(
1895 dest_doc: FPDF_DOCUMENT,
1896 src_doc: FPDF_DOCUMENT,
1897 pagerange: FPDF_BYTESTRING,
1898 index: ::std::os::raw::c_int,
1899 ) -> FPDF_BOOL;
1900}
1901unsafe extern "C" {
1902 #[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"]
1903 pub fn FPDF_ImportNPagesToOne(
1904 src_doc: FPDF_DOCUMENT,
1905 output_width: f32,
1906 output_height: f32,
1907 num_pages_on_x_axis: usize,
1908 num_pages_on_y_axis: usize,
1909 ) -> FPDF_DOCUMENT;
1910}
1911unsafe extern "C" {
1912 #[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. The returned handle's lifetime is tied to |dest_doc| and not\n |src_doc|. It must be closed before |dest_doc|."]
1913 pub fn FPDF_NewXObjectFromPage(
1914 dest_doc: FPDF_DOCUMENT,
1915 src_doc: FPDF_DOCUMENT,
1916 src_page_index: ::std::os::raw::c_int,
1917 ) -> FPDF_XOBJECT;
1918}
1919unsafe extern "C" {
1920 #[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."]
1921 pub fn FPDF_CloseXObject(xobject: FPDF_XOBJECT);
1922}
1923unsafe extern "C" {
1924 #[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."]
1925 pub fn FPDF_NewFormObjectFromXObject(xobject: FPDF_XOBJECT) -> FPDF_PAGEOBJECT;
1926}
1927unsafe extern "C" {
1928 #[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."]
1929 pub fn FPDF_CopyViewerPreferences(dest_doc: FPDF_DOCUMENT, src_doc: FPDF_DOCUMENT)
1930 -> FPDF_BOOL;
1931}
1932pub const FWL_EVENTFLAG_FWL_EVENTFLAG_ShiftKey: FWL_EVENTFLAG = 1;
1933pub const FWL_EVENTFLAG_FWL_EVENTFLAG_ControlKey: FWL_EVENTFLAG = 2;
1934pub const FWL_EVENTFLAG_FWL_EVENTFLAG_AltKey: FWL_EVENTFLAG = 4;
1935pub const FWL_EVENTFLAG_FWL_EVENTFLAG_MetaKey: FWL_EVENTFLAG = 8;
1936pub const FWL_EVENTFLAG_FWL_EVENTFLAG_KeyPad: FWL_EVENTFLAG = 16;
1937pub const FWL_EVENTFLAG_FWL_EVENTFLAG_AutoRepeat: FWL_EVENTFLAG = 32;
1938pub const FWL_EVENTFLAG_FWL_EVENTFLAG_LeftButtonDown: FWL_EVENTFLAG = 64;
1939pub const FWL_EVENTFLAG_FWL_EVENTFLAG_MiddleButtonDown: FWL_EVENTFLAG = 128;
1940pub const FWL_EVENTFLAG_FWL_EVENTFLAG_RightButtonDown: FWL_EVENTFLAG = 256;
1941#[doc = " Key flags."]
1942pub type FWL_EVENTFLAG = ::std::os::raw::c_uint;
1943pub const FWL_VKEYCODE_FWL_VKEY_Back: FWL_VKEYCODE = 8;
1944pub const FWL_VKEYCODE_FWL_VKEY_Tab: FWL_VKEYCODE = 9;
1945pub const FWL_VKEYCODE_FWL_VKEY_NewLine: FWL_VKEYCODE = 10;
1946pub const FWL_VKEYCODE_FWL_VKEY_Clear: FWL_VKEYCODE = 12;
1947pub const FWL_VKEYCODE_FWL_VKEY_Return: FWL_VKEYCODE = 13;
1948pub const FWL_VKEYCODE_FWL_VKEY_Shift: FWL_VKEYCODE = 16;
1949pub const FWL_VKEYCODE_FWL_VKEY_Control: FWL_VKEYCODE = 17;
1950pub const FWL_VKEYCODE_FWL_VKEY_Menu: FWL_VKEYCODE = 18;
1951pub const FWL_VKEYCODE_FWL_VKEY_Pause: FWL_VKEYCODE = 19;
1952pub const FWL_VKEYCODE_FWL_VKEY_Capital: FWL_VKEYCODE = 20;
1953pub const FWL_VKEYCODE_FWL_VKEY_Kana: FWL_VKEYCODE = 21;
1954pub const FWL_VKEYCODE_FWL_VKEY_Hangul: FWL_VKEYCODE = 21;
1955pub const FWL_VKEYCODE_FWL_VKEY_Junja: FWL_VKEYCODE = 23;
1956pub const FWL_VKEYCODE_FWL_VKEY_Final: FWL_VKEYCODE = 24;
1957pub const FWL_VKEYCODE_FWL_VKEY_Hanja: FWL_VKEYCODE = 25;
1958pub const FWL_VKEYCODE_FWL_VKEY_Kanji: FWL_VKEYCODE = 25;
1959pub const FWL_VKEYCODE_FWL_VKEY_Escape: FWL_VKEYCODE = 27;
1960pub const FWL_VKEYCODE_FWL_VKEY_Convert: FWL_VKEYCODE = 28;
1961pub const FWL_VKEYCODE_FWL_VKEY_NonConvert: FWL_VKEYCODE = 29;
1962pub const FWL_VKEYCODE_FWL_VKEY_Accept: FWL_VKEYCODE = 30;
1963pub const FWL_VKEYCODE_FWL_VKEY_ModeChange: FWL_VKEYCODE = 31;
1964pub const FWL_VKEYCODE_FWL_VKEY_Space: FWL_VKEYCODE = 32;
1965pub const FWL_VKEYCODE_FWL_VKEY_Prior: FWL_VKEYCODE = 33;
1966pub const FWL_VKEYCODE_FWL_VKEY_Next: FWL_VKEYCODE = 34;
1967pub const FWL_VKEYCODE_FWL_VKEY_End: FWL_VKEYCODE = 35;
1968pub const FWL_VKEYCODE_FWL_VKEY_Home: FWL_VKEYCODE = 36;
1969pub const FWL_VKEYCODE_FWL_VKEY_Left: FWL_VKEYCODE = 37;
1970pub const FWL_VKEYCODE_FWL_VKEY_Up: FWL_VKEYCODE = 38;
1971pub const FWL_VKEYCODE_FWL_VKEY_Right: FWL_VKEYCODE = 39;
1972pub const FWL_VKEYCODE_FWL_VKEY_Down: FWL_VKEYCODE = 40;
1973pub const FWL_VKEYCODE_FWL_VKEY_Select: FWL_VKEYCODE = 41;
1974pub const FWL_VKEYCODE_FWL_VKEY_Print: FWL_VKEYCODE = 42;
1975pub const FWL_VKEYCODE_FWL_VKEY_Execute: FWL_VKEYCODE = 43;
1976pub const FWL_VKEYCODE_FWL_VKEY_Snapshot: FWL_VKEYCODE = 44;
1977pub const FWL_VKEYCODE_FWL_VKEY_Insert: FWL_VKEYCODE = 45;
1978pub const FWL_VKEYCODE_FWL_VKEY_Delete: FWL_VKEYCODE = 46;
1979pub const FWL_VKEYCODE_FWL_VKEY_Help: FWL_VKEYCODE = 47;
1980pub const FWL_VKEYCODE_FWL_VKEY_0: FWL_VKEYCODE = 48;
1981pub const FWL_VKEYCODE_FWL_VKEY_1: FWL_VKEYCODE = 49;
1982pub const FWL_VKEYCODE_FWL_VKEY_2: FWL_VKEYCODE = 50;
1983pub const FWL_VKEYCODE_FWL_VKEY_3: FWL_VKEYCODE = 51;
1984pub const FWL_VKEYCODE_FWL_VKEY_4: FWL_VKEYCODE = 52;
1985pub const FWL_VKEYCODE_FWL_VKEY_5: FWL_VKEYCODE = 53;
1986pub const FWL_VKEYCODE_FWL_VKEY_6: FWL_VKEYCODE = 54;
1987pub const FWL_VKEYCODE_FWL_VKEY_7: FWL_VKEYCODE = 55;
1988pub const FWL_VKEYCODE_FWL_VKEY_8: FWL_VKEYCODE = 56;
1989pub const FWL_VKEYCODE_FWL_VKEY_9: FWL_VKEYCODE = 57;
1990pub const FWL_VKEYCODE_FWL_VKEY_A: FWL_VKEYCODE = 65;
1991pub const FWL_VKEYCODE_FWL_VKEY_B: FWL_VKEYCODE = 66;
1992pub const FWL_VKEYCODE_FWL_VKEY_C: FWL_VKEYCODE = 67;
1993pub const FWL_VKEYCODE_FWL_VKEY_D: FWL_VKEYCODE = 68;
1994pub const FWL_VKEYCODE_FWL_VKEY_E: FWL_VKEYCODE = 69;
1995pub const FWL_VKEYCODE_FWL_VKEY_F: FWL_VKEYCODE = 70;
1996pub const FWL_VKEYCODE_FWL_VKEY_G: FWL_VKEYCODE = 71;
1997pub const FWL_VKEYCODE_FWL_VKEY_H: FWL_VKEYCODE = 72;
1998pub const FWL_VKEYCODE_FWL_VKEY_I: FWL_VKEYCODE = 73;
1999pub const FWL_VKEYCODE_FWL_VKEY_J: FWL_VKEYCODE = 74;
2000pub const FWL_VKEYCODE_FWL_VKEY_K: FWL_VKEYCODE = 75;
2001pub const FWL_VKEYCODE_FWL_VKEY_L: FWL_VKEYCODE = 76;
2002pub const FWL_VKEYCODE_FWL_VKEY_M: FWL_VKEYCODE = 77;
2003pub const FWL_VKEYCODE_FWL_VKEY_N: FWL_VKEYCODE = 78;
2004pub const FWL_VKEYCODE_FWL_VKEY_O: FWL_VKEYCODE = 79;
2005pub const FWL_VKEYCODE_FWL_VKEY_P: FWL_VKEYCODE = 80;
2006pub const FWL_VKEYCODE_FWL_VKEY_Q: FWL_VKEYCODE = 81;
2007pub const FWL_VKEYCODE_FWL_VKEY_R: FWL_VKEYCODE = 82;
2008pub const FWL_VKEYCODE_FWL_VKEY_S: FWL_VKEYCODE = 83;
2009pub const FWL_VKEYCODE_FWL_VKEY_T: FWL_VKEYCODE = 84;
2010pub const FWL_VKEYCODE_FWL_VKEY_U: FWL_VKEYCODE = 85;
2011pub const FWL_VKEYCODE_FWL_VKEY_V: FWL_VKEYCODE = 86;
2012pub const FWL_VKEYCODE_FWL_VKEY_W: FWL_VKEYCODE = 87;
2013pub const FWL_VKEYCODE_FWL_VKEY_X: FWL_VKEYCODE = 88;
2014pub const FWL_VKEYCODE_FWL_VKEY_Y: FWL_VKEYCODE = 89;
2015pub const FWL_VKEYCODE_FWL_VKEY_Z: FWL_VKEYCODE = 90;
2016pub const FWL_VKEYCODE_FWL_VKEY_LWin: FWL_VKEYCODE = 91;
2017pub const FWL_VKEYCODE_FWL_VKEY_Command: FWL_VKEYCODE = 91;
2018pub const FWL_VKEYCODE_FWL_VKEY_RWin: FWL_VKEYCODE = 92;
2019pub const FWL_VKEYCODE_FWL_VKEY_Apps: FWL_VKEYCODE = 93;
2020pub const FWL_VKEYCODE_FWL_VKEY_Sleep: FWL_VKEYCODE = 95;
2021pub const FWL_VKEYCODE_FWL_VKEY_NumPad0: FWL_VKEYCODE = 96;
2022pub const FWL_VKEYCODE_FWL_VKEY_NumPad1: FWL_VKEYCODE = 97;
2023pub const FWL_VKEYCODE_FWL_VKEY_NumPad2: FWL_VKEYCODE = 98;
2024pub const FWL_VKEYCODE_FWL_VKEY_NumPad3: FWL_VKEYCODE = 99;
2025pub const FWL_VKEYCODE_FWL_VKEY_NumPad4: FWL_VKEYCODE = 100;
2026pub const FWL_VKEYCODE_FWL_VKEY_NumPad5: FWL_VKEYCODE = 101;
2027pub const FWL_VKEYCODE_FWL_VKEY_NumPad6: FWL_VKEYCODE = 102;
2028pub const FWL_VKEYCODE_FWL_VKEY_NumPad7: FWL_VKEYCODE = 103;
2029pub const FWL_VKEYCODE_FWL_VKEY_NumPad8: FWL_VKEYCODE = 104;
2030pub const FWL_VKEYCODE_FWL_VKEY_NumPad9: FWL_VKEYCODE = 105;
2031pub const FWL_VKEYCODE_FWL_VKEY_Multiply: FWL_VKEYCODE = 106;
2032pub const FWL_VKEYCODE_FWL_VKEY_Add: FWL_VKEYCODE = 107;
2033pub const FWL_VKEYCODE_FWL_VKEY_Separator: FWL_VKEYCODE = 108;
2034pub const FWL_VKEYCODE_FWL_VKEY_Subtract: FWL_VKEYCODE = 109;
2035pub const FWL_VKEYCODE_FWL_VKEY_Decimal: FWL_VKEYCODE = 110;
2036pub const FWL_VKEYCODE_FWL_VKEY_Divide: FWL_VKEYCODE = 111;
2037pub const FWL_VKEYCODE_FWL_VKEY_F1: FWL_VKEYCODE = 112;
2038pub const FWL_VKEYCODE_FWL_VKEY_F2: FWL_VKEYCODE = 113;
2039pub const FWL_VKEYCODE_FWL_VKEY_F3: FWL_VKEYCODE = 114;
2040pub const FWL_VKEYCODE_FWL_VKEY_F4: FWL_VKEYCODE = 115;
2041pub const FWL_VKEYCODE_FWL_VKEY_F5: FWL_VKEYCODE = 116;
2042pub const FWL_VKEYCODE_FWL_VKEY_F6: FWL_VKEYCODE = 117;
2043pub const FWL_VKEYCODE_FWL_VKEY_F7: FWL_VKEYCODE = 118;
2044pub const FWL_VKEYCODE_FWL_VKEY_F8: FWL_VKEYCODE = 119;
2045pub const FWL_VKEYCODE_FWL_VKEY_F9: FWL_VKEYCODE = 120;
2046pub const FWL_VKEYCODE_FWL_VKEY_F10: FWL_VKEYCODE = 121;
2047pub const FWL_VKEYCODE_FWL_VKEY_F11: FWL_VKEYCODE = 122;
2048pub const FWL_VKEYCODE_FWL_VKEY_F12: FWL_VKEYCODE = 123;
2049pub const FWL_VKEYCODE_FWL_VKEY_F13: FWL_VKEYCODE = 124;
2050pub const FWL_VKEYCODE_FWL_VKEY_F14: FWL_VKEYCODE = 125;
2051pub const FWL_VKEYCODE_FWL_VKEY_F15: FWL_VKEYCODE = 126;
2052pub const FWL_VKEYCODE_FWL_VKEY_F16: FWL_VKEYCODE = 127;
2053pub const FWL_VKEYCODE_FWL_VKEY_F17: FWL_VKEYCODE = 128;
2054pub const FWL_VKEYCODE_FWL_VKEY_F18: FWL_VKEYCODE = 129;
2055pub const FWL_VKEYCODE_FWL_VKEY_F19: FWL_VKEYCODE = 130;
2056pub const FWL_VKEYCODE_FWL_VKEY_F20: FWL_VKEYCODE = 131;
2057pub const FWL_VKEYCODE_FWL_VKEY_F21: FWL_VKEYCODE = 132;
2058pub const FWL_VKEYCODE_FWL_VKEY_F22: FWL_VKEYCODE = 133;
2059pub const FWL_VKEYCODE_FWL_VKEY_F23: FWL_VKEYCODE = 134;
2060pub const FWL_VKEYCODE_FWL_VKEY_F24: FWL_VKEYCODE = 135;
2061pub const FWL_VKEYCODE_FWL_VKEY_NunLock: FWL_VKEYCODE = 144;
2062pub const FWL_VKEYCODE_FWL_VKEY_Scroll: FWL_VKEYCODE = 145;
2063pub const FWL_VKEYCODE_FWL_VKEY_LShift: FWL_VKEYCODE = 160;
2064pub const FWL_VKEYCODE_FWL_VKEY_RShift: FWL_VKEYCODE = 161;
2065pub const FWL_VKEYCODE_FWL_VKEY_LControl: FWL_VKEYCODE = 162;
2066pub const FWL_VKEYCODE_FWL_VKEY_RControl: FWL_VKEYCODE = 163;
2067pub const FWL_VKEYCODE_FWL_VKEY_LMenu: FWL_VKEYCODE = 164;
2068pub const FWL_VKEYCODE_FWL_VKEY_RMenu: FWL_VKEYCODE = 165;
2069pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Back: FWL_VKEYCODE = 166;
2070pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Forward: FWL_VKEYCODE = 167;
2071pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Refresh: FWL_VKEYCODE = 168;
2072pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Stop: FWL_VKEYCODE = 169;
2073pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Search: FWL_VKEYCODE = 170;
2074pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Favorites: FWL_VKEYCODE = 171;
2075pub const FWL_VKEYCODE_FWL_VKEY_BROWSER_Home: FWL_VKEYCODE = 172;
2076pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Mute: FWL_VKEYCODE = 173;
2077pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Down: FWL_VKEYCODE = 174;
2078pub const FWL_VKEYCODE_FWL_VKEY_VOLUME_Up: FWL_VKEYCODE = 175;
2079pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_NEXT_Track: FWL_VKEYCODE = 176;
2080pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_PREV_Track: FWL_VKEYCODE = 177;
2081pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_Stop: FWL_VKEYCODE = 178;
2082pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_PLAY_Pause: FWL_VKEYCODE = 179;
2083pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_Mail: FWL_VKEYCODE = 180;
2084pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_MEDIA_Select: FWL_VKEYCODE = 181;
2085pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_APP1: FWL_VKEYCODE = 182;
2086pub const FWL_VKEYCODE_FWL_VKEY_MEDIA_LAUNCH_APP2: FWL_VKEYCODE = 183;
2087pub const FWL_VKEYCODE_FWL_VKEY_OEM_1: FWL_VKEYCODE = 186;
2088pub const FWL_VKEYCODE_FWL_VKEY_OEM_Plus: FWL_VKEYCODE = 187;
2089pub const FWL_VKEYCODE_FWL_VKEY_OEM_Comma: FWL_VKEYCODE = 188;
2090pub const FWL_VKEYCODE_FWL_VKEY_OEM_Minus: FWL_VKEYCODE = 189;
2091pub const FWL_VKEYCODE_FWL_VKEY_OEM_Period: FWL_VKEYCODE = 190;
2092pub const FWL_VKEYCODE_FWL_VKEY_OEM_2: FWL_VKEYCODE = 191;
2093pub const FWL_VKEYCODE_FWL_VKEY_OEM_3: FWL_VKEYCODE = 192;
2094pub const FWL_VKEYCODE_FWL_VKEY_OEM_4: FWL_VKEYCODE = 219;
2095pub const FWL_VKEYCODE_FWL_VKEY_OEM_5: FWL_VKEYCODE = 220;
2096pub const FWL_VKEYCODE_FWL_VKEY_OEM_6: FWL_VKEYCODE = 221;
2097pub const FWL_VKEYCODE_FWL_VKEY_OEM_7: FWL_VKEYCODE = 222;
2098pub const FWL_VKEYCODE_FWL_VKEY_OEM_8: FWL_VKEYCODE = 223;
2099pub const FWL_VKEYCODE_FWL_VKEY_OEM_102: FWL_VKEYCODE = 226;
2100pub const FWL_VKEYCODE_FWL_VKEY_ProcessKey: FWL_VKEYCODE = 229;
2101pub const FWL_VKEYCODE_FWL_VKEY_Packet: FWL_VKEYCODE = 231;
2102pub const FWL_VKEYCODE_FWL_VKEY_Attn: FWL_VKEYCODE = 246;
2103pub const FWL_VKEYCODE_FWL_VKEY_Crsel: FWL_VKEYCODE = 247;
2104pub const FWL_VKEYCODE_FWL_VKEY_Exsel: FWL_VKEYCODE = 248;
2105pub const FWL_VKEYCODE_FWL_VKEY_Ereof: FWL_VKEYCODE = 249;
2106pub const FWL_VKEYCODE_FWL_VKEY_Play: FWL_VKEYCODE = 250;
2107pub const FWL_VKEYCODE_FWL_VKEY_Zoom: FWL_VKEYCODE = 251;
2108pub const FWL_VKEYCODE_FWL_VKEY_NoName: FWL_VKEYCODE = 252;
2109pub const FWL_VKEYCODE_FWL_VKEY_PA1: FWL_VKEYCODE = 253;
2110pub const FWL_VKEYCODE_FWL_VKEY_OEM_Clear: FWL_VKEYCODE = 254;
2111pub const FWL_VKEYCODE_FWL_VKEY_Unknown: FWL_VKEYCODE = 0;
2112#[doc = " Virtual keycodes."]
2113pub type FWL_VKEYCODE = ::std::os::raw::c_uint;
2114unsafe extern "C" {
2115 #[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."]
2116 pub fn FPDFPage_SetMediaBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2117}
2118unsafe extern "C" {
2119 #[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."]
2120 pub fn FPDFPage_SetCropBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2121}
2122unsafe extern "C" {
2123 #[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."]
2124 pub fn FPDFPage_SetBleedBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2125}
2126unsafe extern "C" {
2127 #[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."]
2128 pub fn FPDFPage_SetTrimBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2129}
2130unsafe extern "C" {
2131 #[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."]
2132 pub fn FPDFPage_SetArtBox(page: FPDF_PAGE, left: f32, bottom: f32, right: f32, top: f32);
2133}
2134unsafe extern "C" {
2135 #[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."]
2136 pub fn FPDFPage_GetMediaBox(
2137 page: FPDF_PAGE,
2138 left: *mut f32,
2139 bottom: *mut f32,
2140 right: *mut f32,
2141 top: *mut f32,
2142 ) -> FPDF_BOOL;
2143}
2144unsafe extern "C" {
2145 #[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."]
2146 pub fn FPDFPage_GetCropBox(
2147 page: FPDF_PAGE,
2148 left: *mut f32,
2149 bottom: *mut f32,
2150 right: *mut f32,
2151 top: *mut f32,
2152 ) -> FPDF_BOOL;
2153}
2154unsafe extern "C" {
2155 #[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."]
2156 pub fn FPDFPage_GetBleedBox(
2157 page: FPDF_PAGE,
2158 left: *mut f32,
2159 bottom: *mut f32,
2160 right: *mut f32,
2161 top: *mut f32,
2162 ) -> FPDF_BOOL;
2163}
2164unsafe extern "C" {
2165 #[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."]
2166 pub fn FPDFPage_GetTrimBox(
2167 page: FPDF_PAGE,
2168 left: *mut f32,
2169 bottom: *mut f32,
2170 right: *mut f32,
2171 top: *mut f32,
2172 ) -> FPDF_BOOL;
2173}
2174unsafe extern "C" {
2175 #[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."]
2176 pub fn FPDFPage_GetArtBox(
2177 page: FPDF_PAGE,
2178 left: *mut f32,
2179 bottom: *mut f32,
2180 right: *mut f32,
2181 top: *mut f32,
2182 ) -> FPDF_BOOL;
2183}
2184unsafe extern "C" {
2185 #[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."]
2186 pub fn FPDFPage_TransFormWithClip(
2187 page: FPDF_PAGE,
2188 matrix: *const FS_MATRIX,
2189 clipRect: *const FS_RECTF,
2190 ) -> FPDF_BOOL;
2191}
2192unsafe extern "C" {
2193 #[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."]
2194 pub fn FPDFPageObj_TransformClipPath(
2195 page_object: FPDF_PAGEOBJECT,
2196 a: f64,
2197 b: f64,
2198 c: f64,
2199 d: f64,
2200 e: f64,
2201 f: f64,
2202 );
2203}
2204unsafe extern "C" {
2205 #[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|."]
2206 pub fn FPDFPageObj_GetClipPath(page_object: FPDF_PAGEOBJECT) -> FPDF_CLIPPATH;
2207}
2208unsafe extern "C" {
2209 #[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."]
2210 pub fn FPDFClipPath_CountPaths(clip_path: FPDF_CLIPPATH) -> ::std::os::raw::c_int;
2211}
2212unsafe extern "C" {
2213 #[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."]
2214 pub fn FPDFClipPath_CountPathSegments(
2215 clip_path: FPDF_CLIPPATH,
2216 path_index: ::std::os::raw::c_int,
2217 ) -> ::std::os::raw::c_int;
2218}
2219unsafe extern "C" {
2220 #[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|."]
2221 pub fn FPDFClipPath_GetPathSegment(
2222 clip_path: FPDF_CLIPPATH,
2223 path_index: ::std::os::raw::c_int,
2224 segment_index: ::std::os::raw::c_int,
2225 ) -> FPDF_PATHSEGMENT;
2226}
2227unsafe extern "C" {
2228 #[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."]
2229 pub fn FPDF_CreateClipPath(left: f32, bottom: f32, right: f32, top: f32) -> FPDF_CLIPPATH;
2230}
2231unsafe extern "C" {
2232 #[doc = " Destroy the clip path.\n\n clipPath - A handle to the clip path. It will be invalid after this call."]
2233 pub fn FPDF_DestroyClipPath(clipPath: FPDF_CLIPPATH);
2234}
2235unsafe extern "C" {
2236 #[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.)"]
2237 pub fn FPDFPage_InsertClipPath(page: FPDF_PAGE, clipPath: FPDF_CLIPPATH);
2238}
2239#[doc = " Interface: FPDF_SYSFONTINFO\n Interface for getting system font information and font mapping"]
2240#[repr(C)]
2241#[derive(Debug, Copy, Clone)]
2242pub struct _FPDF_SYSFONTINFO {
2243 #[doc = " Version number of the interface. Currently must be 1 or 2.\n Version 1: Traditional behavior - calls EnumFonts during initialization.\n Version 2: Per-request behavior - skips EnumFonts, relies on MapFont.\n Experimental: Subject to change based on feedback."]
2244 pub version: ::std::os::raw::c_int,
2245 #[doc = " Method: Release\n Give implementation a chance to release any data after the\n interface is no longer used.\n Interface Version:\n 1 and 2\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n Return Value:\n None\n Comments:\n Called by PDFium during the final cleanup process."]
2246 pub Release: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO)>,
2247 #[doc = " Method: EnumFonts\n Enumerate all fonts installed on the system\n Interface Version:\n 1\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n pMapper - An opaque pointer to internal font mapper, used\n when calling FPDF_AddInstalledFont().\n Return Value:\n None\n Comments:\n Implementations should call FPDF_AddInstalledFont() function for\n each font found. Only TrueType/OpenType and Type1 fonts are\n accepted by PDFium.\n NOTE: This method will not be called when version is set to 2.\n Version 2 relies entirely on MapFont() for per-request matching."]
2248 pub EnumFonts: ::std::option::Option<
2249 unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO, pMapper: *mut ::std::os::raw::c_void),
2250 >,
2251 #[doc = " Method: MapFont\n Use the system font mapper to get a font handle from requested\n parameters.\n Interface Version:\n 1 and 2\n Implementation Required:\n Required if GetFont method is not implemented.\n Parameters:\n pThis - Pointer to the interface structure itself\n weight - Weight of the requested font. 400 is normal and\n 700 is bold.\n bItalic - Italic option of the requested font, TRUE or\n FALSE.\n charset - Character set identifier for the requested font.\n See above defined constants.\n pitch_family - A combination of flags. See above defined\n constants.\n face - Typeface name. Currently use system local encoding\n only.\n bExact - Obsolete: this parameter is now ignored.\n Return Value:\n An opaque pointer for font handle, or NULL if system mapping is\n not supported.\n Comments:\n If the system supports native font mapper (like Windows),\n implementation can implement this method to get a font handle.\n Otherwise, PDFium will do the mapping and then call GetFont\n method. Only TrueType/OpenType and Type1 fonts are accepted\n by PDFium."]
2252 pub MapFont: ::std::option::Option<
2253 unsafe extern "C" fn(
2254 pThis: *mut _FPDF_SYSFONTINFO,
2255 weight: ::std::os::raw::c_int,
2256 bItalic: FPDF_BOOL,
2257 charset: ::std::os::raw::c_int,
2258 pitch_family: ::std::os::raw::c_int,
2259 face: *const ::std::os::raw::c_char,
2260 bExact: *mut FPDF_BOOL,
2261 ) -> *mut ::std::os::raw::c_void,
2262 >,
2263 #[doc = " Method: GetFont\n Get a handle to a particular font by its internal ID\n Interface Version:\n 1 and 2\n Implementation Required:\n Required if MapFont method is not implemented.\n Return Value:\n An opaque pointer for font handle.\n Parameters:\n pThis - Pointer to the interface structure itself\n face - Typeface name in system local encoding.\n Comments:\n If the system mapping not supported, PDFium will do the font\n mapping and use this method to get a font handle."]
2264 pub GetFont: ::std::option::Option<
2265 unsafe extern "C" fn(
2266 pThis: *mut _FPDF_SYSFONTINFO,
2267 face: *const ::std::os::raw::c_char,
2268 ) -> *mut ::std::os::raw::c_void,
2269 >,
2270 #[doc = " Method: GetFontData\n Get font data from a font\n Interface Version:\n 1 and 2\n Implementation Required:\n Yes\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n table - TrueType/OpenType table identifier (refer to\n TrueType specification), or 0 for the whole file.\n buffer - The buffer receiving the font data. Can be NULL if\n not provided.\n buf_size - Buffer size, can be zero if not provided.\n Return Value:\n Number of bytes needed, if buffer not provided or not large\n enough, or number of bytes written into buffer otherwise.\n Comments:\n Can read either the full font file, or a particular\n TrueType/OpenType table."]
2271 pub GetFontData: ::std::option::Option<
2272 unsafe extern "C" fn(
2273 pThis: *mut _FPDF_SYSFONTINFO,
2274 hFont: *mut ::std::os::raw::c_void,
2275 table: ::std::os::raw::c_uint,
2276 buffer: *mut ::std::os::raw::c_uchar,
2277 buf_size: ::std::os::raw::c_ulong,
2278 ) -> ::std::os::raw::c_ulong,
2279 >,
2280 #[doc = " Method: GetFaceName\n Get face name from a font handle\n Interface Version:\n 1 and 2\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n buffer - The buffer receiving the face name. Can be NULL if\n not provided\n buf_size - Buffer size, can be zero if not provided\n Return Value:\n Number of bytes needed, if buffer not provided or not large\n enough, or number of bytes written into buffer otherwise."]
2281 pub GetFaceName: ::std::option::Option<
2282 unsafe extern "C" fn(
2283 pThis: *mut _FPDF_SYSFONTINFO,
2284 hFont: *mut ::std::os::raw::c_void,
2285 buffer: *mut ::std::os::raw::c_char,
2286 buf_size: ::std::os::raw::c_ulong,
2287 ) -> ::std::os::raw::c_ulong,
2288 >,
2289 #[doc = " Method: GetFontCharset\n Get character set information for a font handle\n Interface Version:\n 1 and 2\n Implementation Required:\n No\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n Return Value:\n Character set identifier. See defined constants above."]
2290 pub GetFontCharset: ::std::option::Option<
2291 unsafe extern "C" fn(
2292 pThis: *mut _FPDF_SYSFONTINFO,
2293 hFont: *mut ::std::os::raw::c_void,
2294 ) -> ::std::os::raw::c_int,
2295 >,
2296 #[doc = " Method: DeleteFont\n Delete a font handle\n Interface Version:\n 1 and 2\n Implementation Required:\n Yes\n Parameters:\n pThis - Pointer to the interface structure itself\n hFont - Font handle returned by MapFont or GetFont method\n Return Value:\n None"]
2297 pub DeleteFont: ::std::option::Option<
2298 unsafe extern "C" fn(pThis: *mut _FPDF_SYSFONTINFO, hFont: *mut ::std::os::raw::c_void),
2299 >,
2300}
2301#[doc = " Interface: FPDF_SYSFONTINFO\n Interface for getting system font information and font mapping"]
2302pub type FPDF_SYSFONTINFO = _FPDF_SYSFONTINFO;
2303#[doc = " Struct: FPDF_CharsetFontMap\n Provides the name of a font to use for a given charset value."]
2304#[repr(C)]
2305#[derive(Debug, Copy, Clone)]
2306pub struct FPDF_CharsetFontMap_ {
2307 #[doc = " Character Set Enum value, see FXFONT_*_CHARSET above."]
2308 pub charset: ::std::os::raw::c_int,
2309 #[doc = " Name of default font to use with that charset."]
2310 pub fontname: *const ::std::os::raw::c_char,
2311}
2312#[doc = " Struct: FPDF_CharsetFontMap\n Provides the name of a font to use for a given charset value."]
2313pub type FPDF_CharsetFontMap = FPDF_CharsetFontMap_;
2314unsafe extern "C" {
2315 #[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"]
2316 pub fn FPDF_GetDefaultTTFMap() -> *const FPDF_CharsetFontMap;
2317}
2318unsafe extern "C" {
2319 #[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."]
2320 pub fn FPDF_GetDefaultTTFMapCount() -> usize;
2321}
2322unsafe extern "C" {
2323 #[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."]
2324 pub fn FPDF_GetDefaultTTFMapEntry(index: usize) -> *const FPDF_CharsetFontMap;
2325}
2326unsafe extern "C" {
2327 #[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."]
2328 pub fn FPDF_AddInstalledFont(
2329 mapper: *mut ::std::os::raw::c_void,
2330 face: *const ::std::os::raw::c_char,
2331 charset: ::std::os::raw::c_int,
2332 );
2333}
2334unsafe extern "C" {
2335 #[doc = " Function: FPDF_SetSystemFontInfo\n Set the system font info interface into PDFium\n Parameters:\n font_info - Pointer to a FPDF_SYSFONTINFO structure\n Return Value:\n None\n Comments:\n Platform support implementation should implement required methods of\n FFDF_SYSFONTINFO interface, then call this function during PDFium\n initialization process.\n\n Call this with NULL to tell PDFium to stop using a previously set\n |FPDF_SYSFONTINFO|."]
2336 pub fn FPDF_SetSystemFontInfo(font_info: *mut FPDF_SYSFONTINFO);
2337}
2338unsafe extern "C" {
2339 #[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()."]
2340 pub fn FPDF_GetDefaultSystemFontInfo() -> *mut FPDF_SYSFONTINFO;
2341}
2342unsafe extern "C" {
2343 #[doc = " Function: FPDF_FreeDefaultSystemFontInfo\n Free a default system font info interface\n Parameters:\n font_info - Pointer to a FPDF_SYSFONTINFO structure\n Return Value:\n None\n Comments:\n This function should be called on the output from\n FPDF_GetDefaultSystemFontInfo() once it is no longer needed."]
2344 pub fn FPDF_FreeDefaultSystemFontInfo(font_info: *mut FPDF_SYSFONTINFO);
2345}
2346#[doc = " Unknown or error state."]
2347pub const FPDF_TEXT_DIRECTION_FPDF_TEXTDIR_UNKNOWN: FPDF_TEXT_DIRECTION = 0;
2348#[doc = " Represents the default layout behavior. This means the text direction is\n determined by the Unicode Bidi Algorithm."]
2349pub const FPDF_TEXT_DIRECTION_FPDF_TEXTDIR_AUTO: FPDF_TEXT_DIRECTION = 1;
2350#[doc = " Represents the default layout behavior. This means the text direction is\n determined by the Unicode Bidi Algorithm."]
2351pub const FPDF_TEXT_DIRECTION_FPDF_TEXTDIR_LTR: FPDF_TEXT_DIRECTION = 2;
2352#[doc = " Represents the default layout behavior. This means the text direction is\n determined by the Unicode Bidi Algorithm."]
2353pub const FPDF_TEXT_DIRECTION_FPDF_TEXTDIR_RTL: FPDF_TEXT_DIRECTION = 3;
2354#[doc = " Text direction for form fields."]
2355pub type FPDF_TEXT_DIRECTION = ::std::os::raw::c_uint;
2356#[repr(C)]
2357#[derive(Debug, Copy, Clone)]
2358pub struct _IPDF_JsPlatform {
2359 #[doc = " Version number of the interface. Currently must be 2."]
2360 pub version: ::std::os::raw::c_int,
2361 #[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."]
2362 pub app_alert: ::std::option::Option<
2363 unsafe extern "C" fn(
2364 pThis: *mut _IPDF_JsPlatform,
2365 Msg: FPDF_WIDESTRING,
2366 Title: FPDF_WIDESTRING,
2367 Type: ::std::os::raw::c_int,
2368 Icon: ::std::os::raw::c_int,
2369 ) -> ::std::os::raw::c_int,
2370 >,
2371 #[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"]
2372 pub app_beep: ::std::option::Option<
2373 unsafe extern "C" fn(pThis: *mut _IPDF_JsPlatform, nType: ::std::os::raw::c_int),
2374 >,
2375 #[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."]
2376 pub app_response: ::std::option::Option<
2377 unsafe extern "C" fn(
2378 pThis: *mut _IPDF_JsPlatform,
2379 Question: FPDF_WIDESTRING,
2380 Title: FPDF_WIDESTRING,
2381 Default: FPDF_WIDESTRING,
2382 cLabel: FPDF_WIDESTRING,
2383 bPassword: FPDF_BOOL,
2384 response: *mut ::std::os::raw::c_void,
2385 length: ::std::os::raw::c_int,
2386 ) -> ::std::os::raw::c_int,
2387 >,
2388 #[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."]
2389 pub Doc_getFilePath: ::std::option::Option<
2390 unsafe extern "C" fn(
2391 pThis: *mut _IPDF_JsPlatform,
2392 filePath: *mut ::std::os::raw::c_void,
2393 length: ::std::os::raw::c_int,
2394 ) -> ::std::os::raw::c_int,
2395 >,
2396 #[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."]
2397 pub Doc_mail: ::std::option::Option<
2398 unsafe extern "C" fn(
2399 pThis: *mut _IPDF_JsPlatform,
2400 mailData: *mut ::std::os::raw::c_void,
2401 length: ::std::os::raw::c_int,
2402 bUI: FPDF_BOOL,
2403 To: FPDF_WIDESTRING,
2404 Subject: FPDF_WIDESTRING,
2405 CC: FPDF_WIDESTRING,
2406 BCC: FPDF_WIDESTRING,
2407 Msg: FPDF_WIDESTRING,
2408 ),
2409 >,
2410 #[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."]
2411 pub Doc_print: ::std::option::Option<
2412 unsafe extern "C" fn(
2413 pThis: *mut _IPDF_JsPlatform,
2414 bUI: FPDF_BOOL,
2415 nStart: ::std::os::raw::c_int,
2416 nEnd: ::std::os::raw::c_int,
2417 bSilent: FPDF_BOOL,
2418 bShrinkToFit: FPDF_BOOL,
2419 bPrintAsImage: FPDF_BOOL,
2420 bReverse: FPDF_BOOL,
2421 bAnnotations: FPDF_BOOL,
2422 ),
2423 >,
2424 #[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."]
2425 pub Doc_submitForm: ::std::option::Option<
2426 unsafe extern "C" fn(
2427 pThis: *mut _IPDF_JsPlatform,
2428 formData: *mut ::std::os::raw::c_void,
2429 length: ::std::os::raw::c_int,
2430 URL: FPDF_WIDESTRING,
2431 ),
2432 >,
2433 #[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."]
2434 pub Doc_gotoPage: ::std::option::Option<
2435 unsafe extern "C" fn(pThis: *mut _IPDF_JsPlatform, nPageNum: ::std::os::raw::c_int),
2436 >,
2437 #[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."]
2438 pub Field_browse: ::std::option::Option<
2439 unsafe extern "C" fn(
2440 pThis: *mut _IPDF_JsPlatform,
2441 filePath: *mut ::std::os::raw::c_void,
2442 length: ::std::os::raw::c_int,
2443 ) -> ::std::os::raw::c_int,
2444 >,
2445 #[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."]
2446 pub m_pFormfillinfo: *mut ::std::os::raw::c_void,
2447 #[doc = " Unused in v3, retain for compatibility."]
2448 pub m_isolate: *mut ::std::os::raw::c_void,
2449 #[doc = " Unused in v3, retain for compatibility."]
2450 pub m_v8EmbedderSlot: ::std::os::raw::c_uint,
2451}
2452pub type IPDF_JSPLATFORM = _IPDF_JsPlatform;
2453#[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."]
2454pub type TimerCallback =
2455 ::std::option::Option<unsafe extern "C" fn(idEvent: ::std::os::raw::c_int)>;
2456#[doc = " Declares of a struct type to the local system time."]
2457#[repr(C)]
2458#[derive(Debug, Copy, Clone)]
2459pub struct _FPDF_SYSTEMTIME {
2460 #[doc = " years since 1900"]
2461 pub wYear: ::std::os::raw::c_ushort,
2462 #[doc = " months since January - [0,11]"]
2463 pub wMonth: ::std::os::raw::c_ushort,
2464 #[doc = " days since Sunday - [0,6]"]
2465 pub wDayOfWeek: ::std::os::raw::c_ushort,
2466 #[doc = " day of the month - [1,31]"]
2467 pub wDay: ::std::os::raw::c_ushort,
2468 #[doc = " hours since midnight - [0,23]"]
2469 pub wHour: ::std::os::raw::c_ushort,
2470 #[doc = " minutes after the hour - [0,59]"]
2471 pub wMinute: ::std::os::raw::c_ushort,
2472 #[doc = " seconds after the minute - [0,59]"]
2473 pub wSecond: ::std::os::raw::c_ushort,
2474 #[doc = " milliseconds after the second - [0,999]"]
2475 pub wMilliseconds: ::std::os::raw::c_ushort,
2476}
2477#[doc = " Declares of a struct type to the local system time."]
2478pub type FPDF_SYSTEMTIME = _FPDF_SYSTEMTIME;
2479#[repr(C)]
2480#[derive(Debug, Copy, Clone)]
2481pub struct _FPDF_FORMFILLINFO {
2482 #[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."]
2483 pub version: ::std::os::raw::c_int,
2484 #[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"]
2485 pub Release: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO)>,
2486 #[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."]
2487 pub FFI_Invalidate: ::std::option::Option<
2488 unsafe extern "C" fn(
2489 pThis: *mut _FPDF_FORMFILLINFO,
2490 page: FPDF_PAGE,
2491 left: f64,
2492 top: f64,
2493 right: f64,
2494 bottom: f64,
2495 ),
2496 >,
2497 #[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."]
2498 pub FFI_OutputSelectedRect: ::std::option::Option<
2499 unsafe extern "C" fn(
2500 pThis: *mut _FPDF_FORMFILLINFO,
2501 page: FPDF_PAGE,
2502 left: f64,
2503 top: f64,
2504 right: f64,
2505 bottom: f64,
2506 ),
2507 >,
2508 #[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."]
2509 pub FFI_SetCursor: ::std::option::Option<
2510 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, nCursorType: ::std::os::raw::c_int),
2511 >,
2512 #[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."]
2513 pub FFI_SetTimer: ::std::option::Option<
2514 unsafe extern "C" fn(
2515 pThis: *mut _FPDF_FORMFILLINFO,
2516 uElapse: ::std::os::raw::c_int,
2517 lpTimerFunc: TimerCallback,
2518 ) -> ::std::os::raw::c_int,
2519 >,
2520 #[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."]
2521 pub FFI_KillTimer: ::std::option::Option<
2522 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, nTimerID: ::std::os::raw::c_int),
2523 >,
2524 #[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."]
2525 pub FFI_GetLocalTime: ::std::option::Option<
2526 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO) -> FPDF_SYSTEMTIME,
2527 >,
2528 #[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."]
2529 pub FFI_OnChange: ::std::option::Option<unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO)>,
2530 #[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."]
2531 pub FFI_GetPage: ::std::option::Option<
2532 unsafe extern "C" fn(
2533 pThis: *mut _FPDF_FORMFILLINFO,
2534 document: FPDF_DOCUMENT,
2535 nPageIndex: ::std::os::raw::c_int,
2536 ) -> FPDF_PAGE,
2537 >,
2538 #[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."]
2539 pub FFI_GetCurrentPage: ::std::option::Option<
2540 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, document: FPDF_DOCUMENT) -> FPDF_PAGE,
2541 >,
2542 #[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."]
2543 pub FFI_GetRotation: ::std::option::Option<
2544 unsafe extern "C" fn(
2545 pThis: *mut _FPDF_FORMFILLINFO,
2546 page: FPDF_PAGE,
2547 ) -> ::std::os::raw::c_int,
2548 >,
2549 #[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."]
2550 pub FFI_ExecuteNamedAction: ::std::option::Option<
2551 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, namedAction: FPDF_BYTESTRING),
2552 >,
2553 #[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."]
2554 pub FFI_SetTextFieldFocus: ::std::option::Option<
2555 unsafe extern "C" fn(
2556 pThis: *mut _FPDF_FORMFILLINFO,
2557 value: FPDF_WIDESTRING,
2558 valueLen: FPDF_DWORD,
2559 is_focus: FPDF_BOOL,
2560 ),
2561 >,
2562 #[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."]
2563 pub FFI_DoURIAction: ::std::option::Option<
2564 unsafe extern "C" fn(pThis: *mut _FPDF_FORMFILLINFO, bsURI: FPDF_BYTESTRING),
2565 >,
2566 #[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."]
2567 pub FFI_DoGoToAction: ::std::option::Option<
2568 unsafe extern "C" fn(
2569 pThis: *mut _FPDF_FORMFILLINFO,
2570 nPageIndex: ::std::os::raw::c_int,
2571 zoomMode: ::std::os::raw::c_int,
2572 fPosArray: *mut f32,
2573 sizeofArray: ::std::os::raw::c_int,
2574 ),
2575 >,
2576 #[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."]
2577 pub m_pJsPlatform: *mut IPDF_JSPLATFORM,
2578 #[doc = " Whether the XFA module is disabled when built with the XFA module.\n Interface Version:\n Ignored if |version| < 2."]
2579 pub xfa_disabled: FPDF_BOOL,
2580 #[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."]
2581 pub FFI_DisplayCaret: ::std::option::Option<
2582 unsafe extern "C" fn(
2583 pThis: *mut _FPDF_FORMFILLINFO,
2584 page: FPDF_PAGE,
2585 bVisible: FPDF_BOOL,
2586 left: f64,
2587 top: f64,
2588 right: f64,
2589 bottom: f64,
2590 ),
2591 >,
2592 #[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."]
2593 pub FFI_GetCurrentPageIndex: ::std::option::Option<
2594 unsafe extern "C" fn(
2595 pThis: *mut _FPDF_FORMFILLINFO,
2596 document: FPDF_DOCUMENT,
2597 ) -> ::std::os::raw::c_int,
2598 >,
2599 #[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."]
2600 pub FFI_SetCurrentPage: ::std::option::Option<
2601 unsafe extern "C" fn(
2602 pThis: *mut _FPDF_FORMFILLINFO,
2603 document: FPDF_DOCUMENT,
2604 iCurPage: ::std::os::raw::c_int,
2605 ),
2606 >,
2607 #[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."]
2608 pub FFI_GotoURL: ::std::option::Option<
2609 unsafe extern "C" fn(
2610 pThis: *mut _FPDF_FORMFILLINFO,
2611 document: FPDF_DOCUMENT,
2612 wsURL: FPDF_WIDESTRING,
2613 ),
2614 >,
2615 #[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."]
2616 pub FFI_GetPageViewRect: ::std::option::Option<
2617 unsafe extern "C" fn(
2618 pThis: *mut _FPDF_FORMFILLINFO,
2619 page: FPDF_PAGE,
2620 left: *mut f64,
2621 top: *mut f64,
2622 right: *mut f64,
2623 bottom: *mut f64,
2624 ),
2625 >,
2626 #[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."]
2627 pub FFI_PageEvent: ::std::option::Option<
2628 unsafe extern "C" fn(
2629 pThis: *mut _FPDF_FORMFILLINFO,
2630 page_count: ::std::os::raw::c_int,
2631 event_type: FPDF_DWORD,
2632 ),
2633 >,
2634 #[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."]
2635 pub FFI_PopupMenu: ::std::option::Option<
2636 unsafe extern "C" fn(
2637 pThis: *mut _FPDF_FORMFILLINFO,
2638 page: FPDF_PAGE,
2639 hWidget: FPDF_WIDGET,
2640 menuFlag: ::std::os::raw::c_int,
2641 x: f32,
2642 y: f32,
2643 ) -> FPDF_BOOL,
2644 >,
2645 #[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."]
2646 pub FFI_OpenFile: ::std::option::Option<
2647 unsafe extern "C" fn(
2648 pThis: *mut _FPDF_FORMFILLINFO,
2649 fileFlag: ::std::os::raw::c_int,
2650 wsURL: FPDF_WIDESTRING,
2651 mode: *const ::std::os::raw::c_char,
2652 ) -> *mut FPDF_FILEHANDLER,
2653 >,
2654 #[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."]
2655 pub FFI_EmailTo: ::std::option::Option<
2656 unsafe extern "C" fn(
2657 pThis: *mut _FPDF_FORMFILLINFO,
2658 fileHandler: *mut FPDF_FILEHANDLER,
2659 pTo: FPDF_WIDESTRING,
2660 pSubject: FPDF_WIDESTRING,
2661 pCC: FPDF_WIDESTRING,
2662 pBcc: FPDF_WIDESTRING,
2663 pMsg: FPDF_WIDESTRING,
2664 ),
2665 >,
2666 #[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."]
2667 pub FFI_UploadTo: ::std::option::Option<
2668 unsafe extern "C" fn(
2669 pThis: *mut _FPDF_FORMFILLINFO,
2670 fileHandler: *mut FPDF_FILEHANDLER,
2671 fileFlag: ::std::os::raw::c_int,
2672 uploadTo: FPDF_WIDESTRING,
2673 ),
2674 >,
2675 #[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."]
2676 pub FFI_GetPlatform: ::std::option::Option<
2677 unsafe extern "C" fn(
2678 pThis: *mut _FPDF_FORMFILLINFO,
2679 platform: *mut ::std::os::raw::c_void,
2680 length: ::std::os::raw::c_int,
2681 ) -> ::std::os::raw::c_int,
2682 >,
2683 #[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."]
2684 pub FFI_GetLanguage: ::std::option::Option<
2685 unsafe extern "C" fn(
2686 pThis: *mut _FPDF_FORMFILLINFO,
2687 language: *mut ::std::os::raw::c_void,
2688 length: ::std::os::raw::c_int,
2689 ) -> ::std::os::raw::c_int,
2690 >,
2691 #[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."]
2692 pub FFI_DownloadFromURL: ::std::option::Option<
2693 unsafe extern "C" fn(
2694 pThis: *mut _FPDF_FORMFILLINFO,
2695 URL: FPDF_WIDESTRING,
2696 ) -> *mut FPDF_FILEHANDLER,
2697 >,
2698 #[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."]
2699 pub FFI_PostRequestURL: ::std::option::Option<
2700 unsafe extern "C" fn(
2701 pThis: *mut _FPDF_FORMFILLINFO,
2702 wsURL: FPDF_WIDESTRING,
2703 wsData: FPDF_WIDESTRING,
2704 wsContentType: FPDF_WIDESTRING,
2705 wsEncode: FPDF_WIDESTRING,
2706 wsHeader: FPDF_WIDESTRING,
2707 response: *mut FPDF_BSTR,
2708 ) -> FPDF_BOOL,
2709 >,
2710 #[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."]
2711 pub FFI_PutRequestURL: ::std::option::Option<
2712 unsafe extern "C" fn(
2713 pThis: *mut _FPDF_FORMFILLINFO,
2714 wsURL: FPDF_WIDESTRING,
2715 wsData: FPDF_WIDESTRING,
2716 wsEncode: FPDF_WIDESTRING,
2717 ) -> FPDF_BOOL,
2718 >,
2719 #[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."]
2720 pub FFI_OnFocusChange: ::std::option::Option<
2721 unsafe extern "C" fn(
2722 param: *mut _FPDF_FORMFILLINFO,
2723 annot: FPDF_ANNOTATION,
2724 page_index: ::std::os::raw::c_int,
2725 ),
2726 >,
2727 #[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."]
2728 pub FFI_DoURIActionWithKeyboardModifier: ::std::option::Option<
2729 unsafe extern "C" fn(
2730 param: *mut _FPDF_FORMFILLINFO,
2731 uri: FPDF_BYTESTRING,
2732 modifiers: ::std::os::raw::c_int,
2733 ),
2734 >,
2735}
2736pub type FPDF_FORMFILLINFO = _FPDF_FORMFILLINFO;
2737unsafe extern "C" {
2738 #[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."]
2739 pub fn FPDFDOC_InitFormFillEnvironment(
2740 document: FPDF_DOCUMENT,
2741 formInfo: *mut FPDF_FORMFILLINFO,
2742 ) -> FPDF_FORMHANDLE;
2743}
2744unsafe extern "C" {
2745 #[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."]
2746 pub fn FPDFDOC_ExitFormFillEnvironment(hHandle: FPDF_FORMHANDLE);
2747}
2748unsafe extern "C" {
2749 #[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."]
2750 pub fn FORM_OnAfterLoadPage(page: FPDF_PAGE, hHandle: FPDF_FORMHANDLE);
2751}
2752unsafe extern "C" {
2753 #[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."]
2754 pub fn FORM_OnBeforeClosePage(page: FPDF_PAGE, hHandle: FPDF_FORMHANDLE);
2755}
2756unsafe extern "C" {
2757 #[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."]
2758 pub fn FORM_DoDocumentJSAction(hHandle: FPDF_FORMHANDLE);
2759}
2760unsafe extern "C" {
2761 #[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."]
2762 pub fn FORM_DoDocumentOpenAction(hHandle: FPDF_FORMHANDLE);
2763}
2764unsafe extern "C" {
2765 #[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|."]
2766 pub fn FORM_DoDocumentAAction(hHandle: FPDF_FORMHANDLE, aaType: ::std::os::raw::c_int);
2767}
2768unsafe extern "C" {
2769 #[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."]
2770 pub fn FORM_DoPageAAction(
2771 page: FPDF_PAGE,
2772 hHandle: FPDF_FORMHANDLE,
2773 aaType: ::std::os::raw::c_int,
2774 );
2775}
2776unsafe extern "C" {
2777 #[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."]
2778 pub fn FORM_OnMouseMove(
2779 hHandle: FPDF_FORMHANDLE,
2780 page: FPDF_PAGE,
2781 modifier: ::std::os::raw::c_int,
2782 page_x: f64,
2783 page_y: f64,
2784 ) -> FPDF_BOOL;
2785}
2786unsafe extern "C" {
2787 #[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."]
2788 pub fn FORM_OnMouseWheel(
2789 hHandle: FPDF_FORMHANDLE,
2790 page: FPDF_PAGE,
2791 modifier: ::std::os::raw::c_int,
2792 page_coord: *const FS_POINTF,
2793 delta_x: ::std::os::raw::c_int,
2794 delta_y: ::std::os::raw::c_int,
2795 ) -> FPDF_BOOL;
2796}
2797unsafe extern "C" {
2798 #[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."]
2799 pub fn FORM_OnFocus(
2800 hHandle: FPDF_FORMHANDLE,
2801 page: FPDF_PAGE,
2802 modifier: ::std::os::raw::c_int,
2803 page_x: f64,
2804 page_y: f64,
2805 ) -> FPDF_BOOL;
2806}
2807unsafe extern "C" {
2808 #[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."]
2809 pub fn FORM_OnLButtonDown(
2810 hHandle: FPDF_FORMHANDLE,
2811 page: FPDF_PAGE,
2812 modifier: ::std::os::raw::c_int,
2813 page_x: f64,
2814 page_y: f64,
2815 ) -> FPDF_BOOL;
2816}
2817unsafe extern "C" {
2818 #[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."]
2819 pub fn FORM_OnRButtonDown(
2820 hHandle: FPDF_FORMHANDLE,
2821 page: FPDF_PAGE,
2822 modifier: ::std::os::raw::c_int,
2823 page_x: f64,
2824 page_y: f64,
2825 ) -> FPDF_BOOL;
2826}
2827unsafe extern "C" {
2828 #[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."]
2829 pub fn FORM_OnLButtonUp(
2830 hHandle: FPDF_FORMHANDLE,
2831 page: FPDF_PAGE,
2832 modifier: ::std::os::raw::c_int,
2833 page_x: f64,
2834 page_y: f64,
2835 ) -> FPDF_BOOL;
2836}
2837unsafe extern "C" {
2838 #[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."]
2839 pub fn FORM_OnRButtonUp(
2840 hHandle: FPDF_FORMHANDLE,
2841 page: FPDF_PAGE,
2842 modifier: ::std::os::raw::c_int,
2843 page_x: f64,
2844 page_y: f64,
2845 ) -> FPDF_BOOL;
2846}
2847unsafe extern "C" {
2848 #[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."]
2849 pub fn FORM_OnLButtonDoubleClick(
2850 hHandle: FPDF_FORMHANDLE,
2851 page: FPDF_PAGE,
2852 modifier: ::std::os::raw::c_int,
2853 page_x: f64,
2854 page_y: f64,
2855 ) -> FPDF_BOOL;
2856}
2857unsafe extern "C" {
2858 #[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."]
2859 pub fn FORM_OnKeyDown(
2860 hHandle: FPDF_FORMHANDLE,
2861 page: FPDF_PAGE,
2862 nKeyCode: ::std::os::raw::c_int,
2863 modifier: ::std::os::raw::c_int,
2864 ) -> FPDF_BOOL;
2865}
2866unsafe extern "C" {
2867 #[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."]
2868 pub fn FORM_OnKeyUp(
2869 hHandle: FPDF_FORMHANDLE,
2870 page: FPDF_PAGE,
2871 nKeyCode: ::std::os::raw::c_int,
2872 modifier: ::std::os::raw::c_int,
2873 ) -> FPDF_BOOL;
2874}
2875unsafe extern "C" {
2876 #[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."]
2877 pub fn FORM_OnChar(
2878 hHandle: FPDF_FORMHANDLE,
2879 page: FPDF_PAGE,
2880 nChar: ::std::os::raw::c_int,
2881 modifier: ::std::os::raw::c_int,
2882 ) -> FPDF_BOOL;
2883}
2884unsafe extern "C" {
2885 #[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."]
2886 pub fn FORM_GetFocusedText(
2887 hHandle: FPDF_FORMHANDLE,
2888 page: FPDF_PAGE,
2889 buffer: *mut ::std::os::raw::c_void,
2890 buflen: ::std::os::raw::c_ulong,
2891 ) -> ::std::os::raw::c_ulong;
2892}
2893unsafe extern "C" {
2894 #[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."]
2895 pub fn FORM_GetSelectedText(
2896 hHandle: FPDF_FORMHANDLE,
2897 page: FPDF_PAGE,
2898 buffer: *mut ::std::os::raw::c_void,
2899 buflen: ::std::os::raw::c_ulong,
2900 ) -> ::std::os::raw::c_ulong;
2901}
2902unsafe extern "C" {
2903 #[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."]
2904 pub fn FORM_ReplaceAndKeepSelection(
2905 hHandle: FPDF_FORMHANDLE,
2906 page: FPDF_PAGE,
2907 wsText: FPDF_WIDESTRING,
2908 );
2909}
2910unsafe extern "C" {
2911 #[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."]
2912 pub fn FORM_ReplaceSelection(
2913 hHandle: FPDF_FORMHANDLE,
2914 page: FPDF_PAGE,
2915 wsText: FPDF_WIDESTRING,
2916 );
2917}
2918unsafe extern "C" {
2919 #[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."]
2920 pub fn FORM_SelectAllText(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
2921}
2922unsafe extern "C" {
2923 #[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."]
2924 pub fn FORM_CanUndo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
2925}
2926unsafe extern "C" {
2927 #[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."]
2928 pub fn FORM_CanRedo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
2929}
2930unsafe extern "C" {
2931 #[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."]
2932 pub fn FORM_Undo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
2933}
2934unsafe extern "C" {
2935 #[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."]
2936 pub fn FORM_Redo(hHandle: FPDF_FORMHANDLE, page: FPDF_PAGE) -> FPDF_BOOL;
2937}
2938unsafe extern "C" {
2939 #[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."]
2940 pub fn FORM_ForceToKillFocus(hHandle: FPDF_FORMHANDLE) -> FPDF_BOOL;
2941}
2942unsafe extern "C" {
2943 #[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."]
2944 pub fn FORM_GetFocusedAnnot(
2945 handle: FPDF_FORMHANDLE,
2946 page_index: *mut ::std::os::raw::c_int,
2947 annot: *mut FPDF_ANNOTATION,
2948 ) -> FPDF_BOOL;
2949}
2950unsafe extern "C" {
2951 #[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."]
2952 pub fn FORM_SetFocusedAnnot(handle: FPDF_FORMHANDLE, annot: FPDF_ANNOTATION) -> FPDF_BOOL;
2953}
2954unsafe extern "C" {
2955 #[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."]
2956 pub fn FPDFPage_HasFormFieldAtPoint(
2957 hHandle: FPDF_FORMHANDLE,
2958 page: FPDF_PAGE,
2959 page_x: f64,
2960 page_y: f64,
2961 ) -> ::std::os::raw::c_int;
2962}
2963unsafe extern "C" {
2964 #[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."]
2965 pub fn FPDFPage_FormFieldZOrderAtPoint(
2966 hHandle: FPDF_FORMHANDLE,
2967 page: FPDF_PAGE,
2968 page_x: f64,
2969 page_y: f64,
2970 ) -> ::std::os::raw::c_int;
2971}
2972unsafe extern "C" {
2973 #[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."]
2974 pub fn FPDF_SetFormFieldHighlightColor(
2975 hHandle: FPDF_FORMHANDLE,
2976 fieldType: ::std::os::raw::c_int,
2977 color: ::std::os::raw::c_ulong,
2978 );
2979}
2980unsafe extern "C" {
2981 #[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."]
2982 pub fn FPDF_SetFormFieldHighlightAlpha(
2983 hHandle: FPDF_FORMHANDLE,
2984 alpha: ::std::os::raw::c_uchar,
2985 );
2986}
2987unsafe extern "C" {
2988 #[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."]
2989 pub fn FPDF_RemoveFormFieldHighlight(hHandle: FPDF_FORMHANDLE);
2990}
2991unsafe extern "C" {
2992 #[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."]
2993 pub fn FPDF_FFLDraw(
2994 hHandle: FPDF_FORMHANDLE,
2995 bitmap: FPDF_BITMAP,
2996 page: FPDF_PAGE,
2997 start_x: ::std::os::raw::c_int,
2998 start_y: ::std::os::raw::c_int,
2999 size_x: ::std::os::raw::c_int,
3000 size_y: ::std::os::raw::c_int,
3001 rotate: ::std::os::raw::c_int,
3002 flags: ::std::os::raw::c_int,
3003 );
3004}
3005unsafe extern "C" {
3006 pub fn FPDF_FFLDrawSkia(
3007 hHandle: FPDF_FORMHANDLE,
3008 canvas: FPDF_SKIA_CANVAS,
3009 page: FPDF_PAGE,
3010 start_x: ::std::os::raw::c_int,
3011 start_y: ::std::os::raw::c_int,
3012 size_x: ::std::os::raw::c_int,
3013 size_y: ::std::os::raw::c_int,
3014 rotate: ::std::os::raw::c_int,
3015 flags: ::std::os::raw::c_int,
3016 );
3017}
3018unsafe extern "C" {
3019 #[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."]
3020 pub fn FPDF_GetFormType(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
3021}
3022unsafe extern "C" {
3023 #[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."]
3024 pub fn FORM_SetIndexSelected(
3025 hHandle: FPDF_FORMHANDLE,
3026 page: FPDF_PAGE,
3027 index: ::std::os::raw::c_int,
3028 selected: FPDF_BOOL,
3029 ) -> FPDF_BOOL;
3030}
3031unsafe extern "C" {
3032 #[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."]
3033 pub fn FORM_IsIndexSelected(
3034 hHandle: FPDF_FORMHANDLE,
3035 page: FPDF_PAGE,
3036 index: ::std::os::raw::c_int,
3037 ) -> FPDF_BOOL;
3038}
3039unsafe extern "C" {
3040 #[doc = " Experimental API\n Function: FORM_GetTextDirection\n Returns the text direction of the given form field annotation.\n Parameters:\n handle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - Handle to the form field annotation.\n Return Value:\n The in-memory text direction of the given form field annotation.\n If the operation fails (e.g., invalid handle), returns\n FPDF_TEXTDIR_UNKNOWN."]
3041 pub fn FORM_GetTextDirection(
3042 handle: FPDF_FORMHANDLE,
3043 annot: FPDF_ANNOTATION,
3044 ) -> FPDF_TEXT_DIRECTION;
3045}
3046unsafe extern "C" {
3047 #[doc = " Experimental API\n Function: FORM_SetTextDirection\n Sets the text direction of the given form field annotation.\n Parameters:\n handle - Handle to the form fill module. Returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - Handle to the form field annotation.\n direction - The new text direction. Passing\n FPDF_TEXTDIR_UNKNOWN will fail and return FALSE.\n Note: This only alters the in-memory state of the\n form field and does not modify the PDF document.\n Return Value:\n TRUE on success, FALSE otherwise."]
3048 pub fn FORM_SetTextDirection(
3049 handle: FPDF_FORMHANDLE,
3050 annot: FPDF_ANNOTATION,
3051 direction: FPDF_TEXT_DIRECTION,
3052 ) -> FPDF_BOOL;
3053}
3054unsafe extern "C" {
3055 #[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."]
3056 pub fn FPDF_LoadXFA(document: FPDF_DOCUMENT) -> FPDF_BOOL;
3057}
3058#[doc = " Structure for custom file write"]
3059#[repr(C)]
3060#[derive(Debug, Copy, Clone)]
3061pub struct FPDF_FILEWRITE_ {
3062 #[doc = "\n Version number of the interface. Currently must be 1.\n"]
3063 pub version: ::std::os::raw::c_int,
3064 #[doc = " Method: WriteBlock\n Output a block of data in your custom way.\n Interface Version:\n 1\n Implementation Required:\n Yes\n Comments:\n Called by function FPDF_SaveDocument\n Parameters:\n self - Pointer to the structure itself\n data - Pointer to a buffer to output\n size - The size of the buffer.\n Return value:\n Should be non-zero if successful, zero for error."]
3065 pub WriteBlock: ::std::option::Option<
3066 unsafe extern "C" fn(
3067 self_: *mut FPDF_FILEWRITE_,
3068 data: *const ::std::os::raw::c_void,
3069 size: ::std::os::raw::c_ulong,
3070 ) -> ::std::os::raw::c_int,
3071 >,
3072}
3073#[doc = " Structure for custom file write"]
3074pub type FPDF_FILEWRITE = FPDF_FILEWRITE_;
3075unsafe extern "C" {
3076 #[doc = " Function: FPDF_SaveAsCopy\n Saves the copy of specified document in custom way.\n Parameters:\n document - Handle to document, as returned by\n FPDF_LoadDocument() or FPDF_CreateNewDocument().\n file_write - A pointer to a custom file write structure.\n flags - Flags above that affect how the PDF gets saved.\n Pass in 0 when there are no flags.\n Return value:\n TRUE for succeed, FALSE for failed.\n"]
3077 pub fn FPDF_SaveAsCopy(
3078 document: FPDF_DOCUMENT,
3079 file_write: *mut FPDF_FILEWRITE,
3080 flags: FPDF_DWORD,
3081 ) -> FPDF_BOOL;
3082}
3083unsafe extern "C" {
3084 #[doc = " Function: FPDF_SaveWithVersion\n Same as FPDF_SaveAsCopy(), except the file version of the\n saved document can be specified by the caller.\n Parameters:\n document - Handle to document.\n file_write - A pointer to a custom file write structure.\n flags - The creating flags.\n file_version - The PDF file version. File version: 14 for 1.4,\n 15 for 1.5, ...\n Return value:\n TRUE if succeed, FALSE if failed.\n"]
3085 pub fn FPDF_SaveWithVersion(
3086 document: FPDF_DOCUMENT,
3087 file_write: *mut FPDF_FILEWRITE,
3088 flags: FPDF_DWORD,
3089 file_version: ::std::os::raw::c_int,
3090 ) -> FPDF_BOOL;
3091}
3092#[doc = " Signed."]
3093pub type int_least8_t = __int_least8_t;
3094pub type int_least16_t = __int_least16_t;
3095pub type int_least32_t = __int_least32_t;
3096pub type int_least64_t = __int_least64_t;
3097#[doc = " Unsigned."]
3098pub type uint_least8_t = __uint_least8_t;
3099pub type uint_least16_t = __uint_least16_t;
3100pub type uint_least32_t = __uint_least32_t;
3101pub type uint_least64_t = __uint_least64_t;
3102#[doc = " Signed."]
3103pub type int_fast8_t = ::std::os::raw::c_schar;
3104pub type int_fast16_t = ::std::os::raw::c_long;
3105pub type int_fast32_t = ::std::os::raw::c_long;
3106pub type int_fast64_t = ::std::os::raw::c_long;
3107#[doc = " Unsigned."]
3108pub type uint_fast8_t = ::std::os::raw::c_uchar;
3109pub type uint_fast16_t = ::std::os::raw::c_ulong;
3110pub type uint_fast32_t = ::std::os::raw::c_ulong;
3111pub type uint_fast64_t = ::std::os::raw::c_ulong;
3112#[doc = " Largest integral types."]
3113pub type intmax_t = __intmax_t;
3114pub type uintmax_t = __uintmax_t;
3115#[repr(C)]
3116#[derive(Debug, Copy, Clone)]
3117pub struct FPDF_IMAGEOBJ_METADATA {
3118 #[doc = " The image width in pixels."]
3119 pub width: ::std::os::raw::c_uint,
3120 #[doc = " The image height in pixels."]
3121 pub height: ::std::os::raw::c_uint,
3122 #[doc = " The image's horizontal pixel-per-inch."]
3123 pub horizontal_dpi: f32,
3124 #[doc = " The image's vertical pixel-per-inch."]
3125 pub vertical_dpi: f32,
3126 #[doc = " The number of bits used to represent each pixel."]
3127 pub bits_per_pixel: ::std::os::raw::c_uint,
3128 #[doc = " The image's colorspace. See above for the list of FPDF_COLORSPACE_*."]
3129 pub colorspace: ::std::os::raw::c_int,
3130 #[doc = " The image's marked content ID. Useful for pairing with associated alt-text.\n A value of -1 indicates no ID."]
3131 pub marked_content_id: ::std::os::raw::c_int,
3132}
3133unsafe extern "C" {
3134 #[doc = " Create a new PDF document.\n\n Returns a handle to a new document, or NULL on failure."]
3135 pub fn FPDF_CreateNewDocument() -> FPDF_DOCUMENT;
3136}
3137unsafe extern "C" {
3138 #[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."]
3139 pub fn FPDFPage_New(
3140 document: FPDF_DOCUMENT,
3141 page_index: ::std::os::raw::c_int,
3142 width: f64,
3143 height: f64,
3144 ) -> FPDF_PAGE;
3145}
3146unsafe extern "C" {
3147 #[doc = " Delete the page at |page_index|.\n\n document - handle to document.\n page_index - the index of the page to delete."]
3148 pub fn FPDFPage_Delete(document: FPDF_DOCUMENT, page_index: ::std::os::raw::c_int);
3149}
3150unsafe extern "C" {
3151 #[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"]
3152 pub fn FPDF_MovePages(
3153 document: FPDF_DOCUMENT,
3154 page_indices: *const ::std::os::raw::c_int,
3155 page_indices_len: ::std::os::raw::c_ulong,
3156 dest_page_index: ::std::os::raw::c_int,
3157 ) -> FPDF_BOOL;
3158}
3159unsafe extern "C" {
3160 #[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.\n\n Or returns -1 on error."]
3161 pub fn FPDFPage_GetRotation(page: FPDF_PAGE) -> ::std::os::raw::c_int;
3162}
3163unsafe extern "C" {
3164 #[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."]
3165 pub fn FPDFPage_SetRotation(page: FPDF_PAGE, rotate: ::std::os::raw::c_int);
3166}
3167unsafe extern "C" {
3168 #[doc = " Insert |page_object| into |page|.\n\n page - Handle to a page.\n page_object - Handle to a page object. FPDFPage_InsertObject() takes\n ownership. Ownership of |page_object| transfers to |page| on\n success. |page_object| is freed on failure. Null\n |page_object| causes a failure.\n\n Returns true if successful."]
3169 pub fn FPDFPage_InsertObject(page: FPDF_PAGE, page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
3170}
3171unsafe extern "C" {
3172 #[doc = " Insert |page_object| into |page| at the specified |index|.\n\n page - handle to a page\n page_object - handle to a page object as previously obtained by\n FPDFPageObj_CreateNew{Path|Rect}() or\n FPDFPageObj_New{Text|Image}Obj(). Ownership of the object\n is transferred back to PDFium.\n index - the index position to insert the object at. If index equals\n the current object count, the object will be appended to the\n end. If index is greater than the object count, the function\n will fail and return false.\n\n Returns true if successful."]
3173 pub fn FPDFPage_InsertObjectAtIndex(
3174 page: FPDF_PAGE,
3175 page_object: FPDF_PAGEOBJECT,
3176 index: usize,
3177 ) -> FPDF_BOOL;
3178}
3179unsafe extern "C" {
3180 #[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."]
3181 pub fn FPDFPage_RemoveObject(page: FPDF_PAGE, page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
3182}
3183unsafe extern "C" {
3184 #[doc = " Get number of page objects inside |page|.\n\n page - handle to a page.\n\n Returns the number of objects in |page|."]
3185 pub fn FPDFPage_CountObjects(page: FPDF_PAGE) -> ::std::os::raw::c_int;
3186}
3187unsafe extern "C" {
3188 #[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."]
3189 pub fn FPDFPage_GetObject(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_PAGEOBJECT;
3190}
3191unsafe extern "C" {
3192 #[doc = " Checks if |page| contains transparency.\n\n page - handle to a page.\n\n Returns TRUE if |page| contains transparency."]
3193 pub fn FPDFPage_HasTransparency(page: FPDF_PAGE) -> FPDF_BOOL;
3194}
3195unsafe extern "C" {
3196 #[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."]
3197 pub fn FPDFPage_GenerateContent(page: FPDF_PAGE) -> FPDF_BOOL;
3198}
3199unsafe extern "C" {
3200 #[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."]
3201 pub fn FPDFPageObj_Destroy(page_object: FPDF_PAGEOBJECT);
3202}
3203unsafe extern "C" {
3204 #[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."]
3205 pub fn FPDFPageObj_HasTransparency(page_object: FPDF_PAGEOBJECT) -> FPDF_BOOL;
3206}
3207unsafe extern "C" {
3208 #[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."]
3209 pub fn FPDFPageObj_GetType(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3210}
3211unsafe extern "C" {
3212 #[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."]
3213 pub fn FPDFPageObj_GetIsActive(
3214 page_object: FPDF_PAGEOBJECT,
3215 active: *mut FPDF_BOOL,
3216 ) -> FPDF_BOOL;
3217}
3218unsafe extern "C" {
3219 #[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."]
3220 pub fn FPDFPageObj_SetIsActive(page_object: FPDF_PAGEOBJECT, active: FPDF_BOOL) -> FPDF_BOOL;
3221}
3222unsafe extern "C" {
3223 #[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|."]
3224 pub fn FPDFPageObj_Transform(
3225 page_object: FPDF_PAGEOBJECT,
3226 a: f64,
3227 b: f64,
3228 c: f64,
3229 d: f64,
3230 e: f64,
3231 f: f64,
3232 );
3233}
3234unsafe extern "C" {
3235 #[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."]
3236 pub fn FPDFPageObj_TransformF(
3237 page_object: FPDF_PAGEOBJECT,
3238 matrix: *const FS_MATRIX,
3239 ) -> FPDF_BOOL;
3240}
3241unsafe extern "C" {
3242 #[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."]
3243 pub fn FPDFPageObj_GetMatrix(page_object: FPDF_PAGEOBJECT, matrix: *mut FS_MATRIX)
3244 -> FPDF_BOOL;
3245}
3246unsafe extern "C" {
3247 #[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."]
3248 pub fn FPDFPageObj_SetMatrix(
3249 page_object: FPDF_PAGEOBJECT,
3250 matrix: *const FS_MATRIX,
3251 ) -> FPDF_BOOL;
3252}
3253unsafe extern "C" {
3254 #[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."]
3255 pub fn FPDFPage_TransformAnnots(
3256 page: FPDF_PAGE,
3257 a: f64,
3258 b: f64,
3259 c: f64,
3260 d: f64,
3261 e: f64,
3262 f: f64,
3263 );
3264}
3265unsafe extern "C" {
3266 #[doc = " Create a new image object.\n\n document - handle to a document.\n\n Returns a handle to a new image object."]
3267 pub fn FPDFPageObj_NewImageObj(document: FPDF_DOCUMENT) -> FPDF_PAGEOBJECT;
3268}
3269unsafe extern "C" {
3270 #[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."]
3271 pub fn FPDFPageObj_GetMarkedContentID(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3272}
3273unsafe extern "C" {
3274 #[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."]
3275 pub fn FPDFPageObj_CountMarks(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3276}
3277unsafe extern "C" {
3278 #[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."]
3279 pub fn FPDFPageObj_GetMark(
3280 page_object: FPDF_PAGEOBJECT,
3281 index: ::std::os::raw::c_ulong,
3282 ) -> FPDF_PAGEOBJECTMARK;
3283}
3284unsafe extern "C" {
3285 #[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."]
3286 pub fn FPDFPageObj_AddMark(
3287 page_object: FPDF_PAGEOBJECT,
3288 name: FPDF_BYTESTRING,
3289 ) -> FPDF_PAGEOBJECTMARK;
3290}
3291unsafe extern "C" {
3292 #[doc = " Experimental API.\n Add an existing content mark to a |page_object|. If consecutive page objects\n have the same |mark|, the generated PDF will contain a single mark that spans\n all of them. If the page objects are not consecutive, multiple copies of the\n |mark| are inserted in the PDF.\n\n page_object - handle to a page object.\n mark - handle to a mark object.\n\n Returns true on success, or false on failure. The handles are all owned by\n the library. The |page_object| and |mark| params must be associated with the\n same document."]
3293 pub fn FPDFPageObj_AddExistingMark(
3294 page_object: FPDF_PAGEOBJECT,
3295 mark: FPDF_PAGEOBJECTMARK,
3296 ) -> FPDF_BOOL;
3297}
3298unsafe extern "C" {
3299 #[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."]
3300 pub fn FPDFPageObj_RemoveMark(
3301 page_object: FPDF_PAGEOBJECT,
3302 mark: FPDF_PAGEOBJECTMARK,
3303 ) -> FPDF_BOOL;
3304}
3305unsafe extern "C" {
3306 #[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."]
3307 pub fn FPDFPageObjMark_GetName(
3308 mark: FPDF_PAGEOBJECTMARK,
3309 buffer: *mut FPDF_WCHAR,
3310 buflen: ::std::os::raw::c_ulong,
3311 out_buflen: *mut ::std::os::raw::c_ulong,
3312 ) -> FPDF_BOOL;
3313}
3314unsafe extern "C" {
3315 #[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."]
3316 pub fn FPDFPageObjMark_CountParams(mark: FPDF_PAGEOBJECTMARK) -> ::std::os::raw::c_int;
3317}
3318unsafe extern "C" {
3319 #[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."]
3320 pub fn FPDFPageObjMark_GetParamKey(
3321 mark: FPDF_PAGEOBJECTMARK,
3322 index: ::std::os::raw::c_ulong,
3323 buffer: *mut FPDF_WCHAR,
3324 buflen: ::std::os::raw::c_ulong,
3325 out_buflen: *mut ::std::os::raw::c_ulong,
3326 ) -> FPDF_BOOL;
3327}
3328unsafe extern "C" {
3329 #[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."]
3330 pub fn FPDFPageObjMark_GetParamValueType(
3331 mark: FPDF_PAGEOBJECTMARK,
3332 key: FPDF_BYTESTRING,
3333 ) -> FPDF_OBJECT_TYPE;
3334}
3335unsafe extern "C" {
3336 #[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."]
3337 pub fn FPDFPageObjMark_GetParamIntValue(
3338 mark: FPDF_PAGEOBJECTMARK,
3339 key: FPDF_BYTESTRING,
3340 out_value: *mut ::std::os::raw::c_int,
3341 ) -> FPDF_BOOL;
3342}
3343unsafe extern "C" {
3344 #[doc = " Experimental API.\n Get the value of a number property in a content mark by key as float.\n FPDFPageObjMark_GetParamValueType() should have returned FPDF_OBJECT_NUMBER\n for this property.\n\n mark - handle to a content mark.\n key - string key of the property.\n out_value - pointer to variable that will receive the value. Not filled if\n false is returned.\n\n Returns TRUE if the key maps to a number value, FALSE otherwise."]
3345 pub fn FPDFPageObjMark_GetParamFloatValue(
3346 mark: FPDF_PAGEOBJECTMARK,
3347 key: FPDF_BYTESTRING,
3348 out_value: *mut f32,
3349 ) -> FPDF_BOOL;
3350}
3351unsafe extern "C" {
3352 #[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."]
3353 pub fn FPDFPageObjMark_GetParamStringValue(
3354 mark: FPDF_PAGEOBJECTMARK,
3355 key: FPDF_BYTESTRING,
3356 buffer: *mut FPDF_WCHAR,
3357 buflen: ::std::os::raw::c_ulong,
3358 out_buflen: *mut ::std::os::raw::c_ulong,
3359 ) -> FPDF_BOOL;
3360}
3361unsafe extern "C" {
3362 #[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."]
3363 pub fn FPDFPageObjMark_GetParamBlobValue(
3364 mark: FPDF_PAGEOBJECTMARK,
3365 key: FPDF_BYTESTRING,
3366 buffer: *mut ::std::os::raw::c_uchar,
3367 buflen: ::std::os::raw::c_ulong,
3368 out_buflen: *mut ::std::os::raw::c_ulong,
3369 ) -> FPDF_BOOL;
3370}
3371unsafe extern "C" {
3372 #[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."]
3373 pub fn FPDFPageObjMark_SetIntParam(
3374 document: FPDF_DOCUMENT,
3375 page_object: FPDF_PAGEOBJECT,
3376 mark: FPDF_PAGEOBJECTMARK,
3377 key: FPDF_BYTESTRING,
3378 value: ::std::os::raw::c_int,
3379 ) -> FPDF_BOOL;
3380}
3381unsafe extern "C" {
3382 #[doc = " Experimental API.\n Set the value of a float property in a content mark by key. If a parameter\n with key |key| exists, its value is set to |value|. Otherwise, it is added as\n a new parameter.\n\n document - handle to the document.\n page_object - handle to the page object with the mark.\n mark - handle to a content mark.\n key - string key of the property.\n value - float value to set.\n\n Returns TRUE if the operation succeeded, FALSE otherwise."]
3383 pub fn FPDFPageObjMark_SetFloatParam(
3384 document: FPDF_DOCUMENT,
3385 page_object: FPDF_PAGEOBJECT,
3386 mark: FPDF_PAGEOBJECTMARK,
3387 key: FPDF_BYTESTRING,
3388 value: f32,
3389 ) -> FPDF_BOOL;
3390}
3391unsafe extern "C" {
3392 #[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."]
3393 pub fn FPDFPageObjMark_SetStringParam(
3394 document: FPDF_DOCUMENT,
3395 page_object: FPDF_PAGEOBJECT,
3396 mark: FPDF_PAGEOBJECTMARK,
3397 key: FPDF_BYTESTRING,
3398 value: FPDF_BYTESTRING,
3399 ) -> FPDF_BOOL;
3400}
3401unsafe extern "C" {
3402 #[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."]
3403 pub fn FPDFPageObjMark_SetBlobParam(
3404 document: FPDF_DOCUMENT,
3405 page_object: FPDF_PAGEOBJECT,
3406 mark: FPDF_PAGEOBJECTMARK,
3407 key: FPDF_BYTESTRING,
3408 value: *const ::std::os::raw::c_uchar,
3409 value_len: ::std::os::raw::c_ulong,
3410 ) -> FPDF_BOOL;
3411}
3412unsafe extern "C" {
3413 #[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."]
3414 pub fn FPDFPageObjMark_RemoveParam(
3415 page_object: FPDF_PAGEOBJECT,
3416 mark: FPDF_PAGEOBJECTMARK,
3417 key: FPDF_BYTESTRING,
3418 ) -> FPDF_BOOL;
3419}
3420unsafe extern "C" {
3421 #[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."]
3422 pub fn FPDFImageObj_LoadJpegFile(
3423 pages: *mut FPDF_PAGE,
3424 count: ::std::os::raw::c_int,
3425 image_object: FPDF_PAGEOBJECT,
3426 file_access: *mut FPDF_FILEACCESS,
3427 ) -> FPDF_BOOL;
3428}
3429unsafe extern "C" {
3430 #[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."]
3431 pub fn FPDFImageObj_LoadJpegFileInline(
3432 pages: *mut FPDF_PAGE,
3433 count: ::std::os::raw::c_int,
3434 image_object: FPDF_PAGEOBJECT,
3435 file_access: *mut FPDF_FILEACCESS,
3436 ) -> FPDF_BOOL;
3437}
3438unsafe extern "C" {
3439 #[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."]
3440 pub fn FPDFImageObj_SetMatrix(
3441 image_object: FPDF_PAGEOBJECT,
3442 a: f64,
3443 b: f64,
3444 c: f64,
3445 d: f64,
3446 e: f64,
3447 f: f64,
3448 ) -> FPDF_BOOL;
3449}
3450unsafe extern "C" {
3451 #[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."]
3452 pub fn FPDFImageObj_SetBitmap(
3453 pages: *mut FPDF_PAGE,
3454 count: ::std::os::raw::c_int,
3455 image_object: FPDF_PAGEOBJECT,
3456 bitmap: FPDF_BITMAP,
3457 ) -> FPDF_BOOL;
3458}
3459unsafe extern "C" {
3460 #[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."]
3461 pub fn FPDFImageObj_GetBitmap(image_object: FPDF_PAGEOBJECT) -> FPDF_BITMAP;
3462}
3463unsafe extern "C" {
3464 #[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."]
3465 pub fn FPDFImageObj_GetRenderedBitmap(
3466 document: FPDF_DOCUMENT,
3467 page: FPDF_PAGE,
3468 image_object: FPDF_PAGEOBJECT,
3469 ) -> FPDF_BITMAP;
3470}
3471unsafe extern "C" {
3472 #[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."]
3473 pub fn FPDFImageObj_GetImageDataDecoded(
3474 image_object: FPDF_PAGEOBJECT,
3475 buffer: *mut ::std::os::raw::c_void,
3476 buflen: ::std::os::raw::c_ulong,
3477 ) -> ::std::os::raw::c_ulong;
3478}
3479unsafe extern "C" {
3480 #[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."]
3481 pub fn FPDFImageObj_GetImageDataRaw(
3482 image_object: FPDF_PAGEOBJECT,
3483 buffer: *mut ::std::os::raw::c_void,
3484 buflen: ::std::os::raw::c_ulong,
3485 ) -> ::std::os::raw::c_ulong;
3486}
3487unsafe extern "C" {
3488 #[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."]
3489 pub fn FPDFImageObj_GetImageFilterCount(image_object: FPDF_PAGEOBJECT)
3490 -> ::std::os::raw::c_int;
3491}
3492unsafe extern "C" {
3493 #[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."]
3494 pub fn FPDFImageObj_GetImageFilter(
3495 image_object: FPDF_PAGEOBJECT,
3496 index: ::std::os::raw::c_int,
3497 buffer: *mut ::std::os::raw::c_void,
3498 buflen: ::std::os::raw::c_ulong,
3499 ) -> ::std::os::raw::c_ulong;
3500}
3501unsafe extern "C" {
3502 #[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."]
3503 pub fn FPDFImageObj_GetImageMetadata(
3504 image_object: FPDF_PAGEOBJECT,
3505 page: FPDF_PAGE,
3506 metadata: *mut FPDF_IMAGEOBJ_METADATA,
3507 ) -> FPDF_BOOL;
3508}
3509unsafe extern "C" {
3510 #[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."]
3511 pub fn FPDFImageObj_GetImagePixelSize(
3512 image_object: FPDF_PAGEOBJECT,
3513 width: *mut ::std::os::raw::c_uint,
3514 height: *mut ::std::os::raw::c_uint,
3515 ) -> FPDF_BOOL;
3516}
3517unsafe extern "C" {
3518 #[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|."]
3519 pub fn FPDFImageObj_GetIccProfileDataDecoded(
3520 image_object: FPDF_PAGEOBJECT,
3521 page: FPDF_PAGE,
3522 buffer: *mut u8,
3523 buflen: usize,
3524 out_buflen: *mut usize,
3525 ) -> FPDF_BOOL;
3526}
3527unsafe extern "C" {
3528 #[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."]
3529 pub fn FPDFPageObj_CreateNewPath(x: f32, y: f32) -> FPDF_PAGEOBJECT;
3530}
3531unsafe extern "C" {
3532 #[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."]
3533 pub fn FPDFPageObj_CreateNewRect(x: f32, y: f32, w: f32, h: f32) -> FPDF_PAGEOBJECT;
3534}
3535unsafe extern "C" {
3536 #[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."]
3537 pub fn FPDFPageObj_GetBounds(
3538 page_object: FPDF_PAGEOBJECT,
3539 left: *mut f32,
3540 bottom: *mut f32,
3541 right: *mut f32,
3542 top: *mut f32,
3543 ) -> FPDF_BOOL;
3544}
3545unsafe extern "C" {
3546 #[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."]
3547 pub fn FPDFPageObj_GetRotatedBounds(
3548 page_object: FPDF_PAGEOBJECT,
3549 quad_points: *mut FS_QUADPOINTSF,
3550 ) -> FPDF_BOOL;
3551}
3552unsafe extern "C" {
3553 #[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"]
3554 pub fn FPDFPageObj_SetBlendMode(page_object: FPDF_PAGEOBJECT, blend_mode: FPDF_BYTESTRING);
3555}
3556unsafe extern "C" {
3557 #[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."]
3558 pub fn FPDFPageObj_SetStrokeColor(
3559 page_object: FPDF_PAGEOBJECT,
3560 R: ::std::os::raw::c_uint,
3561 G: ::std::os::raw::c_uint,
3562 B: ::std::os::raw::c_uint,
3563 A: ::std::os::raw::c_uint,
3564 ) -> FPDF_BOOL;
3565}
3566unsafe extern "C" {
3567 #[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."]
3568 pub fn FPDFPageObj_GetStrokeColor(
3569 page_object: FPDF_PAGEOBJECT,
3570 R: *mut ::std::os::raw::c_uint,
3571 G: *mut ::std::os::raw::c_uint,
3572 B: *mut ::std::os::raw::c_uint,
3573 A: *mut ::std::os::raw::c_uint,
3574 ) -> FPDF_BOOL;
3575}
3576unsafe extern "C" {
3577 #[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"]
3578 pub fn FPDFPageObj_SetStrokeWidth(page_object: FPDF_PAGEOBJECT, width: f32) -> FPDF_BOOL;
3579}
3580unsafe extern "C" {
3581 #[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"]
3582 pub fn FPDFPageObj_GetStrokeWidth(page_object: FPDF_PAGEOBJECT, width: *mut f32) -> FPDF_BOOL;
3583}
3584unsafe extern "C" {
3585 #[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"]
3586 pub fn FPDFPageObj_GetLineJoin(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3587}
3588unsafe extern "C" {
3589 #[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"]
3590 pub fn FPDFPageObj_SetLineJoin(
3591 page_object: FPDF_PAGEOBJECT,
3592 line_join: ::std::os::raw::c_int,
3593 ) -> FPDF_BOOL;
3594}
3595unsafe extern "C" {
3596 #[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"]
3597 pub fn FPDFPageObj_GetLineCap(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3598}
3599unsafe extern "C" {
3600 #[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"]
3601 pub fn FPDFPageObj_SetLineCap(
3602 page_object: FPDF_PAGEOBJECT,
3603 line_cap: ::std::os::raw::c_int,
3604 ) -> FPDF_BOOL;
3605}
3606unsafe extern "C" {
3607 #[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."]
3608 pub fn FPDFPageObj_SetFillColor(
3609 page_object: FPDF_PAGEOBJECT,
3610 R: ::std::os::raw::c_uint,
3611 G: ::std::os::raw::c_uint,
3612 B: ::std::os::raw::c_uint,
3613 A: ::std::os::raw::c_uint,
3614 ) -> FPDF_BOOL;
3615}
3616unsafe extern "C" {
3617 #[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."]
3618 pub fn FPDFPageObj_GetFillColor(
3619 page_object: FPDF_PAGEOBJECT,
3620 R: *mut ::std::os::raw::c_uint,
3621 G: *mut ::std::os::raw::c_uint,
3622 B: *mut ::std::os::raw::c_uint,
3623 A: *mut ::std::os::raw::c_uint,
3624 ) -> FPDF_BOOL;
3625}
3626unsafe extern "C" {
3627 #[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."]
3628 pub fn FPDFPageObj_GetDashPhase(page_object: FPDF_PAGEOBJECT, phase: *mut f32) -> FPDF_BOOL;
3629}
3630unsafe extern "C" {
3631 #[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."]
3632 pub fn FPDFPageObj_SetDashPhase(page_object: FPDF_PAGEOBJECT, phase: f32) -> FPDF_BOOL;
3633}
3634unsafe extern "C" {
3635 #[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."]
3636 pub fn FPDFPageObj_GetDashCount(page_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3637}
3638unsafe extern "C" {
3639 #[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."]
3640 pub fn FPDFPageObj_GetDashArray(
3641 page_object: FPDF_PAGEOBJECT,
3642 dash_array: *mut f32,
3643 dash_count: usize,
3644 ) -> FPDF_BOOL;
3645}
3646unsafe extern "C" {
3647 #[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."]
3648 pub fn FPDFPageObj_SetDashArray(
3649 page_object: FPDF_PAGEOBJECT,
3650 dash_array: *const f32,
3651 dash_count: usize,
3652 phase: f32,
3653 ) -> FPDF_BOOL;
3654}
3655unsafe extern "C" {
3656 #[doc = " Experimental API.\n Get a bitmap rasterization of the stroke pattern of |page_object|.\n To render correctly, the caller must provide the |document| associated with\n |page_object|. The returned bitmap will be owned by the caller, and\n FPDFBitmap_Destroy() must be called on the returned bitmap when it is no\n longer needed.\n\n document - handle to the document containing |page_object|.\n page_object - handle to a page object.\n\n Returns the bitmap, or NULL if the stroke is not a tiling pattern or on\n failure."]
3657 pub fn FPDFPageObj_GetRenderedStrokePattern(
3658 document: FPDF_DOCUMENT,
3659 page_object: FPDF_PAGEOBJECT,
3660 ) -> FPDF_BITMAP;
3661}
3662unsafe extern "C" {
3663 #[doc = " Experimental API.\n Get a bitmap rasterization of the fill pattern of |page_object|.\n To render correctly, the caller must provide the |document| associated with\n |page_object|. The returned bitmap will be owned by the caller, and\n FPDFBitmap_Destroy() must be called on the returned bitmap when it is no\n longer needed.\n\n document - handle to the document containing |page_object|.\n page_object - handle to a page object.\n\n Returns the bitmap, or NULL if the fill is not a tiling pattern or on\n failure."]
3664 pub fn FPDFPageObj_GetRenderedFillPattern(
3665 document: FPDF_DOCUMENT,
3666 page_object: FPDF_PAGEOBJECT,
3667 ) -> FPDF_BITMAP;
3668}
3669unsafe extern "C" {
3670 #[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."]
3671 pub fn FPDFPath_CountSegments(path: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3672}
3673unsafe extern "C" {
3674 #[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."]
3675 pub fn FPDFPath_GetPathSegment(
3676 path: FPDF_PAGEOBJECT,
3677 index: ::std::os::raw::c_int,
3678 ) -> FPDF_PATHSEGMENT;
3679}
3680unsafe extern "C" {
3681 #[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."]
3682 pub fn FPDFPathSegment_GetPoint(
3683 segment: FPDF_PATHSEGMENT,
3684 x: *mut f32,
3685 y: *mut f32,
3686 ) -> FPDF_BOOL;
3687}
3688unsafe extern "C" {
3689 #[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."]
3690 pub fn FPDFPathSegment_GetType(segment: FPDF_PATHSEGMENT) -> ::std::os::raw::c_int;
3691}
3692unsafe extern "C" {
3693 #[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."]
3694 pub fn FPDFPathSegment_GetClose(segment: FPDF_PATHSEGMENT) -> FPDF_BOOL;
3695}
3696unsafe extern "C" {
3697 #[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"]
3698 pub fn FPDFPath_MoveTo(path: FPDF_PAGEOBJECT, x: f32, y: f32) -> FPDF_BOOL;
3699}
3700unsafe extern "C" {
3701 #[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"]
3702 pub fn FPDFPath_LineTo(path: FPDF_PAGEOBJECT, x: f32, y: f32) -> FPDF_BOOL;
3703}
3704unsafe extern "C" {
3705 #[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"]
3706 pub fn FPDFPath_BezierTo(
3707 path: FPDF_PAGEOBJECT,
3708 x1: f32,
3709 y1: f32,
3710 x2: f32,
3711 y2: f32,
3712 x3: f32,
3713 y3: f32,
3714 ) -> FPDF_BOOL;
3715}
3716unsafe extern "C" {
3717 #[doc = " Experimental API.\n Get the two control points of a cubic Bezier segment in |path| at |index|.\n\n path - handle to a path.\n index - the index of the endpoint of a cubic Bezier segment.\n first_control_point - the first control point.\n second_control_point - the second control point.\n\n Returns TRUE on success. Returns FALSE when |path| is not a valid path,\n |index| is out of bounds, the indexed segment is not the endpoint of a cubic\n Bezier segment, or either output pointer is NULL. On failure, the output\n parameters are not modified."]
3718 pub fn FPDFPath_GetBezierControlPoints(
3719 path: FPDF_PAGEOBJECT,
3720 index: usize,
3721 first_control_point: *mut FS_POINTF,
3722 second_control_point: *mut FS_POINTF,
3723 ) -> FPDF_BOOL;
3724}
3725unsafe extern "C" {
3726 #[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"]
3727 pub fn FPDFPath_Close(path: FPDF_PAGEOBJECT) -> FPDF_BOOL;
3728}
3729unsafe extern "C" {
3730 #[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"]
3731 pub fn FPDFPath_SetDrawMode(
3732 path: FPDF_PAGEOBJECT,
3733 fillmode: ::std::os::raw::c_int,
3734 stroke: FPDF_BOOL,
3735 ) -> FPDF_BOOL;
3736}
3737unsafe extern "C" {
3738 #[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"]
3739 pub fn FPDFPath_GetDrawMode(
3740 path: FPDF_PAGEOBJECT,
3741 fillmode: *mut ::std::os::raw::c_int,
3742 stroke: *mut FPDF_BOOL,
3743 ) -> FPDF_BOOL;
3744}
3745unsafe extern "C" {
3746 #[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"]
3747 pub fn FPDFPageObj_NewTextObj(
3748 document: FPDF_DOCUMENT,
3749 font: FPDF_BYTESTRING,
3750 font_size: f32,
3751 ) -> FPDF_PAGEOBJECT;
3752}
3753unsafe extern "C" {
3754 #[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. Fails if |text_object| is null or if |text| is\n empty."]
3755 pub fn FPDFText_SetText(text_object: FPDF_PAGEOBJECT, text: FPDF_WIDESTRING) -> FPDF_BOOL;
3756}
3757unsafe extern "C" {
3758 #[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. Fails if |text_object| or |charcodes| is null, or\n |count| is 0."]
3759 pub fn FPDFText_SetCharcodes(
3760 text_object: FPDF_PAGEOBJECT,
3761 charcodes: *const u32,
3762 count: usize,
3763 ) -> FPDF_BOOL;
3764}
3765unsafe extern "C" {
3766 #[doc = " Experimental API.\n Set the character positions for a text object.\n\n text_object - handle to the text object.\n positions - pointer to an array of character positions to be set.\n count - number of elements in |positions|.\n\n The |positions| array specifies the position in points for each character\n except the first one. The first character has an implied position value of 0.\n All positions are relative to the origin of the text object. The direction is\n either horizontal or vertical, depending on the direction of text in\n |text_object|.\n\n For a text object with N characters, |count| must be N - 1. Therefore this\n API fails when N <= 1.\n\n Returns TRUE on success."]
3767 pub fn FPDFText_SetPositions(
3768 text_object: FPDF_PAGEOBJECT,
3769 positions: *const f32,
3770 count: usize,
3771 ) -> FPDF_BOOL;
3772}
3773unsafe extern "C" {
3774 #[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"]
3775 pub fn FPDFText_LoadFont(
3776 document: FPDF_DOCUMENT,
3777 data: *const u8,
3778 size: u32,
3779 font_type: ::std::os::raw::c_int,
3780 cid: FPDF_BOOL,
3781 ) -> FPDF_FONT;
3782}
3783unsafe extern "C" {
3784 #[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."]
3785 pub fn FPDFText_LoadStandardFont(document: FPDF_DOCUMENT, font: FPDF_BYTESTRING) -> FPDF_FONT;
3786}
3787unsafe extern "C" {
3788 #[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."]
3789 pub fn FPDFText_LoadCidType2Font(
3790 document: FPDF_DOCUMENT,
3791 font_data: *const u8,
3792 font_data_size: u32,
3793 to_unicode_cmap: FPDF_BYTESTRING,
3794 cid_to_gid_map_data: *const u8,
3795 cid_to_gid_map_data_size: u32,
3796 ) -> FPDF_FONT;
3797}
3798unsafe extern "C" {
3799 #[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."]
3800 pub fn FPDFTextObj_GetFontSize(text: FPDF_PAGEOBJECT, size: *mut f32) -> FPDF_BOOL;
3801}
3802unsafe extern "C" {
3803 #[doc = " Experimental API.\n Set the font size of a text object.\n\n text - handle to a text page object.\n size - the new font size, measured in points (1/72 inch). Must be\n non-negative; zero is permitted to mirror\n FPDFPageObj_NewTextObj() with size 0.\n\n Returns TRUE on success. Returns FALSE when |text| is not a text\n page object, or when |size| is negative."]
3804 pub fn FPDFTextObj_SetFontSize(text: FPDF_PAGEOBJECT, size: f32) -> FPDF_BOOL;
3805}
3806unsafe extern "C" {
3807 #[doc = " Close a loaded PDF font.\n\n font - Handle to the loaded font."]
3808 pub fn FPDFFont_Close(font: FPDF_FONT);
3809}
3810unsafe extern "C" {
3811 #[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"]
3812 pub fn FPDFPageObj_CreateTextObj(
3813 document: FPDF_DOCUMENT,
3814 font: FPDF_FONT,
3815 font_size: f32,
3816 ) -> FPDF_PAGEOBJECT;
3817}
3818unsafe extern "C" {
3819 #[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."]
3820 pub fn FPDFTextObj_GetTextRenderMode(text: FPDF_PAGEOBJECT) -> FPDF_TEXT_RENDERMODE;
3821}
3822unsafe extern "C" {
3823 #[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."]
3824 pub fn FPDFTextObj_SetTextRenderMode(
3825 text: FPDF_PAGEOBJECT,
3826 render_mode: FPDF_TEXT_RENDERMODE,
3827 ) -> FPDF_BOOL;
3828}
3829unsafe extern "C" {
3830 #[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."]
3831 pub fn FPDFTextObj_GetText(
3832 text_object: FPDF_PAGEOBJECT,
3833 text_page: FPDF_TEXTPAGE,
3834 buffer: *mut FPDF_WCHAR,
3835 length: ::std::os::raw::c_ulong,
3836 ) -> ::std::os::raw::c_ulong;
3837}
3838unsafe extern "C" {
3839 #[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."]
3840 pub fn FPDFTextObj_GetRenderedBitmap(
3841 document: FPDF_DOCUMENT,
3842 page: FPDF_PAGE,
3843 text_object: FPDF_PAGEOBJECT,
3844 scale: f32,
3845 ) -> FPDF_BITMAP;
3846}
3847unsafe extern "C" {
3848 #[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."]
3849 pub fn FPDFTextObj_GetFont(text: FPDF_PAGEOBJECT) -> FPDF_FONT;
3850}
3851unsafe extern "C" {
3852 #[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."]
3853 pub fn FPDFFont_GetBaseFontName(
3854 font: FPDF_FONT,
3855 buffer: *mut ::std::os::raw::c_char,
3856 length: usize,
3857 ) -> usize;
3858}
3859unsafe extern "C" {
3860 #[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."]
3861 pub fn FPDFFont_GetFamilyName(
3862 font: FPDF_FONT,
3863 buffer: *mut ::std::os::raw::c_char,
3864 length: usize,
3865 ) -> usize;
3866}
3867unsafe extern "C" {
3868 #[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."]
3869 pub fn FPDFFont_GetFontData(
3870 font: FPDF_FONT,
3871 buffer: *mut u8,
3872 buflen: usize,
3873 out_buflen: *mut usize,
3874 ) -> FPDF_BOOL;
3875}
3876unsafe extern "C" {
3877 #[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."]
3878 pub fn FPDFFont_GetIsEmbedded(font: FPDF_FONT) -> ::std::os::raw::c_int;
3879}
3880unsafe extern "C" {
3881 #[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."]
3882 pub fn FPDFFont_GetFlags(font: FPDF_FONT) -> ::std::os::raw::c_int;
3883}
3884unsafe extern "C" {
3885 #[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)."]
3886 pub fn FPDFFont_GetWeight(font: FPDF_FONT) -> ::std::os::raw::c_int;
3887}
3888unsafe extern "C" {
3889 #[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."]
3890 pub fn FPDFFont_GetItalicAngle(font: FPDF_FONT, angle: *mut ::std::os::raw::c_int)
3891 -> FPDF_BOOL;
3892}
3893unsafe extern "C" {
3894 #[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."]
3895 pub fn FPDFFont_GetAscent(font: FPDF_FONT, font_size: f32, ascent: *mut f32) -> FPDF_BOOL;
3896}
3897unsafe extern "C" {
3898 #[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."]
3899 pub fn FPDFFont_GetDescent(font: FPDF_FONT, font_size: f32, descent: *mut f32) -> FPDF_BOOL;
3900}
3901unsafe extern "C" {
3902 #[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."]
3903 pub fn FPDFFont_GetGlyphWidth(
3904 font: FPDF_FONT,
3905 glyph: u32,
3906 font_size: f32,
3907 width: *mut f32,
3908 ) -> FPDF_BOOL;
3909}
3910unsafe extern "C" {
3911 #[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."]
3912 pub fn FPDFFont_GetGlyphPath(font: FPDF_FONT, glyph: u32, font_size: f32) -> FPDF_GLYPHPATH;
3913}
3914unsafe extern "C" {
3915 #[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."]
3916 pub fn FPDFGlyphPath_CountGlyphSegments(glyphpath: FPDF_GLYPHPATH) -> ::std::os::raw::c_int;
3917}
3918unsafe extern "C" {
3919 #[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."]
3920 pub fn FPDFGlyphPath_GetGlyphPathSegment(
3921 glyphpath: FPDF_GLYPHPATH,
3922 index: ::std::os::raw::c_int,
3923 ) -> FPDF_PATHSEGMENT;
3924}
3925unsafe extern "C" {
3926 #[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."]
3927 pub fn FPDFFormObj_CountObjects(form_object: FPDF_PAGEOBJECT) -> ::std::os::raw::c_int;
3928}
3929unsafe extern "C" {
3930 #[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."]
3931 pub fn FPDFFormObj_GetObject(
3932 form_object: FPDF_PAGEOBJECT,
3933 index: ::std::os::raw::c_ulong,
3934 ) -> FPDF_PAGEOBJECT;
3935}
3936unsafe extern "C" {
3937 #[doc = " Experimental API.\n\n Remove |page_object| from |form_object|.\n\n form_object - handle to a form object.\n page_object - handle to a page object to be removed from the form.\n\n Returns TRUE on success.\n\n Ownership of the removed |page_object| is transferred to the caller.\n Call FPDFPageObj_Destroy() on the removed page_object to free it."]
3938 pub fn FPDFFormObj_RemoveObject(
3939 form_object: FPDF_PAGEOBJECT,
3940 page_object: FPDF_PAGEOBJECT,
3941 ) -> FPDF_BOOL;
3942}
3943#[doc = " IFPDF_RENDERINFO interface."]
3944#[repr(C)]
3945#[derive(Debug, Copy, Clone)]
3946pub struct _IFSDK_PAUSE {
3947 #[doc = " Version number of the interface. Currently must be 1."]
3948 pub version: ::std::os::raw::c_int,
3949 #[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."]
3950 pub NeedToPauseNow:
3951 ::std::option::Option<unsafe extern "C" fn(pThis: *mut _IFSDK_PAUSE) -> FPDF_BOOL>,
3952 #[doc = " A user defined data pointer, used by user's application. Can be NULL."]
3953 pub user: *mut ::std::os::raw::c_void,
3954}
3955#[doc = " IFPDF_RENDERINFO interface."]
3956pub type IFSDK_PAUSE = _IFSDK_PAUSE;
3957unsafe extern "C" {
3958 #[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."]
3959 pub fn FPDF_RenderPageBitmapWithColorScheme_Start(
3960 bitmap: FPDF_BITMAP,
3961 page: FPDF_PAGE,
3962 start_x: ::std::os::raw::c_int,
3963 start_y: ::std::os::raw::c_int,
3964 size_x: ::std::os::raw::c_int,
3965 size_y: ::std::os::raw::c_int,
3966 rotate: ::std::os::raw::c_int,
3967 flags: ::std::os::raw::c_int,
3968 color_scheme: *const FPDF_COLORSCHEME,
3969 pause: *mut IFSDK_PAUSE,
3970 ) -> ::std::os::raw::c_int;
3971}
3972unsafe extern "C" {
3973 #[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."]
3974 pub fn FPDF_RenderPageBitmap_Start(
3975 bitmap: FPDF_BITMAP,
3976 page: FPDF_PAGE,
3977 start_x: ::std::os::raw::c_int,
3978 start_y: ::std::os::raw::c_int,
3979 size_x: ::std::os::raw::c_int,
3980 size_y: ::std::os::raw::c_int,
3981 rotate: ::std::os::raw::c_int,
3982 flags: ::std::os::raw::c_int,
3983 pause: *mut IFSDK_PAUSE,
3984 ) -> ::std::os::raw::c_int;
3985}
3986unsafe extern "C" {
3987 #[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."]
3988 pub fn FPDF_RenderPage_Continue(
3989 page: FPDF_PAGE,
3990 pause: *mut IFSDK_PAUSE,
3991 ) -> ::std::os::raw::c_int;
3992}
3993unsafe extern "C" {
3994 #[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."]
3995 pub fn FPDF_RenderPage_Close(page: FPDF_PAGE);
3996}
3997pub const FPDFANNOT_COLORTYPE_FPDFANNOT_COLORTYPE_Color: FPDFANNOT_COLORTYPE = 0;
3998pub const FPDFANNOT_COLORTYPE_FPDFANNOT_COLORTYPE_InteriorColor: FPDFANNOT_COLORTYPE = 1;
3999pub type FPDFANNOT_COLORTYPE = ::std::os::raw::c_uint;
4000unsafe extern "C" {
4001 #[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."]
4002 pub fn FPDFAnnot_IsSupportedSubtype(subtype: FPDF_ANNOTATION_SUBTYPE) -> FPDF_BOOL;
4003}
4004unsafe extern "C" {
4005 #[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."]
4006 pub fn FPDFPage_CreateAnnot(
4007 page: FPDF_PAGE,
4008 subtype: FPDF_ANNOTATION_SUBTYPE,
4009 ) -> FPDF_ANNOTATION;
4010}
4011unsafe extern "C" {
4012 #[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|."]
4013 pub fn FPDFPage_GetAnnotCount(page: FPDF_PAGE) -> ::std::os::raw::c_int;
4014}
4015unsafe extern "C" {
4016 #[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."]
4017 pub fn FPDFPage_GetAnnot(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_ANNOTATION;
4018}
4019unsafe extern "C" {
4020 #[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."]
4021 pub fn FPDFPage_GetAnnotIndex(page: FPDF_PAGE, annot: FPDF_ANNOTATION)
4022 -> ::std::os::raw::c_int;
4023}
4024unsafe extern "C" {
4025 #[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."]
4026 pub fn FPDFPage_CloseAnnot(annot: FPDF_ANNOTATION);
4027}
4028unsafe extern "C" {
4029 #[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."]
4030 pub fn FPDFPage_RemoveAnnot(page: FPDF_PAGE, index: ::std::os::raw::c_int) -> FPDF_BOOL;
4031}
4032unsafe extern "C" {
4033 #[doc = " Experimental API.\n Get the subtype of an annotation.\n\n annot - handle to an annotation.\n\n Returns the annotation subtype."]
4034 pub fn FPDFAnnot_GetSubtype(annot: FPDF_ANNOTATION) -> FPDF_ANNOTATION_SUBTYPE;
4035}
4036unsafe extern "C" {
4037 #[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."]
4038 pub fn FPDFAnnot_IsObjectSupportedSubtype(subtype: FPDF_ANNOTATION_SUBTYPE) -> FPDF_BOOL;
4039}
4040unsafe extern "C" {
4041 #[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."]
4042 pub fn FPDFAnnot_UpdateObject(annot: FPDF_ANNOTATION, obj: FPDF_PAGEOBJECT) -> FPDF_BOOL;
4043}
4044unsafe extern "C" {
4045 #[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."]
4046 pub fn FPDFAnnot_AddInkStroke(
4047 annot: FPDF_ANNOTATION,
4048 points: *const FS_POINTF,
4049 point_count: usize,
4050 ) -> ::std::os::raw::c_int;
4051}
4052unsafe extern "C" {
4053 #[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."]
4054 pub fn FPDFAnnot_RemoveInkList(annot: FPDF_ANNOTATION) -> FPDF_BOOL;
4055}
4056unsafe extern "C" {
4057 #[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."]
4058 pub fn FPDFAnnot_AppendObject(annot: FPDF_ANNOTATION, obj: FPDF_PAGEOBJECT) -> FPDF_BOOL;
4059}
4060unsafe extern "C" {
4061 #[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|."]
4062 pub fn FPDFAnnot_GetObjectCount(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_int;
4063}
4064unsafe extern "C" {
4065 #[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."]
4066 pub fn FPDFAnnot_GetObject(
4067 annot: FPDF_ANNOTATION,
4068 index: ::std::os::raw::c_int,
4069 ) -> FPDF_PAGEOBJECT;
4070}
4071unsafe extern "C" {
4072 #[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."]
4073 pub fn FPDFAnnot_RemoveObject(
4074 annot: FPDF_ANNOTATION,
4075 index: ::std::os::raw::c_int,
4076 ) -> FPDF_BOOL;
4077}
4078unsafe extern "C" {
4079 #[doc = " Experimental API.\n Set the color of an annotation. Fails when called on annotations with\n appearance streams already defined; instead use\n FPDFPageObj_Set{Stroke|Fill}Color().\n\n annot - handle to an annotation.\n type - type of the color to be set.\n R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.\n A - buffer to hold the opacity. Ranges from 0 to 255.\n\n Returns true if successful."]
4080 pub fn FPDFAnnot_SetColor(
4081 annot: FPDF_ANNOTATION,
4082 type_: FPDFANNOT_COLORTYPE,
4083 R: ::std::os::raw::c_uint,
4084 G: ::std::os::raw::c_uint,
4085 B: ::std::os::raw::c_uint,
4086 A: ::std::os::raw::c_uint,
4087 ) -> FPDF_BOOL;
4088}
4089unsafe extern "C" {
4090 #[doc = " Experimental API.\n Get the color of an annotation. If no color is specified, default to yellow\n for highlight annotation, black for all else. Fails when called on\n annotations with appearance streams already defined; instead use\n FPDFPageObj_Get{Stroke|Fill}Color().\n\n annot - handle to an annotation.\n type - type of the color requested.\n R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.\n A - buffer to hold the opacity. Ranges from 0 to 255.\n\n Returns true if successful."]
4091 pub fn FPDFAnnot_GetColor(
4092 annot: FPDF_ANNOTATION,
4093 type_: FPDFANNOT_COLORTYPE,
4094 R: *mut ::std::os::raw::c_uint,
4095 G: *mut ::std::os::raw::c_uint,
4096 B: *mut ::std::os::raw::c_uint,
4097 A: *mut ::std::os::raw::c_uint,
4098 ) -> FPDF_BOOL;
4099}
4100unsafe extern "C" {
4101 #[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."]
4102 pub fn FPDFAnnot_HasAttachmentPoints(annot: FPDF_ANNOTATION) -> FPDF_BOOL;
4103}
4104unsafe extern "C" {
4105 #[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."]
4106 pub fn FPDFAnnot_SetAttachmentPoints(
4107 annot: FPDF_ANNOTATION,
4108 quad_index: usize,
4109 quad_points: *const FS_QUADPOINTSF,
4110 ) -> FPDF_BOOL;
4111}
4112unsafe extern "C" {
4113 #[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."]
4114 pub fn FPDFAnnot_AppendAttachmentPoints(
4115 annot: FPDF_ANNOTATION,
4116 quad_points: *const FS_QUADPOINTSF,
4117 ) -> FPDF_BOOL;
4118}
4119unsafe extern "C" {
4120 #[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."]
4121 pub fn FPDFAnnot_CountAttachmentPoints(annot: FPDF_ANNOTATION) -> usize;
4122}
4123unsafe extern "C" {
4124 #[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."]
4125 pub fn FPDFAnnot_GetAttachmentPoints(
4126 annot: FPDF_ANNOTATION,
4127 quad_index: usize,
4128 quad_points: *mut FS_QUADPOINTSF,
4129 ) -> FPDF_BOOL;
4130}
4131unsafe extern "C" {
4132 #[doc = " Experimental API.\n Set the annotation rectangle defining the location of the annotation.\n\n annot - handle to an annotation.\n rect - the annotation rectangle to be set.\n\n Returns true if successful."]
4133 pub fn FPDFAnnot_SetRect(annot: FPDF_ANNOTATION, rect: *const FS_RECTF) -> FPDF_BOOL;
4134}
4135unsafe extern "C" {
4136 #[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."]
4137 pub fn FPDFAnnot_GetRect(annot: FPDF_ANNOTATION, rect: *mut FS_RECTF) -> FPDF_BOOL;
4138}
4139unsafe extern "C" {
4140 #[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."]
4141 pub fn FPDFAnnot_GetVertices(
4142 annot: FPDF_ANNOTATION,
4143 buffer: *mut FS_POINTF,
4144 length: ::std::os::raw::c_ulong,
4145 ) -> ::std::os::raw::c_ulong;
4146}
4147unsafe extern "C" {
4148 #[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."]
4149 pub fn FPDFAnnot_GetInkListCount(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_ulong;
4150}
4151unsafe extern "C" {
4152 #[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."]
4153 pub fn FPDFAnnot_GetInkListPath(
4154 annot: FPDF_ANNOTATION,
4155 path_index: ::std::os::raw::c_ulong,
4156 buffer: *mut FS_POINTF,
4157 length: ::std::os::raw::c_ulong,
4158 ) -> ::std::os::raw::c_ulong;
4159}
4160unsafe extern "C" {
4161 #[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."]
4162 pub fn FPDFAnnot_GetLine(
4163 annot: FPDF_ANNOTATION,
4164 start: *mut FS_POINTF,
4165 end: *mut FS_POINTF,
4166 ) -> FPDF_BOOL;
4167}
4168unsafe extern "C" {
4169 #[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."]
4170 pub fn FPDFAnnot_SetBorder(
4171 annot: FPDF_ANNOTATION,
4172 horizontal_radius: f32,
4173 vertical_radius: f32,
4174 border_width: f32,
4175 ) -> FPDF_BOOL;
4176}
4177unsafe extern "C" {
4178 #[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."]
4179 pub fn FPDFAnnot_GetBorder(
4180 annot: FPDF_ANNOTATION,
4181 horizontal_radius: *mut f32,
4182 vertical_radius: *mut f32,
4183 border_width: *mut f32,
4184 ) -> FPDF_BOOL;
4185}
4186unsafe extern "C" {
4187 #[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."]
4188 pub fn FPDFAnnot_GetFormAdditionalActionJavaScript(
4189 hHandle: FPDF_FORMHANDLE,
4190 annot: FPDF_ANNOTATION,
4191 event: ::std::os::raw::c_int,
4192 buffer: *mut FPDF_WCHAR,
4193 buflen: ::std::os::raw::c_ulong,
4194 ) -> ::std::os::raw::c_ulong;
4195}
4196unsafe extern "C" {
4197 #[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."]
4198 pub fn FPDFAnnot_HasKey(annot: FPDF_ANNOTATION, key: FPDF_BYTESTRING) -> FPDF_BOOL;
4199}
4200unsafe extern "C" {
4201 #[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."]
4202 pub fn FPDFAnnot_GetValueType(annot: FPDF_ANNOTATION, key: FPDF_BYTESTRING)
4203 -> FPDF_OBJECT_TYPE;
4204}
4205unsafe extern "C" {
4206 #[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."]
4207 pub fn FPDFAnnot_SetStringValue(
4208 annot: FPDF_ANNOTATION,
4209 key: FPDF_BYTESTRING,
4210 value: FPDF_WIDESTRING,
4211 ) -> FPDF_BOOL;
4212}
4213unsafe extern "C" {
4214 #[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."]
4215 pub fn FPDFAnnot_GetStringValue(
4216 annot: FPDF_ANNOTATION,
4217 key: FPDF_BYTESTRING,
4218 buffer: *mut FPDF_WCHAR,
4219 buflen: ::std::os::raw::c_ulong,
4220 ) -> ::std::os::raw::c_ulong;
4221}
4222unsafe extern "C" {
4223 #[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."]
4224 pub fn FPDFAnnot_GetNumberValue(
4225 annot: FPDF_ANNOTATION,
4226 key: FPDF_BYTESTRING,
4227 value: *mut f32,
4228 ) -> FPDF_BOOL;
4229}
4230unsafe extern "C" {
4231 #[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."]
4232 pub fn FPDFAnnot_SetAP(
4233 annot: FPDF_ANNOTATION,
4234 appearanceMode: FPDF_ANNOT_APPEARANCEMODE,
4235 value: FPDF_WIDESTRING,
4236 ) -> FPDF_BOOL;
4237}
4238unsafe extern "C" {
4239 #[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."]
4240 pub fn FPDFAnnot_GetAP(
4241 annot: FPDF_ANNOTATION,
4242 appearanceMode: FPDF_ANNOT_APPEARANCEMODE,
4243 buffer: *mut FPDF_WCHAR,
4244 buflen: ::std::os::raw::c_ulong,
4245 ) -> ::std::os::raw::c_ulong;
4246}
4247unsafe extern "C" {
4248 #[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."]
4249 pub fn FPDFAnnot_GetLinkedAnnot(
4250 annot: FPDF_ANNOTATION,
4251 key: FPDF_BYTESTRING,
4252 ) -> FPDF_ANNOTATION;
4253}
4254unsafe extern "C" {
4255 #[doc = " Experimental API.\n Get the annotation flags of |annot|.\n\n annot - handle to an annotation.\n\n Returns the annotation flags."]
4256 pub fn FPDFAnnot_GetFlags(annot: FPDF_ANNOTATION) -> ::std::os::raw::c_int;
4257}
4258unsafe extern "C" {
4259 #[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."]
4260 pub fn FPDFAnnot_SetFlags(annot: FPDF_ANNOTATION, flags: ::std::os::raw::c_int) -> FPDF_BOOL;
4261}
4262unsafe extern "C" {
4263 #[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."]
4264 pub fn FPDFAnnot_GetFormFieldFlags(
4265 handle: FPDF_FORMHANDLE,
4266 annot: FPDF_ANNOTATION,
4267 ) -> ::std::os::raw::c_int;
4268}
4269unsafe extern "C" {
4270 #[doc = " Experimental API.\n Sets the form field flags for an interactive form annotation.\n\n handle - the handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment().\n annot - handle to an interactive form annotation.\n flags - the form field flags to be set.\n\n Returns true if successful."]
4271 pub fn FPDFAnnot_SetFormFieldFlags(
4272 handle: FPDF_FORMHANDLE,
4273 annot: FPDF_ANNOTATION,
4274 flags: ::std::os::raw::c_int,
4275 ) -> FPDF_BOOL;
4276}
4277unsafe extern "C" {
4278 #[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."]
4279 pub fn FPDFAnnot_GetFormFieldAtPoint(
4280 hHandle: FPDF_FORMHANDLE,
4281 page: FPDF_PAGE,
4282 point: *const FS_POINTF,
4283 ) -> FPDF_ANNOTATION;
4284}
4285unsafe extern "C" {
4286 #[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."]
4287 pub fn FPDFAnnot_GetFormFieldName(
4288 hHandle: FPDF_FORMHANDLE,
4289 annot: FPDF_ANNOTATION,
4290 buffer: *mut FPDF_WCHAR,
4291 buflen: ::std::os::raw::c_ulong,
4292 ) -> ::std::os::raw::c_ulong;
4293}
4294unsafe extern "C" {
4295 #[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."]
4296 pub fn FPDFAnnot_GetFormFieldAlternateName(
4297 hHandle: FPDF_FORMHANDLE,
4298 annot: FPDF_ANNOTATION,
4299 buffer: *mut FPDF_WCHAR,
4300 buflen: ::std::os::raw::c_ulong,
4301 ) -> ::std::os::raw::c_ulong;
4302}
4303unsafe extern "C" {
4304 #[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."]
4305 pub fn FPDFAnnot_GetFormFieldType(
4306 hHandle: FPDF_FORMHANDLE,
4307 annot: FPDF_ANNOTATION,
4308 ) -> ::std::os::raw::c_int;
4309}
4310unsafe extern "C" {
4311 #[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."]
4312 pub fn FPDFAnnot_GetFormFieldValue(
4313 hHandle: FPDF_FORMHANDLE,
4314 annot: FPDF_ANNOTATION,
4315 buffer: *mut FPDF_WCHAR,
4316 buflen: ::std::os::raw::c_ulong,
4317 ) -> ::std::os::raw::c_ulong;
4318}
4319unsafe extern "C" {
4320 #[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."]
4321 pub fn FPDFAnnot_GetOptionCount(
4322 hHandle: FPDF_FORMHANDLE,
4323 annot: FPDF_ANNOTATION,
4324 ) -> ::std::os::raw::c_int;
4325}
4326unsafe extern "C" {
4327 #[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."]
4328 pub fn FPDFAnnot_GetOptionLabel(
4329 hHandle: FPDF_FORMHANDLE,
4330 annot: FPDF_ANNOTATION,
4331 index: ::std::os::raw::c_int,
4332 buffer: *mut FPDF_WCHAR,
4333 buflen: ::std::os::raw::c_ulong,
4334 ) -> ::std::os::raw::c_ulong;
4335}
4336unsafe extern "C" {
4337 #[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."]
4338 pub fn FPDFAnnot_IsOptionSelected(
4339 handle: FPDF_FORMHANDLE,
4340 annot: FPDF_ANNOTATION,
4341 index: ::std::os::raw::c_int,
4342 ) -> FPDF_BOOL;
4343}
4344unsafe extern "C" {
4345 #[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."]
4346 pub fn FPDFAnnot_GetFontSize(
4347 hHandle: FPDF_FORMHANDLE,
4348 annot: FPDF_ANNOTATION,
4349 value: *mut f32,
4350 ) -> FPDF_BOOL;
4351}
4352unsafe extern "C" {
4353 #[doc = " Experimental API.\n Set the text color of an annotation.\n\n handle - handle to the form fill module, returned by\n FPDFDOC_InitFormFillEnvironment.\n annot - handle to an annotation.\n R - the red component for the text color.\n G - the green component for the text color.\n B - the blue component for the text color.\n\n Returns true if successful.\n\n Currently supported subtypes: freetext.\n The range for the color components is 0 to 255."]
4354 pub fn FPDFAnnot_SetFontColor(
4355 handle: FPDF_FORMHANDLE,
4356 annot: FPDF_ANNOTATION,
4357 R: ::std::os::raw::c_uint,
4358 G: ::std::os::raw::c_uint,
4359 B: ::std::os::raw::c_uint,
4360 ) -> FPDF_BOOL;
4361}
4362unsafe extern "C" {
4363 #[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."]
4364 pub fn FPDFAnnot_GetFontColor(
4365 hHandle: FPDF_FORMHANDLE,
4366 annot: FPDF_ANNOTATION,
4367 R: *mut ::std::os::raw::c_uint,
4368 G: *mut ::std::os::raw::c_uint,
4369 B: *mut ::std::os::raw::c_uint,
4370 ) -> FPDF_BOOL;
4371}
4372unsafe extern "C" {
4373 #[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."]
4374 pub fn FPDFAnnot_IsChecked(hHandle: FPDF_FORMHANDLE, annot: FPDF_ANNOTATION) -> FPDF_BOOL;
4375}
4376unsafe extern "C" {
4377 #[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."]
4378 pub fn FPDFAnnot_SetFocusableSubtypes(
4379 hHandle: FPDF_FORMHANDLE,
4380 subtypes: *const FPDF_ANNOTATION_SUBTYPE,
4381 count: usize,
4382 ) -> FPDF_BOOL;
4383}
4384unsafe extern "C" {
4385 #[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."]
4386 pub fn FPDFAnnot_GetFocusableSubtypesCount(hHandle: FPDF_FORMHANDLE) -> ::std::os::raw::c_int;
4387}
4388unsafe extern "C" {
4389 #[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."]
4390 pub fn FPDFAnnot_GetFocusableSubtypes(
4391 hHandle: FPDF_FORMHANDLE,
4392 subtypes: *mut FPDF_ANNOTATION_SUBTYPE,
4393 count: usize,
4394 ) -> FPDF_BOOL;
4395}
4396unsafe extern "C" {
4397 #[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."]
4398 pub fn FPDFAnnot_GetLink(annot: FPDF_ANNOTATION) -> FPDF_LINK;
4399}
4400unsafe extern "C" {
4401 #[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."]
4402 pub fn FPDFAnnot_GetFormControlCount(
4403 hHandle: FPDF_FORMHANDLE,
4404 annot: FPDF_ANNOTATION,
4405 ) -> ::std::os::raw::c_int;
4406}
4407unsafe extern "C" {
4408 #[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."]
4409 pub fn FPDFAnnot_GetFormControlIndex(
4410 hHandle: FPDF_FORMHANDLE,
4411 annot: FPDF_ANNOTATION,
4412 ) -> ::std::os::raw::c_int;
4413}
4414unsafe extern "C" {
4415 #[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."]
4416 pub fn FPDFAnnot_GetFormFieldExportValue(
4417 hHandle: FPDF_FORMHANDLE,
4418 annot: FPDF_ANNOTATION,
4419 buffer: *mut FPDF_WCHAR,
4420 buflen: ::std::os::raw::c_ulong,
4421 ) -> ::std::os::raw::c_ulong;
4422}
4423unsafe extern "C" {
4424 #[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."]
4425 pub fn FPDFAnnot_SetURI(
4426 annot: FPDF_ANNOTATION,
4427 uri: *const ::std::os::raw::c_char,
4428 ) -> FPDF_BOOL;
4429}
4430unsafe extern "C" {
4431 #[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."]
4432 pub fn FPDFAnnot_GetFileAttachment(annot: FPDF_ANNOTATION) -> FPDF_ATTACHMENT;
4433}
4434unsafe extern "C" {
4435 #[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."]
4436 pub fn FPDFAnnot_AddFileAttachment(
4437 annot: FPDF_ANNOTATION,
4438 name: FPDF_WIDESTRING,
4439 ) -> FPDF_ATTACHMENT;
4440}
4441unsafe extern "C" {
4442 #[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."]
4443 pub fn FPDF_StructTree_GetForPage(page: FPDF_PAGE) -> FPDF_STRUCTTREE;
4444}
4445unsafe extern "C" {
4446 #[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."]
4447 pub fn FPDF_StructTree_Close(struct_tree: FPDF_STRUCTTREE);
4448}
4449unsafe extern "C" {
4450 #[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."]
4451 pub fn FPDF_StructTree_CountChildren(struct_tree: FPDF_STRUCTTREE) -> ::std::os::raw::c_int;
4452}
4453unsafe extern "C" {
4454 #[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."]
4455 pub fn FPDF_StructTree_GetChildAtIndex(
4456 struct_tree: FPDF_STRUCTTREE,
4457 index: ::std::os::raw::c_int,
4458 ) -> FPDF_STRUCTELEMENT;
4459}
4460unsafe extern "C" {
4461 #[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."]
4462 pub fn FPDF_StructElement_GetAltText(
4463 struct_element: FPDF_STRUCTELEMENT,
4464 buffer: *mut ::std::os::raw::c_void,
4465 buflen: ::std::os::raw::c_ulong,
4466 ) -> ::std::os::raw::c_ulong;
4467}
4468unsafe extern "C" {
4469 #[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."]
4470 pub fn FPDF_StructElement_GetActualText(
4471 struct_element: FPDF_STRUCTELEMENT,
4472 buffer: *mut ::std::os::raw::c_void,
4473 buflen: ::std::os::raw::c_ulong,
4474 ) -> ::std::os::raw::c_ulong;
4475}
4476unsafe extern "C" {
4477 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetExpansion\n Get the expansion of an abbreviation or acronym for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A buffer for output the expansion text. May be\n NULL.\n buflen - The length of the buffer, in bytes. May be 0.\n Return value:\n The number of bytes in the expansion text, including the terminating\n NUL character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n Comments:\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified."]
4478 pub fn FPDF_StructElement_GetExpansion(
4479 struct_element: FPDF_STRUCTELEMENT,
4480 buffer: *mut ::std::os::raw::c_void,
4481 buflen: ::std::os::raw::c_ulong,
4482 ) -> ::std::os::raw::c_ulong;
4483}
4484unsafe extern "C" {
4485 #[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."]
4486 pub fn FPDF_StructElement_GetID(
4487 struct_element: FPDF_STRUCTELEMENT,
4488 buffer: *mut ::std::os::raw::c_void,
4489 buflen: ::std::os::raw::c_ulong,
4490 ) -> ::std::os::raw::c_ulong;
4491}
4492unsafe extern "C" {
4493 #[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."]
4494 pub fn FPDF_StructElement_GetLang(
4495 struct_element: FPDF_STRUCTELEMENT,
4496 buffer: *mut ::std::os::raw::c_void,
4497 buflen: ::std::os::raw::c_ulong,
4498 ) -> ::std::os::raw::c_ulong;
4499}
4500unsafe extern "C" {
4501 #[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."]
4502 pub fn FPDF_StructElement_GetStringAttribute(
4503 struct_element: FPDF_STRUCTELEMENT,
4504 attr_name: FPDF_BYTESTRING,
4505 buffer: *mut ::std::os::raw::c_void,
4506 buflen: ::std::os::raw::c_ulong,
4507 ) -> ::std::os::raw::c_ulong;
4508}
4509unsafe extern "C" {
4510 #[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."]
4511 pub fn FPDF_StructElement_GetMarkedContentID(
4512 struct_element: FPDF_STRUCTELEMENT,
4513 ) -> ::std::os::raw::c_int;
4514}
4515unsafe extern "C" {
4516 #[doc = " Experimental API.\n Function: FPDF_StructElement_GetRawType\n Get the raw value of the /S entry for a given element.\n Parameters:\n struct_element - Handle to the struct element.\n buffer - A FPDF_WCHAR buffer for output text. May be NULL.\n buflen - The length of the buffer. May be 0.\n Return value:\n The number of bytes in the 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."]
4517 pub fn FPDF_StructElement_GetRawType(
4518 struct_element: FPDF_STRUCTELEMENT,
4519 buffer: *mut FPDF_WCHAR,
4520 buflen: usize,
4521 ) -> ::std::os::raw::c_ulong;
4522}
4523unsafe extern "C" {
4524 #[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."]
4525 pub fn FPDF_StructElement_GetType(
4526 struct_element: FPDF_STRUCTELEMENT,
4527 buffer: *mut ::std::os::raw::c_void,
4528 buflen: ::std::os::raw::c_ulong,
4529 ) -> ::std::os::raw::c_ulong;
4530}
4531unsafe extern "C" {
4532 #[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."]
4533 pub fn FPDF_StructElement_GetObjType(
4534 struct_element: FPDF_STRUCTELEMENT,
4535 buffer: *mut ::std::os::raw::c_void,
4536 buflen: ::std::os::raw::c_ulong,
4537 ) -> ::std::os::raw::c_ulong;
4538}
4539unsafe extern "C" {
4540 #[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."]
4541 pub fn FPDF_StructElement_GetTitle(
4542 struct_element: FPDF_STRUCTELEMENT,
4543 buffer: *mut ::std::os::raw::c_void,
4544 buflen: ::std::os::raw::c_ulong,
4545 ) -> ::std::os::raw::c_ulong;
4546}
4547unsafe extern "C" {
4548 #[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."]
4549 pub fn FPDF_StructElement_CountChildren(
4550 struct_element: FPDF_STRUCTELEMENT,
4551 ) -> ::std::os::raw::c_int;
4552}
4553unsafe extern "C" {
4554 #[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."]
4555 pub fn FPDF_StructElement_GetChildAtIndex(
4556 struct_element: FPDF_STRUCTELEMENT,
4557 index: ::std::os::raw::c_int,
4558 ) -> FPDF_STRUCTELEMENT;
4559}
4560unsafe extern "C" {
4561 #[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."]
4562 pub fn FPDF_StructElement_GetChildMarkedContentID(
4563 struct_element: FPDF_STRUCTELEMENT,
4564 index: ::std::os::raw::c_int,
4565 ) -> ::std::os::raw::c_int;
4566}
4567unsafe extern "C" {
4568 #[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."]
4569 pub fn FPDF_StructElement_GetParent(struct_element: FPDF_STRUCTELEMENT) -> FPDF_STRUCTELEMENT;
4570}
4571unsafe extern "C" {
4572 #[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."]
4573 pub fn FPDF_StructElement_GetAttributeCount(
4574 struct_element: FPDF_STRUCTELEMENT,
4575 ) -> ::std::os::raw::c_int;
4576}
4577unsafe extern "C" {
4578 #[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."]
4579 pub fn FPDF_StructElement_GetAttributeAtIndex(
4580 struct_element: FPDF_STRUCTELEMENT,
4581 index: ::std::os::raw::c_int,
4582 ) -> FPDF_STRUCTELEMENT_ATTR;
4583}
4584unsafe extern "C" {
4585 #[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."]
4586 pub fn FPDF_StructElement_Attr_GetCount(
4587 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
4588 ) -> ::std::os::raw::c_int;
4589}
4590unsafe extern "C" {
4591 #[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."]
4592 pub fn FPDF_StructElement_Attr_GetName(
4593 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
4594 index: ::std::os::raw::c_int,
4595 buffer: *mut ::std::os::raw::c_void,
4596 buflen: ::std::os::raw::c_ulong,
4597 out_buflen: *mut ::std::os::raw::c_ulong,
4598 ) -> FPDF_BOOL;
4599}
4600unsafe extern "C" {
4601 #[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."]
4602 pub fn FPDF_StructElement_Attr_GetValue(
4603 struct_attribute: FPDF_STRUCTELEMENT_ATTR,
4604 name: FPDF_BYTESTRING,
4605 ) -> FPDF_STRUCTELEMENT_ATTR_VALUE;
4606}
4607unsafe extern "C" {
4608 #[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."]
4609 pub fn FPDF_StructElement_Attr_GetType(
4610 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4611 ) -> FPDF_OBJECT_TYPE;
4612}
4613unsafe extern "C" {
4614 #[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."]
4615 pub fn FPDF_StructElement_Attr_GetBooleanValue(
4616 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4617 out_value: *mut FPDF_BOOL,
4618 ) -> FPDF_BOOL;
4619}
4620unsafe extern "C" {
4621 #[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."]
4622 pub fn FPDF_StructElement_Attr_GetNumberValue(
4623 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4624 out_value: *mut f32,
4625 ) -> FPDF_BOOL;
4626}
4627unsafe extern "C" {
4628 #[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."]
4629 pub fn FPDF_StructElement_Attr_GetStringValue(
4630 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4631 buffer: *mut ::std::os::raw::c_void,
4632 buflen: ::std::os::raw::c_ulong,
4633 out_buflen: *mut ::std::os::raw::c_ulong,
4634 ) -> FPDF_BOOL;
4635}
4636unsafe extern "C" {
4637 #[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."]
4638 pub fn FPDF_StructElement_Attr_GetBlobValue(
4639 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4640 buffer: *mut ::std::os::raw::c_void,
4641 buflen: ::std::os::raw::c_ulong,
4642 out_buflen: *mut ::std::os::raw::c_ulong,
4643 ) -> FPDF_BOOL;
4644}
4645unsafe extern "C" {
4646 #[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."]
4647 pub fn FPDF_StructElement_Attr_CountChildren(
4648 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4649 ) -> ::std::os::raw::c_int;
4650}
4651unsafe extern "C" {
4652 #[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."]
4653 pub fn FPDF_StructElement_Attr_GetChildAtIndex(
4654 value: FPDF_STRUCTELEMENT_ATTR_VALUE,
4655 index: ::std::os::raw::c_int,
4656 ) -> FPDF_STRUCTELEMENT_ATTR_VALUE;
4657}
4658unsafe extern "C" {
4659 #[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."]
4660 pub fn FPDF_StructElement_GetMarkedContentIdCount(
4661 struct_element: FPDF_STRUCTELEMENT,
4662 ) -> ::std::os::raw::c_int;
4663}
4664unsafe extern "C" {
4665 #[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()."]
4666 pub fn FPDF_StructElement_GetMarkedContentIdAtIndex(
4667 struct_element: FPDF_STRUCTELEMENT,
4668 index: ::std::os::raw::c_int,
4669 ) -> ::std::os::raw::c_int;
4670}
4671unsafe extern "C" {
4672 #[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."]
4673 pub fn FPDF_GetSignatureCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
4674}
4675unsafe extern "C" {
4676 #[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."]
4677 pub fn FPDF_GetSignatureObject(
4678 document: FPDF_DOCUMENT,
4679 index: ::std::os::raw::c_int,
4680 ) -> FPDF_SIGNATURE;
4681}
4682unsafe extern "C" {
4683 #[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."]
4684 pub fn FPDFSignatureObj_GetContents(
4685 signature: FPDF_SIGNATURE,
4686 buffer: *mut ::std::os::raw::c_void,
4687 length: ::std::os::raw::c_ulong,
4688 ) -> ::std::os::raw::c_ulong;
4689}
4690unsafe extern "C" {
4691 #[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."]
4692 pub fn FPDFSignatureObj_GetByteRange(
4693 signature: FPDF_SIGNATURE,
4694 buffer: *mut ::std::os::raw::c_int,
4695 length: ::std::os::raw::c_ulong,
4696 ) -> ::std::os::raw::c_ulong;
4697}
4698unsafe extern "C" {
4699 #[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."]
4700 pub fn FPDFSignatureObj_GetSubFilter(
4701 signature: FPDF_SIGNATURE,
4702 buffer: *mut ::std::os::raw::c_char,
4703 length: ::std::os::raw::c_ulong,
4704 ) -> ::std::os::raw::c_ulong;
4705}
4706unsafe extern "C" {
4707 #[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."]
4708 pub fn FPDFSignatureObj_GetReason(
4709 signature: FPDF_SIGNATURE,
4710 buffer: *mut ::std::os::raw::c_void,
4711 length: ::std::os::raw::c_ulong,
4712 ) -> ::std::os::raw::c_ulong;
4713}
4714unsafe extern "C" {
4715 #[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."]
4716 pub fn FPDFSignatureObj_GetTime(
4717 signature: FPDF_SIGNATURE,
4718 buffer: *mut ::std::os::raw::c_char,
4719 length: ::std::os::raw::c_ulong,
4720 ) -> ::std::os::raw::c_ulong;
4721}
4722unsafe extern "C" {
4723 #[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."]
4724 pub fn FPDFSignatureObj_GetDocMDPPermission(
4725 signature: FPDF_SIGNATURE,
4726 ) -> ::std::os::raw::c_uint;
4727}
4728unsafe extern "C" {
4729 #[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"]
4730 pub fn FPDFText_LoadPage(page: FPDF_PAGE) -> FPDF_TEXTPAGE;
4731}
4732unsafe extern "C" {
4733 #[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"]
4734 pub fn FPDFText_ClosePage(text_page: FPDF_TEXTPAGE);
4735}
4736unsafe extern "C" {
4737 #[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"]
4738 pub fn FPDFText_CountChars(text_page: FPDF_TEXTPAGE) -> ::std::os::raw::c_int;
4739}
4740unsafe extern "C" {
4741 #[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"]
4742 pub fn FPDFText_GetUnicode(
4743 text_page: FPDF_TEXTPAGE,
4744 index: ::std::os::raw::c_int,
4745 ) -> ::std::os::raw::c_uint;
4746}
4747unsafe extern "C" {
4748 #[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"]
4749 pub fn FPDFText_GetTextObject(
4750 text_page: FPDF_TEXTPAGE,
4751 index: ::std::os::raw::c_int,
4752 ) -> FPDF_PAGEOBJECT;
4753}
4754unsafe extern "C" {
4755 #[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"]
4756 pub fn FPDFText_IsGenerated(
4757 text_page: FPDF_TEXTPAGE,
4758 index: ::std::os::raw::c_int,
4759 ) -> ::std::os::raw::c_int;
4760}
4761unsafe extern "C" {
4762 #[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"]
4763 pub fn FPDFText_IsHyphen(
4764 text_page: FPDF_TEXTPAGE,
4765 index: ::std::os::raw::c_int,
4766 ) -> ::std::os::raw::c_int;
4767}
4768unsafe extern "C" {
4769 #[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"]
4770 pub fn FPDFText_HasUnicodeMapError(
4771 text_page: FPDF_TEXTPAGE,
4772 index: ::std::os::raw::c_int,
4773 ) -> ::std::os::raw::c_int;
4774}
4775unsafe extern "C" {
4776 #[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"]
4777 pub fn FPDFText_GetFontSize(text_page: FPDF_TEXTPAGE, index: ::std::os::raw::c_int) -> f64;
4778}
4779unsafe extern "C" {
4780 #[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"]
4781 pub fn FPDFText_GetFontInfo(
4782 text_page: FPDF_TEXTPAGE,
4783 index: ::std::os::raw::c_int,
4784 buffer: *mut ::std::os::raw::c_void,
4785 buflen: ::std::os::raw::c_ulong,
4786 flags: *mut ::std::os::raw::c_int,
4787 ) -> ::std::os::raw::c_ulong;
4788}
4789unsafe extern "C" {
4790 #[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"]
4791 pub fn FPDFText_GetFontWeight(
4792 text_page: FPDF_TEXTPAGE,
4793 index: ::std::os::raw::c_int,
4794 ) -> ::std::os::raw::c_int;
4795}
4796unsafe extern "C" {
4797 #[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"]
4798 pub fn FPDFText_GetFillColor(
4799 text_page: FPDF_TEXTPAGE,
4800 index: ::std::os::raw::c_int,
4801 R: *mut ::std::os::raw::c_uint,
4802 G: *mut ::std::os::raw::c_uint,
4803 B: *mut ::std::os::raw::c_uint,
4804 A: *mut ::std::os::raw::c_uint,
4805 ) -> FPDF_BOOL;
4806}
4807unsafe extern "C" {
4808 #[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"]
4809 pub fn FPDFText_GetStrokeColor(
4810 text_page: FPDF_TEXTPAGE,
4811 index: ::std::os::raw::c_int,
4812 R: *mut ::std::os::raw::c_uint,
4813 G: *mut ::std::os::raw::c_uint,
4814 B: *mut ::std::os::raw::c_uint,
4815 A: *mut ::std::os::raw::c_uint,
4816 ) -> FPDF_BOOL;
4817}
4818unsafe extern "C" {
4819 #[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"]
4820 pub fn FPDFText_GetCharAngle(text_page: FPDF_TEXTPAGE, index: ::std::os::raw::c_int) -> f32;
4821}
4822unsafe extern "C" {
4823 #[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"]
4824 pub fn FPDFText_GetCharBox(
4825 text_page: FPDF_TEXTPAGE,
4826 index: ::std::os::raw::c_int,
4827 left: *mut f64,
4828 right: *mut f64,
4829 bottom: *mut f64,
4830 top: *mut f64,
4831 ) -> FPDF_BOOL;
4832}
4833unsafe extern "C" {
4834 #[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"]
4835 pub fn FPDFText_GetLooseCharBox(
4836 text_page: FPDF_TEXTPAGE,
4837 index: ::std::os::raw::c_int,
4838 rect: *mut FS_RECTF,
4839 ) -> FPDF_BOOL;
4840}
4841unsafe extern "C" {
4842 #[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"]
4843 pub fn FPDFText_GetMatrix(
4844 text_page: FPDF_TEXTPAGE,
4845 index: ::std::os::raw::c_int,
4846 matrix: *mut FS_MATRIX,
4847 ) -> FPDF_BOOL;
4848}
4849unsafe extern "C" {
4850 #[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"]
4851 pub fn FPDFText_GetCharOrigin(
4852 text_page: FPDF_TEXTPAGE,
4853 index: ::std::os::raw::c_int,
4854 x: *mut f64,
4855 y: *mut f64,
4856 ) -> FPDF_BOOL;
4857}
4858unsafe extern "C" {
4859 #[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"]
4860 pub fn FPDFText_GetCharIndexAtPos(
4861 text_page: FPDF_TEXTPAGE,
4862 x: f64,
4863 y: f64,
4864 xTolerance: f64,
4865 yTolerance: f64,
4866 ) -> ::std::os::raw::c_int;
4867}
4868unsafe extern "C" {
4869 #[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"]
4870 pub fn FPDFText_GetText(
4871 text_page: FPDF_TEXTPAGE,
4872 start_index: ::std::os::raw::c_int,
4873 count: ::std::os::raw::c_int,
4874 result: *mut ::std::os::raw::c_ushort,
4875 ) -> ::std::os::raw::c_int;
4876}
4877unsafe extern "C" {
4878 #[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"]
4879 pub fn FPDFText_CountRects(
4880 text_page: FPDF_TEXTPAGE,
4881 start_index: ::std::os::raw::c_int,
4882 count: ::std::os::raw::c_int,
4883 ) -> ::std::os::raw::c_int;
4884}
4885unsafe extern "C" {
4886 #[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"]
4887 pub fn FPDFText_GetRect(
4888 text_page: FPDF_TEXTPAGE,
4889 rect_index: ::std::os::raw::c_int,
4890 left: *mut f64,
4891 top: *mut f64,
4892 right: *mut f64,
4893 bottom: *mut f64,
4894 ) -> FPDF_BOOL;
4895}
4896unsafe extern "C" {
4897 #[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"]
4898 pub fn FPDFText_GetBoundedText(
4899 text_page: FPDF_TEXTPAGE,
4900 left: f64,
4901 top: f64,
4902 right: f64,
4903 bottom: f64,
4904 buffer: *mut ::std::os::raw::c_ushort,
4905 buflen: ::std::os::raw::c_int,
4906 ) -> ::std::os::raw::c_int;
4907}
4908unsafe extern "C" {
4909 #[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"]
4910 pub fn FPDFText_FindStart(
4911 text_page: FPDF_TEXTPAGE,
4912 findwhat: FPDF_WIDESTRING,
4913 flags: ::std::os::raw::c_ulong,
4914 start_index: ::std::os::raw::c_int,
4915 ) -> FPDF_SCHHANDLE;
4916}
4917unsafe extern "C" {
4918 #[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"]
4919 pub fn FPDFText_FindNext(handle: FPDF_SCHHANDLE) -> FPDF_BOOL;
4920}
4921unsafe extern "C" {
4922 #[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"]
4923 pub fn FPDFText_FindPrev(handle: FPDF_SCHHANDLE) -> FPDF_BOOL;
4924}
4925unsafe extern "C" {
4926 #[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"]
4927 pub fn FPDFText_GetSchResultIndex(handle: FPDF_SCHHANDLE) -> ::std::os::raw::c_int;
4928}
4929unsafe extern "C" {
4930 #[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"]
4931 pub fn FPDFText_GetSchCount(handle: FPDF_SCHHANDLE) -> ::std::os::raw::c_int;
4932}
4933unsafe extern "C" {
4934 #[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"]
4935 pub fn FPDFText_FindClose(handle: FPDF_SCHHANDLE);
4936}
4937unsafe extern "C" {
4938 #[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"]
4939 pub fn FPDFLink_LoadWebLinks(text_page: FPDF_TEXTPAGE) -> FPDF_PAGELINK;
4940}
4941unsafe extern "C" {
4942 #[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"]
4943 pub fn FPDFLink_CountWebLinks(link_page: FPDF_PAGELINK) -> ::std::os::raw::c_int;
4944}
4945unsafe extern "C" {
4946 #[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"]
4947 pub fn FPDFLink_GetURL(
4948 link_page: FPDF_PAGELINK,
4949 link_index: ::std::os::raw::c_int,
4950 buffer: *mut ::std::os::raw::c_ushort,
4951 buflen: ::std::os::raw::c_int,
4952 ) -> ::std::os::raw::c_int;
4953}
4954unsafe extern "C" {
4955 #[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"]
4956 pub fn FPDFLink_CountRects(
4957 link_page: FPDF_PAGELINK,
4958 link_index: ::std::os::raw::c_int,
4959 ) -> ::std::os::raw::c_int;
4960}
4961unsafe extern "C" {
4962 #[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"]
4963 pub fn FPDFLink_GetRect(
4964 link_page: FPDF_PAGELINK,
4965 link_index: ::std::os::raw::c_int,
4966 rect_index: ::std::os::raw::c_int,
4967 left: *mut f64,
4968 top: *mut f64,
4969 right: *mut f64,
4970 bottom: *mut f64,
4971 ) -> FPDF_BOOL;
4972}
4973unsafe extern "C" {
4974 #[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"]
4975 pub fn FPDFLink_GetTextRange(
4976 link_page: FPDF_PAGELINK,
4977 link_index: ::std::os::raw::c_int,
4978 start_char_index: *mut ::std::os::raw::c_int,
4979 char_count: *mut ::std::os::raw::c_int,
4980 ) -> FPDF_BOOL;
4981}
4982unsafe extern "C" {
4983 #[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"]
4984 pub fn FPDFLink_CloseWebLinks(link_page: FPDF_PAGELINK);
4985}
4986unsafe extern "C" {
4987 #[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."]
4988 pub fn FPDFPage_GetDecodedThumbnailData(
4989 page: FPDF_PAGE,
4990 buffer: *mut ::std::os::raw::c_void,
4991 buflen: ::std::os::raw::c_ulong,
4992 ) -> ::std::os::raw::c_ulong;
4993}
4994unsafe extern "C" {
4995 #[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."]
4996 pub fn FPDFPage_GetRawThumbnailData(
4997 page: FPDF_PAGE,
4998 buffer: *mut ::std::os::raw::c_void,
4999 buflen: ::std::os::raw::c_ulong,
5000 ) -> ::std::os::raw::c_ulong;
5001}
5002unsafe extern "C" {
5003 #[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."]
5004 pub fn FPDFPage_GetThumbnailAsBitmap(page: FPDF_PAGE) -> FPDF_BITMAP;
5005}
5006unsafe extern "C" {
5007 #[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."]
5008 pub fn FPDFCatalog_IsTagged(document: FPDF_DOCUMENT) -> FPDF_BOOL;
5009}
5010unsafe extern "C" {
5011 #[doc = " Experimental API.\n Gets the language of |document| from the catalog's /Lang entry.\n\n document - handle to a document.\n buffer - a buffer for the language string. May be NULL.\n buflen - the length of the buffer, in bytes. May be 0.\n\n Returns the number of bytes in the language string, including the\n trailing NUL character. The number of bytes is returned regardless of the\n |buffer| and |buflen| parameters.\n\n Regardless of the platform, the |buffer| is always in UTF-16LE\n encoding. The string is terminated by a UTF16 NUL character. If\n |buflen| is less than the required length, or |buffer| is NULL,\n |buffer| will not be modified.\n\n If |document| has no /Lang entry, an empty string is written to |buffer| and\n 2 is returned. On error, nothing is written to |buffer| and 0 is returned."]
5012 pub fn FPDFCatalog_GetLanguage(
5013 document: FPDF_DOCUMENT,
5014 buffer: *mut FPDF_WCHAR,
5015 buflen: ::std::os::raw::c_ulong,
5016 ) -> ::std::os::raw::c_ulong;
5017}
5018unsafe extern "C" {
5019 #[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."]
5020 pub fn FPDFCatalog_SetLanguage(document: FPDF_DOCUMENT, language: FPDF_WIDESTRING)
5021 -> FPDF_BOOL;
5022}
5023unsafe extern "C" {
5024 #[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."]
5025 pub fn FPDFPage_Flatten(page: FPDF_PAGE, nFlag: ::std::os::raw::c_int)
5026 -> ::std::os::raw::c_int;
5027}
5028#[doc = " Interface for checking whether sections of the file are available."]
5029#[repr(C)]
5030#[derive(Debug, Copy, Clone)]
5031pub struct _FX_FILEAVAIL {
5032 #[doc = " Version number of the interface. Must be 1."]
5033 pub version: ::std::os::raw::c_int,
5034 #[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."]
5035 pub IsDataAvail: ::std::option::Option<
5036 unsafe extern "C" fn(pThis: *mut _FX_FILEAVAIL, offset: usize, size: usize) -> FPDF_BOOL,
5037 >,
5038}
5039#[doc = " Interface for checking whether sections of the file are available."]
5040pub type FX_FILEAVAIL = _FX_FILEAVAIL;
5041unsafe extern "C" {
5042 #[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."]
5043 pub fn FPDFAvail_Create(
5044 file_avail: *mut FX_FILEAVAIL,
5045 file: *mut FPDF_FILEACCESS,
5046 ) -> FPDF_AVAIL;
5047}
5048unsafe extern "C" {
5049 #[doc = " Destroy the |avail| document availability provider.\n\n avail - handle to document availability provider to be destroyed."]
5050 pub fn FPDFAvail_Destroy(avail: FPDF_AVAIL);
5051}
5052#[doc = " Download hints interface. Used to receive hints for further downloading."]
5053#[repr(C)]
5054#[derive(Debug, Copy, Clone)]
5055pub struct _FX_DOWNLOADHINTS {
5056 #[doc = " Version number of the interface. Must be 1."]
5057 pub version: ::std::os::raw::c_int,
5058 #[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."]
5059 pub AddSegment: ::std::option::Option<
5060 unsafe extern "C" fn(pThis: *mut _FX_DOWNLOADHINTS, offset: usize, size: usize),
5061 >,
5062}
5063#[doc = " Download hints interface. Used to receive hints for further downloading."]
5064pub type FX_DOWNLOADHINTS = _FX_DOWNLOADHINTS;
5065unsafe extern "C" {
5066 #[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."]
5067 pub fn FPDFAvail_IsDocAvail(
5068 avail: FPDF_AVAIL,
5069 hints: *mut FX_DOWNLOADHINTS,
5070 ) -> ::std::os::raw::c_int;
5071}
5072unsafe extern "C" {
5073 #[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|."]
5074 pub fn FPDFAvail_GetDocument(avail: FPDF_AVAIL, password: FPDF_BYTESTRING) -> FPDF_DOCUMENT;
5075}
5076unsafe extern "C" {
5077 #[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."]
5078 pub fn FPDFAvail_GetFirstPageNum(doc: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
5079}
5080unsafe extern "C" {
5081 #[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."]
5082 pub fn FPDFAvail_IsPageAvail(
5083 avail: FPDF_AVAIL,
5084 page_index: ::std::os::raw::c_int,
5085 hints: *mut FX_DOWNLOADHINTS,
5086 ) -> ::std::os::raw::c_int;
5087}
5088unsafe extern "C" {
5089 #[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."]
5090 pub fn FPDFAvail_IsFormAvail(
5091 avail: FPDF_AVAIL,
5092 hints: *mut FX_DOWNLOADHINTS,
5093 ) -> ::std::os::raw::c_int;
5094}
5095unsafe extern "C" {
5096 #[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."]
5097 pub fn FPDFAvail_IsLinearized(avail: FPDF_AVAIL) -> ::std::os::raw::c_int;
5098}
5099unsafe extern "C" {
5100 #[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."]
5101 pub fn FPDFText_GetCharIndexFromTextIndex(
5102 text_page: FPDF_TEXTPAGE,
5103 nTextIndex: ::std::os::raw::c_int,
5104 ) -> ::std::os::raw::c_int;
5105}
5106unsafe extern "C" {
5107 #[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."]
5108 pub fn FPDFText_GetTextIndexFromCharIndex(
5109 text_page: FPDF_TEXTPAGE,
5110 nCharIndex: ::std::os::raw::c_int,
5111 ) -> ::std::os::raw::c_int;
5112}
5113unsafe extern "C" {
5114 #[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."]
5115 pub fn FPDFDoc_GetJavaScriptActionCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
5116}
5117unsafe extern "C" {
5118 #[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()."]
5119 pub fn FPDFDoc_GetJavaScriptAction(
5120 document: FPDF_DOCUMENT,
5121 index: ::std::os::raw::c_int,
5122 ) -> FPDF_JAVASCRIPT_ACTION;
5123}
5124unsafe extern "C" {
5125 #[doc = " javascript - Handle to a JavaScript action."]
5126 pub fn FPDFDoc_CloseJavaScriptAction(javascript: FPDF_JAVASCRIPT_ACTION);
5127}
5128unsafe extern "C" {
5129 #[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."]
5130 pub fn FPDFJavaScriptAction_GetName(
5131 javascript: FPDF_JAVASCRIPT_ACTION,
5132 buffer: *mut FPDF_WCHAR,
5133 buflen: ::std::os::raw::c_ulong,
5134 ) -> ::std::os::raw::c_ulong;
5135}
5136unsafe extern "C" {
5137 #[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."]
5138 pub fn FPDFJavaScriptAction_GetScript(
5139 javascript: FPDF_JAVASCRIPT_ACTION,
5140 buffer: *mut FPDF_WCHAR,
5141 buflen: ::std::os::raw::c_ulong,
5142 ) -> ::std::os::raw::c_ulong;
5143}
5144unsafe extern "C" {
5145 #[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|."]
5146 pub fn FPDFDoc_GetAttachmentCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;
5147}
5148unsafe extern "C" {
5149 #[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."]
5150 pub fn FPDFDoc_AddAttachment(document: FPDF_DOCUMENT, name: FPDF_WIDESTRING)
5151 -> FPDF_ATTACHMENT;
5152}
5153unsafe extern "C" {
5154 #[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."]
5155 pub fn FPDFDoc_GetAttachment(
5156 document: FPDF_DOCUMENT,
5157 index: ::std::os::raw::c_int,
5158 ) -> FPDF_ATTACHMENT;
5159}
5160unsafe extern "C" {
5161 #[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."]
5162 pub fn FPDFDoc_DeleteAttachment(
5163 document: FPDF_DOCUMENT,
5164 index: ::std::os::raw::c_int,
5165 ) -> FPDF_BOOL;
5166}
5167unsafe extern "C" {
5168 #[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."]
5169 pub fn FPDFAttachment_GetName(
5170 attachment: FPDF_ATTACHMENT,
5171 buffer: *mut FPDF_WCHAR,
5172 buflen: ::std::os::raw::c_ulong,
5173 ) -> ::std::os::raw::c_ulong;
5174}
5175unsafe extern "C" {
5176 #[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."]
5177 pub fn FPDFAttachment_HasKey(attachment: FPDF_ATTACHMENT, key: FPDF_BYTESTRING) -> FPDF_BOOL;
5178}
5179unsafe extern "C" {
5180 #[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."]
5181 pub fn FPDFAttachment_GetValueType(
5182 attachment: FPDF_ATTACHMENT,
5183 key: FPDF_BYTESTRING,
5184 ) -> FPDF_OBJECT_TYPE;
5185}
5186unsafe extern "C" {
5187 #[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."]
5188 pub fn FPDFAttachment_SetStringValue(
5189 attachment: FPDF_ATTACHMENT,
5190 key: FPDF_BYTESTRING,
5191 value: FPDF_WIDESTRING,
5192 ) -> FPDF_BOOL;
5193}
5194unsafe extern "C" {
5195 #[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."]
5196 pub fn FPDFAttachment_GetStringValue(
5197 attachment: FPDF_ATTACHMENT,
5198 key: FPDF_BYTESTRING,
5199 buffer: *mut FPDF_WCHAR,
5200 buflen: ::std::os::raw::c_ulong,
5201 ) -> ::std::os::raw::c_ulong;
5202}
5203unsafe extern "C" {
5204 #[doc = " Experimental API.\n Sets the string value corresponding to \"/Desc\" in the file specification\n dictionary (ISO 32000-1:2008 section 7.11.3) of the embedded file\n |attachment| to the string value.\n\n attachment - handle to an attachment.\n value - the string value to be set as /Desc, encoded in UTF-16LE.\n\n Returns true if successful."]
5205 pub fn FPDFAttachment_SetDescription(
5206 attachment: FPDF_ATTACHMENT,
5207 value: FPDF_WIDESTRING,
5208 ) -> FPDF_BOOL;
5209}
5210unsafe extern "C" {
5211 #[doc = " Experimental API.\n Gets the string value corresponding to \"/Desc\" in the file specification\n dictionary (ISO 32000-1:2008 section 7.11.3) of the embedded file\n |attachment|. Similarly to the above APIs, |buffer| is only modified if\n |buflen| is longer than the length of the string's value. If the key doesn't\n exist, or is not a string then 2 is returned by the API, alongside an empty\n string. Other errors return 0 instead.\n\n attachment - handle to an attachment.\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 description string in bytes."]
5212 pub fn FPDFAttachment_GetDescription(
5213 attachment: FPDF_ATTACHMENT,
5214 buffer: *mut FPDF_WCHAR,
5215 buflen: ::std::os::raw::c_ulong,
5216 ) -> ::std::os::raw::c_ulong;
5217}
5218unsafe extern "C" {
5219 #[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."]
5220 pub fn FPDFAttachment_SetFile(
5221 attachment: FPDF_ATTACHMENT,
5222 document: FPDF_DOCUMENT,
5223 contents: *const ::std::os::raw::c_void,
5224 len: ::std::os::raw::c_ulong,
5225 ) -> FPDF_BOOL;
5226}
5227unsafe extern "C" {
5228 #[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."]
5229 pub fn FPDFAttachment_GetFile(
5230 attachment: FPDF_ATTACHMENT,
5231 buffer: *mut ::std::os::raw::c_void,
5232 buflen: ::std::os::raw::c_ulong,
5233 out_buflen: *mut ::std::os::raw::c_ulong,
5234 ) -> FPDF_BOOL;
5235}
5236unsafe extern "C" {
5237 #[doc = " Experimental API.\n Get the MIME type (Subtype) of the embedded file |attachment|. |buffer| is\n only modified if |buflen| is longer than the length of the MIME type string.\n If the Subtype is not found or if there is no file stream, an empty string\n would be copied to |buffer| and the return value would be 2. On other errors,\n nothing would be added to |buffer| and the return value would be 0.\n\n attachment - handle to an attachment.\n buffer - buffer for holding the MIME type string encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the MIME type string in bytes."]
5238 pub fn FPDFAttachment_GetSubtype(
5239 attachment: FPDF_ATTACHMENT,
5240 buffer: *mut FPDF_WCHAR,
5241 buflen: ::std::os::raw::c_ulong,
5242 ) -> ::std::os::raw::c_ulong;
5243}
5244unsafe extern "C" {
5245 #[doc = " Experimental API.\n Get the associated file relationship string (the /AFRelationship entry in\n the file specification dictionary of the embedded file |attachment|; PDF\n 2.0, ISO 32000-2:2020, Table 43), e.g. \"Source\", \"Data\", \"Alternative\",\n \"Supplement\" or \"Unspecified\". |buffer| is only modified if |buflen| is\n longer than the length of the relationship name. If the /AFRelationship\n entry is absent or is not a name, an empty string is copied to |buffer| and\n the return value is 2. On other errors, |buffer| is not modified and the\n return value is 0.\n\n attachment - handle to an attachment.\n buffer - buffer for holding the relationship name encoded in UTF-16LE.\n buflen - length of the buffer in bytes.\n\n Returns the length of the relationship name in bytes."]
5246 pub fn FPDFAttachment_GetAFRelationship(
5247 attachment: FPDF_ATTACHMENT,
5248 buffer: *mut FPDF_WCHAR,
5249 buflen: ::std::os::raw::c_ulong,
5250 ) -> ::std::os::raw::c_ulong;
5251}
5252#[doc = " 13 = __LC_LAST."]
5253#[repr(C)]
5254#[derive(Debug, Copy, Clone)]
5255pub struct __locale_data {
5256 pub _address: u8,
5257}