/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



#define INCL_GRE_STRINGS
#define INCL_GPI
#define INCL_DOS

#include <string.h>
//#include <stdlib.h>
//#include <math.h>
#include <svpm.h>

#include <vcl/sysdata.hxx>
#include "tools/svwin.h"

#include "os2/saldata.hxx"
#include "os2/salgdi.h"

#include "vcl/svapp.hxx"
#include "outfont.hxx"
#include "vcl/font.hxx"
#include "fontsubset.hxx"
#include "sallayout.hxx"

#include "rtl/logfile.hxx"
#include "rtl/tencinfo.h"
#include "rtl/textcvt.h"
#include "rtl/bootstrap.hxx"


#include "osl/module.h"
#include "osl/file.hxx"
#include "osl/thread.hxx"
#include "osl/process.h"

#include "tools/poly.hxx"
#include "tools/debug.hxx"
#include "tools/stream.hxx"

#include "basegfx/polygon/b2dpolygon.hxx"
#include "basegfx/polygon/b2dpolypolygon.hxx"
#include "basegfx/matrix/b2dhommatrix.hxx"

#ifndef __H_FT2LIB
#include <os2/wingdi.h>
#include <ft2lib.h>
#endif

#include "sft.hxx"

#ifdef GCP_KERN_HACK
#include <algorithm>
#endif

using namespace vcl;

// -----------
// - Inlines -
// -----------


inline W32FIXED FixedFromDouble( double d )
{
    const long l = (long) ( d * 65536. );
    return *(W32FIXED*) &l;
}

// -----------------------------------------------------------------------

inline int IntTimes256FromFixed(W32FIXED f)
{
    int nFixedTimes256 = (f.value << 8) + ((f.fract+0x80) >> 8);
    return nFixedTimes256;
}

// -----------
// - Defines -
// -----------

// this is a special codepage code, used to identify OS/2 symbol font.
#define SYMBOL_CHARSET					65400

// =======================================================================

UniString ImplSalGetUniString( const sal_Char* pStr, xub_StrLen nLen = STRING_LEN)
{
	return UniString( pStr, nLen, gsl_getSystemTextEncoding(),
					  RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |
					  RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
					  RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT );
}

// =======================================================================

static USHORT ImplSalToCharSet( CharSet eCharSet )
{
	// !!! Fuer DBCS-Systeme muss dieser Code auskommentiert werden und 0
	// !!! zurueckgegeben werden, solange die DBCS-Charsets nicht
	// !!! durchgereicht werden

	switch ( eCharSet )
	{
		case RTL_TEXTENCODING_IBM_437:
			return 437;

		case RTL_TEXTENCODING_IBM_850:
			return 850;

		case RTL_TEXTENCODING_IBM_860:
			return 860;

		case RTL_TEXTENCODING_IBM_861:
			return 861;

		case RTL_TEXTENCODING_IBM_863:
			return 863;

		case RTL_TEXTENCODING_IBM_865:
			return 865;
		case RTL_TEXTENCODING_MS_1252:
			return 1004;
		case RTL_TEXTENCODING_SYMBOL:
			return 65400;
	}

	return 0;
}

// -----------------------------------------------------------------------

static CharSet ImplCharSetToSal( USHORT usCodePage )
{
	switch ( usCodePage )
	{
		case 437:
			return RTL_TEXTENCODING_IBM_437;

		case 850:
			return RTL_TEXTENCODING_IBM_850;

		case 860:
			return RTL_TEXTENCODING_IBM_860;

		case 861:
			return RTL_TEXTENCODING_IBM_861;

		case 863:
			return RTL_TEXTENCODING_IBM_863;

		case 865:
			return RTL_TEXTENCODING_IBM_865;
		case 1004:
			return RTL_TEXTENCODING_MS_1252;
		case 65400:
			return RTL_TEXTENCODING_SYMBOL;
	}

	return RTL_TEXTENCODING_DONTKNOW;
}

// -----------------------------------------------------------------------

static FontFamily ImplFamilyToSal( PM_BYTE bFamilyType )
{
    switch ( bFamilyType )
    {
        case 4:
            return FAMILY_DECORATIVE;
        case 3:
            return FAMILY_SCRIPT;
    }

    return FAMILY_DONTKNOW;
}

// -----------------------------------------------------------------------

static FontWeight ImplWeightToSal( USHORT nWeight )
{
	// Falls sich jemand an die alte Doku gehalten hat
	if ( nWeight > 999 )
		nWeight /= 1000;

	switch ( nWeight )
	{
		case 1:
			return WEIGHT_THIN;

		case 2:
			return WEIGHT_ULTRALIGHT;

		case 3:
			return WEIGHT_LIGHT;

		case 4:
			return WEIGHT_SEMILIGHT;

		case 5:
			return WEIGHT_NORMAL;

		case 6:
			return WEIGHT_SEMIBOLD;

		case 7:
			return WEIGHT_BOLD;

		case 8:
			return WEIGHT_ULTRABOLD;

		case 9:
			return WEIGHT_BLACK;
	}

	return WEIGHT_DONTKNOW;
}

// -----------------------------------------------------------------------

static UniString ImpStyleNameToSal( const char* pFamilyName,
								   const char* pFaceName,
								   USHORT nLen )
{
	if ( !nLen )
		nLen = strlen(pFamilyName);

	// strip FamilyName from FaceName
	if ( strncmp( pFamilyName, pFaceName, nLen ) == 0 )
	{
		USHORT nFaceLen = (USHORT)strlen( pFaceName+nLen );
		// Ist Facename laenger, schneiden wir den FamilyName ab
		if ( nFaceLen > 1 )
			return UniString( pFaceName+(nLen+1), gsl_getSystemTextEncoding());
		else
			return UniString();
	}
	else
		return UniString( pFaceName, gsl_getSystemTextEncoding());
}

// -----------------------------------------------------------------------

inline FontPitch ImplLogPitchToSal( PM_BYTE fsType )
{
    if ( fsType & FM_TYPE_FIXED )
        return PITCH_FIXED;
    else
        return PITCH_VARIABLE;
}

// -----------------------------------------------------------------------

inline PM_BYTE ImplPitchToWin( FontPitch ePitch )
{
    if ( ePitch == PITCH_FIXED )
        return FM_TYPE_FIXED;
    //else if ( ePitch == PITCH_VARIABLE )

	return 0;
}

// -----------------------------------------------------------------------

static ImplDevFontAttributes Os2Font2DevFontAttributes( const PFONTMETRICS pFontMetric)
{
    ImplDevFontAttributes aDFA;

    // get font face attributes
    aDFA.meFamily       = ImplFamilyToSal( pFontMetric->panose.bFamilyType);
    aDFA.meWidthType    = WIDTH_DONTKNOW;
    aDFA.meWeight       = ImplWeightToSal( pFontMetric->usWeightClass);
    aDFA.meItalic       = (pFontMetric->fsSelection & FM_SEL_ITALIC) ? ITALIC_NORMAL : ITALIC_NONE;
    aDFA.mePitch        = ImplLogPitchToSal( pFontMetric->fsType );
    aDFA.mbSymbolFlag   = (pFontMetric->usCodePage == SYMBOL_CHARSET);

	// get the font face name
	// the maName field stores the font name without the style, so under OS/2
	// we must use the family name
	aDFA.maName = UniString( pFontMetric->szFamilyname, gsl_getSystemTextEncoding());

	aDFA.maStyleName = ImpStyleNameToSal( pFontMetric->szFamilyname,
 										  pFontMetric->szFacename,
 										  strlen( pFontMetric->szFamilyname) );

    // get device specific font attributes
    aDFA.mbOrientation  = (pFontMetric->fsDefn & FM_DEFN_OUTLINE) != 0;
    aDFA.mbDevice       = (pFontMetric->fsDefn & FM_DEFN_GENERIC) ? FALSE : TRUE;

    aDFA.mbEmbeddable   = false;
    aDFA.mbSubsettable  = false;
    DWORD fontType = Ft2QueryFontType( 0, pFontMetric->szFamilyname);
    if( fontType == FT2_FONTTYPE_TRUETYPE && !aDFA.mbDevice)
		aDFA.mbSubsettable = true;
    // for now we can only embed Type1 fonts
    if( fontType == FT2_FONTTYPE_TYPE1 )
        aDFA.mbEmbeddable = true;

    // heuristics for font quality
    // -   standard-type1 > opentypeTT > truetype > non-standard-type1 > raster
    // -   subsetting > embedding > none
    aDFA.mnQuality = 0;
    if( fontType == FT2_FONTTYPE_TRUETYPE )
        aDFA.mnQuality += 50;
    if( aDFA.mbSubsettable )
        aDFA.mnQuality += 200;
    else if( aDFA.mbEmbeddable )
        aDFA.mnQuality += 100;

    // #i38665# prefer Type1 versions of the standard postscript fonts
    if( aDFA.mbEmbeddable )
    {
        if( aDFA.maName.EqualsAscii( "AvantGarde" )
        ||  aDFA.maName.EqualsAscii( "Bookman" )
        ||  aDFA.maName.EqualsAscii( "Courier" )
        ||  aDFA.maName.EqualsAscii( "Helvetica" )
        ||  aDFA.maName.EqualsAscii( "NewCenturySchlbk" )
        ||  aDFA.maName.EqualsAscii( "Palatino" )
        ||  aDFA.maName.EqualsAscii( "Symbol" )
        ||  aDFA.maName.EqualsAscii( "Times" )
        ||  aDFA.maName.EqualsAscii( "ZapfChancery" )
        ||  aDFA.maName.EqualsAscii( "ZapfDingbats" ) )
            aDFA.mnQuality += 500;
    }    

    // TODO: add alias names

    return aDFA;
}

// =======================================================================

// raw font data with a scoped lifetime
class RawFontData
{
public:
    explicit	RawFontData( HDC, DWORD nTableTag=0 );
    			~RawFontData() { delete[] mpRawBytes; }
    const unsigned char*	get() const { return mpRawBytes; }
    const unsigned char*	steal() { unsigned char* p = mpRawBytes; mpRawBytes = NULL; return p; }
    const int				size() const { return mnByteCount; }

private:
    unsigned char*	mpRawBytes;
    int				mnByteCount;
};

RawFontData::RawFontData( HPS hPS, DWORD nTableTag )
:	mpRawBytes( NULL )
,	mnByteCount( 0 )
{
	// get required size in bytes
    mnByteCount = ::Ft2GetFontData( hPS, nTableTag, 0, NULL, 0 );
    if( mnByteCount == FT2_ERROR )
        return;
    else if( !mnByteCount )
        return;

	// allocate the array
    mpRawBytes = new unsigned char[ mnByteCount ];

	// get raw data in chunks small enough for GetFontData()
	int nRawDataOfs = 0;
	DWORD nMaxChunkSize = 0x100000;
	for(;;)
	{
		// calculate remaining raw data to get
		DWORD nFDGet = mnByteCount - nRawDataOfs;
		if( nFDGet <= 0 )
			break;
		// #i56745# limit GetFontData requests
		if( nFDGet > nMaxChunkSize )
			nFDGet = nMaxChunkSize;
		const DWORD nFDGot = ::Ft2GetFontData( hPS, nTableTag, nRawDataOfs,
			(void*)(mpRawBytes + nRawDataOfs), nFDGet );
		if( !nFDGot )
			break;
		else if( nFDGot != FT2_ERROR )
			nRawDataOfs += nFDGot;
		else
		{
			// was the chunk too big? reduce it
			nMaxChunkSize /= 2;
			if( nMaxChunkSize < 0x10000 )
				break;
		}
	}

	// cleanup if the raw data is incomplete
	if( nRawDataOfs != mnByteCount )
	{
		delete[] mpRawBytes;
		mpRawBytes = NULL;
	}
}

// -----------------------------------------------------------------------

// =======================================================================

ImplOs2FontData::ImplOs2FontData( PFONTMETRICS _pFontMetric,
    int nHeight, PM_BYTE nPitchAndFamily )
:	ImplFontData( Os2Font2DevFontAttributes(_pFontMetric), 0 ),
    pFontMetric( _pFontMetric ),
	meOs2CharSet( _pFontMetric->usCodePage),
    mnPitchAndFamily( nPitchAndFamily ),
    mpFontCharSets( NULL ),
    mpUnicodeMap( NULL ),
    mbDisableGlyphApi( false ),
    mbHasKoreanRange( false ),
    mbHasCJKSupport( false ),
    mbAliasSymbolsLow( false ),
    mbAliasSymbolsHigh( false ),
    mnId( 0 )
{
    SetBitmapSize( 0, nHeight );
}

// -----------------------------------------------------------------------

ImplOs2FontData::~ImplOs2FontData()
{
    delete[] mpFontCharSets;

    if( mpUnicodeMap )
        mpUnicodeMap->DeReference();
}

// -----------------------------------------------------------------------

sal_IntPtr ImplOs2FontData::GetFontId() const
{
    return mnId;
}

// -----------------------------------------------------------------------

void ImplOs2FontData::UpdateFromHPS( HPS hPS ) const
{
    // short circuit if already initialized
    if( mpUnicodeMap != NULL )
        return;

    ReadCmapTable( hPS );
    ReadOs2Table( hPS );

    // even if the font works some fonts have problems with the glyph API
    // => the heuristic below tries to figure out which fonts have the problem
	DWORD	fontType = Ft2QueryFontType( 0, pFontMetric->szFacename);
    if( fontType != FT2_FONTTYPE_TRUETYPE 
		&& (pFontMetric->fsDefn & FM_DEFN_GENERIC) == 0)
		mbDisableGlyphApi = true;
}

// -----------------------------------------------------------------------

bool ImplOs2FontData::HasGSUBstitutions( HPS hPS ) const
{
    if( !mbGsubRead )
        ReadGsubTable( hPS );
    return !maGsubTable.empty();
}

// -----------------------------------------------------------------------

bool ImplOs2FontData::IsGSUBstituted( sal_Ucs cChar ) const
{
    return( maGsubTable.find( cChar ) != maGsubTable.end() );
}

// -----------------------------------------------------------------------

const ImplFontCharMap* ImplOs2FontData::GetImplFontCharMap() const
{
    mpUnicodeMap->AddReference();
    return mpUnicodeMap;
}

// -----------------------------------------------------------------------

static unsigned GetUInt( const unsigned char* p ) { return((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3]);}
static unsigned GetUShort( const unsigned char* p ){ return((p[0]<<8)+p[1]);}
static signed GetSShort( const unsigned char* p ){ return((short)((p[0]<<8)+p[1]));}
static inline DWORD CalcTag( const char p[4]) { return (p[0]+(p[1]<<8)+(p[2]<<16)+(p[3]<<24)); }

void ImplOs2FontData::ReadOs2Table( HPS hPS ) const
{
    const DWORD Os2Tag = CalcTag( "OS/2" );
    DWORD nLength = Ft2GetFontData( hPS, Os2Tag, 0, NULL, 0 );
    if( (nLength == FT2_ERROR) || !nLength )
        return;
    std::vector<unsigned char> aOS2map( nLength );
    unsigned char* pOS2map = &aOS2map[0];
    DWORD nRC = Ft2GetFontData( hPS, Os2Tag, 0, pOS2map, nLength );
    sal_uInt32 nVersion = GetUShort( pOS2map );
    if ( nVersion >= 0x0001 && nLength >= 58 )
    {
        // We need at least version 0x0001 (TrueType rev 1.66)
        // to have access to the needed struct members.
        sal_uInt32 ulUnicodeRange1 = GetUInt( pOS2map + 42 );
        sal_uInt32 ulUnicodeRange2 = GetUInt( pOS2map + 46 );
#if 0
        sal_uInt32 ulUnicodeRange3 = GetUInt( pOS2map + 50 );
        sal_uInt32 ulUnicodeRange4 = GetUInt( pOS2map + 54 );
#endif

        // Check for CJK capabilities of the current font
        mbHasCJKSupport = (ulUnicodeRange2 & 0x2DF00000);
        mbHasKoreanRange= (ulUnicodeRange1 & 0x10000000)
                        | (ulUnicodeRange2 & 0x01100000);
        mbHasArabicSupport = (ulUnicodeRange1 & 0x00002000);
    }
}


// -----------------------------------------------------------------------

void ImplOs2FontData::ReadGsubTable( HPS hPS ) const
{
    mbGsubRead = true;

    // check the existence of a GSUB table
    const DWORD GsubTag = CalcTag( "GSUB" );
    DWORD nRC = Ft2GetFontData( hPS, GsubTag, 0, NULL, 0 );
    if( (nRC == FT2_ERROR) || !nRC )
        return;

    // parse the GSUB table through sft
    // TODO: parse it directly

    // sft needs the full font file data => get it
    const RawFontData aRawFontData( hPS );
    if( !aRawFontData.get() )
    	return;

    // open font file
    sal_uInt32 nFaceNum = 0;
    if( !*aRawFontData.get() )  // TTC candidate
        nFaceNum = ~0U;  // indicate "TTC font extracts only"

    TrueTypeFont* pTTFont = NULL;
    ::OpenTTFontBuffer( (void*)aRawFontData.get(), aRawFontData.size(), nFaceNum, &pTTFont );
    if( !pTTFont )
        return;

    // add vertically substituted characters to list
    static const sal_Unicode aGSUBCandidates[] = {
        0x0020, 0x0080, // ASCII
        0x2000, 0x2600, // misc
        0x3000, 0x3100, // CJK punctutation
        0x3300, 0x3400, // squared words
        0xFF00, 0xFFF0, // halfwidth|fullwidth forms
    0 };

    for( const sal_Unicode* pPair = aGSUBCandidates; *pPair; pPair += 2 )
        for( sal_Unicode cChar = pPair[0]; cChar < pPair[1]; ++cChar )
            if( ::MapChar( pTTFont, cChar, 0 ) != ::MapChar( pTTFont, cChar, 1 ) )
                maGsubTable.insert( cChar ); // insert GSUBbed unicodes

    CloseTTFont( pTTFont );
}

// -----------------------------------------------------------------------

void ImplOs2FontData::ReadCmapTable( HPS hPS ) const
{
    if( mpUnicodeMap != NULL )
        return;

    bool bIsSymbolFont = (meOs2CharSet == SYMBOL_CHARSET);
    // get the CMAP table from the font which is selected into the DC
    const DWORD nCmapTag = CalcTag( "cmap" );
    const RawFontData aRawFontData( hPS, nCmapTag );
    // parse the CMAP table if available
    if( aRawFontData.get() ) {
        CmapResult aResult;
        ParseCMAP( aRawFontData.get(), aRawFontData.size(), aResult );
        mbDisableGlyphApi |= aResult.mbRecoded;
        aResult.mbSymbolic = bIsSymbolFont;
        if( aResult.mnRangeCount > 0 )
            mpUnicodeMap = new ImplFontCharMap( aResult );
    }

    if( !mpUnicodeMap )
        mpUnicodeMap = ImplFontCharMap::GetDefaultMap( bIsSymbolFont );
    mpUnicodeMap->AddReference();
}

// =======================================================================

void Os2SalGraphics::SetTextColor( SalColor nSalColor )
{
	CHARBUNDLE cb;

	cb.lColor = MAKE_SALCOLOR( SALCOLOR_RED( nSalColor ),
						  SALCOLOR_GREEN( nSalColor ),
						  SALCOLOR_BLUE( nSalColor ) );

	// set default color attributes
	Ft2SetAttrs( mhPS,
				 PRIM_CHAR,
				 CBB_COLOR,
				 0,
				 &cb );
}

// -----------------------------------------------------------------------

USHORT Os2SalGraphics::ImplDoSetFont( ImplFontSelectData* i_pFont, float& o_rFontScale, int nFallbackLevel)
{

#if OSL_DEBUG_LEVEL>10
    debug_printf( "Os2SalGraphics::ImplDoSetFont mbPrinter=%d\n", mbPrinter);
#endif

	ImplOs2FontData* pFontData = (ImplOs2FontData*)i_pFont->mpFontData;
	PFONTMETRICS 	pFontMetric = NULL;
	FATTRS		  	aFAttrs;
	PM_BOOL		  	bOutline = FALSE;
	APIRET			rc;			

	memset( &aFAttrs, 0, sizeof( FATTRS ) );
	aFAttrs.usRecordLength = sizeof( FATTRS );

	aFAttrs.lMaxBaselineExt = i_pFont->mnHeight;
	aFAttrs.lAveCharWidth	= i_pFont->mnWidth;

	// do we have a pointer to the FONTMETRICS of the selected font? -> use it!
	if ( pFontData )
	{
		pFontMetric = pFontData->GetFontMetrics();

		bOutline = (pFontMetric->fsDefn & FM_DEFN_OUTLINE) != 0;

		// use match&registry fields to get correct match
		aFAttrs.lMatch	     	= pFontMetric->lMatch;
		aFAttrs.idRegistry 		= pFontMetric->idRegistry;			
		aFAttrs.usCodePage 		= pFontMetric->usCodePage;

		if ( bOutline )
		{
			aFAttrs.fsFontUse |= FATTR_FONTUSE_OUTLINE;
			if ( i_pFont->mnOrientation )
				aFAttrs.fsFontUse |= FATTR_FONTUSE_TRANSFORMABLE;
		}
		else
		{
			aFAttrs.lMaxBaselineExt = pFontMetric->lMaxBaselineExt;
			aFAttrs.lAveCharWidth	= pFontMetric->lAveCharWidth;
		}

	}
#if OSL_DEBUG_LEVEL>1
	if (pFontMetric->szFacename[0] == 'D') {
		rc = 0; // debugger breakpoint
	}
#endif

	// use family name for outline fonts
    if ( mbPrinter ) {
		// use font face name for printers because otherwise ft2lib will fail 
		// to select the correct font for GPI (ticket#117)
		strncpy( (char*)(aFAttrs.szFacename), pFontMetric->szFacename, sizeof( aFAttrs.szFacename ) );
	} else if ( !pFontMetric) {
		// use OOo name if fontmetrics not available!
		ByteString aName( i_pFont->maName.GetToken( 0 ), gsl_getSystemTextEncoding());
		strncpy( (char*)(aFAttrs.szFacename), aName.GetBuffer(), sizeof( aFAttrs.szFacename ) );
	} else if ( bOutline) {
		// use fontmetric family name for outline fonts
		strncpy( (char*)(aFAttrs.szFacename), pFontMetric->szFamilyname, sizeof( aFAttrs.szFacename ) );
	} else {
		// use real font face name for bitmaps (WarpSans only)
		strncpy( (char*)(aFAttrs.szFacename), pFontMetric->szFacename, sizeof( aFAttrs.szFacename ) );
	}

	if ( i_pFont->meItalic != ITALIC_NONE )
		aFAttrs.fsSelection |= FATTR_SEL_ITALIC;
	if ( i_pFont->meWeight > WEIGHT_MEDIUM )
		aFAttrs.fsSelection |= FATTR_SEL_BOLD;

#if OSL_DEBUG_LEVEL>1
	if (pFontMetric->szFacename[0] == 'A') {
		debug_printf( "Os2SalGraphics::SetFont hps %x lMatch '%d'\n", mhPS, pFontMetric->lMatch);
		debug_printf( "Os2SalGraphics::SetFont hps %x fontmetrics facename '%s'\n", mhPS, pFontMetric->szFacename);
		debug_printf( "Os2SalGraphics::SetFont hps %x fattrs facename '%s'\n", mhPS, aFAttrs.szFacename);
		debug_printf( "Os2SalGraphics::SetFont hps %x fattrs height '%d'\n", mhPS, aFAttrs.lMaxBaselineExt);
		debug_printf( "Os2SalGraphics::SetFont hps %x fattrs width '%d'\n", mhPS, aFAttrs.lAveCharWidth);
	}
#endif

	// set default font
	rc = Ft2SetCharSet( mhPS, LCID_DEFAULT);
	// delete selected font
	rc = Ft2DeleteSetId( mhPS, nFallbackLevel + LCID_BASE);

	// create new logical font
	if ( (rc=Ft2CreateLogFont( mhPS, NULL, nFallbackLevel + LCID_BASE, &aFAttrs)) == GPI_ERROR ) {
#if OSL_DEBUG_LEVEL>1
		ERRORID nLastError = WinGetLastError( GetSalData()->mhAB );
    	debug_printf( "Os2SalGraphics::SetFont hps %x Ft2CreateLogFont failed err %x\n", mhPS, nLastError );
#endif
		return SAL_SETFONT_REMOVEANDMATCHNEW;
	}

#if OSL_DEBUG_LEVEL>1
	// select new font
	rc = Ft2SetCharSet( mhPS, nFallbackLevel + LCID_BASE);

	// query fontmetric of new font
	FONTMETRICS aOS2Metric = {0};
	rc = Ft2QueryFontMetrics( mhPS, sizeof( aOS2Metric ), &aOS2Metric );

	if (pFontMetric->szFacename[0] == 'D') {
		debug_printf( "Os2SalGraphics::SetFont Ft2QueryFontMetrics fattrs facename '%s'\n", aOS2Metric.szFacename);
		debug_printf( "Os2SalGraphics::SetFont Ft2QueryFontMetrics fattrs height '%d'\n", aOS2Metric.lMaxBaselineExt);
		debug_printf( "Os2SalGraphics::SetFont Ft2QueryFontMetrics fattrs width '%d'\n", aOS2Metric.lAveCharWidth);
	}
#endif

	// apply font sizing, rotation
	CHARBUNDLE aBundle;

	ULONG nAttrsDefault = 0;
	ULONG nAttrs = CBB_SET;
	aBundle.usSet = nFallbackLevel + LCID_BASE;

	if ( bOutline )
	{
		nAttrs |= CBB_BOX;
		aBundle.sizfxCell.cy = MAKEFIXED( i_pFont->mnHeight, 0 );

		if ( !i_pFont->mnWidth )
		{
			LONG nXFontRes;
			LONG nYFontRes;
			LONG nHeight;

			// Auf die Aufloesung achten, damit das Ergebnis auch auf
			// Drucken mit 180*360 DPI stimmt. Ausserdem muss gerundet
			// werden, da auf meinem OS2 beispielsweise als
			// Bildschirmaufloesung 3618*3622 PixelPerMeter zurueck-
			// gegeben wird
			GetResolution( nXFontRes, nYFontRes );
			nHeight = i_pFont->mnHeight;
			nHeight *= nXFontRes;
			nHeight += nYFontRes/2;
			nHeight /= nYFontRes;
			aBundle.sizfxCell.cx = MAKEFIXED( nHeight, 0 );
		}
		else
			aBundle.sizfxCell.cx = MAKEFIXED( i_pFont->mnWidth, 0 );
	}

	// set orientation for outlinefonts
	if ( i_pFont->mnOrientation )
	{
		if ( bOutline )
		{
			nAttrs |= CBB_ANGLE;
			double alpha = (double)(i_pFont->mnOrientation);
			alpha *= 0.0017453292;	 // *PI / 1800
			mnOrientationY = (long) (1000.0 * sin( alpha ));
			mnOrientationX = (long) (1000.0 * cos( alpha ));
			aBundle.ptlAngle.x = mnOrientationX;
			aBundle.ptlAngle.y = mnOrientationY;
		}
		else
		{
			mnOrientationX = 1;
			mnOrientationY = 0;
			nAttrs |= CBB_ANGLE;
			aBundle.ptlAngle.x = 1;
			aBundle.ptlAngle.y = 0;
		}
	}
	else
	{
		mnOrientationX = 1;
		mnOrientationY = 0;
		nAttrs |= CBB_ANGLE;
		aBundle.ptlAngle.x = 1;
		aBundle.ptlAngle.y = 0;
	}

	rc = Ft2SetAttrs( mhPS, PRIM_CHAR, nAttrs, nAttrsDefault, &aBundle );

#if OSL_DEBUG_LEVEL>1
	rc = Ft2QueryFontMetrics( mhPS, sizeof( aOS2Metric ), &aOS2Metric );
	if (pFontMetric->szFacename[0] == 'D') {
		debug_printf( "Os2SalGraphics::SetFont Ft2QueryFontMetrics fattrs facename '%s'\n", aOS2Metric.szFacename);
		debug_printf( "Os2SalGraphics::SetFont Ft2QueryFontMetrics fattrs height '%d'\n", aOS2Metric.lMaxBaselineExt);
		debug_printf( "Os2SalGraphics::SetFont Ft2QueryFontMetrics fattrs width '%d'\n", aOS2Metric.lAveCharWidth);
	}
#endif

	return 0;
}


USHORT Os2SalGraphics::SetFont( ImplFontSelectData* pFont, int nFallbackLevel )
{

    // return early if there is no new font
    if( !pFont )
    {
#if 0
        // deselect still active font
        if( mhDefFont )
            Ft2SetCharSet( mhPS, mhDefFont );
        // release no longer referenced font handles
        for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
        {
            if( mhFonts[i] )
                Ft2DeleteSetId( mhPS, mhFonts[i] );
            mhFonts[ i ] = 0;
        }
#endif
        mhDefFont = 0;
        return 0;
    }

#if OSL_DEBUG_LEVEL>10
    debug_printf( "Os2SalGraphics::SetFont\n");
#endif

    DBG_ASSERT( pFont->mpFontData, "WinSalGraphics mpFontData==NULL");
    mpOs2FontEntry[ nFallbackLevel ] = reinterpret_cast<ImplOs2FontEntry*>( pFont->mpFontEntry );
    mpOs2FontData[ nFallbackLevel ] = static_cast<const ImplOs2FontData*>( pFont->mpFontData );

	ImplDoSetFont( pFont, mfFontScale, nFallbackLevel);

    if( !mhDefFont )
    {
        // keep default font
        mhDefFont = nFallbackLevel + LCID_BASE;
    }
    else
    {
        // release no longer referenced font handles
        for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
        {
            if( mhFonts[i] )
            {
#if 0
                Ft2DeleteSetId( mhPS, mhFonts[i] );
#endif
                mhFonts[i] = 0;
            }
        }
    }

    // store new font in correct layer
    mhFonts[ nFallbackLevel ] = nFallbackLevel + LCID_BASE;

    // now the font is live => update font face
    if( mpOs2FontData[ nFallbackLevel ] )
        mpOs2FontData[ nFallbackLevel ]->UpdateFromHPS( mhPS );

    if( !nFallbackLevel )
    {
        mbFontKernInit = TRUE;
        if ( mpFontKernPairs )
        {
            delete[] mpFontKernPairs;
            mpFontKernPairs = NULL;
        }
        mnFontKernPairCount = 0;
    }

    // some printers have higher internal resolution, so their
    // text output would be different from what we calculated
    // => suggest DrawTextArray to workaround this problem
    if ( mbPrinter )
        return SAL_SETFONT_USEDRAWTEXTARRAY;
    else
        return 0;
}

// -----------------------------------------------------------------------

void Os2SalGraphics::GetFontMetric( ImplFontMetricData* pMetric, int nFallbackLevel )
{
	FONTMETRICS aOS2Metric;
	Ft2QueryFontMetrics( mhPS, sizeof( aOS2Metric ), &aOS2Metric );

	// @TODO sync , int nFallbackLevel in 340

#if OSL_DEBUG_LEVEL>1
	debug_printf( "Os2SalGraphics::GetFontMetric hps %x\n", mhPS);
	if (aOS2Metric.szFacename[0] == 'A') {
		debug_printf( "Os2SalGraphics::GetFontMetric hps %x fontmetrics facename '%s'\n", mhPS, aOS2Metric.szFacename);
		debug_printf( "Os2SalGraphics::GetFontMetric hps %x fontmetrics lMatch '%d'\n", mhPS, aOS2Metric.lMatch);
	}
#endif

	pMetric->maName 			= UniString( aOS2Metric.szFamilyname, gsl_getSystemTextEncoding());
	pMetric->maStyleName		= ImpStyleNameToSal( aOS2Metric.szFamilyname,
													 aOS2Metric.szFacename,
													 strlen( aOS2Metric.szFamilyname ) );

    // device independent font attributes
    pMetric->meFamily       = ImplFamilyToSal( aOS2Metric.panose.bFamilyType);
    pMetric->mbSymbolFlag   = (aOS2Metric.usCodePage == SYMBOL_CHARSET);
    pMetric->meWeight       = ImplWeightToSal( aOS2Metric.usWeightClass );
    pMetric->mePitch        = ImplLogPitchToSal( aOS2Metric.fsType );
    pMetric->meItalic       = (aOS2Metric.fsSelection & FM_SEL_ITALIC) ? ITALIC_NORMAL : ITALIC_NONE;
    pMetric->mnSlant        = 0;

    // device dependend font attributes
    pMetric->mbDevice       = (aOS2Metric.fsDefn & FM_DEFN_GENERIC) ? FALSE : TRUE;
    pMetric->mbScalableFont = (aOS2Metric.fsDefn & FM_DEFN_OUTLINE) ? true : false;
    if( pMetric->mbScalableFont )
    {
        // check if there are kern pairs
        // TODO: does this work with GPOS kerning?
        pMetric->mbKernableFont = (aOS2Metric.sKerningPairs > 0);
    }
    else
    {
        // bitmap fonts cannot be rotated directly
        pMetric->mnOrientation  = 0;
        // bitmap fonts have no kerning
        pMetric->mbKernableFont = false;
    }

    // transformation dependend font metrics
	if ( aOS2Metric.fsDefn & FM_DEFN_OUTLINE )
	{
		pMetric->mnWidth	   = aOS2Metric.lEmInc;
	}
	else
	{
		pMetric->mnWidth	   = aOS2Metric.lAveCharWidth;
		pMetric->mnOrientation = 0;
	}
	pMetric->mnIntLeading		= aOS2Metric.lInternalLeading;
	pMetric->mnExtLeading		= aOS2Metric.lExternalLeading;
	pMetric->mnAscent			= aOS2Metric.lMaxAscender;
	pMetric->mnDescent			= aOS2Metric.lMaxDescender;

    // #107888# improved metric compatibility for Asian fonts...
    // TODO: assess workaround below for CWS >= extleading
    // TODO: evaluate use of aWinMetric.sTypo* members for CJK
    if( mpOs2FontData[0] && mpOs2FontData[0]->SupportsCJK() )
    {
        pMetric->mnIntLeading += pMetric->mnExtLeading;

        // #109280# The line height for Asian fonts is too small.
        // Therefore we add half of the external leading to the
        // ascent, the other half is added to the descent.
        const long nHalfTmpExtLeading = pMetric->mnExtLeading / 2;
        const long nOtherHalfTmpExtLeading = pMetric->mnExtLeading - nHalfTmpExtLeading;

        // #110641# external leading for Asian fonts.
        // The factor 0.3 has been confirmed with experiments.
        long nCJKExtLeading = static_cast<long>(0.30 * (pMetric->mnAscent + pMetric->mnDescent));
        nCJKExtLeading -= pMetric->mnExtLeading;
        pMetric->mnExtLeading = (nCJKExtLeading > 0) ? nCJKExtLeading : 0;

        pMetric->mnAscent   += nHalfTmpExtLeading;
        pMetric->mnDescent  += nOtherHalfTmpExtLeading;

        // #109280# HACK korean only: increase descent for wavelines and impr
		// YD win9x only
    }

}

// -----------------------------------------------------------------------

ULONG Os2SalGraphics::GetKernPairs( ULONG nPairs, ImplKernPairData* pKernPairs )
{
	DBG_ASSERT( sizeof( KERNINGPAIRS ) == sizeof( ImplKernPairData ),
				"Os2SalGraphics::GetKernPairs(): KERNINGPAIRS != ImplKernPairData" );

    if ( mbFontKernInit )
    {
        if( mpFontKernPairs )
        {
            delete[] mpFontKernPairs;
            mpFontKernPairs = NULL;
        }
        mnFontKernPairCount = 0;

        {
            KERNINGPAIRS* pPairs = NULL;
			FONTMETRICS aOS2Metric;
			Ft2QueryFontMetrics( mhPS, sizeof( aOS2Metric ), &aOS2Metric );
            int nCount = aOS2Metric.sKerningPairs;
            if( nCount )
            {
#ifdef GCP_KERN_HACK
                pPairs = new KERNINGPAIRS[ nCount+1 ];
                mpFontKernPairs = pPairs;
                mnFontKernPairCount = nCount;
				Ft2QueryKerningPairs( mhPS, nCount, (KERNINGPAIRS*)pPairs );
#else // GCP_KERN_HACK
				pPairs = (KERNINGPAIRS*)pKernPairs;
				nCount = (nCount < nPairs) ? nCount : nPairs;
				Ft2QueryKerningPairs( mhPS, nCount, (KERNINGPAIRS*)pPairs );
                return nCount;
#endif // GCP_KERN_HACK
            }
        }

        mbFontKernInit = FALSE;

        std::sort( mpFontKernPairs, mpFontKernPairs + mnFontKernPairCount, ImplCmpKernData );
    }

    if( !pKernPairs )
        return mnFontKernPairCount;
    else if( mpFontKernPairs )
    {
        if ( nPairs < mnFontKernPairCount )
            nPairs = mnFontKernPairCount;
        memcpy( pKernPairs, mpFontKernPairs,
                nPairs*sizeof( ImplKernPairData ) );
        return nPairs;
    }

    return 0;
}


// -----------------------------------------------------------------------

static const ImplFontCharMap* pOs2DefaultImplFontCharMap = NULL;
static const sal_uInt32 pOs2DefaultRangeCodes[] = {0x0020,0x00FF};

const ImplFontCharMap* Os2SalGraphics::GetImplFontCharMap() const
{
    if( !mpOs2FontData[0] )
        return ImplFontCharMap::GetDefaultMap();
    return mpOs2FontData[0]->GetImplFontCharMap();
}

// -----------------------------------------------------------------------

bool Os2SalGraphics::AddTempDevFont( ImplDevFontList* pFontList,
    const String& rFontFileURL, const String& rFontName )
{
#if OSL_DEBUG_LEVEL>0
    debug_printf("Os2SalGraphics::AddTempDevFont\n");
#endif
    return false;
}

// -----------------------------------------------------------------------

void Os2SalGraphics::GetDevFontList( ImplDevFontList* pList )
{
	PFONTMETRICS	pFontMetrics;
	ULONG			nFontMetricCount;
	SalData*		pSalData;

#if OSL_DEBUG_LEVEL>0
	debug_printf("Os2SalGraphics::GetDevFontList mbPrinter=%d\n", mbPrinter);
#endif

	// install OpenSymbol
	HMODULE hMod;
	ULONG	ObjNum, Offset, rc;
	CHAR	Buff[2*_MAX_PATH];
	char 	drive[_MAX_DRIVE], dir[_MAX_DIR];
	char 	fname[_MAX_FNAME], ext[_MAX_EXT];
	// get module handle (and name)
	rc = DosQueryModFromEIP( &hMod, &ObjNum, sizeof( Buff), Buff, 
							&Offset, (ULONG)ImplSalGetUniString);
	DosQueryModuleName(hMod, sizeof(Buff), Buff);
	// replace module path with font path
	char* slash = strrchr( Buff, '\\');
	*slash = '\0';
	slash = strrchr( Buff, '\\');
	*slash = '\0';
	strcat( Buff, "\\FONTS\\OPENS___.TTF");
	rc = GpiLoadPublicFonts( GetSalData()->mhAB, Buff);

	if ( !mbPrinter )
	{
		// Bei Bildschirm-Devices cachen wir die Liste global, da
		// dies im unabhaengigen Teil auch so gemacht wird und wir
		// ansonsten auf geloeschten Systemdaten arbeiten koennten
		pSalData = GetSalData();
		nFontMetricCount	= pSalData->mnFontMetricCount;
		pFontMetrics		= pSalData->mpFontMetrics;
		// Bei Bildschirm-Devices holen wir uns die Fontliste jedesmal neu
		if ( pFontMetrics )
		{
			delete pFontMetrics;
			pFontMetrics		= NULL;
			nFontMetricCount	= 0;
		}
	}
	else
	{
		nFontMetricCount	= mnFontMetricCount;
		pFontMetrics		= mpFontMetrics;
	}

	// do we have to create the cached font list first?
	if ( !pFontMetrics )
	{
		// query the number of fonts available
		LONG nTemp = 0;
		nFontMetricCount = Ft2QueryFonts( mhPS,
										  QF_PUBLIC | QF_PRIVATE | QF_NO_DEVICE,
										  NULL, &nTemp,
										  sizeof( FONTMETRICS ), NULL );

		// procede only if at least one is available!
		if ( nFontMetricCount )
		{
			// allocate memory for font list
			pFontMetrics = new FONTMETRICS[nFontMetricCount];

			// query font list
			Ft2QueryFonts( mhPS,
						   QF_PUBLIC | QF_PRIVATE | QF_NO_DEVICE,
						   NULL,
						   (PLONG)&nFontMetricCount,
						   (LONG) sizeof( FONTMETRICS ),
						   pFontMetrics );
		}

		if ( !mbPrinter )
		{
			pSalData->mnFontMetricCount 		= nFontMetricCount;
			pSalData->mpFontMetrics 			= pFontMetrics;
		}
		else
		{
			mnFontMetricCount	= nFontMetricCount;
			mpFontMetrics		= pFontMetrics;
		}
	}

	// copy data from the font list
	for( ULONG i = 0; i < nFontMetricCount; i++ )
	{
		PFONTMETRICS pFontMetric = &pFontMetrics[i];

#if OSL_DEBUG_LEVEL>2
		debug_printf("Os2SalGraphics::GetDevFontList #%d,'%s'\n", i, pFontMetric->szFacename);
#endif

		// skip font starting with '@', this is an alias internally
		// used by truetype engine.
		if (pFontMetric->szFacename[0] == '@')
			continue;

		// skip bitmap fonts (but keep WarpSans)
		if ( (pFontMetric->fsDefn & FM_DEFN_OUTLINE) == 0 
			&& strncmp( pFontMetric->szFacename, "WarpSans", 8) )
			// Font nicht aufnehmen
			continue;

		// replace '-' in facename with ' ' (for ft2lib)
		char* dash = pFontMetric->szFacename;
		while( (dash=strchr( dash, '-')))
			*dash++ = ' ';

		// create new font list element
		ImplOs2FontData* pData 		= new ImplOs2FontData( pFontMetric, 0, 0 );

		// ticket#80: font id field is used for pdf font cache code.
		pData->SetFontId( i);

		// add font list element to font list
		pList->Add( pData );

	}
}

// ----------------------------------------------------------------------------

void Os2SalGraphics::GetDevFontSubstList( OutputDevice* pOutDev )
{
}

// -----------------------------------------------------------------------

bool Os2SalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
{
    // use unity matrix
    MAT2 aMat;
    aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
    aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );

    UINT nGGOFlags = GGO_METRICS;
    if( !(aGlyphId & GF_ISCHAR) )
        nGGOFlags |= GGO_GLYPH_INDEX;
    aGlyphId &= GF_IDXMASK;

    GLYPHMETRICS aGM;
    DWORD nSize = FT2_ERROR;
    nSize = Ft2GetGlyphOutline( mhPS, aGlyphId, nGGOFlags, &aGM, 0, NULL, &aMat );
    if( nSize == FT2_ERROR )
        return false;

    rRect = Rectangle( Point( +aGM.gmptGlyphOrigin.x, -aGM.gmptGlyphOrigin.y ),
        Size( aGM.gmBlackBoxX, aGM.gmBlackBoxY ) );
    rRect.Left()    = static_cast<int>( mfFontScale * rRect.Left() );
    rRect.Right()   = static_cast<int>( mfFontScale * rRect.Right() );
    rRect.Top()     = static_cast<int>( mfFontScale * rRect.Top() );
    rRect.Bottom()  = static_cast<int>( mfFontScale * rRect.Bottom() );
    return true;
}

// -----------------------------------------------------------------------

bool Os2SalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId, ::basegfx::B2DPolyPolygon& rB2DPolyPoly )
{
#if OSL_DEBUG_LEVEL>0
	debug_printf("Os2SalGraphics::GetGlyphOutline\n");
#endif
    rB2DPolyPoly.clear();

    PM_BOOL bRet = FALSE;

    // use unity matrix
    MAT2 aMat;
    aMat.eM11 = aMat.eM22 = FixedFromDouble( 1.0 );
    aMat.eM12 = aMat.eM21 = FixedFromDouble( 0.0 );

    UINT nGGOFlags = GGO_NATIVE;
    if( !(aGlyphId & GF_ISCHAR) )
        nGGOFlags |= GGO_GLYPH_INDEX;
    aGlyphId &= GF_IDXMASK;

    GLYPHMETRICS aGlyphMetrics;
    DWORD nSize1 = FT2_ERROR;
    nSize1 = Ft2GetGlyphOutline( mhPS, aGlyphId, nGGOFlags, &aGlyphMetrics, 0, NULL, &aMat );

    if( !nSize1 )       // blank glyphs are ok
        bRet = TRUE;
    else if( nSize1 != FT2_ERROR )
    {
        PM_BYTE*   pData = new PM_BYTE[ nSize1 ];
        ULONG   nTotalCount = 0;
        DWORD   nSize2;
        nSize2 = Ft2GetGlyphOutline( mhPS, aGlyphId, nGGOFlags,
                &aGlyphMetrics, nSize1, pData, &aMat );

        if( nSize1 == nSize2 )
        {
            bRet = TRUE;

            int     nPtSize = 512;
            Point*  pPoints = new Point[ nPtSize ];
            sal_uInt8*   pFlags = new sal_uInt8[ nPtSize ];

            TTPOLYGONHEADER* pHeader = (TTPOLYGONHEADER*)pData;
            while( (PM_BYTE*)pHeader < pData+nSize2 )
            {
                // only outline data is interesting
                if( pHeader->dwType != TT_POLYGON_TYPE )
                    break;

                // get start point; next start points are end points
                // of previous segment
                int nPnt = 0;

                long nX = IntTimes256FromFixed( pHeader->pfxStart.x );
                long nY = IntTimes256FromFixed( pHeader->pfxStart.y );
                pPoints[ nPnt ] = Point( nX, nY );
                pFlags[ nPnt++ ] = POLY_NORMAL;

                bool bHasOfflinePoints = false;
                TTPOLYCURVE* pCurve = (TTPOLYCURVE*)( pHeader + 1 );
                pHeader = (TTPOLYGONHEADER*)( (PM_BYTE*)pHeader + pHeader->cb );
                while( (PM_BYTE*)pCurve < (PM_BYTE*)pHeader )
                {
                    int nNeededSize = nPnt + 16 + 3 * pCurve->cpfx;
                    if( nPtSize < nNeededSize )
                    {
                        Point* pOldPoints = pPoints;
                        sal_uInt8* pOldFlags = pFlags;
                        nPtSize = 2 * nNeededSize;
                        pPoints = new Point[ nPtSize ];
                        pFlags = new sal_uInt8[ nPtSize ];
                        for( int i = 0; i < nPnt; ++i )
                        {
                            pPoints[ i ] = pOldPoints[ i ];
                            pFlags[ i ] = pOldFlags[ i ];
                        }
                        delete[] pOldPoints;
                        delete[] pOldFlags;
                    }

                    int i = 0;
                    if( TT_PRIM_LINE == pCurve->wType )
                    {
                        while( i < pCurve->cpfx )
                        {
                            nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
                            nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
                            ++i;
                            pPoints[ nPnt ] = Point( nX, nY );
                            pFlags[ nPnt ] = POLY_NORMAL;
                            ++nPnt;
                        }
                    }
                    else if( TT_PRIM_QSPLINE == pCurve->wType )
                    {
                        bHasOfflinePoints = true;
                        while( i < pCurve->cpfx )
                        {
                            // get control point of quadratic bezier spline
                            nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
                            nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );
                            ++i;
                            Point aControlP( nX, nY );

                            // calculate first cubic control point
                            // P0 = 1/3 * (PBeg + 2 * PQControl)
                            nX = pPoints[ nPnt-1 ].X() + 2 * aControlP.X();
                            nY = pPoints[ nPnt-1 ].Y() + 2 * aControlP.Y();
                            pPoints[ nPnt+0 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
                            pFlags[ nPnt+0 ] = POLY_CONTROL;

                            // calculate endpoint of segment
                            nX = IntTimes256FromFixed( pCurve->apfx[ i ].x );
                            nY = IntTimes256FromFixed( pCurve->apfx[ i ].y );

                            if ( i+1 >= pCurve->cpfx )
                            {
                                // endpoint is either last point in segment => advance
                                ++i;
                            }
                            else
                            {
                                // or endpoint is the middle of two control points
                                nX += IntTimes256FromFixed( pCurve->apfx[ i-1 ].x );
                                nY += IntTimes256FromFixed( pCurve->apfx[ i-1 ].y );
                                nX = (nX + 1) / 2;
                                nY = (nY + 1) / 2;
                                // no need to advance, because the current point
                                // is the control point in next bezier spline
                            }

                            pPoints[ nPnt+2 ] = Point( nX, nY );
                            pFlags[ nPnt+2 ] = POLY_NORMAL;

                            // calculate second cubic control point
                            // P1 = 1/3 * (PEnd + 2 * PQControl)
                            nX = pPoints[ nPnt+2 ].X() + 2 * aControlP.X();
                            nY = pPoints[ nPnt+2 ].Y() + 2 * aControlP.Y();
                            pPoints[ nPnt+1 ] = Point( (2*nX+3)/6, (2*nY+3)/6 );
                            pFlags[ nPnt+1 ] = POLY_CONTROL;

                            nPnt += 3;
                        }
                    }

                    // next curve segment
                    pCurve = (TTPOLYCURVE*)&pCurve->apfx[ i ];
                }

                // end point is start point for closed contour
                // disabled, because Polygon class closes the contour itself
                // pPoints[nPnt++] = pPoints[0];
				// #i35928#
				// Added again, but add only when not yet closed
				if(pPoints[nPnt - 1] != pPoints[0])
				{
                    if( bHasOfflinePoints )
                        pFlags[nPnt] = pFlags[0];

					pPoints[nPnt++] = pPoints[0];
				}

                // convert y-coordinates W32 -> VCL
                for( int i = 0; i < nPnt; ++i )
                    pPoints[i].Y() = -pPoints[i].Y();

                // insert into polypolygon
                Polygon aPoly( nPnt, pPoints, (bHasOfflinePoints ? pFlags : NULL) );
                // convert to B2DPolyPolygon
                // TODO: get rid of the intermediate PolyPolygon
                rB2DPolyPoly.append( aPoly.getB2DPolygon() );
            }

            delete[] pPoints;
            delete[] pFlags;
        }

        delete[] pData;
    }

    // rescaling needed for the PolyPolygon conversion
    if( rB2DPolyPoly.count() )
    {
        ::basegfx::B2DHomMatrix aMatrix;
        aMatrix.scale( 1.0/256, 1.0/256 );
        aMatrix.scale( mfFontScale, mfFontScale );
        rB2DPolyPoly.transform( aMatrix );
    }
    
    return bRet;
}

// -----------------------------------------------------------------------

// TODO:  Replace this class with boost::scoped_array
class ScopedCharArray
{
public:
	inline explicit ScopedCharArray(char * pArray): m_pArray(pArray) {}

	inline ~ScopedCharArray() { delete[] m_pArray; }

	inline char * get() const { return m_pArray; }

private:
	char * m_pArray;
};

class ScopedFont
{
public:
	explicit ScopedFont(Os2SalGraphics & rData);

	~ScopedFont();

private:
	Os2SalGraphics & m_rData;
	ULONG m_hOrigFont;
};

ScopedFont::ScopedFont(Os2SalGraphics & rData): m_rData(rData)
{
#if 0
	m_hOrigFont = m_rData.mhFonts[0];
	m_rData.mhFonts[0] = 0; // avoid deletion of current font
#endif
}

ScopedFont::~ScopedFont()
{
#if 0
	if( m_hOrigFont )
	{
		// restore original font, destroy temporary font
		HFONT hTempFont = m_rData.mhFonts[0];
		m_rData.mhFonts[0] = m_hOrigFont;
		SelectObject( m_rData.mhDC, m_hOrigFont );
		DeleteObject( hTempFont );
	}
#endif
}

class ScopedTrueTypeFont
{
public:
	inline ScopedTrueTypeFont(): m_pFont(0) {}

	~ScopedTrueTypeFont();

	int open(void * pBuffer, sal_uInt32 nLen, sal_uInt32 nFaceNum);

	inline TrueTypeFont * get() const { return m_pFont; }

private:
	TrueTypeFont * m_pFont;
};

ScopedTrueTypeFont::~ScopedTrueTypeFont()
{
	if (m_pFont != 0)
		CloseTTFont(m_pFont);
}

int ScopedTrueTypeFont::open(void * pBuffer, sal_uInt32 nLen,
							 sal_uInt32 nFaceNum)
{
	OSL_ENSURE(m_pFont == 0, "already open");
    return OpenTTFontBuffer(pBuffer, nLen, nFaceNum, &m_pFont);
}

sal_Bool Os2SalGraphics::CreateFontSubset( const rtl::OUString& rToFile,
	const ImplFontData* pFont, sal_GlyphId* pGlyphIds, sal_uInt8* pEncoding,
	sal_Int32* pGlyphWidths, int nGlyphCount, FontSubsetInfo& rInfo )
{
	// TODO: use more of the central font-subsetting code, move stuff there if needed

	// create matching ImplFontSelectData
	// we need just enough to get to the font file data
	// use height=1000 for easier debugging (to match psprint's font units)
	ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );

	// TODO: much better solution: move SetFont and restoration of old font to caller
	ScopedFont aOldFont(*this);
	SetFont( &aIFSD, 0 );

    ImplOs2FontData* pWinFontData = (ImplOs2FontData*)aIFSD.mpFontData;
    pWinFontData->UpdateFromHPS( mhPS );
    const ImplFontCharMap* pImplFontCharMap = pWinFontData->GetImplFontCharMap();

#if OSL_DEBUG_LEVEL > 100
	// get font metrics
	TEXTMETRICA aWinMetric;
	if( !::GetTextMetricsA( mhDC, &aWinMetric ) )
		return FALSE;

	DBG_ASSERT( !(aWinMetric.tmPitchAndFamily & TMPF_DEVICE), "cannot subset device font" );
	DBG_ASSERT( aWinMetric.tmPitchAndFamily & TMPF_TRUETYPE, "can only subset TT font" );
#endif

    rtl::OUString aSysPath;
    if( osl_File_E_None != osl_getSystemPathFromFileURL( rToFile.pData, &aSysPath.pData ) )
        return FALSE;
    const rtl_TextEncoding aThreadEncoding = osl_getThreadTextEncoding();
    const ByteString aToFile( aSysPath.getStr(), (xub_StrLen)aSysPath.getLength(), aThreadEncoding );

	// check if the font has a CFF-table
	const DWORD nCffTag = CalcTag( "CFF " );
	const RawFontData aRawCffData( mhPS, nCffTag );
	if( aRawCffData.get() )
	{
		sal_GlyphId aRealGlyphIds[ 256 ];
		for( int i = 0; i < nGlyphCount; ++i )
		{
			// TODO: remap notdef glyph if needed
			// TODO: use GDI's GetGlyphIndices instead? Does it handle GSUB properly?
			sal_uInt32 aGlyphId = pGlyphIds[i] & GF_IDXMASK;
			if( pGlyphIds[i] & GF_ISCHAR ) // remaining pseudo-glyphs need to be translated
				aGlyphId = pImplFontCharMap->GetGlyphIndex( aGlyphId );
			if( (pGlyphIds[i] & (GF_ROTMASK|GF_GSUB)) != 0)	// TODO: vertical substitution
				{/*####*/}

			aRealGlyphIds[i] = aGlyphId;
		}

		// provide a font subset from the CFF-table
		FILE* pOutFile = fopen( aToFile.GetBuffer(), "wb" );
		rInfo.LoadFont( FontSubsetInfo::CFF_FONT, aRawCffData.get(), aRawCffData.size() );
		bool bRC = rInfo.CreateFontSubset( FontSubsetInfo::TYPE1_PFB, pOutFile, NULL,
				aRealGlyphIds, pEncoding, nGlyphCount, pGlyphWidths );
		fclose( pOutFile );
		return bRC;
	}

    // get raw font file data
    const RawFontData xRawFontData( mhPS, NULL );
    if( !xRawFontData.get() )
		return FALSE;

	// open font file
	sal_uInt32 nFaceNum = 0;
	if( !*xRawFontData.get() )	// TTC candidate
		nFaceNum = ~0U;	 // indicate "TTC font extracts only"

	ScopedTrueTypeFont aSftTTF;
	int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
	if( nRC != SF_OK )
		return FALSE;

	TTGlobalFontInfo aTTInfo;
	::GetTTGlobalFontInfo( aSftTTF.get(), &aTTInfo );
	rInfo.m_nFontType   = FontSubsetInfo::SFNT_TTF;
	rInfo.m_aPSName		= ImplSalGetUniString( aTTInfo.psname );
	rInfo.m_nAscent		= +aTTInfo.winAscent;
	rInfo.m_nDescent	= -aTTInfo.winDescent;
	rInfo.m_aFontBBox	= Rectangle( Point( aTTInfo.xMin, aTTInfo.yMin ),
									Point( aTTInfo.xMax, aTTInfo.yMax ) );
	rInfo.m_nCapHeight	= aTTInfo.yMax; // Well ...

	// subset TTF-glyphs and get their properties
	// take care that subset fonts require the NotDef glyph in pos 0
	int nOrigCount = nGlyphCount;
	USHORT	  aShortIDs[ 256 ];
	sal_uInt8 aTempEncs[ 256 ];

	int nNotDef=-1, i;
	for( i = 0; i < nGlyphCount; ++i )
	{
		aTempEncs[i] = pEncoding[i];
		sal_GlyphId aGlyphId = pGlyphIds[i] & GF_IDXMASK;
		if( pGlyphIds[i] & GF_ISCHAR )
		{
			sal_Unicode cChar = static_cast<sal_Unicode>(aGlyphId); // TODO: sal_UCS4
			const bool bVertical = ((pGlyphIds[i] & (GF_ROTMASK|GF_GSUB)) != 0);
			aGlyphId = ::MapChar( aSftTTF.get(), cChar, bVertical );
			if( (aGlyphId == 0) && pFont->IsSymbolFont() )
			{
				// #i12824# emulate symbol aliasing U+FXXX <-> U+0XXX
				cChar = (cChar & 0xF000) ? (cChar & 0x00FF) : (cChar | 0xF000);
				aGlyphId = ::MapChar( aSftTTF.get(), cChar, bVertical );
			}
		}
		aShortIDs[i] = static_cast<USHORT>( aGlyphId );
		if( !aGlyphId )
			if( nNotDef < 0 )
				nNotDef = i; // first NotDef glyph found
	}

	if( nNotDef != 0 )
	{
		// add fake NotDef glyph if needed
		if( nNotDef < 0 )
			nNotDef = nGlyphCount++;

		// NotDef glyph must be in pos 0 => swap glyphids
		aShortIDs[ nNotDef ] = aShortIDs[0];
		aTempEncs[ nNotDef ] = aTempEncs[0];
		aShortIDs[0] = 0;
		aTempEncs[0] = 0;
	}
	DBG_ASSERT( nGlyphCount < 257, "too many glyphs for subsetting" );

	// fill pWidth array
	TTSimpleGlyphMetrics* pMetrics =
		::GetTTSimpleGlyphMetrics( aSftTTF.get(), aShortIDs, nGlyphCount, aIFSD.mbVertical );
	if( !pMetrics )
		return FALSE;
	sal_uInt16 nNotDefAdv	= pMetrics[0].adv;
	pMetrics[0].adv			= pMetrics[nNotDef].adv;
	pMetrics[nNotDef].adv	= nNotDefAdv;
	for( i = 0; i < nOrigCount; ++i )
		pGlyphWidths[i] = pMetrics[i].adv;
	free( pMetrics );

	// write subset into destination file
	nRC = ::CreateTTFromTTGlyphs( aSftTTF.get(), aToFile.GetBuffer(), aShortIDs,
			aTempEncs, nGlyphCount, 0, NULL, 0 );
	return (nRC == SF_OK);
}

//--------------------------------------------------------------------------

const void* Os2SalGraphics::GetEmbedFontData( const ImplFontData* pFont,
	const sal_Ucs* pUnicodes, sal_Int32* pCharWidths,
	FontSubsetInfo& rInfo, long* pDataLen )
{
	// create matching ImplFontSelectData
	// we need just enough to get to the font file data
	ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );

	// TODO: much better solution: move SetFont and restoration of old font to caller
	ScopedFont aOldFont(*this);
	SetFont( &aIFSD, 0 );

	// get the raw font file data
	RawFontData aRawFontData( mhPS );
	*pDataLen = aRawFontData.size();
	if( !aRawFontData.get() )
		return NULL;

	// get important font properties
	FONTMETRICS aOS2Metric;
	if (Ft2QueryFontMetrics( mhPS, sizeof( aOS2Metric ), &aOS2Metric ) == GPI_ERROR)
			*pDataLen = 0;
	rInfo.m_nFontType	= FontSubsetInfo::ANY_TYPE1;
	rInfo.m_aPSName		= ImplSalGetUniString( aOS2Metric.szFacename );
	rInfo.m_nAscent		= +aOS2Metric.lMaxAscender;
	rInfo.m_nDescent	= -aOS2Metric.lMaxDescender;
	rInfo.m_aFontBBox	= Rectangle( Point( 0, -aOS2Metric.lMaxDescender ),
			  Point( aOS2Metric.lMaxCharInc, aOS2Metric.lMaxAscender+aOS2Metric.lExternalLeading ) );
	rInfo.m_nCapHeight	= aOS2Metric.lMaxAscender; // Well ...

	// get individual character widths
	for( int i = 0; i < 256; ++i )
	{
		LONG nCharWidth = 0;
		const sal_Ucs cChar = pUnicodes[i];
		if( !Ft2QueryStringWidthW( mhPS, (LPWSTR)&cChar, 1, &nCharWidth ) )
			*pDataLen = 0;
		pCharWidths[i] = nCharWidth;
	}

	if( !*pDataLen )
		return NULL;

	const unsigned char* pData = aRawFontData.steal();
	return (void*)pData;
}

//--------------------------------------------------------------------------

void Os2SalGraphics::FreeEmbedFontData( const void* pData, long /*nLen*/ )
{
	delete[] reinterpret_cast<char*>(const_cast<void*>(pData));
}

const Ucs2SIntMap* Os2SalGraphics::GetFontEncodingVector( const ImplFontData* pFont, const Ucs2OStrMap** pNonEncoded )
{
    // TODO: even for builtin fonts we get here... why?
    if( !pFont->IsEmbeddable() )
        return NULL;

    // fill the encoding vector
    // currently no nonencoded vector
    if( pNonEncoded )
        *pNonEncoded = NULL;

    const ImplOs2FontData* pWinFontData = static_cast<const ImplOs2FontData*>(pFont);
    const Ucs2SIntMap* pEncoding = pWinFontData->GetEncodingVector();
    if( pEncoding == NULL )
    {
        Ucs2SIntMap* pNewEncoding = new Ucs2SIntMap;
        #if 0
        // TODO: get correct encoding vector
        GLYPHSET aGlyphSet;
        aGlyphSet.cbThis = sizeof(aGlyphSet);
        DWORD aW = ::GetFontUnicodeRanges( mhPS, &aGlyphSet);
        #else
        for( sal_Unicode i = 32; i < 256; ++i )
            (*pNewEncoding)[i] = i;
        #endif
        pWinFontData->SetEncodingVector( pNewEncoding );
	pEncoding = pNewEncoding;
    }

    return pEncoding;
}

//--------------------------------------------------------------------------

void Os2SalGraphics::GetGlyphWidths( const ImplFontData* pFont,
                                     bool bVertical,
                                     Int32Vector& rWidths,
                                     Ucs2UIntMap& rUnicodeEnc )
{
    // create matching ImplFontSelectData
    // we need just enough to get to the font file data
    ImplFontSelectData aIFSD( *pFont, Size(0,1000), 1000.0, 0, false );

    // TODO: much better solution: move SetFont and restoration of old font to caller
    ScopedFont aOldFont(*this);
    
    float fScale = 0.0;
    ImplDoSetFont( &aIFSD, fScale, 0);
    
    if( pFont->IsSubsettable() )
    {
        // get raw font file data
	const RawFontData xRawFontData( mhPS );
	if( !xRawFontData.get() )
		return;

        // open font file
        sal_uInt32 nFaceNum = 0;
        if( !*xRawFontData.get() )  // TTC candidate
            nFaceNum = ~0U;  // indicate "TTC font extracts only"
    
        ScopedTrueTypeFont aSftTTF;
        int nRC = aSftTTF.open( (void*)xRawFontData.get(), xRawFontData.size(), nFaceNum );
        if( nRC != SF_OK )
            return;
    
        int nGlyphs = GetTTGlyphCount( aSftTTF.get() );
        if( nGlyphs > 0 )
        {
            rWidths.resize(nGlyphs);
            std::vector<sal_uInt16> aGlyphIds(nGlyphs);
            for( int i = 0; i < nGlyphs; i++ )
                aGlyphIds[i] = sal_uInt16(i);
            TTSimpleGlyphMetrics* pMetrics = ::GetTTSimpleGlyphMetrics( aSftTTF.get(),
                                                                        &aGlyphIds[0],
                                                                        nGlyphs,
                                                                        bVertical ? 1 : 0 );
            if( pMetrics )
            {
                for( int i = 0; i< nGlyphs; i++ )
                    rWidths[i] = pMetrics[i].adv;
                free( pMetrics );
                rUnicodeEnc.clear();
            }
            const ImplOs2FontData* pWinFont = static_cast<const ImplOs2FontData*>(pFont);
            const ImplFontCharMap* pMap = pWinFont->GetImplFontCharMap();
			DBG_ASSERT( pMap && pMap->GetCharCount(), "no map" );

			int nCharCount = pMap->GetCharCount();
            sal_uInt32 nChar = pMap->GetFirstChar();
			for( int i = 0; i < nCharCount; i++ )
            {
                if( nChar < 0x00010000 )
                {
                    sal_uInt16 nGlyph = ::MapChar( aSftTTF.get(),
                                                   static_cast<sal_uInt16>(nChar),
                                                   bVertical ? 1 : 0 );
                    if( nGlyph )
                        rUnicodeEnc[ static_cast<sal_Unicode>(nChar) ] = nGlyph;
                }
				nChar = pMap->GetNextChar( nChar );
            }
        }
    }
    else if( pFont->IsEmbeddable() )
    {
        // get individual character widths
        rWidths.clear();
        rUnicodeEnc.clear();
        rWidths.reserve( 224 );
        for( sal_Unicode i = 32; i < 256; ++i )
        {
            int nCharWidth = 0;
            if( Ft2QueryStringWidthW( mhPS, (LPWSTR)&i, 1, (LONG*)&nCharWidth ) )
            {
                rUnicodeEnc[ i ] = rWidths.size();
                rWidths.push_back( nCharWidth );
            }
        }
    }    
}

//--------------------------------------------------------------------------

void Os2SalGraphics::DrawServerFontLayout( const ServerFontLayout& )
{}

//--------------------------------------------------------------------------

SystemFontData Os2SalGraphics::GetSysFontData( int nFallbacklevel ) const
{
    SystemFontData aSysFontData;

    if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
    if (nFallbacklevel < 0 ) nFallbacklevel = 0;
    
    aSysFontData.nSize = sizeof( SystemFontData );
    aSysFontData.hFont = mhFonts[nFallbacklevel]; 
    aSysFontData.bFakeBold = false;
    aSysFontData.bFakeItalic = false;
    aSysFontData.bAntialias = true;
    aSysFontData.bVerticalCharacterType = false;
        
    return aSysFontData;
}

//--------------------------------------------------------------------------