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