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