xrenderstring.cpp

Go to the documentation of this file.

#include "SdlArs.h"

namespace Ars
{

XRenderedString::XRenderedString( CFontEngine* pFontEngine , EVAlign eVertAlign , EHAlign eHorzAlign )
: m_pFontEngine(pFontEngine), m_eVertAlign(eVertAlign), m_eHorzAlign(eHorzAlign)
, m_bCachedMetricsValid(false), m_MaskChar(' '), m_MaxFontHeight(-1)
{
}

void XRenderedString::_TextOut( SDL_Surface* pSurface , CRect &drawRect , CPoint &OriginPoint , const std::string &str , const CRGBColor &FontColor , CPainter::EPaintMode eMode ) 
{
        m_bCachedMetricsValid = false;
        CPoint OriginOffset , linebox;
        std::vector<CRect> CharacterRects;
        GetMetrics( str , &linebox , &OriginOffset , &CharacterRects );

        textSize.SetX( max( textSize.XPos() , linebox.XPos() ) );
        switch( m_eVertAlign  )
        {
                case VALIGN_TOP :       OriginPoint = CPoint( OriginPoint.XPos() , drawRect.Top() );    break;
                case VALIGN_BOTTOM :    OriginPoint = CPoint( OriginPoint.XPos() , drawRect.Bottom() ); break;
        }

        switch( m_eHorzAlign )
        {
                case HALIGN_LEFT : OriginPoint = CPoint( drawRect.Left() , OriginPoint.YPos() );        break;
                case HALIGN_CENTER : OriginPoint = CPoint( drawRect.Left() + drawRect.Width() / 2 , OriginPoint.YPos() );       break;
                case HALIGN_RIGHT : OriginPoint = CPoint( drawRect.Right() , OriginPoint.YPos() );      break;
        }

        for( unsigned int i = 0 ; i < str.size() ; ++i )
        {
                FT_BitmapGlyphRec *pGlyph;
                if( m_MaskChar == ' ' )
                        pGlyph = m_pFontEngine->RenderGlyph( str[i] );
                else
                        pGlyph = m_pFontEngine->RenderGlyph( m_MaskChar );

                CPainter Painter( pSurface , eMode );

                for (int y = 0; y < pGlyph->bitmap.rows; ++y )
                {
                        for (int x = 0; x < pGlyph->bitmap.width; ++x )
                        {
                                unsigned char *PixelOffset = pGlyph->bitmap.buffer + y * pGlyph->bitmap.width + x;
                                if( *PixelOffset != 0x00 )
                                {
                                        CRGBColor PixelColor(FontColor.red, FontColor.green, FontColor.blue, *PixelOffset);

                                        CPoint PixelPoint( CPoint( x + pGlyph->left, y ) + OriginPoint + OriginOffset + CharacterRects[i].TopLeft() );
                                        
                                        if( drawRect.HitTest( PixelPoint ) == RELPOS_INSIDE)
                                                Painter.DrawPoint(PixelPoint, PixelColor);
                                }
                        }
                }
        }
}

void XRenderedString::TextOut( SDL_Surface* pSurface, const CRect &BoundingRect, const std::string &str , const CRGBColor &FontColor , CPainter::EPaintMode eMode )
{
        m_bCachedMetricsValid = false;
        textSize = CPoint( 0 , 0 );

        CPoint  OriginPoint = BoundingRect.TopLeft();
        CRect   drawRect = BoundingRect;
        
        int     nrlines = 1;
        string  s = str;
        string::size_type       n0 = 0 , n1 = s.find( '\n' , n0 );
        while( n1 != string::npos )
        {
                n0 = n1 + 1;
                n1 = s.find( '\n' , n0 );
                nrlines += 1;
        }
        if( m_eVertAlign == VALIGN_CENTER )
                OriginPoint = CPoint( OriginPoint.XPos() , OriginPoint.YPos() + (drawRect.Height() - (GetMaxFontHeight() * (nrlines - 1))) / 2 );

        textSize.SetY( GetMaxFontHeight() * nrlines );
        n0 = 0 , n1 = s.find( '\n' , n0 );
        while( n1 != string::npos )
        {
                _TextOut( pSurface , drawRect , OriginPoint , s.substr( n0 , n1 - n0 ) , FontColor , eMode );

                n0 = n1 + 1;
                n1 = s.find( '\n' , n0 );
                if( m_eVertAlign == VALIGN_CENTER )
                        OriginPoint = CPoint( OriginPoint.XPos() , OriginPoint.YPos() + GetMaxFontHeight() );
                else
                        drawRect.SetTop( drawRect.Top() + GetMaxFontHeight() );
        }

        _TextOut( pSurface , drawRect , OriginPoint , s.substr( n0 ) , FontColor , eMode );
}

CPoint XRenderedString::GetTextSize( const string &str )
{
        CPoint  ans( 0 , 0 );

        int     nrlines = 1;
        string  s = str;
        string::size_type       n0 = 0 , n1 = s.find( '\n' , n0 );
        while( n1 != string::npos )
        {
                CPoint  lineBox( 0 , 0 );

                m_bCachedMetricsValid = false;
                GetMetrics( s.substr( n0 , n1 - n0 ) , &lineBox , 0 , 0 );
                ans.SetX( max( ans.XPos() , lineBox.XPos() ) );
                n0 = n1 + 1;
                n1 = s.find( '\n' , n0 );
                nrlines += 1;
        }
        CPoint  lineBox( 0 , 0 );
        m_bCachedMetricsValid = false;
        GetMetrics( s.substr( n0 ) , &lineBox , 0 , 0 );
        ans.SetX( max( ans.XPos() , lineBox.XPos() ) );

        ans.SetY( GetMaxFontHeight() * nrlines );

        return ans;
}

unsigned int XRenderedString::GetMaxFontHeight()
{
        if (m_MaxFontHeight < 0)
        {
                int maxHeight=0;
                FT_Glyph_Metrics* pMetrics;
                for(int i=0; i < 256; i++)
                {
                        pMetrics = m_pFontEngine->GetMetrics((char)i);
                        if ((pMetrics->height >> 6) > maxHeight)
                        {
                                maxHeight = (pMetrics->height >> 6);
                        }
                        //maxHeight = std::max(maxHeight, pMetrics->height);
                }
                m_MaxFontHeight = maxHeight + 2;
        }
        return m_MaxFontHeight;
}

void XRenderedString::GetMetrics( const std::string &str , CPoint* pBoundedDimensions, CPoint* pOriginOffset, std::vector<CRect>* pCharacterRects) const
{
        if (! m_bCachedMetricsValid )
        {
                m_CachedCharacterRects.clear();

                int iMinY = 0;
                int iMaxY = 0;
                int iLength = 0;
                for (unsigned int i = 0; i < str.size(); ++i)
                {
                        FT_Glyph_Metrics* pMetrics;
                        if (m_MaskChar == ' ')
                        {
                                pMetrics = m_pFontEngine->GetMetrics(str[i]);
                        }
                        else
                        {
                                pMetrics = m_pFontEngine->GetMetrics(m_MaskChar);
                        }
                                
                        //FT_Glyph_Metrics* pMetrics = m_pFontEngine->GetMetrics(str[i]);
                        if ((pMetrics->horiBearingY - pMetrics->height) < iMinY)
                        {
                                iMinY = pMetrics->horiBearingY - pMetrics->height;
                        }
                        if (pMetrics->horiBearingY > iMaxY)
                        {
                                iMaxY = pMetrics->horiBearingY;
                        }
                        iLength += (pMetrics->horiAdvance);
                        // The top and bottom values of the rect are not actually in rect coordinates at this point, since iMaxY and iMinY are not yet know
                        m_CachedCharacterRects.push_back(
                                CRect((iLength - pMetrics->horiAdvance) >> 6, pMetrics->horiBearingY >> 6, iLength >> 6, pMetrics->height >> 6));
                }

                iMinY = iMinY >> 6;
                iMaxY = iMaxY >> 6;
                iLength = iLength >> 6;

                // now fix the top and bottom values of the rects
                for(std::vector<CRect>::iterator iter = m_CachedCharacterRects.begin(); iter != m_CachedCharacterRects.end(); ++iter)
                {
                        iter->SetTop(iMaxY - iter->Top());
                        iter->SetBottom(iter->Top() + iter->Bottom());
                }

                // Tack an empty rect on the end
                m_CachedCharacterRects.push_back(CRect(iLength, iMaxY, iLength, iMinY));

                m_CachedBoundedDimensions = CPoint(iLength, iMaxY - iMinY);

                switch (m_eHorzAlign)
                {
                case HALIGN_CENTER:
                        m_OriginOffset.SetX(-iLength / 2);
                        break;
                case HALIGN_RIGHT:
                        m_OriginOffset.SetX(-iLength);
                        break;
                case HALIGN_LEFT:
                default:
                        m_OriginOffset.SetX(0);
                        break;
                }

                switch (m_eVertAlign)
                {
                case VALIGN_TOP:
                        m_OriginOffset.SetY(0);
                        break;
                case VALIGN_BOTTOM:
                        m_OriginOffset.SetY(iMinY - iMaxY);
                        break;
                case VALIGN_CENTER:
                        m_OriginOffset.SetY((iMinY - iMaxY) / 2);
                        break;
                case VALIGN_NORMAL:
                default:
                        m_OriginOffset.SetY(-iMaxY);
                        break;
                }

                m_bCachedMetricsValid = true;
        }

        if (pBoundedDimensions)
        {
                *pBoundedDimensions = m_CachedBoundedDimensions;
        }

        if (pOriginOffset)
        {
                *pOriginOffset = m_OriginOffset;
        }

        if (pCharacterRects)
        {
                *pCharacterRects = m_CachedCharacterRects;
        }
}

}

---