summaryrefslogtreecommitdiff
path: root/public/fpdfview.h
blob: 158f8215a45569e036eb84cc7fde083dd31c17b3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

// NOTE: External docs refer to this file as "fpdfview.h", so do not rename
// despite lack of consitency with other public files.

#ifndef PUBLIC_FPDFVIEW_H_
#define PUBLIC_FPDFVIEW_H_

#if defined(_WIN32) && !defined(__WINDOWS__)
#include <windows.h>
#endif

//  TODO: remove the #define when XFA is officially in pdfium
#define PDF_USE_XFA

// Data types
typedef void* FPDF_MODULEMGR;

// PDF types
typedef void* FPDF_DOCUMENT;
typedef void* FPDF_PAGE;
typedef void* FPDF_WIDGET;
typedef void* FPDF_STRINGHANDLE;
typedef void* FPDF_PAGEOBJECT;  // Page object(text, path, etc)
typedef void* FPDF_PATH;
typedef void* FPDF_CLIPPATH;
typedef void* FPDF_BITMAP;
typedef void* FPDF_FONT;
typedef void* FPDF_TEXTPAGE;
typedef void* FPDF_SCHHANDLE;
typedef void* FPDF_PAGELINK;
typedef void* FPDF_HMODULE;
typedef void* FPDF_DOCSCHHANDLE;
typedef void* FPDF_BOOKMARK;
typedef void* FPDF_DEST;
typedef void* FPDF_ACTION;
typedef void* FPDF_LINK;
typedef void* FPDF_PAGERANGE;

// Basic data types
typedef void* FPDF_LPVOID;
typedef void const* FPDF_LPCVOID;
typedef int FPDF_RESULT;
typedef int FPDF_BOOL;
typedef int FPDF_ERROR;
typedef unsigned long FPDF_DWORD;
typedef float FS_FLOAT;

// Duplex types
typedef enum _FPDF_DUPLEXTYPE_ {
  DuplexUndefined = 0,
  Simplex,
  DuplexFlipShortEdge,
  DuplexFlipLongEdge
} FPDF_DUPLEXTYPE;

// String types
typedef unsigned short FPDF_WCHAR;
typedef unsigned char const* FPDF_LPCBYTE;
typedef char const* FPDF_LPCSTR;

// FPDFSDK may use three types of strings: byte string, wide string (UTF-16LE
// encoded), and platform dependent string
typedef const char* FPDF_BYTESTRING;

typedef const unsigned short*
    FPDF_WIDESTRING;  // Foxit PDF SDK always use UTF-16LE encoding wide string,
// each character use 2 bytes (except surrogation), with low byte first.

#ifndef _FPDF_DEF_STR_
#define _FPDF_DEF_STR_
/** @brief Structure for byte string.
  *
  * @note In SDK, a byte string commonly means a UTF-16LE format string.
  */
typedef struct _FPDF_BSTR {
  /**
   * @brief String buffer.
   */
  char* str;
  /**
   * @brief   Length of a string, in bytes.
   */
  int len;
} FPDF_BSTR;

#endif

// For Windows programmers: for most case it's OK to treat FPDF_WIDESTRING as
// Windows unicode string,
//       however, special care needs to be taken if you expect to process
//       Unicode larger than 0xffff.
// For Linux/Unix programmers: most compiler/library environment uses 4 bytes
// for a Unicode character,
//      you have to convert between FPDF_WIDESTRING and system wide string by
//      yourself.

#ifdef _WIN32_WCE
typedef const unsigned short* FPDF_STRING;
#else
typedef const char* FPDF_STRING;
#endif

/** @brief Matrix for transformation. */
typedef struct _FS_MATRIX_ {
  float a; /**< @brief Coefficient a.*/
  float b; /**< @brief Coefficient b.*/
  float c; /**< @brief Coefficient c.*/
  float d; /**< @brief Coefficient d.*/
  float e; /**< @brief Coefficient e.*/
  float f; /**< @brief Coefficient f.*/
} FS_MATRIX;

/** @brief Rectangle area(float) in device or page coordination system. */
typedef struct _FS_RECTF_ {
  /**@{*/
  /** @brief The x-coordinate of the left-top corner. */
  float left;
  /** @brief The y-coordinate of the left-top corner. */
  float top;
  /** @brief The x-coordinate of the right-bottom corner. */
  float right;
  /** @brief The y-coordinate of the right-bottom corner. */
  float bottom;
  /**@}*/
} * FS_LPRECTF, FS_RECTF;
/** @brief Const Pointer to ::FS_RECTF structure.*/
typedef const FS_RECTF* FS_LPCRECTF;

#if defined(_WIN32) && defined(FPDFSDK_EXPORTS)
// On Windows system, functions are exported in a DLL
#define DLLEXPORT __declspec(dllexport)
#define STDCALL __stdcall
#else
#define DLLEXPORT
#define STDCALL
#endif

// Exported Functions
#ifdef __cplusplus
extern "C" {
#endif

// Function: FPDF_InitLibrary
//          Initialize the FPDFSDK library
// Parameters:
//          None
// Return value:
//          None.
// Comments:
//          You have to call this function before you can call any PDF
//          processing functions.
DLLEXPORT void STDCALL FPDF_InitLibrary();

// Function: FPDF_DestroyLibary
//          Release all resources allocated by the FPDFSDK library.
// Parameters:
//          None.
// Return value:
//          None.
// Comments:
//          You can call this function to release all memory blocks allocated by
//          the library.
//          After this function called, you should not call any PDF processing
//          functions.
DLLEXPORT void STDCALL FPDF_DestroyLibrary();

// Policy for accessing the local machine time.
#define FPDF_POLICY_MACHINETIME_ACCESS 0

// Function: FPDF_SetSandBoxPolicy
//          Set the policy for the sandbox environment.
// Parameters:
//          policy      -   The specified policy for setting, for
//          example:FPDF_POLICY_MACHINETIME_ACCESS.
//          enable      -   True for enable, False for disable the policy.
// Return value:
//          None.
DLLEXPORT void STDCALL FPDF_SetSandBoxPolicy(FPDF_DWORD policy,
                                             FPDF_BOOL enable);

// Function: FPDF_LoadDocument
//          Open and load a PDF document.
// Parameters:
//          file_path [in] -  Path to the PDF file (including extension).
//          password [in]  -  A string used as the password for PDF file.
//                            If no password needed, empty or NULL can be used.
// Return value:
//          A handle to the loaded document, or NULL on failure.
// Comments:
//          Loaded document can be closed by FPDF_CloseDocument().
//          If this function fails, you can use FPDF_GetLastError() to retrieve
//          the reason why it failed.
//          The application should call ::FPDF_LoadXFA function after PDF
//          document loaded
//          to support XFA fields in fpdfformfill.h file.
DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path,
                                                  FPDF_BYTESTRING password);

// Function: FPDF_LoadMemDocument
//          Open and load a PDF document from memory.
// Parameters:
//          data_buf    -   Pointer to a buffer containing the PDF document.
//          size        -   Number of bytes in the PDF document.
//          password    -   A string used as the password for PDF file.
//                          If no password needed, empty or NULL can be used.
// Return value:
//          A handle to the loaded document. If failed, NULL is returned.
// Comments:
//          The memory buffer must remain valid when the document is open.
//          Loaded document can be closed by FPDF_CloseDocument.
//          If this function fails, you can use FPDF_GetLastError() to retrieve
//          the reason why it fails.
// Notes:
//          The application should call ::FPDF_LoadXFA function after PDF
//          document loaded
//          to support XFA fields in fpdfformfill.h file.
//
DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
                                                     int size,
                                                     FPDF_BYTESTRING password);

// Structure for custom file access.
typedef struct {
  // File length, in bytes.
  unsigned long m_FileLen;

  // A function pointer for getting a block of data from specific position.
  // Position is specified by byte offset from beginning of the file.
  // The position and size will never go out range of file length.
  // It may be possible for FPDFSDK to call this function multiple times for
  // same position.
  // Return value: should be non-zero if successful, zero for error.
  int (*m_GetBlock)(void* param,
                    unsigned long position,
                    unsigned char* pBuf,
                    unsigned long size);

  // A custom pointer for all implementation specific data.
  // This pointer will be used as the first parameter to m_GetBlock callback.
  void* m_Param;
} FPDF_FILEACCESS;

/**
 * @brief Structure for file reading or writing (I/O).
 *
 * @note This is a handler and should be implemented by callers.
 */
typedef struct _FPDF_FILEHANDLER {
  /**
   * @brief User-defined data.
   * @note Callers can use this field to track controls.
   */
  FPDF_LPVOID clientData;
  /**
   * @brief Callback function to release the current file stream object.
   *
   * @param[in] clientData    Pointer to user-defined data.
   *
   * @return None.
   */
  void (*Release)(FPDF_LPVOID clientData);
  /**
   * @brief Callback function to retrieve the current file stream size.
   *
   * @param[in] clientData    Pointer to user-defined data.
   *
   * @return Size of file stream.
   */
  FPDF_DWORD (*GetSize)(FPDF_LPVOID clientData);
  /**
   * @brief Callback function to read data from the current file stream.
   *
   * @param[in]   clientData  Pointer to user-defined data.
   * @param[in]   offset      Offset position starts from the beginning of file
   * stream. This parameter indicates reading position.
   * @param[in]   buffer      Memory buffer to store data which are read from
   * file stream. This parameter should not be <b>NULL</b>.
   * @param[in]   size        Size of data which should be read from file
   * stream, in bytes. The buffer indicated by the parameter <i>buffer</i>
   * should be enough to store specified data.
   *
   * @return 0 for success, other value for failure.
   */
  FPDF_RESULT (*ReadBlock)(FPDF_LPVOID clientData, FPDF_DWORD offset, FPDF_LPVOID buffer, FPDF_DWORD size);
  /**
   * @brief   Callback function to write data into the current file stream.
   *
   * @param[in]   clientData  Pointer to user-defined data.
   * @param[in]   offset      Offset position starts from the beginning of file
   * stream. This parameter indicates writing position.
   * @param[in]   buffer      Memory buffer contains data which is written into
   * file stream. This parameter should not be <b>NULL</b>.
   * @param[in]   size        Size of data which should be written into file
   * stream, in bytes.
   *
   * @return 0 for success, other value for failure.
   */
  FPDF_RESULT (*WriteBlock)(FPDF_LPVOID clientData, FPDF_DWORD offset, FPDF_LPCVOID buffer, FPDF_DWORD size);
  /**
   * @brief   Callback function to flush all internal accessing buffers.
   *
   * @param[in]   clientData  Pointer to user-defined data.
   *
   * @return 0 for success, other value for failure.
   */
  FPDF_RESULT (*Flush)(FPDF_LPVOID clientData);
  /**
   * @brief   Callback function to change file size.
   *
   * @details This function is called under writing mode usually. Implementer
   * can determine whether to realize it based on application requests.
   *
   * @param[in]   clientData  Pointer to user-defined data.
   * @param[in]   size        New size of file stream, in bytes.
   *
   * @return 0 for success, other value for failure.
   */
  FPDF_RESULT (*Truncate)(FPDF_LPVOID clientData, FPDF_DWORD size);

} FPDF_FILEHANDLER, *FPDF_LPFILEHANDLER;

// Function: FPDF_LoadCustomDocument
//          Load PDF document from a custom access descriptor.
// Parameters:
//          pFileAccess -   A structure for access the file.
//          password    -   Optional password for decrypting the PDF file.
// Return value:
//          A handle to the loaded document. If failed, NULL is returned.
// Comments:
//          The application should maintain the file resources being valid until
//          the PDF document close.
//          Loaded document can be closed by FPDF_CloseDocument.
// Notes:
//          The application should call ::FPDF_LoadXFA function after PDF
//          document loaded
//          to support XFA fields in fpdfformfill.h file.
//
DLLEXPORT FPDF_DOCUMENT STDCALL
FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess, FPDF_BYTESTRING password);

// Function: FPDF_GetFileVersion
//          Get the file version of the specific PDF document.
// Parameters:
//          doc         -   Handle to document.
//          fileVersion -   The PDF file version. File version: 14 for 1.4, 15
//          for 1.5, ...
// Return value:
//          TRUE if this call succeed, If failed, FALSE is returned.
// Comments:
//          If the document is created by function ::FPDF_CreateNewDocument,
//          then this function would always fail.
//
DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
                                                int* fileVersion);

#define FPDF_ERR_SUCCESS 0    // No error.
#define FPDF_ERR_UNKNOWN 1    // Unknown error.
#define FPDF_ERR_FILE 2       // File not found or could not be opened.
#define FPDF_ERR_FORMAT 3     // File not in PDF format or corrupted.
#define FPDF_ERR_PASSWORD 4   // Password required or incorrect password.
#define FPDF_ERR_SECURITY 5   // Unsupported security scheme.
#define FPDF_ERR_PAGE 6       // Page not found or content error.
#define FPDF_ERR_XFALOAD 7    // Load XFA error.
#define FPDF_ERR_XFALAYOUT 8  // Layout XFA error.

// Function: FPDF_GetLastError
//          Get last error code when an SDK function failed.
// Parameters:
//          None.
// Return value:
//          A 32-bit integer indicating error codes (defined above).
// Comments:
//          If the previous SDK call succeeded, the return value of this
//          function
//          is not defined.
//
DLLEXPORT unsigned long STDCALL FPDF_GetLastError();

// Function: FPDF_GetDocPermission
//          Get file permission flags of the document.
// Parameters:
//          document    -   Handle to document. Returned by FPDF_LoadDocument
//          function.
// Return value:
//          A 32-bit integer indicating permission flags. Please refer to PDF
//          Reference for
//          detailed description. If the document is not protected, 0xffffffff
//          will be returned.
//
DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document);

// Function: FPDF_GetSecurityHandlerRevision
//          Get the revision for security handler.
// Parameters:
//          document    -   Handle to document. Returned by FPDF_LoadDocument
//          function.
// Return value:
//          The security handler revision number. Please refer to PDF Reference
//          for
//          detailed description. If the document is not protected, -1 will be
//          returned.
//
DLLEXPORT int STDCALL FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document);

// Function: FPDF_GetPageCount
//          Get total number of pages in a document.
// Parameters:
//          document    -   Handle to document. Returned by FPDF_LoadDocument
//          function.
// Return value:
//          Total number of pages in the document.
//
DLLEXPORT int STDCALL FPDF_GetPageCount(FPDF_DOCUMENT document);

// Function: FPDF_LoadPage
//          Load a page inside a document.
// Parameters:
//          document    -   Handle to document. Returned by FPDF_LoadDocument
//          function.
//          page_index  -   Index number of the page. 0 for the first page.
// Return value:
//          A handle to the loaded page. If failed, NULL is returned.
// Comments:
//          Loaded page can be rendered to devices using FPDF_RenderPage
//          function.
//          Loaded page can be closed by FPDF_ClosePage.
//
DLLEXPORT FPDF_PAGE STDCALL FPDF_LoadPage(FPDF_DOCUMENT document,
                                          int page_index);

// Function: FPDF_GetPageWidth
//          Get page width.
// Parameters:
//          page        -   Handle to the page. Returned by FPDF_LoadPage
//          function.
// Return value:
//          Page width (excluding non-displayable area) measured in points.
//          One point is 1/72 inch (around 0.3528 mm).
//
DLLEXPORT double STDCALL FPDF_GetPageWidth(FPDF_PAGE page);

// Function: FPDF_GetPageHeight
//          Get page height.
// Parameters:
//          page        -   Handle to the page. Returned by FPDF_LoadPage
//          function.
// Return value:
//          Page height (excluding non-displayable area) measured in points.
//          One point is 1/72 inch (around 0.3528 mm)
//
DLLEXPORT double STDCALL FPDF_GetPageHeight(FPDF_PAGE page);

// Function: FPDF_GetPageSizeByIndex
//          Get the size of a page by index.
// Parameters:
//          document    -   Handle to document. Returned by FPDF_LoadDocument
//          function.
//          page_index  -   Page index, zero for the first page.
//          width       -   Pointer to a double value receiving the page width
//          (in points).
//          height      -   Pointer to a double value receiving the page height
//          (in points).
// Return value:
//          Non-zero for success. 0 for error (document or page not found).
//
DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document,
                                              int page_index,
                                              double* width,
                                              double* height);

// Page rendering flags. They can be combined with bit OR.
#define FPDF_ANNOT 0x01  // Set if annotations are to be rendered.
#define FPDF_LCD_TEXT \
  0x02  // Set if using text rendering optimized for LCD display.
#define FPDF_NO_NATIVETEXT \
  0x04  // Don't use the native text output available on some platforms
#define FPDF_GRAYSCALE 0x08   // Grayscale output.
#define FPDF_DEBUG_INFO 0x80  // Set if you want to get some debug info.
// Please discuss with Foxit first if you need to collect debug info.
#define FPDF_NO_CATCH 0x100  // Set if you don't want to catch exception.
#define FPDF_RENDER_LIMITEDIMAGECACHE 0x200  // Limit image cache size.
#define FPDF_RENDER_FORCEHALFTONE \
  0x400                      // Always use halftone for image stretching.
#define FPDF_PRINTING 0x800  // Render for printing.
#define FPDF_REVERSE_BYTE_ORDER \
  0x10  // set whether render in a reverse Byte order, this flag only
// enable when render to a bitmap.
#ifdef _WIN32
// Function: FPDF_RenderPage
//          Render contents in a page to a device (screen, bitmap, or printer).
//          This function is only supported on Windows system.
// Parameters:
//          dc          -   Handle to device context.
//          page        -   Handle to the page. Returned by FPDF_LoadPage
//          function.
//          start_x     -   Left pixel position of the display area in the
//          device coordinate.
//          start_y     -   Top pixel position of the display area in the device
//          coordinate.
//          size_x      -   Horizontal size (in pixels) for displaying the page.
//          size_y      -   Vertical size (in pixels) for displaying the page.
//          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
//          clockwise),
//                              2 (rotated 180 degrees), 3 (rotated 90 degrees
//                              counter-clockwise).
//          flags       -   0 for normal display, or combination of flags
//          defined above.
// Return value:
//          None.
// Notes:
//          The method can not support to render the page for the document
//          consists of dynamic XFA fields.
//
DLLEXPORT void STDCALL FPDF_RenderPage(HDC dc,
                                       FPDF_PAGE page,
                                       int start_x,
                                       int start_y,
                                       int size_x,
                                       int size_y,
                                       int rotate,
                                       int flags);
#endif

// Function: FPDF_RenderPageBitmap
//          Render contents in a page to a device independent bitmap
// Parameters:
//          bitmap      -   Handle to the device independent bitmap (as the
//          output buffer).
//                          Bitmap handle can be created by FPDFBitmap_Create
//                          function.
//          page        -   Handle to the page. Returned by FPDF_LoadPage
//          function.
//          start_x     -   Left pixel position of the display area in the
//          bitmap coordinate.
//          start_y     -   Top pixel position of the display area in the bitmap
//          coordinate.
//          size_x      -   Horizontal size (in pixels) for displaying the page.
//          size_y      -   Vertical size (in pixels) for displaying the page.
//          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
//          clockwise),
//                              2 (rotated 180 degrees), 3 (rotated 90 degrees
//                              counter-clockwise).
//          flags       -   0 for normal display, or combination of flags
//          defined above.
// Return value:
//          None.
// Notes:
//          The method can not support to render the page for the document
//          consists of dynamic XFA fields.
//
DLLEXPORT void STDCALL FPDF_RenderPageBitmap(FPDF_BITMAP bitmap,
                                             FPDF_PAGE page,
                                             int start_x,
                                             int start_y,
                                             int size_x,
                                             int size_y,
                                             int rotate,
                                             int flags);

// Function: FPDF_ClosePage
//          Close a loaded PDF page.
// Parameters:
//          page        -   Handle to the loaded page.
// Return value:
//          None.
//
DLLEXPORT void STDCALL FPDF_ClosePage(FPDF_PAGE page);

// Function: FPDF_CloseDocument
//          Close a loaded PDF document.
// Parameters:
//          document    -   Handle to the loaded document.
// Return value:
//          None.
//
DLLEXPORT void STDCALL FPDF_CloseDocument(FPDF_DOCUMENT document);

// Function: FPDF_DeviceToPage
//          Convert the screen coordinate of a point to page coordinate.
// Parameters:
//          page        -   Handle to the page. Returned by FPDF_LoadPage
//          function.
//          start_x     -   Left pixel position of the display area in the
//          device coordinate.
//          start_y     -   Top pixel position of the display area in the device
//          coordinate.
//          size_x      -   Horizontal size (in pixels) for displaying the page.
//          size_y      -   Vertical size (in pixels) for displaying the page.
//          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
//          clockwise),
//                              2 (rotated 180 degrees), 3 (rotated 90 degrees
//                              counter-clockwise).
//          device_x    -   X value in device coordinate, for the point to be
//          converted.
//          device_y    -   Y value in device coordinate, for the point to be
//          converted.
//          page_x      -   A Pointer to a double receiving the converted X
//          value in page coordinate.
//          page_y      -   A Pointer to a double receiving the converted Y
//          value in page coordinate.
// Return value:
//          None.
// Comments:
//          The page coordinate system has its origin at left-bottom corner of
//          the page, with X axis goes along
//          the bottom side to the right, and Y axis goes along the left side
//          upward. NOTE: this coordinate system
//          can be altered when you zoom, scroll, or rotate a page, however, a
//          point on the page should always have
//          the same coordinate values in the page coordinate system.
//
//          The device coordinate system is device dependent. For screen device,
//          its origin is at left-top
//          corner of the window. However this origin can be altered by Windows
//          coordinate transformation
//          utilities. You must make sure the start_x, start_y, size_x, size_y
//          and rotate parameters have exactly
//          same values as you used in FPDF_RenderPage() function call.
//
DLLEXPORT void STDCALL FPDF_DeviceToPage(FPDF_PAGE page,
                                         int start_x,
                                         int start_y,
                                         int size_x,
                                         int size_y,
                                         int rotate,
                                         int device_x,
                                         int device_y,
                                         double* page_x,
                                         double* page_y);

// Function: FPDF_PageToDevice
//          Convert the page coordinate of a point to screen coordinate.
// Parameters:
//          page        -   Handle to the page. Returned by FPDF_LoadPage
//          function.
//          start_x     -   Left pixel position of the display area in the
//          device coordinate.
//          start_y     -   Top pixel position of the display area in the device
//          coordinate.
//          size_x      -   Horizontal size (in pixels) for displaying the page.
//          size_y      -   Vertical size (in pixels) for displaying the page.
//          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
//          clockwise),
//                              2 (rotated 180 degrees), 3 (rotated 90 degrees
//                              counter-clockwise).
//          page_x      -   X value in page coordinate, for the point to be
//          converted.
//          page_y      -   Y value in page coordinate, for the point to be
//          converted.
//          device_x    -   A pointer to an integer receiving the result X value
//          in device coordinate.
//          device_y    -   A pointer to an integer receiving the result Y value
//          in device coordinate.
// Return value:
//          None.
// Comments:
//          See comments of FPDF_DeviceToPage() function.
//
DLLEXPORT void STDCALL FPDF_PageToDevice(FPDF_PAGE page,
                                         int start_x,
                                         int start_y,
                                         int size_x,
                                         int size_y,
                                         int rotate,
                                         double page_x,
                                         double page_y,
                                         int* device_x,
                                         int* device_y);

// Function: FPDFBitmap_Create
//          Create a Foxit Device Independent Bitmap (FXDIB).
// Parameters:
//          width       -   Number of pixels in a horizontal line of the bitmap.
//          Must be greater than 0.
//          height      -   Number of pixels in a vertical line of the bitmap.
//          Must be greater than 0.
//          alpha       -   A flag indicating whether alpha channel is used.
//          Non-zero for using alpha, zero for not using.
// Return value:
//          The created bitmap handle, or NULL if parameter error or out of
//          memory.
// Comments:
//          An FXDIB always use 4 byte per pixel. The first byte of a pixel is
//          always double word aligned.
//          Each pixel contains red (R), green (G), blue (B) and optionally
//          alpha (A) values.
//          The byte order is BGRx (the last byte unused if no alpha channel) or
//          BGRA.
//
//          The pixels in a horizontal line (also called scan line) are stored
//          side by side, with left most
//          pixel stored first (with lower memory address). Each scan line uses
//          width*4 bytes.
//
//          Scan lines are stored one after another, with top most scan line
//          stored first. There is no gap
//          between adjacent scan lines.
//
//          This function allocates enough memory for holding all pixels in the
//          bitmap, but it doesn't
//          initialize the buffer. Applications can use FPDFBitmap_FillRect to
//          fill the bitmap using any color.
DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width,
                                                int height,
                                                int alpha);

// More DIB formats
#define FPDFBitmap_Gray 1  // Gray scale bitmap, one byte per pixel.
#define FPDFBitmap_BGR 2   // 3 bytes per pixel, byte order: blue, green, red.
#define FPDFBitmap_BGRx \
  3  // 4 bytes per pixel, byte order: blue, green, red, unused.
#define FPDFBitmap_BGRA \
  4  // 4 bytes per pixel, byte order: blue, green, red, alpha.

// Function: FPDFBitmap_CreateEx
//          Create a Foxit Device Independent Bitmap (FXDIB)
// Parameters:
//          width       -   Number of pixels in a horizontal line of the bitmap.
//          Must be greater than 0.
//          height      -   Number of pixels in a vertical line of the bitmap.
//          Must be greater than 0.
//          format      -   A number indicating for bitmap format, as defined
//          above.
//          first_scan  -   A pointer to the first byte of first scan line, for
//          external buffer
//                          only. If this parameter is NULL, then the SDK will
//                          create its own buffer.
//          stride      -   Number of bytes for each scan line, for external
//          buffer only..
// Return value:
//          The created bitmap handle, or NULL if parameter error or out of
//          memory.
// Comments:
//          Similar to FPDFBitmap_Create function, with more formats and
//          external buffer supported.
//          Bitmap created by this function can be used in any place that a
//          FPDF_BITMAP handle is
//          required.
//
//          If external scanline buffer is used, then the application should
//          destroy the buffer
//          by itself. FPDFBitmap_Destroy function will not destroy the buffer.
//
DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_CreateEx(int width,
                                                  int height,
                                                  int format,
                                                  void* first_scan,
                                                  int stride);

// Function: FPDFBitmap_FillRect
//          Fill a rectangle area in an FXDIB.
// Parameters:
//          bitmap      -   The handle to the bitmap. Returned by
//          FPDFBitmap_Create function.
//          left        -   The left side position. Starting from 0 at the
//          left-most pixel.
//          top         -   The top side position. Starting from 0 at the
//          top-most scan line.
//          width       -   Number of pixels to be filled in each scan line.
//          height      -   Number of scan lines to be filled.
//          color       -   A 32-bit value specifing the color, in 8888 ARGB
//          format.
// Return value:
//          None.
// Comments:
//          This function set the color and (optionally) alpha value in
//          specified region of the bitmap.
//          NOTE: If alpha channel is used, this function does NOT composite the
//          background with the source color,
//          instead the background will be replaced by the source color and
//          alpha.
//          If alpha channel is not used, the "alpha" parameter is ignored.
//
DLLEXPORT void STDCALL FPDFBitmap_FillRect(FPDF_BITMAP bitmap,
                                           int left,
                                           int top,
                                           int width,
                                           int height,
                                           FPDF_DWORD color);

// Function: FPDFBitmap_GetBuffer
//          Get data buffer of an FXDIB
// Parameters:
//          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
//          function.
// Return value:
//          The pointer to the first byte of the bitmap buffer.
// Comments:
//          The stride may be more than width * number of bytes per pixel
//          Applications can use this function to get the bitmap buffer pointer,
//          then manipulate any color
//          and/or alpha values for any pixels in the bitmap.
DLLEXPORT void* STDCALL FPDFBitmap_GetBuffer(FPDF_BITMAP bitmap);

// Function: FPDFBitmap_GetWidth
//          Get width of an FXDIB.
// Parameters:
//          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
//          function.
// Return value:
//          The number of pixels in a horizontal line of the bitmap.
DLLEXPORT int STDCALL FPDFBitmap_GetWidth(FPDF_BITMAP bitmap);

// Function: FPDFBitmap_GetHeight
//          Get height of an FXDIB.
// Parameters:
//          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
//          function.
// Return value:
//          The number of pixels in a vertical line of the bitmap.
DLLEXPORT int STDCALL FPDFBitmap_GetHeight(FPDF_BITMAP bitmap);

// Function: FPDFBitmap_GetStride
//          Get number of bytes for each scan line in the bitmap buffer.
// Parameters:
//          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
//          function.
// Return value:
//          The number of bytes for each scan line in the bitmap buffer.
// Comments:
//          The stride may be more than width * number of bytes per pixel
DLLEXPORT int STDCALL FPDFBitmap_GetStride(FPDF_BITMAP bitmap);

// Function: FPDFBitmap_Destroy
//          Destroy an FXDIB and release all related buffers.
// Parameters:
//          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
//          function.
// Return value:
//          None.
// Comments:
//          This function will not destroy any external buffer.
//
DLLEXPORT void STDCALL FPDFBitmap_Destroy(FPDF_BITMAP bitmap);

// Function: FPDF_VIEWERREF_GetPrintScaling
//          Whether the PDF document prefers to be scaled or not.
// Parameters:
//          document    -   Handle to the loaded document.
// Return value:
//          None.
//
DLLEXPORT FPDF_BOOL STDCALL
FPDF_VIEWERREF_GetPrintScaling(FPDF_DOCUMENT document);

// Function: FPDF_VIEWERREF_GetNumCopies
//          Returns the number of copies to be printed.
// Parameters:
//          document    -   Handle to the loaded document.
// Return value:
//          The number of copies to be printed.
//
DLLEXPORT int STDCALL FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document);

// Function: FPDF_VIEWERREF_GetPrintPageRange
//          Page numbers to initialize print dialog box when file is printed.
// Parameters:
//          document    -   Handle to the loaded document.
// Return value:
//          The print page range to be used for printing.
//
DLLEXPORT FPDF_PAGERANGE STDCALL
FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document);

// Function: FPDF_VIEWERREF_GetDuplex
//          Returns the paper handling option to be used when printing from
//          print dialog.
// Parameters:
//          document    -   Handle to the loaded document.
// Return value:
//          The paper handling option to be used when printing.
//
DLLEXPORT FPDF_DUPLEXTYPE STDCALL
FPDF_VIEWERREF_GetDuplex(FPDF_DOCUMENT document);

// Function: FPDF_CountNamedDests
//          Get the count of named destinations in the PDF document.
// Parameters:
//          document    -   Handle to a document
// Return value:
//          The count of named destinations.
DLLEXPORT FPDF_DWORD STDCALL FPDF_CountNamedDests(FPDF_DOCUMENT document);

// Function: FPDF_GetNamedDestByName
//          get a special dest handle by the index.
// Parameters:
//          document    -   Handle to the loaded document.
//          name        -   The name of a special named dest.
// Return value:
//          The handle of the dest.
//
DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDestByName(FPDF_DOCUMENT document,
                                                    FPDF_BYTESTRING name);

// Function: FPDF_GetNamedDest
//          Get the specified named destinations of the PDF document by index.
// Parameters:
//          document        -   Handle to a document
//          index           -   The index of named destination.
//          buffer          -   The buffer to obtain destination name, used as
//          wchar_t*.
//          buflen [in/out] -   Size of the buffer in bytes on input, length of
//          the result in bytes on output or -1 if the buffer is too small.
// Return value:
//          The destination handle of a named destination, or NULL if no named
//          destination corresponding to |index|.
// Comments:
//          Call this function twice to get the name of the named destination:
//          1) First time pass in |buffer| as NULL and get buflen.
//          2) Second time pass in allocated |buffer| and buflen to retrieve
//          |buffer|, which should be used as wchar_t*.
//             If buflen is not sufficiently large, it will be set to -1 upon
//             return.
//
DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDest(FPDF_DOCUMENT document,
                                              int index,
                                              void* buffer,
                                              long* buflen);

// Function: FPDF_BStr_Init
//          Helper function to initialize a byte string.
DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Init(FPDF_BSTR* str);

// Function: FPDF_BStr_Set
//          Helper function to set string data.
DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Set(FPDF_BSTR* str,
                                            FPDF_LPCSTR bstr,
                                            int length);

// Function: FPDF_BStr_Clear
//          Helper function to clear a byte string.
DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Clear(FPDF_BSTR* str);

#ifdef __cplusplus
}
#endif

#endif  // PUBLIC_FPDFVIEW_H_