Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1670 insertions, 0 deletions

diff --git a/vcl/win/gdi/salfont.cxx b/vcl/win/gdi/salfont.cxx
new file mode 100644
index 000000000..3a2eb2261
--- /dev/null
+++ b/vcl/win/gdi/salfont.cxx
@@ -0,0 +1,1670 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <sal/types.h>
+#include <config_folders.h>
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string.h>
+#include <string_view>
+#include <svsys.h>
+#include <vector>
+
+#include <o3tl/lru_map.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <osl/file.hxx>
+#include <osl/process.h>
+#include <rtl/bootstrap.hxx>
+#include <rtl/tencinfo.h>
+#include <sal/log.hxx>
+#include <o3tl/char16_t2wchar_t.hxx>
+#include <tools/helpers.hxx>
+#include <tools/stream.hxx>
+#include <tools/urlobj.hxx>
+#include <unotools/fontcfg.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/sysdata.hxx>
+#include <vcl/metric.hxx>
+#include <vcl/fontcharmap.hxx>
+#include <comphelper/scopeguard.hxx>
+
+#include <font/FontSelectPattern.hxx>
+#include <fontsubset.hxx>
+#include <font/PhysicalFontCollection.hxx>
+#include <font/PhysicalFontFaceCollection.hxx>
+#include <font/PhysicalFontFace.hxx>
+#include <font/fontsubstitution.hxx>
+#include <sft.hxx>
+#include <win/saldata.hxx>
+#include <win/salgdi.h>
+#include <win/winlayout.hxx>
+#include <win/wingdiimpl.hxx>
+#include <impfontcharmap.hxx>
+#include <impfontmetricdata.hxx>
+#include <impglyphitem.hxx>
+
+#if HAVE_FEATURE_SKIA
+#include <vcl/skia/SkiaHelper.hxx>
+#include <skia/win/font.hxx>
+#endif
+
+using namespace vcl;
+
+static FIXED FixedFromDouble( double d )
+{
+    const tools::Long l = static_cast<tools::Long>( d * 65536. );
+    return *reinterpret_cast<FIXED const *>(&l);
+}
+
+static int IntTimes256FromFixed(FIXED f)
+{
+    int nFixedTimes256 = (f.value << 8) + ((f.fract+0x80) >> 8);
+    return nFixedTimes256;
+}
+
+namespace {
+
+// raw font data with a scoped lifetime
+class RawFontData
+{
+public:
+    explicit    RawFontData( HDC, DWORD nTableTag=0 );
+    const unsigned char*    get() const { return mpRawBytes.get(); }
+    const unsigned char*    steal() { return mpRawBytes.release(); }
+    int               size() const { return mnByteCount; }
+
+private:
+    std::unique_ptr<unsigned char[]> mpRawBytes;
+    unsigned        mnByteCount;
+};
+
+}
+
+RawFontData::RawFontData( HDC hDC, DWORD nTableTag )
+:   mnByteCount( 0 )
+{
+    // get required size in bytes
+    mnByteCount = ::GetFontData( hDC, nTableTag, 0, nullptr, 0 );
+    if (mnByteCount == GDI_ERROR)
+        mnByteCount = 0;
+    if (!mnByteCount)
+        return;
+
+    // allocate the array
+    mpRawBytes.reset(new unsigned char[ mnByteCount ]);
+
+    // get raw data in chunks small enough for GetFontData()
+    unsigned nRawDataOfs = 0;
+    DWORD nMaxChunkSize = 0x100000;
+    for(;;)
+    {
+        // calculate remaining raw data to get
+        DWORD nFDGet = mnByteCount - nRawDataOfs;
+        if( nFDGet <= 0 )
+            break;
+        // #i56745# limit GetFontData requests
+        if( nFDGet > nMaxChunkSize )
+            nFDGet = nMaxChunkSize;
+        const DWORD nFDGot = ::GetFontData( hDC, nTableTag, nRawDataOfs,
+            mpRawBytes.get() + nRawDataOfs, nFDGet );
+        if( !nFDGot )
+            break;
+        else if( nFDGot != GDI_ERROR )
+            nRawDataOfs += nFDGot;
+        else
+        {
+            // was the chunk too big? reduce it
+            nMaxChunkSize /= 2;
+            if( nMaxChunkSize < 0x10000 )
+                break;
+        }
+    }
+
+    // cleanup if the raw data is incomplete
+    if( nRawDataOfs != mnByteCount )
+    {
+        mpRawBytes.reset();
+        // mnByteCount must correspond to mpRawBytes length
+        SAL_WARN( "vcl", "Raw data of font is incomplete: " << nRawDataOfs << " byte(s) found whereas " << mnByteCount << " byte(s) expected!" );
+        mnByteCount = 0;
+    }
+}
+
+// platform specific font substitution hooks for glyph fallback enhancement
+
+namespace {
+
+class WinPreMatchFontSubstititution
+:    public vcl::font::PreMatchFontSubstitution
+{
+public:
+    bool FindFontSubstitute(vcl::font::FontSelectPattern&) const override;
+};
+
+class WinGlyphFallbackSubstititution
+:    public vcl::font::GlyphFallbackFontSubstitution
+{
+public:
+    explicit WinGlyphFallbackSubstititution()
+        : mhDC(GetDC(nullptr))
+    {
+    };
+
+    ~WinGlyphFallbackSubstititution() override
+    {
+        ReleaseDC(nullptr, mhDC);
+    };
+
+    bool FindFontSubstitute(vcl::font::FontSelectPattern&, LogicalFontInstance* pLogicalFont, OUString& rMissingChars) const override;
+private:
+    HDC mhDC;
+    bool HasMissingChars(vcl::font::PhysicalFontFace*, OUString& rMissingChars) const;
+};
+
+}
+
+// does a font face hold the given missing characters?
+bool WinGlyphFallbackSubstititution::HasMissingChars(vcl::font::PhysicalFontFace* pFace, OUString& rMissingChars) const
+{
+    WinFontFace* pWinFont = static_cast< WinFontFace* >(pFace);
+    FontCharMapRef xFontCharMap = pWinFont->GetFontCharMap();
+    if( !xFontCharMap.is() )
+    {
+        // create a FontSelectPattern object for getting s LOGFONT
+        const vcl::font::FontSelectPattern aFSD( *pFace, Size(), 0.0, 0, false );
+        // construct log font
+        LOGFONTW aLogFont;
+        ImplGetLogFontFromFontSelect( aFSD, pFace, aLogFont );
+
+        // create HFONT from log font
+        HFONT hNewFont = ::CreateFontIndirectW( &aLogFont );
+        // select the new font into device
+        HFONT hOldFont = ::SelectFont( mhDC, hNewFont );
+
+        // read CMAP table to update their xFontCharMap
+        pWinFont->UpdateFromHDC( mhDC );
+
+        // cleanup temporary font
+        ::SelectFont( mhDC, hOldFont );
+        ::DeleteFont( hNewFont );
+
+        // get the new charmap
+        xFontCharMap = pWinFont->GetFontCharMap();
+    }
+
+    // avoid fonts with unknown CMAP subtables for glyph fallback
+    if( !xFontCharMap.is() || xFontCharMap->IsDefaultMap() )
+        return false;
+
+    int nMatchCount = 0;
+    std::vector<sal_UCS4> rRemainingCodes;
+    const sal_Int32 nStrLen = rMissingChars.getLength();
+    sal_Int32 nStrIdx = 0;
+    while (nStrIdx < nStrLen)
+    {
+        const sal_UCS4 uChar = rMissingChars.iterateCodePoints( &nStrIdx );
+        if (xFontCharMap->HasChar(uChar))
+            nMatchCount++;
+        else
+            rRemainingCodes.push_back(uChar);
+    }
+
+    xFontCharMap = nullptr;
+
+    if (nMatchCount > 0)
+        rMissingChars = OUString(rRemainingCodes.data(), rRemainingCodes.size());
+
+    return nMatchCount > 0;
+}
+
+namespace
+{
+    //used by 2-level font fallback
+    vcl::font::PhysicalFontFamily* findDevFontListByLocale(const vcl::font::PhysicalFontCollection &rFontCollection,
+                                                const LanguageTag& rLanguageTag )
+    {
+        // get the default font for a specified locale
+        const utl::DefaultFontConfiguration& rDefaults = utl::DefaultFontConfiguration::get();
+        const OUString aDefault = rDefaults.getUserInterfaceFont(rLanguageTag);
+        return rFontCollection.FindFontFamilyByTokenNames(aDefault);
+    }
+}
+
+// These are Win 3.1 bitmap fonts using "FON" font format
+// which is not supported with DirectWrite so let's substitute them
+// with a font that is supported and always available.
+// Based on:
+// https://dxr.mozilla.org/mozilla-esr10/source/gfx/thebes/gfxDWriteFontList.cpp#1057
+const std::map<OUString, OUString> aBitmapFontSubs =
+{
+    { "MS Sans Serif", "Microsoft Sans Serif" },
+    { "MS Serif",      "Times New Roman" },
+    { "Small Fonts",   "Arial" },
+    { "Courier",       "Courier New" },
+    { "Roman",         "Times New Roman" },
+    { "Script",        "Mistral" }
+};
+
+// TODO: See if Windows have API that we can use here to improve font fallback.
+bool WinPreMatchFontSubstititution::FindFontSubstitute(vcl::font::FontSelectPattern& rFontSelData) const
+{
+    if (rFontSelData.IsSymbolFont() || IsStarSymbol(rFontSelData.maSearchName))
+        return false;
+
+    for (const auto& aSub : aBitmapFontSubs)
+    {
+        if (rFontSelData.maSearchName == GetEnglishSearchFontName(aSub.first))
+        {
+            rFontSelData.maSearchName = aSub.second;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// find a fallback font for missing characters
+// TODO: should stylistic matches be searched and preferred?
+bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPattern& rFontSelData, LogicalFontInstance* /*pLogicalFont*/, OUString& rMissingChars) const
+{
+    // guess a locale matching to the missing chars
+    LanguageType eLang = rFontSelData.meLanguage;
+    LanguageTag aLanguageTag( eLang);
+
+    // fall back to default UI locale if the font language is inconclusive
+    if( eLang == LANGUAGE_DONTKNOW )
+        aLanguageTag = Application::GetSettings().GetUILanguageTag();
+
+    // first level fallback:
+    // try use the locale specific default fonts defined in VCL.xcu
+    const vcl::font::PhysicalFontCollection* pFontCollection = ImplGetSVData()->maGDIData.mxScreenFontList.get();
+    vcl::font::PhysicalFontFamily* pFontFamily = findDevFontListByLocale(*pFontCollection, aLanguageTag);
+    if( pFontFamily )
+    {
+        vcl::font::PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
+        if( HasMissingChars( pFace, rMissingChars ) )
+        {
+            rFontSelData.maSearchName = pFontFamily->GetSearchName();
+            return true;
+        }
+    }
+
+    // are the missing characters symbols?
+    pFontFamily = pFontCollection->FindFontFamilyByAttributes( ImplFontAttrs::Symbol,
+                                                     rFontSelData.GetWeight(),
+                                                     rFontSelData.GetWidthType(),
+                                                     rFontSelData.GetItalic(),
+                                                     rFontSelData.maSearchName );
+    if( pFontFamily )
+    {
+        vcl::font::PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
+        if( HasMissingChars( pFace, rMissingChars ) )
+        {
+            rFontSelData.maSearchName = pFontFamily->GetSearchName();
+            return true;
+        }
+    }
+
+    // last level fallback, check each font type face one by one
+    std::unique_ptr<vcl::font::PhysicalFontFaceCollection> pTestFontList = pFontCollection->GetFontFaceCollection();
+    // limit the count of fonts to be checked to prevent hangs
+    static const int MAX_GFBFONT_COUNT = 600;
+    int nTestFontCount = pTestFontList->Count();
+    if( nTestFontCount > MAX_GFBFONT_COUNT )
+        nTestFontCount = MAX_GFBFONT_COUNT;
+
+    bool bFound = false;
+    for( int i = 0; i < nTestFontCount; ++i )
+    {
+        vcl::font::PhysicalFontFace* pFace = pTestFontList->Get( i );
+        bFound = HasMissingChars( pFace, rMissingChars );
+        if( !bFound )
+            continue;
+        rFontSelData.maSearchName = pFace->GetFamilyName();
+        break;
+    }
+
+    return bFound;
+}
+
+namespace {
+
+struct ImplEnumInfo
+{
+    HDC                 mhDC;
+    vcl::font::PhysicalFontCollection* mpList;
+    OUString*           mpName;
+    LOGFONTW*           mpLogFont;
+    bool                mbPrinter;
+    int                 mnFontCount;
+};
+
+}
+
+static rtl_TextEncoding ImplCharSetToSal( BYTE nCharSet )
+{
+    rtl_TextEncoding eTextEncoding;
+
+    if ( nCharSet == OEM_CHARSET )
+    {
+        UINT nCP = static_cast<sal_uInt16>(GetOEMCP());
+        switch ( nCP )
+        {
+            // It is unclear why these two (undefined?) code page numbers are
+            // handled specially here:
+            case 1004:  eTextEncoding = RTL_TEXTENCODING_MS_1252; break;
+            case 65400: eTextEncoding = RTL_TEXTENCODING_SYMBOL; break;
+            default:
+                eTextEncoding = rtl_getTextEncodingFromWindowsCodePage(nCP);
+                break;
+        }
+    }
+    else
+    {
+        if( nCharSet )
+            eTextEncoding = rtl_getTextEncodingFromWindowsCharset( nCharSet );
+        else
+            eTextEncoding = RTL_TEXTENCODING_UNICODE;
+    }
+
+    return eTextEncoding;
+}
+
+static FontFamily ImplFamilyToSal( BYTE nFamily )
+{
+    switch ( nFamily & 0xF0 )
+    {
+        case FF_DECORATIVE:
+            return FAMILY_DECORATIVE;
+
+        case FF_MODERN:
+            return FAMILY_MODERN;
+
+        case FF_ROMAN:
+            return FAMILY_ROMAN;
+
+        case FF_SCRIPT:
+            return FAMILY_SCRIPT;
+
+        case FF_SWISS:
+            return FAMILY_SWISS;
+
+        default:
+            break;
+    }
+
+    return FAMILY_DONTKNOW;
+}
+
+static BYTE ImplFamilyToWin( FontFamily eFamily )
+{
+    switch ( eFamily )
+    {
+        case FAMILY_DECORATIVE:
+            return FF_DECORATIVE;
+
+        case FAMILY_MODERN:
+            return FF_MODERN;
+
+        case FAMILY_ROMAN:
+            return FF_ROMAN;
+
+        case FAMILY_SCRIPT:
+            return FF_SCRIPT;
+
+        case FAMILY_SWISS:
+            return FF_SWISS;
+
+        case FAMILY_SYSTEM:
+            return FF_SWISS;
+
+        default:
+            break;
+    }
+
+    return FF_DONTCARE;
+}
+
+static FontWeight ImplWeightToSal( int nWeight )
+{
+    if ( nWeight <= FW_THIN )
+        return WEIGHT_THIN;
+    else if ( nWeight <= FW_ULTRALIGHT )
+        return WEIGHT_ULTRALIGHT;
+    else if ( nWeight <= FW_LIGHT )
+        return WEIGHT_LIGHT;
+    else if ( nWeight < FW_MEDIUM )
+        return WEIGHT_NORMAL;
+    else if ( nWeight == FW_MEDIUM )
+        return WEIGHT_MEDIUM;
+    else if ( nWeight <= FW_SEMIBOLD )
+        return WEIGHT_SEMIBOLD;
+    else if ( nWeight <= FW_BOLD )
+        return WEIGHT_BOLD;
+    else if ( nWeight <= FW_ULTRABOLD )
+        return WEIGHT_ULTRABOLD;
+    else
+        return WEIGHT_BLACK;
+}
+
+static int ImplWeightToWin( FontWeight eWeight )
+{
+    switch ( eWeight )
+    {
+        case WEIGHT_THIN:
+            return FW_THIN;
+
+        case WEIGHT_ULTRALIGHT:
+            return FW_ULTRALIGHT;
+
+        case WEIGHT_LIGHT:
+            return FW_LIGHT;
+
+        case WEIGHT_SEMILIGHT:
+        case WEIGHT_NORMAL:
+            return FW_NORMAL;
+
+        case WEIGHT_MEDIUM:
+            return FW_MEDIUM;
+
+        case WEIGHT_SEMIBOLD:
+            return FW_SEMIBOLD;
+
+        case WEIGHT_BOLD:
+            return FW_BOLD;
+
+        case WEIGHT_ULTRABOLD:
+            return FW_ULTRABOLD;
+
+        case WEIGHT_BLACK:
+            return FW_BLACK;
+
+        default:
+            break;
+    }
+
+    return 0;
+}
+
+static FontPitch ImplLogPitchToSal( BYTE nPitch )
+{
+    if ( nPitch & FIXED_PITCH )
+        return PITCH_FIXED;
+    else
+        return PITCH_VARIABLE;
+}
+
+static FontPitch ImplMetricPitchToSal( BYTE nPitch )
+{
+    // Grrrr! See NT help
+    if ( !(nPitch & TMPF_FIXED_PITCH) )
+        return PITCH_FIXED;
+    else
+        return PITCH_VARIABLE;
+}
+
+static BYTE ImplPitchToWin( FontPitch ePitch )
+{
+    if ( ePitch == PITCH_FIXED )
+        return FIXED_PITCH;
+    else if ( ePitch == PITCH_VARIABLE )
+        return VARIABLE_PITCH;
+    else
+        return DEFAULT_PITCH;
+}
+
+static FontAttributes WinFont2DevFontAttributes( const ENUMLOGFONTEXW& rEnumFont,
+    const NEWTEXTMETRICW& rMetric)
+{
+    FontAttributes aDFA;
+
+    const LOGFONTW rLogFont = rEnumFont.elfLogFont;
+
+    // get font face attributes
+    aDFA.SetFamilyType(ImplFamilyToSal( rLogFont.lfPitchAndFamily ));
+    aDFA.SetWidthType(WIDTH_DONTKNOW);
+    aDFA.SetWeight(ImplWeightToSal( rLogFont.lfWeight ));
+    aDFA.SetItalic((rLogFont.lfItalic) ? ITALIC_NORMAL : ITALIC_NONE);
+    aDFA.SetPitch(ImplLogPitchToSal( rLogFont.lfPitchAndFamily ));
+    aDFA.SetSymbolFlag(rLogFont.lfCharSet == SYMBOL_CHARSET);
+
+    // get the font face name
+    aDFA.SetFamilyName(OUString(o3tl::toU(rLogFont.lfFaceName)));
+
+    // use the face's style name only if it looks reasonable
+    const wchar_t* pStyleName = rEnumFont.elfStyle;
+    const wchar_t* pEnd = pStyleName + sizeof(rEnumFont.elfStyle)/sizeof(*rEnumFont.elfStyle);
+    const wchar_t* p = pStyleName;
+    for(; *p && (p < pEnd); ++p )
+        if( *p < 0x0020 )
+            break;
+    if( p < pEnd )
+        aDFA.SetStyleName(OUString(o3tl::toU(pStyleName)));
+
+    // heuristics for font quality
+    // -   opentypeTT > truetype
+    aDFA.SetQuality( 0 );
+    if( rMetric.tmPitchAndFamily & TMPF_TRUETYPE )
+        aDFA.IncreaseQualityBy( 50 );
+    if( 0 != (rMetric.ntmFlags & (NTM_TT_OPENTYPE | NTM_PS_OPENTYPE)) )
+        aDFA.IncreaseQualityBy( 10 );
+
+    // TODO: add alias names
+    return aDFA;
+}
+
+
+static rtl::Reference<WinFontFace> ImplLogMetricToDevFontDataW( const ENUMLOGFONTEXW* pLogFont,
+                                         const NEWTEXTMETRICW* pMetric)
+{
+    rtl::Reference<WinFontFace> pData = new WinFontFace(
+        WinFont2DevFontAttributes(*pLogFont, *pMetric),
+        pLogFont->elfLogFont.lfCharSet,
+        pMetric->tmPitchAndFamily );
+
+    return pData;
+}
+
+void ImplSalLogFontToFontW( HDC hDC, const LOGFONTW& rLogFont, Font& rFont )
+{
+    OUString aFontName( o3tl::toU(rLogFont.lfFaceName) );
+    if (!aFontName.isEmpty())
+    {
+        rFont.SetFamilyName( aFontName );
+        rFont.SetCharSet( ImplCharSetToSal( rLogFont.lfCharSet ) );
+        rFont.SetFamily( ImplFamilyToSal( rLogFont.lfPitchAndFamily ) );
+        rFont.SetPitch( ImplLogPitchToSal( rLogFont.lfPitchAndFamily ) );
+        rFont.SetWeight( ImplWeightToSal( rLogFont.lfWeight ) );
+
+        tools::Long nFontHeight = rLogFont.lfHeight;
+        if ( nFontHeight < 0 )
+            nFontHeight = -nFontHeight;
+        tools::Long nDPIY = GetDeviceCaps( hDC, LOGPIXELSY );
+        if( !nDPIY )
+            nDPIY = 600;
+        nFontHeight *= 72;
+        nFontHeight += nDPIY/2;
+        nFontHeight /= nDPIY;
+        rFont.SetFontSize( Size( 0, nFontHeight ) );
+        rFont.SetOrientation( Degree10(static_cast<sal_Int16>(rLogFont.lfEscapement)) );
+        if ( rLogFont.lfItalic )
+            rFont.SetItalic( ITALIC_NORMAL );
+        else
+            rFont.SetItalic( ITALIC_NONE );
+        if ( rLogFont.lfUnderline )
+            rFont.SetUnderline( LINESTYLE_SINGLE );
+        else
+            rFont.SetUnderline( LINESTYLE_NONE );
+        if ( rLogFont.lfStrikeOut )
+            rFont.SetStrikeout( STRIKEOUT_SINGLE );
+        else
+            rFont.SetStrikeout( STRIKEOUT_NONE );
+    }
+}
+
+WinFontFace::WinFontFace( const FontAttributes& rDFS,
+    BYTE eWinCharSet, BYTE nPitchAndFamily )
+:   vcl::font::PhysicalFontFace( rDFS ),
+    mnId( 0 ),
+    mbFontCapabilitiesRead( false ),
+    meWinCharSet( eWinCharSet ),
+    mnPitchAndFamily( nPitchAndFamily ),
+    mbAliasSymbolsHigh( false ),
+    mbAliasSymbolsLow( false )
+{
+    if( eWinCharSet == SYMBOL_CHARSET )
+    {
+        if( (nPitchAndFamily & TMPF_TRUETYPE) != 0 )
+        {
+            // truetype fonts need their symbols as U+F0xx
+            mbAliasSymbolsHigh = true;
+        }
+        else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_DEVICE))
+                                 == (TMPF_VECTOR|TMPF_DEVICE) )
+        {
+            // scalable device fonts (e.g. builtin printer fonts)
+            // need their symbols as U+00xx
+            mbAliasSymbolsLow  = true;
+        }
+        else if( (nPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE)) == 0 )
+        {
+            // bitmap fonts need their symbols as U+F0xx
+            mbAliasSymbolsHigh = true;
+        }
+    }
+}
+
+WinFontFace::~WinFontFace()
+{
+    mxUnicodeMap.clear();
+}
+
+sal_IntPtr WinFontFace::GetFontId() const
+{
+    return mnId;
+}
+
+rtl::Reference<LogicalFontInstance> WinFontFace::CreateFontInstance(const vcl::font::FontSelectPattern& rFSD) const
+{
+#if HAVE_FEATURE_SKIA
+    if (SkiaHelper::isVCLSkiaEnabled())
+        return new SkiaWinFontInstance(*this, rFSD);
+#endif
+    return new WinFontInstance(*this, rFSD);
+}
+
+static DWORD CalcTag( const char p[5]) { return (p[0]+(p[1]<<8)+(p[2]<<16)+(p[3]<<24)); }
+
+void WinFontFace::UpdateFromHDC( HDC hDC ) const
+{
+    // short circuit if already initialized
+    if( mxUnicodeMap.is() )
+        return;
+
+    ReadCmapTable( hDC );
+    GetFontCapabilities( hDC );
+}
+
+FontCharMapRef WinFontFace::GetFontCharMap() const
+{
+    return mxUnicodeMap;
+}
+
+bool WinFontFace::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
+{
+    rFontCapabilities = maFontCapabilities;
+    return rFontCapabilities.oUnicodeRange || rFontCapabilities.oCodePageRange;
+}
+
+void WinFontFace::ReadCmapTable( HDC hDC ) const
+{
+    if( mxUnicodeMap.is() )
+        return;
+
+    bool bIsSymbolFont = (meWinCharSet == SYMBOL_CHARSET);
+    // get the CMAP table from the font which is selected into the DC
+    const DWORD nCmapTag = CalcTag( "cmap" );
+    const RawFontData aRawFontData( hDC, nCmapTag );
+    // parse the CMAP table if available
+    if( aRawFontData.get() ) {
+        CmapResult aResult;
+        ParseCMAP( aRawFontData.get(), aRawFontData.size(), aResult );
+        aResult.mbSymbolic = bIsSymbolFont;
+        if( aResult.mnRangeCount > 0 )
+        {
+            FontCharMapRef pUnicodeMap(new FontCharMap(aResult));
+            mxUnicodeMap = pUnicodeMap;
+        }
+    }
+
+    if( !mxUnicodeMap.is() )
+    {
+        mxUnicodeMap = FontCharMap::GetDefaultMap( bIsSymbolFont );
+    }
+}
+
+void WinFontFace::GetFontCapabilities( HDC hDC ) const
+{
+    // read this only once per font
+    if( mbFontCapabilitiesRead )
+        return;
+
+    mbFontCapabilitiesRead = true;
+
+    // OS/2 table
+    const DWORD OS2Tag = CalcTag( "OS/2" );
+    DWORD nLength = ::GetFontData( hDC, OS2Tag, 0, nullptr, 0 );
+    if( (nLength != GDI_ERROR) && nLength )
+    {
+        std::vector<unsigned char> aTable( nLength );
+        unsigned char* pTable = aTable.data();
+        ::GetFontData( hDC, OS2Tag, 0, pTable, nLength );
+        vcl::getTTCoverage(maFontCapabilities.oUnicodeRange, maFontCapabilities.oCodePageRange, pTable, nLength);
+    }
+}
+
+void WinSalGraphics::SetTextColor( Color nColor )
+{
+    COLORREF aCol = PALETTERGB( nColor.GetRed(),
+                                nColor.GetGreen(),
+                                nColor.GetBlue() );
+
+    if( !mbPrinter &&
+        GetSalData()->mhDitherPal &&
+        ImplIsSysColorEntry( nColor ) )
+    {
+        aCol = PALRGB_TO_RGB( aCol );
+    }
+
+    ::SetTextColor( getHDC(), aCol );
+}
+
+static int CALLBACK SalEnumQueryFontProcExW( const LOGFONTW*, const TEXTMETRICW*, DWORD, LPARAM lParam )
+{
+    *reinterpret_cast<bool*>(lParam) = true;
+    return 0;
+}
+
+void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern& rFont,
+                                   const vcl::font::PhysicalFontFace* pFontFace,
+                                   LOGFONTW& rLogFont )
+{
+    OUString aName;
+    if (pFontFace)
+        aName = pFontFace->GetFamilyName();
+    else
+        aName = rFont.GetFamilyName().getToken( 0, ';' );
+
+    UINT nNameLen = aName.getLength();
+    if (nNameLen >= LF_FACESIZE)
+        nNameLen = LF_FACESIZE - 1;
+    memcpy( rLogFont.lfFaceName, aName.getStr(), nNameLen*sizeof( wchar_t ) );
+    rLogFont.lfFaceName[nNameLen] = 0;
+
+    if  (pFontFace)
+    {
+        const WinFontFace* pWinFontData = static_cast<const WinFontFace*>(pFontFace);
+        rLogFont.lfCharSet = pWinFontData->GetCharSet();
+        rLogFont.lfPitchAndFamily = pWinFontData->GetPitchAndFamily();
+    }
+    else
+    {
+        rLogFont.lfCharSet = rFont.IsSymbolFont() ? SYMBOL_CHARSET : DEFAULT_CHARSET;
+        rLogFont.lfPitchAndFamily = ImplPitchToWin( rFont.GetPitch() )
+                                  | ImplFamilyToWin( rFont.GetFamilyType() );
+    }
+
+    rLogFont.lfWeight          = ImplWeightToWin( rFont.GetWeight() );
+    rLogFont.lfHeight          = static_cast<LONG>(-rFont.mnHeight);
+    rLogFont.lfWidth           = static_cast<LONG>(rFont.mnWidth);
+    rLogFont.lfUnderline       = 0;
+    rLogFont.lfStrikeOut       = 0;
+    rLogFont.lfItalic          = BYTE(rFont.GetItalic() != ITALIC_NONE);
+    rLogFont.lfEscapement      = rFont.mnOrientation.get();
+    rLogFont.lfOrientation     = rLogFont.lfEscapement;
+    rLogFont.lfClipPrecision   = CLIP_DEFAULT_PRECIS;
+    rLogFont.lfQuality         = DEFAULT_QUALITY;
+    rLogFont.lfOutPrecision    = OUT_TT_PRECIS;
+    if ( rFont.mnOrientation )
+        rLogFont.lfClipPrecision |= CLIP_LH_ANGLES;
+
+    // disable antialiasing if requested
+    if ( rFont.mbNonAntialiased )
+        rLogFont.lfQuality = NONANTIALIASED_QUALITY;
+
+}
+
+std::tuple<HFONT,bool,sal_Int32> WinSalGraphics::ImplDoSetFont(HDC hDC, vcl::font::FontSelectPattern const & i_rFont,
+                                    const vcl::font::PhysicalFontFace * i_pFontFace,
+                                    HFONT& o_rOldFont)
+{
+    HFONT hNewFont = nullptr;
+
+    LOGFONTW aLogFont;
+    ImplGetLogFontFromFontSelect( i_rFont, i_pFontFace, aLogFont );
+
+    bool    bIsCJKVerticalFont = false;
+    // select vertical mode for printing if requested and available
+    if ( i_rFont.mbVertical && mbPrinter )
+    {
+        constexpr size_t nLen = sizeof(aLogFont.lfFaceName) - sizeof(aLogFont.lfFaceName[0]);
+        // vertical fonts start with an '@'
+        memmove( &aLogFont.lfFaceName[1], &aLogFont.lfFaceName[0], nLen );
+        aLogFont.lfFaceName[0] = '@';
+        aLogFont.lfFaceName[LF_FACESIZE - 1] = 0;
+
+        // check availability of vertical mode for this font
+        EnumFontFamiliesExW( getHDC(), &aLogFont, SalEnumQueryFontProcExW,
+                reinterpret_cast<LPARAM>(&bIsCJKVerticalFont), 0 );
+        if( !bIsCJKVerticalFont )
+        {
+            // restore non-vertical name if not vertical mode isn't available
+            memcpy( &aLogFont.lfFaceName[0], &aLogFont.lfFaceName[1], nLen );
+            aLogFont.lfFaceName[LF_FACESIZE - 1] = 0;
+        }
+    }
+
+    hNewFont = ::CreateFontIndirectW( &aLogFont );
+
+    HDC hdcScreen = nullptr;
+    if( mbVirDev )
+        // only required for virtual devices, see below for details
+        hdcScreen = GetDC(nullptr);
+    if( hdcScreen )
+    {
+        // select font into screen hdc first to get an antialiased font
+        // and instantly restore the default font!
+        // see knowledge base article 305290:
+        // "PRB: Fonts Not Drawn Antialiased on Device Context for DirectDraw Surface"
+        SelectFont( hdcScreen, SelectFont( hdcScreen , hNewFont ) );
+    }
+    o_rOldFont = ::SelectFont(hDC, hNewFont);
+
+    TEXTMETRICW aTextMetricW;
+    if (!::GetTextMetricsW(hDC, &aTextMetricW))
+    {
+        // the selected font doesn't work => try a replacement
+        // TODO: use its font fallback instead
+        lstrcpynW( aLogFont.lfFaceName, L"Courier New", 12 );
+        aLogFont.lfPitchAndFamily = FIXED_PITCH;
+        HFONT hNewFont2 = CreateFontIndirectW( &aLogFont );
+        SelectFont(hDC, hNewFont2);
+        DeleteFont( hNewFont );
+        hNewFont = hNewFont2;
+        bIsCJKVerticalFont = false;
+    }
+
+    if( hdcScreen )
+        ::ReleaseDC( nullptr, hdcScreen );
+
+    return std::make_tuple(hNewFont, bIsCJKVerticalFont, static_cast<sal_Int32>(aTextMetricW.tmDescent));
+}
+
+void WinSalGraphics::SetFont(LogicalFontInstance* pFont, int nFallbackLevel)
+{
+    assert(nFallbackLevel >= 0 && nFallbackLevel < MAX_FALLBACK);
+
+    // return early if there is no new font
+    if( !pFont )
+    {
+        if (!mpWinFontEntry[nFallbackLevel].is())
+            return;
+
+        // DeInitGraphics doesn't free the cached fonts, so mhDefFont might be nullptr
+        if (mhDefFont)
+        {
+            ::SelectFont(getHDC(), mhDefFont);
+            mhDefFont = nullptr;
+        }
+
+        // release no longer referenced font handles
+        for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
+            mpWinFontEntry[i] = nullptr;
+        return;
+    }
+
+    WinFontInstance *pFontInstance = static_cast<WinFontInstance*>(pFont);
+    mpWinFontEntry[ nFallbackLevel ] = pFontInstance;
+
+    HFONT hOldFont = nullptr;
+    HFONT hNewFont = pFontInstance->GetHFONT();
+    if (!hNewFont)
+    {
+        pFontInstance->SetGraphics(this);
+        hNewFont = pFontInstance->GetHFONT();
+    }
+    hOldFont = ::SelectFont(getHDC(), hNewFont);
+
+    // keep default font
+    if( !mhDefFont )
+        mhDefFont = hOldFont;
+    else
+    {
+        // release no longer referenced font handles
+        for( int i = nFallbackLevel + 1; i < MAX_FALLBACK && mpWinFontEntry[i].is(); ++i )
+            mpWinFontEntry[i] = nullptr;
+    }
+
+    // now the font is live => update font face
+    const WinFontFace* pFontFace = pFontInstance->GetFontFace();
+    pFontFace->UpdateFromHDC(getHDC());
+}
+
+void WinSalGraphics::GetFontMetric( ImplFontMetricDataRef& rxFontMetric, int nFallbackLevel )
+{
+    // temporarily change the HDC to the font in the fallback level
+    rtl::Reference<WinFontInstance> pFontInstance = mpWinFontEntry[nFallbackLevel];
+    const HFONT hOldFont = SelectFont(getHDC(), pFontInstance->GetHFONT());
+
+    wchar_t aFaceName[LF_FACESIZE+60];
+    if( GetTextFaceW( getHDC(), SAL_N_ELEMENTS(aFaceName), aFaceName ) )
+        rxFontMetric->SetFamilyName(OUString(o3tl::toU(aFaceName)));
+
+    rxFontMetric->SetMinKashida(pFontInstance->GetKashidaWidth());
+    rxFontMetric->ImplCalcLineSpacing(pFontInstance.get());
+    rxFontMetric->ImplInitBaselines(pFontInstance.get());
+
+    // get the font metric
+    OUTLINETEXTMETRICW aOutlineMetric;
+    const bool bOK = GetOutlineTextMetricsW(getHDC(), sizeof(aOutlineMetric), &aOutlineMetric);
+    // restore the HDC to the font in the base level
+    SelectFont( getHDC(), hOldFont );
+    if( !bOK )
+        return;
+
+    TEXTMETRICW aWinMetric = aOutlineMetric.otmTextMetrics;
+
+    // device independent font attributes
+    rxFontMetric->SetFamilyType(ImplFamilyToSal( aWinMetric.tmPitchAndFamily ));
+    rxFontMetric->SetSymbolFlag(aWinMetric.tmCharSet == SYMBOL_CHARSET);
+    rxFontMetric->SetWeight(ImplWeightToSal( aWinMetric.tmWeight ));
+    rxFontMetric->SetPitch(ImplMetricPitchToSal( aWinMetric.tmPitchAndFamily ));
+    rxFontMetric->SetItalic(aWinMetric.tmItalic ? ITALIC_NORMAL : ITALIC_NONE);
+    rxFontMetric->SetSlant( 0 );
+
+    // transformation dependent font metrics
+    rxFontMetric->SetWidth(static_cast<int>(pFontInstance->GetScale() * aWinMetric.tmAveCharWidth));
+}
+
+FontCharMapRef WinSalGraphics::GetFontCharMap() const
+{
+    if (!mpWinFontEntry[0])
+    {
+        return FontCharMapRef( new FontCharMap() );
+    }
+    return mpWinFontEntry[0]->GetFontFace()->GetFontCharMap();
+}
+
+bool WinSalGraphics::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
+{
+    if (!mpWinFontEntry[0])
+        return false;
+    return mpWinFontEntry[0]->GetFontFace()->GetFontCapabilities(rFontCapabilities);
+}
+
+static int CALLBACK SalEnumFontsProcExW( const LOGFONTW* lpelfe,
+                                  const TEXTMETRICW* lpntme,
+                                  DWORD nFontType, LPARAM lParam )
+{
+    ENUMLOGFONTEXW const * pLogFont
+        = reinterpret_cast<ENUMLOGFONTEXW const *>(lpelfe);
+    NEWTEXTMETRICEXW const * pMetric
+        = reinterpret_cast<NEWTEXTMETRICEXW const *>(lpntme);
+    ImplEnumInfo* pInfo = reinterpret_cast<ImplEnumInfo*>(lParam);
+    if ( !pInfo->mpName )
+    {
+        // Ignore vertical fonts
+        if ( pLogFont->elfLogFont.lfFaceName[0] != '@' )
+        {
+            OUString aName(o3tl::toU(pLogFont->elfLogFont.lfFaceName));
+            pInfo->mpName = &aName;
+            memcpy(pInfo->mpLogFont->lfFaceName, pLogFont->elfLogFont.lfFaceName, (aName.getLength()+1)*sizeof(wchar_t));
+            pInfo->mpLogFont->lfCharSet = pLogFont->elfLogFont.lfCharSet;
+            EnumFontFamiliesExW(pInfo->mhDC, pInfo->mpLogFont, SalEnumFontsProcExW,
+                                reinterpret_cast<LPARAM>(pInfo), 0);
+            pInfo->mpLogFont->lfFaceName[0] = '\0';
+            pInfo->mpLogFont->lfCharSet = DEFAULT_CHARSET;
+            pInfo->mpName = nullptr;
+        }
+    }
+    else
+    {
+        // Ignore non-device fonts on printers.
+        if (pInfo->mbPrinter)
+        {
+            if ((nFontType & RASTER_FONTTYPE) && !(nFontType & DEVICE_FONTTYPE))
+            {
+                SAL_INFO("vcl.fonts", "Unsupported printer font ignored: " << OUString(o3tl::toU(pLogFont->elfLogFont.lfFaceName)));
+                return 1;
+            }
+        }
+        // Only SFNT fonts are supported, ignore anything else.
+        else if (!(nFontType & TRUETYPE_FONTTYPE) &&
+                 !(pMetric->ntmTm.ntmFlags & NTM_PS_OPENTYPE) &&
+                 !(pMetric->ntmTm.ntmFlags & NTM_TT_OPENTYPE))
+        {
+            SAL_INFO("vcl.fonts", "Unsupported font ignored: " << OUString(o3tl::toU(pLogFont->elfLogFont.lfFaceName)));
+            return 1;
+        }
+
+        rtl::Reference<WinFontFace> pData = ImplLogMetricToDevFontDataW(pLogFont, &(pMetric->ntmTm));
+        pData->SetFontId( sal_IntPtr( pInfo->mnFontCount++ ) );
+
+        pInfo->mpList->Add( pData.get() );
+        SAL_INFO("vcl.fonts", "SalEnumFontsProcExW: font added: " << pData->GetFamilyName() << " " << pData->GetStyleName());
+    }
+
+    return 1;
+}
+
+struct TempFontItem
+{
+    OUString maFontResourcePath;
+    TempFontItem* mpNextItem;
+};
+
+static int lcl_AddFontResource(SalData& rSalData, const OUString& rFontFileURL, bool bShared)
+{
+    OUString aFontSystemPath;
+    OSL_VERIFY(!osl::FileBase::getSystemPathFromFileURL(rFontFileURL, aFontSystemPath));
+
+    int nRet = AddFontResourceExW(o3tl::toW(aFontSystemPath.getStr()), FR_PRIVATE, nullptr);
+    SAL_WARN_IF(nRet <= 0, "vcl.fonts", "AddFontResourceExW failed for " << rFontFileURL);
+    if (nRet > 0)
+    {
+        TempFontItem* pNewItem = new TempFontItem;
+        pNewItem->maFontResourcePath = aFontSystemPath;
+        if (bShared)
+        {
+            pNewItem->mpNextItem = rSalData.mpSharedTempFontItem;
+            rSalData.mpSharedTempFontItem = pNewItem;
+        }
+        else
+        {
+            pNewItem->mpNextItem = rSalData.mpOtherTempFontItem;
+            rSalData.mpOtherTempFontItem = pNewItem;
+        }
+    }
+    return nRet;
+}
+
+void ImplReleaseTempFonts(SalData& rSalData, bool bAll)
+{
+    while (TempFontItem* p = rSalData.mpOtherTempFontItem)
+    {
+        RemoveFontResourceExW(o3tl::toW(p->maFontResourcePath.getStr()), FR_PRIVATE, nullptr);
+        rSalData.mpOtherTempFontItem = p->mpNextItem;
+        delete p;
+    }
+
+    if (!bAll)
+        return;
+
+    while (TempFontItem* p = rSalData.mpSharedTempFontItem)
+    {
+        RemoveFontResourceExW(o3tl::toW(p->maFontResourcePath.getStr()), FR_PRIVATE, nullptr);
+        rSalData.mpSharedTempFontItem = p->mpNextItem;
+        delete p;
+    }
+}
+
+static OUString lcl_GetFontFamilyName(std::u16string_view rFontFileURL)
+{
+    // Create temporary file name
+    OUString aTempFileURL;
+    if (osl::File::E_None != osl::File::createTempFile(nullptr, nullptr, &aTempFileURL))
+        return OUString();
+    osl::File::remove(aTempFileURL);
+    OUString aResSystemPath;
+    osl::FileBase::getSystemPathFromFileURL(aTempFileURL, aResSystemPath);
+
+    // Create font resource file (.fot)
+    // There is a limit of 127 characters for the full path passed via lpszFile, so we have to
+    // split the font URL and pass it as two parameters. As a result we can't use
+    // CreateScalableFontResource for renaming, as it now expects the font in the system path.
+    // But it's still good to use it for family name extraction, we're currently after.
+    // BTW: it doesn't help to prefix the lpszFile with \\?\ to support larger paths.
+    // TODO: use TTLoadEmbeddedFont (needs an EOT as input, so we have to add a header to the TTF)
+    // TODO: forward the EOT from the AddTempDevFont call side, if VCL supports it
+    INetURLObject aTTFUrl(rFontFileURL);
+    // GetBase() strips the extension
+    OUString aFilename = aTTFUrl.GetLastName(INetURLObject::DecodeMechanism::WithCharset);
+    if (!CreateScalableFontResourceW(0, o3tl::toW(aResSystemPath.getStr()),
+            o3tl::toW(aFilename.getStr()), o3tl::toW(aTTFUrl.GetPath().getStr())))
+    {
+        sal_uInt32 nError = GetLastError();
+        SAL_WARN("vcl.fonts", "CreateScalableFontResource failed for " << aResSystemPath << " "
+                              << aFilename << " " << aTTFUrl.GetPath() << " " << nError);
+        return OUString();
+    }
+
+    // Open and read the font resource file
+    osl::File aFotFile(aTempFileURL);
+    if (osl::FileBase::E_None != aFotFile.open(osl_File_OpenFlag_Read))
+        return OUString();
+
+    sal_uInt64  nBytesRead = 0;
+    char        aBuffer[4096];
+    aFotFile.read( aBuffer, sizeof( aBuffer ), nBytesRead );
+    // clean up temporary resource file
+    aFotFile.close();
+    osl::File::remove(aTempFileURL);
+
+    // retrieve font family name from byte offset 0x4F6
+    static const sal_uInt64 nNameOfs = 0x4F6;
+    sal_uInt64 nPos = nNameOfs;
+    for (; (nPos < nBytesRead) && (aBuffer[nPos] != 0); nPos++);
+    if (nPos >= nBytesRead || (nPos == nNameOfs))
+        return OUString();
+
+    return OUString(aBuffer + nNameOfs, nPos - nNameOfs, osl_getThreadTextEncoding());
+}
+
+bool WinSalGraphics::AddTempDevFont(vcl::font::PhysicalFontCollection* pFontCollection,
+                                    const OUString& rFontFileURL, const OUString& rFontName)
+{
+    OUString aFontFamily = lcl_GetFontFamilyName(rFontFileURL);
+    if (aFontFamily.isEmpty())
+    {
+        SAL_WARN("vcl.fonts", "error extracting font family from " << rFontFileURL);
+        return false;
+    }
+
+    if (rFontName != aFontFamily)
+    {
+        SAL_WARN("vcl.fonts", "font family renaming not implemented; skipping embedded " << rFontName);
+        return false;
+    }
+
+    int nFonts = lcl_AddFontResource(*GetSalData(), rFontFileURL, false);
+    if (nFonts <= 0)
+        return false;
+
+    ImplEnumInfo aInfo;
+    aInfo.mhDC = getHDC();
+    aInfo.mpList = pFontCollection;
+    aInfo.mpName = &aFontFamily;
+    aInfo.mbPrinter = mbPrinter;
+    aInfo.mnFontCount = pFontCollection->Count();
+    const int nExpectedFontCount = aInfo.mnFontCount + nFonts;
+
+    LOGFONTW aLogFont = {};
+    aLogFont.lfCharSet = DEFAULT_CHARSET;
+    aInfo.mpLogFont = &aLogFont;
+
+    // add the font to the PhysicalFontCollection
+    EnumFontFamiliesExW(getHDC(), &aLogFont,
+        SalEnumFontsProcExW, reinterpret_cast<LPARAM>(&aInfo), 0);
+
+    SAL_WARN_IF(nExpectedFontCount != pFontCollection->Count(), "vcl.fonts",
+        "temp font was registered but is not in enumeration: " << rFontFileURL);
+
+    return true;
+}
+
+void WinSalGraphics::GetDevFontList( vcl::font::PhysicalFontCollection* pFontCollection )
+{
+    // make sure all LO shared fonts are registered temporarily
+    static std::once_flag init;
+    std::call_once(init, []()
+    {
+        auto registerFontsIn = [](const OUString& dir) {
+            // collect fonts in font path that could not be registered
+            osl::Directory aFontDir(dir);
+            osl::FileBase::RC rcOSL = aFontDir.open();
+            if (rcOSL == osl::FileBase::E_None)
+            {
+                osl::DirectoryItem aDirItem;
+                SalData* pSalData = GetSalData();
+                assert(pSalData);
+
+                while (aFontDir.getNextItem(aDirItem, 10) == osl::FileBase::E_None)
+                {
+                    osl::FileStatus aFileStatus(osl_FileStatus_Mask_FileURL);
+                    rcOSL = aDirItem.getFileStatus(aFileStatus);
+                    if (rcOSL == osl::FileBase::E_None)
+                        lcl_AddFontResource(*pSalData, aFileStatus.getFileURL(), true);
+                }
+            }
+        };
+
+        // determine font path
+        // since we are only interested in fonts that could not be
+        // registered before because of missing administration rights
+        // only the font path of the user installation is needed
+        OUString aPath("$BRAND_BASE_DIR");
+        rtl_bootstrap_expandMacros(&aPath.pData);
+
+        // internal font resources, required for normal operation, like OpenSymbol
+        registerFontsIn(aPath + "/" LIBO_SHARE_RESOURCE_FOLDER "/common/fonts");
+
+        // collect fonts in font path that could not be registered
+        registerFontsIn(aPath + "/" LIBO_SHARE_FOLDER "/fonts/truetype");
+
+        return true;
+    });
+
+    ImplEnumInfo aInfo;
+    aInfo.mhDC          = getHDC();
+    aInfo.mpList        = pFontCollection;
+    aInfo.mpName        = nullptr;
+    aInfo.mbPrinter     = mbPrinter;
+    aInfo.mnFontCount   = 0;
+
+    LOGFONTW aLogFont = {};
+    aLogFont.lfCharSet = DEFAULT_CHARSET;
+    aInfo.mpLogFont = &aLogFont;
+
+    // fill the PhysicalFontCollection
+    EnumFontFamiliesExW( getHDC(), &aLogFont,
+        SalEnumFontsProcExW, reinterpret_cast<LPARAM>(&aInfo), 0 );
+
+    // set glyph fallback hook
+    static WinGlyphFallbackSubstititution aSubstFallback;
+    static WinPreMatchFontSubstititution aPreMatchFont;
+    pFontCollection->SetFallbackHook( &aSubstFallback );
+    pFontCollection->SetPreMatchHook(&aPreMatchFont);
+}
+
+void WinSalGraphics::ClearDevFontCache()
+{
+    WinSalGraphicsImplBase* pImpl = dynamic_cast<WinSalGraphicsImplBase*>(GetImpl());
+    assert(pImpl != nullptr);
+    pImpl->ClearDevFontCache();
+    ImplReleaseTempFonts(*GetSalData(), false);
+}
+
+bool WinFontInstance::ImplGetGlyphBoundRect(sal_GlyphId nId, tools::Rectangle& rRect, bool bIsVertical) const
+{
+    assert(m_pGraphics);
+    HDC hDC = m_pGraphics->getHDC();
+    const HFONT hOrigFont = static_cast<HFONT>(GetCurrentObject(hDC, OBJ_FONT));
+    const HFONT hFont = GetHFONT();
+    if (hFont != hOrigFont)
+        SelectObject(hDC, hFont);
+
+    const ::comphelper::ScopeGuard aFontRestoreScopeGuard([hFont, hOrigFont, hDC]()
+        { if (hFont != hOrigFont) SelectObject(hDC, hOrigFont); });
+    const float fFontScale = GetScale();
+
+    // use unity matrix
+    MAT2 aMat;
+    const vcl::font::FontSelectPattern& rFSD = GetFontSelectPattern();
+
+    // Use identity matrix for fonts requested in horizontal
+    // writing (LTR or RTL), or rotated glyphs in vertical writing.
+    if (!rFSD.mbVertical || !bIsVertical)
+    {
+        aMat.eM11 = aMat.eM22 = FixedFromDouble(1.0);
+        aMat.eM12 = aMat.eM21 = FixedFromDouble(0.0);
+    }
+    else
+    {
+        constexpr double nCos = 0.0;
+        constexpr double nSin = 1.0;
+        aMat.eM11 = FixedFromDouble(nCos);
+        aMat.eM12 = FixedFromDouble(nSin);
+        aMat.eM21 = FixedFromDouble(-nSin);
+        aMat.eM22 = FixedFromDouble(nCos);
+    }
+
+    UINT nGGOFlags = GGO_METRICS;
+    nGGOFlags |= GGO_GLYPH_INDEX;
+
+    GLYPHMETRICS aGM;
+    aGM.gmptGlyphOrigin.x = aGM.gmptGlyphOrigin.y = 0;
+    aGM.gmBlackBoxX = aGM.gmBlackBoxY = 0;
+    DWORD nSize = ::GetGlyphOutlineW(hDC, nId, nGGOFlags, &aGM, 0, nullptr, &aMat);
+    if (nSize == GDI_ERROR)
+        return false;
+
+    rRect = tools::Rectangle( Point( +aGM.gmptGlyphOrigin.x, -aGM.gmptGlyphOrigin.y ),
+        Size( aGM.gmBlackBoxX, aGM.gmBlackBoxY ) );
+    rRect.SetLeft(static_cast<int>( fFontScale * rRect.Left() ));
+    rRect.SetRight(static_cast<int>( fFontScale * rRect.Right() ) + 1);
+    rRect.SetTop(static_cast<int>( fFontScale * rRect.Top() ));
+    rRect.SetBottom(static_cast<int>( fFontScale * rRect.Bottom() ) + 1);
+    return true;
+}
+
+bool WinFontInstance::GetGlyphOutline(sal_GlyphId nId, basegfx::B2DPolyPolygon& rB2DPolyPoly, bool) const
+{
+    rB2DPolyPoly.clear();
+
+    assert(m_pGraphics);
+    HDC hDC = m_pGraphics->getHDC();
+    const HFONT hOrigFont = static_cast<HFONT>(GetCurrentObject(hDC, OBJ_FONT));
+    const HFONT hFont = GetHFONT();
+    if (hFont != hOrigFont)
+        SelectObject(hDC, hFont);
+
+    const ::comphelper::ScopeGuard aFontRestoreScopeGuard([hFont, hOrigFont, hDC]()
+        { if (hFont != hOrigFont) SelectObject(hDC, hOrigFont); });
+
+    // use unity matrix
+    MAT2 aMat;
+    aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
+    aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );
+
+    UINT nGGOFlags = GGO_NATIVE;
+    nGGOFlags |= GGO_GLYPH_INDEX;
+
+    GLYPHMETRICS aGlyphMetrics;
+    const DWORD nSize1 = ::GetGlyphOutlineW(hDC, nId, nGGOFlags, &aGlyphMetrics, 0, nullptr, &aMat);
+    if( !nSize1 )       // blank glyphs are ok
+        return true;
+    else if( nSize1 == GDI_ERROR )
+        return false;
+
+    BYTE* pData = new BYTE[ nSize1 ];
+    const DWORD nSize2 = ::GetGlyphOutlineW(hDC, nId, nGGOFlags,
+              &aGlyphMetrics, nSize1, pData, &aMat );
+
+    if( nSize1 != nSize2 )
+        return false;
+
+    // TODO: avoid tools polygon by creating B2DPolygon directly
+    int     nPtSize = 512;
+    Point*  pPoints = new Point[ nPtSize ];
+    PolyFlags* pFlags = new PolyFlags[ nPtSize ];
+
+    TTPOLYGONHEADER* pHeader = reinterpret_cast<TTPOLYGONHEADER*>(pData);
+    while( reinterpret_cast<BYTE*>(pHeader) < pData+nSize2 )
+    {
+        // only outline data is interesting
+        if( pHeader->dwType != TT_POLYGON_TYPE )
+            break;
+
+        // get start point; next start points are end points
+        // of previous segment
+        sal_uInt16 nPnt = 0;
+
+        tools::Long nX = IntTimes256FromFixed( pHeader->pfxStart.x );
+        tools::Long nY = IntTimes256FromFixed( pHeader->pfxStart.y );
+        pPoints[ nPnt ] = Point( nX, nY );
+        pFlags[ nPnt++ ] = PolyFlags::Normal;
+
+        bool bHasOfflinePoints = false;
+        TTPOLYCURVE* pCurve = reinterpret_cast<TTPOLYCURVE*>( pHeader + 1 );
+        pHeader = reinterpret_cast<TTPOLYGONHEADER*>( reinterpret_cast<BYTE*>(pHeader) + pHeader->cb );
+        while( reinterpret_cast<BYTE*>(pCurve) < reinterpret_cast<BYTE*>(pHeader) )
+        {
+            int nNeededSize = nPnt + 16 + 3 * pCurve->cpfx;
+            if( nPtSize < nNeededSize )
+            {
+                Point* pOldPoints = pPoints;
+                PolyFlags* pOldFlags = pFlags;
+                nPtSize = 2 * nNeededSize;
+                pPoints = new Point[ nPtSize ];
+                pFlags = new PolyFlags[ nPtSize ];
+                for( sal_uInt16 i = 0; i < nPnt; ++i )
+                {
+                    pPoints[ i ] = pOldPoints[ i ];
+                    pFlags[ i ] = pOldFlags[ i ];
+                }
+                delete[] pOldPoints;
+                delete[] pOldFlags;
+            }
+
+            int i = 0;
+            if( TT_PRIM_LINE == pCurve->wType )
+            {
+                while( i < pCurve->cpfx )
+                {
+                    nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
+                    nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
+                    ++i;
+                    pPoints[ nPnt ] = Point( nX, nY );
+                    pFlags[ nPnt ] = PolyFlags::Normal;
+                    ++nPnt;
+                }
+            }
+            else if( TT_PRIM_QSPLINE == pCurve->wType )
+            {
+                bHasOfflinePoints = true;
+                while( i < pCurve->cpfx )
+                {
+                    // get control point of quadratic bezier spline
+                    nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
+                    nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
+                    ++i;
+                    Point aControlP( nX, nY );
+
+                    // calculate first cubic control point
+                    // P0 = 1/3 * (PBeg + 2 * PQControl)
+                    nX = pPoints[ nPnt-1 ].X() + 2 * aControlP.X();
+                    nY = pPoints[ nPnt-1 ].Y() + 2 * aControlP.Y();
+                    pPoints[ nPnt+0 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
+                    pFlags[ nPnt+0 ] = PolyFlags::Control;
+
+                    // calculate endpoint of segment
+                    nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
+                    nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
+
+                    if ( i+1 >= pCurve->cpfx )
+                    {
+                        // endpoint is either last point in segment => advance
+                        ++i;
+                    }
+                    else
+                    {
+                        // or endpoint is the middle of two control points
+                        nX += IntTimes256FromFixed( pCurve->apfx[ i-1 ].x );
+                        nY += IntTimes256FromFixed( pCurve->apfx[ i-1 ].y );
+                        nX = (nX + 1) / 2;
+                        nY = (nY + 1) / 2;
+                        // no need to advance, because the current point
+                        // is the control point in next bezier spline
+                    }
+
+                    pPoints[ nPnt+2 ] = Point( nX, nY );
+                    pFlags[ nPnt+2 ] = PolyFlags::Normal;
+
+                    // calculate second cubic control point
+                    // P1 = 1/3 * (PEnd + 2 * PQControl)
+                    nX = pPoints[ nPnt+2 ].X() + 2 * aControlP.X();
+                    nY = pPoints[ nPnt+2 ].Y() + 2 * aControlP.Y();
+                    pPoints[ nPnt+1 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
+                    pFlags[ nPnt+1 ] = PolyFlags::Control;
+
+                    nPnt += 3;
+                }
+            }
+
+            // next curve segment
+            pCurve = reinterpret_cast<TTPOLYCURVE*>(&pCurve->apfx[ i ]);
+        }
+
+        // end point is start point for closed contour
+        // disabled, because Polygon class closes the contour itself
+        // pPoints[nPnt++] = pPoints[0];
+        // #i35928#
+        // Added again, but add only when not yet closed
+        if(pPoints[nPnt - 1] != pPoints[0])
+        {
+            if( bHasOfflinePoints )
+                pFlags[nPnt] = pFlags[0];
+
+            pPoints[nPnt++] = pPoints[0];
+        }
+
+        // convert y-coordinates W32 -> VCL
+        for( int i = 0; i < nPnt; ++i )
+            pPoints[i].setY(-pPoints[i].Y());
+
+        // insert into polypolygon
+        tools::Polygon aPoly( nPnt, pPoints, (bHasOfflinePoints ? pFlags : nullptr) );
+        // convert to B2DPolyPolygon
+        // TODO: get rid of the intermediate PolyPolygon
+        rB2DPolyPoly.append( aPoly.getB2DPolygon() );
+    }
+
+    delete[] pPoints;
+    delete[] pFlags;
+
+    delete[] pData;
+
+    // rescaling needed for the tools::PolyPolygon conversion
+    if( rB2DPolyPoly.count() )
+    {
+        const double fFactor(GetScale()/256);
+        rB2DPolyPoly.transform(basegfx::utils::createScaleB2DHomMatrix(fFactor, fFactor));
+    }
+
+    return true;
+}
+
+namespace {
+
+class ScopedFontHDC final
+{
+public:
+    explicit ScopedFontHDC(WinSalGraphics& rGraphics, const vcl::font::PhysicalFontFace& rFontFace)
+        // use height=1000 for easier debugging (to match psprint's font units)
+        : m_aFSP(rFontFace, Size(0,1000), 1000.0, 0, false)
+        , m_hDC(nullptr)
+        , m_hOrigFont(nullptr)
+    {
+        m_hDC = CreateCompatibleDC(rGraphics.getHDC());
+        if (!m_hDC)
+            return;
+
+        rGraphics.ImplDoSetFont(m_hDC, m_aFSP, &rFontFace, m_hOrigFont);
+    }
+
+    ~ScopedFontHDC()
+    {
+        if (m_hOrigFont)
+            ::DeleteFont(SelectFont(m_hDC, m_hOrigFont));
+        if (m_hDC)
+            DeleteDC(m_hDC);
+    }
+
+    HDC hdc() const { return m_hDC; }
+    const vcl::font::FontSelectPattern& fsp() const { return m_aFSP; }
+
+private:
+    vcl::font::FontSelectPattern m_aFSP;
+    HDC m_hDC;
+    HFONT m_hOrigFont;
+};
+
+class ScopedTrueTypeFont
+{
+public:
+    ScopedTrueTypeFont(): m_pFont(nullptr) {}
+
+    ~ScopedTrueTypeFont();
+
+    SFErrCodes open(void const * pBuffer, sal_uInt32 nLen, sal_uInt32 nFaceNum, const FontCharMapRef xCharMap = nullptr);
+
+    TrueTypeFont * get() const { return m_pFont; }
+
+private:
+    TrueTypeFont * m_pFont;
+};
+
+}
+
+ScopedTrueTypeFont::~ScopedTrueTypeFont()
+{
+    if (m_pFont != nullptr)
+        CloseTTFont(m_pFont);
+}
+
+SFErrCodes ScopedTrueTypeFont::open(void const * pBuffer, sal_uInt32 nLen,
+                             sal_uInt32 nFaceNum, const FontCharMapRef xCharMap)
+{
+    OSL_ENSURE(m_pFont == nullptr, "already open");
+    return OpenTTFontBuffer(pBuffer, nLen, nFaceNum, &m_pFont, xCharMap);
+}
+
+bool WinSalGraphics::CreateFontSubset( const OUString& rToFile,
+    const vcl::font::PhysicalFontFace* pFont, const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
+    sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
+{
+    ScopedFontHDC aScopedFontHDC(*this, *pFont);
+    HDC hDC = aScopedFontHDC.hdc();
+    if (!hDC)
+        return false;
+
+#if OSL_DEBUG_LEVEL > 1
+    // get font metrics
+    TEXTMETRICW aWinMetric;
+    if (!::GetTextMetricsW(hDC, &aWinMetric))
+        return false;
+
+    SAL_WARN_IF( (aWinMetric.tmPitchAndFamily & TMPF_DEVICE), "vcl", "cannot subset device font" );
+    SAL_WARN_IF( !(aWinMetric.tmPitchAndFamily & TMPF_TRUETYPE), "vcl", "can only subset TT font" );
+#endif
+
+    OUString aSysPath;
+    if( osl_File_E_None != osl_getSystemPathFromFileURL( rToFile.pData, &aSysPath.pData ) )
+        return false;
+    const rtl_TextEncoding aThreadEncoding = osl_getThreadTextEncoding();
+    const OString aToFile(OUStringToOString(aSysPath, aThreadEncoding));
+
+    // check if the font has a CFF-table
+    const DWORD nCffTag = CalcTag( "CFF " );
+    const RawFontData aRawCffData(hDC, nCffTag);
+    if (aRawCffData.get())
+        return SalGraphics::CreateCFFfontSubset(aRawCffData.get(), aRawCffData.size(), aToFile,
+                                                pGlyphIds, pEncoding, pGlyphWidths, nGlyphCount,
+                                                rInfo);
+
+    // get raw font file data
+    const RawFontData xRawFontData(hDC, 0);
+    if( !xRawFontData.get() )
+        return false;
+
+    // open font file
+    sal_uInt32 nFaceNum = 0;
+    if( !*xRawFontData.get() )  // TTC candidate
+        nFaceNum = ~0U;  // indicate "TTC font extracts only"
+
+    ScopedTrueTypeFont aSftTTF;
+    SFErrCodes nRC = aSftTTF.open( xRawFontData.get(), xRawFontData.size(), nFaceNum, pFont->GetFontCharMap());
+    if( nRC != SFErrCodes::Ok )
+        return false;
+
+    TTGlobalFontInfo aTTInfo;
+    ::GetTTGlobalFontInfo( aSftTTF.get(), &aTTInfo );
+    OUString aPSName = ImplSalGetUniString(aTTInfo.psname);
+    FillFontSubsetInfo(aTTInfo, aPSName, rInfo);
+
+    // write subset into destination file
+    return SalGraphics::CreateTTFfontSubset(*aSftTTF.get(), aToFile, aScopedFontHDC.fsp().mbVertical,
+                                            pGlyphIds, pEncoding, pGlyphWidths, nGlyphCount);
+}
+
+const void* WinSalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen)
+{
+    ScopedFontHDC aScopedFontHDC(*this, *pFont);
+    HDC hDC = aScopedFontHDC.hdc();
+    if (!hDC)
+        return nullptr;
+
+    // get the raw font file data
+    RawFontData aRawFontData(hDC);
+    *pDataLen = aRawFontData.size();
+    return aRawFontData.get() ? aRawFontData.steal() : nullptr;
+}
+
+void WinSalGraphics::FreeEmbedFontData( const void* pData, tools::Long /*nLen*/ )
+{
+    delete[] static_cast<char const *>(pData);
+}
+
+void WinSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
+                                     bool bVertical,
+                                     std::vector< sal_Int32 >& rWidths,
+                                     Ucs2UIntMap& rUnicodeEnc )
+{
+    ScopedFontHDC aScopedFontHDC(*this, *pFont);
+    HDC hDC = aScopedFontHDC.hdc();
+    if (!hDC)
+        return;
+
+    // get raw font file data
+    const RawFontData xRawFontData(hDC);
+    if( !xRawFontData.get() )
+        return;
+
+    // open font file
+    sal_uInt32 nFaceNum = 0;
+    if( !*xRawFontData.get() )  // TTC candidate
+        nFaceNum = ~0U;  // indicate "TTC font extracts only"
+
+    ScopedTrueTypeFont aSftTTF;
+    SFErrCodes nRC = aSftTTF.open(xRawFontData.get(), xRawFontData.size(), nFaceNum, pFont->GetFontCharMap());
+    if( nRC != SFErrCodes::Ok )
+        return;
+
+    SalGraphics::GetGlyphWidths(*aSftTTF.get(), *pFont, bVertical, rWidths, rUnicodeEnc);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */