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