Skip to content

C
core
Kaydet (Commit) dd179370 authored tarafından Caolán McNamara's avatar Caolán McNamara
Dosyalara gözat
Seçenekler

seperate headless textrendering into its own class 

and forward calls to it from the SvpGraphics

Change-Id: I6d1fbc8919596d5f47661b3471570fcb7e14bc3e
üst 56580e90
Show whitespace changes
Inline Side-by-side
Showing with 650 additions and 393 deletions
vcl/Library_vcl.mk
Dosyayı görüntüle @ dd179370
...@@ -558,6 +558,7 @@ vcl_headless_code= \ ...@@ -558,6 +558,7 @@ vcl_headless_code= \
vcl_headless_freetype_code=\ vcl_headless_freetype_code=\
vcl/headless/svpprn \ vcl/headless/svpprn \
vcl/headless/svptext \ vcl/headless/svptext \
vcl/headless/svptextrender \
ifeq ($(GUIBASE),unx) ifeq ($(GUIBASE),unx)
$(eval $(call gb_Library_add_exception_objects,vcl,\ $(eval $(call gb_Library_add_exception_objects,vcl,\
......
vcl/StaticLibrary_headless.mk
Dosyayı görüntüle @ dd179370
...@@ -25,6 +25,7 @@ $(eval $(call gb_StaticLibrary_add_exception_objects,headless,\ ...@@ -25,6 +25,7 @@ $(eval $(call gb_StaticLibrary_add_exception_objects,headless,\
vcl/headless/svpframe \ vcl/headless/svpframe \
vcl/headless/svpprn \ vcl/headless/svpprn \
vcl/headless/svptext \ vcl/headless/svptext \
vcl/headless/svptextrender \
vcl/headless/svpvd \ vcl/headless/svpvd \
)) ))
......
vcl/headless/svpgdi.cxx
Dosyayı görüntüle @ dd179370
...@@ -19,6 +19,7 @@ ...@@ -19,6 +19,7 @@
#include "headless/svpgdi.hxx" #include "headless/svpgdi.hxx"
#include "headless/svpbmp.hxx" #include "headless/svpbmp.hxx"
#include "headless/svptextrender.hxx"
#include "saldatabasic.hxx" #include "saldatabasic.hxx"
#include <vcl/sysdata.hxx> #include <vcl/sysdata.hxx>
...@@ -101,12 +102,9 @@ SvpSalGraphics::SvpSalGraphics() : ...@@ -101,12 +102,9 @@ SvpSalGraphics::SvpSalGraphics() :
m_bUseFillColor( false ), m_bUseFillColor( false ),
m_aFillColor( COL_WHITE ), m_aFillColor( COL_WHITE ),
m_aDrawMode( basebmp::DrawMode_PAINT ), m_aDrawMode( basebmp::DrawMode_PAINT ),
m_aTextColor( COL_BLACK ),
m_eTextFmt( basebmp::FORMAT_EIGHT_BIT_GREY ),
m_bClipSetup( false ) m_bClipSetup( false )
{ {
for( int i = 0; i < MAX_FALLBACK; ++i ) m_xTextRenderImpl.reset(new SvpTextRender(*this));
m_pServerFont[i] = NULL;
} }
SvpSalGraphics::~SvpSalGraphics() SvpSalGraphics::~SvpSalGraphics()
...@@ -117,26 +115,7 @@ void SvpSalGraphics::setDevice( basebmp::BitmapDeviceSharedPtr& rDevice ) ...@@ -117,26 +115,7 @@ void SvpSalGraphics::setDevice( basebmp::BitmapDeviceSharedPtr& rDevice )
{ {
m_aOrigDevice = rDevice; m_aOrigDevice = rDevice;
ResetClipRegion(); ResetClipRegion();
m_xTextRenderImpl->setDevice(rDevice);
// determine matching bitmap format for masks
basebmp::Format nDeviceFmt = m_aDevice ? m_aDevice->getScanlineFormat() : basebmp::FORMAT_EIGHT_BIT_GREY;
switch( nDeviceFmt )
{
case basebmp::FORMAT_EIGHT_BIT_GREY:
case basebmp::FORMAT_SIXTEEN_BIT_LSB_TC_MASK:
case basebmp::FORMAT_SIXTEEN_BIT_MSB_TC_MASK:
case basebmp::FORMAT_TWENTYFOUR_BIT_TC_MASK:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_BGRX:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_BGRA:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_ARGB:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_ABGR:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_RGBA:
m_eTextFmt = basebmp::FORMAT_EIGHT_BIT_GREY;
break;
default:
m_eTextFmt = basebmp::FORMAT_ONE_BIT_LSB_GREY;
break;
}
} }
#endif #endif
......
vcl/headless/svptext.cxx
Dosyayı görüntüle @ dd179370
...@@ -18,279 +18,43 @@ ...@@ -18,279 +18,43 @@
*/ */
#include <sal/types.h> #include <sal/types.h>
#include <cassert>
#include <basebmp/scanlineformats.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/range/b2ibox.hxx> #include <basegfx/range/b2ibox.hxx>
#include <rtl/instance.hxx>
#include <tools/debug.hxx>
#include <vcl/sysdata.hxx>
#include "generic/geninst.h"
#include "generic/genpspgraphics.h"
#include "generic/glyphcache.hxx"
#include "headless/svpbmp.hxx"
#include "headless/svpgdi.hxx" #include "headless/svpgdi.hxx"
#include "impfont.hxx"
#include "outfont.hxx"
#include "PhysicalFontFace.hxx"
class PhysicalFontCollection;
using namespace basegfx;
using namespace basebmp;
class SvpGlyphPeer : public GlyphCachePeer
{
public:
SvpGlyphPeer() {}
BitmapDeviceSharedPtr GetGlyphBmp( ServerFont&, sal_GlyphId,
basebmp::Format nBmpFormat, B2IPoint& rTargetPos );
protected:
virtual void RemovingFont( ServerFont& ) SAL_OVERRIDE;
virtual void RemovingGlyph( GlyphData& ) SAL_OVERRIDE;
class SvpGcpHelper
{
public:
RawBitmap maRawBitmap;
BitmapDeviceSharedPtr maBitmapDev;
};
};
class SvpGlyphCache : public GlyphCache
{
public:
SvpGlyphCache( SvpGlyphPeer& rPeer ) : GlyphCache( rPeer) {}
SvpGlyphPeer& GetPeer() { return reinterpret_cast<SvpGlyphPeer&>( mrPeer ); }
static SvpGlyphCache& GetInstance();
};
namespace
{
struct GlyphCacheHolder
{
private:
SvpGlyphPeer* m_pSvpGlyphPeer;
SvpGlyphCache* m_pSvpGlyphCache;
public:
GlyphCacheHolder()
{
m_pSvpGlyphPeer = new SvpGlyphPeer();
m_pSvpGlyphCache = new SvpGlyphCache( *m_pSvpGlyphPeer );
}
void release()
{
delete m_pSvpGlyphCache;
delete m_pSvpGlyphPeer;
m_pSvpGlyphCache = NULL;
m_pSvpGlyphPeer = NULL;
}
SvpGlyphCache& getGlyphCache()
{
return *m_pSvpGlyphCache;
}
~GlyphCacheHolder()
{
release();
}
};
struct theGlyphCacheHolder :
public rtl::Static<GlyphCacheHolder, theGlyphCacheHolder>
{};
}
SvpGlyphCache& SvpGlyphCache::GetInstance()
{
return theGlyphCacheHolder::get().getGlyphCache();
}
BitmapDeviceSharedPtr SvpGlyphPeer::GetGlyphBmp( ServerFont& rServerFont,
sal_GlyphId aGlyphId, basebmp::Format nBmpFormat, B2IPoint& rTargetPos )
{
GlyphData& rGlyphData = rServerFont.GetGlyphData( aGlyphId );
if( rGlyphData.ExtDataRef().meInfo != nBmpFormat )
{
SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
rGlyphData.ExtDataRef().mpData);
bool bNew = pGcpHelper == 0;
if( bNew )
pGcpHelper = new SvpGcpHelper;
// get glyph bitmap in matching format
bool bFound = false;
switch( nBmpFormat )
{
case FORMAT_ONE_BIT_LSB_GREY:
bFound = rServerFont.GetGlyphBitmap1( aGlyphId, pGcpHelper->maRawBitmap );
break;
case FORMAT_EIGHT_BIT_GREY:
bFound = rServerFont.GetGlyphBitmap8( aGlyphId, pGcpHelper->maRawBitmap );
break;
default:
OSL_FAIL( "SVP GCP::GetGlyphBmp(): illegal scanline format");
// fall back to black&white mask
nBmpFormat = FORMAT_ONE_BIT_LSB_GREY;
bFound = false;
break;
}
// return .notdef glyph if needed
if( !bFound && (aGlyphId != 0) )
{
if( bNew )
delete pGcpHelper;
return GetGlyphBmp( rServerFont, 0, nBmpFormat, rTargetPos );
}
// construct alpha mask from raw bitmap
if (pGcpHelper->maRawBitmap.mnScanlineSize && pGcpHelper->maRawBitmap.mnHeight)
{
const B2IVector aSize(
pGcpHelper->maRawBitmap.mnScanlineSize,
pGcpHelper->maRawBitmap.mnHeight );
static PaletteMemorySharedVector aDummyPAL;
pGcpHelper->maBitmapDev = createBitmapDevice( aSize, true, nBmpFormat, aSize.getX(), pGcpHelper->maRawBitmap.mpBits, aDummyPAL );
}
rGlyphData.ExtDataRef().meInfo = nBmpFormat;
rGlyphData.ExtDataRef().mpData = pGcpHelper;
}
SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
rGlyphData.ExtDataRef().mpData);
assert(pGcpHelper != 0);
rTargetPos += B2IPoint( pGcpHelper->maRawBitmap.mnXOffset, pGcpHelper->maRawBitmap.mnYOffset );
return pGcpHelper->maBitmapDev;
}
void SvpGlyphPeer::RemovingFont( ServerFont& )
{
// nothing to do: no font resources held in SvpGlyphPeer
}
void SvpGlyphPeer::RemovingGlyph( GlyphData& rGlyphData )
{
SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
rGlyphData.ExtDataRef().mpData);
rGlyphData.ExtDataRef().meInfo = basebmp::FORMAT_NONE;
rGlyphData.ExtDataRef().mpData = 0;
delete pGcpHelper;
}
sal_uInt16 SvpSalGraphics::SetFont( FontSelectPattern* pIFSD, int nFallbackLevel ) sal_uInt16 SvpSalGraphics::SetFont( FontSelectPattern* pIFSD, int nFallbackLevel )
{ {
// release all no longer needed font resources return m_xTextRenderImpl->SetFont(pIFSD, nFallbackLevel);
for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
{
if( m_pServerFont[i] != NULL )
{
// old server side font is no longer referenced
SvpGlyphCache::GetInstance().UncacheFont( *m_pServerFont[i] );
m_pServerFont[i] = NULL;
}
}
// return early if there is no new font
if( !pIFSD )
return 0;
// handle the request for a non-native X11-font => use the GlyphCache
ServerFont* pServerFont = SvpGlyphCache::GetInstance().CacheFont( *pIFSD );
if( !pServerFont )
return SAL_SETFONT_BADFONT;
// check selected font
if( !pServerFont->TestFont() )
{
SvpGlyphCache::GetInstance().UncacheFont( *pServerFont );
return SAL_SETFONT_BADFONT;
}
// update SalGraphics font settings
m_pServerFont[ nFallbackLevel ] = pServerFont;
return SAL_SETFONT_USEDRAWTEXTARRAY;
} }
void SvpSalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel ) void SvpSalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
{ {
if( nFallbackLevel >= MAX_FALLBACK ) m_xTextRenderImpl->GetFontMetric(pMetric, nFallbackLevel);
return;
if( m_pServerFont[nFallbackLevel] != NULL )
{
long rDummyFactor;
m_pServerFont[nFallbackLevel]->FetchFontMetric( *pMetric, rDummyFactor );
}
} }
const FontCharMapPtr SvpSalGraphics::GetFontCharMap() const const FontCharMapPtr SvpSalGraphics::GetFontCharMap() const
{ {
if( !m_pServerFont[0] ) return m_xTextRenderImpl->GetFontCharMap();
return NULL;
const FontCharMapPtr pFCMap = m_pServerFont[0]->GetFontCharMap();
return pFCMap;
} }
bool SvpSalGraphics::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const bool SvpSalGraphics::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
{ {
if (!m_pServerFont[0]) return m_xTextRenderImpl->GetFontCapabilities(rFontCapabilities);
return false;
return m_pServerFont[0]->GetFontCapabilities(rFontCapabilities);
} }
void SvpSalGraphics::GetDevFontList( PhysicalFontCollection* pFontCollection ) void SvpSalGraphics::GetDevFontList( PhysicalFontCollection* pFontCollection )
{ {
GlyphCache& rGC = SvpGlyphCache::GetInstance(); m_xTextRenderImpl->GetDevFontList(pFontCollection);
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
psp::FastPrintFontInfo aInfo;
::std::list< psp::fontID > aList;
rMgr.getFontList( aList );
::std::list< psp::fontID >::iterator it;
for( it = aList.begin(); it != aList.end(); ++it )
{
if( !rMgr.getFontFastInfo( *it, aInfo ) )
continue;
// normalize face number to the GlyphCache
int nFaceNum = rMgr.getFontFaceNumber( aInfo.m_nID );
// inform GlyphCache about this font provided by the PsPrint subsystem
ImplDevFontAttributes aDFA = GenPspGraphics::Info2DevFontAttributes( aInfo );
aDFA.mnQuality += 4096;
const OString& rFileName = rMgr.getFontFileSysPath( aInfo.m_nID );
rGC.AddFontFile( rFileName, nFaceNum, aInfo.m_nID, aDFA );
}
// announce glyphcache fonts
rGC.AnnounceFonts( pFontCollection );
// register platform specific font substitutions if available
SalGenericInstance::RegisterFontSubstitutors( pFontCollection );
ImplGetSVData()->maGDIData.mbNativeFontConfig = true;
} }
void SvpSalGraphics::ClearDevFontCache() void SvpSalGraphics::ClearDevFontCache()
{ {
GlyphCache& rGC = SvpGlyphCache::GetInstance(); m_xTextRenderImpl->ClearDevFontCache();
rGC.ClearFontCache();
} }
bool SvpSalGraphics::AddTempDevFont( PhysicalFontCollection*, bool SvpSalGraphics::AddTempDevFont( PhysicalFontCollection* pFontCollection,
const OUString&, const OUString& ) const OUString& rFileURL, const OUString& rFontName)
{ {
return false; return m_xTextRenderImpl->AddTempDevFont(pFontCollection, rFileURL, rFontName);
} }
bool SvpSalGraphics::CreateFontSubset( bool SvpSalGraphics::CreateFontSubset(
...@@ -300,36 +64,14 @@ bool SvpSalGraphics::CreateFontSubset( ...@@ -300,36 +64,14 @@ bool SvpSalGraphics::CreateFontSubset(
const sal_uInt8* pEncoding, const sal_uInt8* pEncoding,
sal_Int32* pWidths, sal_Int32* pWidths,
int nGlyphCount, int nGlyphCount,
FontSubsetInfo& rInfo FontSubsetInfo& rInfo)
)
{ {
// in this context the pFont->GetFontId() is a valid PSP return m_xTextRenderImpl->CreateFontSubset(rToFile, pFont, pGlyphIds, pEncoding, pWidths, nGlyphCount, rInfo);
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
bool bSuccess = rMgr.createFontSubset( rInfo,
aFont,
rToFile,
pGlyphIds,
pEncoding,
pWidths,
nGlyphCount );
return bSuccess;
} }
const Ucs2SIntMap* SvpSalGraphics::GetFontEncodingVector( const PhysicalFontFace* pFont, const Ucs2OStrMap** pNonEncoded, std::set<sal_Unicode> const** ppPriority) const Ucs2SIntMap* SvpSalGraphics::GetFontEncodingVector( const PhysicalFontFace* pFont, const Ucs2OStrMap** pNonEncoded, std::set<sal_Unicode> const** ppPriority)
{ {
// in this context the pFont->GetFontId() is a valid PSP return m_xTextRenderImpl->GetFontEncodingVector(pFont, pNonEncoded, ppPriority);
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
return GenPspGraphics::DoGetFontEncodingVector(aFont, pNonEncoded, ppPriority);
} }
const void* SvpSalGraphics::GetEmbedFontData( const void* SvpSalGraphics::GetEmbedFontData(
...@@ -338,21 +80,14 @@ const void* SvpSalGraphics::GetEmbedFontData( ...@@ -338,21 +80,14 @@ const void* SvpSalGraphics::GetEmbedFontData(
sal_Int32* pWidths, sal_Int32* pWidths,
size_t nLen, size_t nLen,
FontSubsetInfo& rInfo, FontSubsetInfo& rInfo,
long* pDataLen long* pDataLen)
)
{ {
// in this context the pFont->GetFontId() is a valid PSP return m_xTextRenderImpl->GetEmbedFontData(pFont, pUnicodes, pWidths, nLen, rInfo, pDataLen);
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
return GenPspGraphics::DoGetEmbedFontData( aFont, pUnicodes, pWidths, nLen, rInfo, pDataLen );
} }
void SvpSalGraphics::FreeEmbedFontData( const void* pData, long nLen ) void SvpSalGraphics::FreeEmbedFontData( const void* pData, long nLen )
{ {
GenPspGraphics::DoFreeEmbedFontData( pData, nLen ); m_xTextRenderImpl->FreeEmbedFontData(pData, nLen);
} }
void SvpSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont, void SvpSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
...@@ -360,110 +95,51 @@ void SvpSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont, ...@@ -360,110 +95,51 @@ void SvpSalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
Int32Vector& rWidths, Int32Vector& rWidths,
Ucs2UIntMap& rUnicodeEnc ) Ucs2UIntMap& rUnicodeEnc )
{ {
// in this context the pFont->GetFontId() is a valid PSP m_xTextRenderImpl->GetGlyphWidths(pFont, bVertical, rWidths, rUnicodeEnc);
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
GenPspGraphics::DoGetGlyphWidths( aFont, bVertical, rWidths, rUnicodeEnc );
} }
bool SvpSalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect ) bool SvpSalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
{ {
const int nLevel = aGlyphId >> GF_FONTSHIFT; return m_xTextRenderImpl->GetGlyphBoundRect(aGlyphId, rRect);
if( nLevel >= MAX_FALLBACK )
return false;
ServerFont* pSF = m_pServerFont[ nLevel ];
if( !pSF )
return false;
aGlyphId &= GF_IDXMASK;
const GlyphMetric& rGM = pSF->GetGlyphMetric( aGlyphId );
rRect = Rectangle( rGM.GetOffset(), rGM.GetSize() );
return true;
} }
bool SvpSalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId, B2DPolyPolygon& rPolyPoly ) bool SvpSalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId, basegfx::B2DPolyPolygon& rPolyPoly )
{ {
const int nLevel = aGlyphId >> GF_FONTSHIFT; return m_xTextRenderImpl->GetGlyphOutline(aGlyphId, rPolyPoly);
if( nLevel >= MAX_FALLBACK )
return false;
const ServerFont* pSF = m_pServerFont[ nLevel ];
if( !pSF )
return false;
aGlyphId &= GF_IDXMASK;
if( pSF->GetGlyphOutline( aGlyphId, rPolyPoly ) )
return true;
return false;
} }
SalLayout* SvpSalGraphics::GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) SalLayout* SvpSalGraphics::GetTextLayout( ImplLayoutArgs& rArgs, int nFallbackLevel )
{ {
GenericSalLayout* pLayout = NULL; return m_xTextRenderImpl->GetTextLayout(rArgs, nFallbackLevel);
if( m_pServerFont[ nFallbackLevel ] )
pLayout = new ServerFontLayout( *m_pServerFont[ nFallbackLevel ] );
return pLayout;
} }
void SvpSalGraphics::DrawServerFontLayout( const ServerFontLayout& rSalLayout ) void SvpSalGraphics::DrawServerFontLayout( const ServerFontLayout& rSalLayout )
{ {
// iterate over all glyphs in the layout m_xTextRenderImpl->DrawServerFontLayout(rSalLayout );
Point aPos;
sal_GlyphId aGlyphId;
SvpGlyphPeer& rGlyphPeer = SvpGlyphCache::GetInstance().GetPeer();
for( int nStart = 0; rSalLayout.GetNextGlyphs( 1, &aGlyphId, aPos, nStart ); )
{
int nLevel = aGlyphId >> GF_FONTSHIFT;
DBG_ASSERT( nLevel < MAX_FALLBACK, "SvpGDI: invalid glyph fallback level" );
ServerFont* pSF = m_pServerFont[ nLevel ];
if( !pSF )
continue;
// get the glyph's alpha mask and adjust the drawing position
aGlyphId &= GF_IDXMASK;
B2IPoint aDstPoint( aPos.X(), aPos.Y() );
BitmapDeviceSharedPtr aAlphaMask
= rGlyphPeer.GetGlyphBmp( *pSF, aGlyphId, m_eTextFmt, aDstPoint );
if( !aAlphaMask ) // ignore empty glyphs
continue;
// blend text color into target using the glyph's mask
const B2IBox aSrcRect( B2ITuple(0,0), aAlphaMask->getSize() );
const B2IBox aClipRect( aDstPoint, aAlphaMask->getSize() );
SvpSalGraphics::ClipUndoHandle aUndo( this );
if( !isClippedSetup( aClipRect, aUndo ) )
m_aDevice->drawMaskedColor( m_aTextColor, aAlphaMask,
aSrcRect, aDstPoint, m_aClipMap );
}
} }
void SvpSalGraphics::SetTextColor( SalColor nSalColor ) void SvpSalGraphics::SetTextColor( SalColor nSalColor )
{ {
m_aTextColor = basebmp::Color( nSalColor ); m_xTextRenderImpl->SetTextColor(nSalColor);
} }
SystemFontData SvpSalGraphics::GetSysFontData( int nFallbacklevel ) const SystemFontData SvpSalGraphics::GetSysFontData( int nFallbacklevel ) const
{ {
SystemFontData aSysFontData; return m_xTextRenderImpl->GetSysFontData(nFallbacklevel);
}
void SvpSalGraphics::BlendTextColor(const basebmp::Color &rTextColor, const basebmp::BitmapDeviceSharedPtr &rAlphaMask,
const basegfx::B2IPoint &rDstPoint)
{
// blend text color into target using the glyph's mask
const basegfx::B2IBox aSrcRect(basegfx::B2ITuple(0,0), rAlphaMask->getSize());
const basegfx::B2IBox aClipRect(rDstPoint, rAlphaMask->getSize());
if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1; SvpSalGraphics::ClipUndoHandle aUndo(this);
if (nFallbacklevel < 0 ) nFallbacklevel = 0; if (isClippedSetup(aClipRect, aUndo))
return;
aSysFontData.nSize = sizeof( SystemFontData ); m_aDevice->drawMaskedColor(rTextColor, rAlphaMask, aSrcRect, rDstPoint, m_aClipMap);
aSysFontData.nFontId = 0;
aSysFontData.nFontFlags = 0;
aSysFontData.bFakeBold = false;
aSysFontData.bFakeItalic = false;
aSysFontData.bAntialias = true;
return aSysFontData;
} }
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
vcl/headless/svptextrender.cxx 0 → 100644
Dosyayı görüntüle @ dd179370
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <sal/types.h>
#include <cassert>
#include <basebmp/scanlineformats.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/range/b2ibox.hxx>
#include <rtl/instance.hxx>
#include <tools/debug.hxx>
#include <vcl/sysdata.hxx>
#include "generic/geninst.h"
#include "generic/genpspgraphics.h"
#include "generic/glyphcache.hxx"
#include "headless/svpbmp.hxx"
#include "headless/svpgdi.hxx"
#include "headless/svptextrender.hxx"
#include "impfont.hxx"
#include "outfont.hxx"
#include "PhysicalFontFace.hxx"
class PhysicalFontCollection;
using namespace basegfx;
using namespace basebmp;
class SvpGlyphPeer : public GlyphCachePeer
{
public:
SvpGlyphPeer() {}
BitmapDeviceSharedPtr GetGlyphBmp( ServerFont&, sal_GlyphId,
basebmp::Format nBmpFormat, B2IPoint& rTargetPos );
protected:
virtual void RemovingFont( ServerFont& ) SAL_OVERRIDE;
virtual void RemovingGlyph( GlyphData& ) SAL_OVERRIDE;
class SvpGcpHelper
{
public:
RawBitmap maRawBitmap;
BitmapDeviceSharedPtr maBitmapDev;
};
};
class SvpGlyphCache : public GlyphCache
{
public:
SvpGlyphCache( SvpGlyphPeer& rPeer ) : GlyphCache( rPeer) {}
SvpGlyphPeer& GetPeer() { return reinterpret_cast<SvpGlyphPeer&>( mrPeer ); }
static SvpGlyphCache& GetInstance();
};
namespace
{
struct GlyphCacheHolder
{
private:
SvpGlyphPeer* m_pSvpGlyphPeer;
SvpGlyphCache* m_pSvpGlyphCache;
public:
GlyphCacheHolder()
{
m_pSvpGlyphPeer = new SvpGlyphPeer();
m_pSvpGlyphCache = new SvpGlyphCache( *m_pSvpGlyphPeer );
}
void release()
{
delete m_pSvpGlyphCache;
delete m_pSvpGlyphPeer;
m_pSvpGlyphCache = NULL;
m_pSvpGlyphPeer = NULL;
}
SvpGlyphCache& getGlyphCache()
{
return *m_pSvpGlyphCache;
}
~GlyphCacheHolder()
{
release();
}
};
struct theGlyphCacheHolder :
public rtl::Static<GlyphCacheHolder, theGlyphCacheHolder>
{};
}
SvpGlyphCache& SvpGlyphCache::GetInstance()
{
return theGlyphCacheHolder::get().getGlyphCache();
}
BitmapDeviceSharedPtr SvpGlyphPeer::GetGlyphBmp( ServerFont& rServerFont,
sal_GlyphId aGlyphId, basebmp::Format nBmpFormat, B2IPoint& rTargetPos )
{
GlyphData& rGlyphData = rServerFont.GetGlyphData( aGlyphId );
if( rGlyphData.ExtDataRef().meInfo != nBmpFormat )
{
SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
rGlyphData.ExtDataRef().mpData);
bool bNew = pGcpHelper == 0;
if( bNew )
pGcpHelper = new SvpGcpHelper;
// get glyph bitmap in matching format
bool bFound = false;
switch( nBmpFormat )
{
case FORMAT_ONE_BIT_LSB_GREY:
bFound = rServerFont.GetGlyphBitmap1( aGlyphId, pGcpHelper->maRawBitmap );
break;
case FORMAT_EIGHT_BIT_GREY:
bFound = rServerFont.GetGlyphBitmap8( aGlyphId, pGcpHelper->maRawBitmap );
break;
default:
OSL_FAIL( "SVP GCP::GetGlyphBmp(): illegal scanline format");
// fall back to black&white mask
nBmpFormat = FORMAT_ONE_BIT_LSB_GREY;
bFound = false;
break;
}
// return .notdef glyph if needed
if( !bFound && (aGlyphId != 0) )
{
if( bNew )
delete pGcpHelper;
return GetGlyphBmp( rServerFont, 0, nBmpFormat, rTargetPos );
}
// construct alpha mask from raw bitmap
if (pGcpHelper->maRawBitmap.mnScanlineSize && pGcpHelper->maRawBitmap.mnHeight)
{
const B2IVector aSize(
pGcpHelper->maRawBitmap.mnScanlineSize,
pGcpHelper->maRawBitmap.mnHeight );
static PaletteMemorySharedVector aDummyPAL;
pGcpHelper->maBitmapDev = createBitmapDevice( aSize, true, nBmpFormat, aSize.getX(), pGcpHelper->maRawBitmap.mpBits, aDummyPAL );
}
rGlyphData.ExtDataRef().meInfo = nBmpFormat;
rGlyphData.ExtDataRef().mpData = pGcpHelper;
}
SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
rGlyphData.ExtDataRef().mpData);
assert(pGcpHelper != 0);
rTargetPos += B2IPoint( pGcpHelper->maRawBitmap.mnXOffset, pGcpHelper->maRawBitmap.mnYOffset );
return pGcpHelper->maBitmapDev;
}
void SvpGlyphPeer::RemovingFont( ServerFont& )
{
// nothing to do: no font resources held in SvpGlyphPeer
}
void SvpGlyphPeer::RemovingGlyph( GlyphData& rGlyphData )
{
SvpGcpHelper* pGcpHelper = static_cast<SvpGcpHelper*>(
rGlyphData.ExtDataRef().mpData);
rGlyphData.ExtDataRef().meInfo = basebmp::FORMAT_NONE;
rGlyphData.ExtDataRef().mpData = 0;
delete pGcpHelper;
}
SvpTextRender::SvpTextRender(SvpSalGraphics& rParent)
: m_rParent(rParent)
, m_aTextColor(COL_BLACK)
, m_eTextFmt(basebmp::FORMAT_EIGHT_BIT_GREY)
{
for( int i = 0; i < MAX_FALLBACK; ++i )
m_pServerFont[i] = NULL;
}
sal_uInt16 SvpTextRender::SetFont( FontSelectPattern* pIFSD, int nFallbackLevel )
{
// release all no longer needed font resources
for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
{
if( m_pServerFont[i] != NULL )
{
// old server side font is no longer referenced
SvpGlyphCache::GetInstance().UncacheFont( *m_pServerFont[i] );
m_pServerFont[i] = NULL;
}
}
// return early if there is no new font
if( !pIFSD )
return 0;
// handle the request for a non-native X11-font => use the GlyphCache
ServerFont* pServerFont = SvpGlyphCache::GetInstance().CacheFont( *pIFSD );
if( !pServerFont )
return SAL_SETFONT_BADFONT;
// check selected font
if( !pServerFont->TestFont() )
{
SvpGlyphCache::GetInstance().UncacheFont( *pServerFont );
return SAL_SETFONT_BADFONT;
}
// update SalGraphics font settings
m_pServerFont[ nFallbackLevel ] = pServerFont;
return SAL_SETFONT_USEDRAWTEXTARRAY;
}
void SvpTextRender::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
{
if( nFallbackLevel >= MAX_FALLBACK )
return;
if( m_pServerFont[nFallbackLevel] != NULL )
{
long rDummyFactor;
m_pServerFont[nFallbackLevel]->FetchFontMetric( *pMetric, rDummyFactor );
}
}
const FontCharMapPtr SvpTextRender::GetFontCharMap() const
{
if( !m_pServerFont[0] )
return NULL;
const FontCharMapPtr pFCMap = m_pServerFont[0]->GetFontCharMap();
return pFCMap;
}
bool SvpTextRender::GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const
{
if (!m_pServerFont[0])
return false;
return m_pServerFont[0]->GetFontCapabilities(rFontCapabilities);
}
void SvpTextRender::GetDevFontList( PhysicalFontCollection* pFontCollection )
{
GlyphCache& rGC = SvpGlyphCache::GetInstance();
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
psp::FastPrintFontInfo aInfo;
::std::list< psp::fontID > aList;
rMgr.getFontList( aList );
::std::list< psp::fontID >::iterator it;
for( it = aList.begin(); it != aList.end(); ++it )
{
if( !rMgr.getFontFastInfo( *it, aInfo ) )
continue;
// normalize face number to the GlyphCache
int nFaceNum = rMgr.getFontFaceNumber( aInfo.m_nID );
// inform GlyphCache about this font provided by the PsPrint subsystem
ImplDevFontAttributes aDFA = GenPspGraphics::Info2DevFontAttributes( aInfo );
aDFA.mnQuality += 4096;
const OString& rFileName = rMgr.getFontFileSysPath( aInfo.m_nID );
rGC.AddFontFile( rFileName, nFaceNum, aInfo.m_nID, aDFA );
}
// announce glyphcache fonts
rGC.AnnounceFonts( pFontCollection );
// register platform specific font substitutions if available
SalGenericInstance::RegisterFontSubstitutors( pFontCollection );
ImplGetSVData()->maGDIData.mbNativeFontConfig = true;
}
void SvpTextRender::ClearDevFontCache()
{
GlyphCache& rGC = SvpGlyphCache::GetInstance();
rGC.ClearFontCache();
}
bool SvpTextRender::AddTempDevFont( PhysicalFontCollection*,
const OUString&, const OUString& )
{
return false;
}
bool SvpTextRender::CreateFontSubset(
const OUString& rToFile,
const PhysicalFontFace* pFont,
const sal_GlyphId* pGlyphIds,
const sal_uInt8* pEncoding,
sal_Int32* pWidths,
int nGlyphCount,
FontSubsetInfo& rInfo
)
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
bool bSuccess = rMgr.createFontSubset( rInfo,
aFont,
rToFile,
pGlyphIds,
pEncoding,
pWidths,
nGlyphCount );
return bSuccess;
}
const Ucs2SIntMap* SvpTextRender::GetFontEncodingVector( const PhysicalFontFace* pFont, const Ucs2OStrMap** pNonEncoded, std::set<sal_Unicode> const** ppPriority)
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
return GenPspGraphics::DoGetFontEncodingVector(aFont, pNonEncoded, ppPriority);
}
const void* SvpTextRender::GetEmbedFontData(
const PhysicalFontFace* pFont,
const sal_Ucs* pUnicodes,
sal_Int32* pWidths,
size_t nLen,
FontSubsetInfo& rInfo,
long* pDataLen
)
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
return GenPspGraphics::DoGetEmbedFontData( aFont, pUnicodes, pWidths, nLen, rInfo, pDataLen );
}
void SvpTextRender::FreeEmbedFontData( const void* pData, long nLen )
{
GenPspGraphics::DoFreeEmbedFontData( pData, nLen );
}
void SvpTextRender::GetGlyphWidths( const PhysicalFontFace* pFont,
bool bVertical,
Int32Vector& rWidths,
Ucs2UIntMap& rUnicodeEnc )
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the PhysicalFontFace pFont
psp::fontID aFont = pFont->GetFontId();
GenPspGraphics::DoGetGlyphWidths( aFont, bVertical, rWidths, rUnicodeEnc );
}
bool SvpTextRender::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
{
const int nLevel = aGlyphId >> GF_FONTSHIFT;
if( nLevel >= MAX_FALLBACK )
return false;
ServerFont* pSF = m_pServerFont[ nLevel ];
if( !pSF )
return false;
aGlyphId &= GF_IDXMASK;
const GlyphMetric& rGM = pSF->GetGlyphMetric( aGlyphId );
rRect = Rectangle( rGM.GetOffset(), rGM.GetSize() );
return true;
}
bool SvpTextRender::GetGlyphOutline( sal_GlyphId aGlyphId, B2DPolyPolygon& rPolyPoly )
{
const int nLevel = aGlyphId >> GF_FONTSHIFT;
if( nLevel >= MAX_FALLBACK )
return false;
const ServerFont* pSF = m_pServerFont[ nLevel ];
if( !pSF )
return false;
aGlyphId &= GF_IDXMASK;
if( pSF->GetGlyphOutline( aGlyphId, rPolyPoly ) )
return true;
return false;
}
SalLayout* SvpTextRender::GetTextLayout( ImplLayoutArgs&, int nFallbackLevel )
{
GenericSalLayout* pLayout = NULL;
if( m_pServerFont[ nFallbackLevel ] )
pLayout = new ServerFontLayout( *m_pServerFont[ nFallbackLevel ] );
return pLayout;
}
void SvpTextRender::DrawServerFontLayout( const ServerFontLayout& rSalLayout )
{
// iterate over all glyphs in the layout
Point aPos;
sal_GlyphId aGlyphId;
SvpGlyphPeer& rGlyphPeer = SvpGlyphCache::GetInstance().GetPeer();
for( int nStart = 0; rSalLayout.GetNextGlyphs( 1, &aGlyphId, aPos, nStart ); )
{
int nLevel = aGlyphId >> GF_FONTSHIFT;
DBG_ASSERT( nLevel < MAX_FALLBACK, "SvpGDI: invalid glyph fallback level" );
ServerFont* pSF = m_pServerFont[ nLevel ];
if( !pSF )
continue;
// get the glyph's alpha mask and adjust the drawing position
aGlyphId &= GF_IDXMASK;
B2IPoint aDstPoint( aPos.X(), aPos.Y() );
BitmapDeviceSharedPtr aAlphaMask
= rGlyphPeer.GetGlyphBmp( *pSF, aGlyphId, m_eTextFmt, aDstPoint );
if( !aAlphaMask ) // ignore empty glyphs
continue;
// blend text color into target using the glyph's mask
m_rParent.BlendTextColor(m_aTextColor, aAlphaMask, aDstPoint);
}
}
void SvpTextRender::SetTextColor( SalColor nSalColor )
{
m_aTextColor = basebmp::Color( nSalColor );
}
SystemFontData SvpTextRender::GetSysFontData( int nFallbacklevel ) const
{
SystemFontData aSysFontData;
if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
if (nFallbacklevel < 0 ) nFallbacklevel = 0;
aSysFontData.nSize = sizeof( SystemFontData );
aSysFontData.nFontId = 0;
aSysFontData.nFontFlags = 0;
aSysFontData.bFakeBold = false;
aSysFontData.bFakeItalic = false;
aSysFontData.bAntialias = true;
return aSysFontData;
}
void SvpTextRender::setDevice( basebmp::BitmapDeviceSharedPtr& rDevice )
{
// determine matching bitmap format for masks
basebmp::Format nDeviceFmt = rDevice ? rDevice->getScanlineFormat() : basebmp::FORMAT_EIGHT_BIT_GREY;
switch( nDeviceFmt )
{
case basebmp::FORMAT_EIGHT_BIT_GREY:
case basebmp::FORMAT_SIXTEEN_BIT_LSB_TC_MASK:
case basebmp::FORMAT_SIXTEEN_BIT_MSB_TC_MASK:
case basebmp::FORMAT_TWENTYFOUR_BIT_TC_MASK:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_BGRX:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_BGRA:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_ARGB:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_ABGR:
case basebmp::FORMAT_THIRTYTWO_BIT_TC_MASK_RGBA:
m_eTextFmt = basebmp::FORMAT_EIGHT_BIT_GREY;
break;
default:
m_eTextFmt = basebmp::FORMAT_ONE_BIT_LSB_GREY;
break;
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
vcl/inc/devicetextrender.hxx 0 → 100644
Dosyayı görüntüle @ dd179370
/* -*- 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/.
*/
#ifndef INCLUDED_VCL_INC_DEVICETEXTRENDER_HXX
#define INCLUDED_VCL_INC_DEVICETEXTRENDER_HXX
#include <basebmp/bitmapdevice.hxx>
#include "textrender.hxx"
class VCL_DLLPUBLIC DeviceTextRenderImpl : public TextRenderImpl
{
public:
virtual void setDevice(basebmp::BitmapDeviceSharedPtr& rDevice) = 0;
};
#endif
/* vim:set tabstop=4 shiftwidth=4 softtabstop=4 expandtab: */
vcl/inc/headless/svpgdi.hxx
Dosyayı görüntüle @ dd179370
...@@ -27,6 +27,7 @@ ...@@ -27,6 +27,7 @@
#include "salgdi.hxx" #include "salgdi.hxx"
#include "sallayout.hxx" #include "sallayout.hxx"
#include "devicetextrender.hxx"
#ifdef IOS #ifdef IOS
#define SvpSalGraphics AquaSalGraphics #define SvpSalGraphics AquaSalGraphics
...@@ -48,15 +49,14 @@ class SvpSalGraphics : public SalGraphics ...@@ -48,15 +49,14 @@ class SvpSalGraphics : public SalGraphics
basebmp::DrawMode m_aDrawMode; basebmp::DrawMode m_aDrawMode;
// These fields are used only when we use FreeType to draw into a
// headless backend, i.e. not on iOS.
basebmp::Color m_aTextColor;
ServerFont* m_pServerFont[ MAX_FALLBACK ];
basebmp::Format m_eTextFmt;
protected: protected:
basegfx::B2IVector GetSize() { return m_aOrigDevice->getSize(); } basegfx::B2IVector GetSize() { return m_aOrigDevice->getSize(); }
public:
void setDevice(basebmp::BitmapDeviceSharedPtr& rDevice);
void BlendTextColor(const basebmp::Color &rTextColor, const basebmp::BitmapDeviceSharedPtr &rAlphaMask,
const basegfx::B2IPoint &rDstPoint);
private: private:
bool m_bClipSetup; bool m_bClipSetup;
struct ClipUndoHandle { struct ClipUndoHandle {
...@@ -68,11 +68,9 @@ private: ...@@ -68,11 +68,9 @@ private:
bool isClippedSetup( const basegfx::B2IBox &aRange, ClipUndoHandle &rUndo ); bool isClippedSetup( const basegfx::B2IBox &aRange, ClipUndoHandle &rUndo );
void ensureClip(); void ensureClip();
public:
void setDevice( basebmp::BitmapDeviceSharedPtr& rDevice );
protected: protected:
vcl::Region m_aClipRegion; vcl::Region m_aClipRegion;
std::unique_ptr<DeviceTextRenderImpl> m_xTextRenderImpl;
protected: protected:
virtual bool blendBitmap( const SalTwoRect&, const SalBitmap& rBitmap ) SAL_OVERRIDE; virtual bool blendBitmap( const SalTwoRect&, const SalBitmap& rBitmap ) SAL_OVERRIDE;
......
vcl/inc/headless/svptextrender.hxx 0 → 100644
Dosyayı görüntüle @ dd179370
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef INCLUDED_VCL_INC_HEADLESS_SVPTEXTRENDER_HXX
#define INCLUDED_VCL_INC_HEADLESS_SVPTEXTRENDER_HXX
#include "devicetextrender.hxx"
#include <vcl/region.hxx>
#include <deque>
class VCL_DLLPUBLIC SvpTextRender : public DeviceTextRenderImpl
{
private:
SvpSalGraphics& m_rParent;
// These fields are used only when we use FreeType to draw into a
// headless backend, i.e. not on iOS.
basebmp::Color m_aTextColor;
basebmp::Format m_eTextFmt;
ServerFont* m_pServerFont[ MAX_FALLBACK ];
public:
SvpTextRender(SvpSalGraphics& rParent);
virtual void setDevice(basebmp::BitmapDeviceSharedPtr& rDevice) SAL_OVERRIDE;
virtual void SetTextColor( SalColor nSalColor ) SAL_OVERRIDE;
virtual sal_uInt16 SetFont( FontSelectPattern*, int nFallbackLevel ) SAL_OVERRIDE;
virtual void GetFontMetric( ImplFontMetricData*, int nFallbackLevel ) SAL_OVERRIDE;
virtual const FontCharMapPtr GetFontCharMap() const SAL_OVERRIDE;
virtual bool GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const SAL_OVERRIDE;
virtual void GetDevFontList( PhysicalFontCollection* ) SAL_OVERRIDE;
virtual void ClearDevFontCache() SAL_OVERRIDE;
virtual bool AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) SAL_OVERRIDE;
virtual bool CreateFontSubset(
const OUString& rToFile,
const PhysicalFontFace*,
const sal_GlyphId* pGlyphIDs,
const sal_uInt8* pEncoding,
sal_Int32* pWidths,
int nGlyphs,
FontSubsetInfo& rInfo) SAL_OVERRIDE;
virtual const Ucs2SIntMap* GetFontEncodingVector( const PhysicalFontFace*, const Ucs2OStrMap** ppNonEncoded, std::set<sal_Unicode> const**) SAL_OVERRIDE;
virtual const void* GetEmbedFontData(
const PhysicalFontFace*,
const sal_Ucs* pUnicodes,
sal_Int32* pWidths,
size_t nLen,
FontSubsetInfo& rInfo,
long* pDataLen ) SAL_OVERRIDE;
virtual void FreeEmbedFontData( const void* pData, long nDataLen ) SAL_OVERRIDE;
virtual void GetGlyphWidths(
const PhysicalFontFace*,
bool bVertical,
Int32Vector& rWidths,
Ucs2UIntMap& rUnicodeEnc ) SAL_OVERRIDE;
virtual bool GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& ) SAL_OVERRIDE;
virtual bool GetGlyphOutline( sal_GlyphId nIndex, ::basegfx::B2DPolyPolygon& ) SAL_OVERRIDE;
virtual SalLayout* GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) SAL_OVERRIDE;
virtual void DrawServerFontLayout( const ServerFontLayout& ) SAL_OVERRIDE;
virtual SystemFontData GetSysFontData( int nFallbackLevel ) const SAL_OVERRIDE;
};
#endif // INCLUDED_VCL_INC_HEADLESS_SVPTEXTRENDER_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment