CPDF_Parser shouldnt be in the business of opening files
[pdfium.git] / fpdfsdk / src / fpdfview.cpp
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 #include "../../core/include/fxcodec/fx_codec.h"
8 #include "../../core/include/fxcrt/fx_safe_types.h"
9 #include "../../public/fpdf_ext.h"
10 #include "../../public/fpdf_progressive.h"
11 #include "../../public/fpdfview.h"
12 #include "../../third_party/base/nonstd_unique_ptr.h"
13 #include "../../third_party/base/numerics/safe_conversions_impl.h"
14 #include "../include/fsdk_define.h"
15 #include "../include/fsdk_mgr.h"
16 #include "../include/fsdk_rendercontext.h"
17
18 CPDF_CustomAccess::CPDF_CustomAccess(FPDF_FILEACCESS* pFileAccess) {
19   if (pFileAccess)
20     m_FileAccess = *pFileAccess;
21 }
22
23 FX_BOOL CPDF_CustomAccess::ReadBlock(void* buffer,
24                                      FX_FILESIZE offset,
25                                      size_t size) {
26   if (offset < 0) {
27     return FALSE;
28   }
29   FX_SAFE_FILESIZE newPos =
30       pdfium::base::checked_cast<FX_FILESIZE, size_t>(size);
31   newPos += offset;
32   if (!newPos.IsValid() || newPos.ValueOrDie() > m_FileAccess.m_FileLen) {
33     return FALSE;
34   }
35   return m_FileAccess.m_GetBlock(m_FileAccess.m_Param, offset, (uint8_t*)buffer,
36                                  size);
37 }
38
39 // 0 bit: FPDF_POLICY_MACHINETIME_ACCESS
40 static FX_DWORD foxit_sandbox_policy = 0xFFFFFFFF;
41
42 void FSDK_SetSandBoxPolicy(FPDF_DWORD policy, FPDF_BOOL enable) {
43   switch (policy) {
44     case FPDF_POLICY_MACHINETIME_ACCESS: {
45       if (enable)
46         foxit_sandbox_policy |= 0x01;
47       else
48         foxit_sandbox_policy &= 0xFFFFFFFE;
49     } break;
50     default:
51       break;
52   }
53 }
54
55 FPDF_BOOL FSDK_IsSandBoxPolicyEnabled(FPDF_DWORD policy) {
56   switch (policy) {
57     case FPDF_POLICY_MACHINETIME_ACCESS:
58       return (foxit_sandbox_policy & 0x01) ? TRUE : FALSE;
59     default:
60       return FALSE;
61   }
62 }
63
64 #ifndef _T
65 #define _T(x) x
66 #endif
67
68 CCodec_ModuleMgr* g_pCodecModule = nullptr;
69
70 #if _FX_OS_ == _FX_LINUX_EMBEDDED_
71 class CFontMapper : public IPDF_FontMapper {
72  public:
73   CFontMapper();
74   virtual ~CFontMapper();
75
76   virtual FT_Face FindSubstFont(
77       CPDF_Document* pDoc,              // [IN] The PDF document
78       const CFX_ByteString& face_name,  // [IN] Original name
79       FX_BOOL bTrueType,                // [IN] TrueType or Type1
80       FX_DWORD flags,   // [IN] PDF font flags (see PDF Reference section 5.7.1)
81       int font_weight,  // [IN] original font weight. 0 for not specified
82       int CharsetCP,    // [IN] code page for charset (see Win32 GetACP())
83       FX_BOOL bVertical,
84       CPDF_SubstFont* pSubstFont  // [OUT] Subst font data
85       );
86
87   FT_Face m_SysFace;
88 };
89
90 CFontMapper* g_pFontMapper = NULL;
91 #endif  // #if _FX_OS_ == _FX_LINUX_EMBEDDED_
92
93 DLLEXPORT void STDCALL FPDF_InitLibrary() {
94   g_pCodecModule = new CCodec_ModuleMgr();
95
96   CFX_GEModule::Create();
97   CFX_GEModule::Get()->SetCodecModule(g_pCodecModule);
98
99   CPDF_ModuleMgr::Create();
100   CPDF_ModuleMgr::Get()->SetCodecModule(g_pCodecModule);
101   CPDF_ModuleMgr::Get()->InitPageModule();
102   CPDF_ModuleMgr::Get()->InitRenderModule();
103   CPDF_ModuleMgr* pModuleMgr = CPDF_ModuleMgr::Get();
104   if (pModuleMgr) {
105     pModuleMgr->LoadEmbeddedGB1CMaps();
106     pModuleMgr->LoadEmbeddedJapan1CMaps();
107     pModuleMgr->LoadEmbeddedCNS1CMaps();
108     pModuleMgr->LoadEmbeddedKorea1CMaps();
109   }
110 }
111
112 DLLEXPORT void STDCALL FPDF_DestroyLibrary() {
113 #if _FX_OS_ == _FX_LINUX_EMBEDDED_
114   delete g_pFontMapper;
115   g_pFontMapper = nullptr;
116 #endif
117   CPDF_ModuleMgr::Destroy();
118   CFX_GEModule::Destroy();
119   delete g_pCodecModule;
120   g_pCodecModule = nullptr;
121 }
122
123 #ifndef _WIN32
124 int g_LastError;
125 void SetLastError(int err) {
126   g_LastError = err;
127 }
128
129 int GetLastError() {
130   return g_LastError;
131 }
132 #endif
133
134 void ProcessParseError(FX_DWORD err_code) {
135   // Translate FPDFAPI error code to FPDFVIEW error code
136   switch (err_code) {
137     case PDFPARSE_ERROR_FILE:
138       err_code = FPDF_ERR_FILE;
139       break;
140     case PDFPARSE_ERROR_FORMAT:
141       err_code = FPDF_ERR_FORMAT;
142       break;
143     case PDFPARSE_ERROR_PASSWORD:
144       err_code = FPDF_ERR_PASSWORD;
145       break;
146     case PDFPARSE_ERROR_HANDLER:
147       err_code = FPDF_ERR_SECURITY;
148       break;
149   }
150   SetLastError(err_code);
151 }
152
153 DLLEXPORT void STDCALL FPDF_SetSandBoxPolicy(FPDF_DWORD policy,
154                                              FPDF_BOOL enable) {
155   return FSDK_SetSandBoxPolicy(policy, enable);
156 }
157
158
159 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path,
160                                                   FPDF_BYTESTRING password) {
161   // NOTE: the creation of the file needs to be by the embedder on the
162   // other side of this API.
163   IFX_FileRead* pFileAccess = FX_CreateFileRead((const FX_CHAR*)file_path);
164   if (!pFileAccess) {
165     return nullptr;
166   }
167
168   CPDF_Parser* pParser = new CPDF_Parser;
169   pParser->SetPassword(password);
170
171   FX_DWORD err_code = pParser->StartParse(pFileAccess);
172   if (err_code) {
173     delete pParser;
174     ProcessParseError(err_code);
175     return NULL;
176   }
177   return pParser->GetDocument();
178 }
179
180 extern void CheckUnSupportError(CPDF_Document* pDoc, FX_DWORD err_code);
181
182 class CMemFile final : public IFX_FileRead {
183  public:
184   CMemFile(uint8_t* pBuf, FX_FILESIZE size) : m_pBuf(pBuf), m_size(size) {}
185
186   virtual void Release() { delete this; }
187   virtual FX_FILESIZE GetSize() { return m_size; }
188   virtual FX_BOOL ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) {
189     if (offset < 0) {
190       return FALSE;
191     }
192     FX_SAFE_FILESIZE newPos =
193         pdfium::base::checked_cast<FX_FILESIZE, size_t>(size);
194     newPos += offset;
195     if (!newPos.IsValid() || newPos.ValueOrDie() > (FX_DWORD)m_size) {
196       return FALSE;
197     }
198     FXSYS_memcpy(buffer, m_pBuf + offset, size);
199     return TRUE;
200   }
201
202  private:
203   uint8_t* m_pBuf;
204   FX_FILESIZE m_size;
205 };
206 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
207                                                      int size,
208                                                      FPDF_BYTESTRING password) {
209   CPDF_Parser* pParser = new CPDF_Parser;
210   pParser->SetPassword(password);
211   CMemFile* pMemFile = new CMemFile((uint8_t*)data_buf, size);
212   FX_DWORD err_code = pParser->StartParse(pMemFile);
213   if (err_code) {
214     delete pParser;
215     ProcessParseError(err_code);
216     return NULL;
217   }
218   CPDF_Document* pDoc = NULL;
219   pDoc = pParser ? pParser->GetDocument() : NULL;
220   CheckUnSupportError(pDoc, err_code);
221   return pParser->GetDocument();
222 }
223
224 DLLEXPORT FPDF_DOCUMENT STDCALL
225 FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess,
226                         FPDF_BYTESTRING password) {
227   CPDF_Parser* pParser = new CPDF_Parser;
228   pParser->SetPassword(password);
229   CPDF_CustomAccess* pFile = new CPDF_CustomAccess(pFileAccess);
230   FX_DWORD err_code = pParser->StartParse(pFile);
231   if (err_code) {
232     delete pParser;
233     ProcessParseError(err_code);
234     return NULL;
235   }
236   CPDF_Document* pDoc = NULL;
237   pDoc = pParser ? pParser->GetDocument() : NULL;
238   CheckUnSupportError(pDoc, err_code);
239   return pParser->GetDocument();
240 }
241
242 DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
243                                                 int* fileVersion) {
244   if (!doc || !fileVersion)
245     return FALSE;
246   *fileVersion = 0;
247   CPDF_Document* pDoc = (CPDF_Document*)doc;
248   CPDF_Parser* pParser = (CPDF_Parser*)pDoc->GetParser();
249   if (!pParser)
250     return FALSE;
251   *fileVersion = pParser->GetFileVersion();
252   return TRUE;
253 }
254
255 // jabdelmalek: changed return type from FX_DWORD to build on Linux (and match
256 // header).
257 DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document) {
258   if (document == NULL)
259     return 0;
260   CPDF_Document* pDoc = (CPDF_Document*)document;
261   CPDF_Parser* pParser = (CPDF_Parser*)pDoc->GetParser();
262   CPDF_Dictionary* pDict = pParser->GetEncryptDict();
263   if (pDict == NULL)
264     return (FX_DWORD)-1;
265
266   return pDict->GetInteger("P");
267 }
268
269 DLLEXPORT int STDCALL FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document) {
270   if (document == NULL)
271     return -1;
272   CPDF_Document* pDoc = (CPDF_Document*)document;
273   CPDF_Parser* pParser = (CPDF_Parser*)pDoc->GetParser();
274   CPDF_Dictionary* pDict = pParser->GetEncryptDict();
275   if (pDict == NULL)
276     return -1;
277
278   return pDict->GetInteger("R");
279 }
280
281 DLLEXPORT int STDCALL FPDF_GetPageCount(FPDF_DOCUMENT document) {
282   if (document == NULL)
283     return 0;
284   return ((CPDF_Document*)document)->GetPageCount();
285 }
286
287 DLLEXPORT FPDF_PAGE STDCALL FPDF_LoadPage(FPDF_DOCUMENT document,
288                                           int page_index) {
289   if (document == NULL)
290     return NULL;
291   if (page_index < 0 || page_index >= FPDF_GetPageCount(document))
292     return NULL;
293
294   CPDF_Document* pDoc = (CPDF_Document*)document;
295   if (pDoc == NULL)
296     return NULL;
297   CPDF_Dictionary* pDict = pDoc->GetPage(page_index);
298   if (pDict == NULL)
299     return NULL;
300   CPDF_Page* pPage = new CPDF_Page;
301   pPage->Load(pDoc, pDict);
302   pPage->ParseContent();
303   return pPage;
304 }
305
306 DLLEXPORT double STDCALL FPDF_GetPageWidth(FPDF_PAGE page) {
307   if (!page)
308     return 0.0;
309   return ((CPDF_Page*)page)->GetPageWidth();
310 }
311
312 DLLEXPORT double STDCALL FPDF_GetPageHeight(FPDF_PAGE page) {
313   if (!page)
314     return 0.0;
315   return ((CPDF_Page*)page)->GetPageHeight();
316 }
317
318 void DropContext(void* data) {
319   delete (CRenderContext*)data;
320 }
321
322 #if defined(_DEBUG) || defined(DEBUG)
323 #define DEBUG_TRACE
324 #endif
325
326 #if defined(_WIN32)
327 DLLEXPORT void STDCALL FPDF_RenderPage(HDC dc,
328                                        FPDF_PAGE page,
329                                        int start_x,
330                                        int start_y,
331                                        int size_x,
332                                        int size_y,
333                                        int rotate,
334                                        int flags) {
335   if (page == NULL)
336     return;
337   CPDF_Page* pPage = (CPDF_Page*)page;
338
339   CRenderContext* pContext = new CRenderContext;
340   pPage->SetPrivateData((void*)1, pContext, DropContext);
341
342 #ifndef _WIN32_WCE
343   CFX_DIBitmap* pBitmap = NULL;
344   FX_BOOL bBackgroundAlphaNeeded = FALSE;
345   bBackgroundAlphaNeeded = pPage->BackgroundAlphaNeeded();
346   if (bBackgroundAlphaNeeded) {
347     pBitmap = new CFX_DIBitmap;
348     pBitmap->Create(size_x, size_y, FXDIB_Argb);
349     pBitmap->Clear(0x00ffffff);
350 #ifdef _SKIA_SUPPORT_
351     pContext->m_pDevice = new CFX_SkiaDevice;
352     ((CFX_SkiaDevice*)pContext->m_pDevice)->Attach((CFX_DIBitmap*)pBitmap);
353 #else
354     pContext->m_pDevice = new CFX_FxgeDevice;
355     ((CFX_FxgeDevice*)pContext->m_pDevice)->Attach((CFX_DIBitmap*)pBitmap);
356 #endif
357   } else
358     pContext->m_pDevice = new CFX_WindowsDevice(dc);
359
360   FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y,
361                          rotate, flags, TRUE, NULL);
362
363   if (bBackgroundAlphaNeeded) {
364     if (pBitmap) {
365       CFX_WindowsDevice WinDC(dc);
366
367       if (WinDC.GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
368         CFX_DIBitmap* pDst = new CFX_DIBitmap;
369         int pitch = pBitmap->GetPitch();
370         pDst->Create(size_x, size_y, FXDIB_Rgb32);
371         FXSYS_memset(pDst->GetBuffer(), -1, pitch * size_y);
372         pDst->CompositeBitmap(0, 0, size_x, size_y, pBitmap, 0, 0,
373                               FXDIB_BLEND_NORMAL, NULL, FALSE, NULL);
374         WinDC.StretchDIBits(pDst, 0, 0, size_x, size_y);
375         delete pDst;
376       } else
377         WinDC.SetDIBits(pBitmap, 0, 0);
378     }
379   }
380 #else
381   // get clip region
382   RECT rect, cliprect;
383   rect.left = start_x;
384   rect.top = start_y;
385   rect.right = start_x + size_x;
386   rect.bottom = start_y + size_y;
387   GetClipBox(dc, &cliprect);
388   IntersectRect(&rect, &rect, &cliprect);
389   int width = rect.right - rect.left;
390   int height = rect.bottom - rect.top;
391
392 #ifdef DEBUG_TRACE
393   {
394     char str[128];
395     memset(str, 0, sizeof(str));
396     FXSYS_snprintf(str, sizeof(str) - 1, "Rendering DIB %d x %d", width,
397                    height);
398     CPDF_ModuleMgr::Get()->ReportError(999, str);
399   }
400 #endif
401
402   // Create a DIB section
403   LPVOID pBuffer;
404   BITMAPINFOHEADER bmih;
405   FXSYS_memset(&bmih, 0, sizeof bmih);
406   bmih.biSize = sizeof bmih;
407   bmih.biBitCount = 24;
408   bmih.biHeight = -height;
409   bmih.biPlanes = 1;
410   bmih.biWidth = width;
411   pContext->m_hBitmap = CreateDIBSection(dc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
412                                          &pBuffer, NULL, 0);
413   if (pContext->m_hBitmap == NULL) {
414 #if defined(DEBUG) || defined(_DEBUG)
415     char str[128];
416     memset(str, 0, sizeof(str));
417     FXSYS_snprintf(str, sizeof(str) - 1,
418                    "Error CreateDIBSection: %d x %d, error code = %d", width,
419                    height, GetLastError());
420     CPDF_ModuleMgr::Get()->ReportError(FPDFERR_OUT_OF_MEMORY, str);
421 #else
422     CPDF_ModuleMgr::Get()->ReportError(FPDFERR_OUT_OF_MEMORY, NULL);
423 #endif
424   }
425   FXSYS_memset(pBuffer, 0xff, height * ((width * 3 + 3) / 4 * 4));
426
427 #ifdef DEBUG_TRACE
428   { CPDF_ModuleMgr::Get()->ReportError(999, "DIBSection created"); }
429 #endif
430
431   // Create a device with this external buffer
432   pContext->m_pBitmap = new CFX_DIBitmap;
433   pContext->m_pBitmap->Create(width, height, FXDIB_Rgb, (uint8_t*)pBuffer);
434   pContext->m_pDevice = new CPDF_FxgeDevice;
435   ((CPDF_FxgeDevice*)pContext->m_pDevice)->Attach(pContext->m_pBitmap);
436
437 #ifdef DEBUG_TRACE
438   CPDF_ModuleMgr::Get()->ReportError(999, "Ready for PDF rendering");
439 #endif
440
441   // output to bitmap device
442   FPDF_RenderPage_Retail(pContext, page, start_x - rect.left,
443                          start_y - rect.top, size_x, size_y, rotate, flags);
444
445 #ifdef DEBUG_TRACE
446   CPDF_ModuleMgr::Get()->ReportError(999, "Finished PDF rendering");
447 #endif
448
449   // Now output to real device
450   HDC hMemDC = CreateCompatibleDC(dc);
451   if (hMemDC == NULL) {
452 #if defined(DEBUG) || defined(_DEBUG)
453     char str[128];
454     memset(str, 0, sizeof(str));
455     FXSYS_snprintf(str, sizeof(str) - 1,
456                    "Error CreateCompatibleDC. Error code = %d", GetLastError());
457     CPDF_ModuleMgr::Get()->ReportError(FPDFERR_OUT_OF_MEMORY, str);
458 #else
459     CPDF_ModuleMgr::Get()->ReportError(FPDFERR_OUT_OF_MEMORY, NULL);
460 #endif
461   }
462
463   HGDIOBJ hOldBitmap = SelectObject(hMemDC, pContext->m_hBitmap);
464
465 #ifdef DEBUG_TRACE
466   CPDF_ModuleMgr::Get()->ReportError(999, "Ready for screen rendering");
467 #endif
468
469   BitBlt(dc, rect.left, rect.top, width, height, hMemDC, 0, 0, SRCCOPY);
470   SelectObject(hMemDC, hOldBitmap);
471   DeleteDC(hMemDC);
472
473 #ifdef DEBUG_TRACE
474   CPDF_ModuleMgr::Get()->ReportError(999, "Finished screen rendering");
475 #endif
476
477 #endif
478   if (bBackgroundAlphaNeeded) {
479     delete pBitmap;
480     pBitmap = NULL;
481   }
482   delete pContext;
483   pPage->RemovePrivateData((void*)1);
484 }
485 #endif
486
487 DLLEXPORT void STDCALL FPDF_RenderPageBitmap(FPDF_BITMAP bitmap,
488                                              FPDF_PAGE page,
489                                              int start_x,
490                                              int start_y,
491                                              int size_x,
492                                              int size_y,
493                                              int rotate,
494                                              int flags) {
495   if (bitmap == NULL || page == NULL)
496     return;
497   CPDF_Page* pPage = (CPDF_Page*)page;
498
499   CRenderContext* pContext = new CRenderContext;
500   pPage->SetPrivateData((void*)1, pContext, DropContext);
501 #ifdef _SKIA_SUPPORT_
502   pContext->m_pDevice = new CFX_SkiaDevice;
503
504   if (flags & FPDF_REVERSE_BYTE_ORDER)
505     ((CFX_SkiaDevice*)pContext->m_pDevice)
506         ->Attach((CFX_DIBitmap*)bitmap, 0, TRUE);
507   else
508     ((CFX_SkiaDevice*)pContext->m_pDevice)->Attach((CFX_DIBitmap*)bitmap);
509 #else
510   pContext->m_pDevice = new CFX_FxgeDevice;
511
512   if (flags & FPDF_REVERSE_BYTE_ORDER)
513     ((CFX_FxgeDevice*)pContext->m_pDevice)
514         ->Attach((CFX_DIBitmap*)bitmap, 0, TRUE);
515   else
516     ((CFX_FxgeDevice*)pContext->m_pDevice)->Attach((CFX_DIBitmap*)bitmap);
517 #endif
518
519   FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y,
520                          rotate, flags, TRUE, NULL);
521
522   delete pContext;
523   pPage->RemovePrivateData((void*)1);
524 }
525
526 DLLEXPORT void STDCALL FPDF_ClosePage(FPDF_PAGE page) {
527   if (!page)
528     return;
529   CPDFSDK_PageView* pPageView =
530       (CPDFSDK_PageView*)(((CPDF_Page*)page))->GetPrivateData((void*)page);
531   if (pPageView && pPageView->IsLocked()) {
532     pPageView->TakeOverPage();
533     return;
534   }
535   delete (CPDF_Page*)page;
536 }
537
538 DLLEXPORT void STDCALL FPDF_CloseDocument(FPDF_DOCUMENT document) {
539   if (!document)
540     return;
541   CPDF_Document* pDoc = (CPDF_Document*)document;
542   CPDF_Parser* pParser = (CPDF_Parser*)pDoc->GetParser();
543   if (pParser == NULL) {
544     delete pDoc;
545     return;
546   }
547   delete pParser;
548 }
549
550 DLLEXPORT unsigned long STDCALL FPDF_GetLastError() {
551   return GetLastError();
552 }
553
554 DLLEXPORT void STDCALL FPDF_DeviceToPage(FPDF_PAGE page,
555                                          int start_x,
556                                          int start_y,
557                                          int size_x,
558                                          int size_y,
559                                          int rotate,
560                                          int device_x,
561                                          int device_y,
562                                          double* page_x,
563                                          double* page_y) {
564   if (page == NULL || page_x == NULL || page_y == NULL)
565     return;
566   CPDF_Page* pPage = (CPDF_Page*)page;
567
568   CPDF_Matrix page2device;
569   pPage->GetDisplayMatrix(page2device, start_x, start_y, size_x, size_y,
570                           rotate);
571   CPDF_Matrix device2page;
572   device2page.SetReverse(page2device);
573
574   FX_FLOAT page_x_f, page_y_f;
575   device2page.Transform((FX_FLOAT)(device_x), (FX_FLOAT)(device_y), page_x_f,
576                         page_y_f);
577
578   *page_x = (page_x_f);
579   *page_y = (page_y_f);
580 }
581
582 DLLEXPORT void STDCALL FPDF_PageToDevice(FPDF_PAGE page,
583                                          int start_x,
584                                          int start_y,
585                                          int size_x,
586                                          int size_y,
587                                          int rotate,
588                                          double page_x,
589                                          double page_y,
590                                          int* device_x,
591                                          int* device_y) {
592   if (page == NULL || device_x == NULL || device_y == NULL)
593     return;
594   CPDF_Page* pPage = (CPDF_Page*)page;
595
596   CPDF_Matrix page2device;
597   pPage->GetDisplayMatrix(page2device, start_x, start_y, size_x, size_y,
598                           rotate);
599
600   FX_FLOAT device_x_f, device_y_f;
601   page2device.Transform(((FX_FLOAT)page_x), ((FX_FLOAT)page_y), device_x_f,
602                         device_y_f);
603
604   *device_x = FXSYS_round(device_x_f);
605   *device_y = FXSYS_round(device_y_f);
606 }
607
608 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width,
609                                                 int height,
610                                                 int alpha) {
611   nonstd::unique_ptr<CFX_DIBitmap> pBitmap(new CFX_DIBitmap);
612   if (!pBitmap->Create(width, height, alpha ? FXDIB_Argb : FXDIB_Rgb32)) {
613     return NULL;
614   }
615   return pBitmap.release();
616 }
617
618 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_CreateEx(int width,
619                                                   int height,
620                                                   int format,
621                                                   void* first_scan,
622                                                   int stride) {
623   FXDIB_Format fx_format;
624   switch (format) {
625     case FPDFBitmap_Gray:
626       fx_format = FXDIB_8bppRgb;
627       break;
628     case FPDFBitmap_BGR:
629       fx_format = FXDIB_Rgb;
630       break;
631     case FPDFBitmap_BGRx:
632       fx_format = FXDIB_Rgb32;
633       break;
634     case FPDFBitmap_BGRA:
635       fx_format = FXDIB_Argb;
636       break;
637     default:
638       return NULL;
639   }
640   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
641   pBitmap->Create(width, height, fx_format, (uint8_t*)first_scan, stride);
642   return pBitmap;
643 }
644
645 DLLEXPORT void STDCALL FPDFBitmap_FillRect(FPDF_BITMAP bitmap,
646                                            int left,
647                                            int top,
648                                            int width,
649                                            int height,
650                                            FPDF_DWORD color) {
651   if (bitmap == NULL)
652     return;
653 #ifdef _SKIA_SUPPORT_
654   CFX_SkiaDevice device;
655 #else
656   CFX_FxgeDevice device;
657 #endif
658   device.Attach((CFX_DIBitmap*)bitmap);
659   if (!((CFX_DIBitmap*)bitmap)->HasAlpha())
660     color |= 0xFF000000;
661   FX_RECT rect(left, top, left + width, top + height);
662   device.FillRect(&rect, color);
663 }
664
665 DLLEXPORT void* STDCALL FPDFBitmap_GetBuffer(FPDF_BITMAP bitmap) {
666   if (bitmap == NULL)
667     return NULL;
668   return ((CFX_DIBitmap*)bitmap)->GetBuffer();
669 }
670
671 DLLEXPORT int STDCALL FPDFBitmap_GetWidth(FPDF_BITMAP bitmap) {
672   if (bitmap == NULL)
673     return 0;
674   return ((CFX_DIBitmap*)bitmap)->GetWidth();
675 }
676
677 DLLEXPORT int STDCALL FPDFBitmap_GetHeight(FPDF_BITMAP bitmap) {
678   if (bitmap == NULL)
679     return 0;
680   return ((CFX_DIBitmap*)bitmap)->GetHeight();
681 }
682
683 DLLEXPORT int STDCALL FPDFBitmap_GetStride(FPDF_BITMAP bitmap) {
684   if (bitmap == NULL)
685     return 0;
686   return ((CFX_DIBitmap*)bitmap)->GetPitch();
687 }
688
689 DLLEXPORT void STDCALL FPDFBitmap_Destroy(FPDF_BITMAP bitmap) {
690   delete (CFX_DIBitmap*)bitmap;
691 }
692
693 void FPDF_RenderPage_Retail(CRenderContext* pContext,
694                             FPDF_PAGE page,
695                             int start_x,
696                             int start_y,
697                             int size_x,
698                             int size_y,
699                             int rotate,
700                             int flags,
701                             FX_BOOL bNeedToRestore,
702                             IFSDK_PAUSE_Adapter* pause) {
703   CPDF_Page* pPage = (CPDF_Page*)page;
704   if (pPage == NULL)
705     return;
706
707   if (!pContext->m_pOptions)
708     pContext->m_pOptions = new CPDF_RenderOptions;
709
710   if (flags & FPDF_LCD_TEXT)
711     pContext->m_pOptions->m_Flags |= RENDER_CLEARTYPE;
712   else
713     pContext->m_pOptions->m_Flags &= ~RENDER_CLEARTYPE;
714   if (flags & FPDF_NO_NATIVETEXT)
715     pContext->m_pOptions->m_Flags |= RENDER_NO_NATIVETEXT;
716   if (flags & FPDF_RENDER_LIMITEDIMAGECACHE)
717     pContext->m_pOptions->m_Flags |= RENDER_LIMITEDIMAGECACHE;
718   if (flags & FPDF_RENDER_FORCEHALFTONE)
719     pContext->m_pOptions->m_Flags |= RENDER_FORCE_HALFTONE;
720   if (flags & FPDF_RENDER_NO_SMOOTHTEXT)
721     pContext->m_pOptions->m_Flags |= RENDER_NOTEXTSMOOTH;
722   if (flags & FPDF_RENDER_NO_SMOOTHIMAGE)
723     pContext->m_pOptions->m_Flags |= RENDER_NOIMAGESMOOTH;
724   if (flags & FPDF_RENDER_NO_SMOOTHPATH)
725     pContext->m_pOptions->m_Flags |= RENDER_NOPATHSMOOTH;
726   // Grayscale output
727   if (flags & FPDF_GRAYSCALE) {
728     pContext->m_pOptions->m_ColorMode = RENDER_COLOR_GRAY;
729     pContext->m_pOptions->m_ForeColor = 0;
730     pContext->m_pOptions->m_BackColor = 0xffffff;
731   }
732   const CPDF_OCContext::UsageType usage =
733       (flags & FPDF_PRINTING) ? CPDF_OCContext::Print : CPDF_OCContext::View;
734   pContext->m_pOptions->m_AddFlags = flags >> 8;
735   pContext->m_pOptions->m_pOCContext =
736       new CPDF_OCContext(pPage->m_pDocument, usage);
737
738   CFX_AffineMatrix matrix;
739   pPage->GetDisplayMatrix(matrix, start_x, start_y, size_x, size_y, rotate);
740
741   FX_RECT clip;
742   clip.left = start_x;
743   clip.right = start_x + size_x;
744   clip.top = start_y;
745   clip.bottom = start_y + size_y;
746   pContext->m_pDevice->SaveState();
747   pContext->m_pDevice->SetClip_Rect(&clip);
748
749   pContext->m_pContext = new CPDF_RenderContext;
750   pContext->m_pContext->Create(pPage);
751   pContext->m_pContext->AppendObjectList(pPage, &matrix);
752
753   if (flags & FPDF_ANNOT) {
754     pContext->m_pAnnots = new CPDF_AnnotList(pPage);
755     FX_BOOL bPrinting = pContext->m_pDevice->GetDeviceClass() != FXDC_DISPLAY;
756     pContext->m_pAnnots->DisplayAnnots(pPage, pContext->m_pContext, bPrinting,
757                                        &matrix, TRUE, NULL);
758   }
759
760   pContext->m_pRenderer = new CPDF_ProgressiveRenderer(
761       pContext->m_pContext, pContext->m_pDevice, pContext->m_pOptions);
762   pContext->m_pRenderer->Start(pause);
763   if (bNeedToRestore)
764     pContext->m_pDevice->RestoreState();
765 }
766
767 DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document,
768                                               int page_index,
769                                               double* width,
770                                               double* height) {
771   CPDF_Document* pDoc = (CPDF_Document*)document;
772   if (pDoc == NULL)
773     return FALSE;
774
775   CPDF_Dictionary* pDict = pDoc->GetPage(page_index);
776   if (pDict == NULL)
777     return FALSE;
778
779   CPDF_Page page;
780   page.Load(pDoc, pDict);
781   *width = page.GetPageWidth();
782   *height = page.GetPageHeight();
783
784   return TRUE;
785 }
786
787 DLLEXPORT FPDF_BOOL STDCALL
788 FPDF_VIEWERREF_GetPrintScaling(FPDF_DOCUMENT document) {
789   CPDF_Document* pDoc = (CPDF_Document*)document;
790   if (!pDoc)
791     return TRUE;
792   CPDF_ViewerPreferences viewRef(pDoc);
793   return viewRef.PrintScaling();
794 }
795
796 DLLEXPORT int STDCALL FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document) {
797   CPDF_Document* pDoc = (CPDF_Document*)document;
798   if (!pDoc)
799     return 1;
800   CPDF_ViewerPreferences viewRef(pDoc);
801   return viewRef.NumCopies();
802 }
803
804 DLLEXPORT FPDF_PAGERANGE STDCALL
805 FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document) {
806   CPDF_Document* pDoc = (CPDF_Document*)document;
807   if (!pDoc)
808     return NULL;
809   CPDF_ViewerPreferences viewRef(pDoc);
810   return viewRef.PrintPageRange();
811 }
812
813 DLLEXPORT FPDF_DUPLEXTYPE STDCALL
814 FPDF_VIEWERREF_GetDuplex(FPDF_DOCUMENT document) {
815   CPDF_Document* pDoc = (CPDF_Document*)document;
816   if (!pDoc)
817     return DuplexUndefined;
818   CPDF_ViewerPreferences viewRef(pDoc);
819   CFX_ByteString duplex = viewRef.Duplex();
820   if (FX_BSTRC("Simplex") == duplex)
821     return Simplex;
822   if (FX_BSTRC("DuplexFlipShortEdge") == duplex)
823     return DuplexFlipShortEdge;
824   if (FX_BSTRC("DuplexFlipLongEdge") == duplex)
825     return DuplexFlipLongEdge;
826   return DuplexUndefined;
827 }
828
829 DLLEXPORT FPDF_DWORD STDCALL FPDF_CountNamedDests(FPDF_DOCUMENT document) {
830   if (!document)
831     return 0;
832   CPDF_Document* pDoc = (CPDF_Document*)document;
833
834   CPDF_Dictionary* pRoot = pDoc->GetRoot();
835   if (!pRoot)
836     return 0;
837
838   CPDF_NameTree nameTree(pDoc, FX_BSTRC("Dests"));
839   int count = nameTree.GetCount();
840   CPDF_Dictionary* pDest = pRoot->GetDict(FX_BSTRC("Dests"));
841   if (pDest)
842     count += pDest->GetCount();
843   return count;
844 }
845
846 DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDestByName(FPDF_DOCUMENT document,
847                                                     FPDF_BYTESTRING name) {
848   if (!document)
849     return NULL;
850   if (!name || name[0] == 0)
851     return NULL;
852
853   CPDF_Document* pDoc = (CPDF_Document*)document;
854   CPDF_NameTree name_tree(pDoc, FX_BSTRC("Dests"));
855   return name_tree.LookupNamedDest(pDoc, name);
856 }
857
858 DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDest(FPDF_DOCUMENT document,
859                                               int index,
860                                               void* buffer,
861                                               long* buflen) {
862   if (!buffer)
863     *buflen = 0;
864   if (!document || index < 0)
865     return NULL;
866   CPDF_Document* pDoc = (CPDF_Document*)document;
867
868   CPDF_Dictionary* pRoot = pDoc->GetRoot();
869   if (!pRoot)
870     return NULL;
871
872   CPDF_Object* pDestObj = NULL;
873   CFX_ByteString bsName;
874   CPDF_NameTree nameTree(pDoc, FX_BSTRC("Dests"));
875   int count = nameTree.GetCount();
876   if (index >= count) {
877     CPDF_Dictionary* pDest = pRoot->GetDict(FX_BSTRC("Dests"));
878     if (!pDest)
879       return NULL;
880     if (index >= count + pDest->GetCount())
881       return NULL;
882     index -= count;
883     FX_POSITION pos = pDest->GetStartPos();
884     int i = 0;
885     while (pos) {
886       pDestObj = pDest->GetNextElement(pos, bsName);
887       if (!pDestObj)
888         continue;
889       if (i == index)
890         break;
891       i++;
892     }
893   } else {
894     pDestObj = nameTree.LookupValue(index, bsName);
895   }
896   if (!pDestObj)
897     return NULL;
898   if (pDestObj->GetType() == PDFOBJ_DICTIONARY) {
899     pDestObj = ((CPDF_Dictionary*)pDestObj)->GetArray(FX_BSTRC("D"));
900     if (!pDestObj)
901       return NULL;
902   }
903   if (pDestObj->GetType() != PDFOBJ_ARRAY)
904     return NULL;
905   CFX_WideString wsName = PDF_DecodeText(bsName);
906   CFX_ByteString utf16Name = wsName.UTF16LE_Encode();
907   unsigned int len = utf16Name.GetLength();
908   if (!buffer) {
909     *buflen = len;
910   } else if (*buflen >= len) {
911     memcpy(buffer, utf16Name.c_str(), len);
912     *buflen = len;
913   } else {
914     *buflen = -1;
915   }
916   return (FPDF_DEST)pDestObj;
917 }