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