strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

#i64508# honor fontconfig hinting settings (patch by cmc)

Browse source
This commit is contained in:
hdu 2009-12-23 12:24:41 +01:00
parent 0c5348ff2c
commit 196a6282b4
23 changed files with 526 additions and 178 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
vcl/inc/vcl/fontmanager.hxx
View file

@ -137,6 +137,33 @@ enum type {
};
}
namespace fchint
{
enum type {
Nohint = 0,
Slight = 1,
Medium = 2,
Full = 3
};
}
struct FontConfigHints
{
fcstatus::type m_eEmbeddedbitmap;
fcstatus::type m_eAntialias;
fcstatus::type m_eAutoHint;
fcstatus::type m_eHinting;
fchint::type m_eHintStyle;
FontConfigHints() :
m_eEmbeddedbitmap( fcstatus::isunset ),
m_eAntialias( fcstatus::isunset ),
m_eAutoHint( fcstatus::isunset ),
m_eHinting( fcstatus::isunset ),
m_eHintStyle( fchint::Full )
{}
};
/*
* the difference between FastPrintFontInfo and PrintFontInfo
* is that the information in FastPrintFontInfo can usually
@ -162,8 +189,6 @@ struct FastPrintFontInfo
weight::type m_eWeight;
pitch::type m_ePitch;
rtl_TextEncoding m_aEncoding;
fcstatus::type m_eEmbeddedbitmap;
fcstatus::type m_eAntialias;
bool m_bSubsettable;
bool m_bEmbeddable;
@ -175,9 +200,7 @@ struct FastPrintFontInfo
m_eWidth( width::Unknown ),
m_eWeight( weight::Unknown ),
m_ePitch( pitch::Unknown ),
m_aEncoding( RTL_TEXTENCODING_DONTKNOW ),
m_eEmbeddedbitmap( fcstatus::isunset ),
m_eAntialias( fcstatus::isunset )
m_aEncoding( RTL_TEXTENCODING_DONTKNOW )
{}
};
@ -294,9 +317,6 @@ class VCL_DLLPUBLIC PrintFontManager
bool m_bHaveVerticalSubstitutedGlyphs;
bool m_bUserOverride;
fcstatus::type m_eEmbeddedbitmap;
fcstatus::type m_eAntialias;
std::map< sal_Unicode, sal_Int32 > m_aEncodingVector;
std::map< sal_Unicode, rtl::OString > m_aNonEncoded;
@ -736,6 +756,7 @@ public:
false else
*/
bool matchFont( FastPrintFontInfo& rInfo, const com::sun::star::lang::Locale& rLocale );
FontConfigHints getFontConfigHints(const FastPrintFontInfo& rInfo, int nSize, void (*subcallback)(void *));
rtl::OUString Substitute( const rtl::OUString& rFontName, rtl::OUString& rMissingCodes,
const rtl::OString& rLangAttrib, italic::type eItalic, weight::type eWeight,

36
vcl/inc/vcl/impfont.hxx
View file

@ -133,6 +133,42 @@ public:
bool operator==( const ImplFontMetric& ) const;
};
// ------------------
// - ImplFontHints -
// ------------------
class ImplFontHints
{
public:
FontEmbeddedBitmap meEmbeddedBitmap; // whether the embedded bitmaps should be used
FontAntiAlias meAntiAlias; // whether the font should be antialiased
FontAutoHint meAutoHint; // whether the font should be autohinted
FontHinting meHinting; // whether the font should be hinted
FontHintStyle meHintStyle; // type of font hinting to be used
public:
ImplFontHints() :
meEmbeddedBitmap(EMBEDDEDBITMAP_DONTKNOW),
meAntiAlias(ANTIALIAS_DONTKNOW),
meAutoHint(AUTOHINT_DONTKNOW),
meHinting(HINTING_DONTKNOW),
meHintStyle(HINT_SLIGHT)
{}
ImplFontHints(FontEmbeddedBitmap eEmbeddedBitmap, FontAntiAlias eAntiAlias,
FontAutoHint eAutoHint, FontHinting eHinting, FontHintStyle eHintStyle) :
meEmbeddedBitmap(eEmbeddedBitmap),
meAntiAlias(eAntiAlias),
meAutoHint(eAutoHint),
meHinting(eHinting),
meHintStyle(eHintStyle)
{}
FontAutoHint GetUseAutoHint() const { return meAutoHint; }
FontHintStyle GetHintStyle() const { return meHintStyle; }
bool DontUseEmbeddedBitmaps() const { return meEmbeddedBitmap == EMBEDDEDBITMAP_FALSE; }
bool DontUseAntiAlias() const { return meAntiAlias == ANTIALIAS_FALSE; }
bool DontUseHinting() const { return (meHinting == HINTING_FALSE) || (GetHintStyle() == HINT_NONE); }
};
// -------------------
// - ImplFontCharMap -
// -------------------

3
vcl/inc/vcl/outdev.hxx
View file

@ -80,6 +80,8 @@ class AlphaMask;
class FontCharMap;
class SalLayout;
class ImplLayoutArgs;
class ImplFontHints;
class ImplFontAttributes;
class VirtualDevice;
namespace com {
@ -543,6 +545,7 @@ public:
SAL_DLLPRIVATE static FontEmphasisMark ImplGetEmphasisMarkStyle( const Font& rFont );
SAL_DLLPRIVATE static BOOL ImplIsUnderlineAbove( const Font& );
SAL_DLLPRIVATE void ImplGetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const;
// tells whether this output device is RTL in an LTR UI or LTR in a RTL UI

4
vcl/inc/vcl/outfont.hxx
View file

@ -94,8 +94,6 @@ public: // TODO: create matching interface class
bool IsDeviceFont() const { return mbDevice; }
bool IsEmbeddable() const { return mbEmbeddable; }
bool IsSubsettable() const { return mbSubsettable; }
FontEmbeddedBitmap UseEmbeddedBitmap() const { return meEmbeddedBitmap; }
FontAntiAlias UseAntiAlias() const { return meAntiAlias; }
public: // TODO: hide members behind accessor methods
String maMapNames; // List of family name aliass separated with ';'
@ -104,8 +102,6 @@ public: // TODO: hide members behind accessor methods
bool mbDevice; // true: built in font
bool mbSubsettable; // true: a subset of the font can be created
bool mbEmbeddable; // true: the font can be embedded
FontEmbeddedBitmap meEmbeddedBitmap; // whether the embedded bitmaps should be used
FontAntiAlias meAntiAlias; // whether the font should be antialiased
};
// ----------------

2
vcl/inc/vcl/salgdi.hxx
View file

@ -237,6 +237,8 @@ public:
void ReleaseFonts() { SetFont( NULL, 0 ); }
// get the current font's metrics
virtual void GetFontMetric( ImplFontMetricData* ) = 0;
virtual void GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const = 0;
// get kernign pairs of the current font
// return only PairCount if (pKernPairs == NULL)
virtual ULONG GetKernPairs( ULONG nPairs, ImplKernPairData* pKernPairs ) = 0;

21
vcl/inc/vcl/vclenum.hxx
View file

@ -284,6 +284,27 @@ enum FontAntiAlias { ANTIALIAS_DONTKNOW, ANTIALIAS_FALSE, ANTIALIAS_TRUE };
#endif
#ifndef ENUM_FONTAUTOHINT_DECLARED
#define ENUM_FONTAUTOHINT_DECLARED
enum FontAutoHint { AUTOHINT_DONTKNOW, AUTOHINT_FALSE, AUTOHINT_TRUE };
#endif
#ifndef ENUM_FONTHINTING_DECLARED
#define ENUM_FONTHINTING_DECLARED
enum FontHinting { HINTING_DONTKNOW, HINTING_FALSE, HINTING_TRUE };
#endif
#ifndef ENUM_FONTHINTSTYLE_DECLARED
#define ENUM_FONTHINTSTYLE_DECLARED
enum FontHintStyle { HINT_NONE, HINT_SLIGHT, HINT_MEDIUM, HINT_FULL };
#endif
// ------------------------------------------------------------
#ifndef ENUM_KEYFUNCTYPE_DECLARED

8
vcl/source/gdi/outdev3.cxx
View file

@ -7157,6 +7157,14 @@ BOOL OutputDevice::IsFontAvailable( const String& rFontName ) const
// -----------------------------------------------------------------------
void OutputDevice::ImplGetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints &rHints) const
{
if ( mpGraphics )
mpGraphics->GetFontHints( rFontAttributes, nSize, rHints );
}
// -----------------------------------------------------------------------
FontMetric OutputDevice::GetFontMetric() const
{
DBG_TRACE( "OutputDevice::GetFontMetric()" );

84
vcl/source/glyphs/gcach_ftyp.cxx
View file

@ -40,6 +40,7 @@
#include "vcl/impfont.hxx"
#include "vcl/bitmap.hxx"
#include "vcl/bmpacc.hxx"
#include "vcl/virdev.hxx"
#include "tools/poly.hxx"
#include "basegfx/matrix/b2dhommatrix.hxx"
@ -622,9 +623,6 @@ long FreetypeManager::AddFontDir( const String& rUrlName )
aDFA.mbSubsettable= false;
aDFA.mbEmbeddable = false;
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_DONTKNOW;
aDFA.meAntiAlias = ANTIALIAS_DONTKNOW;
FT_Done_Face( aFaceFT );
AddFontFile( aCFileName, nFaceNum, ++mnNextFontId, aDFA, NULL );
++nCount;
@ -704,6 +702,7 @@ FreetypeServerFont::FreetypeServerFont( const ImplFontSelectData& rFSD, FtFontIn
: ServerFont( rFSD ),
mnPrioEmbedded(nDefaultPrioEmbedded),
mnPrioAntiAlias(nDefaultPrioAntiAlias),
mnPrioAutoHint(nDefaultPrioAutoHint),
mpFontInfo( pFI ),
maFaceFT( NULL ),
maSizeFT( NULL ),
@ -837,42 +836,69 @@ FreetypeServerFont::FreetypeServerFont( const ImplFontSelectData& rFSD, FtFontIn
mbArtItalic = (rFSD.meItalic != ITALIC_NONE && pFI->GetFontAttributes().GetSlant() == ITALIC_NONE);
mbArtBold = (rFSD.meWeight > WEIGHT_MEDIUM && pFI->GetFontAttributes().GetWeight() <= WEIGHT_MEDIUM);
//static const int TT_CODEPAGE_RANGE_874 = (1L << 16); // Thai
//static const int TT_CODEPAGE_RANGE_932 = (1L << 17); // JIS/Japan
//static const int TT_CODEPAGE_RANGE_936 = (1L << 18); // Chinese: Simplified
//static const int TT_CODEPAGE_RANGE_949 = (1L << 19); // Korean Wansung
//static const int TT_CODEPAGE_RANGE_950 = (1L << 20); // Chinese: Traditional
//static const int TT_CODEPAGE_RANGE_1361 = (1L << 21); // Korean Johab
static const int TT_CODEPAGE_RANGES1_CJKT = 0x3F0000; // all of the above
const TT_OS2* pOs2 = (const TT_OS2*)FT_Get_Sfnt_Table( maFaceFT, ft_sfnt_os2 );
if ((pOs2) && (pOs2->ulCodePageRange1 & TT_CODEPAGE_RANGES1_CJKT )
mbUseGamma = false;
if (mbArtBold)
{
//static const int TT_CODEPAGE_RANGE_874 = (1L << 16); // Thai
//static const int TT_CODEPAGE_RANGE_932 = (1L << 17); // JIS/Japan
//static const int TT_CODEPAGE_RANGE_936 = (1L << 18); // Chinese: Simplified
//static const int TT_CODEPAGE_RANGE_949 = (1L << 19); // Korean Wansung
//static const int TT_CODEPAGE_RANGE_950 = (1L << 20); // Chinese: Traditional
//static const int TT_CODEPAGE_RANGE_1361 = (1L << 21); // Korean Johab
static const int TT_CODEPAGE_RANGES1_CJKT = 0x3F0000; // all of the above
const TT_OS2* pOs2 = (const TT_OS2*)FT_Get_Sfnt_Table( maFaceFT, ft_sfnt_os2 );
if ((pOs2) && (pOs2->ulCodePageRange1 & TT_CODEPAGE_RANGES1_CJKT )
&& rFSD.mnHeight < 20)
mbUseGamma = true;
else
mbUseGamma = false;
}
if (mbUseGamma)
ImplFontHints aHints;
VirtualDevice vdev( 1 );
vdev.ImplGetFontHints( pFI->GetFontAttributes(), mnWidth, aHints );
FontAutoHint eHint = aHints.GetUseAutoHint();
if (eHint == AUTOHINT_DONTKNOW)
eHint = mbUseGamma ? AUTOHINT_TRUE : AUTOHINT_FALSE;
if (eHint == AUTOHINT_TRUE)
mnLoadFlags |= FT_LOAD_FORCE_AUTOHINT;
if( (mnSin != 0) && (mnCos != 0) ) // hinting for 0/90/180/270 degrees only
mnLoadFlags |= FT_LOAD_NO_HINTING;
mnLoadFlags |= FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH; //#88334#
if (mpFontInfo->DontUseAntiAlias())
mnPrioAntiAlias = 0;
if (mpFontInfo->DontUseEmbeddedBitmaps())
mnPrioEmbedded = 0;
if (aHints.DontUseAntiAlias())
mnPrioAntiAlias = 0;
if (aHints.DontUseEmbeddedBitmaps())
mnPrioEmbedded = 0;
if (aHints.DontUseHinting())
mnPrioAutoHint = 0;
#if (FTVERSION >= 2005) || defined(TT_CONFIG_OPTION_BYTECODE_INTERPRETER)
if( nDefaultPrioAutoHint <= 0 )
if( mnPrioAutoHint <= 0 )
#endif
mnLoadFlags |= FT_LOAD_NO_HINTING;
#ifdef FT_LOAD_TARGET_LIGHT
// enable "light hinting" if available
#if defined(FT_LOAD_TARGET_LIGHT) && defined(FT_LOAD_TARGET_NORMAL)
if( !(mnLoadFlags & FT_LOAD_NO_HINTING) && (nFTVERSION >= 2103))
mnLoadFlags |= FT_LOAD_TARGET_LIGHT;
{
mnLoadFlags |= FT_LOAD_TARGET_NORMAL;
switch (aHints.GetHintStyle())
{
case HINT_NONE:
mnLoadFlags |= FT_LOAD_NO_HINTING;
break;
case HINT_SLIGHT:
mnLoadFlags |= FT_LOAD_TARGET_LIGHT;
break;
case HINT_MEDIUM:
break;
case HINT_FULL:
default:
break;
}
}
#endif
if( ((mnCos != 0) && (mnSin != 0)) || (mnPrioEmbedded <= 0) )
@ -1230,13 +1256,15 @@ int FreetypeServerFont::FixupGlyphIndex( int nGlyphIndex, sal_UCS4 aChar ) const
}
}
#if !defined(TT_CONFIG_OPTION_BYTECODE_INTERPRETER)
#if 0
// #95556# autohinting not yet optimized for non-western glyph styles
if( !(mnLoadFlags & (FT_LOAD_NO_HINTING | FT_LOAD_FORCE_AUTOHINT) )
&& ( (aChar >= 0x0600 && aChar < 0x1E00) // south-east asian + arabic
||(aChar >= 0x2900 && aChar < 0xD800) // CJKV
||(aChar >= 0xF800) ) ) // presentation + symbols
{
nGlyphFlags |= GF_UNHINTED;
}
#endif
if( nGlyphIndex != 0 )
@ -1378,11 +1406,11 @@ bool FreetypeServerFont::GetGlyphBitmap1( int nGlyphIndex, RawBitmap& rRawBitmap
#if (FTVERSION >= 2002)
// for 0/90/180/270 degree fonts enable autohinting even if not advisable
// non-hinted and non-antialiased bitmaps just look too ugly
if( (mnCos==0 || mnSin==0) && (nDefaultPrioAutoHint > 0) )
if( (mnCos==0 || mnSin==0) && (mnPrioAutoHint > 0) )
nLoadFlags &= ~FT_LOAD_NO_HINTING;
#endif
if( mnPrioEmbedded <= nDefaultPrioAutoHint )
if( mnPrioEmbedded <= mnPrioAutoHint )
nLoadFlags |= FT_LOAD_NO_BITMAP;
FT_Error rc = -1;
@ -1547,7 +1575,7 @@ bool FreetypeServerFont::GetGlyphBitmap8( int nGlyphIndex, RawBitmap& rRawBitmap
// autohinting in FT<=2.0.4 makes antialiased glyphs look worse
nLoadFlags |= FT_LOAD_NO_HINTING;
#else
if( (nGlyphFlags & GF_UNHINTED) || (nDefaultPrioAutoHint < mnPrioAntiAlias) )
if( (nGlyphFlags & GF_UNHINTED) || (mnPrioAutoHint < mnPrioAntiAlias) )
nLoadFlags |= FT_LOAD_NO_HINTING;
#endif

5
vcl/source/glyphs/gcach_ftyp.hxx
View file

@ -85,10 +85,6 @@ public:
int GetFaceNum() const { return mnFaceNum; }
int GetSynthetic() const { return mnSynthetic; }
sal_IntPtr GetFontId() const { return mnFontId; }
bool DontUseAntiAlias() const
{ return maDevFontAttributes.UseAntiAlias() == ANTIALIAS_FALSE; }
bool DontUseEmbeddedBitmaps() const
{ return maDevFontAttributes.UseEmbeddedBitmap() == EMBEDDEDBITMAP_FALSE; }
bool IsSymbolFont() const { return maDevFontAttributes.IsSymbolFont(); }
const ImplFontAttributes& GetFontAttributes() const { return maDevFontAttributes; }
@ -213,6 +209,7 @@ private:
int mnWidth;
int mnPrioEmbedded;
int mnPrioAntiAlias;
int mnPrioAutoHint;
FtFontInfo* mpFontInfo;
FT_Int mnLoadFlags;
double mfStretch;

4
vcl/unx/headless/svpgdi.cxx
View file

@ -587,3 +587,7 @@ bool SvpSalGraphics::supportsOperation( OutDevSupportType ) const
{
return false;
}
void SvpSalGraphics::GetFontHints( const ImplFontAttributes& , int , ImplFontHints& ) const
{
}

1
vcl/unx/headless/svpgdi.hxx
View file

@ -170,6 +170,7 @@ public:
virtual SystemGraphicsData GetGraphicsData() const;
virtual SystemFontData GetSysFontData( int nFallbacklevel ) const;
virtual void GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const;
};
#endif

30
vcl/unx/headless/svppspgraphics.cxx
View file

@ -1160,32 +1160,6 @@ ImplDevFontAttributes PspGraphics::Info2DevFontAttributes( const psp::FastPrintF
aDFA.mePitch = ToFontPitch (rInfo.m_ePitch);
aDFA.mbSymbolFlag = (rInfo.m_aEncoding == RTL_TEXTENCODING_SYMBOL);
switch (rInfo.m_eEmbeddedbitmap)
{
default:
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_DONTKNOW;
break;
case psp::fcstatus::istrue:
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_TRUE;
break;
case psp::fcstatus::isfalse:
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_FALSE;
break;
}
switch (rInfo.m_eAntialias)
{
default:
aDFA.meAntiAlias = ANTIALIAS_DONTKNOW;
break;
case psp::fcstatus::istrue:
aDFA.meAntiAlias = ANTIALIAS_TRUE;
break;
case psp::fcstatus::isfalse:
aDFA.meAntiAlias = ANTIALIAS_FALSE;
break;
}
switch( rInfo.m_eType )
{
case psp::fonttype::Builtin:
@ -1392,3 +1366,7 @@ SystemGraphicsData PspGraphics::GetGraphicsData() const
return aRes;
}
void PspGraphics::GetFontHints( const ImplFontAttributes& , int , ImplFontHints& ) const
{
}

1
vcl/unx/headless/svppspgraphics.hxx
View file

@ -190,6 +190,7 @@ public:
virtual SystemGraphicsData GetGraphicsData() const;
virtual SystemFontData GetSysFontData( int nFallbacklevel ) const;
virtual void GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const;
};
#endif // _SVP_PSPGRAPHICS_HXX

1
vcl/unx/inc/pspgraphics.h
View file

@ -103,6 +103,7 @@ public:
virtual void SetTextColor( SalColor nSalColor );
virtual USHORT SetFont( ImplFontSelectData*, int nFallbackLevel );
virtual void GetFontMetric( ImplFontMetricData* );
virtual void GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const;
virtual ULONG GetKernPairs( ULONG nPairs, ImplKernPairData* pKernPairs );
virtual ImplFontCharMap* GetImplFontCharMap() const;
virtual void GetDevFontList( ImplDevFontList* );

1
vcl/unx/inc/salgdi.h
View file

@ -253,6 +253,7 @@ public:
virtual void SetTextColor( SalColor nSalColor );
virtual USHORT SetFont( ImplFontSelectData*, int nFallbackLevel );
virtual void GetFontMetric( ImplFontMetricData* );
virtual void GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const;
virtual ULONG GetKernPairs( ULONG nPairs, ImplKernPairData* pKernPairs );
virtual ImplFontCharMap* GetImplFontCharMap() const;
virtual void GetDevFontList( ImplDevFontList* );

13
vcl/unx/source/fontmanager/fontcache.cxx
View file

@ -214,9 +214,9 @@ void FontCache::flush()
aLine.Append( ';' );
aLine.Append( (*it)->m_bUserOverride ? "1" : "0" );
aLine.Append( ';' );
aLine.Append( ByteString::CreateFromInt32( (*it)->m_eEmbeddedbitmap ) );
aLine.Append( ByteString::CreateFromInt32( 0 ) );
aLine.Append( ';' );
aLine.Append( ByteString::CreateFromInt32( (*it)->m_eAntialias ) );
aLine.Append( ByteString::CreateFromInt32( 0 ) );
switch( (*it)->m_eType )
{
@ -426,9 +426,6 @@ void FontCache::read()
= atoi( pLine + nTokenPos[14] );
pFont->m_bUserOverride
= (atoi( pLine + nTokenPos[15] ) != 0);
pFont->m_eEmbeddedbitmap
= (fcstatus::type)atoi(pLine+nTokenPos[16]);
pFont->m_eAntialias = (fcstatus::type)atoi(pLine+nTokenPos[17]);
int nStyleTokenNr = 18;
switch( eType )
{
@ -560,8 +557,6 @@ void FontCache::copyPrintFont( const PrintFontManager::PrintFont* pFrom, PrintFo
pTo->m_nYMax = pFrom->m_nYMax;
pTo->m_bHaveVerticalSubstitutedGlyphs = pFrom->m_bHaveVerticalSubstitutedGlyphs;
pTo->m_bUserOverride = pFrom->m_bUserOverride;
pTo->m_eEmbeddedbitmap = pFrom->m_eEmbeddedbitmap;
pTo->m_eAntialias = pFrom->m_eAntialias;
}
/*
@ -623,9 +618,7 @@ bool FontCache::equalsPrintFont( const PrintFontManager::PrintFont* pLeft, Print
pRight->m_nXMax != pLeft->m_nXMax ||
pRight->m_nYMax != pLeft->m_nYMax ||
pRight->m_bHaveVerticalSubstitutedGlyphs != pLeft->m_bHaveVerticalSubstitutedGlyphs ||
pRight->m_bUserOverride != pLeft->m_bUserOverride ||
pRight->m_eEmbeddedbitmap != pLeft->m_eEmbeddedbitmap ||
pRight->m_eAntialias != pLeft->m_eAntialias
pRight->m_bUserOverride != pLeft->m_bUserOverride
)
return false;
std::list< int >::const_iterator lit, rit;

210
vcl/unx/source/fontmanager/fontconfig.cxx
View file

@ -120,6 +120,7 @@ class FontCfgWrapper
FcBool (*m_pFcConfigAppFontAddDir)(FcConfig*, const FcChar8*);
FcBool (*m_pFcConfigSubstitute)(FcConfig*,FcPattern*,FcMatchKind);
FcBool (*m_pFcPatternAddInteger)(FcPattern*,const char*,int);
FcBool (*m_pFcPatternAddDouble)(FcPattern*,const char*,double);
FcBool (*m_pFcPatternAddBool)(FcPattern*,const char*,FcBool);
FcBool (*m_pFcPatternAddCharSet)(FcPattern*,const char*,const FcCharSet*);
FcBool (*m_pFcPatternAddString)(FcPattern*,const char*,const FcChar8*);
@ -223,6 +224,8 @@ public:
{ return m_pFcConfigSubstitute( pConfig, pPattern, eKind ); }
FcBool FcPatternAddInteger( FcPattern* pPattern, const char* pObject, int nValue )
{ return m_pFcPatternAddInteger( pPattern, pObject, nValue ); }
FcBool FcPatternAddDouble( FcPattern* pPattern, const char* pObject, double nValue )
{ return m_pFcPatternAddDouble( pPattern, pObject, nValue ); }
FcBool FcPatternAddString( FcPattern* pPattern, const char* pObject, const FcChar8* pString )
{ return m_pFcPatternAddString( pPattern, pObject, pString ); }
FcBool FcPatternAddBool( FcPattern* pPattern, const char* pObject, bool nValue )
@ -234,7 +237,9 @@ public:
{ return m_pFcFreeTypeCharIndex ? m_pFcFreeTypeCharIndex( face, ucs4 ) : 0; }
public: // TODO: cleanup
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash > m_aFontconfigNameToLocalized;
FcResult FamilyFromPattern(FcPattern* pPattern, FcChar8 **family);
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash > m_aFontNameToLocalized;
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash > m_aLocalizedToCanonical;
};
oslGenericFunction FontCfgWrapper::loadSymbol( const char* pSymbol )
@ -324,6 +329,8 @@ FontCfgWrapper::FontCfgWrapper()
loadSymbol( "FcConfigSubstitute" );
m_pFcPatternAddInteger = (FcBool(*)(FcPattern*,const char*,int))
loadSymbol( "FcPatternAddInteger" );
m_pFcPatternAddDouble = (FcBool(*)(FcPattern*,const char*,double))
loadSymbol( "FcPatternAddDouble" );
m_pFcPatternAddBool = (FcBool(*)(FcPattern*,const char*,FcBool))
loadSymbol( "FcPatternAddBool" );
m_pFcPatternAddCharSet = (FcBool(*)(FcPattern*,const char*,const FcCharSet *))
@ -374,6 +381,7 @@ FontCfgWrapper::FontCfgWrapper()
m_pFcDefaultSubstitute &&
m_pFcConfigSubstitute &&
m_pFcPatternAddInteger &&
m_pFcPatternAddDouble &&
m_pFcPatternAddCharSet &&
m_pFcPatternAddBool &&
m_pFcPatternAddString
@ -506,53 +514,52 @@ namespace
return candidate;
}
FcResult lcl_FamilyFromPattern(FontCfgWrapper& rWrapper, FcPattern* pPattern, FcChar8 **family,
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash > &aFontconfigNameToLocalized)
{
FcChar8 *origfamily;
FcResult eFamilyRes = rWrapper.FcPatternGetString( pPattern, FC_FAMILY, 0, &origfamily );
*family = origfamily;
if( eFamilyRes == FcResultMatch)
{
FcChar8* familylang = NULL;
if (rWrapper.FcPatternGetString( pPattern, FC_FAMILYLANG, 0, &familylang ) == FcResultMatch)
{
std::vector< lang_and_family > lang_and_families;
lang_and_families.push_back(lang_and_family(familylang, *family));
int k = 1;
while (1)
{
if (rWrapper.FcPatternGetString( pPattern, FC_FAMILYLANG, k, &familylang ) != FcResultMatch)
break;
if (rWrapper.FcPatternGetString( pPattern, FC_FAMILY, k, family ) != FcResultMatch)
break;
lang_and_families.push_back(lang_and_family(familylang, *family));
++k;
}
//possible to-do, sort by UILocale instead of process locale
rtl_Locale* pLoc;
osl_getProcessLocale(&pLoc);
localizedsorter aSorter(pLoc);
*family = aSorter.bestname(lang_and_families);
std::vector<lang_and_family>::const_iterator aEnd = lang_and_families.end();
for (std::vector<lang_and_family>::const_iterator aIter = lang_and_families.begin(); aIter != aEnd; ++aIter)
{
const char *candidate = (const char*)(aIter->second);
if (rtl_str_compare(candidate, (const char*)(*family)) != 0)
aFontconfigNameToLocalized[OString(candidate)] = OString((const char*)(*family));
}
}
}
return eFamilyRes;
}
}
FcResult FontCfgWrapper::FamilyFromPattern(FcPattern* pPattern, FcChar8 **family)
{
FcChar8 *origfamily;
FcResult eFamilyRes = FcPatternGetString( pPattern, FC_FAMILY, 0, &origfamily );
*family = origfamily;
if( eFamilyRes == FcResultMatch)
{
FcChar8* familylang = NULL;
if (FcPatternGetString( pPattern, FC_FAMILYLANG, 0, &familylang ) == FcResultMatch)
{
std::vector< lang_and_family > lang_and_families;
lang_and_families.push_back(lang_and_family(familylang, *family));
int k = 1;
while (1)
{
if (FcPatternGetString( pPattern, FC_FAMILYLANG, k, &familylang ) != FcResultMatch)
break;
if (FcPatternGetString( pPattern, FC_FAMILY, k, family ) != FcResultMatch)
break;
lang_and_families.push_back(lang_and_family(familylang, *family));
++k;
}
//possible to-do, sort by UILocale instead of process locale
rtl_Locale* pLoc;
osl_getProcessLocale(&pLoc);
localizedsorter aSorter(pLoc);
*family = aSorter.bestname(lang_and_families);
std::vector<lang_and_family>::const_iterator aEnd = lang_and_families.end();
for (std::vector<lang_and_family>::const_iterator aIter = lang_and_families.begin(); aIter != aEnd; ++aIter)
{
const char *candidate = (const char*)(aIter->second);
if (rtl_str_compare(candidate, (const char*)(*family)) != 0)
m_aFontNameToLocalized[OString(candidate)] = OString((const char*)(*family));
}
if (rtl_str_compare((const char*)origfamily, (const char*)(*family)) != 0)
m_aLocalizedToCanonical[OString((const char*)(*family))] = OString((const char*)origfamily);
}
}
return eFamilyRes;
}
/*
* PrintFontManager::initFontconfig
@ -588,18 +595,16 @@ int PrintFontManager::countFontconfigFonts()
int weight = 0;
int spacing = 0;
int nCollectionEntry = -1;
FcBool outline = false, embitmap = true, antialias = true;
FcBool outline = false;
FcResult eFileRes = rWrapper.FcPatternGetString( pFSet->fonts[i], FC_FILE, 0, &file );
FcResult eFamilyRes = lcl_FamilyFromPattern(rWrapper, pFSet->fonts[i], &family, rWrapper.m_aFontconfigNameToLocalized );
FcResult eFamilyRes = rWrapper.FamilyFromPattern( pFSet->fonts[i], &family );
FcResult eStyleRes = rWrapper.FcPatternGetString( pFSet->fonts[i], FC_STYLE, 0, &style );
FcResult eSlantRes = rWrapper.FcPatternGetInteger( pFSet->fonts[i], FC_SLANT, 0, &slant );
FcResult eWeightRes = rWrapper.FcPatternGetInteger( pFSet->fonts[i], FC_WEIGHT, 0, &weight );
FcResult eSpacRes = rWrapper.FcPatternGetInteger( pFSet->fonts[i], FC_SPACING, 0, &spacing );
FcResult eOutRes = rWrapper.FcPatternGetBool( pFSet->fonts[i], FC_OUTLINE, 0, &outline );
FcResult eIndexRes = rWrapper.FcPatternGetInteger( pFSet->fonts[i], FC_INDEX, 0, &nCollectionEntry );
FcResult eEmbeddedBitmap = rWrapper.FcPatternGetBool( pFSet->fonts[i], FC_EMBEDDED_BITMAP, 0, &embitmap );
FcResult eAntialias = rWrapper.FcPatternGetBool( pFSet->fonts[i], FC_ANTIALIAS, 0, &antialias );
if( eFileRes != FcResultMatch || eFamilyRes != FcResultMatch || eOutRes != FcResultMatch )
continue;
@ -739,15 +744,6 @@ int PrintFontManager::countFontconfigFonts()
{
pUpdate->m_aStyleName = OStringToOUString( OString( (sal_Char*)style ), RTL_TEXTENCODING_UTF8 );
}
if( eEmbeddedBitmap == FcResultMatch )
{
pUpdate->m_eEmbeddedbitmap = embitmap ? fcstatus::istrue : fcstatus::isfalse;
}
if( eAntialias == FcResultMatch )
{
pUpdate->m_eAntialias = antialias ? fcstatus::istrue : fcstatus::isfalse;
}
// update font cache
m_pFontCache->updateFontCacheEntry( pUpdate, false );
@ -952,8 +948,8 @@ rtl::OUString PrintFontManager::Substitute(const rtl::OUString& rFontName,
if( eFileRes == FcResultMatch )
{
OString sFamily((sal_Char*)family);
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash >::const_iterator aI = rWrapper.m_aFontconfigNameToLocalized.find(sFamily);
if (aI != rWrapper.m_aFontconfigNameToLocalized.end())
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash >::const_iterator aI = rWrapper.m_aFontNameToLocalized.find(sFamily);
if (aI != rWrapper.m_aFontNameToLocalized.end())
sFamily = aI->second;
aName = rtl::OStringToOUString( sFamily, RTL_TEXTENCODING_UTF8 );
}
@ -984,6 +980,98 @@ rtl::OUString PrintFontManager::Substitute(const rtl::OUString& rFontName,
return aName;
}
FontConfigHints PrintFontManager::getFontConfigHints(
const FastPrintFontInfo& rInfo, int nSize, void (*subcallback)(void *) )
{
FontConfigHints aHints;
#ifdef ENABLE_FONTCONFIG
FontCfgWrapper& rWrapper = FontCfgWrapper::get();
if( ! rWrapper.isValid() )
return aHints;
FcConfig* pConfig = rWrapper.FcConfigGetCurrent();
FcPattern* pPattern = rWrapper.FcPatternCreate();
OString sFamily = OUStringToOString( rInfo.m_aFamilyName, RTL_TEXTENCODING_UTF8 );
std::hash_map< rtl::OString, rtl::OString, rtl::OStringHash >::const_iterator aI = rWrapper.m_aLocalizedToCanonical.find(sFamily);
if (aI != rWrapper.m_aLocalizedToCanonical.end())
sFamily = aI->second;
if( sFamily.getLength() )
rWrapper.FcPatternAddString( pPattern, FC_FAMILY, (FcChar8*)sFamily.getStr() );
addtopattern(rWrapper, pPattern, rInfo.m_eItalic, rInfo.m_eWeight, rInfo.m_eWidth, rInfo.m_ePitch);
rWrapper.FcPatternAddDouble( pPattern, FC_PIXEL_SIZE, nSize);
FcBool embitmap = true, antialias = true, autohint = true, hinting = true;
int hintstyle = FC_HINT_FULL;
rWrapper.FcConfigSubstitute( pConfig, pPattern, FcMatchPattern );
if (subcallback) subcallback(pPattern);
rWrapper.FcDefaultSubstitute( pPattern );
FcResult eResult = FcResultNoMatch;
FcFontSet *pFontSet = rWrapper.getFontSet();
FcPattern* pResult = rWrapper.FcFontSetMatch( pConfig, &pFontSet, 1, pPattern, &eResult );
if( pResult )
{
FcFontSet* pSet = rWrapper.FcFontSetCreate();
rWrapper.FcFontSetAdd( pSet, pResult );
if( pSet->nfont > 0 )
{
FcResult eEmbeddedBitmap = rWrapper.FcPatternGetBool(pSet->fonts[0],
FC_EMBEDDED_BITMAP, 0, &embitmap);
FcResult eAntialias = rWrapper.FcPatternGetBool(pSet->fonts[0],
FC_ANTIALIAS, 0, &antialias);
FcResult eAutoHint = rWrapper.FcPatternGetBool(pSet->fonts[0],
FC_AUTOHINT, 0, &autohint);
FcResult eHinting = rWrapper.FcPatternGetBool(pSet->fonts[0],
FC_HINTING, 0, &hinting);
FcResult eHintStyle = rWrapper.FcPatternGetInteger(pSet->fonts[0],
FC_HINT_STYLE, 0, &hintstyle);
if( eEmbeddedBitmap == FcResultMatch )
aHints.m_eEmbeddedbitmap = embitmap ? fcstatus::istrue : fcstatus::isfalse;
if( eAntialias == FcResultMatch )
aHints.m_eAntialias = antialias ? fcstatus::istrue : fcstatus::isfalse;
if( eAutoHint == FcResultMatch )
aHints.m_eAutoHint = autohint ? fcstatus::istrue : fcstatus::isfalse;
if( eHinting == FcResultMatch )
aHints.m_eHinting = hinting ? fcstatus::istrue : fcstatus::isfalse;
if (eHintStyle != FcResultMatch)
aHints.m_eHintStyle = fchint::Full;
else
{
switch (hintstyle)
{
case FC_HINT_NONE:
aHints.m_eHintStyle = fchint::Nohint;
break;
case FC_HINT_SLIGHT:
aHints.m_eHintStyle = fchint::Slight;
break;
case FC_HINT_MEDIUM:
aHints.m_eHintStyle = fchint::Medium;
break;
case FC_HINT_FULL:
default:
aHints.m_eHintStyle = fchint::Full;
break;
}
}
}
// info: destroying the pSet destroys pResult implicitly
// since pResult was "added" to pSet
rWrapper.FcFontSetDestroy( pSet );
}
// cleanup
rWrapper.FcPatternDestroy( pPattern );
#endif
return aHints;
}
bool PrintFontManager::matchFont( FastPrintFontInfo& rInfo, const com::sun::star::lang::Locale& rLocale )
{
FontCfgWrapper& rWrapper = FontCfgWrapper::get();

8
vcl/unx/source/fontmanager/fontmanager.cxx
View file

@ -353,9 +353,7 @@ PrintFontManager::PrintFont::PrintFont( fonttype::type eType ) :
m_nXMax( 0 ),
m_nYMax( 0 ),
m_bHaveVerticalSubstitutedGlyphs( false ),
m_bUserOverride( false ),
m_eEmbeddedbitmap( fcstatus::isunset ),
m_eAntialias( fcstatus::isunset )
m_bUserOverride( false )
{
}
@ -2630,8 +2628,6 @@ void PrintFontManager::fillPrintFontInfo( PrintFont* pFont, FastPrintFontInfo& r
rInfo.m_eWeight = pFont->m_eWeight;
rInfo.m_ePitch = pFont->m_ePitch;
rInfo.m_aEncoding = pFont->m_aEncoding;
rInfo.m_eEmbeddedbitmap = pFont->m_eEmbeddedbitmap;
rInfo.m_eAntialias = pFont->m_eAntialias;
rInfo.m_bEmbeddable = (pFont->m_eType == fonttype::Type1);
rInfo.m_bSubsettable = (pFont->m_eType == fonttype::TrueType); // TODO: rename to SfntType
@ -3936,8 +3932,6 @@ bool PrintFontManager::readOverrideMetrics()
BuiltinFont* pFont = new BuiltinFont();
pFont->m_nDirectory = 0;
pFont->m_bUserOverride = false;
pFont->m_eEmbeddedbitmap = fcstatus::isunset;
pFont->m_eAntialias = fcstatus::isunset;
pFont->m_pMetrics = new PrintFontMetrics;
memset( pFont->m_pMetrics->m_aPages, 0xff, sizeof( pFont->m_pMetrics->m_aPages ) );
pFont->m_pMetrics->m_bKernPairsQueried = true;

30
vcl/unx/source/gdi/pspgraphics.cxx
View file

@ -885,6 +885,10 @@ void PspGraphics::GetDevFontSubstList( OutputDevice* pOutDev )
}
}
void PspGraphics::GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const
{
}
void PspGraphics::GetFontMetric( ImplFontMetricData *pMetric )
{
const psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
@ -1284,32 +1288,6 @@ ImplDevFontAttributes PspGraphics::Info2DevFontAttributes( const psp::FastPrintF
aDFA.mbSubsettable = rInfo.m_bSubsettable;
aDFA.mbEmbeddable = rInfo.m_bEmbeddable;
switch (rInfo.m_eEmbeddedbitmap)
{
default:
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_DONTKNOW;
break;
case psp::fcstatus::istrue:
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_TRUE;
break;
case psp::fcstatus::isfalse:
aDFA.meEmbeddedBitmap = EMBEDDEDBITMAP_FALSE;
break;
}
switch (rInfo.m_eAntialias)
{
default:
aDFA.meAntiAlias = ANTIALIAS_DONTKNOW;
break;
case psp::fcstatus::istrue:
aDFA.meAntiAlias = ANTIALIAS_TRUE;
break;
case psp::fcstatus::isfalse:
aDFA.meAntiAlias = ANTIALIAS_FALSE;
break;
}
switch( rInfo.m_eType )
{
case psp::fonttype::Builtin:

195
vcl/unx/source/gdi/salgdi3.cxx
View file

@ -743,6 +743,8 @@ private:
void (*mp_set_font_matrix)(cairo_t *, const cairo_matrix_t *);
void (*mp_show_glyphs)(cairo_t *, const cairo_glyph_t *, int );
void (*mp_set_source_rgb)(cairo_t *, double , double , double );
void (*mp_set_font_options)(cairo_t *, const void *);
void (*mp_ft_font_options_substitute)(const void*, void*);
bool canEmbolden() const { return false; }
@ -778,6 +780,10 @@ public:
{ (*mp_show_glyphs)(cr, glyphs, no_glyphs); }
void set_source_rgb(cairo_t *cr, double red, double green, double blue)
{ (*mp_set_source_rgb)(cr, red, green, blue); }
void set_font_options(cairo_t *cr, const void *options)
{ (*mp_set_font_options)(cr, options); }
void ft_font_options_substitute(const void *options, void *pattern)
{ (*mp_ft_font_options_substitute)(options, pattern); }
};
static CairoWrapper* pCairoInstance = NULL;
@ -847,6 +853,10 @@ CairoWrapper::CairoWrapper()
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_show_glyphs" );
mp_set_source_rgb = (void (*)(cairo_t *, double , double , double ))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_set_source_rgb" );
mp_set_font_options = (void (*)(cairo_t *, const void *options ))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_set_font_options" );
mp_ft_font_options_substitute = (void (*)(const void *, void *))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_ft_font_options_substitute" );
if( !(
mp_xlib_surface_create_with_xrender_format &&
@ -863,7 +873,9 @@ CairoWrapper::CairoWrapper()
mp_matrix_rotate &&
mp_set_font_matrix &&
mp_show_glyphs &&
mp_set_source_rgb
mp_set_source_rgb &&
mp_set_font_options &&
mp_ft_font_options_substitute
) )
{
osl_unloadModule( mpCairoLib );
@ -1601,6 +1613,187 @@ void X11SalGraphics::GetDevFontSubstList( OutputDevice* )
// ----------------------------------------------------------------------------
void cairosubcallback(void *pPattern)
{
CairoWrapper &rCairo = CairoWrapper::get();
if (rCairo.isValid())
{
rCairo.ft_font_options_substitute(
Application::GetSettings().GetStyleSettings().GetCairoFontOptions(),
pPattern);
}
}
void X11SalGraphics::GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints) const
{
psp::FastPrintFontInfo aInfo;
// set family name
aInfo.m_aFamilyName = rFontAttributes.GetFamilyName();
// set italic
switch( rFontAttributes.GetSlant() )
{
case ITALIC_NONE:
aInfo.m_eItalic = psp::italic::Upright;
break;
case ITALIC_NORMAL:
aInfo.m_eItalic = psp::italic::Italic;
break;
case ITALIC_OBLIQUE:
aInfo.m_eItalic = psp::italic::Oblique;
break;
default:
aInfo.m_eItalic = psp::italic::Unknown;
break;
}
// set weight
switch( rFontAttributes.GetWeight() )
{
case WEIGHT_THIN:
aInfo.m_eWeight = psp::weight::Thin;
break;
case WEIGHT_ULTRALIGHT:
aInfo.m_eWeight = psp::weight::UltraLight;
break;
case WEIGHT_LIGHT:
aInfo.m_eWeight = psp::weight::Light;
break;
case WEIGHT_SEMILIGHT:
aInfo.m_eWeight = psp::weight::SemiLight;
break;
case WEIGHT_NORMAL:
aInfo.m_eWeight = psp::weight::Normal;
break;
case WEIGHT_MEDIUM:
aInfo.m_eWeight = psp::weight::Medium;
break;
case WEIGHT_SEMIBOLD:
aInfo.m_eWeight = psp::weight::SemiBold;
break;
case WEIGHT_BOLD:
aInfo.m_eWeight = psp::weight::Bold;
break;
case WEIGHT_ULTRABOLD:
aInfo.m_eWeight = psp::weight::UltraBold;
break;
case WEIGHT_BLACK:
aInfo.m_eWeight = psp::weight::Black;
break;
default:
aInfo.m_eWeight = psp::weight::Unknown;
break;
}
// set width
switch( rFontAttributes.GetWidthType() )
{
case WIDTH_ULTRA_CONDENSED:
aInfo.m_eWidth = psp::width::UltraCondensed;
break;
case WIDTH_EXTRA_CONDENSED:
aInfo.m_eWidth = psp::width::ExtraCondensed;
break;
case WIDTH_CONDENSED:
aInfo.m_eWidth = psp::width::Condensed;
break;
case WIDTH_SEMI_CONDENSED:
aInfo.m_eWidth = psp::width::SemiCondensed;
break;
case WIDTH_NORMAL:
aInfo.m_eWidth = psp::width::Normal;
break;
case WIDTH_SEMI_EXPANDED:
aInfo.m_eWidth = psp::width::SemiExpanded;
break;
case WIDTH_EXPANDED:
aInfo.m_eWidth = psp::width::Expanded;
break;
case WIDTH_EXTRA_EXPANDED:
aInfo.m_eWidth = psp::width::ExtraExpanded;
break;
case WIDTH_ULTRA_EXPANDED:
aInfo.m_eWidth = psp::width::UltraExpanded;
break;
default:
aInfo.m_eWidth = psp::width::Unknown;
break;
}
psp::FontConfigHints aHints(psp::PrintFontManager::get().getFontConfigHints(aInfo, nSize,
cairosubcallback));
switch (aHints.m_eEmbeddedbitmap)
{
default:
rFontHints.meEmbeddedBitmap = EMBEDDEDBITMAP_DONTKNOW;
break;
case psp::fcstatus::istrue:
rFontHints.meEmbeddedBitmap = EMBEDDEDBITMAP_TRUE;
break;
case psp::fcstatus::isfalse:
rFontHints.meEmbeddedBitmap = EMBEDDEDBITMAP_FALSE;
break;
}
switch (aHints.m_eAntialias)
{
default:
rFontHints.meAntiAlias = ANTIALIAS_DONTKNOW;
break;
case psp::fcstatus::istrue:
rFontHints.meAntiAlias = ANTIALIAS_TRUE;
break;
case psp::fcstatus::isfalse:
rFontHints.meAntiAlias = ANTIALIAS_FALSE;
break;
}
switch (aHints.m_eAutoHint)
{
default:
rFontHints.meAutoHint = AUTOHINT_DONTKNOW;
break;
case psp::fcstatus::istrue:
rFontHints.meAutoHint = AUTOHINT_TRUE;
break;
case psp::fcstatus::isfalse:
rFontHints.meAutoHint = AUTOHINT_FALSE;
break;
}
switch (aHints.m_eHinting)
{
default:
rFontHints.meHinting = HINTING_DONTKNOW;
break;
case psp::fcstatus::istrue:
rFontHints.meHinting = HINTING_TRUE;
break;
case psp::fcstatus::isfalse:
rFontHints.meHinting = HINTING_FALSE;
break;
}
switch (aHints.m_eHintStyle)
{
case psp::fchint::Nohint:
rFontHints.meHintStyle = HINT_NONE;
break;
case psp::fchint::Slight:
rFontHints.meHintStyle = HINT_SLIGHT;
break;
case psp::fchint::Medium:
rFontHints.meHintStyle = HINT_MEDIUM;
break;
default:
case psp::fchint::Full:
rFontHints.meHintStyle = HINT_FULL;
break;
}
}
// ----------------------------------------------------------------------------
void
X11SalGraphics::GetFontMetric( ImplFontMetricData *pMetric )
{

3
vcl/unx/source/gdi/xlfd_extd.cxx
View file

@ -105,9 +105,6 @@ ExtendedXlfd::ExtendedXlfd( bool bScalable )
mbSubsettable = false;
mbEmbeddable = false;
meEmbeddedBitmap = EMBEDDEDBITMAP_DONTKNOW;
meAntiAlias = ANTIALIAS_DONTKNOW;
mnQuality = -1;
}

1
vcl/win/inc/salgdi.h
View file

@ -286,6 +286,7 @@ public:
virtual USHORT SetFont( ImplFontSelectData*, int nFallbackLevel );
// get the current font's etrics
virtual void GetFontMetric( ImplFontMetricData* );
virtual void GetFontHints( const ImplFontAttributes& rFontAttributes, int nHints, ImplFontHints& rFontHints);
// get kernign pairs of the current font
// return only PairCount if (pKernPairs == NULL)
virtual ULONG GetKernPairs( ULONG nPairs, ImplKernPairData* pKernPairs );

6
vcl/win/source/gdi/salgdi3.cxx
View file

@ -1450,6 +1450,12 @@ USHORT WinSalGraphics::SetFont( ImplFontSelectData* pFont, int nFallbackLevel )
// -----------------------------------------------------------------------
void WinSalGraphics::GetFontHints( const ImplFontAttributes& rFontAttributes, int nSize, ImplFontHints& rFontHints)
{
}
// -----------------------------------------------------------------------
void WinSalGraphics::GetFontMetric( ImplFontMetricData* pMetric )
{
if ( aSalShlData.mbWNT )