vcl: test PhysicalFontFace and move to vcl::font namespace

- moved PhysicalFontFace.hxx to vcl/inc/font
- added PhysicalFontFace to vcl::font namespace
- had to regenerate precompiled_vcl.hxx
- tested PhysicalFontFace, with some extensive tests for
IsBetterMatch()

Change-Id: I860022ac244f8a827f6f9cb7ed9018c5d9c328cb
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/121970
Tested-by: Jenkins
Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com>

59 files changed, 516 insertions, 170 deletions

diff --git a/include/vcl/metric.hxx b/include/vcl/metric.hxx
index 7d5ddfd055fa..a89e8eedfb0c 100644
--- a/include/vcl/metric.hxx
+++ b/include/vcl/metric.hxx
@@ -28,7 +28,7 @@
 #include <vcl/font.hxx>
 
 class FontCharMap;
-class PhysicalFontFace;
+namespace vcl::font { class PhysicalFontFace; }
 
 typedef tools::SvRef<FontCharMap> FontCharMapRef;
 
@@ -37,7 +37,7 @@ class VCL_DLLPUBLIC FontMetric : public vcl::Font
 public:
     explicit            FontMetric();
                         FontMetric( const FontMetric& );  // TODO make this explicit
-                        FontMetric(PhysicalFontFace const& rFace);
+                        FontMetric(vcl::font::PhysicalFontFace const& rFace);
                         ~FontMetric() override;
 
     tools::Long                GetAscent() const                           { return mnAscent; }
diff --git a/include/vcl/vcllayout.hxx b/include/vcl/vcllayout.hxx
index 3b6254869f1b..34acb2fe733e 100644
--- a/include/vcl/vcllayout.hxx
+++ b/include/vcl/vcllayout.hxx
@@ -24,13 +24,14 @@
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <tools/gen.hxx>
 #include <tools/degree.hxx>
+
 #include <vcl/devicecoordinate.hxx>
 #include <vcl/glyphitem.hxx>
 #include <vcl/dllapi.h>
 
 class LogicalFontInstance;
 namespace vcl::text { class ImplLayoutArgs; }
-class PhysicalFontFace;
+namespace vcl::font { class PhysicalFontFace; }
 class SalGraphics;
 class GlyphItem;
 
@@ -93,7 +94,7 @@ public:
     // methods using glyph indexing
     virtual bool    GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart,
                                  const LogicalFontInstance** ppGlyphFont = nullptr,
-                                 const PhysicalFontFace** pFallbackFont = nullptr) const = 0;
+                                 const vcl::font::PhysicalFontFace** pFallbackFont = nullptr) const = 0;
     virtual bool GetOutline(basegfx::B2DPolyPolygonVector&) const;
     bool GetBoundRect(tools::Rectangle&) const;
 
diff --git a/solenv/clang-format/excludelist b/solenv/clang-format/excludelist
index 6d590cd53040..9240bffc7064 100644
--- a/solenv/clang-format/excludelist
+++ b/solenv/clang-format/excludelist
@@ -14420,7 +14420,6 @@ vcl/headless/svpvd.cxx
 vcl/inc/IconThemeSelector.hxx
 vcl/inc/IPrioritable.hxx
 vcl/inc/PhysicalFontCollection.hxx
-vcl/inc/PhysicalFontFace.hxx
 vcl/inc/PhysicalFontFamily.hxx
 vcl/inc/ResampleKernel.hxx
 vcl/inc/WidgetThemeLibraryTypes.hxx
@@ -14440,6 +14439,7 @@ vcl/inc/dndlistenercontainer.hxx
 vcl/inc/factory.hxx
 vcl/inc/fltcall.hxx
 vcl/inc/font/FontSelectPattern.hxx
+vcl/inc/font/PhysicalFontFace.hxx
 vcl/inc/fontattributes.hxx
 vcl/inc/fontinstance.hxx
 vcl/inc/fontsubset.hxx
@@ -14940,6 +14940,7 @@ vcl/source/filter/wmf/emfwr.hxx
 vcl/source/filter/wmf/wmf.cxx
 vcl/source/filter/wmf/wmfwr.cxx
 vcl/source/filter/wmf/wmfwr.hxx
+vcl/source/font/FontSelectPattern.cxx
 vcl/source/font/PhysicalFontCollection.cxx
 vcl/source/font/PhysicalFontFace.cxx
 vcl/source/font/PhysicalFontFamily.cxx
@@ -14949,7 +14950,6 @@ vcl/source/font/fontcache.cxx
 vcl/source/font/fontcharmap.cxx
 vcl/source/font/fontinstance.cxx
 vcl/source/font/fontmetric.cxx
-vcl/source/font/fontselect.cxx
 vcl/source/fontsubset/cff.cxx
 vcl/source/fontsubset/fontsubset.cxx
 vcl/source/fontsubset/list.cxx
diff --git a/vcl/CppunitTest_vcl_font.mk b/vcl/CppunitTest_vcl_font.mk
index 456468557056..5c9da11d4f19 100644
--- a/vcl/CppunitTest_vcl_font.mk
+++ b/vcl/CppunitTest_vcl_font.mk
@@ -16,6 +16,7 @@ $(eval $(call gb_CppunitTest_set_include,vcl_font,\
 
 $(eval $(call gb_CppunitTest_add_exception_objects,vcl_font, \
 	vcl/qa/cppunit/font \
+	vcl/qa/cppunit/physicalfontface \
 	vcl/qa/cppunit/physicalfontfacecollection \
 	vcl/qa/cppunit/physicalfontfamily \
 ))
diff --git a/vcl/Library_vcl.mk b/vcl/Library_vcl.mk
index abd645216ab4..5c410de75bb0 100644
--- a/vcl/Library_vcl.mk
+++ b/vcl/Library_vcl.mk
@@ -473,12 +473,12 @@ $(eval $(call gb_Library_add_exception_objects,vcl,\
     vcl/source/font/Feature \
     vcl/source/font/FeatureCollector \
     vcl/source/font/FeatureParser \
+    vcl/source/font/FontSelectPattern \
     vcl/source/font/OpenTypeFeatureDefinitionList \
     vcl/source/font/PhysicalFontCollection \
     vcl/source/font/PhysicalFontFace \
     vcl/source/font/PhysicalFontFamily \
     vcl/source/font/fontattributes \
-    vcl/source/font/fontselect \
     vcl/source/font/fontinstance \
     vcl/source/font/fontcache \
     vcl/source/font/fontcharmap \
diff --git a/vcl/headless/svptext.cxx b/vcl/headless/svptext.cxx
index 4f64c7469aff..3822bac4070c 100644
--- a/vcl/headless/svptext.cxx
+++ b/vcl/headless/svptext.cxx
@@ -65,7 +65,7 @@ bool SvpSalGraphics::AddTempDevFont( PhysicalFontCollection* pFontCollection,
 
 bool SvpSalGraphics::CreateFontSubset(
     const OUString& rToFile,
-    const PhysicalFontFace* pFont,
+    const vcl::font::PhysicalFontFace* pFont,
     const sal_GlyphId* pGlyphIds,
     const sal_uInt8* pEncoding,
     sal_Int32* pWidths,
@@ -75,7 +75,7 @@ bool SvpSalGraphics::CreateFontSubset(
     return m_aTextRenderImpl.CreateFontSubset(rToFile, pFont, pGlyphIds, pEncoding, pWidths, nGlyphCount, rInfo);
 }
 
-const void* SvpSalGraphics::GetEmbedFontData(const PhysicalFontFace* pFont, tools::Long* pDataLen)
+const void* SvpSalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen)
 {
     return m_aTextRenderImpl.GetEmbedFontData(pFont, pDataLen);
 }
@@ -85,7 +85,7 @@ void SvpSalGraphics::FreeEmbedFontData( const void* pData, tools::Long nLen )
     m_aTextRenderImpl.FreeEmbedFontData(pData, nLen);
 }
 
-void SvpSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
+void SvpSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
                                    bool bVertical,
                                    std::vector< sal_Int32 >& rWidths,
                                    Ucs2UIntMap& rUnicodeEnc )
diff --git a/vcl/inc/PhysicalFontCollection.hxx b/vcl/inc/PhysicalFontCollection.hxx
index 79358d6a49ae..ee1fdad285c9 100644
--- a/vcl/inc/PhysicalFontCollection.hxx
+++ b/vcl/inc/PhysicalFontCollection.hxx
@@ -43,7 +43,7 @@ public:
                             ~PhysicalFontCollection();
 
     // fill the list with device font faces
-    void                    Add( PhysicalFontFace* );
+    void                    Add( vcl::font::PhysicalFontFace* );
     void                    Clear();
     int                     Count() const { return maPhysicalFontFamilies.size(); }
 
diff --git a/vcl/inc/font/FontSelectPattern.hxx b/vcl/inc/font/FontSelectPattern.hxx
index 077c1c941996..78be730130f1 100644
--- a/vcl/inc/font/FontSelectPattern.hxx
+++ b/vcl/inc/font/FontSelectPattern.hxx
@@ -36,6 +36,7 @@ class Size;
 
 namespace vcl::font
 {
+class PhysicalFontFace;
 
 class VCL_DLLPUBLIC FontSelectPattern : public FontAttributes
 {
diff --git a/vcl/inc/PhysicalFontFace.hxx b/vcl/inc/font/PhysicalFontFace.hxx
index c2743e4c1ca1..0fa71de0af44 100644
--- a/vcl/inc/PhysicalFontFace.hxx
+++ b/vcl/inc/font/PhysicalFontFace.hxx
@@ -28,7 +28,7 @@
 #include <vcl/dllapi.h>
 #include <vcl/fontcharmap.hxx>
 
-#include "fontattributes.hxx"
+#include <fontattributes.hxx>
 
 class LogicalFontInstance;
 struct FontMatchStatus;
@@ -44,6 +44,10 @@ struct FontCapabilities;
 class PhysicalFontFamily;
 }
 
+namespace vcl::font
+{
+class FontSelectPattern;
+
 struct FontMatchStatus
 {
 public:
@@ -53,7 +57,6 @@ public:
     const OUString*     mpTargetStyleName;
 };
 
-
 // TODO: no more direct access to members
 // TODO: get rid of height/width for scalable fonts
 // TODO: make cloning cheaper
@@ -80,6 +83,8 @@ protected:
     explicit PhysicalFontFace(const FontAttributes&);
 };
 
+}
+
 #endif // INCLUDED_VCL_INC_PHYSICALFONTFACE_HXX
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/font/PhysicalFontFaceCollection.hxx b/vcl/inc/font/PhysicalFontFaceCollection.hxx
index 9b4622690bfb..c9e3e64b6640 100644
--- a/vcl/inc/font/PhysicalFontFaceCollection.hxx
+++ b/vcl/inc/font/PhysicalFontFaceCollection.hxx
@@ -23,7 +23,7 @@
 
 #include <vcl/dllapi.h>
 
-#include <PhysicalFontFace.hxx>
+#include "PhysicalFontFace.hxx"
 
 #include <vector>
 
diff --git a/vcl/inc/font/PhysicalFontFamily.hxx b/vcl/inc/font/PhysicalFontFamily.hxx
index d807c4f648e5..a3c4d0b90a31 100644
--- a/vcl/inc/font/PhysicalFontFamily.hxx
+++ b/vcl/inc/font/PhysicalFontFamily.hxx
@@ -28,9 +28,6 @@
 
 #include <unotools/fontcfg.hxx>
 
-#include <PhysicalFontFace.hxx>
-
-class PhysicalFontFace;
 class PhysicalFontCollection;
 
 namespace vcl::font
@@ -59,6 +56,8 @@ struct typed_flags<vcl::font::FontTypeFaces> : is_typed_flags<vcl::font::FontTyp
 
 namespace vcl::font
 {
+class FontSelectPattern;
+class PhysicalFontFace;
 class PhysicalFontFaceCollection;
 
 class VCL_PLUGIN_PUBLIC PhysicalFontFamily
diff --git a/vcl/inc/fontinstance.hxx b/vcl/inc/fontinstance.hxx
index fa8fcba15806..aad22017e0d4 100644
--- a/vcl/inc/fontinstance.hxx
+++ b/vcl/inc/fontinstance.hxx
@@ -48,7 +48,7 @@ class VCL_PLUGIN_PUBLIC LogicalFontInstance : public salhelper::SimpleReferenceO
 {
     // just declaring the factory function doesn't work AKA
     // friend LogicalFontInstance* PhysicalFontFace::CreateFontInstance(const FontSelectPattern&) const;
-    friend class PhysicalFontFace;
+    friend class vcl::font::PhysicalFontFace;
     friend class ImplFontCache;
 
 public: // TODO: make data members private
@@ -72,8 +72,8 @@ public: // TODO: make data members private
     double GetAverageWidthFactor() const { return m_nAveWidthFactor; }
     const vcl::font::FontSelectPattern& GetFontSelectPattern() const { return m_aFontSelData; }
 
-    const PhysicalFontFace* GetFontFace() const { return m_pFontFace.get(); }
-    PhysicalFontFace* GetFontFace() { return m_pFontFace.get(); }
+    const vcl::font::PhysicalFontFace* GetFontFace() const { return m_pFontFace.get(); }
+    vcl::font::PhysicalFontFace* GetFontFace() { return m_pFontFace.get(); }
     const ImplFontCache* GetFontCache() const { return mpFontCache; }
 
     bool GetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const;
@@ -85,7 +85,7 @@ public: // TODO: make data members private
     static inline void DecodeOpenTypeTag(const uint32_t nTableTag, char* pTagName);
 
 protected:
-    explicit LogicalFontInstance(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
+    explicit LogicalFontInstance(const vcl::font::PhysicalFontFace&, const vcl::font::FontSelectPattern&);
 
     virtual bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const = 0;
 
@@ -103,7 +103,7 @@ private:
     const vcl::font::FontSelectPattern m_aFontSelData;
     hb_font_t* m_pHbFont;
     double m_nAveWidthFactor;
-    rtl::Reference<PhysicalFontFace> m_pFontFace;
+    rtl::Reference<vcl::font::PhysicalFontFace> m_pFontFace;
     std::optional<bool> m_xbIsGraphiteFont;
 };
 
diff --git a/vcl/inc/headless/svpgdi.hxx b/vcl/inc/headless/svpgdi.hxx
index 7be2f35e2cc1..e7c0c884e20f 100644
--- a/vcl/inc/headless/svpgdi.hxx
+++ b/vcl/inc/headless/svpgdi.hxx
@@ -31,6 +31,7 @@
 #include <vcl/sysdata.hxx>
 #include <config_cairo_canvas.h>
 
+#include <font/PhysicalFontFace.hxx>
 #include <salgdi.hxx>
 #include <sallayout.hxx>
 #include "svpcairotextrender.hxx"
@@ -183,16 +184,16 @@ public:
     virtual void ClearDevFontCache() override;
     virtual bool            AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
     virtual bool        CreateFontSubset( const OUString& rToFile,
-                                              const PhysicalFontFace*,
+                                              const vcl::font::PhysicalFontFace*,
                                               const sal_GlyphId* pGlyphIds,
                                               const sal_uInt8* pEncoding,
                                               sal_Int32* pWidths,
                                               int nGlyphs,
                                               FontSubsetInfo& rInfo
                                               ) override;
-    virtual const void*     GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
+    virtual const void*     GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen) override;
     virtual void            FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
-    virtual void            GetGlyphWidths( const PhysicalFontFace*,
+    virtual void            GetGlyphWidths( const vcl::font::PhysicalFontFace*,
                                             bool bVertical,
                                             std::vector< sal_Int32 >& rWidths,
                                             Ucs2UIntMap& rUnicodeEnc ) override;
diff --git a/vcl/inc/outdev.h b/vcl/inc/outdev.h
index 85b4ca601ac7..c9185bcc23fb 100644
--- a/vcl/inc/outdev.h
+++ b/vcl/inc/outdev.h
@@ -25,8 +25,8 @@
 #include <tools/gen.hxx>
 #include <vcl/vclptr.hxx>
 
+#include "font/PhysicalFontFace.hxx"
 #include "fontinstance.hxx"
-#include "PhysicalFontFace.hxx"
 #include "impfontcache.hxx"
 
 class Size;
diff --git a/vcl/inc/pch/precompiled_vcl.hxx b/vcl/inc/pch/precompiled_vcl.hxx
index b42d7e50c2f5..9fea18da7661 100644
--- a/vcl/inc/pch/precompiled_vcl.hxx
+++ b/vcl/inc/pch/precompiled_vcl.hxx
@@ -13,7 +13,7 @@
  manual changes will be rewritten by the next run of update_pch.sh (which presumably
  also fixes all possible problems, so it's usually better to use it).
 
- Generated on 2021-08-04 20:14:15 using:
+ Generated on 2021-09-21 16:33:04 using:
  ./bin/update_pch vcl vcl --cutoff=6 --exclude:system --include:module --include:local
 
  If after updating build fails, use the following command to locate conflicting headers:
@@ -33,9 +33,11 @@
 #include <deque>
 #include <float.h>
 #include <functional>
+#include <hb.h>
 #include <initializer_list>
 #include <iomanip>
 #include <limits>
+#include <list>
 #include <map>
 #include <math.h>
 #include <memory>
@@ -52,7 +54,6 @@
 #include <unordered_map>
 #include <utility>
 #include <vector>
-#include <boost/functional/hash.hpp>
 #include <boost/math/special_functions/sinc.hpp>
 #include <boost/multi_array.hpp>
 #include <boost/property_tree/json_parser.hpp>
@@ -80,6 +81,7 @@
 #include <rtl/bootstrap.hxx>
 #include <rtl/byteseq.hxx>
 #include <rtl/character.hxx>
+#include <rtl/cipher.h>
 #include <rtl/crc.h>
 #include <rtl/digest.h>
 #include <rtl/instance.hxx>
@@ -129,8 +131,6 @@
 #include <basegfx/vector/b2enums.hxx>
 #include <basegfx/vector/b2ivector.hxx>
 #include <bitmap/BitmapWriteAccess.hxx>
-#include <com/sun/star/awt/Key.hpp>
-#include <com/sun/star/awt/KeyGroup.hpp>
 #include <com/sun/star/beans/PropertyValue.hpp>
 #include <com/sun/star/datatransfer/DataFlavor.hpp>
 #include <com/sun/star/datatransfer/XTransferable2.hpp>
@@ -146,8 +146,13 @@
 #include <com/sun/star/embed/Aspects.hpp>
 #include <com/sun/star/frame/XTerminateListener.hpp>
 #include <com/sun/star/i18n/Calendar2.hpp>
+#include <com/sun/star/i18n/DirectionProperty.hpp>
+#include <com/sun/star/i18n/KCharacterType.hpp>
+#include <com/sun/star/i18n/NativeNumberXmlAttributes.hpp>
+#include <com/sun/star/i18n/ParseResult.hpp>
 #include <com/sun/star/i18n/TransliterationModules.hpp>
 #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
+#include <com/sun/star/i18n/UnicodeScript.hpp>
 #include <com/sun/star/lang/DisposedException.hpp>
 #include <com/sun/star/lang/EventObject.hpp>
 #include <com/sun/star/lang/Locale.hpp>
@@ -190,10 +195,14 @@
 #include <cppuhelper/weak.hxx>
 #include <cppuhelper/weakagg.hxx>
 #include <cppuhelper/weakref.hxx>
+#include <font/FontSelectPattern.hxx>
+#include <font/PhysicalFontFace.hxx>
+#include <font/PhysicalFontFaceCollection.hxx>
 #include <i18nlangtag/lang.h>
 #include <i18nlangtag/languagetag.hxx>
 #include <i18nlangtag/mslangid.hxx>
 #include <i18nutil/i18nutildllapi.h>
+#include <i18nutil/transliteration.hxx>
 #include <o3tl/cow_wrapper.hxx>
 #include <o3tl/safeint.hxx>
 #include <o3tl/sorted_vector.hxx>
@@ -246,18 +255,20 @@
 #include <uno/any2.h>
 #include <uno/data.h>
 #include <uno/sequence2.h>
+#include <unotools/calendarwrapper.hxx>
 #include <unotools/configmgr.hxx>
 #include <unotools/localedatawrapper.hxx>
+#include <unotools/resmgr.hxx>
 #include <unotools/syslocale.hxx>
 #include <unotools/ucbstreamhelper.hxx>
 #include <unotools/unotoolsdllapi.h>
 #endif // PCH_LEVEL >= 3
 #if PCH_LEVEL >= 4
 #include <PhysicalFontCollection.hxx>
-#include <PhysicalFontFace.hxx>
 #include <accel.hxx>
 #include <brdwin.hxx>
 #include <configsettings.hxx>
+#include <drawmode.hxx>
 #include <fontattributes.hxx>
 #include <impglyphitem.hxx>
 #include <outdev.h>
@@ -303,6 +314,8 @@
 #include <vcl/dllapi.h>
 #include <vcl/dockwin.hxx>
 #include <vcl/event.hxx>
+#include <vcl/filter/SvmReader.hxx>
+#include <vcl/filter/SvmWriter.hxx>
 #include <vcl/fntstyle.hxx>
 #include <vcl/font.hxx>
 #include <vcl/formatter.hxx>
@@ -354,6 +367,7 @@
 #include <vcl/unohelp.hxx>
 #include <vcl/vclenum.hxx>
 #include <vcl/vclevent.hxx>
+#include <vcl/vcllayout.hxx>
 #include <vcl/vclptr.hxx>
 #include <vcl/virdev.hxx>
 #include <vcl/weld.hxx>
diff --git a/vcl/inc/pdf/pdfbuildin_fonts.hxx b/vcl/inc/pdf/pdfbuildin_fonts.hxx
index 88629be914c3..fbcc04a9e6fa 100644
--- a/vcl/inc/pdf/pdfbuildin_fonts.hxx
+++ b/vcl/inc/pdf/pdfbuildin_fonts.hxx
@@ -21,7 +21,7 @@
 
 #include <sal/config.h>
 
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <fontinstance.hxx>
 
 namespace vcl::pdf
@@ -52,12 +52,12 @@ class BuildinFontInstance final : public LogicalFontInstance
     bool ImplGetGlyphBoundRect(sal_GlyphId nID, tools::Rectangle& rRect, bool) const override;
 
 public:
-    BuildinFontInstance(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
+    BuildinFontInstance(const vcl::font::PhysicalFontFace&, const vcl::font::FontSelectPattern&);
 
     bool GetGlyphOutline(sal_GlyphId nId, basegfx::B2DPolyPolygon& rPoly, bool) const override;
 };
 
-class BuildinFontFace final : public PhysicalFontFace
+class BuildinFontFace final : public vcl::font::PhysicalFontFace
 {
     static const BuildinFont m_aBuildinFonts[14];
     const BuildinFont& mrBuildin;
diff --git a/vcl/inc/pdf/pdffontcache.hxx b/vcl/inc/pdf/pdffontcache.hxx
index 094652fefe89..a6b58d8e7b00 100644
--- a/vcl/inc/pdf/pdffontcache.hxx
+++ b/vcl/inc/pdf/pdffontcache.hxx
@@ -37,7 +37,7 @@ namespace vcl
             bool            m_bVertical;
             std::type_info* m_typeFontFace;
 
-            FontIdentifier( const PhysicalFontFace*, bool bVertical );
+            FontIdentifier( const vcl::font::PhysicalFontFace*, bool bVertical );
 
             // Less than needed for std::set and std::map
             bool operator<( const FontIdentifier& rRight ) const
@@ -60,11 +60,11 @@ namespace vcl
         std::vector< FontData >     m_aFonts;
         FontToIndexMap              m_aFontToIndex;
 
-        FontData& getFont( const PhysicalFontFace*, bool bVertical );
+        FontData& getFont( const vcl::font::PhysicalFontFace*, bool bVertical );
         public:
         PDFFontCache() {}
 
-        sal_Int32 getGlyphWidth( const PhysicalFontFace*, sal_GlyphId, bool bVertical, SalGraphics* );
+        sal_Int32 getGlyphWidth( const vcl::font::PhysicalFontFace*, sal_GlyphId, bool bVertical, SalGraphics* );
     };
 }
 
diff --git a/vcl/inc/pdf/pdfwriter_impl.hxx b/vcl/inc/pdf/pdfwriter_impl.hxx
index 21c2b799654b..c3f63be2693d 100644
--- a/vcl/inc/pdf/pdfwriter_impl.hxx
+++ b/vcl/inc/pdf/pdfwriter_impl.hxx
@@ -64,7 +64,7 @@ class FontSubsetInfo;
 class ZCodec;
 class EncHashTransporter;
 struct BitStreamState;
-class PhysicalFontFace;
+namespace vcl::font { class PhysicalFontFace; }
 class SvStream;
 class SvMemoryStream;
 
@@ -721,8 +721,8 @@ private:
     std::vector< TilingEmit >           m_aTilings;
     std::vector< TransparencyEmit >     m_aTransparentObjects;
     /*  contains all font subsets in use */
-    std::map<const PhysicalFontFace*, FontSubset> m_aSubsets;
-    std::map<const PhysicalFontFace*, EmbedFont> m_aSystemFonts;
+    std::map<const vcl::font::PhysicalFontFace*, FontSubset> m_aSubsets;
+    std::map<const vcl::font::PhysicalFontFace*, EmbedFont> m_aSystemFonts;
     sal_Int32                           m_nNextFID;
     PDFFontCache                        m_aFontCache;
 
@@ -807,7 +807,7 @@ i12626
     void appendLiteralStringEncrypt( std::string_view rInString, const sal_Int32 nInObjectNumber, OStringBuffer& rOutBuffer );
 
     /* creates fonts and subsets that will be emitted later */
-    void registerGlyph(const GlyphItem* pGlyph, const PhysicalFontFace* pFont, const std::vector<sal_Ucs>& rCodeUnits, sal_uInt8& nMappedGlyph, sal_Int32& nMappedFontObject);
+    void registerGlyph(const GlyphItem* pGlyph, const vcl::font::PhysicalFontFace* pFont, const std::vector<sal_Ucs>& rCodeUnits, sal_uInt8& nMappedGlyph, sal_Int32& nMappedFontObject);
 
     /*  emits a text object according to the passed layout */
     /* TODO: remove rText as soon as SalLayout will change so that rText is not necessary anymore */
@@ -852,9 +852,9 @@ i12626
     /* writes a builtin font object and returns its objectid (or 0 in case of failure ) */
     sal_Int32 emitBuildinFont( const pdf::BuildinFontFace*, sal_Int32 nObject );
     /* writes a type1 system font object and returns its mapping from font ids to object ids (or 0 in case of failure ) */
-    std::map< sal_Int32, sal_Int32 > emitSystemFont( const PhysicalFontFace*, EmbedFont const & );
+    std::map< sal_Int32, sal_Int32 > emitSystemFont(const vcl::font::PhysicalFontFace*, EmbedFont const &);
     /* writes a font descriptor and returns its object id (or 0) */
-    sal_Int32 emitFontDescriptor( const PhysicalFontFace*, FontSubsetInfo const &, sal_Int32 nSubsetID, sal_Int32 nStream );
+    sal_Int32 emitFontDescriptor(const vcl::font::PhysicalFontFace*, FontSubsetInfo const &, sal_Int32 nSubsetID, sal_Int32 nStream);
     /* writes a ToUnicode cmap, returns the corresponding stream object */
     sal_Int32 createToUnicodeCMap( sal_uInt8 const * pEncoding, const sal_Ucs* pCodeUnits, const sal_Int32* pCodeUnitsPerGlyph,
                                    const sal_Int32* pEncToUnicodeIndex, int nGlyphs );
diff --git a/vcl/inc/qt5/QtFont.hxx b/vcl/inc/qt5/QtFont.hxx
index f2b250f33d18..237523e2d10a 100644
--- a/vcl/inc/qt5/QtFont.hxx
+++ b/vcl/inc/qt5/QtFont.hxx
@@ -37,7 +37,7 @@ class QtFont final : public QFont, public LogicalFontInstance
 
     virtual hb_font_t* ImplInitHbFont() override;
 
-    explicit QtFont(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
+    explicit QtFont(const vcl::font::PhysicalFontFace&, const vcl::font::FontSelectPattern&);
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/qt5/QtFontFace.hxx b/vcl/inc/qt5/QtFontFace.hxx
index 6089a18b38c2..5b0460443e90 100644
--- a/vcl/inc/qt5/QtFontFace.hxx
+++ b/vcl/inc/qt5/QtFontFace.hxx
@@ -22,7 +22,7 @@
 #include <sal/config.h>
 
 #include <vclpluginapi.h>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 
 #include <tools/ref.hxx>
 #include <vcl/fontcapabilities.hxx>
@@ -37,7 +37,7 @@ namespace vcl::font
 class FontSelectPattern;
 }
 
-class QtFontFace final : public PhysicalFontFace
+class QtFontFace final : public vcl::font::PhysicalFontFace
 {
 public:
     static QtFontFace* fromQFont(const QFont& rFont);
diff --git a/vcl/inc/qt5/QtGraphics.hxx b/vcl/inc/qt5/QtGraphics.hxx
index db08f8418844..a285f07bb353 100644
--- a/vcl/inc/qt5/QtGraphics.hxx
+++ b/vcl/inc/qt5/QtGraphics.hxx
@@ -228,16 +228,17 @@ public:
     virtual void ClearDevFontCache() override;
     virtual bool AddTempDevFont(PhysicalFontCollection*, const OUString& rFileURL,
                                 const OUString& rFontName) override;
-    virtual bool CreateFontSubset(const OUString& rToFile, const PhysicalFontFace* pFont,
+    virtual bool CreateFontSubset(const OUString& rToFile, const vcl::font::PhysicalFontFace* pFont,
                                   const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
                                   sal_Int32* pWidths, int nGlyphs,
                                   FontSubsetInfo& rInfo // out parameter
                                   ) override;
 
-    virtual const void* GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
+    virtual const void* GetEmbedFontData(const vcl::font::PhysicalFontFace*,
+                                         tools::Long* pDataLen) override;
     virtual void FreeEmbedFontData(const void* pData, tools::Long nDataLen) override;
 
-    virtual void GetGlyphWidths(const PhysicalFontFace*, bool bVertical,
+    virtual void GetGlyphWidths(const vcl::font::PhysicalFontFace*, bool bVertical,
                                 std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc) override;
 
     virtual std::unique_ptr<GenericSalLayout> GetTextLayout(int nFallbackLevel) override;
diff --git a/vcl/inc/quartz/salgdi.h b/vcl/inc/quartz/salgdi.h
index ffffe7f9a1f5..4210499c52d9 100644
--- a/vcl/inc/quartz/salgdi.h
+++ b/vcl/inc/quartz/salgdi.h
@@ -44,7 +44,7 @@
 
 #include <fontinstance.hxx>
 #include <impfontmetricdata.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <salgdi.hxx>
 
 #include <quartz/salgdicommon.hxx>
@@ -58,7 +58,7 @@ class FontAttributes;
 class XorEmulation;
 
 // CoreText-specific physically available font face
-class CoreTextFontFace : public PhysicalFontFace
+class CoreTextFontFace : public vcl::font::PhysicalFontFace
 {
 public:
                                     CoreTextFontFace( const FontAttributes&, sal_IntPtr nFontID );
@@ -102,7 +102,7 @@ public:
     bool mbFauxBold;
 
 private:
-    explicit CoreTextStyle(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
+    explicit CoreTextStyle(const vcl::font::PhysicalFontFace&, const vcl::font::FontSelectPattern&);
 
     hb_font_t* ImplInitHbFont() override;
     bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override;
@@ -552,7 +552,7 @@ public:
     // implementation note: encoding 0 with glyph id 0 should be added implicitly
     // as "undefined character"
     virtual bool            CreateFontSubset( const OUString& rToFile,
-                                                  const PhysicalFontFace* pFont,
+                                                  const vcl::font::PhysicalFontFace* pFont,
                                                   const sal_GlyphId* pGlyphIds,
                                                   const sal_uInt8* pEncoding,
                                                   sal_Int32* pWidths,
@@ -564,12 +564,12 @@ public:
     // embeddable by GetDevFontList or NULL in case of error
     // parameters: pFont: describes the font in question
     //             pDataLen: out parameter, contains the byte length of the returned buffer
-    virtual const void*     GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen)
+    virtual const void*     GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen)
         override;
     // frees the font data again
     virtual void            FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
 
-    virtual void            GetGlyphWidths( const PhysicalFontFace*,
+    virtual void            GetGlyphWidths( const vcl::font::PhysicalFontFace*,
                                             bool bVertical,
                                             std::vector< sal_Int32 >& rWidths,
                                             Ucs2UIntMap& rUnicodeEnc ) override;
@@ -582,7 +582,7 @@ public:
                             GetGraphicsData() const override;
 
 private:
-    static bool             GetRawFontData( const PhysicalFontFace* pFontData,
+    static bool             GetRawFontData( const vcl::font::PhysicalFontFace* pFontData,
                                 std::vector<unsigned char>& rBuffer,
                                 bool* pJustCFF );
 };
diff --git a/vcl/inc/salgdi.hxx b/vcl/inc/salgdi.hxx
index 99b9a55eb855..3abfbd726eb4 100644
--- a/vcl/inc/salgdi.hxx
+++ b/vcl/inc/salgdi.hxx
@@ -38,7 +38,10 @@
 class PhysicalFontCollection;
 class SalBitmap;
 class FontAttributes;
-class PhysicalFontFace;
+namespace vcl::font {
+    class FontSelectPattern;
+    class PhysicalFontFace;
+}
 class SalLayout;
 namespace tools { class Rectangle; }
 class FontSubsetInfo;
@@ -173,7 +176,7 @@ public:
     // as "undefined character"
     virtual bool                CreateFontSubset(
                                     const OUString& rToFile,
-                                    const PhysicalFontFace* pFont,
+                                    const vcl::font::PhysicalFontFace* pFont,
                                     const sal_GlyphId* pGlyphIDs,
                                     const sal_uInt8* pEncoding,
                                     sal_Int32* pWidths,
@@ -184,7 +187,7 @@ public:
     // embeddable by GetDevFontList or NULL in case of error
     // parameters: pFont: describes the font in question
     //             pDataLen: out parameter, contains the byte length of the returned buffer
-    virtual const void*         GetEmbedFontData(const PhysicalFontFace* pFont, tools::Long* pDataLen) = 0;
+    virtual const void*         GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen) = 0;
 
     // free the font data again
     virtual void                FreeEmbedFontData( const void* pData, tools::Long nDataLen ) = 0;
@@ -194,7 +197,7 @@ public:
     // between unicode and glyph id
     // leave widths vector and mapping untouched in case of failure
     virtual void                GetGlyphWidths(
-                                    const PhysicalFontFace* pFont,
+                                    const vcl::font::PhysicalFontFace* pFont,
                                     bool bVertical,
                                     std::vector< sal_Int32 >& rWidths,
                                     Ucs2UIntMap& rUnicodeEnc ) = 0;
@@ -648,7 +651,7 @@ protected:
     vcl::WidgetDrawInterface* forWidget() { return m_pWidgetDraw ? m_pWidgetDraw.get() : this; }
 
     static void GetGlyphWidths(const vcl::AbstractTrueTypeFont& rTTF,
-                               const PhysicalFontFace& rFontFace, bool bVertical,
+                               const vcl::font::PhysicalFontFace& rFontFace, bool bVertical,
                                std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc);
 
     static bool CreateTTFfontSubset(vcl::AbstractTrueTypeFont& aTTF, const OString& rSysPath,
diff --git a/vcl/inc/sallayout.hxx b/vcl/inc/sallayout.hxx
index a3b33b6b3bc1..8dc16d9021c1 100644
--- a/vcl/inc/sallayout.hxx
+++ b/vcl/inc/sallayout.hxx
@@ -45,10 +45,14 @@
 
 #define MAX_FALLBACK 16
 
-class PhysicalFontFace;
 class GenericSalLayout;
 class SalGraphics;
 enum class SalLayoutFlags;
+
+namespace vcl::font {
+    class PhysicalFontFace;
+}
+
 namespace vcl::text {
     class TextLayoutCache;
 }
@@ -62,7 +66,7 @@ public:
     void            GetCaretPositions(int nArraySize, tools::Long* pCaretXArray) const override;
     bool            GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart,
                                  const LogicalFontInstance** ppGlyphFont = nullptr,
-                                 const PhysicalFontFace** pFallbackFont = nullptr) const override;
+                                 const vcl::font::PhysicalFontFace** pFallbackFont = nullptr) const override;
     bool            GetOutline(basegfx::B2DPolyPolygonVector&) const override;
     bool            IsKashidaPosValid(int nCharPos) const override;
     SalLayoutGlyphs GetGlyphs() const final override;
@@ -119,7 +123,7 @@ public:
 
     bool            GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart,
                                  const LogicalFontInstance** ppGlyphFont = nullptr,
-                                 const PhysicalFontFace** pFallbackFont = nullptr) const override;
+                                 const vcl::font::PhysicalFontFace** pFallbackFont = nullptr) const override;
 
     const SalLayoutGlyphsImpl& GlyphsImpl() const { return m_GlyphItems; }
 
diff --git a/vcl/inc/textrender.hxx b/vcl/inc/textrender.hxx
index aa2057ba62c1..7d9718b790a3 100644
--- a/vcl/inc/textrender.hxx
+++ b/vcl/inc/textrender.hxx
@@ -26,7 +26,7 @@
 
 class ImplFontMetricData;
 class PhysicalFontCollection;
-class PhysicalFontFace;
+namespace vcl::font { class PhysicalFontFace; }
 
 class TextRenderImpl
 {
@@ -45,17 +45,17 @@ public:
     virtual bool                    AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) = 0;
     virtual bool                    CreateFontSubset(
                                         const OUString& rToFile,
-                                        const PhysicalFontFace*,
+                                        const vcl::font::PhysicalFontFace*,
                                         const sal_GlyphId* pGlyphIDs,
                                         const sal_uInt8* pEncoding,
                                         sal_Int32* pWidths,
                                         int nGlyphs,
                                         FontSubsetInfo& rInfo) = 0;
 
-    virtual const void*             GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) = 0;
+    virtual const void*             GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen) = 0;
     virtual void                    FreeEmbedFontData( const void* pData, tools::Long nDataLen ) = 0;
     virtual void                    GetGlyphWidths(
-                                        const PhysicalFontFace*,
+                                        const vcl::font::PhysicalFontFace*,
                                         bool bVertical,
                                         std::vector< sal_Int32 >& rWidths,
                                         Ucs2UIntMap& rUnicodeEnc ) = 0;
diff --git a/vcl/inc/unx/cairotextrender.hxx b/vcl/inc/unx/cairotextrender.hxx
index 3879bf5d975d..c046b00c9e49 100644
--- a/vcl/inc/unx/cairotextrender.hxx
+++ b/vcl/inc/unx/cairotextrender.hxx
@@ -22,6 +22,8 @@
 
 #include <unx/freetypetextrender.hxx>
 
+class GenericSalLayout;
+class SalGraphics;
 typedef struct _cairo cairo_t;
 
 class VCL_DLLPUBLIC CairoTextRender : public FreeTypeTextRenderImpl
diff --git a/vcl/inc/unx/freetype_glyphcache.hxx b/vcl/inc/unx/freetype_glyphcache.hxx
index 285a1ddd4a2f..d7b71514cd69 100644
--- a/vcl/inc/unx/freetype_glyphcache.hxx
+++ b/vcl/inc/unx/freetype_glyphcache.hxx
@@ -22,7 +22,7 @@
 #include <sal/config.h>
 
 #include <unx/glyphcache.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <fontinstance.hxx>
 #include <vcl/glyphitem.hxx>
 
@@ -92,7 +92,7 @@ private:
     mutable FontCharMapRef mxFontCharMap;
 };
 
-class FreetypeFontFace : public PhysicalFontFace
+class FreetypeFontFace : public vcl::font::PhysicalFontFace
 {
 private:
     FreetypeFontInfo*             mpFreetypeFontInfo;
@@ -100,7 +100,7 @@ private:
 public:
                             FreetypeFontFace( FreetypeFontInfo*, const FontAttributes& );
 
-    virtual rtl::Reference<LogicalFontInstance> CreateFontInstance( const vcl::font::FontSelectPattern& ) const override;
+    virtual rtl::Reference<LogicalFontInstance> CreateFontInstance(const vcl::font::FontSelectPattern&) const override;
     virtual sal_IntPtr      GetFontId() const override { return mpFreetypeFontInfo->GetFontId(); }
 
     FontCharMapRef GetFontCharMap() const override { return mpFreetypeFontInfo->GetFontCharMap(); }
@@ -121,7 +121,7 @@ class SAL_DLLPUBLIC_RTTI FreetypeFontInstance final : public LogicalFontInstance
     virtual hb_font_t* ImplInitHbFont() override;
     virtual bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override;
 
-    explicit FreetypeFontInstance(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP);
+    explicit FreetypeFontInstance(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP);
 
 public:
     virtual ~FreetypeFontInstance() override;
diff --git a/vcl/inc/unx/freetypetextrender.hxx b/vcl/inc/unx/freetypetextrender.hxx
index 7866f966a196..6b17a15db06f 100644
--- a/vcl/inc/unx/freetypetextrender.hxx
+++ b/vcl/inc/unx/freetypetextrender.hxx
@@ -49,17 +49,17 @@ public:
     virtual bool                AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
     virtual bool                CreateFontSubset(
                                     const OUString& rToFile,
-                                    const PhysicalFontFace*,
+                                    const vcl::font::PhysicalFontFace*,
                                     const sal_GlyphId* pGlyphIDs,
                                     const sal_uInt8* pEncoding,
                                     sal_Int32* pWidths,
                                     int nGlyphs,
                                     FontSubsetInfo& rInfo) override;
 
-    virtual const void*         GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
+    virtual const void*         GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen) override;
     virtual void                FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
     virtual void                GetGlyphWidths(
-                                    const PhysicalFontFace*,
+                                    const vcl::font::PhysicalFontFace*,
                                     bool bVertical,
                                     std::vector< sal_Int32 >& rWidths,
                                     Ucs2UIntMap& rUnicodeEnc ) override;
diff --git a/vcl/inc/unx/genpspgraphics.h b/vcl/inc/unx/genpspgraphics.h
index cc8c346b862c..977083b948c2 100644
--- a/vcl/inc/unx/genpspgraphics.h
+++ b/vcl/inc/unx/genpspgraphics.h
@@ -30,7 +30,7 @@
 
 #include <unx/GenPspGfxBackend.hxx>
 
-class PhysicalFontFace;
+namespace vcl::font { class PhysicalFontFace; }
 class PhysicalFontCollection;
 
 namespace psp { struct JobData; class PrinterGfx; }
@@ -93,15 +93,15 @@ public:
                                                   const OUString& rFontName);
 
     virtual bool            CreateFontSubset( const OUString& rToFile,
-                                              const PhysicalFontFace*,
+                                              const vcl::font::PhysicalFontFace*,
                                               const sal_GlyphId* pGlyphIDs,
                                               const sal_uInt8* pEncoding,
                                               sal_Int32* pWidths,
                                               int nGlyphs,
                                               FontSubsetInfo& rInfo ) override;
-    virtual const void*     GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
+    virtual const void*     GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen) override;
     virtual void            FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
-    virtual void            GetGlyphWidths( const PhysicalFontFace*,
+    virtual void            GetGlyphWidths( const vcl::font::PhysicalFontFace*,
                                             bool bVertical,
                                             std::vector< sal_Int32 >& rWidths,
                                             Ucs2UIntMap& rUnicodeEnc ) override;
diff --git a/vcl/inc/unx/salgdi.h b/vcl/inc/unx/salgdi.h
index af6642010546..bc5653e05c41 100644
--- a/vcl/inc/unx/salgdi.h
+++ b/vcl/inc/unx/salgdi.h
@@ -51,7 +51,7 @@ class X11SalVirtualDevice;
 class X11SalGraphicsImpl;
 class X11SkiaSalVirtualDevice;
 class PhysicalFontCollection;
-class PhysicalFontFace;
+namespace vcl::font { class PhysicalFontFace; }
 class SalGraphicsImpl;
 class TextRenderImpl;
 
@@ -122,18 +122,18 @@ public:
 
     virtual bool                    CreateFontSubset(
                                         const OUString& rToFile,
-                                        const PhysicalFontFace*,
+                                        const vcl::font::PhysicalFontFace*,
                                         const sal_GlyphId* pGlyphIDs,
                                         const sal_uInt8* pEncoding,
                                         sal_Int32* pWidths,
                                         int nGlyphs,
                                         FontSubsetInfo& rInfo ) override;
 
-    virtual const void*             GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
+    virtual const void*             GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen) override;
     virtual void                    FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
 
     virtual void                    GetGlyphWidths(
-                                        const PhysicalFontFace*,
+                                        const vcl::font::PhysicalFontFace*,
                                         bool bVertical,
                                         std::vector< sal_Int32 >& rWidths,
                                         Ucs2UIntMap& rUnicodeEnc ) override;
diff --git a/vcl/inc/win/salgdi.h b/vcl/inc/win/salgdi.h
index 4ea2546b9ae3..f02eadf60c14 100644
--- a/vcl/inc/win/salgdi.h
+++ b/vcl/inc/win/salgdi.h
@@ -26,7 +26,7 @@
 #include <salgdi.hxx>
 #include <fontinstance.hxx>
 #include <fontattributes.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <impfont.hxx>
 #include <vcl/fontcapabilities.hxx>
 #include <vcl/fontcharmap.hxx>
@@ -58,7 +58,7 @@ class ImplFontMetricData;
 #define PALRGB_TO_RGB(nPalRGB)      ((nPalRGB)&0x00ffffff)
 
 // win32 specific physically available font face
-class WinFontFace : public PhysicalFontFace
+class WinFontFace : public vcl::font::PhysicalFontFace
 {
 public:
     explicit                WinFontFace( const FontAttributes&,
@@ -174,7 +174,7 @@ private:
     void DeInitGraphics();
 
 public:
-    HFONT ImplDoSetFont(vcl::font::FontSelectPattern const & i_rFont, const PhysicalFontFace * i_pFontFace, HFONT& o_rOldFont);
+    HFONT ImplDoSetFont(vcl::font::FontSelectPattern const & i_rFont, const vcl::font::PhysicalFontFace * i_pFontFace, HFONT& o_rOldFont);
 
     HDC getHDC() const { return mhLocalDC; }
     void setHDC(HDC aNew);
@@ -364,7 +364,7 @@ public:
     // implementation note: encoding 0 with glyph id 0 should be added implicitly
     // as "undefined character"
     virtual bool            CreateFontSubset( const OUString& rToFile,
-                                              const PhysicalFontFace*,
+                                              const vcl::font::PhysicalFontFace*,
                                               const sal_GlyphId* pGlyphIDs,
                                               const sal_uInt8* pEncoding,
                                               sal_Int32* pWidths,
@@ -376,10 +376,10 @@ public:
     // embeddable by GetDevFontList or NULL in case of error
     // parameters: pFont: describes the font in question
     //             pDataLen: out parameter, contains the byte length of the returned buffer
-    virtual const void* GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
+    virtual const void* GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* pDataLen) override;
     // frees the font data again
     virtual void            FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
-    virtual void            GetGlyphWidths( const PhysicalFontFace*,
+    virtual void            GetGlyphWidths( const vcl::font::PhysicalFontFace*,
                                             bool bVertical,
                                             std::vector< sal_Int32 >& rWidths,
                                             Ucs2UIntMap& rUnicodeEnc ) override;
@@ -400,7 +400,7 @@ public:
 void    ImplUpdateSysColorEntries();
 int     ImplIsSysColorEntry( Color nColor );
 void    ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern&,
-            const PhysicalFontFace*, LOGFONTW& );
+            const vcl::font::PhysicalFontFace*, LOGFONTW& );
 
 #define MAX_64KSALPOINTS    ((((sal_uInt16)0xFFFF)-8)/sizeof(POINTS))
 
diff --git a/vcl/qa/cppunit/fontmocks.hxx b/vcl/qa/cppunit/fontmocks.hxx
index 8f3ad6eba5f1..7367acab69ee 100644
--- a/vcl/qa/cppunit/fontmocks.hxx
+++ b/vcl/qa/cppunit/fontmocks.hxx
@@ -7,18 +7,20 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
+#pragma once
+
 #include <sal/config.h>
 
-#include <PhysicalFontFace.hxx>
+#include <font/FontSelectPattern.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <font/PhysicalFontFaceCollection.hxx>
 #include <fontattributes.hxx>
 #include <fontinstance.hxx>
-#include <font/FontSelectPattern.hxx>
 
 class TestFontInstance : public LogicalFontInstance
 {
 public:
-    TestFontInstance(PhysicalFontFace const& rFontFace,
+    TestFontInstance(vcl::font::PhysicalFontFace const& rFontFace,
                      vcl::font::FontSelectPattern const& rFontSelectPattern)
         : LogicalFontInstance(rFontFace, rFontSelectPattern)
     {
@@ -33,17 +35,17 @@ protected:
     bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override { return true; }
 };
 
-class TestFontFace : public PhysicalFontFace
+class TestFontFace : public vcl::font::PhysicalFontFace
 {
 public:
     TestFontFace(sal_uIntPtr nId)
-        : PhysicalFontFace(FontAttributes())
+        : vcl::font::PhysicalFontFace(FontAttributes())
         , mnFontId(nId)
     {
     }
 
     TestFontFace(FontAttributes const& rFontAttributes, sal_uIntPtr nId)
-        : PhysicalFontFace(rFontAttributes)
+        : vcl::font::PhysicalFontFace(rFontAttributes)
         , mnFontId(nId)
     {
     }
diff --git a/vcl/qa/cppunit/physicalfontface.cxx b/vcl/qa/cppunit/physicalfontface.cxx
new file mode 100644
index 000000000000..30fe616c1cd0
--- /dev/null
+++ b/vcl/qa/cppunit/physicalfontface.cxx
@@ -0,0 +1,301 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+
+#include <test/bootstrapfixture.hxx>
+#include <cppunit/TestAssert.h>
+
+#include <tools/degree.hxx>
+
+#include <vcl/font.hxx>
+
+#include <font/PhysicalFontFace.hxx>
+#include <fontattributes.hxx>
+
+#include "fontmocks.hxx"
+
+#include <memory>
+
+const sal_IntPtr FONTID = 1;
+
+class VclPhysicalFontFaceTest : public test::BootstrapFixture
+{
+public:
+    VclPhysicalFontFaceTest()
+        : BootstrapFixture(true, false)
+    {
+    }
+
+    void testShouldCompareAsLesserFontFaceWithShorterWidth();
+    void testShouldCompareAsGreaterFontFaceWithLongerWidth();
+    void testShouldCompareAsLesserFontFaceWithLighterWeight();
+    void testShouldCompareAsGreaterFontFaceWithHeavierWeight();
+    void testShouldCompareAsLesserFontFaceWithLesserItalics();
+    void testShouldCompareAsGreaterFontFaceWithGreaterItalics();
+    void testShouldCompareAsGreaterFontFaceWitHigherAlphabeticalFamilyName();
+    void testShouldCompareAsGreaterFontFaceWitLesserAlphabeticalFamilyName();
+    void testShouldCompareAsGreaterFontFaceWithHigherAlphabeticalStyleName();
+    void testShouldCompareAsGreaterFontFaceWithLesserAlphabeticalStyleName();
+    void testShouldCompareAsSameFontFace();
+    void testMatchStatusValue();
+
+    CPPUNIT_TEST_SUITE(VclPhysicalFontFaceTest);
+    CPPUNIT_TEST(testShouldCompareAsLesserFontFaceWithShorterWidth);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWithLongerWidth);
+    CPPUNIT_TEST(testShouldCompareAsLesserFontFaceWithLighterWeight);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWithHeavierWeight);
+    CPPUNIT_TEST(testShouldCompareAsLesserFontFaceWithLesserItalics);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWithGreaterItalics);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWitHigherAlphabeticalFamilyName);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWitLesserAlphabeticalFamilyName);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWithHigherAlphabeticalStyleName);
+    CPPUNIT_TEST(testShouldCompareAsGreaterFontFaceWithLesserAlphabeticalStyleName);
+    CPPUNIT_TEST(testShouldCompareAsSameFontFace);
+    CPPUNIT_TEST(testMatchStatusValue);
+
+    CPPUNIT_TEST_SUITE_END();
+};
+
+void VclPhysicalFontFaceTest::testShouldCompareAsLesserFontFaceWithShorterWidth()
+{
+    FontAttributes aFontAttrsShorterWidth;
+    aFontAttrsShorterWidth.SetWidthType(WIDTH_CONDENSED);
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrsShorterWidth, FONTID));
+
+    FontAttributes aFontAttrsLongerWidth;
+    aFontAttrsLongerWidth.SetWidthType(WIDTH_NORMAL);
+    rtl::Reference<TestFontFace> aComparedToFontFace(
+        new TestFontFace(aFontAttrsLongerWidth, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWithLongerWidth()
+{
+    FontAttributes aFontAttrsLongerWidth;
+    aFontAttrsLongerWidth.SetWidthType(WIDTH_NORMAL);
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrsLongerWidth, FONTID));
+
+    FontAttributes aFontAttrsShorterWidth;
+    aFontAttrsShorterWidth.SetWidthType(WIDTH_CONDENSED);
+    rtl::Reference<TestFontFace> aComparedToFontFace(
+        new TestFontFace(aFontAttrsShorterWidth, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsLesserFontFaceWithLighterWeight()
+{
+    FontAttributes aFontAttrsLighterWeight;
+    aFontAttrsLighterWeight.SetWidthType(WIDTH_NORMAL);
+    aFontAttrsLighterWeight.SetWeight(WEIGHT_THIN);
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrsLighterWeight, FONTID));
+
+    FontAttributes aFontAttrsHeavierWeight;
+    aFontAttrsHeavierWeight.SetWeight(WEIGHT_BOLD);
+    aFontAttrsHeavierWeight.SetWidthType(WIDTH_NORMAL);
+    rtl::Reference<TestFontFace> aComparedToFontFace(
+        new TestFontFace(aFontAttrsHeavierWeight, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWithHeavierWeight()
+{
+    FontAttributes aFontAttrsHeavierWeight;
+    aFontAttrsHeavierWeight.SetWidthType(WIDTH_NORMAL);
+    aFontAttrsHeavierWeight.SetWeight(WEIGHT_BOLD);
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrsHeavierWeight, FONTID));
+
+    FontAttributes aFontAttrsLighterWeight;
+    aFontAttrsLighterWeight.SetWidthType(WIDTH_NORMAL);
+    aFontAttrsLighterWeight.SetWeight(WEIGHT_THIN);
+    rtl::Reference<TestFontFace> aComparedToFontFace(
+        new TestFontFace(aFontAttrsLighterWeight, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsLesserFontFaceWithLesserItalics()
+{
+    FontAttributes aFontAttrsLesserItalics;
+    aFontAttrsLesserItalics.SetWidthType(WIDTH_NORMAL);
+    aFontAttrsLesserItalics.SetWeight(WEIGHT_THIN);
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrsLesserItalics, FONTID));
+
+    FontAttributes aFontAttrsGreaterItalics;
+    aFontAttrsGreaterItalics.SetWeight(WEIGHT_BOLD);
+    aFontAttrsGreaterItalics.SetWidthType(WIDTH_NORMAL);
+    rtl::Reference<TestFontFace> aComparedToFontFace(
+        new TestFontFace(aFontAttrsGreaterItalics, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWithGreaterItalics()
+{
+    FontAttributes aFontAttrsGreaterItalics;
+    aFontAttrsGreaterItalics.SetWidthType(WIDTH_NORMAL);
+    aFontAttrsGreaterItalics.SetWeight(WEIGHT_BOLD);
+    rtl::Reference<TestFontFace> aTestedFontFace(
+        new TestFontFace(aFontAttrsGreaterItalics, FONTID));
+
+    FontAttributes aFontAttrsLesserItalics;
+    aFontAttrsLesserItalics.SetWidthType(WIDTH_NORMAL);
+    aFontAttrsLesserItalics.SetWeight(WEIGHT_THIN);
+    rtl::Reference<TestFontFace> aComparedToFontFace(
+        new TestFontFace(aFontAttrsLesserItalics, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWitHigherAlphabeticalFamilyName()
+{
+    FontAttributes aFontAttrs1;
+    aFontAttrs1.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs1.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs1.SetFamilyName("B family");
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrs1, FONTID));
+
+    FontAttributes aFontAttrs2;
+    aFontAttrs2.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs2.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs2.SetFamilyName("A Family");
+    rtl::Reference<TestFontFace> aComparedToFontFace(new TestFontFace(aFontAttrs2, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWitLesserAlphabeticalFamilyName()
+{
+    FontAttributes aFontAttrs1;
+    aFontAttrs1.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs1.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs1.SetFamilyName("A family");
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrs1, FONTID));
+
+    FontAttributes aFontAttrs2;
+    aFontAttrs2.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs2.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs2.SetFamilyName("B Family");
+    rtl::Reference<TestFontFace> aComparedToFontFace(new TestFontFace(aFontAttrs2, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWithHigherAlphabeticalStyleName()
+{
+    FontAttributes aFontAttrs1;
+    aFontAttrs1.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs1.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs1.SetFamilyName("DejaVu Sans");
+    aFontAttrs1.SetStyleName("B Style");
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrs1, FONTID));
+
+    FontAttributes aFontAttrs2;
+    aFontAttrs2.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs2.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs2.SetFamilyName("DejaVu Sans");
+    aFontAttrs2.SetStyleName("A Style");
+    rtl::Reference<TestFontFace> aComparedToFontFace(new TestFontFace(aFontAttrs2, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsGreaterFontFaceWithLesserAlphabeticalStyleName()
+{
+    FontAttributes aFontAttrs1;
+    aFontAttrs1.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs1.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs1.SetFamilyName("DejaVu Sans");
+    aFontAttrs1.SetStyleName("A Style");
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrs1, FONTID));
+
+    FontAttributes aFontAttrs2;
+    aFontAttrs2.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs2.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs2.SetFamilyName("DejaVu Sans");
+    aFontAttrs2.SetStyleName("B Style");
+    rtl::Reference<TestFontFace> aComparedToFontFace(new TestFontFace(aFontAttrs2, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testShouldCompareAsSameFontFace()
+{
+    FontAttributes aFontAttrs1;
+    aFontAttrs1.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs1.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs1.SetFamilyName("DejaVu Sans");
+    aFontAttrs1.SetStyleName("Style");
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrs1, FONTID));
+
+    FontAttributes aFontAttrs2;
+    aFontAttrs2.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs2.SetWeight(WEIGHT_NORMAL);
+    aFontAttrs2.SetFamilyName("DejaVu Sans");
+    aFontAttrs2.SetStyleName("Style");
+    rtl::Reference<TestFontFace> aComparedToFontFace(new TestFontFace(aFontAttrs2, FONTID));
+
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(0),
+                         aTestedFontFace->CompareIgnoreSize(*aComparedToFontFace));
+}
+
+void VclPhysicalFontFaceTest::testMatchStatusValue()
+{
+    FontAttributes aFontAttrs;
+    aFontAttrs.SetFamilyName("DejaVu Sans");
+    aFontAttrs.SetStyleName("Book");
+    aFontAttrs.SetPitch(FontPitch::PITCH_VARIABLE);
+    aFontAttrs.SetWidthType(WIDTH_NORMAL);
+    aFontAttrs.SetWeight(WEIGHT_BOLD);
+    rtl::Reference<TestFontFace> aTestedFontFace(new TestFontFace(aFontAttrs, FONTID));
+
+    std::unique_ptr<OUString> pTargetStyleName(new OUString("Book"));
+    vcl::font::FontMatchStatus aFontMatchStatus = { 0, 0, 0, pTargetStyleName.get() };
+
+    vcl::Font aTestFont("DejaVu Sans", "Book", Size(0, 36));
+
+    vcl::font::FontSelectPattern aFSP(aTestFont, "DejaVu Sans", Size(0, 36), 36, true);
+    aFSP.mbEmbolden = false;
+    aFSP.mnOrientation = Degree10(10);
+    aFSP.SetWeight(WEIGHT_BOLD);
+    aFSP.SetPitch(FontPitch::PITCH_VARIABLE);
+    aFSP.maTargetName = "DejaVu Sans";
+
+    const int EXPECTED_FAMILY = 240'000;
+    const int EXPECTED_STYLE = 120'000;
+    const int EXPECTED_PITCH = 20'000;
+    const int EXPECTED_WIDTHTYPE = 400;
+    const int EXPECTED_WEIGHT = 1'000;
+    const int EXPECTED_ITALIC = 900;
+    const int EXPECTED_ORIENTATION = 80;
+
+    const int EXPECTED_MATCH = EXPECTED_FAMILY + EXPECTED_STYLE + EXPECTED_PITCH
+                               + EXPECTED_WIDTHTYPE + EXPECTED_WEIGHT + EXPECTED_ITALIC
+                               + EXPECTED_ORIENTATION;
+
+    CPPUNIT_ASSERT(aTestedFontFace->IsBetterMatch(aFSP, aFontMatchStatus));
+    CPPUNIT_ASSERT_EQUAL(EXPECTED_MATCH, aFontMatchStatus.mnFaceMatch);
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(VclPhysicalFontFaceTest);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/vcl/qa/cppunit/physicalfontfacecollection.cxx b/vcl/qa/cppunit/physicalfontfacecollection.cxx
index 56f44d2b39b9..3a8cedde76d5 100644
--- a/vcl/qa/cppunit/physicalfontfacecollection.cxx
+++ b/vcl/qa/cppunit/physicalfontfacecollection.cxx
@@ -42,8 +42,8 @@ void VclPhysicalFontFaceCollectionTest::testShouldGetFontId()
     vcl::font::PhysicalFontFaceCollection aCollection;
     aCollection.Add(new TestFontFace(1988756));
 
-    rtl::Reference<PhysicalFontFace> pActual(new TestFontFace(1988756));
-    rtl::Reference<PhysicalFontFace> pExpected = aCollection.Get(0);
+    rtl::Reference<vcl::font::PhysicalFontFace> pActual(new TestFontFace(1988756));
+    rtl::Reference<vcl::font::PhysicalFontFace> pExpected = aCollection.Get(0);
 
     CPPUNIT_ASSERT_EQUAL(pExpected->GetFontId(), pActual->GetFontId());
     CPPUNIT_ASSERT_EQUAL(1, aCollection.Count());
diff --git a/vcl/qt5/QtFont.cxx b/vcl/qt5/QtFont.cxx
index 8079576f156f..a9d84e897c1b 100644
--- a/vcl/qt5/QtFont.cxx
+++ b/vcl/qt5/QtFont.cxx
@@ -120,7 +120,7 @@ static inline void applyStyle(QtFont& rFont, FontItalic eItalic)
     }
 }
 
-QtFont::QtFont(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
+QtFont::QtFont(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
     : LogicalFontInstance(rPFF, rFSP)
 {
     setFamily(toQString(rPFF.GetFamilyName()));
diff --git a/vcl/qt5/QtFontFace.cxx b/vcl/qt5/QtFontFace.cxx
index 0eb51bf850b6..ffe88f242835 100644
--- a/vcl/qt5/QtFontFace.cxx
+++ b/vcl/qt5/QtFontFace.cxx
@@ -39,7 +39,7 @@
 using namespace vcl;
 
 QtFontFace::QtFontFace(const QtFontFace& rSrc)
-    : PhysicalFontFace(rSrc)
+    : vcl::font::PhysicalFontFace(rSrc)
     , m_aFontId(rSrc.m_aFontId)
     , m_eFontIdType(rSrc.m_eFontIdType)
 {
diff --git a/vcl/qt5/QtGraphics_Text.cxx b/vcl/qt5/QtGraphics_Text.cxx
index 3f1e196d6d7a..457338888323 100644
--- a/vcl/qt5/QtGraphics_Text.cxx
+++ b/vcl/qt5/QtGraphics_Text.cxx
@@ -216,7 +216,8 @@ const sal_uInt8* QtTrueTypeFont::table(sal_uInt32 ord, sal_uInt32& size) const
 }
 }
 
-bool QtGraphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFace* pFontFace,
+bool QtGraphics::CreateFontSubset(const OUString& rToFile,
+                                  const vcl::font::PhysicalFontFace* pFontFace,
                                   const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
                                   sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo)
 {
@@ -254,14 +255,15 @@ bool QtGraphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFac
                                             pGlyphIds, pEncoding, pGlyphWidths, nGlyphCount);
 }
 
-const void* QtGraphics::GetEmbedFontData(const PhysicalFontFace*, tools::Long* /*pDataLen*/)
+const void* QtGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace*,
+                                         tools::Long* /*pDataLen*/)
 {
     return nullptr;
 }
 
 void QtGraphics::FreeEmbedFontData(const void* /*pData*/, tools::Long /*nDataLen*/) {}
 
-void QtGraphics::GetGlyphWidths(const PhysicalFontFace* pFontFace, bool bVertical,
+void QtGraphics::GetGlyphWidths(const vcl::font::PhysicalFontFace* pFontFace, bool bVertical,
                                 std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc)
 {
     const QtFontFace* pQtFontFace = static_cast<const QtFontFace*>(pFontFace);
diff --git a/vcl/quartz/ctfonts.cxx b/vcl/quartz/ctfonts.cxx
index 5a9a8f27e0d6..5e958f73c35a 100644
--- a/vcl/quartz/ctfonts.cxx
+++ b/vcl/quartz/ctfonts.cxx
@@ -46,7 +46,7 @@ static double toRadian(int nDegree)
     return nDegree * (M_PI / 1800.0);
 }
 
-CoreTextStyle::CoreTextStyle(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
+CoreTextStyle::CoreTextStyle(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
     : LogicalFontInstance(rPFF, rFSP)
     , mfFontStretch( 1.0 )
     , mfFontRotation( 0.0 )
diff --git a/vcl/quartz/salgdi.cxx b/vcl/quartz/salgdi.cxx
index 3cfa39cc98fc..ab67e851612a 100644
--- a/vcl/quartz/salgdi.cxx
+++ b/vcl/quartz/salgdi.cxx
@@ -109,7 +109,7 @@ bool CoreTextGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSele
 }
 
 CoreTextFontFace::CoreTextFontFace( const FontAttributes& rDFA, sal_IntPtr nFontId )
-  : PhysicalFontFace( rDFA )
+  : vcl::font::PhysicalFontFace( rDFA )
   , mnFontId( nFontId )
   , mbFontCapabilitiesRead( false )
 {
@@ -556,7 +556,7 @@ static void FakeDirEntry( const char aTag[5], ByteCount nOfs, ByteCount nLen,
 
 // fake a TTF or CFF font as directly accessing font file is not possible
 // when only the fontid is known. This approach also handles *.font fonts.
-bool AquaSalGraphics::GetRawFontData( const PhysicalFontFace* pFontData,
+bool AquaSalGraphics::GetRawFontData( const vcl::font::PhysicalFontFace* pFontData,
                                       std::vector<unsigned char>& rBuffer, bool* pJustCFF )
 {
     const CoreTextFontFace* pMacFont = static_cast<const CoreTextFontFace*>(pFontData);
@@ -742,7 +742,7 @@ bool AquaSalGraphics::GetRawFontData( const PhysicalFontFace* pFontData,
     return true;
 }
 
-void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bVertical,
+void AquaSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFontData, bool bVertical,
     std::vector< sal_Int32 >& rGlyphWidths, Ucs2UIntMap& rUnicodeEnc )
 {
     rGlyphWidths.clear();
@@ -768,7 +768,7 @@ void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bV
     ::CloseTTFont( pSftFont );
 }
 
-const void* AquaSalGraphics::GetEmbedFontData(const PhysicalFontFace*, tools::Long* /*pDataLen*/)
+const void* AquaSalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* /*pDataLen*/)
 {
     return nullptr;
 }
diff --git a/vcl/quartz/salgdicommon.cxx b/vcl/quartz/salgdicommon.cxx
index 4061aefb4a40..b4b24d4e5f4d 100644
--- a/vcl/quartz/salgdicommon.cxx
+++ b/vcl/quartz/salgdicommon.cxx
@@ -47,7 +47,7 @@
 using namespace vcl;
 
 bool AquaSalGraphics::CreateFontSubset( const OUString& rToFile,
-                                        const PhysicalFontFace* pFontData,
+                                        const vcl::font::PhysicalFontFace* pFontData,
                                         const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
                                         sal_Int32* pGlyphWidths, const int nGlyphCount,
                                         FontSubsetInfo& rInfo )
diff --git a/vcl/source/font/fontselect.cxx b/vcl/source/font/FontSelectPattern.cxx
index 3ea89bde90e1..23e7673c8da2 100644
--- a/vcl/source/font/fontselect.cxx
+++ b/vcl/source/font/FontSelectPattern.cxx
@@ -20,10 +20,11 @@
 #include <sal/config.h>
 #include <o3tl/safeint.hxx>
 #include <tools/gen.hxx>
+
 #include <vcl/font.hxx>
 
-#include <PhysicalFontFace.hxx>
 #include <font/FontSelectPattern.hxx>
+#include <font/PhysicalFontFace.hxx>
 
 namespace vcl::font
 {
diff --git a/vcl/source/font/PhysicalFontCollection.cxx b/vcl/source/font/PhysicalFontCollection.cxx
index c97beb478c79..42dc11d303e2 100644
--- a/vcl/source/font/PhysicalFontCollection.cxx
+++ b/vcl/source/font/PhysicalFontCollection.cxx
@@ -276,7 +276,7 @@ vcl::font::PhysicalFontFamily* PhysicalFontCollection::GetGlyphFallbackFont( vcl
     return pFallbackData;
 }
 
-void PhysicalFontCollection::Add( PhysicalFontFace* pNewData )
+void PhysicalFontCollection::Add( vcl::font::PhysicalFontFace* pNewData )
 {
     OUString aSearchName = GetEnglishSearchFontName( pNewData->GetFamilyName() );
 
diff --git a/vcl/source/font/PhysicalFontFace.cxx b/vcl/source/font/PhysicalFontFace.cxx
index 7d278df9871d..6acfe3da1575 100644
--- a/vcl/source/font/PhysicalFontFace.cxx
+++ b/vcl/source/font/PhysicalFontFace.cxx
@@ -24,9 +24,12 @@
 #include <unotools/fontdefs.hxx>
 
 #include <fontattributes.hxx>
+
 #include <font/FontSelectPattern.hxx>
+#include <font/PhysicalFontFace.hxx>
 
-#include <PhysicalFontFace.hxx>
+namespace vcl::font
+{
 
 PhysicalFontFace::PhysicalFontFace( const FontAttributes& rDFA )
     : FontAttributes( rDFA )
@@ -176,5 +179,6 @@ bool PhysicalFontFace::IsBetterMatch( const vcl::font::FontSelectPattern& rFSD,
     rStatus.mnWidthMatch = nWidthMatch;
     return true;
 }
+}
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/vcl/source/font/fontcache.cxx b/vcl/source/font/fontcache.cxx
index 5e94441466b0..c125d49f0d1b 100644
--- a/vcl/source/font/fontcache.cxx
+++ b/vcl/source/font/fontcache.cxx
@@ -18,10 +18,11 @@
  */
 
 #include <sal/config.h>
+
 #include <sal/log.hxx>
 
 #include <PhysicalFontCollection.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <font/PhysicalFontFamily.hxx>
 #include <fontinstance.hxx>
 #include <impfontcache.hxx>
@@ -143,7 +144,7 @@ rtl::Reference<LogicalFontInstance> ImplFontCache::GetFontInstance( PhysicalFont
 
     if( !pFontInstance && pFontFamily) // still no cache hit => create a new font instance
     {
-        PhysicalFontFace* pFontData = pFontFamily->FindBestFontFace(aFontSelData);
+        vcl::font::PhysicalFontFace* pFontData = pFontFamily->FindBestFontFace(aFontSelData);
 
         // create a new logical font instance from this physical font face
         pFontInstance = pFontData->CreateFontInstance( aFontSelData );
diff --git a/vcl/source/font/fontinstance.cxx b/vcl/source/font/fontinstance.cxx
index 672ac82e1bdb..49b0593ce592 100644
--- a/vcl/source/font/fontinstance.cxx
+++ b/vcl/source/font/fontinstance.cxx
@@ -22,9 +22,9 @@
 #include <hb-ot.h>
 #include <hb-graphite2.h>
 
+#include <font/PhysicalFontFace.hxx>
 #include <fontinstance.hxx>
 #include <impfontcache.hxx>
-#include <PhysicalFontFace.hxx>
 
 #include <o3tl/hash_combine.hxx>
 
@@ -45,7 +45,7 @@ namespace std
 }
 
 
-LogicalFontInstance::LogicalFontInstance(const PhysicalFontFace& rFontFace, const vcl::font::FontSelectPattern& rFontSelData )
+LogicalFontInstance::LogicalFontInstance(const vcl::font::PhysicalFontFace& rFontFace, const vcl::font::FontSelectPattern& rFontSelData )
     : mxFontMetric( new ImplFontMetricData( rFontSelData ))
     , mpConversion( nullptr )
     , mnLineHeight( 0 )
@@ -56,7 +56,7 @@ LogicalFontInstance::LogicalFontInstance(const PhysicalFontFace& rFontFace, cons
     , m_aFontSelData(rFontSelData)
     , m_pHbFont(nullptr)
     , m_nAveWidthFactor(1.0f)
-    , m_pFontFace(&const_cast<PhysicalFontFace&>(rFontFace))
+    , m_pFontFace(&const_cast<vcl::font::PhysicalFontFace&>(rFontFace))
 {
 }
 
diff --git a/vcl/source/font/fontmetric.cxx b/vcl/source/font/fontmetric.cxx
index 2e3859b1f941..000523941813 100644
--- a/vcl/source/font/fontmetric.cxx
+++ b/vcl/source/font/fontmetric.cxx
@@ -26,9 +26,9 @@
 #include <vcl/outdev.hxx>
 #include <sal/log.hxx>
 
-#include <PhysicalFontFace.hxx>
-#include <fontinstance.hxx>
 #include <font/FontSelectPattern.hxx>
+#include <font/PhysicalFontFace.hxx>
+#include <fontinstance.hxx>
 #include <impfontmetricdata.hxx>
 #include <sft.hxx>
 
@@ -53,7 +53,7 @@ FontMetric::FontMetric()
 
 FontMetric::FontMetric( const FontMetric& rFontMetric ) = default;
 
-FontMetric::FontMetric(PhysicalFontFace const& rFace)
+FontMetric::FontMetric(vcl::font::PhysicalFontFace const& rFace)
     : FontMetric()
 {
     SetFamilyName(rFace.GetFamilyName());
diff --git a/vcl/source/gdi/embeddedfontshelper.cxx b/vcl/source/gdi/embeddedfontshelper.cxx
index ebcedb45b6a4..03c80ccb885b 100644
--- a/vcl/source/gdi/embeddedfontshelper.cxx
+++ b/vcl/source/gdi/embeddedfontshelper.cxx
@@ -260,12 +260,12 @@ OUString EmbeddedFontsHelper::fontFileUrl( std::u16string_view familyName, FontF
     PhysicalFontCollection fonts;
     graphics->GetDevFontList( &fonts );
     std::unique_ptr< vcl::font::PhysicalFontFaceCollection > fontInfo( fonts.GetFontFaceCollection());
-    PhysicalFontFace* selected = nullptr;
+    vcl::font::PhysicalFontFace* selected = nullptr;
     for( int i = 0;
          i < fontInfo->Count();
          ++i )
     {
-        PhysicalFontFace* f = fontInfo->Get( i );
+        vcl::font::PhysicalFontFace* f = fontInfo->Get( i );
         if( f->GetFamilyName() == familyName )
         {
             // Ignore comparing text encodings, at least for now. They cannot be trivially compared
diff --git a/vcl/source/gdi/pdfbuildin_fonts.cxx b/vcl/source/gdi/pdfbuildin_fonts.cxx
index 688b608de2e1..d6504c5c0fb7 100644
--- a/vcl/source/gdi/pdfbuildin_fonts.cxx
+++ b/vcl/source/gdi/pdfbuildin_fonts.cxx
@@ -731,7 +731,7 @@ const BuildinFont BuildinFontFace::m_aBuildinFonts[14]
 
       };
 
-BuildinFontInstance::BuildinFontInstance(const PhysicalFontFace& rFontFace,
+BuildinFontInstance::BuildinFontInstance(const vcl::font::PhysicalFontFace& rFontFace,
                                          const vcl::font::FontSelectPattern& rFSP)
     : LogicalFontInstance(rFontFace, rFSP)
 {
@@ -748,7 +748,7 @@ bool BuildinFontInstance::GetGlyphOutline(sal_GlyphId, basegfx::B2DPolyPolygon&,
 }
 
 BuildinFontFace::BuildinFontFace(int nId)
-    : PhysicalFontFace(m_aBuildinFonts[nId].GetFontAttributes())
+    : vcl::font::PhysicalFontFace(m_aBuildinFonts[nId].GetFontAttributes())
     , mrBuildin(m_aBuildinFonts[nId])
 {
 }
diff --git a/vcl/source/gdi/pdffontcache.cxx b/vcl/source/gdi/pdffontcache.cxx
index dadcb03048e2..e4646f8777bd 100644
--- a/vcl/source/gdi/pdffontcache.cxx
+++ b/vcl/source/gdi/pdffontcache.cxx
@@ -21,7 +21,7 @@
 
 #include <sal/types.h>
 
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <pdf/pdffontcache.hxx>
 #include <salgdi.hxx>
 
@@ -29,14 +29,14 @@
 
 using namespace vcl;
 
-PDFFontCache::FontIdentifier::FontIdentifier( const PhysicalFontFace* pFont, bool bVertical ) :
+PDFFontCache::FontIdentifier::FontIdentifier( const vcl::font::PhysicalFontFace* pFont, bool bVertical ) :
     m_nFontId( pFont->GetFontId() ),
     m_bVertical( bVertical ),
     m_typeFontFace( const_cast<std::type_info*>(&typeid(pFont)) )
 {
 }
 
-PDFFontCache::FontData& PDFFontCache::getFont( const PhysicalFontFace* pFont, bool bVertical )
+PDFFontCache::FontData& PDFFontCache::getFont( const vcl::font::PhysicalFontFace* pFont, bool bVertical )
 {
     FontIdentifier aId( pFont, bVertical );
     FontToIndexMap::iterator it = m_aFontToIndex.find( aId );
@@ -47,7 +47,7 @@ PDFFontCache::FontData& PDFFontCache::getFont( const PhysicalFontFace* pFont, bo
     return m_aFonts.back();
 }
 
-sal_Int32 PDFFontCache::getGlyphWidth( const PhysicalFontFace* pFont, sal_GlyphId nGlyph, bool bVertical, SalGraphics* pGraphics )
+sal_Int32 PDFFontCache::getGlyphWidth( const vcl::font::PhysicalFontFace* pFont, sal_GlyphId nGlyph, bool bVertical, SalGraphics* pGraphics )
 {
     sal_Int32 nWidth = 0;
     FontData& rFontData( getFont( pFont, bVertical ) );
diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx
index 6b02a6d384fc..7718cbd39f9c 100644
--- a/vcl/source/gdi/pdfwriter_impl.cxx
+++ b/vcl/source/gdi/pdfwriter_impl.cxx
@@ -72,7 +72,7 @@
 #include <svdata.hxx>
 #include <bitmap/BitmapWriteAccess.hxx>
 #include <fontsubset.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <salgdi.hxx>
 #include <textlayout.hxx>
 #include <textlineinfo.hxx>
@@ -2310,7 +2310,7 @@ sal_Int32 PDFWriterImpl::emitBuildinFont(const pdf::BuildinFontFace* pFD, sal_In
     return nFontObject;
 }
 
-std::map< sal_Int32, sal_Int32 > PDFWriterImpl::emitSystemFont( const PhysicalFontFace* pFont, EmbedFont const & rEmbed )
+std::map< sal_Int32, sal_Int32 > PDFWriterImpl::emitSystemFont( const vcl::font::PhysicalFontFace* pFont, EmbedFont const & rEmbed )
 {
     std::map< sal_Int32, sal_Int32 > aRet;
 
@@ -2549,7 +2549,7 @@ sal_Int32 PDFWriterImpl::createToUnicodeCMap( sal_uInt8 const * pEncoding,
     return nStream;
 }
 
-sal_Int32 PDFWriterImpl::emitFontDescriptor( const PhysicalFontFace* pFont, FontSubsetInfo const & rInfo, sal_Int32 nSubsetID, sal_Int32 nFontStream )
+sal_Int32 PDFWriterImpl::emitFontDescriptor( const vcl::font::PhysicalFontFace* pFont, FontSubsetInfo const & rInfo, sal_Int32 nSubsetID, sal_Int32 nFontStream )
 {
     OStringBuffer aLine( 1024 );
     // get font flags, see PDF reference 1.4 p. 358
@@ -2854,7 +2854,7 @@ bool PDFWriterImpl::emitFonts()
             }
             else
             {
-                const PhysicalFontFace* pFont = subset.first;
+                const vcl::font::PhysicalFontFace* pFont = subset.first;
                 OStringBuffer aErrorComment( 256 );
                 aErrorComment.append( "CreateFontSubset failed for font \"" );
                 aErrorComment.append( OUStringToOString( pFont->GetFamilyName(), RTL_TEXTENCODING_UTF8 ) );
@@ -3889,7 +3889,7 @@ void PDFWriterImpl::createDefaultCheckBoxAppearance( PDFWidget& rBox, const PDFW
     FontCharMapRef pMap;
     GetFontCharMap(pMap);
     const LogicalFontInstance* pFontInstance = GetFontInstance();
-    const PhysicalFontFace* pDevFont = pFontInstance->GetFontFace();
+    const vcl::font::PhysicalFontFace* pDevFont = pFontInstance->GetFontFace();
     Pop();
 
     // make sure OpenSymbol is embedded, and includes our checkmark
@@ -5676,7 +5676,7 @@ sal_Int32 PDFWriterImpl::getSystemFont( const vcl::Font& i_rFont )
 
     SetFont( i_rFont );
 
-    const PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace();
+    const vcl::font::PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace();
     sal_Int32 nFontID = 0;
     auto it = m_aSystemFonts.find( pDevFont );
     if( it != m_aSystemFonts.end() )
@@ -5693,7 +5693,7 @@ sal_Int32 PDFWriterImpl::getSystemFont( const vcl::Font& i_rFont )
 }
 
 void PDFWriterImpl::registerGlyph(const GlyphItem* pGlyph,
-                                  const PhysicalFontFace* pFont,
+                                  const vcl::font::PhysicalFontFace* pFont,
                                   const std::vector<sal_Ucs>& rCodeUnits,
                                   sal_uInt8& nMappedGlyph,
                                   sal_Int32& nMappedFontObject)
@@ -6123,9 +6123,9 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool
     }
 
     FontMetric aRefDevFontMetric = GetFontMetric();
-    const PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace();
+    const vcl::font::PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace();
     const GlyphItem* pGlyph = nullptr;
-    const PhysicalFontFace* pFallbackFont = nullptr;
+    const vcl::font::PhysicalFontFace* pFallbackFont = nullptr;
 
     // collect the glyphs into a single array
     std::vector< PDFGlyph > aGlyphs;
diff --git a/vcl/source/gdi/salgdilayout.cxx b/vcl/source/gdi/salgdilayout.cxx
index 9a327dd5312f..aafa8f157e70 100644
--- a/vcl/source/gdi/salgdilayout.cxx
+++ b/vcl/source/gdi/salgdilayout.cxx
@@ -22,7 +22,7 @@
 #include <memory>
 #include <config_features.h>
 #include <sal/log.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <fontsubset.hxx>
 #include <salgdi.hxx>
 #include <salframe.hxx>
@@ -885,7 +885,7 @@ OUString SalGraphics::getRenderBackendName() const
 }
 
 void SalGraphics::GetGlyphWidths(const vcl::AbstractTrueTypeFont& rTTF,
-                                 const PhysicalFontFace& rFontFace, const bool bVertical,
+                                 const vcl::font::PhysicalFontFace& rFontFace, const bool bVertical,
                                  std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc)
 {
     rWidths.clear();
diff --git a/vcl/source/gdi/sallayout.cxx b/vcl/source/gdi/sallayout.cxx
index 445e2cddba07..bdd6deaaa49e 100644
--- a/vcl/source/gdi/sallayout.cxx
+++ b/vcl/source/gdi/sallayout.cxx
@@ -493,7 +493,7 @@ sal_Int32 GenericSalLayout::GetTextBreak( DeviceCoordinate nMaxWidth, DeviceCoor
 bool GenericSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
                                     Point& rPos, int& nStart,
                                     const LogicalFontInstance** ppGlyphFont,
-                                    const PhysicalFontFace**) const
+                                    const vcl::font::PhysicalFontFace**) const
 {
     std::vector<GlyphItem>::const_iterator pGlyphIter = m_GlyphItems.begin();
     std::vector<GlyphItem>::const_iterator pGlyphIterEnd = m_GlyphItems.end();
@@ -1107,7 +1107,7 @@ void MultiSalLayout::GetCaretPositions( int nMaxIndex, tools::Long* pCaretXArray
 bool MultiSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
                                   Point& rPos, int& nStart,
                                   const LogicalFontInstance** ppGlyphFont,
-                                  const PhysicalFontFace** pFallbackFont) const
+                                  const vcl::font::PhysicalFontFace** pFallbackFont) const
 {
     // NOTE: nStart is tagged with current font index
     int nLevel = static_cast<unsigned>(nStart) >> GF_FONTSHIFT;
@@ -1116,7 +1116,7 @@ bool MultiSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
     {
         GenericSalLayout& rLayout = *mpLayouts[ nLevel ];
         rLayout.InitFont();
-        const PhysicalFontFace* pFontFace = rLayout.GetFont().GetFontFace();
+        const vcl::font::PhysicalFontFace* pFontFace = rLayout.GetFont().GetFontFace();
         if (rLayout.GetNextGlyph(pGlyph, rPos, nStart, ppGlyphFont))
         {
             int nFontTag = nLevel << GF_FONTSHIFT;
diff --git a/vcl/unx/generic/gdi/font.cxx b/vcl/unx/generic/gdi/font.cxx
index 36618829279c..bc56b56286c5 100644
--- a/vcl/unx/generic/gdi/font.cxx
+++ b/vcl/unx/generic/gdi/font.cxx
@@ -83,7 +83,7 @@ std::unique_ptr<GenericSalLayout> X11SalGraphics::GetTextLayout(int nFallbackLev
 
 bool X11SalGraphics::CreateFontSubset(
                                    const OUString& rToFile,
-                                   const PhysicalFontFace* pFont,
+                                   const vcl::font::PhysicalFontFace* pFont,
                                    const sal_GlyphId* pGlyphIds,
                                    const sal_uInt8* pEncoding,
                                    sal_Int32* pWidths,
@@ -95,7 +95,7 @@ bool X11SalGraphics::CreateFontSubset(
             pGlyphIds, pEncoding, pWidths, nGlyphCount, rInfo);
 }
 
-const void* X11SalGraphics::GetEmbedFontData(const PhysicalFontFace* pFont, tools::Long* pDataLen)
+const void* X11SalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen)
 {
     return mxTextRenderImpl->GetEmbedFontData(pFont, pDataLen);
 }
@@ -105,7 +105,7 @@ void X11SalGraphics::FreeEmbedFontData( const void* pData, tools::Long nLen )
     mxTextRenderImpl->FreeEmbedFontData(pData, nLen);
 }
 
-void X11SalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
+void X11SalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
                                    bool bVertical,
                                    std::vector< sal_Int32 >& rWidths,
                                    Ucs2UIntMap& rUnicodeEnc )
diff --git a/vcl/unx/generic/gdi/freetypetextrender.cxx b/vcl/unx/generic/gdi/freetypetextrender.cxx
index 9f66c5f5f536..2b39d8787605 100644
--- a/vcl/unx/generic/gdi/freetypetextrender.cxx
+++ b/vcl/unx/generic/gdi/freetypetextrender.cxx
@@ -33,7 +33,7 @@
 #include <unx/glyphcache.hxx>
 #include <unx/fc_fontoptions.hxx>
 #include <unx/freetype_glyphcache.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <impfontmetricdata.hxx>
 
 #include <sallayout.hxx>
@@ -157,7 +157,7 @@ std::unique_ptr<GenericSalLayout> FreeTypeTextRenderImpl::GetTextLayout(int nFal
 
 bool FreeTypeTextRenderImpl::CreateFontSubset(
                                    const OUString& rToFile,
-                                   const PhysicalFontFace* pFont,
+                                   const vcl::font::PhysicalFontFace* pFont,
                                    const sal_GlyphId* pGlyphIds,
                                    const sal_uInt8* pEncoding,
                                    sal_Int32* pWidths,
@@ -183,7 +183,7 @@ bool FreeTypeTextRenderImpl::CreateFontSubset(
     return bSuccess;
 }
 
-const void* FreeTypeTextRenderImpl::GetEmbedFontData(const PhysicalFontFace* pFont, tools::Long* pDataLen)
+const void* FreeTypeTextRenderImpl::GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen)
 {
     // in this context the pFont->GetFontId() is a valid PSP
     // font since they are the only ones left after the PDF
@@ -199,7 +199,7 @@ void FreeTypeTextRenderImpl::FreeEmbedFontData( const void* pData, tools::Long n
     GenPspGraphics::DoFreeEmbedFontData( pData, nLen );
 }
 
-void FreeTypeTextRenderImpl::GetGlyphWidths( const PhysicalFontFace* pFont,
+void FreeTypeTextRenderImpl::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
                                    bool bVertical,
                                    std::vector< sal_Int32 >& rWidths,
                                    Ucs2UIntMap& rUnicodeEnc )
diff --git a/vcl/unx/generic/glyphs/freetype_glyphcache.cxx b/vcl/unx/generic/glyphs/freetype_glyphcache.cxx
index 77c1566727d4..645afddabc73 100644
--- a/vcl/unx/generic/glyphs/freetype_glyphcache.cxx
+++ b/vcl/unx/generic/glyphs/freetype_glyphcache.cxx
@@ -373,7 +373,7 @@ FreetypeFont* FreetypeManager::CreateFont(FreetypeFontInstance* pFontInstance)
     if (!pFontInstance)
         return nullptr;
 
-    const PhysicalFontFace* pFontFace = pFontInstance->GetFontFace();
+    const vcl::font::PhysicalFontFace* pFontFace = pFontInstance->GetFontFace();
     if (!pFontFace)
         return nullptr;
 
@@ -387,7 +387,7 @@ FreetypeFont* FreetypeManager::CreateFont(FreetypeFontInstance* pFontInstance)
 }
 
 FreetypeFontFace::FreetypeFontFace( FreetypeFontInfo* pFI, const FontAttributes& rDFA )
-:   PhysicalFontFace( rDFA ),
+:   vcl::font::PhysicalFontFace( rDFA ),
     mpFreetypeFontInfo( pFI )
 {
 }
diff --git a/vcl/unx/generic/glyphs/glyphcache.cxx b/vcl/unx/generic/glyphs/glyphcache.cxx
index ec2afc4db8f3..79db2d87bdb0 100644
--- a/vcl/unx/generic/glyphs/glyphcache.cxx
+++ b/vcl/unx/generic/glyphs/glyphcache.cxx
@@ -66,7 +66,7 @@ FreetypeFontFile* FreetypeManager::FindFontFile(const OString& rNativeFileName)
     return pFontFile;
 }
 
-FreetypeFontInstance::FreetypeFontInstance(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
+FreetypeFontInstance::FreetypeFontInstance(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
     : LogicalFontInstance(rPFF, rFSP)
     , mxFreetypeFont(FreetypeManager::get().CreateFont(this))
 {
diff --git a/vcl/unx/generic/print/genpspgraphics.cxx b/vcl/unx/generic/print/genpspgraphics.cxx
index 48b5ca8af32b..3ae0e8fa40af 100644
--- a/vcl/unx/generic/print/genpspgraphics.cxx
+++ b/vcl/unx/generic/print/genpspgraphics.cxx
@@ -46,8 +46,9 @@
 #include <fontinstance.hxx>
 #include <fontattributes.hxx>
 #include <impfontmetricdata.hxx>
+#include <font/FontSelectPattern.hxx>
 #include <PhysicalFontCollection.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <sallayout.hxx>
 
 using namespace psp;
@@ -309,7 +310,7 @@ std::unique_ptr<GenericSalLayout> GenPspGraphics::GetTextLayout(int nFallbackLev
 
 bool GenPspGraphics::CreateFontSubset(
                                    const OUString& rToFile,
-                                   const PhysicalFontFace* pFont,
+                                   const vcl::font::PhysicalFontFace* pFont,
                                    const sal_GlyphId* pGlyphIds,
                                    const sal_uInt8* pEncoding,
                                    sal_Int32* pWidths,
@@ -335,7 +336,7 @@ bool GenPspGraphics::CreateFontSubset(
     return bSuccess;
 }
 
-void GenPspGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
+void GenPspGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
                                   bool bVertical,
                                   std::vector< sal_Int32 >& rWidths,
                                   Ucs2UIntMap& rUnicodeEnc )
@@ -504,7 +505,7 @@ void GenPspGraphics::FreeEmbedFontData( const void* pData, tools::Long nLen )
     DoFreeEmbedFontData( pData, nLen );
 }
 
-const void* GenPspGraphics::GetEmbedFontData(const PhysicalFontFace* pFont, tools::Long* pDataLen)
+const void* GenPspGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen)
 {
     // in this context the pFont->GetFontId() is a valid PSP
     // font since they are the only ones left after the PDF
diff --git a/vcl/win/gdi/salfont.cxx b/vcl/win/gdi/salfont.cxx
index 6dd8365e6955..842f5ed8830f 100644
--- a/vcl/win/gdi/salfont.cxx
+++ b/vcl/win/gdi/salfont.cxx
@@ -51,11 +51,12 @@
 #include <vcl/fontcharmap.hxx>
 #include <comphelper/scopeguard.hxx>
 
+#include <font/FontSelectPattern.hxx>
 #include <fontsubset.hxx>
 #include <outdev.h>
 #include <font/PhysicalFontFaceCollection.hxx>
 #include <PhysicalFontCollection.hxx>
-#include <PhysicalFontFace.hxx>
+#include <font/PhysicalFontFace.hxx>
 #include <sft.hxx>
 #include <win/saldata.hxx>
 #include <win/salgdi.h>
@@ -180,13 +181,13 @@ public:
     bool FindFontSubstitute(vcl::font::FontSelectPattern&, LogicalFontInstance* pLogicalFont, OUString& rMissingChars) const override;
 private:
     HDC mhDC;
-    bool HasMissingChars(PhysicalFontFace*, OUString& rMissingChars) const;
+    bool HasMissingChars(vcl::font::PhysicalFontFace*, OUString& rMissingChars) const;
 };
 
 }
 
 // does a font face hold the given missing characters?
-bool WinGlyphFallbackSubstititution::HasMissingChars(PhysicalFontFace* pFace, OUString& rMissingChars) const
+bool WinGlyphFallbackSubstititution::HasMissingChars(vcl::font::PhysicalFontFace* pFace, OUString& rMissingChars) const
 {
     WinFontFace* pWinFont = static_cast< WinFontFace* >(pFace);
     FontCharMapRef xFontCharMap = pWinFont->GetFontCharMap();
@@ -303,7 +304,7 @@ bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPat
     vcl::font::PhysicalFontFamily* pFontFamily = findDevFontListByLocale(*pFontCollection, aLanguageTag);
     if( pFontFamily )
     {
-        PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
+        vcl::font::PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
         if( HasMissingChars( pFace, rMissingChars ) )
         {
             rFontSelData.maSearchName = pFontFamily->GetSearchName();
@@ -319,7 +320,7 @@ bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPat
                                                      rFontSelData.maSearchName );
     if( pFontFamily )
     {
-        PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
+        vcl::font::PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
         if( HasMissingChars( pFace, rMissingChars ) )
         {
             rFontSelData.maSearchName = pFontFamily->GetSearchName();
@@ -338,7 +339,7 @@ bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPat
     bool bFound = false;
     for( int i = 0; i < nTestFontCount; ++i )
     {
-        PhysicalFontFace* pFace = pTestFontList->Get( i );
+        vcl::font::PhysicalFontFace* pFace = pTestFontList->Get( i );
         bFound = HasMissingChars( pFace, rMissingChars );
         if( !bFound )
             continue;
@@ -626,7 +627,7 @@ void ImplSalLogFontToFontW( HDC hDC, const LOGFONTW& rLogFont, Font& rFont )
 
 WinFontFace::WinFontFace( const FontAttributes& rDFS,
     BYTE eWinCharSet, BYTE nPitchAndFamily )
-:   PhysicalFontFace( rDFS ),
+:   vcl::font::PhysicalFontFace( rDFS ),
     mnId( 0 ),
     mbFontCapabilitiesRead( false ),
     meWinCharSet( eWinCharSet ),
@@ -762,7 +763,7 @@ void WinSalGraphics::SetTextColor( Color nColor )
 }
 
 void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern& rFont,
-                                   const PhysicalFontFace* pFontFace,
+                                   const vcl::font::PhysicalFontFace* pFontFace,
                                    LOGFONTW& rLogFont )
 {
     OUString aName;
@@ -811,7 +812,7 @@ void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern& rFont,
 }
 
 HFONT WinSalGraphics::ImplDoSetFont(vcl::font::FontSelectPattern const & i_rFont,
-                                    const PhysicalFontFace * i_pFontFace,
+                                    const vcl::font::PhysicalFontFace * i_pFontFace,
                                     HFONT& o_rOldFont)
 {
     HFONT hNewFont = nullptr;
@@ -1535,7 +1536,7 @@ SFErrCodes ScopedTrueTypeFont::open(void const * pBuffer, sal_uInt32 nLen,
 }
 
 bool WinSalGraphics::CreateFontSubset( const OUString& rToFile,
-    const PhysicalFontFace* pFont, const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
+    const vcl::font::PhysicalFontFace* pFont, const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
     sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
 {
     // TODO: use more of the central font-subsetting code, move stuff there if needed
@@ -1604,7 +1605,7 @@ bool WinSalGraphics::CreateFontSubset( const OUString& rToFile,
                                             pEncoding, pGlyphWidths, nGlyphCount);
 }
 
-const void* WinSalGraphics::GetEmbedFontData(const PhysicalFontFace* pFont, tools::Long* pDataLen)
+const void* WinSalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace* pFont, tools::Long* pDataLen)
 {
     // create matching FontSelectPattern
     // we need just enough to get to the font file data
@@ -1630,7 +1631,7 @@ void WinSalGraphics::FreeEmbedFontData( const void* pData, tools::Long /*nLen*/
     delete[] static_cast<char const *>(pData);
 }
 
-void WinSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
+void WinSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
                                      bool bVertical,
                                      std::vector< sal_Int32 >& rWidths,
                                      Ucs2UIntMap& rUnicodeEnc )
diff --git a/vcl/win/gdi/winlayout.cxx b/vcl/win/gdi/winlayout.cxx
index 749b9c96ec4f..0db736c256c0 100644
--- a/vcl/win/gdi/winlayout.cxx
+++ b/vcl/win/gdi/winlayout.cxx
@@ -163,7 +163,7 @@ struct BlobReference
 };
 }
 
-using BlobCacheKey = std::pair<rtl::Reference<PhysicalFontFace>, hb_tag_t>;
+using BlobCacheKey = std::pair<rtl::Reference<vcl::font::PhysicalFontFace>, hb_tag_t>;
 
 namespace
 {
@@ -189,7 +189,8 @@ static hb_blob_t* getFontTable(hb_face_t* /*face*/, hb_tag_t nTableTag, void* pU
     assert(hDC);
     assert(hFont);
 
-    BlobCacheKey cacheKey{ rtl::Reference<PhysicalFontFace>(pFont->GetFontFace()), nTableTag };
+    BlobCacheKey cacheKey{ rtl::Reference<vcl::font::PhysicalFontFace>(pFont->GetFontFace()),
+                           nTableTag };
     auto it = gCache.find(cacheKey);
     if (it != gCache.end())
     {