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