mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
- 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>
This commit is contained in:
Chris Sherlock 2021-09-12 14:41:19 +10:00 committed by Mike Kaganski
parent 0e736b0c20
commit c817a5a495
59 changed files with 517 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/vcl/metric.hxx
View File

@ -28,7 +28,7 @@
#include <vcl/font.hxx> #include <vcl/font.hxx>
class FontCharMap; class FontCharMap;
class PhysicalFontFace; namespace vcl::font { class PhysicalFontFace; }
typedef tools::SvRef<FontCharMap> FontCharMapRef; typedef tools::SvRef<FontCharMap> FontCharMapRef;
@ -37,7 +37,7 @@ class VCL_DLLPUBLIC FontMetric : public vcl::Font
public: public:
explicit FontMetric(); explicit FontMetric();
FontMetric( const FontMetric& ); // TODO make this explicit FontMetric( const FontMetric& ); // TODO make this explicit
FontMetric(PhysicalFontFace const& rFace); FontMetric(vcl::font::PhysicalFontFace const& rFace);
~FontMetric() override; ~FontMetric() override;
tools::Long GetAscent() const { return mnAscent; } tools::Long GetAscent() const { return mnAscent; }

5
include/vcl/vcllayout.hxx
View File

@ -24,13 +24,14 @@
#include <basegfx/polygon/b2dpolypolygon.hxx> #include <basegfx/polygon/b2dpolypolygon.hxx>
#include <tools/gen.hxx> #include <tools/gen.hxx>
#include <tools/degree.hxx> #include <tools/degree.hxx>
#include <vcl/devicecoordinate.hxx> #include <vcl/devicecoordinate.hxx>
#include <vcl/glyphitem.hxx> #include <vcl/glyphitem.hxx>
#include <vcl/dllapi.h> #include <vcl/dllapi.h>
class LogicalFontInstance; class LogicalFontInstance;
namespace vcl::text { class ImplLayoutArgs; } namespace vcl::text { class ImplLayoutArgs; }
class PhysicalFontFace; namespace vcl::font { class PhysicalFontFace; }
class SalGraphics; class SalGraphics;
class GlyphItem; class GlyphItem;
@ -93,7 +94,7 @@ public:
// methods using glyph indexing // methods using glyph indexing
virtual bool GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart, virtual bool GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart,
const LogicalFontInstance** ppGlyphFont = nullptr, const LogicalFontInstance** ppGlyphFont = nullptr,
const PhysicalFontFace** pFallbackFont = nullptr) const = 0; const vcl::font::PhysicalFontFace** pFallbackFont = nullptr) const = 0;
virtual bool GetOutline(basegfx::B2DPolyPolygonVector&) const; virtual bool GetOutline(basegfx::B2DPolyPolygonVector&) const;
bool GetBoundRect(tools::Rectangle&) const; bool GetBoundRect(tools::Rectangle&) const;

4
solenv/clang-format/excludelist
View File

@ -14420,7 +14420,6 @@ vcl/headless/svpvd.cxx
vcl/inc/IconThemeSelector.hxx vcl/inc/IconThemeSelector.hxx
vcl/inc/IPrioritable.hxx vcl/inc/IPrioritable.hxx
vcl/inc/PhysicalFontCollection.hxx vcl/inc/PhysicalFontCollection.hxx
vcl/inc/PhysicalFontFace.hxx
vcl/inc/PhysicalFontFamily.hxx vcl/inc/PhysicalFontFamily.hxx
vcl/inc/ResampleKernel.hxx vcl/inc/ResampleKernel.hxx
vcl/inc/WidgetThemeLibraryTypes.hxx vcl/inc/WidgetThemeLibraryTypes.hxx
@ -14440,6 +14439,7 @@ vcl/inc/dndlistenercontainer.hxx
vcl/inc/factory.hxx vcl/inc/factory.hxx
vcl/inc/fltcall.hxx vcl/inc/fltcall.hxx
vcl/inc/font/FontSelectPattern.hxx vcl/inc/font/FontSelectPattern.hxx
vcl/inc/font/PhysicalFontFace.hxx
vcl/inc/fontattributes.hxx vcl/inc/fontattributes.hxx
vcl/inc/fontinstance.hxx vcl/inc/fontinstance.hxx
vcl/inc/fontsubset.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/wmf.cxx
vcl/source/filter/wmf/wmfwr.cxx vcl/source/filter/wmf/wmfwr.cxx
vcl/source/filter/wmf/wmfwr.hxx vcl/source/filter/wmf/wmfwr.hxx
vcl/source/font/FontSelectPattern.cxx
vcl/source/font/PhysicalFontCollection.cxx vcl/source/font/PhysicalFontCollection.cxx
vcl/source/font/PhysicalFontFace.cxx vcl/source/font/PhysicalFontFace.cxx
vcl/source/font/PhysicalFontFamily.cxx vcl/source/font/PhysicalFontFamily.cxx
@ -14949,7 +14950,6 @@ vcl/source/font/fontcache.cxx
vcl/source/font/fontcharmap.cxx vcl/source/font/fontcharmap.cxx
vcl/source/font/fontinstance.cxx vcl/source/font/fontinstance.cxx
vcl/source/font/fontmetric.cxx vcl/source/font/fontmetric.cxx
vcl/source/font/fontselect.cxx
vcl/source/fontsubset/cff.cxx vcl/source/fontsubset/cff.cxx
vcl/source/fontsubset/fontsubset.cxx vcl/source/fontsubset/fontsubset.cxx
vcl/source/fontsubset/list.cxx vcl/source/fontsubset/list.cxx

1
vcl/CppunitTest_vcl_font.mk
View File

@ -16,6 +16,7 @@ $(eval $(call gb_CppunitTest_set_include,vcl_font,\
$(eval $(call gb_CppunitTest_add_exception_objects,vcl_font, \ $(eval $(call gb_CppunitTest_add_exception_objects,vcl_font, \
vcl/qa/cppunit/font \ vcl/qa/cppunit/font \
vcl/qa/cppunit/physicalfontface \
vcl/qa/cppunit/physicalfontfacecollection \ vcl/qa/cppunit/physicalfontfacecollection \
vcl/qa/cppunit/physicalfontfamily \ vcl/qa/cppunit/physicalfontfamily \
)) ))

2
vcl/Library_vcl.mk
View File

@ -473,12 +473,12 @@ $(eval $(call gb_Library_add_exception_objects,vcl,\
vcl/source/font/Feature \ vcl/source/font/Feature \
vcl/source/font/FeatureCollector \ vcl/source/font/FeatureCollector \
vcl/source/font/FeatureParser \ vcl/source/font/FeatureParser \
vcl/source/font/FontSelectPattern \
vcl/source/font/OpenTypeFeatureDefinitionList \ vcl/source/font/OpenTypeFeatureDefinitionList \
vcl/source/font/PhysicalFontCollection \ vcl/source/font/PhysicalFontCollection \
vcl/source/font/PhysicalFontFace \ vcl/source/font/PhysicalFontFace \
vcl/source/font/PhysicalFontFamily \ vcl/source/font/PhysicalFontFamily \
vcl/source/font/fontattributes \ vcl/source/font/fontattributes \
vcl/source/font/fontselect \
vcl/source/font/fontinstance \ vcl/source/font/fontinstance \
vcl/source/font/fontcache \ vcl/source/font/fontcache \
vcl/source/font/fontcharmap \ vcl/source/font/fontcharmap \

6
vcl/headless/svptext.cxx
View File

@ -65,7 +65,7 @@ bool SvpSalGraphics::AddTempDevFont( PhysicalFontCollection* pFontCollection,
bool SvpSalGraphics::CreateFontSubset( bool SvpSalGraphics::CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds, const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -75,7 +75,7 @@ bool SvpSalGraphics::CreateFontSubset(
return m_aTextRenderImpl.CreateFontSubset(rToFile, pFont, pGlyphIds, pEncoding, pWidths, nGlyphCount, rInfo); 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); return m_aTextRenderImpl.GetEmbedFontData(pFont, pDataLen);
} }
@ -85,7 +85,7 @@ void SvpSalGraphics::FreeEmbedFontData( const void* pData, tools::Long nLen )
m_aTextRenderImpl.FreeEmbedFontData(pData, nLen); m_aTextRenderImpl.FreeEmbedFontData(pData, nLen);
} }
void SvpSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont, void SvpSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) Ucs2UIntMap& rUnicodeEnc )

2
vcl/inc/PhysicalFontCollection.hxx
View File

@ -43,7 +43,7 @@ public:
~PhysicalFontCollection(); ~PhysicalFontCollection();
// fill the list with device font faces // fill the list with device font faces
void Add( PhysicalFontFace* ); void Add( vcl::font::PhysicalFontFace* );
void Clear(); void Clear();
int Count() const { return maPhysicalFontFamilies.size(); } int Count() const { return maPhysicalFontFamilies.size(); }

1
vcl/inc/font/FontSelectPattern.hxx
View File

@ -36,6 +36,7 @@ class Size;
namespace vcl::font namespace vcl::font
{ {
class PhysicalFontFace;
class VCL_DLLPUBLIC FontSelectPattern : public FontAttributes class VCL_DLLPUBLIC FontSelectPattern : public FontAttributes
{ {

9
vcl/inc/PhysicalFontFace.hxx → vcl/inc/font/PhysicalFontFace.hxx
View File

@ -28,7 +28,7 @@
#include <vcl/dllapi.h> #include <vcl/dllapi.h>
#include <vcl/fontcharmap.hxx> #include <vcl/fontcharmap.hxx>
#include "fontattributes.hxx" #include <fontattributes.hxx>
class LogicalFontInstance; class LogicalFontInstance;
struct FontMatchStatus; struct FontMatchStatus;
@ -44,6 +44,10 @@ struct FontCapabilities;
class PhysicalFontFamily; class PhysicalFontFamily;
} }
namespace vcl::font
{
class FontSelectPattern;
struct FontMatchStatus struct FontMatchStatus
{ {
public: public:
@ -53,7 +57,6 @@ public:
const OUString* mpTargetStyleName; const OUString* mpTargetStyleName;
}; };
// TODO: no more direct access to members // TODO: no more direct access to members
// TODO: get rid of height/width for scalable fonts // TODO: get rid of height/width for scalable fonts
// TODO: make cloning cheaper // TODO: make cloning cheaper
@ -80,6 +83,8 @@ protected:
explicit PhysicalFontFace(const FontAttributes&); explicit PhysicalFontFace(const FontAttributes&);
}; };
}
#endif // INCLUDED_VCL_INC_PHYSICALFONTFACE_HXX #endif // INCLUDED_VCL_INC_PHYSICALFONTFACE_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

2
vcl/inc/font/PhysicalFontFaceCollection.hxx
View File

@ -23,7 +23,7 @@
#include <vcl/dllapi.h> #include <vcl/dllapi.h>
#include <PhysicalFontFace.hxx> #include "PhysicalFontFace.hxx"
#include <vector> #include <vector>

5
vcl/inc/font/PhysicalFontFamily.hxx
View File

@ -28,9 +28,6 @@
#include <unotools/fontcfg.hxx> #include <unotools/fontcfg.hxx>
#include <PhysicalFontFace.hxx>
class PhysicalFontFace;
class PhysicalFontCollection; class PhysicalFontCollection;
namespace vcl::font namespace vcl::font
@ -59,6 +56,8 @@ struct typed_flags<vcl::font::FontTypeFaces> : is_typed_flags<vcl::font::FontTyp
namespace vcl::font namespace vcl::font
{ {
class FontSelectPattern;
class PhysicalFontFace;
class PhysicalFontFaceCollection; class PhysicalFontFaceCollection;
class VCL_PLUGIN_PUBLIC PhysicalFontFamily class VCL_PLUGIN_PUBLIC PhysicalFontFamily

10
vcl/inc/fontinstance.hxx
View File

@ -48,7 +48,7 @@ class VCL_PLUGIN_PUBLIC LogicalFontInstance : public salhelper::SimpleReferenceO
{ {
// just declaring the factory function doesn't work AKA // just declaring the factory function doesn't work AKA
// friend LogicalFontInstance* PhysicalFontFace::CreateFontInstance(const FontSelectPattern&) const; // friend LogicalFontInstance* PhysicalFontFace::CreateFontInstance(const FontSelectPattern&) const;
friend class PhysicalFontFace; friend class vcl::font::PhysicalFontFace;
friend class ImplFontCache; friend class ImplFontCache;
public: // TODO: make data members private public: // TODO: make data members private
@ -72,8 +72,8 @@ public: // TODO: make data members private
double GetAverageWidthFactor() const { return m_nAveWidthFactor; } double GetAverageWidthFactor() const { return m_nAveWidthFactor; }
const vcl::font::FontSelectPattern& GetFontSelectPattern() const { return m_aFontSelData; } const vcl::font::FontSelectPattern& GetFontSelectPattern() const { return m_aFontSelData; }
const PhysicalFontFace* GetFontFace() const { return m_pFontFace.get(); } const vcl::font::PhysicalFontFace* GetFontFace() const { return m_pFontFace.get(); }
PhysicalFontFace* GetFontFace() { return m_pFontFace.get(); } vcl::font::PhysicalFontFace* GetFontFace() { return m_pFontFace.get(); }
const ImplFontCache* GetFontCache() const { return mpFontCache; } const ImplFontCache* GetFontCache() const { return mpFontCache; }
bool GetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const; 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); static inline void DecodeOpenTypeTag(const uint32_t nTableTag, char* pTagName);
protected: 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; virtual bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const = 0;
@ -103,7 +103,7 @@ private:
const vcl::font::FontSelectPattern m_aFontSelData; const vcl::font::FontSelectPattern m_aFontSelData;
hb_font_t* m_pHbFont; hb_font_t* m_pHbFont;
double m_nAveWidthFactor; double m_nAveWidthFactor;
rtl::Reference<PhysicalFontFace> m_pFontFace; rtl::Reference<vcl::font::PhysicalFontFace> m_pFontFace;
std::optional<bool> m_xbIsGraphiteFont; std::optional<bool> m_xbIsGraphiteFont;
}; };

7
vcl/inc/headless/svpgdi.hxx
View File

@ -31,6 +31,7 @@
#include <vcl/sysdata.hxx> #include <vcl/sysdata.hxx>
#include <config_cairo_canvas.h> #include <config_cairo_canvas.h>
#include <font/PhysicalFontFace.hxx>
#include <salgdi.hxx> #include <salgdi.hxx>
#include <sallayout.hxx> #include <sallayout.hxx>
#include "svpcairotextrender.hxx" #include "svpcairotextrender.hxx"
@ -183,16 +184,16 @@ public:
virtual void ClearDevFontCache() override; virtual void ClearDevFontCache() override;
virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override; virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
virtual bool CreateFontSubset( const OUString& rToFile, virtual bool CreateFontSubset( const OUString& rToFile,
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
const sal_GlyphId* pGlyphIds, const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
int nGlyphs, int nGlyphs,
FontSubsetInfo& rInfo FontSubsetInfo& rInfo
) override; ) 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 FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
virtual void GetGlyphWidths( const PhysicalFontFace*, virtual void GetGlyphWidths( const vcl::font::PhysicalFontFace*,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) override; Ucs2UIntMap& rUnicodeEnc ) override;

2
vcl/inc/outdev.h
View File

@ -25,8 +25,8 @@
#include <tools/gen.hxx> #include <tools/gen.hxx>
#include <vcl/vclptr.hxx> #include <vcl/vclptr.hxx>
#include "font/PhysicalFontFace.hxx"
#include "fontinstance.hxx" #include "fontinstance.hxx"
#include "PhysicalFontFace.hxx"
#include "impfontcache.hxx" #include "impfontcache.hxx"
class Size; class Size;

24
vcl/inc/pch/precompiled_vcl.hxx
View File

@ -13,7 +13,7 @@
manual changes will be rewritten by the next run of update_pch.sh (which presumably 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). 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 ./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: If after updating build fails, use the following command to locate conflicting headers:
@ -33,9 +33,11 @@
#include <deque> #include <deque>
#include <float.h> #include <float.h>
#include <functional> #include <functional>
#include <hb.h>
#include <initializer_list> #include <initializer_list>
#include <iomanip> #include <iomanip>
#include <limits> #include <limits>
#include <list>
#include <map> #include <map>
#include <math.h> #include <math.h>
#include <memory> #include <memory>
@ -52,7 +54,6 @@
#include <unordered_map> #include <unordered_map>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <boost/functional/hash.hpp>
#include <boost/math/special_functions/sinc.hpp> #include <boost/math/special_functions/sinc.hpp>
#include <boost/multi_array.hpp> #include <boost/multi_array.hpp>
#include <boost/property_tree/json_parser.hpp> #include <boost/property_tree/json_parser.hpp>
@ -80,6 +81,7 @@
#include <rtl/bootstrap.hxx> #include <rtl/bootstrap.hxx>
#include <rtl/byteseq.hxx> #include <rtl/byteseq.hxx>
#include <rtl/character.hxx> #include <rtl/character.hxx>
#include <rtl/cipher.h>
#include <rtl/crc.h> #include <rtl/crc.h>
#include <rtl/digest.h> #include <rtl/digest.h>
#include <rtl/instance.hxx> #include <rtl/instance.hxx>
@ -129,8 +131,6 @@
#include <basegfx/vector/b2enums.hxx> #include <basegfx/vector/b2enums.hxx>
#include <basegfx/vector/b2ivector.hxx> #include <basegfx/vector/b2ivector.hxx>
#include <bitmap/BitmapWriteAccess.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/beans/PropertyValue.hpp>
#include <com/sun/star/datatransfer/DataFlavor.hpp> #include <com/sun/star/datatransfer/DataFlavor.hpp>
#include <com/sun/star/datatransfer/XTransferable2.hpp> #include <com/sun/star/datatransfer/XTransferable2.hpp>
@ -146,8 +146,13 @@
#include <com/sun/star/embed/Aspects.hpp> #include <com/sun/star/embed/Aspects.hpp>
#include <com/sun/star/frame/XTerminateListener.hpp> #include <com/sun/star/frame/XTerminateListener.hpp>
#include <com/sun/star/i18n/Calendar2.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/TransliterationModules.hpp>
#include <com/sun/star/i18n/TransliterationModulesExtra.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/DisposedException.hpp>
#include <com/sun/star/lang/EventObject.hpp> #include <com/sun/star/lang/EventObject.hpp>
#include <com/sun/star/lang/Locale.hpp> #include <com/sun/star/lang/Locale.hpp>
@ -190,10 +195,14 @@
#include <cppuhelper/weak.hxx> #include <cppuhelper/weak.hxx>
#include <cppuhelper/weakagg.hxx> #include <cppuhelper/weakagg.hxx>
#include <cppuhelper/weakref.hxx> #include <cppuhelper/weakref.hxx>
#include <font/FontSelectPattern.hxx>
#include <font/PhysicalFontFace.hxx>
#include <font/PhysicalFontFaceCollection.hxx>
#include <i18nlangtag/lang.h> #include <i18nlangtag/lang.h>
#include <i18nlangtag/languagetag.hxx> #include <i18nlangtag/languagetag.hxx>
#include <i18nlangtag/mslangid.hxx> #include <i18nlangtag/mslangid.hxx>
#include <i18nutil/i18nutildllapi.h> #include <i18nutil/i18nutildllapi.h>
#include <i18nutil/transliteration.hxx>
#include <o3tl/cow_wrapper.hxx> #include <o3tl/cow_wrapper.hxx>
#include <o3tl/safeint.hxx> #include <o3tl/safeint.hxx>
#include <o3tl/sorted_vector.hxx> #include <o3tl/sorted_vector.hxx>
@ -246,18 +255,20 @@
#include <uno/any2.h> #include <uno/any2.h>
#include <uno/data.h> #include <uno/data.h>
#include <uno/sequence2.h> #include <uno/sequence2.h>
#include <unotools/calendarwrapper.hxx>
#include <unotools/configmgr.hxx> #include <unotools/configmgr.hxx>
#include <unotools/localedatawrapper.hxx> #include <unotools/localedatawrapper.hxx>
#include <unotools/resmgr.hxx>
#include <unotools/syslocale.hxx> #include <unotools/syslocale.hxx>
#include <unotools/ucbstreamhelper.hxx> #include <unotools/ucbstreamhelper.hxx>
#include <unotools/unotoolsdllapi.h> #include <unotools/unotoolsdllapi.h>
#endif // PCH_LEVEL >= 3 #endif // PCH_LEVEL >= 3
#if PCH_LEVEL >= 4 #if PCH_LEVEL >= 4
#include <PhysicalFontCollection.hxx> #include <PhysicalFontCollection.hxx>
#include <PhysicalFontFace.hxx>
#include <accel.hxx> #include <accel.hxx>
#include <brdwin.hxx> #include <brdwin.hxx>
#include <configsettings.hxx> #include <configsettings.hxx>
#include <drawmode.hxx>
#include <fontattributes.hxx> #include <fontattributes.hxx>
#include <impglyphitem.hxx> #include <impglyphitem.hxx>
#include <outdev.h> #include <outdev.h>
@ -303,6 +314,8 @@
#include <vcl/dllapi.h> #include <vcl/dllapi.h>
#include <vcl/dockwin.hxx> #include <vcl/dockwin.hxx>
#include <vcl/event.hxx> #include <vcl/event.hxx>
#include <vcl/filter/SvmReader.hxx>
#include <vcl/filter/SvmWriter.hxx>
#include <vcl/fntstyle.hxx> #include <vcl/fntstyle.hxx>
#include <vcl/font.hxx> #include <vcl/font.hxx>
#include <vcl/formatter.hxx> #include <vcl/formatter.hxx>
@ -354,6 +367,7 @@
#include <vcl/unohelp.hxx> #include <vcl/unohelp.hxx>
#include <vcl/vclenum.hxx> #include <vcl/vclenum.hxx>
#include <vcl/vclevent.hxx> #include <vcl/vclevent.hxx>
#include <vcl/vcllayout.hxx>
#include <vcl/vclptr.hxx> #include <vcl/vclptr.hxx>
#include <vcl/virdev.hxx> #include <vcl/virdev.hxx>
#include <vcl/weld.hxx> #include <vcl/weld.hxx>

6
vcl/inc/pdf/pdfbuildin_fonts.hxx
View File

@ -21,7 +21,7 @@
#include <sal/config.h> #include <sal/config.h>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <fontinstance.hxx> #include <fontinstance.hxx>
namespace vcl::pdf namespace vcl::pdf
@ -52,12 +52,12 @@ class BuildinFontInstance final : public LogicalFontInstance
bool ImplGetGlyphBoundRect(sal_GlyphId nID, tools::Rectangle& rRect, bool) const override; bool ImplGetGlyphBoundRect(sal_GlyphId nID, tools::Rectangle& rRect, bool) const override;
public: 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; 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]; static const BuildinFont m_aBuildinFonts[14];
const BuildinFont& mrBuildin; const BuildinFont& mrBuildin;

6
vcl/inc/pdf/pdffontcache.hxx
View File

@ -37,7 +37,7 @@ namespace vcl
bool m_bVertical; bool m_bVertical;
std::type_info* m_typeFontFace; 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 // Less than needed for std::set and std::map
bool operator<( const FontIdentifier& rRight ) const bool operator<( const FontIdentifier& rRight ) const
@ -60,11 +60,11 @@ namespace vcl
std::vector< FontData > m_aFonts; std::vector< FontData > m_aFonts;
FontToIndexMap m_aFontToIndex; FontToIndexMap m_aFontToIndex;
FontData& getFont( const PhysicalFontFace*, bool bVertical ); FontData& getFont( const vcl::font::PhysicalFontFace*, bool bVertical );
public: public:
PDFFontCache() {} PDFFontCache() {}
sal_Int32 getGlyphWidth( const PhysicalFontFace*, sal_GlyphId, bool bVertical, SalGraphics* ); sal_Int32 getGlyphWidth( const vcl::font::PhysicalFontFace*, sal_GlyphId, bool bVertical, SalGraphics* );
}; };
} }

12
vcl/inc/pdf/pdfwriter_impl.hxx
View File

@ -64,7 +64,7 @@ class FontSubsetInfo;
class ZCodec; class ZCodec;
class EncHashTransporter; class EncHashTransporter;
struct BitStreamState; struct BitStreamState;
class PhysicalFontFace; namespace vcl::font { class PhysicalFontFace; }
class SvStream; class SvStream;
class SvMemoryStream; class SvMemoryStream;
@ -721,8 +721,8 @@ private:
std::vector< TilingEmit > m_aTilings; std::vector< TilingEmit > m_aTilings;
std::vector< TransparencyEmit > m_aTransparentObjects; std::vector< TransparencyEmit > m_aTransparentObjects;
/* contains all font subsets in use */ /* contains all font subsets in use */
std::map<const PhysicalFontFace*, FontSubset> m_aSubsets; std::map<const vcl::font::PhysicalFontFace*, FontSubset> m_aSubsets;
std::map<const PhysicalFontFace*, EmbedFont> m_aSystemFonts; std::map<const vcl::font::PhysicalFontFace*, EmbedFont> m_aSystemFonts;
sal_Int32 m_nNextFID; sal_Int32 m_nNextFID;
PDFFontCache m_aFontCache; PDFFontCache m_aFontCache;
@ -807,7 +807,7 @@ i12626
void appendLiteralStringEncrypt( std::string_view rInString, const sal_Int32 nInObjectNumber, OStringBuffer& rOutBuffer ); void appendLiteralStringEncrypt( std::string_view rInString, const sal_Int32 nInObjectNumber, OStringBuffer& rOutBuffer );
/* creates fonts and subsets that will be emitted later */ /* 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 */ /* 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 */ /* 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 ) */ /* writes a builtin font object and returns its objectid (or 0 in case of failure ) */
sal_Int32 emitBuildinFont( const pdf::BuildinFontFace*, sal_Int32 nObject ); 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 ) */ /* 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) */ /* 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 */ /* writes a ToUnicode cmap, returns the corresponding stream object */
sal_Int32 createToUnicodeCMap( sal_uInt8 const * pEncoding, const sal_Ucs* pCodeUnits, const sal_Int32* pCodeUnitsPerGlyph, sal_Int32 createToUnicodeCMap( sal_uInt8 const * pEncoding, const sal_Ucs* pCodeUnits, const sal_Int32* pCodeUnitsPerGlyph,
const sal_Int32* pEncToUnicodeIndex, int nGlyphs ); const sal_Int32* pEncToUnicodeIndex, int nGlyphs );

2
vcl/inc/qt5/QtFont.hxx
View File

@ -37,7 +37,7 @@ class QtFont final : public QFont, public LogicalFontInstance
virtual hb_font_t* ImplInitHbFont() override; 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: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

4
vcl/inc/qt5/QtFontFace.hxx
View File

@ -22,7 +22,7 @@
#include <sal/config.h> #include <sal/config.h>
#include <vclpluginapi.h> #include <vclpluginapi.h>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <tools/ref.hxx> #include <tools/ref.hxx>
#include <vcl/fontcapabilities.hxx> #include <vcl/fontcapabilities.hxx>
@ -37,7 +37,7 @@ namespace vcl::font
class FontSelectPattern; class FontSelectPattern;
} }
class QtFontFace final : public PhysicalFontFace class QtFontFace final : public vcl::font::PhysicalFontFace
{ {
public: public:
static QtFontFace* fromQFont(const QFont& rFont); static QtFontFace* fromQFont(const QFont& rFont);

7
vcl/inc/qt5/QtGraphics.hxx
View File

@ -228,16 +228,17 @@ public:
virtual void ClearDevFontCache() override; virtual void ClearDevFontCache() override;
virtual bool AddTempDevFont(PhysicalFontCollection*, const OUString& rFileURL, virtual bool AddTempDevFont(PhysicalFontCollection*, const OUString& rFileURL,
const OUString& rFontName) override; 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, const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
sal_Int32* pWidths, int nGlyphs, sal_Int32* pWidths, int nGlyphs,
FontSubsetInfo& rInfo // out parameter FontSubsetInfo& rInfo // out parameter
) override; ) 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 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; std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc) override;
virtual std::unique_ptr<GenericSalLayout> GetTextLayout(int nFallbackLevel) override; virtual std::unique_ptr<GenericSalLayout> GetTextLayout(int nFallbackLevel) override;

14
vcl/inc/quartz/salgdi.h
View File

@ -44,7 +44,7 @@
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <impfontmetricdata.hxx> #include <impfontmetricdata.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <salgdi.hxx> #include <salgdi.hxx>
#include <quartz/salgdicommon.hxx> #include <quartz/salgdicommon.hxx>
@ -58,7 +58,7 @@ class FontAttributes;
class XorEmulation; class XorEmulation;
// CoreText-specific physically available font face // CoreText-specific physically available font face
class CoreTextFontFace : public PhysicalFontFace class CoreTextFontFace : public vcl::font::PhysicalFontFace
{ {
public: public:
CoreTextFontFace( const FontAttributes&, sal_IntPtr nFontID ); CoreTextFontFace( const FontAttributes&, sal_IntPtr nFontID );
@ -102,7 +102,7 @@ public:
bool mbFauxBold; bool mbFauxBold;
private: private:
explicit CoreTextStyle(const PhysicalFontFace&, const vcl::font::FontSelectPattern&); explicit CoreTextStyle(const vcl::font::PhysicalFontFace&, const vcl::font::FontSelectPattern&);
hb_font_t* ImplInitHbFont() override; hb_font_t* ImplInitHbFont() override;
bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const 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 // implementation note: encoding 0 with glyph id 0 should be added implicitly
// as "undefined character" // as "undefined character"
virtual bool CreateFontSubset( const OUString& rToFile, virtual bool CreateFontSubset( const OUString& rToFile,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds, const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -564,12 +564,12 @@ public:
// embeddable by GetDevFontList or NULL in case of error // embeddable by GetDevFontList or NULL in case of error
// parameters: pFont: describes the font in question // parameters: pFont: describes the font in question
// pDataLen: out parameter, contains the byte length of the returned buffer // 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; override;
// frees the font data again // frees the font data again
virtual void FreeEmbedFontData( const void* pData, tools::Long nDataLen ) 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, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) override; Ucs2UIntMap& rUnicodeEnc ) override;
@ -582,7 +582,7 @@ public:
GetGraphicsData() const override; GetGraphicsData() const override;
private: private:
static bool GetRawFontData( const PhysicalFontFace* pFontData, static bool GetRawFontData( const vcl::font::PhysicalFontFace* pFontData,
std::vector<unsigned char>& rBuffer, std::vector<unsigned char>& rBuffer,
bool* pJustCFF ); bool* pJustCFF );
}; };

13
vcl/inc/salgdi.hxx
View File

@ -38,7 +38,10 @@
class PhysicalFontCollection; class PhysicalFontCollection;
class SalBitmap; class SalBitmap;
class FontAttributes; class FontAttributes;
class PhysicalFontFace; namespace vcl::font {
class FontSelectPattern;
class PhysicalFontFace;
}
class SalLayout; class SalLayout;
namespace tools { class Rectangle; } namespace tools { class Rectangle; }
class FontSubsetInfo; class FontSubsetInfo;
@ -173,7 +176,7 @@ public:
// as "undefined character" // as "undefined character"
virtual bool CreateFontSubset( virtual bool CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIDs, const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -184,7 +187,7 @@ public:
// embeddable by GetDevFontList or NULL in case of error // embeddable by GetDevFontList or NULL in case of error
// parameters: pFont: describes the font in question // parameters: pFont: describes the font in question
// pDataLen: out parameter, contains the byte length of the returned buffer // 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 // free the font data again
virtual void FreeEmbedFontData( const void* pData, tools::Long nDataLen ) = 0; virtual void FreeEmbedFontData( const void* pData, tools::Long nDataLen ) = 0;
@ -194,7 +197,7 @@ public:
// between unicode and glyph id // between unicode and glyph id
// leave widths vector and mapping untouched in case of failure // leave widths vector and mapping untouched in case of failure
virtual void GetGlyphWidths( virtual void GetGlyphWidths(
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) = 0; Ucs2UIntMap& rUnicodeEnc ) = 0;
@ -648,7 +651,7 @@ protected:
vcl::WidgetDrawInterface* forWidget() { return m_pWidgetDraw ? m_pWidgetDraw.get() : this; } vcl::WidgetDrawInterface* forWidget() { return m_pWidgetDraw ? m_pWidgetDraw.get() : this; }
static void GetGlyphWidths(const vcl::AbstractTrueTypeFont& rTTF, 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); std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc);
static bool CreateTTFfontSubset(vcl::AbstractTrueTypeFont& aTTF, const OString& rSysPath, static bool CreateTTFfontSubset(vcl::AbstractTrueTypeFont& aTTF, const OString& rSysPath,

10
vcl/inc/sallayout.hxx
View File

@ -45,10 +45,14 @@
#define MAX_FALLBACK 16 #define MAX_FALLBACK 16
class PhysicalFontFace;
class GenericSalLayout; class GenericSalLayout;
class SalGraphics; class SalGraphics;
enum class SalLayoutFlags; enum class SalLayoutFlags;
namespace vcl::font {
class PhysicalFontFace;
}
namespace vcl::text { namespace vcl::text {
class TextLayoutCache; class TextLayoutCache;
} }
@ -62,7 +66,7 @@ public:
void GetCaretPositions(int nArraySize, tools::Long* pCaretXArray) const override; void GetCaretPositions(int nArraySize, tools::Long* pCaretXArray) const override;
bool GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart, bool GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart,
const LogicalFontInstance** ppGlyphFont = nullptr, 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 GetOutline(basegfx::B2DPolyPolygonVector&) const override;
bool IsKashidaPosValid(int nCharPos) const override; bool IsKashidaPosValid(int nCharPos) const override;
SalLayoutGlyphs GetGlyphs() const final override; SalLayoutGlyphs GetGlyphs() const final override;
@ -119,7 +123,7 @@ public:
bool GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart, bool GetNextGlyph(const GlyphItem** pGlyph, Point& rPos, int& nStart,
const LogicalFontInstance** ppGlyphFont = nullptr, 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; } const SalLayoutGlyphsImpl& GlyphsImpl() const { return m_GlyphItems; }

8
vcl/inc/textrender.hxx
View File

@ -26,7 +26,7 @@
class ImplFontMetricData; class ImplFontMetricData;
class PhysicalFontCollection; class PhysicalFontCollection;
class PhysicalFontFace; namespace vcl::font { class PhysicalFontFace; }
class TextRenderImpl class TextRenderImpl
{ {
@ -45,17 +45,17 @@ public:
virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) = 0; virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) = 0;
virtual bool CreateFontSubset( virtual bool CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
const sal_GlyphId* pGlyphIDs, const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
int nGlyphs, int nGlyphs,
FontSubsetInfo& rInfo) = 0; 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 FreeEmbedFontData( const void* pData, tools::Long nDataLen ) = 0;
virtual void GetGlyphWidths( virtual void GetGlyphWidths(
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) = 0; Ucs2UIntMap& rUnicodeEnc ) = 0;

2
vcl/inc/unx/cairotextrender.hxx
View File

@ -22,6 +22,8 @@
#include <unx/freetypetextrender.hxx> #include <unx/freetypetextrender.hxx>
class GenericSalLayout;
class SalGraphics;
typedef struct _cairo cairo_t; typedef struct _cairo cairo_t;
class VCL_DLLPUBLIC CairoTextRender : public FreeTypeTextRenderImpl class VCL_DLLPUBLIC CairoTextRender : public FreeTypeTextRenderImpl

8
vcl/inc/unx/freetype_glyphcache.hxx
View File

@ -22,7 +22,7 @@
#include <sal/config.h> #include <sal/config.h>
#include <unx/glyphcache.hxx> #include <unx/glyphcache.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <vcl/glyphitem.hxx> #include <vcl/glyphitem.hxx>
@ -92,7 +92,7 @@ private:
mutable FontCharMapRef mxFontCharMap; mutable FontCharMapRef mxFontCharMap;
}; };
class FreetypeFontFace : public PhysicalFontFace class FreetypeFontFace : public vcl::font::PhysicalFontFace
{ {
private: private:
FreetypeFontInfo* mpFreetypeFontInfo; FreetypeFontInfo* mpFreetypeFontInfo;
@ -100,7 +100,7 @@ private:
public: public:
FreetypeFontFace( FreetypeFontInfo*, const FontAttributes& ); 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(); } virtual sal_IntPtr GetFontId() const override { return mpFreetypeFontInfo->GetFontId(); }
FontCharMapRef GetFontCharMap() const override { return mpFreetypeFontInfo->GetFontCharMap(); } 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 hb_font_t* ImplInitHbFont() override;
virtual bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const 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: public:
virtual ~FreetypeFontInstance() override; virtual ~FreetypeFontInstance() override;

6
vcl/inc/unx/freetypetextrender.hxx
View File

@ -49,17 +49,17 @@ public:
virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override; virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
virtual bool CreateFontSubset( virtual bool CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
const sal_GlyphId* pGlyphIDs, const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
int nGlyphs, int nGlyphs,
FontSubsetInfo& rInfo) override; 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 FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
virtual void GetGlyphWidths( virtual void GetGlyphWidths(
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) override; Ucs2UIntMap& rUnicodeEnc ) override;

8
vcl/inc/unx/genpspgraphics.h
View File

@ -30,7 +30,7 @@
#include <unx/GenPspGfxBackend.hxx> #include <unx/GenPspGfxBackend.hxx>
class PhysicalFontFace; namespace vcl::font { class PhysicalFontFace; }
class PhysicalFontCollection; class PhysicalFontCollection;
namespace psp { struct JobData; class PrinterGfx; } namespace psp { struct JobData; class PrinterGfx; }
@ -93,15 +93,15 @@ public:
const OUString& rFontName); const OUString& rFontName);
virtual bool CreateFontSubset( const OUString& rToFile, virtual bool CreateFontSubset( const OUString& rToFile,
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
const sal_GlyphId* pGlyphIDs, const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
int nGlyphs, int nGlyphs,
FontSubsetInfo& rInfo ) override; 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 FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
virtual void GetGlyphWidths( const PhysicalFontFace*, virtual void GetGlyphWidths( const vcl::font::PhysicalFontFace*,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) override; Ucs2UIntMap& rUnicodeEnc ) override;

8
vcl/inc/unx/salgdi.h
View File

@ -51,7 +51,7 @@ class X11SalVirtualDevice;
class X11SalGraphicsImpl; class X11SalGraphicsImpl;
class X11SkiaSalVirtualDevice; class X11SkiaSalVirtualDevice;
class PhysicalFontCollection; class PhysicalFontCollection;
class PhysicalFontFace; namespace vcl::font { class PhysicalFontFace; }
class SalGraphicsImpl; class SalGraphicsImpl;
class TextRenderImpl; class TextRenderImpl;
@ -122,18 +122,18 @@ public:
virtual bool CreateFontSubset( virtual bool CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
const sal_GlyphId* pGlyphIDs, const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
int nGlyphs, int nGlyphs,
FontSubsetInfo& rInfo ) override; 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 FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
virtual void GetGlyphWidths( virtual void GetGlyphWidths(
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) override; Ucs2UIntMap& rUnicodeEnc ) override;

14
vcl/inc/win/salgdi.h
View File

@ -26,7 +26,7 @@
#include <salgdi.hxx> #include <salgdi.hxx>
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <fontattributes.hxx> #include <fontattributes.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <impfont.hxx> #include <impfont.hxx>
#include <vcl/fontcapabilities.hxx> #include <vcl/fontcapabilities.hxx>
#include <vcl/fontcharmap.hxx> #include <vcl/fontcharmap.hxx>
@ -58,7 +58,7 @@ class ImplFontMetricData;
#define PALRGB_TO_RGB(nPalRGB) ((nPalRGB)&0x00ffffff) #define PALRGB_TO_RGB(nPalRGB) ((nPalRGB)&0x00ffffff)
// win32 specific physically available font face // win32 specific physically available font face
class WinFontFace : public PhysicalFontFace class WinFontFace : public vcl::font::PhysicalFontFace
{ {
public: public:
explicit WinFontFace( const FontAttributes&, explicit WinFontFace( const FontAttributes&,
@ -174,7 +174,7 @@ private:
void DeInitGraphics(); void DeInitGraphics();
public: 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; } HDC getHDC() const { return mhLocalDC; }
void setHDC(HDC aNew); void setHDC(HDC aNew);
@ -364,7 +364,7 @@ public:
// implementation note: encoding 0 with glyph id 0 should be added implicitly // implementation note: encoding 0 with glyph id 0 should be added implicitly
// as "undefined character" // as "undefined character"
virtual bool CreateFontSubset( const OUString& rToFile, virtual bool CreateFontSubset( const OUString& rToFile,
const PhysicalFontFace*, const vcl::font::PhysicalFontFace*,
const sal_GlyphId* pGlyphIDs, const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -376,10 +376,10 @@ public:
// embeddable by GetDevFontList or NULL in case of error // embeddable by GetDevFontList or NULL in case of error
// parameters: pFont: describes the font in question // parameters: pFont: describes the font in question
// pDataLen: out parameter, contains the byte length of the returned buffer // 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 // frees the font data again
virtual void FreeEmbedFontData( const void* pData, tools::Long nDataLen ) 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, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) override; Ucs2UIntMap& rUnicodeEnc ) override;
@ -400,7 +400,7 @@ public:
void ImplUpdateSysColorEntries(); void ImplUpdateSysColorEntries();
int ImplIsSysColorEntry( Color nColor ); int ImplIsSysColorEntry( Color nColor );
void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern&, void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern&,
const PhysicalFontFace*, LOGFONTW& ); const vcl::font::PhysicalFontFace*, LOGFONTW& );
#define MAX_64KSALPOINTS ((((sal_uInt16)0xFFFF)-8)/sizeof(POINTS)) #define MAX_64KSALPOINTS ((((sal_uInt16)0xFFFF)-8)/sizeof(POINTS))

14
vcl/qa/cppunit/fontmocks.hxx
View File

@ -7,18 +7,20 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/ */
#pragma once
#include <sal/config.h> #include <sal/config.h>
#include <PhysicalFontFace.hxx> #include <font/FontSelectPattern.hxx>
#include <font/PhysicalFontFace.hxx>
#include <font/PhysicalFontFaceCollection.hxx> #include <font/PhysicalFontFaceCollection.hxx>
#include <fontattributes.hxx> #include <fontattributes.hxx>
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <font/FontSelectPattern.hxx>
class TestFontInstance : public LogicalFontInstance class TestFontInstance : public LogicalFontInstance
{ {
public: public:
TestFontInstance(PhysicalFontFace const& rFontFace, TestFontInstance(vcl::font::PhysicalFontFace const& rFontFace,
vcl::font::FontSelectPattern const& rFontSelectPattern) vcl::font::FontSelectPattern const& rFontSelectPattern)
: LogicalFontInstance(rFontFace, rFontSelectPattern) : LogicalFontInstance(rFontFace, rFontSelectPattern)
{ {
@ -33,17 +35,17 @@ protected:
bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override { return true; } bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override { return true; }
}; };
class TestFontFace : public PhysicalFontFace class TestFontFace : public vcl::font::PhysicalFontFace
{ {
public: public:
TestFontFace(sal_uIntPtr nId) TestFontFace(sal_uIntPtr nId)
: PhysicalFontFace(FontAttributes()) : vcl::font::PhysicalFontFace(FontAttributes())
, mnFontId(nId) , mnFontId(nId)
{ {
} }
TestFontFace(FontAttributes const& rFontAttributes, sal_uIntPtr nId) TestFontFace(FontAttributes const& rFontAttributes, sal_uIntPtr nId)
: PhysicalFontFace(rFontAttributes) : vcl::font::PhysicalFontFace(rFontAttributes)
, mnFontId(nId) , mnFontId(nId)
{ {
} }

301
vcl/qa/cppunit/physicalfontface.cxx Normal file
View File

@ -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: */

4
vcl/qa/cppunit/physicalfontfacecollection.cxx
View File

@ -42,8 +42,8 @@ void VclPhysicalFontFaceCollectionTest::testShouldGetFontId()
vcl::font::PhysicalFontFaceCollection aCollection; vcl::font::PhysicalFontFaceCollection aCollection;
aCollection.Add(new TestFontFace(1988756)); aCollection.Add(new TestFontFace(1988756));
rtl::Reference<PhysicalFontFace> pActual(new TestFontFace(1988756)); rtl::Reference<vcl::font::PhysicalFontFace> pActual(new TestFontFace(1988756));
rtl::Reference<PhysicalFontFace> pExpected = aCollection.Get(0); rtl::Reference<vcl::font::PhysicalFontFace> pExpected = aCollection.Get(0);
CPPUNIT_ASSERT_EQUAL(pExpected->GetFontId(), pActual->GetFontId()); CPPUNIT_ASSERT_EQUAL(pExpected->GetFontId(), pActual->GetFontId());
CPPUNIT_ASSERT_EQUAL(1, aCollection.Count()); CPPUNIT_ASSERT_EQUAL(1, aCollection.Count());

2
vcl/qt5/QtFont.cxx
View File

@ -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) : LogicalFontInstance(rPFF, rFSP)
{ {
setFamily(toQString(rPFF.GetFamilyName())); setFamily(toQString(rPFF.GetFamilyName()));

2
vcl/qt5/QtFontFace.cxx
View File

@ -39,7 +39,7 @@
using namespace vcl; using namespace vcl;
QtFontFace::QtFontFace(const QtFontFace& rSrc) QtFontFace::QtFontFace(const QtFontFace& rSrc)
: PhysicalFontFace(rSrc) : vcl::font::PhysicalFontFace(rSrc)
, m_aFontId(rSrc.m_aFontId) , m_aFontId(rSrc.m_aFontId)
, m_eFontIdType(rSrc.m_eFontIdType) , m_eFontIdType(rSrc.m_eFontIdType)
{ {

8
vcl/qt5/QtGraphics_Text.cxx
View File

@ -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, const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo) sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo)
{ {
@ -254,14 +255,15 @@ bool QtGraphics::CreateFontSubset(const OUString& rToFile, const PhysicalFontFac
pGlyphIds, pEncoding, pGlyphWidths, nGlyphCount); 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; return nullptr;
} }
void QtGraphics::FreeEmbedFontData(const void* /*pData*/, tools::Long /*nDataLen*/) {} 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) std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc)
{ {
const QtFontFace* pQtFontFace = static_cast<const QtFontFace*>(pFontFace); const QtFontFace* pQtFontFace = static_cast<const QtFontFace*>(pFontFace);

2
vcl/quartz/ctfonts.cxx
View File

@ -46,7 +46,7 @@ static double toRadian(int nDegree)
return nDegree * (M_PI / 1800.0); 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) : LogicalFontInstance(rPFF, rFSP)
, mfFontStretch( 1.0 ) , mfFontStretch( 1.0 )
, mfFontRotation( 0.0 ) , mfFontRotation( 0.0 )

8
vcl/quartz/salgdi.cxx
View File

@ -109,7 +109,7 @@ bool CoreTextGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSele
} }
CoreTextFontFace::CoreTextFontFace( const FontAttributes& rDFA, sal_IntPtr nFontId ) CoreTextFontFace::CoreTextFontFace( const FontAttributes& rDFA, sal_IntPtr nFontId )
: PhysicalFontFace( rDFA ) : vcl::font::PhysicalFontFace( rDFA )
, mnFontId( nFontId ) , mnFontId( nFontId )
, mbFontCapabilitiesRead( false ) , 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 // 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. // 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 ) std::vector<unsigned char>& rBuffer, bool* pJustCFF )
{ {
const CoreTextFontFace* pMacFont = static_cast<const CoreTextFontFace*>(pFontData); const CoreTextFontFace* pMacFont = static_cast<const CoreTextFontFace*>(pFontData);
@ -742,7 +742,7 @@ bool AquaSalGraphics::GetRawFontData( const PhysicalFontFace* pFontData,
return true; 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 ) std::vector< sal_Int32 >& rGlyphWidths, Ucs2UIntMap& rUnicodeEnc )
{ {
rGlyphWidths.clear(); rGlyphWidths.clear();
@ -768,7 +768,7 @@ void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bV
::CloseTTFont( pSftFont ); ::CloseTTFont( pSftFont );
} }
const void* AquaSalGraphics::GetEmbedFontData(const PhysicalFontFace*, tools::Long* /*pDataLen*/) const void* AquaSalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* /*pDataLen*/)
{ {
return nullptr; return nullptr;
} }

2
vcl/quartz/salgdicommon.cxx
View File

@ -47,7 +47,7 @@
using namespace vcl; using namespace vcl;
bool AquaSalGraphics::CreateFontSubset( const OUString& rToFile, bool AquaSalGraphics::CreateFontSubset( const OUString& rToFile,
const PhysicalFontFace* pFontData, const vcl::font::PhysicalFontFace* pFontData,
const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding, const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
sal_Int32* pGlyphWidths, const int nGlyphCount, sal_Int32* pGlyphWidths, const int nGlyphCount,
FontSubsetInfo& rInfo ) FontSubsetInfo& rInfo )

3
vcl/source/font/fontselect.cxx → vcl/source/font/FontSelectPattern.cxx
View File

@ -20,10 +20,11 @@
#include <sal/config.h> #include <sal/config.h>
#include <o3tl/safeint.hxx> #include <o3tl/safeint.hxx>
#include <tools/gen.hxx> #include <tools/gen.hxx>
#include <vcl/font.hxx> #include <vcl/font.hxx>
#include <PhysicalFontFace.hxx>
#include <font/FontSelectPattern.hxx> #include <font/FontSelectPattern.hxx>
#include <font/PhysicalFontFace.hxx>
namespace vcl::font namespace vcl::font
{ {

2
vcl/source/font/PhysicalFontCollection.cxx
View File

@ -276,7 +276,7 @@ vcl::font::PhysicalFontFamily* PhysicalFontCollection::GetGlyphFallbackFont( vcl
return pFallbackData; return pFallbackData;
} }
void PhysicalFontCollection::Add( PhysicalFontFace* pNewData ) void PhysicalFontCollection::Add( vcl::font::PhysicalFontFace* pNewData )
{ {
OUString aSearchName = GetEnglishSearchFontName( pNewData->GetFamilyName() ); OUString aSearchName = GetEnglishSearchFontName( pNewData->GetFamilyName() );

8
vcl/source/font/PhysicalFontFace.cxx
View File

@ -24,9 +24,12 @@
#include <unotools/fontdefs.hxx> #include <unotools/fontdefs.hxx>
#include <fontattributes.hxx> #include <fontattributes.hxx>
#include <font/FontSelectPattern.hxx>
#include <PhysicalFontFace.hxx> #include <font/FontSelectPattern.hxx>
#include <font/PhysicalFontFace.hxx>
namespace vcl::font
{
PhysicalFontFace::PhysicalFontFace( const FontAttributes& rDFA ) PhysicalFontFace::PhysicalFontFace( const FontAttributes& rDFA )
: FontAttributes( rDFA ) : FontAttributes( rDFA )
@ -176,5 +179,6 @@ bool PhysicalFontFace::IsBetterMatch( const vcl::font::FontSelectPattern& rFSD,
rStatus.mnWidthMatch = nWidthMatch; rStatus.mnWidthMatch = nWidthMatch;
return true; return true;
} }
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */

5
vcl/source/font/fontcache.cxx
View File

@ -18,10 +18,11 @@
*/ */
#include <sal/config.h> #include <sal/config.h>
#include <sal/log.hxx> #include <sal/log.hxx>
#include <PhysicalFontCollection.hxx> #include <PhysicalFontCollection.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <font/PhysicalFontFamily.hxx> #include <font/PhysicalFontFamily.hxx>
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <impfontcache.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 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 // create a new logical font instance from this physical font face
pFontInstance = pFontData->CreateFontInstance( aFontSelData ); pFontInstance = pFontData->CreateFontInstance( aFontSelData );

6
vcl/source/font/fontinstance.cxx
View File

@ -22,9 +22,9 @@
#include <hb-ot.h> #include <hb-ot.h>
#include <hb-graphite2.h> #include <hb-graphite2.h>
#include <font/PhysicalFontFace.hxx>
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <impfontcache.hxx> #include <impfontcache.hxx>
#include <PhysicalFontFace.hxx>
#include <o3tl/hash_combine.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 )) : mxFontMetric( new ImplFontMetricData( rFontSelData ))
, mpConversion( nullptr ) , mpConversion( nullptr )
, mnLineHeight( 0 ) , mnLineHeight( 0 )
@ -56,7 +56,7 @@ LogicalFontInstance::LogicalFontInstance(const PhysicalFontFace& rFontFace, cons
, m_aFontSelData(rFontSelData) , m_aFontSelData(rFontSelData)
, m_pHbFont(nullptr) , m_pHbFont(nullptr)
, m_nAveWidthFactor(1.0f) , m_nAveWidthFactor(1.0f)
, m_pFontFace(&const_cast<PhysicalFontFace&>(rFontFace)) , m_pFontFace(&const_cast<vcl::font::PhysicalFontFace&>(rFontFace))
{ {
} }

6
vcl/source/font/fontmetric.cxx
View File

@ -26,9 +26,9 @@
#include <vcl/outdev.hxx> #include <vcl/outdev.hxx>
#include <sal/log.hxx> #include <sal/log.hxx>
#include <PhysicalFontFace.hxx>
#include <fontinstance.hxx>
#include <font/FontSelectPattern.hxx> #include <font/FontSelectPattern.hxx>
#include <font/PhysicalFontFace.hxx>
#include <fontinstance.hxx>
#include <impfontmetricdata.hxx> #include <impfontmetricdata.hxx>
#include <sft.hxx> #include <sft.hxx>
@ -53,7 +53,7 @@ FontMetric::FontMetric()
FontMetric::FontMetric( const FontMetric& rFontMetric ) = default; FontMetric::FontMetric( const FontMetric& rFontMetric ) = default;
FontMetric::FontMetric(PhysicalFontFace const& rFace) FontMetric::FontMetric(vcl::font::PhysicalFontFace const& rFace)
: FontMetric() : FontMetric()
{ {
SetFamilyName(rFace.GetFamilyName()); SetFamilyName(rFace.GetFamilyName());

4
vcl/source/gdi/embeddedfontshelper.cxx
View File

@ -260,12 +260,12 @@ OUString EmbeddedFontsHelper::fontFileUrl( std::u16string_view familyName, FontF
PhysicalFontCollection fonts; PhysicalFontCollection fonts;
graphics->GetDevFontList( &fonts ); graphics->GetDevFontList( &fonts );
std::unique_ptr< vcl::font::PhysicalFontFaceCollection > fontInfo( fonts.GetFontFaceCollection()); std::unique_ptr< vcl::font::PhysicalFontFaceCollection > fontInfo( fonts.GetFontFaceCollection());
PhysicalFontFace* selected = nullptr; vcl::font::PhysicalFontFace* selected = nullptr;
for( int i = 0; for( int i = 0;
i < fontInfo->Count(); i < fontInfo->Count();
++i ) ++i )
{ {
PhysicalFontFace* f = fontInfo->Get( i ); vcl::font::PhysicalFontFace* f = fontInfo->Get( i );
if( f->GetFamilyName() == familyName ) if( f->GetFamilyName() == familyName )
{ {
// Ignore comparing text encodings, at least for now. They cannot be trivially compared // Ignore comparing text encodings, at least for now. They cannot be trivially compared

4
vcl/source/gdi/pdfbuildin_fonts.cxx
View File

@ -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) const vcl::font::FontSelectPattern& rFSP)
: LogicalFontInstance(rFontFace, rFSP) : LogicalFontInstance(rFontFace, rFSP)
{ {
@ -748,7 +748,7 @@ bool BuildinFontInstance::GetGlyphOutline(sal_GlyphId, basegfx::B2DPolyPolygon&,
} }
BuildinFontFace::BuildinFontFace(int nId) BuildinFontFace::BuildinFontFace(int nId)
: PhysicalFontFace(m_aBuildinFonts[nId].GetFontAttributes()) : vcl::font::PhysicalFontFace(m_aBuildinFonts[nId].GetFontAttributes())
, mrBuildin(m_aBuildinFonts[nId]) , mrBuildin(m_aBuildinFonts[nId])
{ {
} }

8
vcl/source/gdi/pdffontcache.cxx
View File

@ -21,7 +21,7 @@
#include <sal/types.h> #include <sal/types.h>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <pdf/pdffontcache.hxx> #include <pdf/pdffontcache.hxx>
#include <salgdi.hxx> #include <salgdi.hxx>
@ -29,14 +29,14 @@
using namespace vcl; 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_nFontId( pFont->GetFontId() ),
m_bVertical( bVertical ), m_bVertical( bVertical ),
m_typeFontFace( const_cast<std::type_info*>(&typeid(pFont)) ) 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 ); FontIdentifier aId( pFont, bVertical );
FontToIndexMap::iterator it = m_aFontToIndex.find( aId ); FontToIndexMap::iterator it = m_aFontToIndex.find( aId );
@ -47,7 +47,7 @@ PDFFontCache::FontData& PDFFontCache::getFont( const PhysicalFontFace* pFont, bo
return m_aFonts.back(); 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; sal_Int32 nWidth = 0;
FontData& rFontData( getFont( pFont, bVertical ) ); FontData& rFontData( getFont( pFont, bVertical ) );

18
vcl/source/gdi/pdfwriter_impl.cxx
View File

@ -72,7 +72,7 @@
#include <svdata.hxx> #include <svdata.hxx>
#include <bitmap/BitmapWriteAccess.hxx> #include <bitmap/BitmapWriteAccess.hxx>
#include <fontsubset.hxx> #include <fontsubset.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <salgdi.hxx> #include <salgdi.hxx>
#include <textlayout.hxx> #include <textlayout.hxx>
#include <textlineinfo.hxx> #include <textlineinfo.hxx>
@ -2310,7 +2310,7 @@ sal_Int32 PDFWriterImpl::emitBuildinFont(const pdf::BuildinFontFace* pFD, sal_In
return nFontObject; 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; std::map< sal_Int32, sal_Int32 > aRet;
@ -2549,7 +2549,7 @@ sal_Int32 PDFWriterImpl::createToUnicodeCMap( sal_uInt8 const * pEncoding,
return nStream; 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 ); OStringBuffer aLine( 1024 );
// get font flags, see PDF reference 1.4 p. 358 // get font flags, see PDF reference 1.4 p. 358
@ -2854,7 +2854,7 @@ bool PDFWriterImpl::emitFonts()
} }
else else
{ {
const PhysicalFontFace* pFont = subset.first; const vcl::font::PhysicalFontFace* pFont = subset.first;
OStringBuffer aErrorComment( 256 ); OStringBuffer aErrorComment( 256 );
aErrorComment.append( "CreateFontSubset failed for font \"" ); aErrorComment.append( "CreateFontSubset failed for font \"" );
aErrorComment.append( OUStringToOString( pFont->GetFamilyName(), RTL_TEXTENCODING_UTF8 ) ); aErrorComment.append( OUStringToOString( pFont->GetFamilyName(), RTL_TEXTENCODING_UTF8 ) );
@ -3889,7 +3889,7 @@ void PDFWriterImpl::createDefaultCheckBoxAppearance( PDFWidget& rBox, const PDFW
FontCharMapRef pMap; FontCharMapRef pMap;
GetFontCharMap(pMap); GetFontCharMap(pMap);
const LogicalFontInstance* pFontInstance = GetFontInstance(); const LogicalFontInstance* pFontInstance = GetFontInstance();
const PhysicalFontFace* pDevFont = pFontInstance->GetFontFace(); const vcl::font::PhysicalFontFace* pDevFont = pFontInstance->GetFontFace();
Pop(); Pop();
// make sure OpenSymbol is embedded, and includes our checkmark // 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 ); SetFont( i_rFont );
const PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace(); const vcl::font::PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace();
sal_Int32 nFontID = 0; sal_Int32 nFontID = 0;
auto it = m_aSystemFonts.find( pDevFont ); auto it = m_aSystemFonts.find( pDevFont );
if( it != m_aSystemFonts.end() ) if( it != m_aSystemFonts.end() )
@ -5693,7 +5693,7 @@ sal_Int32 PDFWriterImpl::getSystemFont( const vcl::Font& i_rFont )
} }
void PDFWriterImpl::registerGlyph(const GlyphItem* pGlyph, void PDFWriterImpl::registerGlyph(const GlyphItem* pGlyph,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const std::vector<sal_Ucs>& rCodeUnits, const std::vector<sal_Ucs>& rCodeUnits,
sal_uInt8& nMappedGlyph, sal_uInt8& nMappedGlyph,
sal_Int32& nMappedFontObject) sal_Int32& nMappedFontObject)
@ -6123,9 +6123,9 @@ void PDFWriterImpl::drawLayout( SalLayout& rLayout, const OUString& rText, bool
} }
FontMetric aRefDevFontMetric = GetFontMetric(); FontMetric aRefDevFontMetric = GetFontMetric();
const PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace(); const vcl::font::PhysicalFontFace* pDevFont = GetFontInstance()->GetFontFace();
const GlyphItem* pGlyph = nullptr; const GlyphItem* pGlyph = nullptr;
const PhysicalFontFace* pFallbackFont = nullptr; const vcl::font::PhysicalFontFace* pFallbackFont = nullptr;
// collect the glyphs into a single array // collect the glyphs into a single array
std::vector< PDFGlyph > aGlyphs; std::vector< PDFGlyph > aGlyphs;

4
vcl/source/gdi/salgdilayout.cxx
View File

@ -22,7 +22,7 @@
#include <memory> #include <memory>
#include <config_features.h> #include <config_features.h>
#include <sal/log.hxx> #include <sal/log.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <fontsubset.hxx> #include <fontsubset.hxx>
#include <salgdi.hxx> #include <salgdi.hxx>
#include <salframe.hxx> #include <salframe.hxx>
@ -885,7 +885,7 @@ OUString SalGraphics::getRenderBackendName() const
} }
void SalGraphics::GetGlyphWidths(const vcl::AbstractTrueTypeFont& rTTF, 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) std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc)
{ {
rWidths.clear(); rWidths.clear();

6
vcl/source/gdi/sallayout.cxx
View File

@ -493,7 +493,7 @@ sal_Int32 GenericSalLayout::GetTextBreak( DeviceCoordinate nMaxWidth, DeviceCoor
bool GenericSalLayout::GetNextGlyph(const GlyphItem** pGlyph, bool GenericSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
Point& rPos, int& nStart, Point& rPos, int& nStart,
const LogicalFontInstance** ppGlyphFont, 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 pGlyphIter = m_GlyphItems.begin();
std::vector<GlyphItem>::const_iterator pGlyphIterEnd = m_GlyphItems.end(); 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, bool MultiSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
Point& rPos, int& nStart, Point& rPos, int& nStart,
const LogicalFontInstance** ppGlyphFont, const LogicalFontInstance** ppGlyphFont,
const PhysicalFontFace** pFallbackFont) const const vcl::font::PhysicalFontFace** pFallbackFont) const
{ {
// NOTE: nStart is tagged with current font index // NOTE: nStart is tagged with current font index
int nLevel = static_cast<unsigned>(nStart) >> GF_FONTSHIFT; int nLevel = static_cast<unsigned>(nStart) >> GF_FONTSHIFT;
@ -1116,7 +1116,7 @@ bool MultiSalLayout::GetNextGlyph(const GlyphItem** pGlyph,
{ {
GenericSalLayout& rLayout = *mpLayouts[ nLevel ]; GenericSalLayout& rLayout = *mpLayouts[ nLevel ];
rLayout.InitFont(); rLayout.InitFont();
const PhysicalFontFace* pFontFace = rLayout.GetFont().GetFontFace(); const vcl::font::PhysicalFontFace* pFontFace = rLayout.GetFont().GetFontFace();
if (rLayout.GetNextGlyph(pGlyph, rPos, nStart, ppGlyphFont)) if (rLayout.GetNextGlyph(pGlyph, rPos, nStart, ppGlyphFont))
{ {
int nFontTag = nLevel << GF_FONTSHIFT; int nFontTag = nLevel << GF_FONTSHIFT;

6
vcl/unx/generic/gdi/font.cxx
View File

@ -83,7 +83,7 @@ std::unique_ptr<GenericSalLayout> X11SalGraphics::GetTextLayout(int nFallbackLev
bool X11SalGraphics::CreateFontSubset( bool X11SalGraphics::CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds, const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -95,7 +95,7 @@ bool X11SalGraphics::CreateFontSubset(
pGlyphIds, pEncoding, pWidths, nGlyphCount, rInfo); 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); return mxTextRenderImpl->GetEmbedFontData(pFont, pDataLen);
} }
@ -105,7 +105,7 @@ void X11SalGraphics::FreeEmbedFontData( const void* pData, tools::Long nLen )
mxTextRenderImpl->FreeEmbedFontData(pData, nLen); mxTextRenderImpl->FreeEmbedFontData(pData, nLen);
} }
void X11SalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont, void X11SalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) Ucs2UIntMap& rUnicodeEnc )

8
vcl/unx/generic/gdi/freetypetextrender.cxx
View File

@ -33,7 +33,7 @@
#include <unx/glyphcache.hxx> #include <unx/glyphcache.hxx>
#include <unx/fc_fontoptions.hxx> #include <unx/fc_fontoptions.hxx>
#include <unx/freetype_glyphcache.hxx> #include <unx/freetype_glyphcache.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <impfontmetricdata.hxx> #include <impfontmetricdata.hxx>
#include <sallayout.hxx> #include <sallayout.hxx>
@ -157,7 +157,7 @@ std::unique_ptr<GenericSalLayout> FreeTypeTextRenderImpl::GetTextLayout(int nFal
bool FreeTypeTextRenderImpl::CreateFontSubset( bool FreeTypeTextRenderImpl::CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds, const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -183,7 +183,7 @@ bool FreeTypeTextRenderImpl::CreateFontSubset(
return bSuccess; 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 // in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF // 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 ); GenPspGraphics::DoFreeEmbedFontData( pData, nLen );
} }
void FreeTypeTextRenderImpl::GetGlyphWidths( const PhysicalFontFace* pFont, void FreeTypeTextRenderImpl::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) Ucs2UIntMap& rUnicodeEnc )

4
vcl/unx/generic/glyphs/freetype_glyphcache.cxx
View File

@ -373,7 +373,7 @@ FreetypeFont* FreetypeManager::CreateFont(FreetypeFontInstance* pFontInstance)
if (!pFontInstance) if (!pFontInstance)
return nullptr; return nullptr;
const PhysicalFontFace* pFontFace = pFontInstance->GetFontFace(); const vcl::font::PhysicalFontFace* pFontFace = pFontInstance->GetFontFace();
if (!pFontFace) if (!pFontFace)
return nullptr; return nullptr;
@ -387,7 +387,7 @@ FreetypeFont* FreetypeManager::CreateFont(FreetypeFontInstance* pFontInstance)
} }
FreetypeFontFace::FreetypeFontFace( FreetypeFontInfo* pFI, const FontAttributes& rDFA ) FreetypeFontFace::FreetypeFontFace( FreetypeFontInfo* pFI, const FontAttributes& rDFA )
: PhysicalFontFace( rDFA ), : vcl::font::PhysicalFontFace( rDFA ),
mpFreetypeFontInfo( pFI ) mpFreetypeFontInfo( pFI )
{ {
} }

2
vcl/unx/generic/glyphs/glyphcache.cxx
View File

@ -66,7 +66,7 @@ FreetypeFontFile* FreetypeManager::FindFontFile(const OString& rNativeFileName)
return pFontFile; 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) : LogicalFontInstance(rPFF, rFSP)
, mxFreetypeFont(FreetypeManager::get().CreateFont(this)) , mxFreetypeFont(FreetypeManager::get().CreateFont(this))
{ {

9
vcl/unx/generic/print/genpspgraphics.cxx
View File

@ -46,8 +46,9 @@
#include <fontinstance.hxx> #include <fontinstance.hxx>
#include <fontattributes.hxx> #include <fontattributes.hxx>
#include <impfontmetricdata.hxx> #include <impfontmetricdata.hxx>
#include <font/FontSelectPattern.hxx>
#include <PhysicalFontCollection.hxx> #include <PhysicalFontCollection.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <sallayout.hxx> #include <sallayout.hxx>
using namespace psp; using namespace psp;
@ -309,7 +310,7 @@ std::unique_ptr<GenericSalLayout> GenPspGraphics::GetTextLayout(int nFallbackLev
bool GenPspGraphics::CreateFontSubset( bool GenPspGraphics::CreateFontSubset(
const OUString& rToFile, const OUString& rToFile,
const PhysicalFontFace* pFont, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds, const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
@ -335,7 +336,7 @@ bool GenPspGraphics::CreateFontSubset(
return bSuccess; return bSuccess;
} }
void GenPspGraphics::GetGlyphWidths( const PhysicalFontFace* pFont, void GenPspGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) Ucs2UIntMap& rUnicodeEnc )
@ -504,7 +505,7 @@ void GenPspGraphics::FreeEmbedFontData( const void* pData, tools::Long nLen )
DoFreeEmbedFontData( pData, 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 // in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF // font since they are the only ones left after the PDF

25
vcl/win/gdi/salfont.cxx
View File

@ -51,11 +51,12 @@
#include <vcl/fontcharmap.hxx> #include <vcl/fontcharmap.hxx>
#include <comphelper/scopeguard.hxx> #include <comphelper/scopeguard.hxx>
#include <font/FontSelectPattern.hxx>
#include <fontsubset.hxx> #include <fontsubset.hxx>
#include <outdev.h> #include <outdev.h>
#include <font/PhysicalFontFaceCollection.hxx> #include <font/PhysicalFontFaceCollection.hxx>
#include <PhysicalFontCollection.hxx> #include <PhysicalFontCollection.hxx>
#include <PhysicalFontFace.hxx> #include <font/PhysicalFontFace.hxx>
#include <sft.hxx> #include <sft.hxx>
#include <win/saldata.hxx> #include <win/saldata.hxx>
#include <win/salgdi.h> #include <win/salgdi.h>
@ -180,13 +181,13 @@ public:
bool FindFontSubstitute(vcl::font::FontSelectPattern&, LogicalFontInstance* pLogicalFont, OUString& rMissingChars) const override; bool FindFontSubstitute(vcl::font::FontSelectPattern&, LogicalFontInstance* pLogicalFont, OUString& rMissingChars) const override;
private: private:
HDC mhDC; 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? // 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); WinFontFace* pWinFont = static_cast< WinFontFace* >(pFace);
FontCharMapRef xFontCharMap = pWinFont->GetFontCharMap(); FontCharMapRef xFontCharMap = pWinFont->GetFontCharMap();
@ -303,7 +304,7 @@ bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPat
vcl::font::PhysicalFontFamily* pFontFamily = findDevFontListByLocale(*pFontCollection, aLanguageTag); vcl::font::PhysicalFontFamily* pFontFamily = findDevFontListByLocale(*pFontCollection, aLanguageTag);
if( pFontFamily ) if( pFontFamily )
{ {
PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData ); vcl::font::PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
if( HasMissingChars( pFace, rMissingChars ) ) if( HasMissingChars( pFace, rMissingChars ) )
{ {
rFontSelData.maSearchName = pFontFamily->GetSearchName(); rFontSelData.maSearchName = pFontFamily->GetSearchName();
@ -319,7 +320,7 @@ bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPat
rFontSelData.maSearchName ); rFontSelData.maSearchName );
if( pFontFamily ) if( pFontFamily )
{ {
PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData ); vcl::font::PhysicalFontFace* pFace = pFontFamily->FindBestFontFace( rFontSelData );
if( HasMissingChars( pFace, rMissingChars ) ) if( HasMissingChars( pFace, rMissingChars ) )
{ {
rFontSelData.maSearchName = pFontFamily->GetSearchName(); rFontSelData.maSearchName = pFontFamily->GetSearchName();
@ -338,7 +339,7 @@ bool WinGlyphFallbackSubstititution::FindFontSubstitute(vcl::font::FontSelectPat
bool bFound = false; bool bFound = false;
for( int i = 0; i < nTestFontCount; ++i ) for( int i = 0; i < nTestFontCount; ++i )
{ {
PhysicalFontFace* pFace = pTestFontList->Get( i ); vcl::font::PhysicalFontFace* pFace = pTestFontList->Get( i );
bFound = HasMissingChars( pFace, rMissingChars ); bFound = HasMissingChars( pFace, rMissingChars );
if( !bFound ) if( !bFound )
continue; continue;
@ -626,7 +627,7 @@ void ImplSalLogFontToFontW( HDC hDC, const LOGFONTW& rLogFont, Font& rFont )
WinFontFace::WinFontFace( const FontAttributes& rDFS, WinFontFace::WinFontFace( const FontAttributes& rDFS,
BYTE eWinCharSet, BYTE nPitchAndFamily ) BYTE eWinCharSet, BYTE nPitchAndFamily )
: PhysicalFontFace( rDFS ), : vcl::font::PhysicalFontFace( rDFS ),
mnId( 0 ), mnId( 0 ),
mbFontCapabilitiesRead( false ), mbFontCapabilitiesRead( false ),
meWinCharSet( eWinCharSet ), meWinCharSet( eWinCharSet ),
@ -762,7 +763,7 @@ void WinSalGraphics::SetTextColor( Color nColor )
} }
void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern& rFont, void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern& rFont,
const PhysicalFontFace* pFontFace, const vcl::font::PhysicalFontFace* pFontFace,
LOGFONTW& rLogFont ) LOGFONTW& rLogFont )
{ {
OUString aName; OUString aName;
@ -811,7 +812,7 @@ void ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern& rFont,
} }
HFONT WinSalGraphics::ImplDoSetFont(vcl::font::FontSelectPattern const & i_rFont, HFONT WinSalGraphics::ImplDoSetFont(vcl::font::FontSelectPattern const & i_rFont,
const PhysicalFontFace * i_pFontFace, const vcl::font::PhysicalFontFace * i_pFontFace,
HFONT& o_rOldFont) HFONT& o_rOldFont)
{ {
HFONT hNewFont = nullptr; HFONT hNewFont = nullptr;
@ -1535,7 +1536,7 @@ SFErrCodes ScopedTrueTypeFont::open(void const * pBuffer, sal_uInt32 nLen,
} }
bool WinSalGraphics::CreateFontSubset( const OUString& rToFile, 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 ) sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
{ {
// TODO: use more of the central font-subsetting code, move stuff there if needed // 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); 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 // create matching FontSelectPattern
// we need just enough to get to the font file data // 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); delete[] static_cast<char const *>(pData);
} }
void WinSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont, void WinSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFont,
bool bVertical, bool bVertical,
std::vector< sal_Int32 >& rWidths, std::vector< sal_Int32 >& rWidths,
Ucs2UIntMap& rUnicodeEnc ) Ucs2UIntMap& rUnicodeEnc )

5
vcl/win/gdi/winlayout.cxx
View File

@ -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 namespace
{ {
@ -189,7 +189,8 @@ static hb_blob_t* getFontTable(hb_face_t* /*face*/, hb_tag_t nTableTag, void* pU
assert(hDC); assert(hDC);
assert(hFont); 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); auto it = gCache.find(cacheKey);
if (it != gCache.end()) if (it != gCache.end())
{ {