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