| // Copyright 2014 PDFium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | |
| #include <crtdbg.h> | |
| #include <algorithm> | |
| #include <memory> | |
| #include <vector> | |
| #include "core/fxcrt/fx_codepage.h" | |
| #include "core/fxcrt/fx_memory.h" | |
| #include "core/fxcrt/fx_system.h" | |
| #include "core/fxcrt/maybe_owned.h" | |
| #include "core/fxge/cfx_folderfontinfo.h" | |
| #include "core/fxge/cfx_gemodule.h" | |
| #include "core/fxge/cfx_windowsrenderdevice.h" | |
| #include "core/fxge/dib/cfx_dibextractor.h" | |
| #include "core/fxge/dib/cfx_imagerenderer.h" | |
| #include "core/fxge/dib/cstretchengine.h" | |
| #include "core/fxge/fx_font.h" | |
| #include "core/fxge/fx_freetype.h" | |
| #include "core/fxge/ifx_systemfontinfo.h" | |
| #include "core/fxge/win32/cfx_windowsdib.h" | |
| #include "core/fxge/win32/dwrite_int.h" | |
| #include "core/fxge/win32/win32_int.h" | |
| #include "third_party/base/ptr_util.h" | |
| #include "third_party/base/stl_util.h" | |
| #ifndef _SKIA_SUPPORT_ | |
| #include "core/fxge/agg/fx_agg_driver.h" | |
| #endif | |
| namespace { | |
| const struct { | |
| const char* m_pFaceName; | |
| const char* m_pVariantName; | |
| } g_VariantNames[] = { | |
| {"DFKai-SB", "\x19\x6A\x77\x69\xD4\x9A"}, | |
| }; | |
| const struct { | |
| const char* m_pName; | |
| const char* m_pWinName; | |
| bool m_bBold; | |
| bool m_bItalic; | |
| } g_Base14Substs[] = { | |
| {"Courier", "Courier New", false, false}, | |
| {"Courier-Bold", "Courier New", true, false}, | |
| {"Courier-BoldOblique", "Courier New", true, true}, | |
| {"Courier-Oblique", "Courier New", false, true}, | |
| {"Helvetica", "Arial", false, false}, | |
| {"Helvetica-Bold", "Arial", true, false}, | |
| {"Helvetica-BoldOblique", "Arial", true, true}, | |
| {"Helvetica-Oblique", "Arial", false, true}, | |
| {"Times-Roman", "Times New Roman", false, false}, | |
| {"Times-Bold", "Times New Roman", true, false}, | |
| {"Times-BoldItalic", "Times New Roman", true, true}, | |
| {"Times-Italic", "Times New Roman", false, true}, | |
| }; | |
| struct FontNameMap { | |
| const char* m_pSubFontName; | |
| const char* m_pSrcFontName; | |
| }; | |
| const FontNameMap g_JpFontNameMap[] = { | |
| {"MS Mincho", "Heiseimin-W3"}, | |
| {"MS Gothic", "Jun101-Light"}, | |
| }; | |
| bool GetSubFontName(ByteString* name) { | |
| for (size_t i = 0; i < FX_ArraySize(g_JpFontNameMap); ++i) { | |
| if (!FXSYS_stricmp(name->c_str(), g_JpFontNameMap[i].m_pSrcFontName)) { | |
| *name = g_JpFontNameMap[i].m_pSubFontName; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool IsGDIEnabled() { | |
| // If GDI is disabled then GetDC for the desktop will fail. | |
| HDC hdc = ::GetDC(nullptr); | |
| if (!hdc) | |
| return false; | |
| ::ReleaseDC(nullptr, hdc); | |
| return true; | |
| } | |
| HPEN CreatePen(const CFX_GraphStateData* pGraphState, | |
| const CFX_Matrix* pMatrix, | |
| uint32_t argb) { | |
| float width; | |
| float scale = 1.f; | |
| if (pMatrix) | |
| scale = fabs(pMatrix->a) > fabs(pMatrix->b) ? fabs(pMatrix->a) | |
| : fabs(pMatrix->b); | |
| if (pGraphState) { | |
| width = scale * pGraphState->m_LineWidth; | |
| } else { | |
| width = 1.0f; | |
| } | |
| uint32_t PenStyle = PS_GEOMETRIC; | |
| if (width < 1) { | |
| width = 1; | |
| } | |
| if (pGraphState->m_DashCount) { | |
| PenStyle |= PS_USERSTYLE; | |
| } else { | |
| PenStyle |= PS_SOLID; | |
| } | |
| switch (pGraphState->m_LineCap) { | |
| case 0: | |
| PenStyle |= PS_ENDCAP_FLAT; | |
| break; | |
| case 1: | |
| PenStyle |= PS_ENDCAP_ROUND; | |
| break; | |
| case 2: | |
| PenStyle |= PS_ENDCAP_SQUARE; | |
| break; | |
| } | |
| switch (pGraphState->m_LineJoin) { | |
| case 0: | |
| PenStyle |= PS_JOIN_MITER; | |
| break; | |
| case 1: | |
| PenStyle |= PS_JOIN_ROUND; | |
| break; | |
| case 2: | |
| PenStyle |= PS_JOIN_BEVEL; | |
| break; | |
| } | |
| int a; | |
| FX_COLORREF rgb; | |
| std::tie(a, rgb) = ArgbToColorRef(argb); | |
| LOGBRUSH lb; | |
| lb.lbColor = rgb; | |
| lb.lbStyle = BS_SOLID; | |
| lb.lbHatch = 0; | |
| std::vector<uint32_t> dashes; | |
| if (pGraphState->m_DashCount) { | |
| dashes.resize(pGraphState->m_DashCount); | |
| for (int i = 0; i < pGraphState->m_DashCount; i++) { | |
| dashes[i] = FXSYS_round( | |
| pMatrix ? pMatrix->TransformDistance(pGraphState->m_DashArray[i]) | |
| : pGraphState->m_DashArray[i]); | |
| dashes[i] = std::max(dashes[i], 1U); | |
| } | |
| } | |
| return ExtCreatePen(PenStyle, (DWORD)ceil(width), &lb, | |
| pGraphState->m_DashCount, | |
| reinterpret_cast<const DWORD*>(dashes.data())); | |
| } | |
| HBRUSH CreateBrush(uint32_t argb) { | |
| int a; | |
| FX_COLORREF rgb; | |
| std::tie(a, rgb) = ArgbToColorRef(argb); | |
| return CreateSolidBrush(rgb); | |
| } | |
| void SetPathToDC(HDC hDC, | |
| const CFX_PathData* pPathData, | |
| const CFX_Matrix* pMatrix) { | |
| BeginPath(hDC); | |
| const std::vector<FX_PATHPOINT>& pPoints = pPathData->GetPoints(); | |
| for (size_t i = 0; i < pPoints.size(); i++) { | |
| CFX_PointF pos = pPoints[i].m_Point; | |
| if (pMatrix) | |
| pos = pMatrix->Transform(pos); | |
| CFX_Point screen(FXSYS_round(pos.x), FXSYS_round(pos.y)); | |
| FXPT_TYPE point_type = pPoints[i].m_Type; | |
| if (point_type == FXPT_TYPE::MoveTo) { | |
| MoveToEx(hDC, screen.x, screen.y, nullptr); | |
| } else if (point_type == FXPT_TYPE::LineTo) { | |
| if (pPoints[i].m_Point == pPoints[i - 1].m_Point) | |
| screen.x++; | |
| LineTo(hDC, screen.x, screen.y); | |
| } else if (point_type == FXPT_TYPE::BezierTo) { | |
| POINT lppt[3]; | |
| lppt[0].x = screen.x; | |
| lppt[0].y = screen.y; | |
| pos = pPoints[i + 1].m_Point; | |
| if (pMatrix) | |
| pos = pMatrix->Transform(pos); | |
| lppt[1].x = FXSYS_round(pos.x); | |
| lppt[1].y = FXSYS_round(pos.y); | |
| pos = pPoints[i + 2].m_Point; | |
| if (pMatrix) | |
| pos = pMatrix->Transform(pos); | |
| lppt[2].x = FXSYS_round(pos.x); | |
| lppt[2].y = FXSYS_round(pos.y); | |
| PolyBezierTo(hDC, lppt, 3); | |
| i += 2; | |
| } | |
| if (pPoints[i].m_CloseFigure) | |
| CloseFigure(hDC); | |
| } | |
| EndPath(hDC); | |
| } | |
| #ifdef _SKIA_SUPPORT_ | |
| // TODO(caryclark) This antigrain function is duplicated here to permit | |
| // removing the last remaining dependency. Eventually, this will be elminiated | |
| // altogether and replace by Skia code. | |
| struct rect_base { | |
| float x1; | |
| float y1; | |
| float x2; | |
| float y2; | |
| }; | |
| unsigned clip_liang_barsky(float x1, | |
| float y1, | |
| float x2, | |
| float y2, | |
| const rect_base& clip_box, | |
| float* x, | |
| float* y) { | |
| const float nearzero = 1e-30f; | |
| float deltax = x2 - x1; | |
| float deltay = y2 - y1; | |
| unsigned np = 0; | |
| if (deltax == 0) | |
| deltax = (x1 > clip_box.x1) ? -nearzero : nearzero; | |
| float xin, xout; | |
| if (deltax > 0) { | |
| xin = clip_box.x1; | |
| xout = clip_box.x2; | |
| } else { | |
| xin = clip_box.x2; | |
| xout = clip_box.x1; | |
| } | |
| float tinx = (xin - x1) / deltax; | |
| if (deltay == 0) | |
| deltay = (y1 > clip_box.y1) ? -nearzero : nearzero; | |
| float yin, yout; | |
| if (deltay > 0) { | |
| yin = clip_box.y1; | |
| yout = clip_box.y2; | |
| } else { | |
| yin = clip_box.y2; | |
| yout = clip_box.y1; | |
| } | |
| float tiny = (yin - y1) / deltay; | |
| float tin1, tin2; | |
| if (tinx < tiny) { | |
| tin1 = tinx; | |
| tin2 = tiny; | |
| } else { | |
| tin1 = tiny; | |
| tin2 = tinx; | |
| } | |
| if (tin1 <= 1.0f) { | |
| if (0 < tin1) { | |
| *x++ = xin; | |
| *y++ = yin; | |
| ++np; | |
| } | |
| if (tin2 <= 1.0f) { | |
| float toutx = (xout - x1) / deltax; | |
| float touty = (yout - y1) / deltay; | |
| float tout1 = (toutx < touty) ? toutx : touty; | |
| if (tin2 > 0 || tout1 > 0) { | |
| if (tin2 <= tout1) { | |
| if (tin2 > 0) { | |
| if (tinx > tiny) { | |
| *x++ = xin; | |
| *y++ = y1 + (deltay * tinx); | |
| } else { | |
| *x++ = x1 + (deltax * tiny); | |
| *y++ = yin; | |
| } | |
| ++np; | |
| } | |
| if (tout1 < 1.0f) { | |
| if (toutx < touty) { | |
| *x++ = xout; | |
| *y++ = y1 + (deltay * toutx); | |
| } else { | |
| *x++ = x1 + (deltax * touty); | |
| *y++ = yout; | |
| } | |
| } else { | |
| *x++ = x2; | |
| *y++ = y2; | |
| } | |
| ++np; | |
| } else { | |
| if (tinx > tiny) { | |
| *x++ = xin; | |
| *y++ = yout; | |
| } else { | |
| *x++ = xout; | |
| *y++ = yin; | |
| } | |
| ++np; | |
| } | |
| } | |
| } | |
| } | |
| return np; | |
| } | |
| #endif // _SKIA_SUPPORT_ | |
| class CFX_Win32FallbackFontInfo final : public CFX_FolderFontInfo { | |
| public: | |
| CFX_Win32FallbackFontInfo() {} | |
| ~CFX_Win32FallbackFontInfo() override {} | |
| // CFX_FolderFontInfo: | |
| void* MapFont(int weight, | |
| bool bItalic, | |
| int charset, | |
| int pitch_family, | |
| const char* family) override; | |
| }; | |
| class CFX_Win32FontInfo final : public IFX_SystemFontInfo { | |
| public: | |
| CFX_Win32FontInfo(); | |
| ~CFX_Win32FontInfo() override; | |
| // IFX_SystemFontInfo | |
| bool EnumFontList(CFX_FontMapper* pMapper) override; | |
| void* MapFont(int weight, | |
| bool bItalic, | |
| int charset, | |
| int pitch_family, | |
| const char* face) override; | |
| void* GetFont(const char* face) override { return nullptr; } | |
| uint32_t GetFontData(void* hFont, | |
| uint32_t table, | |
| uint8_t* buffer, | |
| uint32_t size) override; | |
| bool GetFaceName(void* hFont, ByteString* name) override; | |
| bool GetFontCharset(void* hFont, int* charset) override; | |
| void DeleteFont(void* hFont) override; | |
| bool IsOpenTypeFromDiv(const LOGFONTA* plf); | |
| bool IsSupportFontFormDiv(const LOGFONTA* plf); | |
| void AddInstalledFont(const LOGFONTA* plf, uint32_t FontType); | |
| void GetGBPreference(ByteString& face, int weight, int picth_family); | |
| void GetJapanesePreference(ByteString& face, int weight, int picth_family); | |
| ByteString FindFont(const ByteString& name); | |
| HDC m_hDC; | |
| UnownedPtr<CFX_FontMapper> m_pMapper; | |
| ByteString m_LastFamily; | |
| ByteString m_KaiTi, m_FangSong; | |
| }; | |
| int CALLBACK FontEnumProc(const LOGFONTA* plf, | |
| const TEXTMETRICA* lpntme, | |
| uint32_t FontType, | |
| LPARAM lParam) { | |
| CFX_Win32FontInfo* pFontInfo = reinterpret_cast<CFX_Win32FontInfo*>(lParam); | |
| pFontInfo->AddInstalledFont(plf, FontType); | |
| return 1; | |
| } | |
| CFX_Win32FontInfo::CFX_Win32FontInfo() : m_hDC(CreateCompatibleDC(nullptr)) {} | |
| CFX_Win32FontInfo::~CFX_Win32FontInfo() { | |
| DeleteDC(m_hDC); | |
| } | |
| bool CFX_Win32FontInfo::IsOpenTypeFromDiv(const LOGFONTA* plf) { | |
| HFONT hFont = CreateFontIndirectA(plf); | |
| bool ret = false; | |
| uint32_t font_size = GetFontData(hFont, 0, nullptr, 0); | |
| if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) { | |
| uint32_t lVersion = 0; | |
| GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t)); | |
| lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) | | |
| ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 | | |
| ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 | | |
| ((uint8_t)(lVersion >> 24)); | |
| if (lVersion == FXBSTR_ID('O', 'T', 'T', 'O') || lVersion == 0x00010000 || | |
| lVersion == FXBSTR_ID('t', 't', 'c', 'f') || | |
| lVersion == FXBSTR_ID('t', 'r', 'u', 'e') || lVersion == 0x00020000) { | |
| ret = true; | |
| } | |
| } | |
| DeleteFont(hFont); | |
| return ret; | |
| } | |
| bool CFX_Win32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf) { | |
| HFONT hFont = CreateFontIndirectA(plf); | |
| bool ret = false; | |
| uint32_t font_size = GetFontData(hFont, 0, nullptr, 0); | |
| if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) { | |
| uint32_t lVersion = 0; | |
| GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t)); | |
| lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) | | |
| ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 | | |
| ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 | | |
| ((uint8_t)(lVersion >> 24)); | |
| if (lVersion == FXBSTR_ID('O', 'T', 'T', 'O') || lVersion == 0x00010000 || | |
| lVersion == FXBSTR_ID('t', 't', 'c', 'f') || | |
| lVersion == FXBSTR_ID('t', 'r', 'u', 'e') || lVersion == 0x00020000 || | |
| (lVersion & 0xFFFF0000) == FXBSTR_ID(0x80, 0x01, 0x00, 0x00) || | |
| (lVersion & 0xFFFF0000) == FXBSTR_ID('%', '!', 0, 0)) { | |
| ret = true; | |
| } | |
| } | |
| DeleteFont(hFont); | |
| return ret; | |
| } | |
| void CFX_Win32FontInfo::AddInstalledFont(const LOGFONTA* plf, | |
| uint32_t FontType) { | |
| ByteString name(plf->lfFaceName); | |
| if (name.GetLength() > 0 && name[0] == '@') | |
| return; | |
| if (name == m_LastFamily) { | |
| m_pMapper->AddInstalledFont(name, plf->lfCharSet); | |
| return; | |
| } | |
| if (!(FontType & TRUETYPE_FONTTYPE)) { | |
| if (!(FontType & DEVICE_FONTTYPE) || !IsSupportFontFormDiv(plf)) | |
| return; | |
| } | |
| m_pMapper->AddInstalledFont(name, plf->lfCharSet); | |
| m_LastFamily = name; | |
| } | |
| bool CFX_Win32FontInfo::EnumFontList(CFX_FontMapper* pMapper) { | |
| m_pMapper = pMapper; | |
| LOGFONTA lf; | |
| memset(&lf, 0, sizeof(LOGFONTA)); | |
| lf.lfCharSet = FX_CHARSET_Default; | |
| lf.lfFaceName[0] = 0; | |
| lf.lfPitchAndFamily = 0; | |
| EnumFontFamiliesExA(m_hDC, &lf, (FONTENUMPROCA)FontEnumProc, (uintptr_t) this, | |
| 0); | |
| return true; | |
| } | |
| ByteString CFX_Win32FontInfo::FindFont(const ByteString& name) { | |
| if (!m_pMapper) | |
| return name; | |
| for (size_t i = 0; i < m_pMapper->m_InstalledTTFonts.size(); ++i) { | |
| ByteString thisname = m_pMapper->m_InstalledTTFonts[i]; | |
| if (thisname.Left(name.GetLength()) == name) | |
| return m_pMapper->m_InstalledTTFonts[i]; | |
| } | |
| for (size_t i = 0; i < m_pMapper->m_LocalizedTTFonts.size(); ++i) { | |
| ByteString thisname = m_pMapper->m_LocalizedTTFonts[i].first; | |
| if (thisname.Left(name.GetLength()) == name) | |
| return m_pMapper->m_LocalizedTTFonts[i].second; | |
| } | |
| return ByteString(); | |
| } | |
| void* CFX_Win32FallbackFontInfo::MapFont(int weight, | |
| bool bItalic, | |
| int charset, | |
| int pitch_family, | |
| const char* cstr_face) { | |
| void* font = GetSubstFont(cstr_face); | |
| if (font) | |
| return font; | |
| bool bCJK = true; | |
| switch (charset) { | |
| case FX_CHARSET_ShiftJIS: | |
| case FX_CHARSET_ChineseSimplified: | |
| case FX_CHARSET_ChineseTraditional: | |
| case FX_CHARSET_Hangul: | |
| break; | |
| default: | |
| bCJK = false; | |
| break; | |
| } | |
| return FindFont(weight, bItalic, charset, pitch_family, cstr_face, !bCJK); | |
| } | |
| void CFX_Win32FontInfo::GetGBPreference(ByteString& face, | |
| int weight, | |
| int picth_family) { | |
| if (face.Contains("KaiTi") || face.Contains("\xbf\xac")) { | |
| if (m_KaiTi.IsEmpty()) { | |
| m_KaiTi = FindFont("KaiTi"); | |
| if (m_KaiTi.IsEmpty()) { | |
| m_KaiTi = "SimSun"; | |
| } | |
| } | |
| face = m_KaiTi; | |
| } else if (face.Contains("FangSong") || face.Contains("\xb7\xc2\xcb\xce")) { | |
| if (m_FangSong.IsEmpty()) { | |
| m_FangSong = FindFont("FangSong"); | |
| if (m_FangSong.IsEmpty()) { | |
| m_FangSong = "SimSun"; | |
| } | |
| } | |
| face = m_FangSong; | |
| } else if (face.Contains("SimSun") || face.Contains("\xcb\xce")) { | |
| face = "SimSun"; | |
| } else if (face.Contains("SimHei") || face.Contains("\xba\xda")) { | |
| face = "SimHei"; | |
| } else if (!(picth_family & FF_ROMAN) && weight > 550) { | |
| face = "SimHei"; | |
| } else { | |
| face = "SimSun"; | |
| } | |
| } | |
| void CFX_Win32FontInfo::GetJapanesePreference(ByteString& face, | |
| int weight, | |
| int picth_family) { | |
| if (face.Contains("Gothic") || | |
| face.Contains("\x83\x53\x83\x56\x83\x62\x83\x4e")) { | |
| if (face.Contains("PGothic") || | |
| face.Contains("\x82\x6f\x83\x53\x83\x56\x83\x62\x83\x4e")) { | |
| face = "MS PGothic"; | |
| } else if (face.Contains("UI Gothic")) { | |
| face = "MS UI Gothic"; | |
| } else { | |
| if (face.Contains("HGSGothicM") || face.Contains("HGMaruGothicMPRO")) { | |
| face = "MS PGothic"; | |
| } else { | |
| face = "MS Gothic"; | |
| } | |
| } | |
| return; | |
| } | |
| if (face.Contains("Mincho") || face.Contains("\x96\xbe\x92\xa9")) { | |
| if (face.Contains("PMincho") || face.Contains("\x82\x6f\x96\xbe\x92\xa9")) { | |
| face = "MS PMincho"; | |
| } else { | |
| face = "MS Mincho"; | |
| } | |
| return; | |
| } | |
| if (GetSubFontName(&face)) | |
| return; | |
| if (!(picth_family & FF_ROMAN) && weight > 400) { | |
| face = "MS PGothic"; | |
| } else { | |
| face = "MS PMincho"; | |
| } | |
| } | |
| void* CFX_Win32FontInfo::MapFont(int weight, | |
| bool bItalic, | |
| int charset, | |
| int pitch_family, | |
| const char* cstr_face) { | |
| ByteString face = cstr_face; | |
| int iBaseFont; | |
| for (iBaseFont = 0; iBaseFont < 12; iBaseFont++) { | |
| if (face == ByteStringView(g_Base14Substs[iBaseFont].m_pName)) { | |
| face = g_Base14Substs[iBaseFont].m_pWinName; | |
| weight = g_Base14Substs[iBaseFont].m_bBold ? FW_BOLD : FW_NORMAL; | |
| bItalic = g_Base14Substs[iBaseFont].m_bItalic; | |
| break; | |
| } | |
| } | |
| if (charset == FX_CHARSET_ANSI || charset == FX_CHARSET_Symbol) | |
| charset = FX_CHARSET_Default; | |
| int subst_pitch_family = pitch_family; | |
| switch (charset) { | |
| case FX_CHARSET_ShiftJIS: | |
| subst_pitch_family = FF_ROMAN; | |
| break; | |
| case FX_CHARSET_ChineseTraditional: | |
| case FX_CHARSET_Hangul: | |
| case FX_CHARSET_ChineseSimplified: | |
| subst_pitch_family = 0; | |
| break; | |
| } | |
| HFONT hFont = | |
| ::CreateFontA(-10, 0, 0, 0, weight, bItalic, 0, 0, charset, | |
| OUT_TT_ONLY_PRECIS, 0, 0, subst_pitch_family, face.c_str()); | |
| char facebuf[100]; | |
| HFONT hOldFont = (HFONT)::SelectObject(m_hDC, hFont); | |
| ::GetTextFaceA(m_hDC, 100, facebuf); | |
| ::SelectObject(m_hDC, hOldFont); | |
| if (face.EqualNoCase(facebuf)) | |
| return hFont; | |
| WideString wsFace = WideString::FromLocal(facebuf); | |
| for (size_t i = 0; i < FX_ArraySize(g_VariantNames); ++i) { | |
| if (face != g_VariantNames[i].m_pFaceName) | |
| continue; | |
| const unsigned short* pName = reinterpret_cast<const unsigned short*>( | |
| g_VariantNames[i].m_pVariantName); | |
| size_t len = WideString::WStringLength(pName); | |
| WideString wsName = WideString::FromUTF16LE(pName, len); | |
| if (wsFace == wsName) | |
| return hFont; | |
| } | |
| ::DeleteObject(hFont); | |
| if (charset == FX_CHARSET_Default) | |
| return nullptr; | |
| switch (charset) { | |
| case FX_CHARSET_ShiftJIS: | |
| GetJapanesePreference(face, weight, pitch_family); | |
| break; | |
| case FX_CHARSET_ChineseSimplified: | |
| GetGBPreference(face, weight, pitch_family); | |
| break; | |
| case FX_CHARSET_Hangul: | |
| face = "Gulim"; | |
| break; | |
| case FX_CHARSET_ChineseTraditional: | |
| if (face.Contains("MSung")) { | |
| face = "MingLiU"; | |
| } else { | |
| face = "PMingLiU"; | |
| } | |
| break; | |
| } | |
| hFont = | |
| ::CreateFontA(-10, 0, 0, 0, weight, bItalic, 0, 0, charset, | |
| OUT_TT_ONLY_PRECIS, 0, 0, subst_pitch_family, face.c_str()); | |
| return hFont; | |
| } | |
| void CFX_Win32FontInfo::DeleteFont(void* hFont) { | |
| ::DeleteObject(hFont); | |
| } | |
| uint32_t CFX_Win32FontInfo::GetFontData(void* hFont, | |
| uint32_t table, | |
| uint8_t* buffer, | |
| uint32_t size) { | |
| HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont); | |
| table = FXDWORD_GET_MSBFIRST(reinterpret_cast<uint8_t*>(&table)); | |
| size = ::GetFontData(m_hDC, table, 0, buffer, size); | |
| ::SelectObject(m_hDC, hOldFont); | |
| if (size == GDI_ERROR) { | |
| return 0; | |
| } | |
| return size; | |
| } | |
| bool CFX_Win32FontInfo::GetFaceName(void* hFont, ByteString* name) { | |
| char facebuf[100]; | |
| HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont); | |
| int ret = ::GetTextFaceA(m_hDC, 100, facebuf); | |
| ::SelectObject(m_hDC, hOldFont); | |
| if (ret == 0) { | |
| return false; | |
| } | |
| *name = facebuf; | |
| return true; | |
| } | |
| bool CFX_Win32FontInfo::GetFontCharset(void* hFont, int* charset) { | |
| TEXTMETRIC tm; | |
| HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont); | |
| ::GetTextMetrics(m_hDC, &tm); | |
| ::SelectObject(m_hDC, hOldFont); | |
| *charset = tm.tmCharSet; | |
| return true; | |
| } | |
| } // namespace | |
| int g_pdfium_print_mode = WindowsPrintMode::kModeEmf; | |
| std::unique_ptr<IFX_SystemFontInfo> IFX_SystemFontInfo::CreateDefault( | |
| const char** pUnused) { | |
| if (IsGDIEnabled()) | |
| return std::unique_ptr<IFX_SystemFontInfo>(new CFX_Win32FontInfo); | |
| // Select the fallback font information class if GDI is disabled. | |
| CFX_Win32FallbackFontInfo* pInfoFallback = new CFX_Win32FallbackFontInfo; | |
| // Construct the font path manually, SHGetKnownFolderPath won't work under | |
| // a restrictive sandbox. | |
| CHAR windows_path[MAX_PATH] = {}; | |
| DWORD path_len = ::GetWindowsDirectoryA(windows_path, MAX_PATH); | |
| if (path_len > 0 && path_len < MAX_PATH) { | |
| ByteString fonts_path(windows_path); | |
| fonts_path += "\\Fonts"; | |
| pInfoFallback->AddPath(fonts_path); | |
| } | |
| return std::unique_ptr<IFX_SystemFontInfo>(pInfoFallback); | |
| } | |
| void CFX_GEModule::InitPlatform() { | |
| CWin32Platform* pPlatformData = new CWin32Platform; | |
| OSVERSIONINFO ver; | |
| ver.dwOSVersionInfoSize = sizeof(ver); | |
| GetVersionEx(&ver); | |
| pPlatformData->m_bHalfTone = ver.dwMajorVersion >= 5; | |
| if (IsGDIEnabled()) | |
| pPlatformData->m_GdiplusExt.Load(); | |
| m_pPlatformData = pPlatformData; | |
| m_pFontMgr->SetSystemFontInfo(IFX_SystemFontInfo::CreateDefault(nullptr)); | |
| } | |
| void CFX_GEModule::DestroyPlatform() { | |
| delete (CWin32Platform*)m_pPlatformData; | |
| m_pPlatformData = nullptr; | |
| } | |
| CGdiDeviceDriver::CGdiDeviceDriver(HDC hDC, int device_class) { | |
| m_hDC = hDC; | |
| m_DeviceClass = device_class; | |
| CWin32Platform* pPlatform = | |
| (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData(); | |
| SetStretchBltMode(hDC, pPlatform->m_bHalfTone ? HALFTONE : COLORONCOLOR); | |
| DWORD obj_type = GetObjectType(m_hDC); | |
| m_bMetafileDCType = obj_type == OBJ_ENHMETADC || obj_type == OBJ_ENHMETAFILE; | |
| if (obj_type == OBJ_MEMDC) { | |
| HBITMAP hBitmap = CreateBitmap(1, 1, 1, 1, nullptr); | |
| hBitmap = (HBITMAP)SelectObject(m_hDC, hBitmap); | |
| BITMAP bitmap; | |
| GetObject(hBitmap, sizeof bitmap, &bitmap); | |
| m_nBitsPerPixel = bitmap.bmBitsPixel; | |
| m_Width = bitmap.bmWidth; | |
| m_Height = abs(bitmap.bmHeight); | |
| hBitmap = (HBITMAP)SelectObject(m_hDC, hBitmap); | |
| DeleteObject(hBitmap); | |
| } else { | |
| m_nBitsPerPixel = ::GetDeviceCaps(m_hDC, BITSPIXEL); | |
| m_Width = ::GetDeviceCaps(m_hDC, HORZRES); | |
| m_Height = ::GetDeviceCaps(m_hDC, VERTRES); | |
| } | |
| if (m_DeviceClass != FXDC_DISPLAY) { | |
| m_RenderCaps = FXRC_BIT_MASK; | |
| } else { | |
| m_RenderCaps = FXRC_GET_BITS | FXRC_BIT_MASK; | |
| } | |
| } | |
| CGdiDeviceDriver::~CGdiDeviceDriver() {} | |
| int CGdiDeviceDriver::GetDeviceCaps(int caps_id) const { | |
| switch (caps_id) { | |
| case FXDC_DEVICE_CLASS: | |
| return m_DeviceClass; | |
| case FXDC_PIXEL_WIDTH: | |
| return m_Width; | |
| case FXDC_PIXEL_HEIGHT: | |
| return m_Height; | |
| case FXDC_BITS_PIXEL: | |
| return m_nBitsPerPixel; | |
| case FXDC_RENDER_CAPS: | |
| return m_RenderCaps; | |
| } | |
| return 0; | |
| } | |
| void CGdiDeviceDriver::SaveState() { | |
| SaveDC(m_hDC); | |
| } | |
| void CGdiDeviceDriver::RestoreState(bool bKeepSaved) { | |
| RestoreDC(m_hDC, -1); | |
| if (bKeepSaved) | |
| SaveDC(m_hDC); | |
| } | |
| bool CGdiDeviceDriver::GDI_SetDIBits(const RetainPtr<CFX_DIBitmap>& pBitmap1, | |
| const FX_RECT* pSrcRect, | |
| int left, | |
| int top) { | |
| if (m_DeviceClass == FXDC_PRINTER) { | |
| RetainPtr<CFX_DIBitmap> pBitmap = pBitmap1->FlipImage(false, true); | |
| if (!pBitmap) | |
| return false; | |
| if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb)) | |
| return false; | |
| int width = pSrcRect->Width(), height = pSrcRect->Height(); | |
| LPBYTE pBuffer = pBitmap->GetBuffer(); | |
| ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap); | |
| ((BITMAPINFOHEADER*)info.c_str())->biHeight *= -1; | |
| FX_RECT dst_rect(0, 0, width, height); | |
| dst_rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight()); | |
| int dst_width = dst_rect.Width(); | |
| int dst_height = dst_rect.Height(); | |
| ::StretchDIBits(m_hDC, left, top, dst_width, dst_height, 0, 0, dst_width, | |
| dst_height, pBuffer, (BITMAPINFO*)info.c_str(), | |
| DIB_RGB_COLORS, SRCCOPY); | |
| } else { | |
| RetainPtr<CFX_DIBitmap> pBitmap = pBitmap1; | |
| if (pBitmap->IsCmykImage()) { | |
| pBitmap = pBitmap->CloneConvert(FXDIB_Rgb); | |
| if (!pBitmap) | |
| return false; | |
| } | |
| int width = pSrcRect->Width(), height = pSrcRect->Height(); | |
| LPBYTE pBuffer = pBitmap->GetBuffer(); | |
| ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap); | |
| ::SetDIBitsToDevice(m_hDC, left, top, width, height, pSrcRect->left, | |
| pBitmap->GetHeight() - pSrcRect->bottom, 0, | |
| pBitmap->GetHeight(), pBuffer, | |
| (BITMAPINFO*)info.c_str(), DIB_RGB_COLORS); | |
| } | |
| return true; | |
| } | |
| bool CGdiDeviceDriver::GDI_StretchDIBits( | |
| const RetainPtr<CFX_DIBitmap>& pBitmap1, | |
| int dest_left, | |
| int dest_top, | |
| int dest_width, | |
| int dest_height, | |
| uint32_t flags) { | |
| RetainPtr<CFX_DIBitmap> pBitmap = pBitmap1; | |
| if (!pBitmap || dest_width == 0 || dest_height == 0) | |
| return false; | |
| if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb)) | |
| return false; | |
| ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap); | |
| if ((int64_t)abs(dest_width) * abs(dest_height) < | |
| (int64_t)pBitmap1->GetWidth() * pBitmap1->GetHeight() * 4 || | |
| (flags & FXDIB_INTERPOL) || (flags & FXDIB_BICUBIC_INTERPOL)) { | |
| SetStretchBltMode(m_hDC, HALFTONE); | |
| } else { | |
| SetStretchBltMode(m_hDC, COLORONCOLOR); | |
| } | |
| RetainPtr<CFX_DIBitmap> pToStrechBitmap = pBitmap; | |
| if (m_DeviceClass == FXDC_PRINTER && | |
| ((int64_t)pBitmap->GetWidth() * pBitmap->GetHeight() > | |
| (int64_t)abs(dest_width) * abs(dest_height))) { | |
| pToStrechBitmap = pBitmap->StretchTo(dest_width, dest_height, 0, nullptr); | |
| } | |
| ByteString toStrechBitmapInfo = | |
| CFX_WindowsDIB::GetBitmapInfo(pToStrechBitmap); | |
| ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height, 0, 0, | |
| pToStrechBitmap->GetWidth(), pToStrechBitmap->GetHeight(), | |
| pToStrechBitmap->GetBuffer(), | |
| (BITMAPINFO*)toStrechBitmapInfo.c_str(), DIB_RGB_COLORS, | |
| SRCCOPY); | |
| return true; | |
| } | |
| bool CGdiDeviceDriver::GDI_StretchBitMask( | |
| const RetainPtr<CFX_DIBitmap>& pBitmap1, | |
| int dest_left, | |
| int dest_top, | |
| int dest_width, | |
| int dest_height, | |
| uint32_t bitmap_color, | |
| uint32_t flags) { | |
| RetainPtr<CFX_DIBitmap> pBitmap = pBitmap1; | |
| if (!pBitmap || dest_width == 0 || dest_height == 0) | |
| return false; | |
| int width = pBitmap->GetWidth(), height = pBitmap->GetHeight(); | |
| struct { | |
| BITMAPINFOHEADER bmiHeader; | |
| uint32_t bmiColors[2]; | |
| } bmi; | |
| memset(&bmi.bmiHeader, 0, sizeof(BITMAPINFOHEADER)); | |
| bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
| bmi.bmiHeader.biBitCount = 1; | |
| bmi.bmiHeader.biCompression = BI_RGB; | |
| bmi.bmiHeader.biHeight = -height; | |
| bmi.bmiHeader.biPlanes = 1; | |
| bmi.bmiHeader.biWidth = width; | |
| if (m_nBitsPerPixel != 1) { | |
| SetStretchBltMode(m_hDC, HALFTONE); | |
| } | |
| bmi.bmiColors[0] = 0xffffff; | |
| bmi.bmiColors[1] = 0; | |
| HBRUSH hPattern = CreateSolidBrush(bitmap_color & 0xffffff); | |
| HBRUSH hOld = (HBRUSH)SelectObject(m_hDC, hPattern); | |
| // In PDF, when image mask is 1, use device bitmap; when mask is 0, use brush | |
| // bitmap. | |
| // A complete list of the boolen operations is as follows: | |
| /* P(bitmap_color) S(ImageMask) D(DeviceBitmap) Result | |
| * 0 0 0 0 | |
| * 0 0 1 0 | |
| * 0 1 0 0 | |
| * 0 1 1 1 | |
| * 1 0 0 1 | |
| * 1 0 1 1 | |
| * 1 1 0 0 | |
| * 1 1 1 1 | |
| */ | |
| // The boolen codes is B8. Based on | |
| // http://msdn.microsoft.com/en-us/library/aa932106.aspx, the ROP3 code is | |
| // 0xB8074A | |
| ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height, 0, 0, | |
| width, height, pBitmap->GetBuffer(), (BITMAPINFO*)&bmi, | |
| DIB_RGB_COLORS, 0xB8074A); | |
| SelectObject(m_hDC, hOld); | |
| DeleteObject(hPattern); | |
| return true; | |
| } | |
| bool CGdiDeviceDriver::GetClipBox(FX_RECT* pRect) { | |
| return !!(::GetClipBox(m_hDC, (RECT*)pRect)); | |
| } | |
| void CGdiDeviceDriver::DrawLine(float x1, float y1, float x2, float y2) { | |
| if (!m_bMetafileDCType) { // EMF drawing is not bound to the DC. | |
| int startOutOfBoundsFlag = (x1 < 0) | ((x1 > m_Width) << 1) | | |
| ((y1 < 0) << 2) | ((y1 > m_Height) << 3); | |
| int endOutOfBoundsFlag = (x2 < 0) | ((x2 > m_Width) << 1) | | |
| ((y2 < 0) << 2) | ((y2 > m_Height) << 3); | |
| if (startOutOfBoundsFlag & endOutOfBoundsFlag) | |
| return; | |
| if (startOutOfBoundsFlag || endOutOfBoundsFlag) { | |
| float x[2]; | |
| float y[2]; | |
| int np; | |
| #ifdef _SKIA_SUPPORT_ | |
| // TODO(caryclark) temporary replacement of antigrain in line function | |
| // to permit removing antigrain altogether | |
| rect_base rect = {0.0f, 0.0f, (float)(m_Width), (float)(m_Height)}; | |
| np = clip_liang_barsky(x1, y1, x2, y2, rect, x, y); | |
| #else | |
| agg::rect_base<float> rect(0.0f, 0.0f, (float)(m_Width), | |
| (float)(m_Height)); | |
| np = agg::clip_liang_barsky<float>(x1, y1, x2, y2, rect, x, y); | |
| #endif | |
| if (np == 0) | |
| return; | |
| if (np == 1) { | |
| x2 = x[0]; | |
| y2 = y[0]; | |
| } else { | |
| ASSERT(np == 2); | |
| x1 = x[0]; | |
| y1 = y[0]; | |
| x2 = x[1]; | |
| y2 = y[1]; | |
| } | |
| } | |
| } | |
| MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr); | |
| LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2)); | |
| } | |
| bool CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData, | |
| const CFX_Matrix* pMatrix, | |
| const CFX_GraphStateData* pGraphState, | |
| uint32_t fill_color, | |
| uint32_t stroke_color, | |
| int fill_mode, | |
| int blend_type) { | |
| if (blend_type != FXDIB_BLEND_NORMAL) | |
| return false; | |
| CWin32Platform* pPlatform = | |
| (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData(); | |
| if (!(pGraphState || stroke_color == 0) && | |
| !pPlatform->m_GdiplusExt.IsAvailable()) { | |
| CFX_FloatRect bbox_f = pPathData->GetBoundingBox(); | |
| if (pMatrix) | |
| bbox_f = pMatrix->TransformRect(bbox_f); | |
| FX_RECT bbox = bbox_f.GetInnerRect(); | |
| if (bbox.Width() <= 0) { | |
| return DrawCosmeticLine(CFX_PointF(bbox.left, bbox.top), | |
| CFX_PointF(bbox.left, bbox.bottom + 1), | |
| fill_color, FXDIB_BLEND_NORMAL); | |
| } | |
| if (bbox.Height() <= 0) { | |
| return DrawCosmeticLine(CFX_PointF(bbox.left, bbox.top), | |
| CFX_PointF(bbox.right + 1, bbox.top), fill_color, | |
| FXDIB_BLEND_NORMAL); | |
| } | |
| } | |
| int fill_alpha = FXARGB_A(fill_color); | |
| int stroke_alpha = FXARGB_A(stroke_color); | |
| bool bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) || | |
| (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState); | |
| if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha) | |
| return false; | |
| if (pPlatform->m_GdiplusExt.IsAvailable()) { | |
| if (bDrawAlpha || | |
| ((m_DeviceClass != FXDC_PRINTER && !(fill_mode & FXFILL_FULLCOVER)) || | |
| (pGraphState && pGraphState->m_DashCount))) { | |
| if (!((!pMatrix || !pMatrix->WillScale()) && pGraphState && | |
| pGraphState->m_LineWidth == 1.f && | |
| (pPathData->GetPoints().size() == 5 || | |
| pPathData->GetPoints().size() == 4) && | |
| pPathData->IsRect())) { | |
| if (pPlatform->m_GdiplusExt.DrawPath(m_hDC, pPathData, pMatrix, | |
| pGraphState, fill_color, | |
| stroke_color, fill_mode)) { | |
| return true; | |
| } | |
| } | |
| } | |
| } | |
| int old_fill_mode = fill_mode; | |
| fill_mode &= 3; | |
| HPEN hPen = nullptr; | |
| HBRUSH hBrush = nullptr; | |
| if (pGraphState && stroke_alpha) { | |
| SetMiterLimit(m_hDC, pGraphState->m_MiterLimit, nullptr); | |
| hPen = CreatePen(pGraphState, pMatrix, stroke_color); | |
| hPen = (HPEN)SelectObject(m_hDC, hPen); | |
| } | |
| if (fill_mode && fill_alpha) { | |
| SetPolyFillMode(m_hDC, fill_mode); | |
| hBrush = CreateBrush(fill_color); | |
| hBrush = (HBRUSH)SelectObject(m_hDC, hBrush); | |
| } | |
| if (pPathData->GetPoints().size() == 2 && pGraphState && | |
| pGraphState->m_DashCount) { | |
| CFX_PointF pos1 = pPathData->GetPoint(0); | |
| CFX_PointF pos2 = pPathData->GetPoint(1); | |
| if (pMatrix) { | |
| pos1 = pMatrix->Transform(pos1); | |
| pos2 = pMatrix->Transform(pos2); | |
| } | |
| DrawLine(pos1.x, pos1.y, pos2.x, pos2.y); | |
| } else { | |
| SetPathToDC(m_hDC, pPathData, pMatrix); | |
| if (pGraphState && stroke_alpha) { | |
| if (fill_mode && fill_alpha) { | |
| if (old_fill_mode & FX_FILL_TEXT_MODE) { | |
| StrokeAndFillPath(m_hDC); | |
| } else { | |
| FillPath(m_hDC); | |
| SetPathToDC(m_hDC, pPathData, pMatrix); | |
| StrokePath(m_hDC); | |
| } | |
| } else { | |
| StrokePath(m_hDC); | |
| } | |
| } else if (fill_mode && fill_alpha) { | |
| FillPath(m_hDC); | |
| } | |
| } | |
| if (hPen) { | |
| hPen = (HPEN)SelectObject(m_hDC, hPen); | |
| DeleteObject(hPen); | |
| } | |
| if (hBrush) { | |
| hBrush = (HBRUSH)SelectObject(m_hDC, hBrush); | |
| DeleteObject(hBrush); | |
| } | |
| return true; | |
| } | |
| bool CGdiDeviceDriver::FillRectWithBlend(const FX_RECT* pRect, | |
| uint32_t fill_color, | |
| int blend_type) { | |
| if (blend_type != FXDIB_BLEND_NORMAL) | |
| return false; | |
| int alpha; | |
| FX_COLORREF rgb; | |
| std::tie(alpha, rgb) = ArgbToColorRef(fill_color); | |
| if (alpha == 0) | |
| return true; | |
| if (alpha < 255) | |
| return false; | |
| HBRUSH hBrush = CreateSolidBrush(rgb); | |
| ::FillRect(m_hDC, (RECT*)pRect, hBrush); | |
| DeleteObject(hBrush); | |
| return true; | |
| } | |
| bool CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData, | |
| const CFX_Matrix* pMatrix, | |
| int fill_mode) { | |
| if (pPathData->GetPoints().size() == 5) { | |
| CFX_FloatRect rectf; | |
| if (pPathData->IsRect(pMatrix, &rectf)) { | |
| FX_RECT rect = rectf.GetOuterRect(); | |
| IntersectClipRect(m_hDC, rect.left, rect.top, rect.right, rect.bottom); | |
| return true; | |
| } | |
| } | |
| SetPathToDC(m_hDC, pPathData, pMatrix); | |
| SetPolyFillMode(m_hDC, fill_mode & 3); | |
| SelectClipPath(m_hDC, RGN_AND); | |
| return true; | |
| } | |
| bool CGdiDeviceDriver::SetClip_PathStroke( | |
| const CFX_PathData* pPathData, | |
| const CFX_Matrix* pMatrix, | |
| const CFX_GraphStateData* pGraphState) { | |
| HPEN hPen = CreatePen(pGraphState, pMatrix, 0xff000000); | |
| hPen = (HPEN)SelectObject(m_hDC, hPen); | |
| SetPathToDC(m_hDC, pPathData, pMatrix); | |
| WidenPath(m_hDC); | |
| SetPolyFillMode(m_hDC, WINDING); | |
| bool ret = !!SelectClipPath(m_hDC, RGN_AND); | |
| hPen = (HPEN)SelectObject(m_hDC, hPen); | |
| DeleteObject(hPen); | |
| return ret; | |
| } | |
| bool CGdiDeviceDriver::DrawCosmeticLine(const CFX_PointF& ptMoveTo, | |
| const CFX_PointF& ptLineTo, | |
| uint32_t color, | |
| int blend_type) { | |
| if (blend_type != FXDIB_BLEND_NORMAL) | |
| return false; | |
| int a; | |
| FX_COLORREF rgb; | |
| std::tie(a, rgb) = ArgbToColorRef(color); | |
| if (a == 0) | |
| return true; | |
| HPEN hPen = CreatePen(PS_SOLID, 1, rgb); | |
| hPen = (HPEN)SelectObject(m_hDC, hPen); | |
| MoveToEx(m_hDC, FXSYS_round(ptMoveTo.x), FXSYS_round(ptMoveTo.y), nullptr); | |
| LineTo(m_hDC, FXSYS_round(ptLineTo.x), FXSYS_round(ptLineTo.y)); | |
| hPen = (HPEN)SelectObject(m_hDC, hPen); | |
| DeleteObject(hPen); | |
| return true; | |
| } | |
| CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC) | |
| : CGdiDeviceDriver(hDC, FXDC_DISPLAY) { | |
| CWin32Platform* pPlatform = | |
| (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData(); | |
| if (pPlatform->m_GdiplusExt.IsAvailable()) { | |
| m_RenderCaps |= FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE; | |
| } | |
| } | |
| CGdiDisplayDriver::~CGdiDisplayDriver() {} | |
| bool CGdiDisplayDriver::GetDIBits(const RetainPtr<CFX_DIBitmap>& pBitmap, | |
| int left, | |
| int top) { | |
| bool ret = false; | |
| int width = pBitmap->GetWidth(); | |
| int height = pBitmap->GetHeight(); | |
| HBITMAP hbmp = CreateCompatibleBitmap(m_hDC, width, height); | |
| HDC hDCMemory = CreateCompatibleDC(m_hDC); | |
| HBITMAP holdbmp = (HBITMAP)SelectObject(hDCMemory, hbmp); | |
| BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY); | |
| SelectObject(hDCMemory, holdbmp); | |
| BITMAPINFO bmi; | |
| memset(&bmi, 0, sizeof bmi); | |
| bmi.bmiHeader.biSize = sizeof bmi.bmiHeader; | |
| bmi.bmiHeader.biBitCount = pBitmap->GetBPP(); | |
| bmi.bmiHeader.biHeight = -height; | |
| bmi.bmiHeader.biPlanes = 1; | |
| bmi.bmiHeader.biWidth = width; | |
| if (pBitmap->GetBPP() > 8 && !pBitmap->IsCmykImage()) { | |
| ret = ::GetDIBits(hDCMemory, hbmp, 0, height, pBitmap->GetBuffer(), &bmi, | |
| DIB_RGB_COLORS) == height; | |
| } else { | |
| auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (bitmap->Create(width, height, FXDIB_Rgb)) { | |
| bmi.bmiHeader.biBitCount = 24; | |
| ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap->GetBuffer(), &bmi, | |
| DIB_RGB_COLORS); | |
| ret = pBitmap->TransferBitmap(0, 0, width, height, bitmap, 0, 0); | |
| } else { | |
| ret = false; | |
| } | |
| } | |
| if (pBitmap->HasAlpha() && ret) | |
| pBitmap->LoadChannel(FXDIB_Alpha, 0xff); | |
| DeleteObject(hbmp); | |
| DeleteObject(hDCMemory); | |
| return ret; | |
| } | |
| bool CGdiDisplayDriver::SetDIBits(const RetainPtr<CFX_DIBSource>& pSource, | |
| uint32_t color, | |
| const FX_RECT* pSrcRect, | |
| int left, | |
| int top, | |
| int blend_type) { | |
| ASSERT(blend_type == FXDIB_BLEND_NORMAL); | |
| if (pSource->IsAlphaMask()) { | |
| int width = pSource->GetWidth(), height = pSource->GetHeight(); | |
| int alpha = FXARGB_A(color); | |
| if (pSource->GetBPP() != 1 || alpha != 255) { | |
| auto background = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!background->Create(width, height, FXDIB_Rgb32) || | |
| !GetDIBits(background, left, top) || | |
| !background->CompositeMask(0, 0, width, height, pSource, color, 0, 0, | |
| FXDIB_BLEND_NORMAL, nullptr, false, 0)) { | |
| return false; | |
| } | |
| FX_RECT src_rect(0, 0, width, height); | |
| return SetDIBits(background, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL); | |
| } | |
| FX_RECT clip_rect(left, top, left + pSrcRect->Width(), | |
| top + pSrcRect->Height()); | |
| return StretchDIBits(pSource, color, left - pSrcRect->left, | |
| top - pSrcRect->top, width, height, &clip_rect, 0, | |
| FXDIB_BLEND_NORMAL); | |
| } | |
| int width = pSrcRect->Width(), height = pSrcRect->Height(); | |
| if (pSource->HasAlpha()) { | |
| auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!bitmap->Create(width, height, FXDIB_Rgb) || | |
| !GetDIBits(bitmap, left, top) || | |
| !bitmap->CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left, | |
| pSrcRect->top, FXDIB_BLEND_NORMAL, nullptr, | |
| false)) { | |
| return false; | |
| } | |
| FX_RECT src_rect(0, 0, width, height); | |
| return SetDIBits(bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL); | |
| } | |
| CFX_DIBExtractor temp(pSource); | |
| RetainPtr<CFX_DIBitmap> pBitmap = temp.GetBitmap(); | |
| if (!pBitmap) | |
| return false; | |
| return GDI_SetDIBits(pBitmap, pSrcRect, left, top); | |
| } | |
| bool CGdiDisplayDriver::UseFoxitStretchEngine( | |
| const RetainPtr<CFX_DIBSource>& pSource, | |
| uint32_t color, | |
| int dest_left, | |
| int dest_top, | |
| int dest_width, | |
| int dest_height, | |
| const FX_RECT* pClipRect, | |
| int render_flags) { | |
| FX_RECT bitmap_clip = *pClipRect; | |
| if (dest_width < 0) | |
| dest_left += dest_width; | |
| if (dest_height < 0) | |
| dest_top += dest_height; | |
| bitmap_clip.Offset(-dest_left, -dest_top); | |
| RetainPtr<CFX_DIBitmap> pStretched = | |
| pSource->StretchTo(dest_width, dest_height, render_flags, &bitmap_clip); | |
| if (!pStretched) | |
| return true; | |
| FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight()); | |
| return SetDIBits(pStretched, color, &src_rect, pClipRect->left, | |
| pClipRect->top, FXDIB_BLEND_NORMAL); | |
| } | |
| bool CGdiDisplayDriver::StretchDIBits(const RetainPtr<CFX_DIBSource>& pSource, | |
| uint32_t color, | |
| int dest_left, | |
| int dest_top, | |
| int dest_width, | |
| int dest_height, | |
| const FX_RECT* pClipRect, | |
| uint32_t flags, | |
| int blend_type) { | |
| ASSERT(pSource && pClipRect); | |
| if (flags || dest_width > 10000 || dest_width < -10000 || | |
| dest_height > 10000 || dest_height < -10000) { | |
| return UseFoxitStretchEngine(pSource, color, dest_left, dest_top, | |
| dest_width, dest_height, pClipRect, flags); | |
| } | |
| if (pSource->IsAlphaMask()) { | |
| FX_RECT image_rect; | |
| image_rect.left = dest_width > 0 ? dest_left : dest_left + dest_width; | |
| image_rect.right = dest_width > 0 ? dest_left + dest_width : dest_left; | |
| image_rect.top = dest_height > 0 ? dest_top : dest_top + dest_height; | |
| image_rect.bottom = dest_height > 0 ? dest_top + dest_height : dest_top; | |
| FX_RECT clip_rect = image_rect; | |
| clip_rect.Intersect(*pClipRect); | |
| clip_rect.Offset(-image_rect.left, -image_rect.top); | |
| int clip_width = clip_rect.Width(), clip_height = clip_rect.Height(); | |
| RetainPtr<CFX_DIBitmap> pStretched( | |
| pSource->StretchTo(dest_width, dest_height, flags, &clip_rect)); | |
| if (!pStretched) | |
| return true; | |
| auto background = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!background->Create(clip_width, clip_height, FXDIB_Rgb32) || | |
| !GetDIBits(background, image_rect.left + clip_rect.left, | |
| image_rect.top + clip_rect.top) || | |
| !background->CompositeMask(0, 0, clip_width, clip_height, pStretched, | |
| color, 0, 0, FXDIB_BLEND_NORMAL, nullptr, | |
| false, 0)) { | |
| return false; | |
| } | |
| FX_RECT src_rect(0, 0, clip_width, clip_height); | |
| return SetDIBits(background, 0, &src_rect, image_rect.left + clip_rect.left, | |
| image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL); | |
| } | |
| if (pSource->HasAlpha()) { | |
| CWin32Platform* pPlatform = | |
| (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData(); | |
| if (pPlatform->m_GdiplusExt.IsAvailable() && !pSource->IsCmykImage()) { | |
| CFX_DIBExtractor temp(pSource); | |
| RetainPtr<CFX_DIBitmap> pBitmap = temp.GetBitmap(); | |
| if (!pBitmap) | |
| return false; | |
| return pPlatform->m_GdiplusExt.StretchDIBits( | |
| m_hDC, pBitmap, dest_left, dest_top, dest_width, dest_height, | |
| pClipRect, flags); | |
| } | |
| return UseFoxitStretchEngine(pSource, color, dest_left, dest_top, | |
| dest_width, dest_height, pClipRect, flags); | |
| } | |
| CFX_DIBExtractor temp(pSource); | |
| RetainPtr<CFX_DIBitmap> pBitmap = temp.GetBitmap(); | |
| if (!pBitmap) | |
| return false; | |
| return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width, | |
| dest_height, flags); | |
| } | |
| bool CGdiDisplayDriver::StartDIBits(const RetainPtr<CFX_DIBSource>& pBitmap, | |
| int bitmap_alpha, | |
| uint32_t color, | |
| const CFX_Matrix* pMatrix, | |
| uint32_t render_flags, | |
| std::unique_ptr<CFX_ImageRenderer>* handle, | |
| int blend_type) { | |
| return false; | |
| } | |
| CFX_WindowsRenderDevice::CFX_WindowsRenderDevice(HDC hDC) { | |
| SetDeviceDriver(pdfium::WrapUnique(CreateDriver(hDC))); | |
| } | |
| CFX_WindowsRenderDevice::~CFX_WindowsRenderDevice() {} | |
| // static | |
| IFX_RenderDeviceDriver* CFX_WindowsRenderDevice::CreateDriver(HDC hDC) { | |
| int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY); | |
| int obj_type = ::GetObjectType(hDC); | |
| bool use_printer = device_type == DT_RASPRINTER || | |
| device_type == DT_PLOTTER || | |
| device_type == DT_CHARSTREAM || obj_type == OBJ_ENHMETADC; | |
| if (!use_printer) | |
| return new CGdiDisplayDriver(hDC); | |
| if (g_pdfium_print_mode == WindowsPrintMode::kModeEmf) | |
| return new CGdiPrinterDriver(hDC); | |
| if (g_pdfium_print_mode == WindowsPrintMode::kModeTextOnly) | |
| return new CTextOnlyPrinterDriver(hDC); | |
| // Should be PostScript | |
| ASSERT(g_pdfium_print_mode == WindowsPrintMode::kModePostScript2 || | |
| g_pdfium_print_mode == WindowsPrintMode::kModePostScript3); | |
| return new CPSPrinterDriver(hDC, g_pdfium_print_mode, false); | |
| } |