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