Add signatures to FXJS_V8.
[pdfium.git] / public / fpdfview.h
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 // NOTE: External docs refer to this file as "fpdfview.h", so do not rename
8 // despite lack of consitency with other public files.
9
10 #ifndef PUBLIC_FPDFVIEW_H_
11 #define PUBLIC_FPDFVIEW_H_
12
13 #if defined(_WIN32) && !defined(__WINDOWS__)
14 #include <windows.h>
15 #endif
16
17 // Data types
18 typedef void* FPDF_MODULEMGR;
19
20 // PDF types
21 typedef void* FPDF_DOCUMENT;
22 typedef void* FPDF_PAGE;
23 typedef void* FPDF_PAGEOBJECT;  // Page object(text, path, etc)
24 typedef void* FPDF_PATH;
25 typedef void* FPDF_CLIPPATH;
26 typedef void* FPDF_BITMAP;
27 typedef void* FPDF_FONT;
28 typedef void* FPDF_TEXTPAGE;
29 typedef void* FPDF_SCHHANDLE;
30 typedef void* FPDF_PAGELINK;
31 typedef void* FPDF_HMODULE;
32 typedef void* FPDF_DOCSCHHANDLE;
33 typedef void* FPDF_BOOKMARK;
34 typedef void* FPDF_DEST;
35 typedef void* FPDF_ACTION;
36 typedef void* FPDF_LINK;
37 typedef void* FPDF_PAGERANGE;
38
39 // Basic data types
40 typedef int FPDF_BOOL;
41 typedef int FPDF_ERROR;
42 typedef unsigned long FPDF_DWORD;
43 typedef float FS_FLOAT;
44
45 // Duplex types
46 typedef enum _FPDF_DUPLEXTYPE_ {
47   DuplexUndefined = 0,
48   Simplex,
49   DuplexFlipShortEdge,
50   DuplexFlipLongEdge
51 } FPDF_DUPLEXTYPE;
52
53 // String types
54 typedef unsigned short FPDF_WCHAR;
55 typedef unsigned char const* FPDF_LPCBYTE;
56
57 // FPDFSDK may use three types of strings: byte string, wide string (UTF-16LE
58 // encoded), and platform dependent string
59 typedef const char* FPDF_BYTESTRING;
60
61 typedef const unsigned short*
62     FPDF_WIDESTRING;  // Foxit PDF SDK always use UTF-16LE encoding wide string,
63 // each character use 2 bytes (except surrogation), with low byte first.
64
65 // For Windows programmers: for most case it's OK to treat FPDF_WIDESTRING as
66 // Windows unicode string,
67 //       however, special care needs to be taken if you expect to process
68 //       Unicode larger than 0xffff.
69 // For Linux/Unix programmers: most compiler/library environment uses 4 bytes
70 // for a Unicode character,
71 //      you have to convert between FPDF_WIDESTRING and system wide string by
72 //      yourself.
73
74 #ifdef _WIN32_WCE
75 typedef const unsigned short* FPDF_STRING;
76 #else
77 typedef const char* FPDF_STRING;
78 #endif
79
80 /** @brief Matrix for transformation. */
81 typedef struct _FS_MATRIX_ {
82   float a; /**< @brief Coefficient a.*/
83   float b; /**< @brief Coefficient b.*/
84   float c; /**< @brief Coefficient c.*/
85   float d; /**< @brief Coefficient d.*/
86   float e; /**< @brief Coefficient e.*/
87   float f; /**< @brief Coefficient f.*/
88 } FS_MATRIX;
89
90 /** @brief Rectangle area(float) in device or page coordination system. */
91 typedef struct _FS_RECTF_ {
92   /**@{*/
93   /** @brief The x-coordinate of the left-top corner. */
94   float left;
95   /** @brief The y-coordinate of the left-top corner. */
96   float top;
97   /** @brief The x-coordinate of the right-bottom corner. */
98   float right;
99   /** @brief The y-coordinate of the right-bottom corner. */
100   float bottom;
101   /**@}*/
102 } * FS_LPRECTF, FS_RECTF;
103 /** @brief Const Pointer to ::FS_RECTF structure.*/
104 typedef const FS_RECTF* FS_LPCRECTF;
105
106 #if defined(_WIN32) && defined(FPDFSDK_EXPORTS)
107 // On Windows system, functions are exported in a DLL
108 #define DLLEXPORT __declspec(dllexport)
109 #define STDCALL __stdcall
110 #else
111 #define DLLEXPORT
112 #define STDCALL
113 #endif
114
115 // Exported Functions
116 #ifdef __cplusplus
117 extern "C" {
118 #endif
119
120 // Function: FPDF_InitLibrary
121 //          Initialize the FPDFSDK library
122 // Parameters:
123 //          None
124 // Return value:
125 //          None.
126 // Comments:
127 //          Convenience function to call FPDF_InitLibraryWithConfig() for
128 //          backwards comatibility purposes.
129 DLLEXPORT void STDCALL FPDF_InitLibrary();
130
131 // Process-wide options for initializing library.
132 typedef struct FPDF_LIBRARY_CONFIG_ {
133   // Version number of the interface. Currently must be 1.
134   int version;
135
136   // Array of paths to scan in place of the defaults when using built-in
137   // FXGE font loading code. The array is terminated by a NULL pointer.
138   // The Array may be NULL itself to use the default paths. May be ignored
139   // entirely depending upon the platform.
140   const char** m_pUserFontPaths;
141 } FPDF_LIBRARY_CONFIG;
142
143 // Function: FPDF_InitLibraryWithConfig
144 //          Initialize the FPDFSDK library
145 // Parameters:
146 //          cfg - configuration information as above.
147 // Return value:
148 //          None.
149 // Comments:
150 //          You have to call this function before you can call any PDF
151 //          processing functions.
152 DLLEXPORT void STDCALL FPDF_InitLibraryWithConfig(
153     const FPDF_LIBRARY_CONFIG* config);
154
155 // Function: FPDF_DestroyLibary
156 //          Release all resources allocated by the FPDFSDK library.
157 // Parameters:
158 //          None.
159 // Return value:
160 //          None.
161 // Comments:
162 //          You can call this function to release all memory blocks allocated by
163 //          the library.
164 //          After this function called, you should not call any PDF processing
165 //          functions.
166 DLLEXPORT void STDCALL FPDF_DestroyLibrary();
167
168 // Policy for accessing the local machine time.
169 #define FPDF_POLICY_MACHINETIME_ACCESS 0
170
171 // Function: FPDF_SetSandBoxPolicy
172 //          Set the policy for the sandbox environment.
173 // Parameters:
174 //          policy      -   The specified policy for setting, for
175 //          example:FPDF_POLICY_MACHINETIME_ACCESS.
176 //          enable      -   True for enable, False for disable the policy.
177 // Return value:
178 //          None.
179 DLLEXPORT void STDCALL FPDF_SetSandBoxPolicy(FPDF_DWORD policy,
180                                              FPDF_BOOL enable);
181
182 // Function: FPDF_LoadDocument
183 //          Open and load a PDF document.
184 // Parameters:
185 //          file_path [in] -  Path to the PDF file (including extension).
186 //          password [in]  -  A string used as the password for PDF file.
187 //                            If no password needed, empty or NULL can be used.
188 // Return value:
189 //          A handle to the loaded document, or NULL on failure.
190 // Comments:
191 //          Loaded document can be closed by FPDF_CloseDocument().
192 //          If this function fails, you can use FPDF_GetLastError() to retrieve
193 //          the reason why it failed.
194 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path,
195                                                   FPDF_BYTESTRING password);
196
197 // Function: FPDF_LoadMemDocument
198 //          Open and load a PDF document from memory.
199 // Parameters:
200 //          data_buf    -   Pointer to a buffer containing the PDF document.
201 //          size        -   Number of bytes in the PDF document.
202 //          password    -   A string used as the password for PDF file.
203 //                          If no password needed, empty or NULL can be used.
204 // Return value:
205 //          A handle to the loaded document. If failed, NULL is returned.
206 // Comments:
207 //          The memory buffer must remain valid when the document is open.
208 //          Loaded document can be closed by FPDF_CloseDocument.
209 //          If this function fails, you can use FPDF_GetLastError() to retrieve
210 //          the reason why it fails.
211 //
212 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
213                                                      int size,
214                                                      FPDF_BYTESTRING password);
215
216 // Structure for custom file access.
217 typedef struct {
218   // File length, in bytes.
219   unsigned long m_FileLen;
220
221   // A function pointer for getting a block of data from specific position.
222   // Position is specified by byte offset from beginning of the file.
223   // The position and size will never go out range of file length.
224   // It may be possible for FPDFSDK to call this function multiple times for
225   // same position.
226   // Return value: should be non-zero if successful, zero for error.
227   int (*m_GetBlock)(void* param,
228                     unsigned long position,
229                     unsigned char* pBuf,
230                     unsigned long size);
231
232   // A custom pointer for all implementation specific data.
233   // This pointer will be used as the first parameter to m_GetBlock callback.
234   void* m_Param;
235 } FPDF_FILEACCESS;
236
237 // Function: FPDF_LoadCustomDocument
238 //          Load PDF document from a custom access descriptor.
239 // Parameters:
240 //          pFileAccess -   A structure for access the file.
241 //          password    -   Optional password for decrypting the PDF file.
242 // Return value:
243 //          A handle to the loaded document. If failed, NULL is returned.
244 // Comments:
245 //          The application should maintain the file resources being valid until
246 //          the PDF document close.
247 //          Loaded document can be closed by FPDF_CloseDocument.
248 DLLEXPORT FPDF_DOCUMENT STDCALL
249 FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess, FPDF_BYTESTRING password);
250
251 // Function: FPDF_GetFileVersion
252 //          Get the file version of the specific PDF document.
253 // Parameters:
254 //          doc         -   Handle to document.
255 //          fileVersion -   The PDF file version. File version: 14 for 1.4, 15
256 //          for 1.5, ...
257 // Return value:
258 //          TRUE if this call succeed, If failed, FALSE is returned.
259 // Comments:
260 //          If the document is created by function ::FPDF_CreateNewDocument,
261 //          then this function would always fail.
262 DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
263                                                 int* fileVersion);
264
265 #define FPDF_ERR_SUCCESS 0   // No error.
266 #define FPDF_ERR_UNKNOWN 1   // Unknown error.
267 #define FPDF_ERR_FILE 2      // File not found or could not be opened.
268 #define FPDF_ERR_FORMAT 3    // File not in PDF format or corrupted.
269 #define FPDF_ERR_PASSWORD 4  // Password required or incorrect password.
270 #define FPDF_ERR_SECURITY 5  // Unsupported security scheme.
271 #define FPDF_ERR_PAGE 6      // Page not found or content error.
272
273 // Function: FPDF_GetLastError
274 //          Get last error code when an SDK function failed.
275 // Parameters:
276 //          None.
277 // Return value:
278 //          A 32-bit integer indicating error codes (defined above).
279 // Comments:
280 //          If the previous SDK call succeeded, the return value of this
281 //          function
282 //          is not defined.
283 //
284 DLLEXPORT unsigned long STDCALL FPDF_GetLastError();
285
286 // Function: FPDF_GetDocPermission
287 //          Get file permission flags of the document.
288 // Parameters:
289 //          document    -   Handle to document. Returned by FPDF_LoadDocument
290 //          function.
291 // Return value:
292 //          A 32-bit integer indicating permission flags. Please refer to PDF
293 //          Reference for
294 //          detailed description. If the document is not protected, 0xffffffff
295 //          will be returned.
296 //
297 DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document);
298
299 // Function: FPDF_GetSecurityHandlerRevision
300 //          Get the revision for security handler.
301 // Parameters:
302 //          document    -   Handle to document. Returned by FPDF_LoadDocument
303 //          function.
304 // Return value:
305 //          The security handler revision number. Please refer to PDF Reference
306 //          for
307 //          detailed description. If the document is not protected, -1 will be
308 //          returned.
309 //
310 DLLEXPORT int STDCALL FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document);
311
312 // Function: FPDF_GetPageCount
313 //          Get total number of pages in a document.
314 // Parameters:
315 //          document    -   Handle to document. Returned by FPDF_LoadDocument
316 //          function.
317 // Return value:
318 //          Total number of pages in the document.
319 //
320 DLLEXPORT int STDCALL FPDF_GetPageCount(FPDF_DOCUMENT document);
321
322 // Function: FPDF_LoadPage
323 //          Load a page inside a document.
324 // Parameters:
325 //          document    -   Handle to document. Returned by FPDF_LoadDocument
326 //          function.
327 //          page_index  -   Index number of the page. 0 for the first page.
328 // Return value:
329 //          A handle to the loaded page. If failed, NULL is returned.
330 // Comments:
331 //          Loaded page can be rendered to devices using FPDF_RenderPage
332 //          function.
333 //          Loaded page can be closed by FPDF_ClosePage.
334 //
335 DLLEXPORT FPDF_PAGE STDCALL FPDF_LoadPage(FPDF_DOCUMENT document,
336                                           int page_index);
337
338 // Function: FPDF_GetPageWidth
339 //          Get page width.
340 // Parameters:
341 //          page        -   Handle to the page. Returned by FPDF_LoadPage
342 //          function.
343 // Return value:
344 //          Page width (excluding non-displayable area) measured in points.
345 //          One point is 1/72 inch (around 0.3528 mm).
346 //
347 DLLEXPORT double STDCALL FPDF_GetPageWidth(FPDF_PAGE page);
348
349 // Function: FPDF_GetPageHeight
350 //          Get page height.
351 // Parameters:
352 //          page        -   Handle to the page. Returned by FPDF_LoadPage
353 //          function.
354 // Return value:
355 //          Page height (excluding non-displayable area) measured in points.
356 //          One point is 1/72 inch (around 0.3528 mm)
357 //
358 DLLEXPORT double STDCALL FPDF_GetPageHeight(FPDF_PAGE page);
359
360 // Function: FPDF_GetPageSizeByIndex
361 //          Get the size of a page by index.
362 // Parameters:
363 //          document    -   Handle to document. Returned by FPDF_LoadDocument
364 //          function.
365 //          page_index  -   Page index, zero for the first page.
366 //          width       -   Pointer to a double value receiving the page width
367 //          (in points).
368 //          height      -   Pointer to a double value receiving the page height
369 //          (in points).
370 // Return value:
371 //          Non-zero for success. 0 for error (document or page not found).
372 //
373 DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document,
374                                               int page_index,
375                                               double* width,
376                                               double* height);
377
378 // Page rendering flags. They can be combined with bit OR.
379 #define FPDF_ANNOT 0x01  // Set if annotations are to be rendered.
380 #define FPDF_LCD_TEXT \
381   0x02  // Set if using text rendering optimized for LCD display.
382 #define FPDF_NO_NATIVETEXT \
383   0x04  // Don't use the native text output available on some platforms
384 #define FPDF_GRAYSCALE 0x08   // Grayscale output.
385 #define FPDF_DEBUG_INFO 0x80  // Set if you want to get some debug info.
386 // Please discuss with Foxit first if you need to collect debug info.
387 #define FPDF_NO_CATCH 0x100  // Set if you don't want to catch exception.
388 #define FPDF_RENDER_LIMITEDIMAGECACHE 0x200  // Limit image cache size.
389 #define FPDF_RENDER_FORCEHALFTONE \
390   0x400                      // Always use halftone for image stretching.
391 #define FPDF_PRINTING 0x800  // Render for printing.
392 #define FPDF_RENDER_NO_SMOOTHTEXT \
393   0x1000  // Set to disable anti-aliasing on text.
394 #define FPDF_RENDER_NO_SMOOTHIMAGE \
395   0x2000  // Set to disable anti-aliasing on images.
396 #define FPDF_RENDER_NO_SMOOTHPATH \
397   0x4000  // Set to disable anti-aliasing on paths.
398 #define FPDF_REVERSE_BYTE_ORDER \
399   0x10  // set whether render in a reverse Byte order, this flag only
400 // enable when render to a bitmap.
401 #ifdef _WIN32
402 // Function: FPDF_RenderPage
403 //          Render contents in a page to a device (screen, bitmap, or printer).
404 //          This function is only supported on Windows system.
405 // Parameters:
406 //          dc          -   Handle to device context.
407 //          page        -   Handle to the page. Returned by FPDF_LoadPage
408 //          function.
409 //          start_x     -   Left pixel position of the display area in the
410 //          device coordinate.
411 //          start_y     -   Top pixel position of the display area in the device
412 //          coordinate.
413 //          size_x      -   Horizontal size (in pixels) for displaying the page.
414 //          size_y      -   Vertical size (in pixels) for displaying the page.
415 //          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
416 //          clockwise),
417 //                              2 (rotated 180 degrees), 3 (rotated 90 degrees
418 //                              counter-clockwise).
419 //          flags       -   0 for normal display, or combination of flags
420 //          defined above.
421 // Return value:
422 //          None.
423 //
424 DLLEXPORT void STDCALL FPDF_RenderPage(HDC dc,
425                                        FPDF_PAGE page,
426                                        int start_x,
427                                        int start_y,
428                                        int size_x,
429                                        int size_y,
430                                        int rotate,
431                                        int flags);
432 #endif
433
434 // Function: FPDF_RenderPageBitmap
435 //          Render contents in a page to a device independent bitmap
436 // Parameters:
437 //          bitmap      -   Handle to the device independent bitmap (as the
438 //          output buffer).
439 //                          Bitmap handle can be created by FPDFBitmap_Create
440 //                          function.
441 //          page        -   Handle to the page. Returned by FPDF_LoadPage
442 //          function.
443 //          start_x     -   Left pixel position of the display area in the
444 //          bitmap coordinate.
445 //          start_y     -   Top pixel position of the display area in the bitmap
446 //          coordinate.
447 //          size_x      -   Horizontal size (in pixels) for displaying the page.
448 //          size_y      -   Vertical size (in pixels) for displaying the page.
449 //          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
450 //          clockwise),
451 //                              2 (rotated 180 degrees), 3 (rotated 90 degrees
452 //                              counter-clockwise).
453 //          flags       -   0 for normal display, or combination of flags
454 //          defined above.
455 // Return value:
456 //          None.
457 //
458 DLLEXPORT void STDCALL FPDF_RenderPageBitmap(FPDF_BITMAP bitmap,
459                                              FPDF_PAGE page,
460                                              int start_x,
461                                              int start_y,
462                                              int size_x,
463                                              int size_y,
464                                              int rotate,
465                                              int flags);
466
467 // Function: FPDF_ClosePage
468 //          Close a loaded PDF page.
469 // Parameters:
470 //          page        -   Handle to the loaded page.
471 // Return value:
472 //          None.
473 //
474 DLLEXPORT void STDCALL FPDF_ClosePage(FPDF_PAGE page);
475
476 // Function: FPDF_CloseDocument
477 //          Close a loaded PDF document.
478 // Parameters:
479 //          document    -   Handle to the loaded document.
480 // Return value:
481 //          None.
482 //
483 DLLEXPORT void STDCALL FPDF_CloseDocument(FPDF_DOCUMENT document);
484
485 // Function: FPDF_DeviceToPage
486 //          Convert the screen coordinate of a point to page coordinate.
487 // Parameters:
488 //          page        -   Handle to the page. Returned by FPDF_LoadPage
489 //          function.
490 //          start_x     -   Left pixel position of the display area in the
491 //          device coordinate.
492 //          start_y     -   Top pixel position of the display area in the device
493 //          coordinate.
494 //          size_x      -   Horizontal size (in pixels) for displaying the page.
495 //          size_y      -   Vertical size (in pixels) for displaying the page.
496 //          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
497 //          clockwise),
498 //                              2 (rotated 180 degrees), 3 (rotated 90 degrees
499 //                              counter-clockwise).
500 //          device_x    -   X value in device coordinate, for the point to be
501 //          converted.
502 //          device_y    -   Y value in device coordinate, for the point to be
503 //          converted.
504 //          page_x      -   A Pointer to a double receiving the converted X
505 //          value in page coordinate.
506 //          page_y      -   A Pointer to a double receiving the converted Y
507 //          value in page coordinate.
508 // Return value:
509 //          None.
510 // Comments:
511 //          The page coordinate system has its origin at left-bottom corner of
512 //          the page, with X axis goes along
513 //          the bottom side to the right, and Y axis goes along the left side
514 //          upward. NOTE: this coordinate system
515 //          can be altered when you zoom, scroll, or rotate a page, however, a
516 //          point on the page should always have
517 //          the same coordinate values in the page coordinate system.
518 //
519 //          The device coordinate system is device dependent. For screen device,
520 //          its origin is at left-top
521 //          corner of the window. However this origin can be altered by Windows
522 //          coordinate transformation
523 //          utilities. You must make sure the start_x, start_y, size_x, size_y
524 //          and rotate parameters have exactly
525 //          same values as you used in FPDF_RenderPage() function call.
526 //
527 DLLEXPORT void STDCALL FPDF_DeviceToPage(FPDF_PAGE page,
528                                          int start_x,
529                                          int start_y,
530                                          int size_x,
531                                          int size_y,
532                                          int rotate,
533                                          int device_x,
534                                          int device_y,
535                                          double* page_x,
536                                          double* page_y);
537
538 // Function: FPDF_PageToDevice
539 //          Convert the page coordinate of a point to screen coordinate.
540 // Parameters:
541 //          page        -   Handle to the page. Returned by FPDF_LoadPage
542 //          function.
543 //          start_x     -   Left pixel position of the display area in the
544 //          device coordinate.
545 //          start_y     -   Top pixel position of the display area in the device
546 //          coordinate.
547 //          size_x      -   Horizontal size (in pixels) for displaying the page.
548 //          size_y      -   Vertical size (in pixels) for displaying the page.
549 //          rotate      -   Page orientation: 0 (normal), 1 (rotated 90 degrees
550 //          clockwise),
551 //                              2 (rotated 180 degrees), 3 (rotated 90 degrees
552 //                              counter-clockwise).
553 //          page_x      -   X value in page coordinate, for the point to be
554 //          converted.
555 //          page_y      -   Y value in page coordinate, for the point to be
556 //          converted.
557 //          device_x    -   A pointer to an integer receiving the result X value
558 //          in device coordinate.
559 //          device_y    -   A pointer to an integer receiving the result Y value
560 //          in device coordinate.
561 // Return value:
562 //          None.
563 // Comments:
564 //          See comments of FPDF_DeviceToPage() function.
565 //
566 DLLEXPORT void STDCALL FPDF_PageToDevice(FPDF_PAGE page,
567                                          int start_x,
568                                          int start_y,
569                                          int size_x,
570                                          int size_y,
571                                          int rotate,
572                                          double page_x,
573                                          double page_y,
574                                          int* device_x,
575                                          int* device_y);
576
577 // Function: FPDFBitmap_Create
578 //          Create a Foxit Device Independent Bitmap (FXDIB).
579 // Parameters:
580 //          width       -   Number of pixels in a horizontal line of the bitmap.
581 //          Must be greater than 0.
582 //          height      -   Number of pixels in a vertical line of the bitmap.
583 //          Must be greater than 0.
584 //          alpha       -   A flag indicating whether alpha channel is used.
585 //          Non-zero for using alpha, zero for not using.
586 // Return value:
587 //          The created bitmap handle, or NULL if parameter error or out of
588 //          memory.
589 // Comments:
590 //          An FXDIB always use 4 byte per pixel. The first byte of a pixel is
591 //          always double word aligned.
592 //          Each pixel contains red (R), green (G), blue (B) and optionally
593 //          alpha (A) values.
594 //          The byte order is BGRx (the last byte unused if no alpha channel) or
595 //          BGRA.
596 //
597 //          The pixels in a horizontal line (also called scan line) are stored
598 //          side by side, with left most
599 //          pixel stored first (with lower memory address). Each scan line uses
600 //          width*4 bytes.
601 //
602 //          Scan lines are stored one after another, with top most scan line
603 //          stored first. There is no gap
604 //          between adjacent scan lines.
605 //
606 //          This function allocates enough memory for holding all pixels in the
607 //          bitmap, but it doesn't
608 //          initialize the buffer. Applications can use FPDFBitmap_FillRect to
609 //          fill the bitmap using any color.
610 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width,
611                                                 int height,
612                                                 int alpha);
613
614 // More DIB formats
615 #define FPDFBitmap_Gray 1  // Gray scale bitmap, one byte per pixel.
616 #define FPDFBitmap_BGR 2   // 3 bytes per pixel, byte order: blue, green, red.
617 #define FPDFBitmap_BGRx \
618   3  // 4 bytes per pixel, byte order: blue, green, red, unused.
619 #define FPDFBitmap_BGRA \
620   4  // 4 bytes per pixel, byte order: blue, green, red, alpha.
621
622 // Function: FPDFBitmap_CreateEx
623 //          Create a Foxit Device Independent Bitmap (FXDIB)
624 // Parameters:
625 //          width       -   Number of pixels in a horizontal line of the bitmap.
626 //          Must be greater than 0.
627 //          height      -   Number of pixels in a vertical line of the bitmap.
628 //          Must be greater than 0.
629 //          format      -   A number indicating for bitmap format, as defined
630 //          above.
631 //          first_scan  -   A pointer to the first byte of first scan line, for
632 //          external buffer
633 //                          only. If this parameter is NULL, then the SDK will
634 //                          create its own buffer.
635 //          stride      -   Number of bytes for each scan line, for external
636 //          buffer only..
637 // Return value:
638 //          The created bitmap handle, or NULL if parameter error or out of
639 //          memory.
640 // Comments:
641 //          Similar to FPDFBitmap_Create function, with more formats and
642 //          external buffer supported.
643 //          Bitmap created by this function can be used in any place that a
644 //          FPDF_BITMAP handle is
645 //          required.
646 //
647 //          If external scanline buffer is used, then the application should
648 //          destroy the buffer
649 //          by itself. FPDFBitmap_Destroy function will not destroy the buffer.
650 //
651 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_CreateEx(int width,
652                                                   int height,
653                                                   int format,
654                                                   void* first_scan,
655                                                   int stride);
656
657 // Function: FPDFBitmap_FillRect
658 //          Fill a rectangle area in an FXDIB.
659 // Parameters:
660 //          bitmap      -   The handle to the bitmap. Returned by
661 //          FPDFBitmap_Create function.
662 //          left        -   The left side position. Starting from 0 at the
663 //          left-most pixel.
664 //          top         -   The top side position. Starting from 0 at the
665 //          top-most scan line.
666 //          width       -   Number of pixels to be filled in each scan line.
667 //          height      -   Number of scan lines to be filled.
668 //          color       -   A 32-bit value specifing the color, in 8888 ARGB
669 //          format.
670 // Return value:
671 //          None.
672 // Comments:
673 //          This function set the color and (optionally) alpha value in
674 //          specified region of the bitmap.
675 //          NOTE: If alpha channel is used, this function does NOT composite the
676 //          background with the source color,
677 //          instead the background will be replaced by the source color and
678 //          alpha.
679 //          If alpha channel is not used, the "alpha" parameter is ignored.
680 //
681 DLLEXPORT void STDCALL FPDFBitmap_FillRect(FPDF_BITMAP bitmap,
682                                            int left,
683                                            int top,
684                                            int width,
685                                            int height,
686                                            FPDF_DWORD color);
687
688 // Function: FPDFBitmap_GetBuffer
689 //          Get data buffer of an FXDIB
690 // Parameters:
691 //          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
692 //          function.
693 // Return value:
694 //          The pointer to the first byte of the bitmap buffer.
695 // Comments:
696 //          The stride may be more than width * number of bytes per pixel
697 //          Applications can use this function to get the bitmap buffer pointer,
698 //          then manipulate any color
699 //          and/or alpha values for any pixels in the bitmap.
700 DLLEXPORT void* STDCALL FPDFBitmap_GetBuffer(FPDF_BITMAP bitmap);
701
702 // Function: FPDFBitmap_GetWidth
703 //          Get width of an FXDIB.
704 // Parameters:
705 //          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
706 //          function.
707 // Return value:
708 //          The number of pixels in a horizontal line of the bitmap.
709 DLLEXPORT int STDCALL FPDFBitmap_GetWidth(FPDF_BITMAP bitmap);
710
711 // Function: FPDFBitmap_GetHeight
712 //          Get height of an FXDIB.
713 // Parameters:
714 //          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
715 //          function.
716 // Return value:
717 //          The number of pixels in a vertical line of the bitmap.
718 DLLEXPORT int STDCALL FPDFBitmap_GetHeight(FPDF_BITMAP bitmap);
719
720 // Function: FPDFBitmap_GetStride
721 //          Get number of bytes for each scan line in the bitmap buffer.
722 // Parameters:
723 //          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
724 //          function.
725 // Return value:
726 //          The number of bytes for each scan line in the bitmap buffer.
727 // Comments:
728 //          The stride may be more than width * number of bytes per pixel
729 DLLEXPORT int STDCALL FPDFBitmap_GetStride(FPDF_BITMAP bitmap);
730
731 // Function: FPDFBitmap_Destroy
732 //          Destroy an FXDIB and release all related buffers.
733 // Parameters:
734 //          bitmap      -   Handle to the bitmap. Returned by FPDFBitmap_Create
735 //          function.
736 // Return value:
737 //          None.
738 // Comments:
739 //          This function will not destroy any external buffer.
740 //
741 DLLEXPORT void STDCALL FPDFBitmap_Destroy(FPDF_BITMAP bitmap);
742
743 // Function: FPDF_VIEWERREF_GetPrintScaling
744 //          Whether the PDF document prefers to be scaled or not.
745 // Parameters:
746 //          document    -   Handle to the loaded document.
747 // Return value:
748 //          None.
749 //
750 DLLEXPORT FPDF_BOOL STDCALL
751 FPDF_VIEWERREF_GetPrintScaling(FPDF_DOCUMENT document);
752
753 // Function: FPDF_VIEWERREF_GetNumCopies
754 //          Returns the number of copies to be printed.
755 // Parameters:
756 //          document    -   Handle to the loaded document.
757 // Return value:
758 //          The number of copies to be printed.
759 //
760 DLLEXPORT int STDCALL FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document);
761
762 // Function: FPDF_VIEWERREF_GetPrintPageRange
763 //          Page numbers to initialize print dialog box when file is printed.
764 // Parameters:
765 //          document    -   Handle to the loaded document.
766 // Return value:
767 //          The print page range to be used for printing.
768 //
769 DLLEXPORT FPDF_PAGERANGE STDCALL
770 FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document);
771
772 // Function: FPDF_VIEWERREF_GetDuplex
773 //          Returns the paper handling option to be used when printing from
774 //          print dialog.
775 // Parameters:
776 //          document    -   Handle to the loaded document.
777 // Return value:
778 //          The paper handling option to be used when printing.
779 //
780 DLLEXPORT FPDF_DUPLEXTYPE STDCALL
781 FPDF_VIEWERREF_GetDuplex(FPDF_DOCUMENT document);
782
783 // Function: FPDF_CountNamedDests
784 //          Get the count of named destinations in the PDF document.
785 // Parameters:
786 //          document    -   Handle to a document
787 // Return value:
788 //          The count of named destinations.
789 DLLEXPORT FPDF_DWORD STDCALL FPDF_CountNamedDests(FPDF_DOCUMENT document);
790
791 // Function: FPDF_GetNamedDestByName
792 //          get a special dest handle by the index.
793 // Parameters:
794 //          document    -   Handle to the loaded document.
795 //          name        -   The name of a special named dest.
796 // Return value:
797 //          The handle of the dest.
798 //
799 DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDestByName(FPDF_DOCUMENT document,
800                                                     FPDF_BYTESTRING name);
801
802 // Function: FPDF_GetNamedDest
803 //          Get the specified named destinations of the PDF document by index.
804 // Parameters:
805 //          document        -   Handle to a document
806 //          index           -   The index of named destination.
807 //          buffer          -   The buffer to obtain destination name, used as
808 //          wchar_t*.
809 //          buflen [in/out] -   Size of the buffer in bytes on input, length of
810 //          the result in bytes on output or -1 if the buffer is too small.
811 // Return value:
812 //          The destination handle of a named destination, or NULL if no named
813 //          destination corresponding to |index|.
814 // Comments:
815 //          Call this function twice to get the name of the named destination:
816 //          1) First time pass in |buffer| as NULL and get buflen.
817 //          2) Second time pass in allocated |buffer| and buflen to retrieve
818 //          |buffer|, which should be used as wchar_t*.
819 //             If buflen is not sufficiently large, it will be set to -1 upon
820 //             return.
821 //
822 DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDest(FPDF_DOCUMENT document,
823                                               int index,
824                                               void* buffer,
825                                               long* buflen);
826
827 #ifdef __cplusplus
828 }
829 #endif
830
831 #endif  // PUBLIC_FPDFVIEW_H_