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