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