path: root/vcl/source/glyphs/gcach_layout.cxx

/*************************************************************************
 *
 *  $RCSfile: gcach_layout.cxx,v $
 *
 *  $Revision: 1.16 $
 *  last change: $Author: hdu $ $Date: 2002-09-25 13:27:36 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (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.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 *
 *  Copyright: 2000 by Sun Microsystems, Inc.
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/

#define ENABLE_ICU_LAYOUT
#ifdef DEBUG
//#define VERBOSE_DEBUG
#endif

#if !defined(_SV_SALUNX_HXX) && !defined(WIN32)
#include <salunx.h>
#endif

#ifndef _SV_GCACHFTYP_HXX
#include <gcach_ftyp.hxx>
#endif

#ifndef _SV_SALLAYOUT_HXX
#include <sallayout.hxx>
#endif

#ifdef WIN32
#include <malloc.h>
#define alloca _alloca
#elif !defined(FREEBSD) && !defined(NETBSD)
#include <alloca.h>
#endif

#ifdef DEBUG
#include <cstdio>
#endif

static ServerFontLayoutEngine aSimpleLayoutEngine;

// =======================================================================
// layout implementation for ServerFont
// =======================================================================

ServerFontLayout::ServerFontLayout( const ImplLayoutArgs& rArgs, ServerFont& rFont )
:   GenericSalLayout( rArgs ),
    mrServerFont( rFont )
{
    ServerFontLayoutEngine* pLE = NULL;
    if( ~rArgs.mnFlags & (SAL_LAYOUT_COMPLEX_DISABLED|SAL_LAYOUT_BIDI_STRONG) )
        pLE = rFont.GetLayoutEngine();
    if( !pLE )
        pLE = &aSimpleLayoutEngine;

    (*pLE)( *this, rArgs );
}

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

bool ServerFontLayoutEngine::operator()( ServerFontLayout& rLayout,
    const ImplLayoutArgs& rArgs )
{
    FreetypeServerFont& rFont = reinterpret_cast<FreetypeServerFont&>(rLayout.GetServerFont());

    bool bRightToLeft = (SAL_LAYOUT_BIDI_RTL & rArgs.mnFlags) != 0;

    int nGlyphCount = rArgs.mnEndCharPos - rArgs.mnMinCharPos;
    GlyphItem* pGlyphItems = new GlyphItem[ nGlyphCount ];

    Point aNewPos( 0, 0 );
    bool bWantFallback = false;
    int nOldGlyphId = -1;
    int nGlyphWidth = 0;
    for( int i = 0; i < nGlyphCount; ++i )
    {
        int nLogicalIndex = bRightToLeft ? rArgs.mnEndCharPos-1-i : rArgs.mnMinCharPos+i;
        int nGlyphIndex = rFont.GetGlyphIndex( rArgs.mpStr[ nLogicalIndex ] );
        if( !nGlyphIndex )
            bWantFallback = true;

        // apply pair kerning if requested
        if( SAL_LAYOUT_KERNING_PAIRS & rArgs.mnFlags )
        {
            int nKern = rFont.GetGlyphKernValue( nOldGlyphId, nGlyphIndex );
            nGlyphWidth += nKern;
            nOldGlyphId = nGlyphIndex;
        }

        // update position of this glyph using all previous info
        aNewPos.X() += nGlyphWidth;

        const GlyphMetric& rGM = rFont.GetGlyphMetric( nGlyphIndex );
        nGlyphWidth = rGM.GetCharWidth();
        int nGlyphFlags = bRightToLeft ? GlyphItem::IS_RTL_GLYPH : 0;
        pGlyphItems[i] = GlyphItem( nLogicalIndex, nGlyphIndex, aNewPos,
            nGlyphFlags, nGlyphWidth );
    }

    // apply asian kerning if requested
    if( (rArgs.mnFlags & SAL_LAYOUT_KERNING_ASIAN)
    &&  !rArgs.mpDXArray && !rArgs.mnLayoutWidth && !bRightToLeft )
    {
        bool bVertical = false; // TODO

        const xub_Unicode* pStr = rArgs.mpStr + rArgs.mnMinCharPos;
        // #99658# also do asian kerning one beyond substring
        int nLen = nGlyphCount;
        if( rArgs.mnMinCharPos + nLen < rArgs.mnLength )
            ++nLen;
        long nOffset = 0;
        for( int i = 1; i < nLen; ++i )
        {
            if( (0x3000 == (0xFF00 & pStr[i-1]))
            &&  (0x3000 == (0xFF00 & pStr[i])) )
            {
                long nKernFirst = +SalLayout::CalcAsianKerning( pStr[i-1], true, bVertical );
                long nKernNext  = -SalLayout::CalcAsianKerning( pStr[i], false, bVertical );

                long nDelta = (nKernFirst < nKernNext) ? nKernFirst : nKernNext;
                if( nDelta<0 && nKernFirst!=0 && nKernNext!=0 )
                {
                    nGlyphWidth = pGlyphItems[i-1].mnOrigWidth;
                    nDelta = (nDelta * nGlyphWidth + 2) / 4;
                    if( i == nGlyphCount )
                        pGlyphItems[i-1].mnNewWidth += nDelta;
                    nOffset += nDelta;
                }
            }

            if( i < nGlyphCount )
                pGlyphItems[i].maLinearPos.X() += nOffset;
        }
    }

    // create layout object
    rLayout.SetGlyphItems( pGlyphItems, nGlyphCount );
    rLayout.SetWantFallback( bWantFallback );

    if( rArgs.mpDXArray )
        rLayout.ApplyDXArray( rArgs.mpDXArray );
    else if( rArgs.mnLayoutWidth )
        rLayout.Justify( rArgs.mnLayoutWidth );
    return true;
}

// =======================================================================
// bridge to ICU LayoutEngine
// =======================================================================

#ifdef ENABLE_ICU_LAYOUT

#define bool_t signed char
#include <layout/LayoutEngine.h>
#include <layout/LEFontInstance.h>
#include <layout/LEScripts.h>
#include <unicode/uscript.h>
#include <unicode/ubidi.h>

using namespace U_ICU_NAMESPACE;

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

class IcuFontFromServerFont
: public LEFontInstance
{
private:
    FreetypeServerFont&     mrServerFont;

public:
                            IcuFontFromServerFont( FreetypeServerFont& rFont )
                            : mrServerFont( rFont )
                            {}

    virtual const void*     getFontTable(LETag tableTag) const;
    virtual le_bool         canDisplay(LEUnicode32 ch) const;
    virtual le_int32        getUnitsPerEM() const;

    virtual void            mapCharsToGlyphs( const LEUnicode chars[],
                                le_int32 offset, le_int32 count, le_bool reverse,
                                const LECharMapper* mapper, LEGlyphID glyphs[] ) const;
    virtual LEGlyphID       mapCharToGlyph( LEUnicode32 ch, const LECharMapper* mapper) const;

    virtual le_int32        getName( le_uint16 platformID, le_uint16 scriptID, le_uint16 languageID,
                                le_uint16 nameID, LEUnicode *name ) const;
    virtual void            getGlyphAdvance( LEGlyphID glyph, LEPoint &advance ) const;
    virtual le_bool         getGlyphPoint( LEGlyphID glyph, le_int32 pointNumber, LEPoint& point ) const;
    virtual float           getXPixelsPerEm() const;
    virtual float           getYPixelsPerEm() const;
    virtual float           xUnitsToPoints( float xUnits ) const;
    virtual float           yUnitsToPoints( float xUnits ) const;
    virtual void            unitsToPoints( LEPoint &units, LEPoint &points ) const;
    virtual float           xPixelsToUnits( float xPixels ) const;
    virtual float           yPixelsToUnits( float xPixels ) const;
    virtual void            pixelsToUnits( LEPoint &pixels, LEPoint &units ) const;
    virtual void            transformFunits( float xFunits, float yFunits, LEPoint &pixels ) const;
};


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

const void* IcuFontFromServerFont::getFontTable( LETag nICUTableTag ) const
{
    char pTagName[5];
    pTagName[0] = (char)(nICUTableTag >> 24);
    pTagName[1] = (char)(nICUTableTag >> 16);
    pTagName[2] = (char)(nICUTableTag >>  8);
    pTagName[3] = (char)(nICUTableTag);
    pTagName[4] = 0;

    ULONG nLength;
    const unsigned char* pBuffer = mrServerFont.GetTable( pTagName, &nLength );
#ifdef VERBOSE_DEBUG
    fprintf(stderr,"IcuGetTable(\"%s\") => %p\n", pTagName, pBuffer);
    int mnHeight = mrServerFont.GetFontSelData().mnHeight;
    const char* pName = mrServerFont.GetFontFileName()->getStr();
    fprintf(stderr,"font( h=%d, s=%\"%s\" )\n", mnHeight, pName );
#endif
    return (const void*)pBuffer;
}

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

le_bool IcuFontFromServerFont::canDisplay( LEUnicode32 ch ) const
{
    le_bool rc = (mrServerFont.GetRawGlyphIndex( ch ) != 0);
    return rc;
}

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

le_int32 IcuFontFromServerFont::getUnitsPerEM() const
{
    return mrServerFont.GetEmUnits();
}

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

void IcuFontFromServerFont::mapCharsToGlyphs( const LEUnicode pChars[],
    le_int32 nOffset, le_int32 nCount, le_bool bReverse,
    const LECharMapper* pMapper, LEGlyphID pGlyphs[] ) const
{
    if( !bReverse )
        pMapper = NULL;
    for( int i = 0; i < nCount; ++i )
        pGlyphs[i] = mapCharToGlyph( pChars[nOffset+i], pMapper );

    if( bReverse )
    {
        for( LEGlyphID *p1=pGlyphs, *p2=p1+nCount; p1 < --p2; ++p1 )
        {
            LEGlyphID t = *p1; *p1 = *p2; *p2 = t;
        }
    }
}

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

LEGlyphID IcuFontFromServerFont::mapCharToGlyph( LEUnicode32 c1,
    const LECharMapper* pMapper ) const
{
    LEUnicode32 c2 = c1;
    if( pMapper )
        c2 = pMapper->mapChar( c1 );
    LEGlyphID nGlyphIndex = mrServerFont.GetRawGlyphIndex( c2 );
    return nGlyphIndex;
}


// -----------------------------------------------------------------------
le_int32 IcuFontFromServerFont::getName(
    le_uint16 platformID, le_uint16 scriptID, le_uint16 languageID,
    le_uint16 nameID, LEUnicode *name ) const
{
    //TODO: replace dummy implementation
    if( name )
        name[0] = '#';
    return 1;
}

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

void IcuFontFromServerFont::getGlyphAdvance( LEGlyphID nGlyphIndex,
    LEPoint &advance ) const
{
    const GlyphMetric& rGM = mrServerFont.GetGlyphMetric( nGlyphIndex );
    advance.fX = rGM.GetCharWidth();
    advance.fY = 0;
}

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

le_bool IcuFontFromServerFont::getGlyphPoint( LEGlyphID glyph,
    le_int32 pointNumber, LEPoint& point ) const
{
    //TODO: replace dummy implementation
#ifdef DEBUG
    fprintf(stderr,"getGlyphPoint\n");
#endif
    return false;
}

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

float IcuFontFromServerFont::getXPixelsPerEm() const
{
    const ImplFontSelectData& r = mrServerFont.GetFontSelData();
    float fX = r.mnWidth ? r.mnWidth : r.mnHeight;
    return fX;
}

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

float IcuFontFromServerFont::getYPixelsPerEm() const
{
    float fY = mrServerFont.GetFontSelData().mnHeight;
    return fY;
}

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

float IcuFontFromServerFont::xUnitsToPoints( float xUnits ) const
{
    // TODO: avoid assumption: pixels==points
    float fPoints = xUnits;
    const ImplFontSelectData& r = mrServerFont.GetFontSelData();
    fPoints *= r.mnWidth ? r.mnWidth : r.mnHeight;
    fPoints /= mrServerFont.GetEmUnits();
    return fPoints;
}

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

float IcuFontFromServerFont::yUnitsToPoints( float yUnits ) const
{
    // TODO: avoid assumption pixels==points
    float fPoints = yUnits;
    fPoints *= mrServerFont.GetFontSelData().mnHeight;
    fPoints /= mrServerFont.GetEmUnits();
    return fPoints;
}

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

void IcuFontFromServerFont::unitsToPoints( LEPoint &units, LEPoint &points ) const
{
    points.fX = xUnitsToPoints( units.fX );
    points.fY = yUnitsToPoints( units.fY );
}

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

float IcuFontFromServerFont::xPixelsToUnits( float xPixels ) const
{
    float fPixels = xPixels;
    fPixels *= mrServerFont.GetEmUnits();
    const ImplFontSelectData& r = mrServerFont.GetFontSelData();
    fPixels /= r.mnWidth ? r.mnWidth : r.mnHeight;
    return fPixels;
}

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

float IcuFontFromServerFont::yPixelsToUnits( float yPixels ) const
{
    float fPixels = yPixels;
    fPixels *= mrServerFont.GetEmUnits();
    fPixels /= mrServerFont.GetFontSelData().mnHeight;
    return fPixels;
}

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

void IcuFontFromServerFont::pixelsToUnits( LEPoint &pixels, LEPoint &units ) const
{
    units.fX = xPixelsToUnits( pixels.fX );
    units.fY = yPixelsToUnits( pixels.fY );
}

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

void IcuFontFromServerFont::transformFunits( float xFunits, float yFunits, LEPoint &pixels ) const
{
    // TODO: avoid assumption pixels==points
    LEPoint units = { xFunits, yFunits };
    unitsToPoints( units, pixels );
}

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

class IcuLayoutEngine : public ServerFontLayoutEngine
{
private:
    IcuFontFromServerFont   maIcuFont;

    le_int32                meScriptCode;
    LayoutEngine*           mpIcuLE;

public:
                            IcuLayoutEngine( FreetypeServerFont& );
    virtual                 ~IcuLayoutEngine();

    virtual bool            operator()( ServerFontLayout&, const ImplLayoutArgs& );
};

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

IcuLayoutEngine::IcuLayoutEngine( FreetypeServerFont& rServerFont )
:   maIcuFont( rServerFont ),
    mpIcuLE( NULL ),
    meScriptCode( USCRIPT_INVALID_CODE )
{}

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

IcuLayoutEngine::~IcuLayoutEngine()
{
    if( mpIcuLE )
        delete mpIcuLE;
}

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

bool IcuLayoutEngine::operator()( ServerFontLayout& rLayout,
    const ImplLayoutArgs& rArgs )
{
    LEUnicode* pIcuChars;
    if( sizeof(LEUnicode) == sizeof(*rArgs.mpStr) )
        pIcuChars = (LEUnicode*)rArgs.mpStr;
    else
    {
        // this conversion will only be needed when either
        // ICU's or OOo's unicodes stop being unsigned shorts
        // TODO: watch out for surrogates!
        pIcuChars = (LEUnicode*)alloca( rArgs.mnLength * sizeof(LEUnicode) );
        for( xub_StrLen ic = 0; ic < rArgs.mnLength; ++ic )
            pIcuChars[ic] = static_cast<LEUnicode>( rArgs.mpStr[ic] );
    }

    UErrorCode rcI18n = U_ZERO_ERROR;
    LEErrorCode rcIcu = LE_NO_ERROR;

    // find matching script
    // TODO: consider script changes
    le_int32 eScriptCode = uscript_getScript( pIcuChars[rArgs.mnMinCharPos], &rcI18n );
    if( eScriptCode < 0 )   // TODO: handle errors better
        eScriptCode = latnScriptCode;

    // get layout engine matching to this script
    // no engine change necessary if script is latin
    if( (meScriptCode != eScriptCode)
    &&  (eScriptCode > USCRIPT_INHERITED) )
    {
        // TODO: cache multiple layout engines when multiple scripts are used
        delete mpIcuLE;
        meScriptCode = eScriptCode;
        le_int32 eLangCode = 0; // TODO: get better value
        mpIcuLE = LayoutEngine::layoutEngineFactory( &maIcuFont, eScriptCode, eLangCode, rcIcu );
        if( LE_FAILURE(rcIcu) )
        {
            delete mpIcuLE;
            mpIcuLE = NULL;
        }
    }

    // fall back to default layout if needed
    if( !mpIcuLE )
        return aSimpleLayoutEngine( rLayout, rArgs );

    // run Bidi algorithms if necessary
    bool bRightToLeft = (0 != (rArgs.mnFlags & SAL_LAYOUT_BIDI_RTL));
    UBiDi* pParaBidi;
    UBiDi* pLineBidi;
    UTextOffset nMinBidiPos;
    UTextOffset nEndBidiPos;
    int nRunCount = 1;

    if( (rArgs.mnFlags & SAL_LAYOUT_BIDI_STRONG)
    ||  (rArgs.mnEndCharPos - rArgs.mnMinCharPos <= 1) )
    {
        pParaBidi   = NULL;
        pLineBidi   = NULL;
        nMinBidiPos = rArgs.mnMinCharPos;
        nEndBidiPos = rArgs.mnEndCharPos;
    }
    else
    {
        pParaBidi = ubidi_openSized( rArgs.mnLength, 0, &rcI18n );
        ubidi_setPara( pParaBidi, rArgs.mpStr, rArgs.mnLength,
            (bRightToLeft ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR), NULL, &rcI18n );
        pLineBidi = pParaBidi;
        if( (0 < rArgs.mnMinCharPos) || (rArgs.mnEndCharPos < rArgs.mnLength) )
        {
            pLineBidi = ubidi_openSized( rArgs.mnEndCharPos - rArgs.mnMinCharPos, 0, &rcI18n );
            ubidi_setLine( pParaBidi, rArgs.mnMinCharPos, rArgs.mnEndCharPos, pLineBidi, &rcI18n );
        }
        nRunCount = ubidi_countRuns( pLineBidi, &rcI18n );
    }

    // layout bidi/script runs and export them to a ServerFontLayout
    Point aNewPos( 0, 0 );
    bool bWantFallback = false;
    int nGlyphCapacity = 3 * (rArgs.mnEndCharPos - rArgs.mnMinCharPos) + 16;
    int nSumGlyphCount = 0;

    // allocate temporary arrays
    GlyphItem* pGlyphItems = new GlyphItem[ nGlyphCapacity ];
    struct IcuPosition{ float fX, fY; };
    LEGlyphID* pIcuGlyphs = (LEGlyphID*)alloca( nGlyphCapacity * sizeof(LEGlyphID) );
    le_int32* pCharIndices = (le_int32*)alloca( nGlyphCapacity * sizeof(le_int32) );
    IcuPosition* pGlyphPositions = (IcuPosition*)alloca( (nGlyphCapacity+1) * sizeof(IcuPosition) );

    for( int i = 0; i < nRunCount; ++i )
    {
        if( pLineBidi )
        {
            // TODO: reorder chars, layout at once, reorder charpos
            nMinBidiPos = rArgs.mnMinCharPos;
            bRightToLeft = (UBIDI_RTL == ubidi_getVisualRun( pLineBidi, i, &nMinBidiPos, &nEndBidiPos ));
            nEndBidiPos += nMinBidiPos;
        }

        // run ICU layout engine
        int nRunGlyphCount = mpIcuLE->layoutChars( pIcuChars, nMinBidiPos,
            nEndBidiPos - nMinBidiPos, rArgs.mnLength, bRightToLeft,
            aNewPos.X(), aNewPos.Y(), rcIcu );
        if( LE_FAILURE(rcIcu) )
            break;

        // import layout info from icu
        // TODO: reallocate also temporary arrays if necessary
        if( nRunGlyphCount >= nGlyphCapacity )
            break;
        mpIcuLE->getGlyphs( pIcuGlyphs, rcIcu );
        mpIcuLE->getCharIndices( pCharIndices, rcIcu );
        mpIcuLE->getGlyphPositions( &pGlyphPositions->fX, rcIcu );
        mpIcuLE->reset();
        if( LE_FAILURE(rcIcu) )
            break;

        if( nGlyphCapacity < nSumGlyphCount + nRunGlyphCount )
        {
            nGlyphCapacity = 2 * (nSumGlyphCount + nRunGlyphCount) + 16;
            GlyphItem* pNewGI = new GlyphItem[ nGlyphCapacity ];
            for( int j = 0; j < nSumGlyphCount; ++j )
                pNewGI[j] = pGlyphItems[j];
            delete[] pGlyphItems;
            pGlyphItems = pNewGI;
        }

        // convert results to GlyphItems
        const IcuPosition* pPos = pGlyphPositions;
        FreetypeServerFont& rFont = reinterpret_cast<FreetypeServerFont&>(rLayout.GetServerFont());
        for( int i = 0; i < nRunGlyphCount; ++i, ++pPos )
        {
            //TODO: remove workaround below for ICU getting pCharIndex wrong
            int nCharPos = nMinBidiPos + pCharIndices[i];
            int nGlyphIndex = pIcuGlyphs[i];
            if( !nGlyphIndex )
                bWantFallback = true;

            // apply vertical flags, etc.
            sal_Unicode aChar = rArgs.mpStr[ pCharIndices[ i ] ];
            nGlyphIndex = rFont.FixupGlyphIndex( nGlyphIndex, aChar );

            aNewPos = Point( (int)(pPos->fX+0.5), (int)(pPos->fY+0.5) );
            const GlyphMetric& rGM = rFont.GetGlyphMetric( nGlyphIndex );
            int nGlyphWidth = rGM.GetCharWidth();
            long nGlyphFlags = (nGlyphWidth > 0) ? 0 : GlyphItem::IS_IN_CLUSTER;
            if( bRightToLeft )
                nGlyphFlags |= GlyphItem::IS_RTL_GLYPH;
            pGlyphItems[ nSumGlyphCount+i ]
                = GlyphItem( nCharPos, nGlyphIndex, aNewPos, nGlyphFlags, nGlyphWidth );
            //TODO: apply kerning if requested, set MOVED flag
        }
        aNewPos = Point( (int)(pPos->fX+0.5), (int)(pPos->fY+0.5) );
        nSumGlyphCount += nRunGlyphCount;
    }

    // cleanup Bidi engine
    if( pLineBidi != pParaBidi )
        ubidi_close( pLineBidi );
    if( pParaBidi != NULL )
        ubidi_close( pParaBidi );

    if( LE_FAILURE(rcIcu) )
    {
        delete[] pGlyphItems;
        return false;
    }

    // create ServerFontLayout using GlyphItems from above
    rLayout.SetGlyphItems( pGlyphItems, nSumGlyphCount );
    rLayout.SetWantFallback( bWantFallback );

    if( rArgs.mpDXArray )
        rLayout.ApplyDXArray( rArgs.mpDXArray );
    else if( rArgs.mnLayoutWidth )
        rLayout.Justify( rArgs.mnLayoutWidth );

    return true;
}

#endif // ENABLE_ICU_LAYOUT

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

ServerFontLayoutEngine* FreetypeServerFont::GetLayoutEngine()
{
    // find best layout engine for font, platform, script and language
#ifdef ENABLE_ICU_LAYOUT
    if( !mpLayoutEngine )
        mpLayoutEngine = new IcuLayoutEngine( *this );
#endif // ENABLE_ICU_LAYOUT

    return mpLayoutEngine;
}

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