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