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