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