openoffice-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From h..@apache.org
Subject svn commit: r1560749 [2/2] - in /openoffice/trunk/main/vcl: Library_vcl.mk aqua/source/gdi/atsfonts.cxx aqua/source/gdi/atsfonts.hxx aqua/source/gdi/atslayout.cxx aqua/source/gdi/salgdi.cxx source/gdi/outdev3.cxx
Date Thu, 23 Jan 2014 17:00:44 GMT
Modified: openoffice/trunk/main/vcl/aqua/source/gdi/salgdi.cxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/vcl/aqua/source/gdi/salgdi.cxx?rev=1560749&r1=1560748&r2=1560749&view=diff
==============================================================================
--- openoffice/trunk/main/vcl/aqua/source/gdi/salgdi.cxx (original)
+++ openoffice/trunk/main/vcl/aqua/source/gdi/salgdi.cxx Thu Jan 23 17:00:44 2014
@@ -19,8 +19,6 @@
  * 
  *************************************************************/
 
-
-
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_vcl.hxx"
 
@@ -46,25 +44,43 @@
 #include "aqua/salbmp.h"
 #include "aqua/salframe.h"
 #include "aqua/salcolorutils.hxx"
+#ifdef USE_ATSU
 #include "atsfonts.hxx"
+#else // !USE_ATSU
+#include "ctfonts.hxx"
+#endif
 
 #include "fontsubset.hxx"
 #include "impfont.hxx"
 #include "sallayout.hxx"
 #include "sft.hxx"
 
-
 using namespace vcl;
 
-//typedef unsigned char Boolean; // copied from MacTypes.h, should be properly included
-typedef std::vector<unsigned char> ByteVector;
+// =======================================================================
 
+SystemFontList::~SystemFontList( void )
+{}
 
 // =======================================================================
 
-ImplMacFontData::ImplMacFontData( const ImplDevFontAttributes& rDFA, ATSUFontID nFontId
)
-:   ImplFontData( rDFA, 0 )
-,   mnFontId( nFontId )
+ImplMacTextStyle::ImplMacTextStyle( const ImplFontSelectData& rReqFont )
+:	mpFontData( (ImplMacFontData*)rReqFont.mpFontData )
+,	mfFontScale( 1.0 )
+,	mfFontStretch( 1.0 )
+,	mfFontRotation( 0.0 )
+{}
+
+// -----------------------------------------------------------------------
+
+ImplMacTextStyle::~ImplMacTextStyle( void )
+{}
+
+// =======================================================================
+
+ImplMacFontData::ImplMacFontData( const ImplDevFontAttributes& rDFA, sal_IntPtr nFontId
)
+:	ImplFontData( rDFA, 0 )
+,	mnFontId( nFontId )
 ,	mpCharMap( NULL )
 ,	mbOs2Read( false )
 ,	mbHasOs2Table( false )
@@ -74,43 +90,43 @@ ImplMacFontData::ImplMacFontData( const 
 
 // -----------------------------------------------------------------------
 
-ImplMacFontData::~ImplMacFontData()
+ImplMacFontData::ImplMacFontData( const ImplMacFontData& rSrc )
+:	ImplFontData(       rSrc)
+,	mnFontId(           rSrc.mnFontId)
+,	mpCharMap(          rSrc.mpCharMap)
+,	mbOs2Read(          rSrc.mbOs2Read)
+,	mbHasOs2Table(      rSrc.mbHasOs2Table)
+,	mbCmapEncodingRead( rSrc.mbCmapEncodingRead)
+,	mbHasCJKSupport(    rSrc.mbHasCJKSupport)
 {
 	if( mpCharMap )
-		mpCharMap->DeReference();
+		mpCharMap->AddReference();
 }
 
 // -----------------------------------------------------------------------
 
-sal_IntPtr ImplMacFontData::GetFontId() const
+ImplMacFontData::~ImplMacFontData()
 {
-    return (sal_IntPtr)mnFontId;
+	if( mpCharMap )
+		mpCharMap->DeReference();
 }
 
 // -----------------------------------------------------------------------
 
-ImplFontData* ImplMacFontData::Clone() const
+sal_IntPtr ImplMacFontData::GetFontId() const
 {
-	ImplMacFontData* pClone = new ImplMacFontData(*this);
-	if( mpCharMap )
-		mpCharMap->AddReference();
-    return pClone;
+    return reinterpret_cast<sal_IntPtr>( mnFontId);
 }
 
 // -----------------------------------------------------------------------
 
 ImplFontEntry* ImplMacFontData::CreateFontInstance(ImplFontSelectData& rFSD) const
 {
-    return new ImplFontEntry(rFSD);
+	return new ImplFontEntry(rFSD);
 }
 
 // -----------------------------------------------------------------------
 
-inline FourCharCode GetTag(const char aTagName[5])
-{
-	return (aTagName[0]<<24)+(aTagName[1]<<16)+(aTagName[2]<<8)+(aTagName[3]);
-}
-
 static unsigned GetUShort( const unsigned char* p ){return((p[0]<<8)+p[1]);}
 static unsigned GetUInt( const unsigned char* p ) { return((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3]);}
 
@@ -125,27 +141,23 @@ const ImplFontCharMap* ImplMacFontData::
 	mpCharMap->AddReference();
 
 	// get the CMAP byte size
-	ATSFontRef rFont = FMGetATSFontRefFromFont( mnFontId );
-	ByteCount nBufSize = 0;
-    OSStatus eStatus = ATSFontGetTable( rFont, GetTag("cmap"), 0, 0, NULL, &nBufSize
);
-	DBG_ASSERT( (eStatus==noErr), "ImplMacFontData::GetImplFontCharMap : ATSFontGetTable1 failed!\n");
-	if( eStatus != noErr )
-		return mpCharMap;
-
 	// allocate a buffer for the CMAP raw data
-	ByteVector aBuffer( nBufSize );
+	const int nBufSize = GetFontTable( "cmap", NULL );
+	DBG_ASSERT( (nBufSize > 0), "ImplMacFontData::GetImplFontCharMap : FontGetTable1 failed!\n");
+	if( nBufSize <= 0 )
+		return mpCharMap;
 
 	// get the CMAP raw data
-	ByteCount nRawLength = 0;
-	eStatus = ATSFontGetTable( rFont, GetTag("cmap"), 0, nBufSize, (void*)&aBuffer[0], &nRawLength
);
-	DBG_ASSERT( (eStatus==noErr), "ImplMacFontData::GetImplFontCharMap : ATSFontGetTable2 failed!\n");
-	if( eStatus != noErr )
+	ByteVector aBuffer( nBufSize );
+	const int nRawSize = GetFontTable( "cmap", &aBuffer[0] );
+	DBG_ASSERT( (nRawSize > 0), "ImplMacFontData::GetImplFontCharMap : ATSFontGetTable2 failed!\n");
+	if( nRawSize <= 0 )
 		return mpCharMap;
-	DBG_ASSERT( (nBufSize==nRawLength), "ImplMacFontData::GetImplFontCharMap : ByteCount mismatch!\n");
+	DBG_ASSERT( (nBufSize==nRawSize), "ImplMacFontData::GetImplFontCharMap : ByteCount mismatch!\n");
 
 	// parse the CMAP
 	CmapResult aCmapResult;
-	if( ParseCMAP( &aBuffer[0], nRawLength, aCmapResult ) )
+	if( ParseCMAP( &aBuffer[0], nRawSize, aCmapResult ) )
 	{
 		// create the matching charmap
 		mpCharMap->DeReference();
@@ -164,25 +176,21 @@ void ImplMacFontData::ReadOs2Table( void
 	if( mbOs2Read )
 		return;
 	mbOs2Read = true;
+	mbHasOs2Table = false;
 
 	// prepare to get the OS/2 table raw data
-	ATSFontRef rFont = FMGetATSFontRefFromFont( mnFontId );
-	ByteCount nBufSize = 0;
-	OSStatus eStatus = ATSFontGetTable( rFont, GetTag("OS/2"), 0, 0, NULL, &nBufSize );
-	DBG_ASSERT( (eStatus==noErr), "ImplMacFontData::ReadOs2Table : ATSFontGetTable1 failed!\n");
-	if( eStatus != noErr )
+	const int nBufSize = GetFontTable( "OS/2", NULL );
+	DBG_ASSERT( (nBufSize > 0), "ImplMacFontData::ReadOs2Table : FontGetTable1 failed!\n");
+	if( nBufSize <= 0 )
 		return;
 
-	// allocate a buffer for the OS/2 raw data
-	ByteVector aBuffer( nBufSize );
-
 	// get the OS/2 raw data
-	ByteCount nRawLength = 0;
-	eStatus = ATSFontGetTable( rFont, GetTag("OS/2"), 0, nBufSize, (void*)&aBuffer[0], &nRawLength
);
-	DBG_ASSERT( (eStatus==noErr), "ImplMacFontData::ReadOs2Table : ATSFontGetTable2 failed!\n");
-	if( eStatus != noErr )
+	ByteVector aBuffer( nBufSize );
+	const int nRawSize = GetFontTable( "cmap", &aBuffer[0] );
+	DBG_ASSERT( (nRawSize > 0), "ImplMacFontData::ReadOs2Table : ATSFontGetTable2 failed!\n");
+	if( nRawSize <= 0 )
 		return;
-	DBG_ASSERT( (nBufSize==nRawLength), "ImplMacFontData::ReadOs2Table : ByteCount mismatch!\n");
+	DBG_ASSERT( (nBufSize == nRawSize), "ImplMacFontData::ReadOs2Table : ByteCount mismatch!\n");
 	mbHasOs2Table = true;
 
 	// parse the OS/2 raw data
@@ -190,63 +198,53 @@ void ImplMacFontData::ReadOs2Table( void
 
 	// check if the fonts needs the "CJK extra leading" heuristic
 	const unsigned char* pOS2map = &aBuffer[0];
-    const sal_uInt32 nVersion = GetUShort( pOS2map );
-    if( nVersion >= 0x0001 )
-    {
-        sal_uInt32 ulUnicodeRange2 = GetUInt( pOS2map + 46 );
-        if( ulUnicodeRange2 & 0x2DF00000 )
-            mbHasCJKSupport = true;
-    }
+	const sal_uInt32 nVersion = GetUShort( pOS2map );
+	if( nVersion >= 0x0001 )
+	{
+		const sal_uInt32 ulUnicodeRange2 = GetUInt( pOS2map + 46 );
+		if( ulUnicodeRange2 & 0x2DF00000 )
+			mbHasCJKSupport = true;
+	}
 }
 
 void ImplMacFontData::ReadMacCmapEncoding( void ) const
 {
-    // read this only once per font
-    if( mbCmapEncodingRead )
-        return;
-    mbCmapEncodingRead = true;
-
-    ATSFontRef rFont = FMGetATSFontRefFromFont( mnFontId );
-    ByteCount nBufSize = 0;
-    OSStatus eStatus = ATSFontGetTable( rFont, GetTag("cmap"), 0, 0, NULL, &nBufSize
);
-    DBG_ASSERT( (eStatus==noErr), "ImplMacFontData::ReadMacCmapEncoding : ATSFontGetTable1
failed!\n");
-    if( eStatus != noErr )
-        return;
-
-    ByteVector aBuffer( nBufSize );
-
-    ByteCount nRawLength = 0;
-    eStatus = ATSFontGetTable( rFont, GetTag("cmap"), 0, nBufSize, (void*)&aBuffer[0],
&nRawLength );
-    DBG_ASSERT( (eStatus==noErr), "ImplMacFontData::ReadMacCmapEncoding : ATSFontGetTable2
failed!\n");
-    if( eStatus != noErr )
-        return;
-    DBG_ASSERT( (nBufSize==nRawLength), "ImplMacFontData::ReadMacCmapEncoding : ByteCount
mismatch!\n");
+	// read this only once per font
+	if( mbCmapEncodingRead )
+		return;
+	mbCmapEncodingRead = true;
 
-    const unsigned char* pCmap = &aBuffer[0];
+	const int nBufSize = GetFontTable( "cmap", NULL );
+	if( nBufSize <= 0 )
+		return;
 
-    if (nRawLength < 24 )
-        return;
-    if( GetUShort( pCmap ) != 0x0000 )
-        return;
+	// get the CMAP raw data
+	ByteVector aBuffer( nBufSize );
+	const int nRawSize = GetFontTable( "cmap", &aBuffer[0] );
+	if( nRawSize < 24 )
+		return;
 
-    // check if the fonts needs the "CJK extra leading" heuristic
-    int nSubTables = GetUShort( pCmap + 2 );
+	const unsigned char* pCmap = &aBuffer[0];
+	if( GetUShort( pCmap ) != 0x0000 )
+		return;
 
-    for( const unsigned char* p = pCmap + 4; --nSubTables >= 0; p += 8 )
-    {
-        int nPlatform = GetUShort( p );
-        if( nPlatform == kFontMacintoshPlatform ) {
-            int nEncoding = GetUShort (p + 2 );
-            if( nEncoding == kFontJapaneseScript ||
-                nEncoding == kFontTraditionalChineseScript ||
-                nEncoding == kFontKoreanScript ||
-                nEncoding == kFontSimpleChineseScript )
-            {
-                mbHasCJKSupport = true;
-                break;
-            }
-        }
-    }
+	// check if the fonts needs the "CJK extra leading" heuristic
+	int nSubTables = GetUShort( pCmap + 2 );
+	for( const unsigned char* p = pCmap + 4; --nSubTables >= 0; p += 8 )
+	{
+		int nPlatform = GetUShort( p );
+		if( nPlatform == kFontMacintoshPlatform ) {
+			const int nEncoding = GetUShort (p + 2 );
+			if( nEncoding == kFontJapaneseScript ||
+			    nEncoding == kFontTraditionalChineseScript ||
+			    nEncoding == kFontKoreanScript ||
+			    nEncoding == kFontSimpleChineseScript )
+			{
+				mbHasCJKSupport = true;
+				break;
+			}
+		}
+	}
 }
 
 // -----------------------------------------------------------------------
@@ -254,8 +252,8 @@ void ImplMacFontData::ReadMacCmapEncodin
 bool ImplMacFontData::HasCJKSupport( void ) const
 {
 	ReadOs2Table();
-    if( !mbHasOs2Table )
-        ReadMacCmapEncoding();
+	if( !mbHasOs2Table )
+		ReadMacCmapEncoding();
 
 	return mbHasCJKSupport;
 }
@@ -277,59 +275,51 @@ AquaSalGraphics::AquaSalGraphics()
     , mxClipPath( NULL )
     , maLineColor( COL_WHITE )
     , maFillColor( COL_BLACK )
-	, mpMacFontData( NULL )
-    , mnATSUIRotation( 0 )
-    , mfFontScale( 1.0 )
-    , mfFontStretch( 1.0 )
+    , mpMacFontData( NULL )
+    , mpMacTextStyle( NULL )
+    , maTextColor( COL_BLACK )
     , mbNonAntialiasedText( false )
     , mbPrinter( false )
     , mbVirDev( false )
     , mbWindow( false )
-{
-    // create the style object for font attributes
-    ATSUCreateStyle( &maATSUStyle );
-}
+{}
 
 // -----------------------------------------------------------------------
 
 AquaSalGraphics::~AquaSalGraphics()
 {
-/*
-	if( mnUpdateGraphicsEvent )
-	{
-		Application::RemoveUserEvent( mnUpdateGraphicsEvent );
-	}
-*/
-    CGPathRelease( mxClipPath );
-    ATSUDisposeStyle( maATSUStyle );
+	CGPathRelease( mxClipPath );
+
+    delete mpMacTextStyle;
 
 	if( mpXorEmulation )
 		delete mpXorEmulation;
 
 	if( mxLayer )
-    	CGLayerRelease( mxLayer );
+		CGLayerRelease( mxLayer );
 	else if( mrContext && mbWindow )
 	{
 		// destroy backbuffer bitmap context that we created ourself
 		CGContextRelease( mrContext );
 		mrContext = NULL;
-        // memory is freed automatically by maOwnContextMemory
+		// memory is freed automatically by maOwnContextMemory
 	}
 }
 
 bool AquaSalGraphics::supportsOperation( OutDevSupportType eType ) const
 {
-    bool bRet = false;
-    switch( eType )
-    {
-    case OutDevSupport_TransparentRect:
-    case OutDevSupport_B2DClip:
-    case OutDevSupport_B2DDraw:
-        bRet = true;
-        break;
-    default: break;
-    }
-    return bRet;
+	bool bRet = false;
+	switch( eType )
+	{
+		case OutDevSupport_TransparentRect:
+		case OutDevSupport_B2DClip:
+		case OutDevSupport_B2DDraw:
+			bRet = true;
+			break;
+		default:
+			break;
+	}
+	return bRet;
 }
 
 // =======================================================================
@@ -1599,73 +1589,23 @@ bool AquaSalGraphics::drawAlphaRect( lon
 	// restore state
 	CGContextRestoreGState(mrContext);
 	RefreshRect( aRect );
-    return true;
+	return true;
 }
 
 // -----------------------------------------------------------------------
 
 void AquaSalGraphics::SetTextColor( SalColor nSalColor )
 {
-    RGBColor color;
-    color.red     = (unsigned short) ( SALCOLOR_RED(nSalColor)   * 65535.0 / 255.0 );
-    color.green   = (unsigned short) ( SALCOLOR_GREEN(nSalColor) * 65535.0 / 255.0 );
-    color.blue    = (unsigned short) ( SALCOLOR_BLUE(nSalColor)  * 65535.0 / 255.0 );
-
-    ATSUAttributeTag aTag = kATSUColorTag;
-    ByteCount aValueSize = sizeof( color );
-    ATSUAttributeValuePtr aValue = &color;
-
-    OSStatus err = ATSUSetAttributes( maATSUStyle, 1, &aTag, &aValueSize, &aValue
);
-	DBG_ASSERT( (err==noErr), "AquaSalGraphics::SetTextColor() : Could not set font attributes!\n");
-	if( err != noErr )
-		return;
+	maTextColor = RGBAColor( nSalColor );
+	if( mpMacTextStyle)
+		mpMacTextStyle->SetTextColor( maTextColor );
 }
 
 // -----------------------------------------------------------------------
 
-void AquaSalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
+void AquaSalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int /*nFallbackLevel*/
)
 {
-	(void)nFallbackLevel; // glyph-fallback on ATSU is done differently -> no fallback level
-
-	// get the ATSU font metrics (in point units)
-	// of the font that has eventually been size-limited
-
-    ATSUFontID fontId; 	 
-    OSStatus err = ATSUGetAttribute( maATSUStyle, kATSUFontTag, sizeof(ATSUFontID), &fontId,
0 );
-    DBG_ASSERT( (err==noErr), "AquaSalGraphics::GetFontMetric() : could not get font id\n");
-
-    ATSFontMetrics aMetrics;
-    ATSFontRef rFont = FMGetATSFontRefFromFont( fontId );
-    err = ATSFontGetHorizontalMetrics ( rFont, kATSOptionFlagsDefault, &aMetrics );
-	DBG_ASSERT( (err==noErr), "AquaSalGraphics::GetFontMetric() : could not get font metrics\n");
-    if( err != noErr )
-		return;
-
-	// all ATS fonts are scalable fonts
-	pMetric->mbScalableFont = true;
-	// TODO: check if any kerning is possible
-	pMetric->mbKernableFont = true;
-
-	// convert into VCL font metrics (in unscaled pixel units)
-
-    Fixed ptSize;
-    err = ATSUGetAttribute( maATSUStyle, kATSUSizeTag, sizeof(Fixed), &ptSize, 0);
-    DBG_ASSERT( (err==noErr), "AquaSalGraphics::GetFontMetric() : could not get font size\n");
-	const double fPointSize = Fix2X( ptSize );
-
-	// convert quartz units to pixel units
-	// please see the comment in AquaSalGraphics::SetFont() for details
-    const double fPixelSize = (mfFontScale * mfFakeDPIScale * fPointSize);
-    pMetric->mnAscent       = static_cast<long>(+aMetrics.ascent  * fPixelSize +
0.5);
-    pMetric->mnDescent      = static_cast<long>(-aMetrics.descent * fPixelSize +
0.5);
-    const long nExtDescent  = static_cast<long>((-aMetrics.descent + aMetrics.leading)
* fPixelSize + 0.5);
-    pMetric->mnExtLeading   = nExtDescent - pMetric->mnDescent;
-    pMetric->mnIntLeading   = 0;
-    // ATSFontMetrics.avgAdvanceWidth is obsolete, so it is usually set to zero
-    // since ImplFontMetricData::mnWidth is only used for stretching/squeezing fonts
-    // setting this width to the pixel height of the fontsize is good enough
-    // it also makes the calculation of the stretch factor simple
-    pMetric->mnWidth        = static_cast<long>(mfFontStretch * fPixelSize + 0.5);
+	mpMacTextStyle->GetFontMetric( mfFakeDPIScale, *pMetric );
 }
 
 // -----------------------------------------------------------------------
@@ -1748,19 +1688,26 @@ void AquaSalGraphics::GetDevFontList( Im
 {
 	DBG_ASSERT( pFontList, "AquaSalGraphics::GetDevFontList(NULL) !");
 
-    AddLocalTempFontDirs();
+	AddLocalTempFontDirs();
  
 	// The idea is to cache the list of system fonts once it has been generated. 
 	// SalData seems to be a good place for this caching. However we have to 
 	// carefully make the access to the font list thread-safe. If we register 
 	// a font-change event handler to update the font list in case fonts have 
 	// changed on the system we have to lock access to the list. The right
-    // way to do that is the solar mutex since GetDevFontList is protected
-    // through it as should be all event handlers
+	// way to do that is the solar mutex since GetDevFontList is protected
+	// through it as should be all event handlers
 
 	SalData* pSalData = GetSalData();
-	if (pSalData->mpFontList == NULL)
-		pSalData->mpFontList = new SystemFontList();
+#ifdef USE_ATSU
+	SystemFontList* GetAtsFontList(void);      // forward declaration
+	if( !pSalData->mpFontList )
+		pSalData->mpFontList = GetAtsFontList();
+#else
+	SystemFontList* GetCoretextFontList(void); // forward declaration
+	if( !pSalData->mpFontList )
+		pSalData->mpFontList = GetCoretextFontList();
+#endif // DISABLE_ATSUI
 
 	// Copy all ImplFontData objects contained in the SystemFontList
 	pSalData->mpFontList->AnnounceFonts( *pFontList );
@@ -1810,71 +1757,6 @@ bool AquaSalGraphics::AddTempDevFont( Im
 
 // -----------------------------------------------------------------------
 
-// callbacks from ATSUGlyphGetCubicPaths() fore GetGlyphOutline()
-struct GgoData { basegfx::B2DPolygon maPolygon; basegfx::B2DPolyPolygon* mpPolyPoly; };
-
-static OSStatus GgoLineToProc( const Float32Point* pPoint, void* pData )
-{
-	basegfx::B2DPolygon& rPolygon = static_cast<GgoData*>(pData)->maPolygon;
-	const basegfx::B2DPoint aB2DPoint( pPoint->x, pPoint->y );
-	rPolygon.append( aB2DPoint );
-	return noErr;
-}
-
-static OSStatus GgoCurveToProc( const Float32Point* pCP1, const Float32Point* pCP2,
-	const Float32Point* pPoint, void* pData )
-{
-	basegfx::B2DPolygon& rPolygon = static_cast<GgoData*>(pData)->maPolygon;
-	const sal_uInt32 nPointCount = rPolygon.count();
-	const basegfx::B2DPoint aB2DControlPoint1( pCP1->x, pCP1->y );
-	rPolygon.setNextControlPoint( nPointCount-1, aB2DControlPoint1 );
-	const basegfx::B2DPoint aB2DEndPoint( pPoint->x, pPoint->y );
-	rPolygon.append( aB2DEndPoint );
-	const basegfx::B2DPoint aB2DControlPoint2( pCP2->x, pCP2->y );
-	rPolygon.setPrevControlPoint( nPointCount, aB2DControlPoint2 );
-	return noErr;
-}
-
-static OSStatus GgoClosePathProc( void* pData )
-{
-	GgoData* pGgoData = static_cast<GgoData*>(pData);
-	basegfx::B2DPolygon& rPolygon = pGgoData->maPolygon;
-	if( rPolygon.count() > 0 )
-		pGgoData->mpPolyPoly->append( rPolygon );
-	rPolygon.clear();
-	return noErr;
-}
-
-static OSStatus GgoMoveToProc( const Float32Point* pPoint, void* pData )
-{
-	GgoClosePathProc( pData );
-	OSStatus eStatus = GgoLineToProc( pPoint, pData );
-	return eStatus;
-}
-
-bool AquaSalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId, basegfx::B2DPolyPolygon&
rPolyPoly )
-{
-	GgoData aGgoData;
-	aGgoData.mpPolyPoly = &rPolyPoly;
-	rPolyPoly.clear();
-
-	ATSUStyle rATSUStyle = maATSUStyle;	// TODO: handle glyph fallback when CWS pdffix02 is
integrated
-	OSStatus eGgoStatus = noErr;
-	OSStatus eStatus = ATSUGlyphGetCubicPaths( rATSUStyle, aGlyphId,
-		GgoMoveToProc, GgoLineToProc, GgoCurveToProc, GgoClosePathProc,
-		&aGgoData, &eGgoStatus );
-	if( (eStatus != noErr) ) // TODO: why is (eGgoStatus!=noErr) when curves are involved?
-		return false;
-
-	GgoClosePathProc( &aGgoData );
-	if( mfFontScale != 1.0 ) {
-		rPolyPoly.transform(basegfx::tools::createScaleB2DHomMatrix(+mfFontScale, +mfFontScale));
-	}
-	return true;
-}
-
-// -----------------------------------------------------------------------
-
 long AquaSalGraphics::GetGraphicsWidth() const
 {
     long w = 0;
@@ -1896,20 +1778,16 @@ long AquaSalGraphics::GetGraphicsWidth()
 
 bool AquaSalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
 {
-	ATSUStyle rATSUStyle = maATSUStyle;	// TODO: handle glyph fallback
-	ATSGlyphScreenMetrics aGlyphMetrics;
-	GlyphID nAtsGlyphId = aGlyphId;
-	OSStatus eStatus = ATSUGlyphGetScreenMetrics( rATSUStyle,
-		1, &nAtsGlyphId, 0, FALSE, !mbNonAntialiasedText, &aGlyphMetrics );
-	if( eStatus != noErr )
-		return false;
+	const bool bRC = mpMacTextStyle->GetGlyphBoundRect( aGlyphId, rRect );
+	return bRC;
+}
 
-	const long nMinX = (long)(+aGlyphMetrics.topLeft.x * mfFontScale - 0.5);
-	const long nMaxX = (long)(aGlyphMetrics.width * mfFontScale + 0.5) + nMinX;
-	const long nMinY = (long)(-aGlyphMetrics.topLeft.y * mfFontScale - 0.5);
-	const long nMaxY = (long)(aGlyphMetrics.height * mfFontScale + 0.5) + nMinY;
-	rRect = Rectangle( nMinX, nMinY, nMaxX, nMaxY );
-	return true;
+// -----------------------------------------------------------------------
+
+bool AquaSalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId, basegfx::B2DPolyPolygon&
rPolyPoly )
+{
+	const bool bRC = mpMacTextStyle->GetGlyphOutline( aGlyphId, rPolyPoly );
+	return bRC;
 }
 
 // -----------------------------------------------------------------------
@@ -1922,138 +1800,40 @@ void AquaSalGraphics::GetDevFontSubstLis
 // -----------------------------------------------------------------------
 
 void AquaSalGraphics::DrawServerFontLayout( const ServerFontLayout& )
-{
-}
+{}
 
 // -----------------------------------------------------------------------
 
 sal_uInt16 AquaSalGraphics::SetFont( ImplFontSelectData* pReqFont, int /*nFallbackLevel*/
)
 {
-    if( !pReqFont )
-    {
-    	ATSUClearStyle( maATSUStyle );
-		mpMacFontData = NULL;
-        return 0;
-    }
+	// release the text style
+	delete mpMacTextStyle;
+	mpMacTextStyle = NULL;
 
-    // store the requested device font entry
-    const ImplMacFontData* pMacFont = static_cast<const ImplMacFontData*>( pReqFont->mpFontData
);
-    mpMacFontData = pMacFont;
-
-    // convert pixel units (as seen by upper layers) to typographic point units
-    double fScaledAtsHeight = pReqFont->mfExactHeight;
-    // avoid Fixed16.16 overflows by limiting the ATS font size
-    static const float fMaxAtsHeight = 144.0;
-    if( fScaledAtsHeight <= fMaxAtsHeight )
-        mfFontScale = 1.0;
-    else
-    {
-        mfFontScale = fScaledAtsHeight / fMaxAtsHeight;
-        fScaledAtsHeight = fMaxAtsHeight;
-    }
-    Fixed fFixedSize = FloatToFixed( fScaledAtsHeight );
-    // enable bold-emulation if needed
-    Boolean bFakeBold = FALSE;
-    if( (pReqFont->GetWeight() >= WEIGHT_BOLD)
-    &&  (pMacFont->GetWeight() < WEIGHT_SEMIBOLD) )
-        bFakeBold = TRUE;
-    // enable italic-emulation if needed
-    Boolean bFakeItalic = FALSE;
-    if( ((pReqFont->GetSlant() == ITALIC_NORMAL) || (pReqFont->GetSlant() == ITALIC_OBLIQUE))
-    && !((pMacFont->GetSlant() == ITALIC_NORMAL) || (pMacFont->GetSlant() ==
ITALIC_OBLIQUE)) )
-        bFakeItalic = TRUE;
-
-    // enable/disable antialiased text
-    mbNonAntialiasedText = pReqFont->mbNonAntialiased;
-    UInt32 nStyleRenderingOptions = kATSStyleNoOptions;
-    if( pReqFont->mbNonAntialiased )
-        nStyleRenderingOptions |= kATSStyleNoAntiAliasing; 
-
-	// set horizontal/vertical mode
-	ATSUVerticalCharacterType aVerticalCharacterType = kATSUStronglyHorizontal;
-	if( pReqFont->mbVertical )
-		aVerticalCharacterType = kATSUStronglyVertical;
-
-	// prepare ATS-fontid as type matching to the kATSUFontTag request
-	ATSUFontID nFontID = static_cast<ATSUFontID>(pMacFont->GetFontId());
-
-    // update ATSU style attributes with requested font parameters
-	// TODO: no need to set styles which are already defaulted
-
-    const ATSUAttributeTag aTag[] =
-    {
-        kATSUFontTag,
-        kATSUSizeTag,
-        kATSUQDBoldfaceTag,
-        kATSUQDItalicTag,
-        kATSUStyleRenderingOptionsTag,
-		kATSUVerticalCharacterTag
-    };
-
-    const ByteCount aValueSize[] = 
-    {
-        sizeof(ATSUFontID),
-        sizeof(fFixedSize),
-        sizeof(bFakeBold), 
-        sizeof(bFakeItalic),
-        sizeof(nStyleRenderingOptions),
-        sizeof(aVerticalCharacterType)
-    };
- 
-    const ATSUAttributeValuePtr aValue[] = 
-    {
-        &nFontID,
-        &fFixedSize,
-        &bFakeBold, 
-        &bFakeItalic,
-        &nStyleRenderingOptions,
-        &aVerticalCharacterType
-    };
-
-	static const int nTagCount = sizeof(aTag) / sizeof(*aTag);
-    OSStatus eStatus = ATSUSetAttributes( maATSUStyle, nTagCount,
-                             aTag, aValueSize, aValue );
-    // reset ATSUstyle if there was an error
-    if( eStatus != noErr )
-    {
-        DBG_WARNING( "AquaSalGraphics::SetFont() : Could not set font attributes!\n");
-        ATSUClearStyle( maATSUStyle );
-        mpMacFontData = NULL;
-        return 0;
-    }
+	// handle NULL request meaning: release-font-resources request
+	if( !pReqFont )
+	{
+		mpMacFontData = NULL;
+		return 0;
+	}
 
-    // prepare font stretching
-    const ATSUAttributeTag aMatrixTag = kATSUFontMatrixTag;
-    if( (pReqFont->mnWidth == 0) || (pReqFont->mnWidth == pReqFont->mnHeight) )
-    {
-        mfFontStretch = 1.0;
-    	ATSUClearAttributes( maATSUStyle, 1, &aMatrixTag );
-    }
-    else
-    {
-        mfFontStretch = (float)pReqFont->mnWidth / pReqFont->mnHeight;
-        CGAffineTransform aMatrix = CGAffineTransformMakeScale( mfFontStretch, 1.0F );
-        const ATSUAttributeValuePtr aAttr = &aMatrix;
-        const ByteCount aMatrixBytes = sizeof(aMatrix);
-        eStatus = ATSUSetAttributes( maATSUStyle, 1, &aMatrixTag, &aMatrixBytes,
&aAttr );
-        DBG_ASSERT( (eStatus==noErr), "AquaSalGraphics::SetFont() : Could not set font matrix\n");
-    }
-
-    // prepare font rotation
-    mnATSUIRotation = FloatToFixed( pReqFont->mnOrientation / 10.0 );
-
-#if OSL_DEBUG_LEVEL > 3
-    fprintf( stderr, "SetFont to (\"%s\", \"%s\", fontid=%d) for (\"%s\" \"%s\" weight=%d,
slant=%d size=%dx%d orientation=%d)\n",
-             ::rtl::OUStringToOString( pMacFont->GetFamilyName(), RTL_TEXTENCODING_UTF8
).getStr(),
-             ::rtl::OUStringToOString( pMacFont->GetStyleName(), RTL_TEXTENCODING_UTF8
).getStr(),
-             (int)nFontID,
-             ::rtl::OUStringToOString( pReqFont->GetFamilyName(), RTL_TEXTENCODING_UTF8
).getStr(),
-             ::rtl::OUStringToOString( pReqFont->GetStyleName(), RTL_TEXTENCODING_UTF8
).getStr(),
-             pReqFont->GetWeight(),
-             pReqFont->GetSlant(),
-             pReqFont->mnHeight,
-             pReqFont->mnWidth,
-             pReqFont->mnOrientation);
+	// update the text style
+	mpMacFontData = static_cast<const ImplMacFontData*>( pReqFont->mpFontData );
+	mpMacTextStyle = mpMacFontData->CreateMacTextStyle( *pReqFont );
+	mpMacTextStyle->SetTextColor( maTextColor );
+
+#if (OSL_DEBUG_LEVEL > 3)
+	fprintf( stderr, "SetFont to (\"%s\", \"%s\", fontid=%d) for (\"%s\" \"%s\" weight=%d, slant=%d
size=%dx%d orientation=%d)\n",
+		::rtl::OUStringToOString( mpMacFontData->GetFamilyName(), RTL_TEXTENCODING_UTF8 ).getStr(),
+		::rtl::OUStringToOString( mpMacFontData->GetStyleName(), RTL_TEXTENCODING_UTF8 ).getStr(),
+		(int)pMacFont->GetFontId(),
+		::rtl::OUStringToOString( mpMacFontData->GetFamilyName(), RTL_TEXTENCODING_UTF8 ).getStr(),
+		::rtl::OUStringToOString( mpMacFontData->GetStyleName(), RTL_TEXTENCODING_UTF8 ).getStr(),
+		pReqFont->GetWeight(),
+		pReqFont->GetSlant(),
+		pReqFont->mnHeight,
+		pReqFont->mnWidth,
+		pReqFont->mnOrientation);
 #endif
 
     return 0;
@@ -2061,6 +1841,14 @@ sal_uInt16 AquaSalGraphics::SetFont( Imp
 
 // -----------------------------------------------------------------------
 
+SalLayout* AquaSalGraphics::GetTextLayout( ImplLayoutArgs& /*rArgs*/, int /*nFallbackLevel*/
)
+{
+	SalLayout* pSalLayout = mpMacTextStyle->GetTextLayout();
+	return pSalLayout;
+}
+
+// -----------------------------------------------------------------------
+
 const ImplFontCharMap* AquaSalGraphics::GetImplFontCharMap() const
 {
 	if( !mpMacFontData )
@@ -2073,17 +1861,17 @@ const ImplFontCharMap* AquaSalGraphics::
 
 // fake a SFNT font directory entry for a font table
 // see http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6.html#Directory
-static void FakeDirEntry( FourCharCode eFCC, ByteCount nOfs, ByteCount nLen,
+static void FakeDirEntry( const char aTag[5], ByteCount nOfs, ByteCount nLen,
 	const unsigned char* /*pData*/, unsigned char*& rpDest )
 {
 	// write entry tag
-	rpDest[ 0] = (char)(eFCC >> 24);
-	rpDest[ 1] = (char)(eFCC >> 16);
-	rpDest[ 2] = (char)(eFCC >>  8);
-	rpDest[ 3] = (char)(eFCC >>  0);
+	rpDest[ 0] = aTag[0];
+	rpDest[ 1] = aTag[1];
+	rpDest[ 2] = aTag[2];
+	rpDest[ 3] = aTag[3];
 	// TODO: get entry checksum and write it
-	// 		not too important since the subsetter doesn't care currently
-	// 		for( pData+nOfs ... pData+nOfs+nLen )
+	//       not too important since the subsetter doesn't care currently
+	//       for( pData+nOfs ... pData+nOfs+nLen )
 	// write entry offset
 	rpDest[ 8] = (char)(nOfs >> 24);
 	rpDest[ 9] = (char)(nOfs >> 16);
@@ -2098,88 +1886,82 @@ static void FakeDirEntry( FourCharCode e
 	rpDest += 16;
 }
 
+// fake a TTF or CFF font as directly accessing font file is not possible
+// when only the fontid is known. This approach also handles *.dfont fonts.
 static bool GetRawFontData( const ImplFontData* pFontData,
 	ByteVector& rBuffer, bool* pJustCFF )
 {
 	const ImplMacFontData* pMacFont = static_cast<const ImplMacFontData*>(pFontData);
-	const ATSUFontID nFontId = static_cast<ATSUFontID>(pMacFont->GetFontId());
-	ATSFontRef rFont = FMGetATSFontRefFromFont( nFontId );
 
-	ByteCount nCffLen = 0;
-	OSStatus eStatus = ATSFontGetTable( rFont, GetTag("CFF "), 0, 0, NULL, &nCffLen);
+	// short circuit for CFF-only fonts
+	const int nCffSize = pMacFont->GetFontTable( "CFF ", NULL);
 	if( pJustCFF != NULL )
 	{
-		*pJustCFF = (eStatus == noErr) && (nCffLen > 0);
-		if( *pJustCFF )
+		*pJustCFF = (nCffSize > 0);
+		if( *pJustCFF)
 		{
-			rBuffer.resize( nCffLen );
-			eStatus = ATSFontGetTable( rFont, GetTag("CFF "), 0, nCffLen, (void*)&rBuffer[0],
&nCffLen);
-			if( (eStatus != noErr) || (nCffLen <= 0) )
+			rBuffer.resize( nCffSize);
+			const int nCffRead = pMacFont->GetFontTable( "CFF ", &rBuffer[0]);
+			if( nCffRead != nCffSize)
 				return false;
 			return true;
 		}
 	}
 
 	// get font table availability and size in bytes
-	ByteCount nHeadLen	= 0;
-	eStatus = ATSFontGetTable( rFont, GetTag("head"), 0, 0, NULL, &nHeadLen);
-	if( (eStatus != noErr) || (nHeadLen <= 0) )
-		return false;
-	ByteCount nMaxpLen	= 0;
-    eStatus = ATSFontGetTable( rFont, GetTag("maxp"), 0, 0, NULL, &nMaxpLen);
-	if( (eStatus != noErr) || (nMaxpLen <= 0) )
-		return false;
-	ByteCount nCmapLen	= 0;
-    eStatus = ATSFontGetTable( rFont, GetTag("cmap"), 0, 0, NULL, &nCmapLen);
-	if( (eStatus != noErr) || (nCmapLen <= 0) )
-		return false;
-	ByteCount nNameLen	= 0;
-    eStatus = ATSFontGetTable( rFont, GetTag("name"), 0, 0, NULL, &nNameLen);
-	if( (eStatus != noErr) || (nNameLen <= 0) )
-		return false;
-	ByteCount nHheaLen	= 0;
-	eStatus = ATSFontGetTable( rFont, GetTag("hhea"), 0, 0, NULL, &nHheaLen);
-	if( (eStatus != noErr) || (nHheaLen <= 0) )
-		return false;
-	ByteCount nHmtxLen	= 0;
-	eStatus = ATSFontGetTable( rFont, GetTag("hmtx"), 0, 0, NULL, &nHmtxLen);
-	if( (eStatus != noErr) || (nHmtxLen <= 0) )
-		return false;
-
-	// get the glyph outline tables
-	ByteCount nLocaLen	= 0;
-	ByteCount nGlyfLen	= 0;
-	if( (eStatus != noErr) || (nCffLen <= 0) )
+	const int nHeadSize = pMacFont->GetFontTable( "head", NULL);
+	if( nHeadSize <= 0)
+		return false;
+	const int nMaxpSize = pMacFont->GetFontTable( "maxp", NULL);
+	if( nMaxpSize <= 0)
+		return false;
+	const int nCmapSize = pMacFont->GetFontTable( "cmap", NULL);
+	if( nCmapSize <= 0)
+		return false;
+	const int nNameSize = pMacFont->GetFontTable( "name", NULL);
+	if( nNameSize <= 0)
+		return false;
+	const int nHheaSize = pMacFont->GetFontTable( "hhea", NULL);
+	if( nHheaSize <= 0)
+		return false;
+	const int nHmtxSize = pMacFont->GetFontTable( "hmtx", NULL);
+	if( nHmtxSize <= 0)
+		return false;
+
+	// get the ttf-glyf outline tables
+	int nLocaSize = 0;
+	int nGlyfSize = 0;
+	if( nCffSize <= 0)
 	{
-		eStatus = ATSFontGetTable( rFont, GetTag("loca"), 0, 0, NULL, &nLocaLen);
-		if( (eStatus != noErr) || (nLocaLen <= 0) )
+		nLocaSize = pMacFont->GetFontTable( "loca", NULL);
+		if( nLocaSize <= 0)
 			return false;
-		eStatus = ATSFontGetTable( rFont, GetTag("glyf"), 0, 0, NULL, &nGlyfLen);
-		if( (eStatus != noErr) || (nGlyfLen <= 0) )
+		nGlyfSize = pMacFont->GetFontTable( "glyf", NULL);
+		if( nGlyfSize <= 0)
 			return false;
 	}
 
-	ByteCount nPrepLen=0, nCvtLen=0, nFpgmLen=0;
-	if( nGlyfLen )	// TODO: reduce PDF size by making hint subsetting optional
+	int nPrepSize = 0, nCvtSize = 0, nFpgmSize = 0;
+	if( nGlyfSize) // TODO: reduce PDF size by making hint subsetting optional
 	{
-		eStatus = ATSFontGetTable( rFont, GetTag("prep"), 0, 0, NULL, &nPrepLen);
-		eStatus = ATSFontGetTable( rFont, GetTag("cvt "), 0, 0, NULL, &nCvtLen);
-		eStatus = ATSFontGetTable( rFont, GetTag("fpgm"), 0, 0, NULL, &nFpgmLen);
+		nPrepSize = pMacFont->GetFontTable( "prep", NULL);
+		nCvtSize  = pMacFont->GetFontTable( "cvt ", NULL);
+		nFpgmSize = pMacFont->GetFontTable( "fpgm", NULL);
 	}
 	
 	// prepare a byte buffer for a fake font
 	int nTableCount = 7;
-	nTableCount += (nPrepLen>0) + (nCvtLen>0) + (nFpgmLen>0) + (nGlyfLen>0);
-	const ByteCount nFdirLen = 12 + 16*nTableCount;
-	ByteCount nTotalLen = nFdirLen;
-	nTotalLen += nHeadLen + nMaxpLen + nNameLen + nCmapLen;
-	if( nGlyfLen )
-		nTotalLen += nLocaLen + nGlyfLen;
+	nTableCount += (nPrepSize>0) + (nCvtSize>0) + (nFpgmSize>0) + (nGlyfSize>0);
+	const ByteCount nFdirSize = 12 + 16*nTableCount;
+	ByteCount nTotalSize = nFdirSize;
+	nTotalSize += nHeadSize + nMaxpSize + nNameSize + nCmapSize;
+	if( nGlyfSize )
+		nTotalSize += nLocaSize + nGlyfSize;
 	else
-		nTotalLen += nCffLen;
-	nTotalLen += nHheaLen + nHmtxLen;
-	nTotalLen += nPrepLen + nCvtLen + nFpgmLen;
-	rBuffer.resize( nTotalLen );
+		nTotalSize += nCffSize;
+	nTotalSize += nHheaSize + nHmtxSize;
+	nTotalSize += nPrepSize + nCvtSize + nFpgmSize;
+	rBuffer.resize( nTotalSize );
 
 	// fake a SFNT font directory header
 	if( nTableCount < 16 )
@@ -2194,57 +1976,69 @@ static bool GetRawFontData( const ImplFo
 	}
 
 	// get font table raw data and update the fake directory entries
-	ByteCount nOfs = nFdirLen;
+	ByteCount nOfs = nFdirSize;
 	unsigned char* pFakeEntry = &rBuffer[12];
-    eStatus = ATSFontGetTable( rFont, GetTag("cmap"), 0, nCmapLen, (void*)&rBuffer[nOfs],
&nCmapLen);
-	FakeDirEntry( GetTag("cmap"), nOfs, nCmapLen, &rBuffer[0], pFakeEntry );
-	nOfs += nCmapLen;
-	if( nCvtLen ) {
-		eStatus = ATSFontGetTable( rFont, GetTag("cvt "), 0, nCvtLen, (void*)&rBuffer[nOfs],
&nCvtLen);
-		FakeDirEntry( GetTag("cvt "), nOfs, nCvtLen, &rBuffer[0], pFakeEntry );
-		nOfs += nCvtLen;
-	}
-	if( nFpgmLen ) {
-		eStatus = ATSFontGetTable( rFont, GetTag("fpgm"), 0, nFpgmLen, (void*)&rBuffer[nOfs],
&nFpgmLen);
-		FakeDirEntry( GetTag("fpgm"), nOfs, nFpgmLen, &rBuffer[0], pFakeEntry );
-		nOfs += nFpgmLen;
-	}
-	if( nCffLen ) {
-	    eStatus = ATSFontGetTable( rFont, GetTag("CFF "), 0, nCffLen, (void*)&rBuffer[nOfs],
&nCffLen);
-		FakeDirEntry( GetTag("CFF "), nOfs, nCffLen, &rBuffer[0], pFakeEntry );
-		nOfs += nGlyfLen;
+	if( nCmapSize != pMacFont->GetFontTable( "cmap", &rBuffer[nOfs]))
+		return false;
+	FakeDirEntry( "cmap", nOfs, nCmapSize, &rBuffer[0], pFakeEntry );
+	nOfs += nCmapSize;
+	if( nCvtSize ) {
+		if( nCvtSize != pMacFont->GetFontTable( "cvt ", &rBuffer[nOfs]))
+			return false;
+		FakeDirEntry( "cvt ", nOfs, nCvtSize, &rBuffer[0], pFakeEntry );
+		nOfs += nCvtSize;
+	}
+	if( nFpgmSize ) {
+		if( nFpgmSize != pMacFont->GetFontTable( "fpgm", &rBuffer[nOfs]))
+			return false;
+		FakeDirEntry( "fpgm", nOfs, nFpgmSize, &rBuffer[0], pFakeEntry );
+		nOfs += nFpgmSize;
+	}
+	if( nCffSize ) {
+		if( nCffSize != pMacFont->GetFontTable( "CFF ", &rBuffer[nOfs]))
+			return false;
+		FakeDirEntry( "CFF ", nOfs, nCffSize, &rBuffer[0], pFakeEntry );
+		nOfs += nGlyfSize;
 	} else {
-	    eStatus = ATSFontGetTable( rFont, GetTag("glyf"), 0, nGlyfLen, (void*)&rBuffer[nOfs],
&nGlyfLen);
-		FakeDirEntry( GetTag("glyf"), nOfs, nGlyfLen, &rBuffer[0], pFakeEntry );
-		nOfs += nGlyfLen;
-		eStatus = ATSFontGetTable( rFont, GetTag("loca"), 0, nLocaLen, (void*)&rBuffer[nOfs],
&nLocaLen);
-		FakeDirEntry( GetTag("loca"), nOfs, nLocaLen, &rBuffer[0], pFakeEntry );
-		nOfs += nLocaLen;
-	}
-	eStatus = ATSFontGetTable( rFont, GetTag("head"), 0, nHeadLen, (void*)&rBuffer[nOfs],
&nHeadLen);
-	FakeDirEntry( GetTag("head"), nOfs, nHeadLen, &rBuffer[0], pFakeEntry );
-	nOfs += nHeadLen;
-	eStatus = ATSFontGetTable( rFont, GetTag("hhea"), 0, nHheaLen, (void*)&rBuffer[nOfs],
&nHheaLen);
-	FakeDirEntry( GetTag("hhea"), nOfs, nHheaLen, &rBuffer[0], pFakeEntry );
-	nOfs += nHheaLen;
-	eStatus = ATSFontGetTable( rFont, GetTag("hmtx"), 0, nHmtxLen, (void*)&rBuffer[nOfs],
&nHmtxLen);
-	FakeDirEntry( GetTag("hmtx"), nOfs, nHmtxLen, &rBuffer[0], pFakeEntry );
-	nOfs += nHmtxLen;
-    eStatus = ATSFontGetTable( rFont, GetTag("maxp"), 0, nMaxpLen, (void*)&rBuffer[nOfs],
&nMaxpLen);
-	FakeDirEntry( GetTag("maxp"), nOfs, nMaxpLen, &rBuffer[0], pFakeEntry );
-	nOfs += nMaxpLen;
-    eStatus = ATSFontGetTable( rFont, GetTag("name"), 0, nNameLen, (void*)&rBuffer[nOfs],
&nNameLen);
-	FakeDirEntry( GetTag("name"), nOfs, nNameLen, &rBuffer[0], pFakeEntry );
-	nOfs += nNameLen;
-	if( nPrepLen ) {
-		eStatus = ATSFontGetTable( rFont, GetTag("prep"), 0, nPrepLen, (void*)&rBuffer[nOfs],
&nPrepLen);
-		FakeDirEntry( GetTag("prep"), nOfs, nPrepLen, &rBuffer[0], pFakeEntry );
-		nOfs += nPrepLen;
+		if( nGlyfSize != pMacFont->GetFontTable( "glyf", &rBuffer[nOfs]))
+			return false;
+		FakeDirEntry( "glyf", nOfs, nGlyfSize, &rBuffer[0], pFakeEntry );
+		nOfs += nGlyfSize;
+		if( nLocaSize != pMacFont->GetFontTable( "loca", &rBuffer[nOfs]))
+			return false;
+		FakeDirEntry( "loca", nOfs, nLocaSize, &rBuffer[0], pFakeEntry );
+		nOfs += nLocaSize;
+	}
+	if( nHeadSize != pMacFont->GetFontTable( "head", &rBuffer[nOfs]))
+		return false;
+	FakeDirEntry( "head", nOfs, nHeadSize, &rBuffer[0], pFakeEntry );
+	nOfs += nHeadSize;
+	if( nHheaSize != pMacFont->GetFontTable( "hhea", &rBuffer[nOfs]))
+		return false;
+	FakeDirEntry( "hhea", nOfs, nHheaSize, &rBuffer[0], pFakeEntry );
+	nOfs += nHheaSize;
+	if( nHmtxSize != pMacFont->GetFontTable( "hmtx", &rBuffer[nOfs]))
+		return false;
+	FakeDirEntry( "hmtx", nOfs, nHmtxSize, &rBuffer[0], pFakeEntry );
+	nOfs += nHmtxSize;
+	if( nMaxpSize != pMacFont->GetFontTable( "maxp", &rBuffer[nOfs]))
+		return false;
+	FakeDirEntry( "maxp", nOfs, nMaxpSize, &rBuffer[0], pFakeEntry );
+	nOfs += nMaxpSize;
+	if( nNameSize != pMacFont->GetFontTable( "name", &rBuffer[nOfs]))
+		return false;
+	FakeDirEntry( "name", nOfs, nNameSize, &rBuffer[0], pFakeEntry );
+	nOfs += nNameSize;
+	if( nPrepSize ) {
+		if( nPrepSize != pMacFont->GetFontTable( "prep", &rBuffer[nOfs]))
+			return false;
+		FakeDirEntry( "prep", nOfs, nPrepSize, &rBuffer[0], pFakeEntry );
+		nOfs += nPrepSize;
 	}
 
-	DBG_ASSERT( (nOfs==nTotalLen), "AquaSalGraphics::CreateFontSubset (nOfs!=nTotalLen)");
+	DBG_ASSERT( (nOfs==nTotalSize), "AquaSalGraphics::CreateFontSubset (nOfs!=nTotalSize)");
 
-	return sal_True;
+	return true;
 }
 
 sal_Bool AquaSalGraphics::CreateFontSubset( const rtl::OUString& rToFile,
@@ -2270,7 +2064,7 @@ sal_Bool AquaSalGraphics::CreateFontSubs
 	if( bCffOnly )
 	{
 		// provide the raw-CFF data to the subsetter
-		ByteCount nCffLen = aBuffer.size();
+		const ByteCount nCffLen = aBuffer.size();
 		rInfo.LoadFont( FontSubsetInfo::CFF_FONT, &aBuffer[0], nCffLen );
 
 		// NOTE: assuming that all glyphids requested on Aqua are fully translated
@@ -2298,9 +2092,9 @@ sal_Bool AquaSalGraphics::CreateFontSubs
 	::GetTTGlobalFontInfo( pSftFont, &aTTInfo );
 	rInfo.m_nFontType   = FontSubsetInfo::SFNT_TTF;
 	rInfo.m_aPSName     = String( aTTInfo.psname, RTL_TEXTENCODING_UTF8 );
-	rInfo.m_aFontBBox	= Rectangle( Point( aTTInfo.xMin, aTTInfo.yMin ),
+	rInfo.m_aFontBBox   = Rectangle( Point( aTTInfo.xMin, aTTInfo.yMin ),
                                     Point( aTTInfo.xMax, aTTInfo.yMax ) );
-	rInfo.m_nCapHeight	= aTTInfo.yMax; // Well ...
+	rInfo.m_nCapHeight  = aTTInfo.yMax; // Well ...
 	rInfo.m_nAscent     = aTTInfo.winAscent;
 	rInfo.m_nDescent    = aTTInfo.winDescent;
 	// mac fonts usually do not have an OS2-table
@@ -2317,7 +2111,7 @@ sal_Bool AquaSalGraphics::CreateFontSubs
     // subset glyphs and get their properties
     // take care that subset fonts require the NotDef glyph in pos 0
     int nOrigCount = nGlyphCount;
-    sal_uInt16    aShortIDs[ 256 ];
+    sal_uInt16 aShortIDs[ 256 ];
     sal_uInt8 aTempEncs[ 256 ];
 
     int nNotDef = -1;
@@ -2389,7 +2183,7 @@ void AquaSalGraphics::GetGlyphWidths( co
     rUnicodeEnc.clear();
 
 	if( pFontData->IsSubsettable() )
-    {
+	{
 		ByteVector aBuffer;
 		if( !GetRawFontData( pFontData, aBuffer, NULL ) )
 			return;
@@ -2469,7 +2263,7 @@ void AquaSalGraphics::GetGlyphWidths( co
 const Ucs2SIntMap* AquaSalGraphics::GetFontEncodingVector(
 	const ImplFontData*, const Ucs2OStrMap** /*ppNonEncoded*/ )
 {
-    return NULL;
+	return NULL;
 }
 
 // -----------------------------------------------------------------------
@@ -2480,14 +2274,14 @@ const void*	AquaSalGraphics::GetEmbedFon
                               FontSubsetInfo&,
                               long* /*pDataLen*/ )
 {
-    return NULL;
+	return NULL;
 }
 
 // -----------------------------------------------------------------------
 
 void AquaSalGraphics::FreeEmbedFontData( const void* pData, long /*nDataLen*/ )
 {
-    // TODO: implementing this only makes sense when the implementation of
+	// TODO: implementing this only makes sense when the implementation of
 	//		AquaSalGraphics::GetEmbedFontData() returns non-NULL
 	(void)pData;
 	DBG_ASSERT( (pData!=NULL), "AquaSalGraphics::FreeEmbedFontData() is not implemented\n");
@@ -2498,11 +2292,12 @@ void AquaSalGraphics::FreeEmbedFontData(
 SystemFontData AquaSalGraphics::GetSysFontData( int /* nFallbacklevel */ ) const
 {
     SystemFontData aSysFontData;
-    OSStatus err;
     aSysFontData.nSize = sizeof( SystemFontData );
 
+#ifdef USE_ATSU
     // NOTE: Native ATSU font fallbacks are used, not the VCL fallbacks.
     ATSUFontID fontId; 	 
+    OSStatus err;
     err = ATSUGetAttribute( maATSUStyle, kATSUFontTag, sizeof(fontId), &fontId, 0 );
     if (err) fontId = 0;
     aSysFontData.aATSUFontID = (void *) fontId;
@@ -2524,6 +2319,7 @@ SystemFontData AquaSalGraphics::GetSysFo
     } else {
         aSysFontData.bVerticalCharacterType = false;
     }
+#endif // USE_ATSU
 
     aSysFontData.bAntialias = !mbNonAntialiasedText;
 
@@ -2753,4 +2549,3 @@ bool XorEmulation::UpdateTarget()
 }
 
 // =======================================================================
-

Modified: openoffice/trunk/main/vcl/source/gdi/outdev3.cxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/vcl/source/gdi/outdev3.cxx?rev=1560749&r1=1560748&r2=1560749&view=diff
==============================================================================
--- openoffice/trunk/main/vcl/source/gdi/outdev3.cxx (original)
+++ openoffice/trunk/main/vcl/source/gdi/outdev3.cxx Thu Jan 23 17:00:44 2014
@@ -6043,6 +6043,14 @@ SalLayout* OutputDevice::ImplLayout( con
 
     ImplLayoutArgs aLayoutArgs = ImplPrepareLayoutArgs( aStr, nMinIndex, nLen, nPixelWidth,
pDXArray );
 
+#ifdef MACOSX
+    // CoreText layouts are immutable and already contain the text color
+    // so we need to provide the color already for the layout request
+    // even if this layout will never be drawn
+    if( mbInitTextColor )
+        const_cast<OutputDevice&>(*this).ImplInitTextColor();
+#endif
+
     // get matching layout object for base font
     SalLayout* pSalLayout = NULL;
     if( mpPDFWriter )



Mime
View raw message