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

5
include/vcl/vcllayout.hxx
View File

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

4
solenv/clang-format/excludelist
View File

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

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, \
vcl/qa/cppunit/font \
vcl/qa/cppunit/physicalfontface \
vcl/qa/cppunit/physicalfontfacecollection \
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/FeatureCollector \
vcl/source/font/FeatureParser \
vcl/source/font/FontSelectPattern \
vcl/source/font/OpenTypeFeatureDefinitionList \
vcl/source/font/PhysicalFontCollection \
vcl/source/font/PhysicalFontFace \
vcl/source/font/PhysicalFontFamily \
vcl/source/font/fontattributes \
vcl/source/font/fontselect \
vcl/source/font/fontinstance \
vcl/source/font/fontcache \
vcl/source/font/fontcharmap \

6
vcl/headless/svptext.cxx
View File

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

2
vcl/inc/PhysicalFontCollection.hxx
View File

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

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

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

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

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

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

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

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

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

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

2
vcl/inc/outdev.h
View File

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

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
also fixes all possible problems, so it's usually better to use it).
Generated on 2021-08-04 20:14:15 using:
Generated on 2021-09-21 16:33:04 using:
./bin/update_pch vcl vcl --cutoff=6 --exclude:system --include:module --include:local
If after updating build fails, use the following command to locate conflicting headers:
@ -33,9 +33,11 @@
#include <deque>
#include <float.h>
#include <functional>
#include <hb.h>
#include <initializer_list>
#include <iomanip>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
@ -52,7 +54,6 @@
#include <unordered_map>
#include <utility>
#include <vector>
#include <boost/functional/hash.hpp>
#include <boost/math/special_functions/sinc.hpp>
#include <boost/multi_array.hpp>
#include <boost/property_tree/json_parser.hpp>
@ -80,6 +81,7 @@
#include <rtl/bootstrap.hxx>
#include <rtl/byteseq.hxx>
#include <rtl/character.hxx>
#include <rtl/cipher.h>
#include <rtl/crc.h>
#include <rtl/digest.h>
#include <rtl/instance.hxx>
@ -129,8 +131,6 @@
#include <basegfx/vector/b2enums.hxx>
#include <basegfx/vector/b2ivector.hxx>
#include <bitmap/BitmapWriteAccess.hxx>
#include <com/sun/star/awt/Key.hpp>
#include <com/sun/star/awt/KeyGroup.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/datatransfer/DataFlavor.hpp>
#include <com/sun/star/datatransfer/XTransferable2.hpp>
@ -146,8 +146,13 @@
#include <com/sun/star/embed/Aspects.hpp>
#include <com/sun/star/frame/XTerminateListener.hpp>
#include <com/sun/star/i18n/Calendar2.hpp>
#include <com/sun/star/i18n/DirectionProperty.hpp>
#include <com/sun/star/i18n/KCharacterType.hpp>
#include <com/sun/star/i18n/NativeNumberXmlAttributes.hpp>
#include <com/sun/star/i18n/ParseResult.hpp>
#include <com/sun/star/i18n/TransliterationModules.hpp>
#include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
#include <com/sun/star/i18n/UnicodeScript.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/lang/EventObject.hpp>
#include <com/sun/star/lang/Locale.hpp>
@ -190,10 +195,14 @@
#include <cppuhelper/weak.hxx>
#include <cppuhelper/weakagg.hxx>
#include <cppuhelper/weakref.hxx>
#include <font/FontSelectPattern.hxx>
#include <font/PhysicalFontFace.hxx>
#include <font/PhysicalFontFaceCollection.hxx>
#include <i18nlangtag/lang.h>
#include <i18nlangtag/languagetag.hxx>
#include <i18nlangtag/mslangid.hxx>
#include <i18nutil/i18nutildllapi.h>
#include <i18nutil/transliteration.hxx>
#include <o3tl/cow_wrapper.hxx>
#include <o3tl/safeint.hxx>
#include <o3tl/sorted_vector.hxx>
@ -246,18 +255,20 @@
#include <uno/any2.h>
#include <uno/data.h>
#include <uno/sequence2.h>
#include <unotools/calendarwrapper.hxx>
#include <unotools/configmgr.hxx>
#include <unotools/localedatawrapper.hxx>
#include <unotools/resmgr.hxx>
#include <unotools/syslocale.hxx>
#include <unotools/ucbstreamhelper.hxx>
#include <unotools/unotoolsdllapi.h>
#endif // PCH_LEVEL >= 3
#if PCH_LEVEL >= 4
#include <PhysicalFontCollection.hxx>
#include <PhysicalFontFace.hxx>
#include <accel.hxx>
#include <brdwin.hxx>
#include <configsettings.hxx>
#include <drawmode.hxx>
#include <fontattributes.hxx>
#include <impglyphitem.hxx>
#include <outdev.h>
@ -303,6 +314,8 @@
#include <vcl/dllapi.h>
#include <vcl/dockwin.hxx>
#include <vcl/event.hxx>
#include <vcl/filter/SvmReader.hxx>
#include <vcl/filter/SvmWriter.hxx>
#include <vcl/fntstyle.hxx>
#include <vcl/font.hxx>
#include <vcl/formatter.hxx>
@ -354,6 +367,7 @@
#include <vcl/unohelp.hxx>
#include <vcl/vclenum.hxx>
#include <vcl/vclevent.hxx>
#include <vcl/vcllayout.hxx>
#include <vcl/vclptr.hxx>
#include <vcl/virdev.hxx>
#include <vcl/weld.hxx>

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

@ -21,7 +21,7 @@
#include <sal/config.h>
#include <PhysicalFontFace.hxx>
#include <font/PhysicalFontFace.hxx>
#include <fontinstance.hxx>
namespace vcl::pdf
@ -52,12 +52,12 @@ class BuildinFontInstance final : public LogicalFontInstance
bool ImplGetGlyphBoundRect(sal_GlyphId nID, tools::Rectangle& rRect, bool) const override;
public:
BuildinFontInstance(const PhysicalFontFace&, const vcl::font::FontSelectPattern&);
BuildinFontInstance(const vcl::font::PhysicalFontFace&, const vcl::font::FontSelectPattern&);
bool GetGlyphOutline(sal_GlyphId nId, basegfx::B2DPolyPolygon& rPoly, bool) const override;
};
class BuildinFontFace final : public PhysicalFontFace
class BuildinFontFace final : public vcl::font::PhysicalFontFace
{
static const BuildinFont m_aBuildinFonts[14];
const BuildinFont& mrBuildin;

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

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

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

@ -64,7 +64,7 @@ class FontSubsetInfo;
class ZCodec;
class EncHashTransporter;
struct BitStreamState;
class PhysicalFontFace;
namespace vcl::font { class PhysicalFontFace; }
class SvStream;
class SvMemoryStream;
@ -721,8 +721,8 @@ private:
std::vector< TilingEmit > m_aTilings;
std::vector< TransparencyEmit > m_aTransparentObjects;
/* contains all font subsets in use */
std::map<const PhysicalFontFace*, FontSubset> m_aSubsets;
std::map<const PhysicalFontFace*, EmbedFont> m_aSystemFonts;
std::map<const vcl::font::PhysicalFontFace*, FontSubset> m_aSubsets;
std::map<const vcl::font::PhysicalFontFace*, EmbedFont> m_aSystemFonts;
sal_Int32 m_nNextFID;
PDFFontCache m_aFontCache;
@ -807,7 +807,7 @@ i12626
void appendLiteralStringEncrypt( std::string_view rInString, const sal_Int32 nInObjectNumber, OStringBuffer& rOutBuffer );
/* creates fonts and subsets that will be emitted later */
void registerGlyph(const GlyphItem* pGlyph, const PhysicalFontFace* pFont, const std::vector<sal_Ucs>& rCodeUnits, sal_uInt8& nMappedGlyph, sal_Int32& nMappedFontObject);
void registerGlyph(const GlyphItem* pGlyph, const vcl::font::PhysicalFontFace* pFont, const std::vector<sal_Ucs>& rCodeUnits, sal_uInt8& nMappedGlyph, sal_Int32& nMappedFontObject);
/* emits a text object according to the passed layout */
/* TODO: remove rText as soon as SalLayout will change so that rText is not necessary anymore */
@ -852,9 +852,9 @@ i12626
/* writes a builtin font object and returns its objectid (or 0 in case of failure ) */
sal_Int32 emitBuildinFont( const pdf::BuildinFontFace*, sal_Int32 nObject );
/* writes a type1 system font object and returns its mapping from font ids to object ids (or 0 in case of failure ) */
std::map< sal_Int32, sal_Int32 > emitSystemFont( const PhysicalFontFace*, EmbedFont const & );
std::map< sal_Int32, sal_Int32 > emitSystemFont(const vcl::font::PhysicalFontFace*, EmbedFont const &);
/* writes a font descriptor and returns its object id (or 0) */
sal_Int32 emitFontDescriptor( const PhysicalFontFace*, FontSubsetInfo const &, sal_Int32 nSubsetID, sal_Int32 nStream );
sal_Int32 emitFontDescriptor(const vcl::font::PhysicalFontFace*, FontSubsetInfo const &, sal_Int32 nSubsetID, sal_Int32 nStream);
/* writes a ToUnicode cmap, returns the corresponding stream object */
sal_Int32 createToUnicodeCMap( sal_uInt8 const * pEncoding, const sal_Ucs* pCodeUnits, const sal_Int32* pCodeUnitsPerGlyph,
const sal_Int32* pEncToUnicodeIndex, int nGlyphs );

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

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

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

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

@ -228,16 +228,17 @@ public:
virtual void ClearDevFontCache() override;
virtual bool AddTempDevFont(PhysicalFontCollection*, const OUString& rFileURL,
const OUString& rFontName) override;
virtual bool CreateFontSubset(const OUString& rToFile, const PhysicalFontFace* pFont,
virtual bool CreateFontSubset(const OUString& rToFile, const vcl::font::PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds, const sal_uInt8* pEncoding,
sal_Int32* pWidths, int nGlyphs,
FontSubsetInfo& rInfo // out parameter
) override;
virtual const void* GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
virtual const void* GetEmbedFontData(const vcl::font::PhysicalFontFace*,
tools::Long* pDataLen) override;
virtual void FreeEmbedFontData(const void* pData, tools::Long nDataLen) override;
virtual void GetGlyphWidths(const PhysicalFontFace*, bool bVertical,
virtual void GetGlyphWidths(const vcl::font::PhysicalFontFace*, bool bVertical,
std::vector<sal_Int32>& rWidths, Ucs2UIntMap& rUnicodeEnc) override;
virtual std::unique_ptr<GenericSalLayout> GetTextLayout(int nFallbackLevel) override;

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

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

13
vcl/inc/salgdi.hxx
View File

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

10
vcl/inc/sallayout.hxx
View File

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

8
vcl/inc/textrender.hxx
View File

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

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

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

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

@ -22,7 +22,7 @@
#include <sal/config.h>
#include <unx/glyphcache.hxx>
#include <PhysicalFontFace.hxx>
#include <font/PhysicalFontFace.hxx>
#include <fontinstance.hxx>
#include <vcl/glyphitem.hxx>
@ -92,7 +92,7 @@ private:
mutable FontCharMapRef mxFontCharMap;
};
class FreetypeFontFace : public PhysicalFontFace
class FreetypeFontFace : public vcl::font::PhysicalFontFace
{
private:
FreetypeFontInfo* mpFreetypeFontInfo;
@ -100,7 +100,7 @@ private:
public:
FreetypeFontFace( FreetypeFontInfo*, const FontAttributes& );
virtual rtl::Reference<LogicalFontInstance> CreateFontInstance( const vcl::font::FontSelectPattern& ) const override;
virtual rtl::Reference<LogicalFontInstance> CreateFontInstance(const vcl::font::FontSelectPattern&) const override;
virtual sal_IntPtr GetFontId() const override { return mpFreetypeFontInfo->GetFontId(); }
FontCharMapRef GetFontCharMap() const override { return mpFreetypeFontInfo->GetFontCharMap(); }
@ -121,7 +121,7 @@ class SAL_DLLPUBLIC_RTTI FreetypeFontInstance final : public LogicalFontInstance
virtual hb_font_t* ImplInitHbFont() override;
virtual bool ImplGetGlyphBoundRect(sal_GlyphId, tools::Rectangle&, bool) const override;
explicit FreetypeFontInstance(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP);
explicit FreetypeFontInstance(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP);
public:
virtual ~FreetypeFontInstance() override;

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

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

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

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

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

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

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

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

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

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;
aCollection.Add(new TestFontFace(1988756));
rtl::Reference<PhysicalFontFace> pActual(new TestFontFace(1988756));
rtl::Reference<PhysicalFontFace> pExpected = aCollection.Get(0);
rtl::Reference<vcl::font::PhysicalFontFace> pActual(new TestFontFace(1988756));
rtl::Reference<vcl::font::PhysicalFontFace> pExpected = aCollection.Get(0);
CPPUNIT_ASSERT_EQUAL(pExpected->GetFontId(), pActual->GetFontId());
CPPUNIT_ASSERT_EQUAL(1, aCollection.Count());

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)
{
setFamily(toQString(rPFF.GetFamilyName()));

2
vcl/qt5/QtFontFace.cxx
View File

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

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

2
vcl/quartz/ctfonts.cxx
View File

@ -46,7 +46,7 @@ static double toRadian(int nDegree)
return nDegree * (M_PI / 1800.0);
}
CoreTextStyle::CoreTextStyle(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
CoreTextStyle::CoreTextStyle(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
: LogicalFontInstance(rPFF, rFSP)
, mfFontStretch( 1.0 )
, mfFontRotation( 0.0 )

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 )
: PhysicalFontFace( rDFA )
: vcl::font::PhysicalFontFace( rDFA )
, mnFontId( nFontId )
, mbFontCapabilitiesRead( false )
{
@ -556,7 +556,7 @@ static void FakeDirEntry( const char aTag[5], ByteCount nOfs, ByteCount nLen,
// fake a TTF or CFF font as directly accessing font file is not possible
// when only the fontid is known. This approach also handles *.font fonts.
bool AquaSalGraphics::GetRawFontData( const PhysicalFontFace* pFontData,
bool AquaSalGraphics::GetRawFontData( const vcl::font::PhysicalFontFace* pFontData,
std::vector<unsigned char>& rBuffer, bool* pJustCFF )
{
const CoreTextFontFace* pMacFont = static_cast<const CoreTextFontFace*>(pFontData);
@ -742,7 +742,7 @@ bool AquaSalGraphics::GetRawFontData( const PhysicalFontFace* pFontData,
return true;
}
void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bVertical,
void AquaSalGraphics::GetGlyphWidths( const vcl::font::PhysicalFontFace* pFontData, bool bVertical,
std::vector< sal_Int32 >& rGlyphWidths, Ucs2UIntMap& rUnicodeEnc )
{
rGlyphWidths.clear();
@ -768,7 +768,7 @@ void AquaSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFontData, bool bV
::CloseTTFont( pSftFont );
}
const void* AquaSalGraphics::GetEmbedFontData(const PhysicalFontFace*, tools::Long* /*pDataLen*/)
const void* AquaSalGraphics::GetEmbedFontData(const vcl::font::PhysicalFontFace*, tools::Long* /*pDataLen*/)
{
return nullptr;
}

2
vcl/quartz/salgdicommon.cxx
View File

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

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

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

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

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

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

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

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

@ -18,10 +18,11 @@
*/
#include <sal/config.h>
#include <sal/log.hxx>
#include <PhysicalFontCollection.hxx>
#include <PhysicalFontFace.hxx>
#include <font/PhysicalFontFace.hxx>
#include <font/PhysicalFontFamily.hxx>
#include <fontinstance.hxx>
#include <impfontcache.hxx>
@ -143,7 +144,7 @@ rtl::Reference<LogicalFontInstance> ImplFontCache::GetFontInstance( PhysicalFont
if( !pFontInstance && pFontFamily) // still no cache hit => create a new font instance
{
PhysicalFontFace* pFontData = pFontFamily->FindBestFontFace(aFontSelData);
vcl::font::PhysicalFontFace* pFontData = pFontFamily->FindBestFontFace(aFontSelData);
// create a new logical font instance from this physical font face
pFontInstance = pFontData->CreateFontInstance( aFontSelData );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -66,7 +66,7 @@ FreetypeFontFile* FreetypeManager::FindFontFile(const OString& rNativeFileName)
return pFontFile;
}
FreetypeFontInstance::FreetypeFontInstance(const PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
FreetypeFontInstance::FreetypeFontInstance(const vcl::font::PhysicalFontFace& rPFF, const vcl::font::FontSelectPattern& rFSP)
: LogicalFontInstance(rPFF, rFSP)
, mxFreetypeFont(FreetypeManager::get().CreateFont(this))
{

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

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

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

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

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
{
@ -189,7 +189,8 @@ static hb_blob_t* getFontTable(hb_face_t* /*face*/, hb_tag_t nTableTag, void* pU
assert(hDC);
assert(hFont);
BlobCacheKey cacheKey{ rtl::Reference<PhysicalFontFace>(pFont->GetFontFace()), nTableTag };
BlobCacheKey cacheKey{ rtl::Reference<vcl::font::PhysicalFontFace>(pFont->GetFontFace()),
nTableTag };
auto it = gCache.find(cacheKey);
if (it != gCache.end())
{