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