summaryrefslogtreecommitdiff
path: root/public/fpdfview.h
blob: 9794d5fd007adc09d12db305055836d548082e1a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

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

#ifndef _FPDFVIEW_H_
#define _FPDFVIEW_H_

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

// Data types
typedef void*	FPDF_MODULEMGR;

// PDF types
typedef void*	FPDF_DOCUMENT;		
typedef void*	FPDF_PAGE;			
typedef void*	FPDF_PAGEOBJECT;	// Page object(text, path, etc)
typedef void*	FPDF_PATH;
typedef void*	FPDF_CLIPPATH;	
typedef void*	FPDF_BITMAP;	
typedef void*	FPDF_FONT;			

typedef void*	FPDF_TEXTPAGE;
typedef void*	FPDF_SCHHANDLE;
typedef void*	FPDF_PAGELINK;
typedef void*	FPDF_HMODULE;
typedef void*	FPDF_DOCSCHHANDLE;

typedef void*	FPDF_BOOKMARK;
typedef void*	FPDF_DEST;
typedef void*	FPDF_ACTION;
typedef void*	FPDF_LINK;
typedef void*   FPDF_PAGERANGE;

// Basic data types
typedef int				FPDF_BOOL;
typedef int				FPDF_ERROR;	
typedef unsigned long	FPDF_DWORD;

typedef	float			FS_FLOAT;

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

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

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

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

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

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

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

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

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

extern const char g_ExpireDate[];
extern const char g_ModuleCodes[];

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

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

DLLEXPORT void STDCALL FPDF_InitLibrary();


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

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

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

/**
* Open and load a PDF document.
* @param[in] file_path	-	Path to the PDF file (including extension).
* @param[in] password	-	A string used as the password for PDF file. 
*							If no password needed, empty or NULL can be used.
* @note		Loaded document can be closed by FPDF_CloseDocument.
*			If this function fails, you can use FPDF_GetLastError() to retrieve
*			the reason why it fails.
* @retval	A handle to the loaded document. If failed, NULL is returned.
*/
DLLEXPORT FPDF_DOCUMENT	STDCALL FPDF_LoadDocument(FPDF_STRING file_path, 
	FPDF_BYTESTRING password);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


#ifdef __cplusplus
};
#endif

#endif // _FPDFVIEW_H_