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 <crtdbg.h>
8 
9 #include <algorithm>
10 #include <memory>
11 #include <vector>
12 
13 #include "core/fxcodec/fx_codec.h"
14 #include "core/fxcrt/cfx_maybe_owned.h"
15 #include "core/fxcrt/fx_memory.h"
16 #include "core/fxcrt/fx_system.h"
17 #include "core/fxge/cfx_windowsdevice.h"
18 #include "core/fxge/dib/dib_int.h"
19 #include "core/fxge/fx_font.h"
20 #include "core/fxge/fx_freetype.h"
21 #include "core/fxge/ge/cfx_folderfontinfo.h"
22 #include "core/fxge/ge/fx_text_int.h"
23 #include "core/fxge/ifx_systemfontinfo.h"
24 #include "core/fxge/win32/cfx_windowsdib.h"
25 #include "core/fxge/win32/dwrite_int.h"
26 #include "core/fxge/win32/win32_int.h"
27 #include "third_party/base/ptr_util.h"
28 #include "third_party/base/stl_util.h"
29 
30 #ifndef _SKIA_SUPPORT_
31 #include "core/fxge/agg/fx_agg_driver.h"
32 #endif
33 
34 namespace {
35 
36 const struct {
37   const FX_CHAR* m_pFaceName;
38   const FX_CHAR* m_pVariantName;
39 } g_VariantNames[] = {
40     {"DFKai-SB", "\x19\x6A\x77\x69\xD4\x9A"},
41 };
42 
43 const struct {
44   const FX_CHAR* m_pName;
45   const FX_CHAR* m_pWinName;
46   bool m_bBold;
47   bool m_bItalic;
48 } g_Base14Substs[] = {
49     {"Courier", "Courier New", false, false},
50     {"Courier-Bold", "Courier New", true, false},
51     {"Courier-BoldOblique", "Courier New", true, true},
52     {"Courier-Oblique", "Courier New", false, true},
53     {"Helvetica", "Arial", false, false},
54     {"Helvetica-Bold", "Arial", true, false},
55     {"Helvetica-BoldOblique", "Arial", true, true},
56     {"Helvetica-Oblique", "Arial", false, true},
57     {"Times-Roman", "Times New Roman", false, false},
58     {"Times-Bold", "Times New Roman", true, false},
59     {"Times-BoldItalic", "Times New Roman", true, true},
60     {"Times-Italic", "Times New Roman", false, true},
61 };
62 
63 struct FontNameMap {
64   const FX_CHAR* m_pSubFontName;
65   const FX_CHAR* m_pSrcFontName;
66 };
67 const FontNameMap g_JpFontNameMap[] = {
68     {"MS Mincho", "Heiseimin-W3"},
69     {"MS Gothic", "Jun101-Light"},
70 };
71 
GetSubFontName(CFX_ByteString * name)72 bool GetSubFontName(CFX_ByteString* name) {
73   for (size_t i = 0; i < FX_ArraySize(g_JpFontNameMap); ++i) {
74     if (!FXSYS_stricmp(name->c_str(), g_JpFontNameMap[i].m_pSrcFontName)) {
75       *name = g_JpFontNameMap[i].m_pSubFontName;
76       return true;
77     }
78   }
79   return false;
80 }
81 
IsGDIEnabled()82 bool IsGDIEnabled() {
83   // If GDI is disabled then GetDC for the desktop will fail.
84   HDC hdc = ::GetDC(nullptr);
85   if (!hdc)
86     return false;
87   ::ReleaseDC(nullptr, hdc);
88   return true;
89 }
90 
CreatePen(const CFX_GraphStateData * pGraphState,const CFX_Matrix * pMatrix,uint32_t argb)91 HPEN CreatePen(const CFX_GraphStateData* pGraphState,
92                const CFX_Matrix* pMatrix,
93                uint32_t argb) {
94   FX_FLOAT width;
95   FX_FLOAT scale = 1.f;
96   if (pMatrix)
97     scale = FXSYS_fabs(pMatrix->a) > FXSYS_fabs(pMatrix->b)
98                 ? FXSYS_fabs(pMatrix->a)
99                 : FXSYS_fabs(pMatrix->b);
100   if (pGraphState) {
101     width = scale * pGraphState->m_LineWidth;
102   } else {
103     width = 1.0f;
104   }
105   uint32_t PenStyle = PS_GEOMETRIC;
106   if (width < 1) {
107     width = 1;
108   }
109   if (pGraphState->m_DashCount) {
110     PenStyle |= PS_USERSTYLE;
111   } else {
112     PenStyle |= PS_SOLID;
113   }
114   switch (pGraphState->m_LineCap) {
115     case 0:
116       PenStyle |= PS_ENDCAP_FLAT;
117       break;
118     case 1:
119       PenStyle |= PS_ENDCAP_ROUND;
120       break;
121     case 2:
122       PenStyle |= PS_ENDCAP_SQUARE;
123       break;
124   }
125   switch (pGraphState->m_LineJoin) {
126     case 0:
127       PenStyle |= PS_JOIN_MITER;
128       break;
129     case 1:
130       PenStyle |= PS_JOIN_ROUND;
131       break;
132     case 2:
133       PenStyle |= PS_JOIN_BEVEL;
134       break;
135   }
136   int a;
137   FX_COLORREF rgb;
138   ArgbDecode(argb, a, rgb);
139   LOGBRUSH lb;
140   lb.lbColor = rgb;
141   lb.lbStyle = BS_SOLID;
142   lb.lbHatch = 0;
143   std::vector<uint32_t> dashes;
144   if (pGraphState->m_DashCount) {
145     dashes.resize(pGraphState->m_DashCount);
146     for (int i = 0; i < pGraphState->m_DashCount; i++) {
147       dashes[i] = FXSYS_round(
148           pMatrix ? pMatrix->TransformDistance(pGraphState->m_DashArray[i])
149                   : pGraphState->m_DashArray[i]);
150       dashes[i] = std::max(dashes[i], 1U);
151     }
152   }
153   return ExtCreatePen(PenStyle, (DWORD)FXSYS_ceil(width), &lb,
154                       pGraphState->m_DashCount,
155                       reinterpret_cast<const DWORD*>(dashes.data()));
156 }
157 
CreateBrush(uint32_t argb)158 HBRUSH CreateBrush(uint32_t argb) {
159   int a;
160   FX_COLORREF rgb;
161   ArgbDecode(argb, a, rgb);
162   return CreateSolidBrush(rgb);
163 }
164 
SetPathToDC(HDC hDC,const CFX_PathData * pPathData,const CFX_Matrix * pMatrix)165 void SetPathToDC(HDC hDC,
166                  const CFX_PathData* pPathData,
167                  const CFX_Matrix* pMatrix) {
168   BeginPath(hDC);
169 
170   const std::vector<FX_PATHPOINT>& pPoints = pPathData->GetPoints();
171   for (size_t i = 0; i < pPoints.size(); i++) {
172     CFX_PointF pos = pPoints[i].m_Point;
173     if (pMatrix)
174       pos = pMatrix->Transform(pos);
175 
176     CFX_Point screen(FXSYS_round(pos.x), FXSYS_round(pos.y));
177     FXPT_TYPE point_type = pPoints[i].m_Type;
178     if (point_type == FXPT_TYPE::MoveTo) {
179       MoveToEx(hDC, screen.x, screen.y, nullptr);
180     } else if (point_type == FXPT_TYPE::LineTo) {
181       if (pPoints[i].m_Point == pPoints[i - 1].m_Point)
182         screen.x++;
183 
184       LineTo(hDC, screen.x, screen.y);
185     } else if (point_type == FXPT_TYPE::BezierTo) {
186       POINT lppt[3];
187       lppt[0].x = screen.x;
188       lppt[0].y = screen.y;
189 
190       pos = pPoints[i + 1].m_Point;
191       if (pMatrix)
192         pos = pMatrix->Transform(pos);
193 
194       lppt[1].x = FXSYS_round(pos.x);
195       lppt[1].y = FXSYS_round(pos.y);
196 
197       pos = pPoints[i + 2].m_Point;
198       if (pMatrix)
199         pos = pMatrix->Transform(pos);
200 
201       lppt[2].x = FXSYS_round(pos.x);
202       lppt[2].y = FXSYS_round(pos.y);
203       PolyBezierTo(hDC, lppt, 3);
204       i += 2;
205     }
206     if (pPoints[i].m_CloseFigure)
207       CloseFigure(hDC);
208   }
209   EndPath(hDC);
210 }
211 
212 #ifdef _SKIA_SUPPORT_
213 // TODO(caryclark)  This antigrain function is duplicated here to permit
214 // removing the last remaining dependency. Eventually, this will be elminiated
215 // altogether and replace by Skia code.
216 
217 struct rect_base {
218   FX_FLOAT x1;
219   FX_FLOAT y1;
220   FX_FLOAT x2;
221   FX_FLOAT y2;
222 };
223 
clip_liang_barsky(FX_FLOAT x1,FX_FLOAT y1,FX_FLOAT x2,FX_FLOAT y2,const rect_base & clip_box,FX_FLOAT * x,FX_FLOAT * y)224 unsigned clip_liang_barsky(FX_FLOAT x1,
225                            FX_FLOAT y1,
226                            FX_FLOAT x2,
227                            FX_FLOAT y2,
228                            const rect_base& clip_box,
229                            FX_FLOAT* x,
230                            FX_FLOAT* y) {
231   const FX_FLOAT nearzero = 1e-30f;
232   FX_FLOAT deltax = x2 - x1;
233   FX_FLOAT deltay = y2 - y1;
234   unsigned np = 0;
235   if (deltax == 0)
236     deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
237   FX_FLOAT xin, xout;
238   if (deltax > 0) {
239     xin = clip_box.x1;
240     xout = clip_box.x2;
241   } else {
242     xin = clip_box.x2;
243     xout = clip_box.x1;
244   }
245   FX_FLOAT tinx = (xin - x1) / deltax;
246   if (deltay == 0)
247     deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
248   FX_FLOAT yin, yout;
249   if (deltay > 0) {
250     yin = clip_box.y1;
251     yout = clip_box.y2;
252   } else {
253     yin = clip_box.y2;
254     yout = clip_box.y1;
255   }
256   FX_FLOAT tiny = (yin - y1) / deltay;
257   FX_FLOAT tin1, tin2;
258   if (tinx < tiny) {
259     tin1 = tinx;
260     tin2 = tiny;
261   } else {
262     tin1 = tiny;
263     tin2 = tinx;
264   }
265   if (tin1 <= 1.0f) {
266     if (0 < tin1) {
267       *x++ = xin;
268       *y++ = yin;
269       ++np;
270     }
271     if (tin2 <= 1.0f) {
272       FX_FLOAT toutx = (xout - x1) / deltax;
273       FX_FLOAT touty = (yout - y1) / deltay;
274       FX_FLOAT tout1 = (toutx < touty) ? toutx : touty;
275       if (tin2 > 0 || tout1 > 0) {
276         if (tin2 <= tout1) {
277           if (tin2 > 0) {
278             if (tinx > tiny) {
279               *x++ = xin;
280               *y++ = y1 + (deltay * tinx);
281             } else {
282               *x++ = x1 + (deltax * tiny);
283               *y++ = yin;
284             }
285             ++np;
286           }
287           if (tout1 < 1.0f) {
288             if (toutx < touty) {
289               *x++ = xout;
290               *y++ = y1 + (deltay * toutx);
291             } else {
292               *x++ = x1 + (deltax * touty);
293               *y++ = yout;
294             }
295           } else {
296             *x++ = x2;
297             *y++ = y2;
298           }
299           ++np;
300         } else {
301           if (tinx > tiny) {
302             *x++ = xin;
303             *y++ = yout;
304           } else {
305             *x++ = xout;
306             *y++ = yin;
307           }
308           ++np;
309         }
310       }
311     }
312   }
313   return np;
314 }
315 #endif  // _SKIA_SUPPORT_
316 
317 class CFX_Win32FallbackFontInfo final : public CFX_FolderFontInfo {
318  public:
CFX_Win32FallbackFontInfo()319   CFX_Win32FallbackFontInfo() {}
~CFX_Win32FallbackFontInfo()320   ~CFX_Win32FallbackFontInfo() override {}
321 
322   // CFX_FolderFontInfo:
323   void* MapFont(int weight,
324                 bool bItalic,
325                 int charset,
326                 int pitch_family,
327                 const FX_CHAR* family,
328                 int& iExact) override;
329 };
330 
331 class CFX_Win32FontInfo final : public IFX_SystemFontInfo {
332  public:
333   CFX_Win32FontInfo();
334   ~CFX_Win32FontInfo() override;
335 
336   // IFX_SystemFontInfo
337   bool EnumFontList(CFX_FontMapper* pMapper) override;
338   void* MapFont(int weight,
339                 bool bItalic,
340                 int charset,
341                 int pitch_family,
342                 const FX_CHAR* face,
343                 int& iExact) override;
GetFont(const FX_CHAR * face)344   void* GetFont(const FX_CHAR* face) override { return nullptr; }
345   uint32_t GetFontData(void* hFont,
346                        uint32_t table,
347                        uint8_t* buffer,
348                        uint32_t size) override;
349   bool GetFaceName(void* hFont, CFX_ByteString& name) override;
350   bool GetFontCharset(void* hFont, int& charset) override;
351   void DeleteFont(void* hFont) override;
352 
353   bool IsOpenTypeFromDiv(const LOGFONTA* plf);
354   bool IsSupportFontFormDiv(const LOGFONTA* plf);
355   void AddInstalledFont(const LOGFONTA* plf, uint32_t FontType);
356   void GetGBPreference(CFX_ByteString& face, int weight, int picth_family);
357   void GetJapanesePreference(CFX_ByteString& face,
358                              int weight,
359                              int picth_family);
360   CFX_ByteString FindFont(const CFX_ByteString& name);
361 
362   HDC m_hDC;
363   CFX_FontMapper* m_pMapper;
364   CFX_ByteString m_LastFamily;
365   CFX_ByteString m_KaiTi, m_FangSong;
366 };
367 
FontEnumProc(const LOGFONTA * plf,const TEXTMETRICA * lpntme,uint32_t FontType,LPARAM lParam)368 int CALLBACK FontEnumProc(const LOGFONTA* plf,
369                           const TEXTMETRICA* lpntme,
370                           uint32_t FontType,
371                           LPARAM lParam) {
372   CFX_Win32FontInfo* pFontInfo = reinterpret_cast<CFX_Win32FontInfo*>(lParam);
373   pFontInfo->AddInstalledFont(plf, FontType);
374   return 1;
375 }
376 
CFX_Win32FontInfo()377 CFX_Win32FontInfo::CFX_Win32FontInfo() : m_hDC(CreateCompatibleDC(nullptr)) {}
378 
~CFX_Win32FontInfo()379 CFX_Win32FontInfo::~CFX_Win32FontInfo() {
380   DeleteDC(m_hDC);
381 }
382 
IsOpenTypeFromDiv(const LOGFONTA * plf)383 bool CFX_Win32FontInfo::IsOpenTypeFromDiv(const LOGFONTA* plf) {
384   HFONT hFont = CreateFontIndirectA(plf);
385   bool ret = false;
386   uint32_t font_size = GetFontData(hFont, 0, nullptr, 0);
387   if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) {
388     uint32_t lVersion = 0;
389     GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t));
390     lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) |
391                ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 |
392                ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 |
393                ((uint8_t)(lVersion >> 24));
394     if (lVersion == FXBSTR_ID('O', 'T', 'T', 'O') || lVersion == 0x00010000 ||
395         lVersion == FXBSTR_ID('t', 't', 'c', 'f') ||
396         lVersion == FXBSTR_ID('t', 'r', 'u', 'e') || lVersion == 0x00020000) {
397       ret = true;
398     }
399   }
400   DeleteFont(hFont);
401   return ret;
402 }
403 
IsSupportFontFormDiv(const LOGFONTA * plf)404 bool CFX_Win32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf) {
405   HFONT hFont = CreateFontIndirectA(plf);
406   bool ret = false;
407   uint32_t font_size = GetFontData(hFont, 0, nullptr, 0);
408   if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) {
409     uint32_t lVersion = 0;
410     GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t));
411     lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) |
412                ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 |
413                ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 |
414                ((uint8_t)(lVersion >> 24));
415     if (lVersion == FXBSTR_ID('O', 'T', 'T', 'O') || lVersion == 0x00010000 ||
416         lVersion == FXBSTR_ID('t', 't', 'c', 'f') ||
417         lVersion == FXBSTR_ID('t', 'r', 'u', 'e') || lVersion == 0x00020000 ||
418         (lVersion & 0xFFFF0000) == FXBSTR_ID(0x80, 0x01, 0x00, 0x00) ||
419         (lVersion & 0xFFFF0000) == FXBSTR_ID('%', '!', 0, 0)) {
420       ret = true;
421     }
422   }
423   DeleteFont(hFont);
424   return ret;
425 }
426 
AddInstalledFont(const LOGFONTA * plf,uint32_t FontType)427 void CFX_Win32FontInfo::AddInstalledFont(const LOGFONTA* plf,
428                                          uint32_t FontType) {
429   CFX_ByteString name(plf->lfFaceName);
430   if (name[0] == '@')
431     return;
432 
433   if (name == m_LastFamily) {
434     m_pMapper->AddInstalledFont(name, plf->lfCharSet);
435     return;
436   }
437   if (!(FontType & TRUETYPE_FONTTYPE)) {
438     if (!(FontType & DEVICE_FONTTYPE) || !IsSupportFontFormDiv(plf))
439       return;
440   }
441 
442   m_pMapper->AddInstalledFont(name, plf->lfCharSet);
443   m_LastFamily = name;
444 }
445 
EnumFontList(CFX_FontMapper * pMapper)446 bool CFX_Win32FontInfo::EnumFontList(CFX_FontMapper* pMapper) {
447   m_pMapper = pMapper;
448   LOGFONTA lf;
449   FXSYS_memset(&lf, 0, sizeof(LOGFONTA));
450   lf.lfCharSet = FXFONT_DEFAULT_CHARSET;
451   lf.lfFaceName[0] = 0;
452   lf.lfPitchAndFamily = 0;
453   EnumFontFamiliesExA(m_hDC, &lf, (FONTENUMPROCA)FontEnumProc, (uintptr_t) this,
454                       0);
455   return true;
456 }
457 
FindFont(const CFX_ByteString & name)458 CFX_ByteString CFX_Win32FontInfo::FindFont(const CFX_ByteString& name) {
459   if (!m_pMapper)
460     return name;
461 
462   for (size_t i = 0; i < m_pMapper->m_InstalledTTFonts.size(); ++i) {
463     CFX_ByteString thisname = m_pMapper->m_InstalledTTFonts[i];
464     if (thisname.Left(name.GetLength()) == name)
465       return m_pMapper->m_InstalledTTFonts[i];
466   }
467   for (size_t i = 0; i < m_pMapper->m_LocalizedTTFonts.size(); ++i) {
468     CFX_ByteString thisname = m_pMapper->m_LocalizedTTFonts[i].first;
469     if (thisname.Left(name.GetLength()) == name)
470       return m_pMapper->m_LocalizedTTFonts[i].second;
471   }
472   return CFX_ByteString();
473 }
474 
MapFont(int weight,bool bItalic,int charset,int pitch_family,const FX_CHAR * cstr_face,int & iExact)475 void* CFX_Win32FallbackFontInfo::MapFont(int weight,
476                                          bool bItalic,
477                                          int charset,
478                                          int pitch_family,
479                                          const FX_CHAR* cstr_face,
480                                          int& iExact) {
481   void* font = GetSubstFont(cstr_face);
482   if (font) {
483     iExact = 1;
484     return font;
485   }
486   bool bCJK = true;
487   switch (charset) {
488     case FXFONT_SHIFTJIS_CHARSET:
489     case FXFONT_GB2312_CHARSET:
490     case FXFONT_CHINESEBIG5_CHARSET:
491     case FXFONT_HANGUL_CHARSET:
492       break;
493     default:
494       bCJK = false;
495       break;
496   }
497   return FindFont(weight, bItalic, charset, pitch_family, cstr_face, !bCJK);
498 }
499 
GetGBPreference(CFX_ByteString & face,int weight,int picth_family)500 void CFX_Win32FontInfo::GetGBPreference(CFX_ByteString& face,
501                                         int weight,
502                                         int picth_family) {
503   if (face.Find("KaiTi") >= 0 || face.Find("\xbf\xac") >= 0) {
504     if (m_KaiTi.IsEmpty()) {
505       m_KaiTi = FindFont("KaiTi");
506       if (m_KaiTi.IsEmpty()) {
507         m_KaiTi = "SimSun";
508       }
509     }
510     face = m_KaiTi;
511   } else if (face.Find("FangSong") >= 0 || face.Find("\xb7\xc2\xcb\xce") >= 0) {
512     if (m_FangSong.IsEmpty()) {
513       m_FangSong = FindFont("FangSong");
514       if (m_FangSong.IsEmpty()) {
515         m_FangSong = "SimSun";
516       }
517     }
518     face = m_FangSong;
519   } else if (face.Find("SimSun") >= 0 || face.Find("\xcb\xce") >= 0) {
520     face = "SimSun";
521   } else if (face.Find("SimHei") >= 0 || face.Find("\xba\xda") >= 0) {
522     face = "SimHei";
523   } else if (!(picth_family & FF_ROMAN) && weight > 550) {
524     face = "SimHei";
525   } else {
526     face = "SimSun";
527   }
528 }
529 
GetJapanesePreference(CFX_ByteString & face,int weight,int picth_family)530 void CFX_Win32FontInfo::GetJapanesePreference(CFX_ByteString& face,
531                                               int weight,
532                                               int picth_family) {
533   if (face.Find("Gothic") >= 0 ||
534       face.Find("\x83\x53\x83\x56\x83\x62\x83\x4e") >= 0) {
535     if (face.Find("PGothic") >= 0 ||
536         face.Find("\x82\x6f\x83\x53\x83\x56\x83\x62\x83\x4e") >= 0) {
537       face = "MS PGothic";
538     } else if (face.Find("UI Gothic") >= 0) {
539       face = "MS UI Gothic";
540     } else {
541       if (face.Find("HGSGothicM") >= 0 || face.Find("HGMaruGothicMPRO") >= 0) {
542         face = "MS PGothic";
543       } else {
544         face = "MS Gothic";
545       }
546     }
547     return;
548   }
549   if (face.Find("Mincho") >= 0 || face.Find("\x96\xbe\x92\xa9") >= 0) {
550     if (face.Find("PMincho") >= 0 ||
551         face.Find("\x82\x6f\x96\xbe\x92\xa9") >= 0) {
552       face = "MS PMincho";
553     } else {
554       face = "MS Mincho";
555     }
556     return;
557   }
558   if (GetSubFontName(&face))
559     return;
560 
561   if (!(picth_family & FF_ROMAN) && weight > 400) {
562     face = "MS PGothic";
563   } else {
564     face = "MS PMincho";
565   }
566 }
567 
MapFont(int weight,bool bItalic,int charset,int pitch_family,const FX_CHAR * cstr_face,int & iExact)568 void* CFX_Win32FontInfo::MapFont(int weight,
569                                  bool bItalic,
570                                  int charset,
571                                  int pitch_family,
572                                  const FX_CHAR* cstr_face,
573                                  int& iExact) {
574   CFX_ByteString face = cstr_face;
575   int iBaseFont;
576   for (iBaseFont = 0; iBaseFont < 12; iBaseFont++)
577     if (face == CFX_ByteStringC(g_Base14Substs[iBaseFont].m_pName)) {
578       face = g_Base14Substs[iBaseFont].m_pWinName;
579       weight = g_Base14Substs[iBaseFont].m_bBold ? FW_BOLD : FW_NORMAL;
580       bItalic = g_Base14Substs[iBaseFont].m_bItalic;
581       iExact = true;
582       break;
583     }
584   if (charset == FXFONT_ANSI_CHARSET || charset == FXFONT_SYMBOL_CHARSET) {
585     charset = FXFONT_DEFAULT_CHARSET;
586   }
587   int subst_pitch_family = pitch_family;
588   switch (charset) {
589     case FXFONT_SHIFTJIS_CHARSET:
590       subst_pitch_family = FF_ROMAN;
591       break;
592     case FXFONT_CHINESEBIG5_CHARSET:
593     case FXFONT_HANGUL_CHARSET:
594     case FXFONT_GB2312_CHARSET:
595       subst_pitch_family = 0;
596       break;
597   }
598   HFONT hFont =
599       ::CreateFontA(-10, 0, 0, 0, weight, bItalic, 0, 0, charset,
600                     OUT_TT_ONLY_PRECIS, 0, 0, subst_pitch_family, face.c_str());
601   char facebuf[100];
602   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, hFont);
603   ::GetTextFaceA(m_hDC, 100, facebuf);
604   ::SelectObject(m_hDC, hOldFont);
605   if (face.EqualNoCase(facebuf))
606     return hFont;
607 
608   CFX_WideString wsFace = CFX_WideString::FromLocal(facebuf);
609   for (size_t i = 0; i < FX_ArraySize(g_VariantNames); ++i) {
610     if (face != g_VariantNames[i].m_pFaceName)
611       continue;
612 
613     const unsigned short* pName = reinterpret_cast<const unsigned short*>(
614         g_VariantNames[i].m_pVariantName);
615     FX_STRSIZE len = CFX_WideString::WStringLength(pName);
616     CFX_WideString wsName = CFX_WideString::FromUTF16LE(pName, len);
617     if (wsFace == wsName)
618       return hFont;
619   }
620   ::DeleteObject(hFont);
621   if (charset == FXFONT_DEFAULT_CHARSET)
622     return nullptr;
623 
624   switch (charset) {
625     case FXFONT_SHIFTJIS_CHARSET:
626       GetJapanesePreference(face, weight, pitch_family);
627       break;
628     case FXFONT_GB2312_CHARSET:
629       GetGBPreference(face, weight, pitch_family);
630       break;
631     case FXFONT_HANGUL_CHARSET:
632       face = "Gulim";
633       break;
634     case FXFONT_CHINESEBIG5_CHARSET:
635       if (face.Find("MSung") >= 0) {
636         face = "MingLiU";
637       } else {
638         face = "PMingLiU";
639       }
640       break;
641   }
642   hFont =
643       ::CreateFontA(-10, 0, 0, 0, weight, bItalic, 0, 0, charset,
644                     OUT_TT_ONLY_PRECIS, 0, 0, subst_pitch_family, face.c_str());
645   return hFont;
646 }
647 
DeleteFont(void * hFont)648 void CFX_Win32FontInfo::DeleteFont(void* hFont) {
649   ::DeleteObject(hFont);
650 }
651 
GetFontData(void * hFont,uint32_t table,uint8_t * buffer,uint32_t size)652 uint32_t CFX_Win32FontInfo::GetFontData(void* hFont,
653                                         uint32_t table,
654                                         uint8_t* buffer,
655                                         uint32_t size) {
656   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
657   table = FXDWORD_GET_MSBFIRST(reinterpret_cast<uint8_t*>(&table));
658   size = ::GetFontData(m_hDC, table, 0, buffer, size);
659   ::SelectObject(m_hDC, hOldFont);
660   if (size == GDI_ERROR) {
661     return 0;
662   }
663   return size;
664 }
665 
GetFaceName(void * hFont,CFX_ByteString & name)666 bool CFX_Win32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name) {
667   char facebuf[100];
668   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
669   int ret = ::GetTextFaceA(m_hDC, 100, facebuf);
670   ::SelectObject(m_hDC, hOldFont);
671   if (ret == 0) {
672     return false;
673   }
674   name = facebuf;
675   return true;
676 }
677 
GetFontCharset(void * hFont,int & charset)678 bool CFX_Win32FontInfo::GetFontCharset(void* hFont, int& charset) {
679   TEXTMETRIC tm;
680   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
681   ::GetTextMetrics(m_hDC, &tm);
682   ::SelectObject(m_hDC, hOldFont);
683   charset = tm.tmCharSet;
684   return true;
685 }
686 
687 }  // namespace
688 
689 int g_pdfium_print_postscript_level = 0;
690 
CreateDefault(const char ** pUnused)691 std::unique_ptr<IFX_SystemFontInfo> IFX_SystemFontInfo::CreateDefault(
692     const char** pUnused) {
693   if (IsGDIEnabled())
694     return std::unique_ptr<IFX_SystemFontInfo>(new CFX_Win32FontInfo);
695 
696   // Select the fallback font information class if GDI is disabled.
697   CFX_Win32FallbackFontInfo* pInfoFallback = new CFX_Win32FallbackFontInfo;
698   // Construct the font path manually, SHGetKnownFolderPath won't work under
699   // a restrictive sandbox.
700   CHAR windows_path[MAX_PATH] = {};
701   DWORD path_len = ::GetWindowsDirectoryA(windows_path, MAX_PATH);
702   if (path_len > 0 && path_len < MAX_PATH) {
703     CFX_ByteString fonts_path(windows_path);
704     fonts_path += "\\Fonts";
705     pInfoFallback->AddPath(fonts_path.AsStringC());
706   }
707   return std::unique_ptr<IFX_SystemFontInfo>(pInfoFallback);
708 }
709 
InitPlatform()710 void CFX_GEModule::InitPlatform() {
711   CWin32Platform* pPlatformData = new CWin32Platform;
712   OSVERSIONINFO ver;
713   ver.dwOSVersionInfoSize = sizeof(ver);
714   GetVersionEx(&ver);
715   pPlatformData->m_bHalfTone = ver.dwMajorVersion >= 5;
716   if (IsGDIEnabled())
717     pPlatformData->m_GdiplusExt.Load();
718   m_pPlatformData = pPlatformData;
719   m_pFontMgr->SetSystemFontInfo(IFX_SystemFontInfo::CreateDefault(nullptr));
720 }
721 
DestroyPlatform()722 void CFX_GEModule::DestroyPlatform() {
723   delete (CWin32Platform*)m_pPlatformData;
724   m_pPlatformData = nullptr;
725 }
726 
CGdiDeviceDriver(HDC hDC,int device_class)727 CGdiDeviceDriver::CGdiDeviceDriver(HDC hDC, int device_class) {
728   m_hDC = hDC;
729   m_DeviceClass = device_class;
730   CWin32Platform* pPlatform =
731       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
732   SetStretchBltMode(hDC, pPlatform->m_bHalfTone ? HALFTONE : COLORONCOLOR);
733   DWORD obj_type = GetObjectType(m_hDC);
734   m_bMetafileDCType = obj_type == OBJ_ENHMETADC || obj_type == OBJ_ENHMETAFILE;
735   if (obj_type == OBJ_MEMDC) {
736     HBITMAP hBitmap = CreateBitmap(1, 1, 1, 1, nullptr);
737     hBitmap = (HBITMAP)SelectObject(m_hDC, hBitmap);
738     BITMAP bitmap;
739     GetObject(hBitmap, sizeof bitmap, &bitmap);
740     m_nBitsPerPixel = bitmap.bmBitsPixel;
741     m_Width = bitmap.bmWidth;
742     m_Height = abs(bitmap.bmHeight);
743     hBitmap = (HBITMAP)SelectObject(m_hDC, hBitmap);
744     DeleteObject(hBitmap);
745   } else {
746     m_nBitsPerPixel = ::GetDeviceCaps(m_hDC, BITSPIXEL);
747     m_Width = ::GetDeviceCaps(m_hDC, HORZRES);
748     m_Height = ::GetDeviceCaps(m_hDC, VERTRES);
749   }
750   if (m_DeviceClass != FXDC_DISPLAY) {
751     m_RenderCaps = FXRC_BIT_MASK;
752   } else {
753     m_RenderCaps = FXRC_GET_BITS | FXRC_BIT_MASK;
754   }
755 }
756 
~CGdiDeviceDriver()757 CGdiDeviceDriver::~CGdiDeviceDriver() {}
758 
GetDeviceCaps(int caps_id) const759 int CGdiDeviceDriver::GetDeviceCaps(int caps_id) const {
760   switch (caps_id) {
761     case FXDC_DEVICE_CLASS:
762       return m_DeviceClass;
763     case FXDC_PIXEL_WIDTH:
764       return m_Width;
765     case FXDC_PIXEL_HEIGHT:
766       return m_Height;
767     case FXDC_BITS_PIXEL:
768       return m_nBitsPerPixel;
769     case FXDC_RENDER_CAPS:
770       return m_RenderCaps;
771   }
772   return 0;
773 }
774 
SaveState()775 void CGdiDeviceDriver::SaveState() {
776   SaveDC(m_hDC);
777 }
778 
RestoreState(bool bKeepSaved)779 void CGdiDeviceDriver::RestoreState(bool bKeepSaved) {
780   RestoreDC(m_hDC, -1);
781   if (bKeepSaved)
782     SaveDC(m_hDC);
783 }
784 
GDI_SetDIBits(CFX_DIBitmap * pBitmap1,const FX_RECT * pSrcRect,int left,int top)785 bool CGdiDeviceDriver::GDI_SetDIBits(CFX_DIBitmap* pBitmap1,
786                                      const FX_RECT* pSrcRect,
787                                      int left,
788                                      int top) {
789   if (m_DeviceClass == FXDC_PRINTER) {
790     std::unique_ptr<CFX_DIBitmap> pBitmap = pBitmap1->FlipImage(false, true);
791     if (!pBitmap)
792       return false;
793 
794     if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb))
795       return false;
796 
797     int width = pSrcRect->Width(), height = pSrcRect->Height();
798     LPBYTE pBuffer = pBitmap->GetBuffer();
799     CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap.get());
800     ((BITMAPINFOHEADER*)info.c_str())->biHeight *= -1;
801     FX_RECT dst_rect(0, 0, width, height);
802     dst_rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
803     int dst_width = dst_rect.Width();
804     int dst_height = dst_rect.Height();
805     ::StretchDIBits(m_hDC, left, top, dst_width, dst_height, 0, 0, dst_width,
806                     dst_height, pBuffer, (BITMAPINFO*)info.c_str(),
807                     DIB_RGB_COLORS, SRCCOPY);
808   } else {
809     CFX_MaybeOwned<CFX_DIBitmap> pBitmap(pBitmap1);
810     if (pBitmap->IsCmykImage()) {
811       pBitmap = pBitmap->CloneConvert(FXDIB_Rgb).release();
812       if (!pBitmap)
813         return false;
814     }
815     int width = pSrcRect->Width(), height = pSrcRect->Height();
816     LPBYTE pBuffer = pBitmap->GetBuffer();
817     CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap.Get());
818     ::SetDIBitsToDevice(m_hDC, left, top, width, height, pSrcRect->left,
819                         pBitmap->GetHeight() - pSrcRect->bottom, 0,
820                         pBitmap->GetHeight(), pBuffer,
821                         (BITMAPINFO*)info.c_str(), DIB_RGB_COLORS);
822   }
823   return true;
824 }
825 
GDI_StretchDIBits(CFX_DIBitmap * pBitmap1,int dest_left,int dest_top,int dest_width,int dest_height,uint32_t flags)826 bool CGdiDeviceDriver::GDI_StretchDIBits(CFX_DIBitmap* pBitmap1,
827                                          int dest_left,
828                                          int dest_top,
829                                          int dest_width,
830                                          int dest_height,
831                                          uint32_t flags) {
832   CFX_DIBitmap* pBitmap = pBitmap1;
833   if (!pBitmap || dest_width == 0 || dest_height == 0)
834     return false;
835 
836   if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb))
837     return false;
838 
839   CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
840   if ((int64_t)abs(dest_width) * abs(dest_height) <
841           (int64_t)pBitmap1->GetWidth() * pBitmap1->GetHeight() * 4 ||
842       (flags & FXDIB_INTERPOL) || (flags & FXDIB_BICUBIC_INTERPOL)) {
843     SetStretchBltMode(m_hDC, HALFTONE);
844   } else {
845     SetStretchBltMode(m_hDC, COLORONCOLOR);
846   }
847   CFX_MaybeOwned<CFX_DIBitmap> pToStrechBitmap(pBitmap);
848   if (m_DeviceClass == FXDC_PRINTER &&
849       ((int64_t)pBitmap->GetWidth() * pBitmap->GetHeight() >
850        (int64_t)abs(dest_width) * abs(dest_height))) {
851     pToStrechBitmap = pBitmap->StretchTo(dest_width, dest_height);
852   }
853   CFX_ByteString toStrechBitmapInfo =
854       CFX_WindowsDIB::GetBitmapInfo(pToStrechBitmap.Get());
855   ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height, 0, 0,
856                   pToStrechBitmap->GetWidth(), pToStrechBitmap->GetHeight(),
857                   pToStrechBitmap->GetBuffer(),
858                   (BITMAPINFO*)toStrechBitmapInfo.c_str(), DIB_RGB_COLORS,
859                   SRCCOPY);
860   return true;
861 }
862 
GDI_StretchBitMask(CFX_DIBitmap * pBitmap1,int dest_left,int dest_top,int dest_width,int dest_height,uint32_t bitmap_color,uint32_t flags)863 bool CGdiDeviceDriver::GDI_StretchBitMask(CFX_DIBitmap* pBitmap1,
864                                           int dest_left,
865                                           int dest_top,
866                                           int dest_width,
867                                           int dest_height,
868                                           uint32_t bitmap_color,
869                                           uint32_t flags) {
870   CFX_DIBitmap* pBitmap = pBitmap1;
871   if (!pBitmap || dest_width == 0 || dest_height == 0)
872     return false;
873 
874   int width = pBitmap->GetWidth(), height = pBitmap->GetHeight();
875   struct {
876     BITMAPINFOHEADER bmiHeader;
877     uint32_t bmiColors[2];
878   } bmi;
879   FXSYS_memset(&bmi.bmiHeader, 0, sizeof(BITMAPINFOHEADER));
880   bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
881   bmi.bmiHeader.biBitCount = 1;
882   bmi.bmiHeader.biCompression = BI_RGB;
883   bmi.bmiHeader.biHeight = -height;
884   bmi.bmiHeader.biPlanes = 1;
885   bmi.bmiHeader.biWidth = width;
886   if (m_nBitsPerPixel != 1) {
887     SetStretchBltMode(m_hDC, HALFTONE);
888   }
889   bmi.bmiColors[0] = 0xffffff;
890   bmi.bmiColors[1] = 0;
891 
892   HBRUSH hPattern = CreateSolidBrush(bitmap_color & 0xffffff);
893   HBRUSH hOld = (HBRUSH)SelectObject(m_hDC, hPattern);
894 
895   // In PDF, when image mask is 1, use device bitmap; when mask is 0, use brush
896   // bitmap.
897   // A complete list of the boolen operations is as follows:
898 
899   /* P(bitmap_color)    S(ImageMask)    D(DeviceBitmap)    Result
900    *        0                 0                0              0
901    *        0                 0                1              0
902    *        0                 1                0              0
903    *        0                 1                1              1
904    *        1                 0                0              1
905    *        1                 0                1              1
906    *        1                 1                0              0
907    *        1                 1                1              1
908    */
909   // The boolen codes is B8. Based on
910   // http://msdn.microsoft.com/en-us/library/aa932106.aspx, the ROP3 code is
911   // 0xB8074A
912 
913   ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height, 0, 0,
914                   width, height, pBitmap->GetBuffer(), (BITMAPINFO*)&bmi,
915                   DIB_RGB_COLORS, 0xB8074A);
916 
917   SelectObject(m_hDC, hOld);
918   DeleteObject(hPattern);
919 
920   return true;
921 }
922 
GetClipBox(FX_RECT * pRect)923 bool CGdiDeviceDriver::GetClipBox(FX_RECT* pRect) {
924   return !!(::GetClipBox(m_hDC, (RECT*)pRect));
925 }
926 
GetPlatformSurface() const927 void* CGdiDeviceDriver::GetPlatformSurface() const {
928   return (void*)m_hDC;
929 }
930 
DrawLine(FX_FLOAT x1,FX_FLOAT y1,FX_FLOAT x2,FX_FLOAT y2)931 void CGdiDeviceDriver::DrawLine(FX_FLOAT x1,
932                                 FX_FLOAT y1,
933                                 FX_FLOAT x2,
934                                 FX_FLOAT y2) {
935   if (!m_bMetafileDCType) {  // EMF drawing is not bound to the DC.
936     int startOutOfBoundsFlag = (x1 < 0) | ((x1 > m_Width) << 1) |
937                                ((y1 < 0) << 2) | ((y1 > m_Height) << 3);
938     int endOutOfBoundsFlag = (x2 < 0) | ((x2 > m_Width) << 1) |
939                              ((y2 < 0) << 2) | ((y2 > m_Height) << 3);
940     if (startOutOfBoundsFlag & endOutOfBoundsFlag)
941       return;
942 
943     if (startOutOfBoundsFlag || endOutOfBoundsFlag) {
944       FX_FLOAT x[2];
945       FX_FLOAT y[2];
946       int np;
947 #ifdef _SKIA_SUPPORT_
948       // TODO(caryclark) temporary replacement of antigrain in line function
949       // to permit removing antigrain altogether
950       rect_base rect = {0.0f, 0.0f, (FX_FLOAT)(m_Width), (FX_FLOAT)(m_Height)};
951       np = clip_liang_barsky(x1, y1, x2, y2, rect, x, y);
952 #else
953       agg::rect_base<FX_FLOAT> rect(0.0f, 0.0f, (FX_FLOAT)(m_Width),
954                                     (FX_FLOAT)(m_Height));
955       np = agg::clip_liang_barsky<FX_FLOAT>(x1, y1, x2, y2, rect, x, y);
956 #endif
957       if (np == 0)
958         return;
959 
960       if (np == 1) {
961         x2 = x[0];
962         y2 = y[0];
963       } else {
964         ASSERT(np == 2);
965         x1 = x[0];
966         y1 = y[0];
967         x2 = x[1];
968         y2 = y[1];
969       }
970     }
971   }
972 
973   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr);
974   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
975 }
976 
DrawPath(const CFX_PathData * pPathData,const CFX_Matrix * pMatrix,const CFX_GraphStateData * pGraphState,uint32_t fill_color,uint32_t stroke_color,int fill_mode,int blend_type)977 bool CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
978                                 const CFX_Matrix* pMatrix,
979                                 const CFX_GraphStateData* pGraphState,
980                                 uint32_t fill_color,
981                                 uint32_t stroke_color,
982                                 int fill_mode,
983                                 int blend_type) {
984   if (blend_type != FXDIB_BLEND_NORMAL)
985     return false;
986 
987   CWin32Platform* pPlatform =
988       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
989   if (!(pGraphState || stroke_color == 0) &&
990       !pPlatform->m_GdiplusExt.IsAvailable()) {
991     CFX_FloatRect bbox_f = pPathData->GetBoundingBox();
992     if (pMatrix)
993       pMatrix->TransformRect(bbox_f);
994 
995     FX_RECT bbox = bbox_f.GetInnerRect();
996     if (bbox.Width() <= 0) {
997       return DrawCosmeticLine(
998           (FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top), (FX_FLOAT)(bbox.left),
999           (FX_FLOAT)(bbox.bottom + 1), fill_color, FXDIB_BLEND_NORMAL);
1000     }
1001     if (bbox.Height() <= 0) {
1002       return DrawCosmeticLine((FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top),
1003                               (FX_FLOAT)(bbox.right + 1), (FX_FLOAT)(bbox.top),
1004                               fill_color, FXDIB_BLEND_NORMAL);
1005     }
1006   }
1007   int fill_alpha = FXARGB_A(fill_color);
1008   int stroke_alpha = FXARGB_A(stroke_color);
1009   bool bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) ||
1010                     (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
1011   if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha)
1012     return false;
1013 
1014   if (pPlatform->m_GdiplusExt.IsAvailable()) {
1015     if (bDrawAlpha ||
1016         ((m_DeviceClass != FXDC_PRINTER && !(fill_mode & FXFILL_FULLCOVER)) ||
1017          (pGraphState && pGraphState->m_DashCount))) {
1018       if (!((!pMatrix || !pMatrix->WillScale()) && pGraphState &&
1019             pGraphState->m_LineWidth == 1.f &&
1020             (pPathData->GetPoints().size() == 5 ||
1021              pPathData->GetPoints().size() == 4) &&
1022             pPathData->IsRect())) {
1023         if (pPlatform->m_GdiplusExt.DrawPath(m_hDC, pPathData, pMatrix,
1024                                              pGraphState, fill_color,
1025                                              stroke_color, fill_mode)) {
1026           return true;
1027         }
1028       }
1029     }
1030   }
1031   int old_fill_mode = fill_mode;
1032   fill_mode &= 3;
1033   HPEN hPen = nullptr;
1034   HBRUSH hBrush = nullptr;
1035   if (pGraphState && stroke_alpha) {
1036     SetMiterLimit(m_hDC, pGraphState->m_MiterLimit, nullptr);
1037     hPen = CreatePen(pGraphState, pMatrix, stroke_color);
1038     hPen = (HPEN)SelectObject(m_hDC, hPen);
1039   }
1040   if (fill_mode && fill_alpha) {
1041     SetPolyFillMode(m_hDC, fill_mode);
1042     hBrush = CreateBrush(fill_color);
1043     hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
1044   }
1045   if (pPathData->GetPoints().size() == 2 && pGraphState &&
1046       pGraphState->m_DashCount) {
1047     CFX_PointF pos1 = pPathData->GetPoint(0);
1048     CFX_PointF pos2 = pPathData->GetPoint(1);
1049     if (pMatrix) {
1050       pos1 = pMatrix->Transform(pos1);
1051       pos2 = pMatrix->Transform(pos2);
1052     }
1053     DrawLine(pos1.x, pos1.y, pos2.x, pos2.y);
1054   } else {
1055     SetPathToDC(m_hDC, pPathData, pMatrix);
1056     if (pGraphState && stroke_alpha) {
1057       if (fill_mode && fill_alpha) {
1058         if (old_fill_mode & FX_FILL_TEXT_MODE) {
1059           StrokeAndFillPath(m_hDC);
1060         } else {
1061           FillPath(m_hDC);
1062           SetPathToDC(m_hDC, pPathData, pMatrix);
1063           StrokePath(m_hDC);
1064         }
1065       } else {
1066         StrokePath(m_hDC);
1067       }
1068     } else if (fill_mode && fill_alpha) {
1069       FillPath(m_hDC);
1070     }
1071   }
1072   if (hPen) {
1073     hPen = (HPEN)SelectObject(m_hDC, hPen);
1074     DeleteObject(hPen);
1075   }
1076   if (hBrush) {
1077     hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
1078     DeleteObject(hBrush);
1079   }
1080   return true;
1081 }
1082 
FillRectWithBlend(const FX_RECT * pRect,uint32_t fill_color,int blend_type)1083 bool CGdiDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
1084                                          uint32_t fill_color,
1085                                          int blend_type) {
1086   if (blend_type != FXDIB_BLEND_NORMAL)
1087     return false;
1088 
1089   int alpha;
1090   FX_COLORREF rgb;
1091   ArgbDecode(fill_color, alpha, rgb);
1092   if (alpha == 0)
1093     return true;
1094 
1095   if (alpha < 255)
1096     return false;
1097 
1098   HBRUSH hBrush = CreateSolidBrush(rgb);
1099   ::FillRect(m_hDC, (RECT*)pRect, hBrush);
1100   DeleteObject(hBrush);
1101   return true;
1102 }
1103 
SetClip_PathFill(const CFX_PathData * pPathData,const CFX_Matrix * pMatrix,int fill_mode)1104 bool CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
1105                                         const CFX_Matrix* pMatrix,
1106                                         int fill_mode) {
1107   if (pPathData->GetPoints().size() == 5) {
1108     CFX_FloatRect rectf;
1109     if (pPathData->IsRect(pMatrix, &rectf)) {
1110       FX_RECT rect = rectf.GetOuterRect();
1111       IntersectClipRect(m_hDC, rect.left, rect.top, rect.right, rect.bottom);
1112       return true;
1113     }
1114   }
1115   SetPathToDC(m_hDC, pPathData, pMatrix);
1116   SetPolyFillMode(m_hDC, fill_mode & 3);
1117   SelectClipPath(m_hDC, RGN_AND);
1118   return true;
1119 }
1120 
SetClip_PathStroke(const CFX_PathData * pPathData,const CFX_Matrix * pMatrix,const CFX_GraphStateData * pGraphState)1121 bool CGdiDeviceDriver::SetClip_PathStroke(
1122     const CFX_PathData* pPathData,
1123     const CFX_Matrix* pMatrix,
1124     const CFX_GraphStateData* pGraphState) {
1125   HPEN hPen = CreatePen(pGraphState, pMatrix, 0xff000000);
1126   hPen = (HPEN)SelectObject(m_hDC, hPen);
1127   SetPathToDC(m_hDC, pPathData, pMatrix);
1128   WidenPath(m_hDC);
1129   SetPolyFillMode(m_hDC, WINDING);
1130   bool ret = !!SelectClipPath(m_hDC, RGN_AND);
1131   hPen = (HPEN)SelectObject(m_hDC, hPen);
1132   DeleteObject(hPen);
1133   return ret;
1134 }
1135 
DrawCosmeticLine(FX_FLOAT x1,FX_FLOAT y1,FX_FLOAT x2,FX_FLOAT y2,uint32_t color,int blend_type)1136 bool CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
1137                                         FX_FLOAT y1,
1138                                         FX_FLOAT x2,
1139                                         FX_FLOAT y2,
1140                                         uint32_t color,
1141                                         int blend_type) {
1142   if (blend_type != FXDIB_BLEND_NORMAL)
1143     return false;
1144 
1145   int a;
1146   FX_COLORREF rgb;
1147   ArgbDecode(color, a, rgb);
1148   if (a == 0)
1149     return true;
1150 
1151   HPEN hPen = CreatePen(PS_SOLID, 1, rgb);
1152   hPen = (HPEN)SelectObject(m_hDC, hPen);
1153   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr);
1154   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
1155   hPen = (HPEN)SelectObject(m_hDC, hPen);
1156   DeleteObject(hPen);
1157   return true;
1158 }
1159 
CGdiDisplayDriver(HDC hDC)1160 CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC)
1161     : CGdiDeviceDriver(hDC, FXDC_DISPLAY) {
1162   CWin32Platform* pPlatform =
1163       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
1164   if (pPlatform->m_GdiplusExt.IsAvailable()) {
1165     m_RenderCaps |= FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE;
1166   }
1167 }
1168 
~CGdiDisplayDriver()1169 CGdiDisplayDriver::~CGdiDisplayDriver() {}
1170 
GetDIBits(CFX_DIBitmap * pBitmap,int left,int top)1171 bool CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top) {
1172   bool ret = false;
1173   int width = pBitmap->GetWidth();
1174   int height = pBitmap->GetHeight();
1175   HBITMAP hbmp = CreateCompatibleBitmap(m_hDC, width, height);
1176   HDC hDCMemory = CreateCompatibleDC(m_hDC);
1177   HBITMAP holdbmp = (HBITMAP)SelectObject(hDCMemory, hbmp);
1178   BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY);
1179   SelectObject(hDCMemory, holdbmp);
1180   BITMAPINFO bmi;
1181   FXSYS_memset(&bmi, 0, sizeof bmi);
1182   bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;
1183   bmi.bmiHeader.biBitCount = pBitmap->GetBPP();
1184   bmi.bmiHeader.biHeight = -height;
1185   bmi.bmiHeader.biPlanes = 1;
1186   bmi.bmiHeader.biWidth = width;
1187   if (pBitmap->GetBPP() > 8 && !pBitmap->IsCmykImage()) {
1188     ret = ::GetDIBits(hDCMemory, hbmp, 0, height, pBitmap->GetBuffer(), &bmi,
1189                       DIB_RGB_COLORS) == height;
1190   } else {
1191     CFX_DIBitmap bitmap;
1192     if (bitmap.Create(width, height, FXDIB_Rgb)) {
1193       bmi.bmiHeader.biBitCount = 24;
1194       ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap.GetBuffer(), &bmi,
1195                   DIB_RGB_COLORS);
1196       ret = pBitmap->TransferBitmap(0, 0, width, height, &bitmap, 0, 0);
1197     } else {
1198       ret = false;
1199     }
1200   }
1201   if (pBitmap->HasAlpha() && ret)
1202     pBitmap->LoadChannel(FXDIB_Alpha, 0xff);
1203 
1204   DeleteObject(hbmp);
1205   DeleteObject(hDCMemory);
1206   return ret;
1207 }
1208 
SetDIBits(const CFX_DIBSource * pSource,uint32_t color,const FX_RECT * pSrcRect,int left,int top,int blend_type)1209 bool CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource,
1210                                   uint32_t color,
1211                                   const FX_RECT* pSrcRect,
1212                                   int left,
1213                                   int top,
1214                                   int blend_type) {
1215   ASSERT(blend_type == FXDIB_BLEND_NORMAL);
1216   if (pSource->IsAlphaMask()) {
1217     int width = pSource->GetWidth(), height = pSource->GetHeight();
1218     int alpha = FXARGB_A(color);
1219     if (pSource->GetBPP() != 1 || alpha != 255) {
1220       CFX_DIBitmap background;
1221       if (!background.Create(width, height, FXDIB_Rgb32) ||
1222           !GetDIBits(&background, left, top) ||
1223           !background.CompositeMask(0, 0, width, height, pSource, color, 0, 0,
1224                                     FXDIB_BLEND_NORMAL, nullptr, false, 0,
1225                                     nullptr)) {
1226         return false;
1227       }
1228       FX_RECT src_rect(0, 0, width, height);
1229       return SetDIBits(&background, 0, &src_rect, left, top,
1230                        FXDIB_BLEND_NORMAL);
1231     }
1232     FX_RECT clip_rect(left, top, left + pSrcRect->Width(),
1233                       top + pSrcRect->Height());
1234     return StretchDIBits(pSource, color, left - pSrcRect->left,
1235                          top - pSrcRect->top, width, height, &clip_rect, 0,
1236                          FXDIB_BLEND_NORMAL);
1237   }
1238   int width = pSrcRect->Width(), height = pSrcRect->Height();
1239   if (pSource->HasAlpha()) {
1240     CFX_DIBitmap bitmap;
1241     if (!bitmap.Create(width, height, FXDIB_Rgb) ||
1242         !GetDIBits(&bitmap, left, top) ||
1243         !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left,
1244                                 pSrcRect->top, FXDIB_BLEND_NORMAL, nullptr,
1245                                 false, nullptr)) {
1246       return false;
1247     }
1248     FX_RECT src_rect(0, 0, width, height);
1249     return SetDIBits(&bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL);
1250   }
1251   CFX_DIBExtractor temp(pSource);
1252   CFX_DIBitmap* pBitmap = temp.GetBitmap();
1253   if (!pBitmap)
1254     return false;
1255   return GDI_SetDIBits(pBitmap, pSrcRect, left, top);
1256 }
1257 
UseFoxitStretchEngine(const CFX_DIBSource * pSource,uint32_t color,int dest_left,int dest_top,int dest_width,int dest_height,const FX_RECT * pClipRect,int render_flags)1258 bool CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource,
1259                                               uint32_t color,
1260                                               int dest_left,
1261                                               int dest_top,
1262                                               int dest_width,
1263                                               int dest_height,
1264                                               const FX_RECT* pClipRect,
1265                                               int render_flags) {
1266   FX_RECT bitmap_clip = *pClipRect;
1267   if (dest_width < 0)
1268     dest_left += dest_width;
1269 
1270   if (dest_height < 0)
1271     dest_top += dest_height;
1272 
1273   bitmap_clip.Offset(-dest_left, -dest_top);
1274   std::unique_ptr<CFX_DIBitmap> pStretched(
1275       pSource->StretchTo(dest_width, dest_height, render_flags, &bitmap_clip));
1276   if (!pStretched)
1277     return true;
1278 
1279   FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight());
1280   return SetDIBits(pStretched.get(), color, &src_rect, pClipRect->left,
1281                    pClipRect->top, FXDIB_BLEND_NORMAL);
1282 }
1283 
StretchDIBits(const CFX_DIBSource * pSource,uint32_t color,int dest_left,int dest_top,int dest_width,int dest_height,const FX_RECT * pClipRect,uint32_t flags,int blend_type)1284 bool CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource,
1285                                       uint32_t color,
1286                                       int dest_left,
1287                                       int dest_top,
1288                                       int dest_width,
1289                                       int dest_height,
1290                                       const FX_RECT* pClipRect,
1291                                       uint32_t flags,
1292                                       int blend_type) {
1293   ASSERT(pSource && pClipRect);
1294   if (flags || dest_width > 10000 || dest_width < -10000 ||
1295       dest_height > 10000 || dest_height < -10000) {
1296     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
1297                                  dest_width, dest_height, pClipRect, flags);
1298   }
1299   if (pSource->IsAlphaMask()) {
1300     FX_RECT image_rect;
1301     image_rect.left = dest_width > 0 ? dest_left : dest_left + dest_width;
1302     image_rect.right = dest_width > 0 ? dest_left + dest_width : dest_left;
1303     image_rect.top = dest_height > 0 ? dest_top : dest_top + dest_height;
1304     image_rect.bottom = dest_height > 0 ? dest_top + dest_height : dest_top;
1305     FX_RECT clip_rect = image_rect;
1306     clip_rect.Intersect(*pClipRect);
1307     clip_rect.Offset(-image_rect.left, -image_rect.top);
1308     int clip_width = clip_rect.Width(), clip_height = clip_rect.Height();
1309     std::unique_ptr<CFX_DIBitmap> pStretched(
1310         pSource->StretchTo(dest_width, dest_height, flags, &clip_rect));
1311     if (!pStretched)
1312       return true;
1313 
1314     CFX_DIBitmap background;
1315     if (!background.Create(clip_width, clip_height, FXDIB_Rgb32) ||
1316         !GetDIBits(&background, image_rect.left + clip_rect.left,
1317                    image_rect.top + clip_rect.top) ||
1318         !background.CompositeMask(
1319             0, 0, clip_width, clip_height, pStretched.get(), color, 0, 0,
1320             FXDIB_BLEND_NORMAL, nullptr, false, 0, nullptr)) {
1321       return false;
1322     }
1323 
1324     FX_RECT src_rect(0, 0, clip_width, clip_height);
1325     return SetDIBits(&background, 0, &src_rect,
1326                      image_rect.left + clip_rect.left,
1327                      image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL);
1328   }
1329   if (pSource->HasAlpha()) {
1330     CWin32Platform* pPlatform =
1331         (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
1332     if (pPlatform->m_GdiplusExt.IsAvailable() && !pSource->IsCmykImage()) {
1333       CFX_DIBExtractor temp(pSource);
1334       CFX_DIBitmap* pBitmap = temp.GetBitmap();
1335       if (!pBitmap)
1336         return false;
1337       return pPlatform->m_GdiplusExt.StretchDIBits(
1338           m_hDC, pBitmap, dest_left, dest_top, dest_width, dest_height,
1339           pClipRect, flags);
1340     }
1341     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
1342                                  dest_width, dest_height, pClipRect, flags);
1343   }
1344   CFX_DIBExtractor temp(pSource);
1345   CFX_DIBitmap* pBitmap = temp.GetBitmap();
1346   if (!pBitmap)
1347     return false;
1348   return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width,
1349                            dest_height, flags);
1350 }
1351 
StartDIBits(const CFX_DIBSource * pBitmap,int bitmap_alpha,uint32_t color,const CFX_Matrix * pMatrix,uint32_t render_flags,void * & handle,int blend_type)1352 bool CGdiDisplayDriver::StartDIBits(const CFX_DIBSource* pBitmap,
1353                                     int bitmap_alpha,
1354                                     uint32_t color,
1355                                     const CFX_Matrix* pMatrix,
1356                                     uint32_t render_flags,
1357                                     void*& handle,
1358                                     int blend_type) {
1359   return false;
1360 }
1361 
CFX_WindowsDevice(HDC hDC)1362 CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC) {
1363   SetDeviceDriver(pdfium::WrapUnique(CreateDriver(hDC)));
1364 }
1365 
~CFX_WindowsDevice()1366 CFX_WindowsDevice::~CFX_WindowsDevice() {}
1367 
GetDC() const1368 HDC CFX_WindowsDevice::GetDC() const {
1369   IFX_RenderDeviceDriver* pRDD = GetDeviceDriver();
1370   return pRDD ? reinterpret_cast<HDC>(pRDD->GetPlatformSurface()) : nullptr;
1371 }
1372 
1373 // static
CreateDriver(HDC hDC)1374 IFX_RenderDeviceDriver* CFX_WindowsDevice::CreateDriver(HDC hDC) {
1375   int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY);
1376   int obj_type = ::GetObjectType(hDC);
1377   bool use_printer = device_type == DT_RASPRINTER ||
1378                      device_type == DT_PLOTTER || obj_type == OBJ_ENHMETADC;
1379 
1380   if (!use_printer)
1381     return new CGdiDisplayDriver(hDC);
1382 
1383   if (g_pdfium_print_postscript_level == 2 ||
1384       g_pdfium_print_postscript_level == 3) {
1385     return new CPSPrinterDriver(hDC, g_pdfium_print_postscript_level, false);
1386   }
1387   return new CGdiPrinterDriver(hDC);
1388 }
1389