arspaint.cpp

Go to the documentation of this file.

#include "SdlArs.h"

namespace Ars
{
SDL_Surface *HPaint::NoSurface = 0;

HPaint::HPaint( void )
: m_pSurface( NoSurface ), m_PaintMode( PAINT_NORMAL )
, m_pFontEngine( 0 )
, m_bCachedMetricsValid(false), m_MaskChar(' '), m_MaxFontHeight(-1)
{
        m_pFontEngine = ArsApplication::GetInstance()->GetDefaultFontEngine();
}

HPaint::HPaint( SDL_Surface *&surface )
: m_pSurface( surface ), m_PaintMode( PAINT_NORMAL )
, m_pFontEngine( 0 )
, m_bCachedMetricsValid(false), m_MaskChar(' '), m_MaxFontHeight(-1)
{
        m_pFontEngine = ArsApplication::GetInstance()->GetDefaultFontEngine();
}

void HPaint::_TextOut( XRect &drawRect , XPoint &OriginPoint , const std::string &str , const RGBColor &FontColor ) 
{
        m_bCachedMetricsValid = false;
        XPoint OriginOffset , linebox;
        std::vector<XRect> CharacterRects;

        GetMetrics( str , &linebox , &OriginOffset , &CharacterRects );

        textSize.x = max( textSize.x , linebox.x );
        switch( (GetStates() & VALIGN_MASK)  )
        {
                case S_ALIGN_TOP :      OriginPoint = XPoint( OriginPoint.x , drawRect.y );     break;
                case S_ALIGN_BOTTOM :   OriginPoint = XPoint( OriginPoint.x , drawRect.Bottom() );      break;
        }

        switch( (GetStates() & HALIGN_MASK) )
        {
                case S_ALIGN_LEFT : OriginPoint = XPoint( drawRect.x , OriginPoint.y ); break;
                case S_ALIGN_RIGHT : OriginPoint = XPoint( drawRect.Right() , OriginPoint.y );  break;
                default : OriginPoint = XPoint( drawRect.x + drawRect.Width() / 2 , OriginPoint.y );    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 );

                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 )
                                {
                                        RGBColor PixelColor(FontColor.red, FontColor.green, FontColor.blue, *PixelOffset);

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

void HPaint::TextOutStr( const XRect &BoundingRect, const std::string &aStr , const RGBColor &FontColor )
{
        string  str;
        for( int i = 0 ; aStr[i] ; i++ )
                if( aStr[i] == '\t' )
                        str += "    ";
                else
                        str += aStr[i];

        m_bCachedMetricsValid = false;
        textSize = XPoint( 0 , 0 );

        XPoint  OriginPoint = BoundingRect.TopLeft();
        XRect   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( (GetStates() & VALIGN_MASK) == 0 )
                OriginPoint = XPoint( OriginPoint.x , OriginPoint.y + 2 + max( 0 , (int)(drawRect.Height() - ((GetMaxFontHeight() + 2) * (nrlines -1))) / 2 ) );

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

                n0 = n1 + 1;
                n1 = s.find( '\n' , n0 );
                if( (GetStates() & VALIGN_MASK) == 0 )
                        OriginPoint = XPoint( OriginPoint.x , OriginPoint.y + (GetMaxFontHeight() + 2) );
                else    
                        drawRect.y = drawRect.y + (GetMaxFontHeight() + 2);
        }

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

XPoint HPaint::GetTextSize( const string &aStr )
{
        string  str;
        for( int i = 0 ; aStr[i] ; i++ )
                if( aStr[i] == '\t' )
                        str += "    ";
                else
                        str += aStr[i];
        XPoint  ans( 0 , 0 );

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

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

        ans.y = (m_pFontEngine->GetFontSize() + 2) * nrlines;

        return ans;
}

unsigned int HPaint::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 HPaint::GetMetrics( const std::string &str , XPoint* pBoundedDimensions, XPoint* pOriginOffset, std::vector<XRect>* 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);
                        }
                        

                        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( XRect((iLength - pMetrics->horiAdvance) >> 6, pMetrics->horiBearingY >> 6, (iLength >> 6) - ((iLength - pMetrics->horiAdvance) >> 6) , (pMetrics->height >> 6) - (pMetrics->horiBearingY >> 6 )));
                }

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

                // now fix the top and bottom values of the rects
                for(std::vector<XRect>::iterator iter = m_CachedCharacterRects.begin(); iter != m_CachedCharacterRects.end(); ++iter)
                        iter->y = iMaxY - iter->y;

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

                m_CachedBoundedDimensions = XPoint(iLength, iMaxY - iMinY);

                switch ( (GetStates() & HALIGN_MASK) )
                {
                default:
                        m_OriginOffset.x = -iLength / 2;
                        break;
                case S_ALIGN_RIGHT:
                        m_OriginOffset.x = -iLength;
                        break;
                case S_ALIGN_LEFT:
                        m_OriginOffset.x = 0;
                        break;
                }

                switch( (GetStates() & VALIGN_MASK) )
                {
                case S_ALIGN_TOP:
                        m_OriginOffset.y = 0;
                        break;
                case S_ALIGN_BOTTOM:
                        m_OriginOffset.y = iMinY - iMaxY;
                        break;
                default:
                        m_OriginOffset.y = (iMinY - iMaxY) / 2;
                        break;
                }

                m_bCachedMetricsValid = true;
        }

        if (pBoundedDimensions)
        {
                *pBoundedDimensions = m_CachedBoundedDimensions;
        }

        if (pOriginOffset)
        {
                *pOriginOffset = m_OriginOffset;
        }

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

void HPaint::DrawHLine(const int xStart, const int xEnd, const int y, const RGBColor &LineColor)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }

#ifdef WIN32
#ifndef MSVC6  // There are problems with VC6 and these std lib template classes
/*
        if (xStart < std::numeric_limits<short int>::min() ||xStart > std::numeric_limits<short int>::max()
                || xEnd < std::numeric_limits<short int>::min() ||xEnd > std::numeric_limits<short int>::max()
                || y < std::numeric_limits<short int>::min() ||y > std::numeric_limits<short int>::max())
        {
                throw(ExceptionRange("HPaint::DrawHLine : Out of range - converting int to short int!"));
        }
*/
#endif // MSVC6
#endif // WIN32

        SDL_Rect Rect;
        Rect.x = static_cast<short int>( min(xStart, xEnd) );
        Rect.y = static_cast<short int>(y);
        Rect.w = static_cast<short int>( max(xEnd - xStart + 1, xStart - xEnd + 1) );
        Rect.h = 1;
        SDL_FillRect(m_pSurface, &Rect, LineColor.SDLColor(m_pSurface->format));
}


void HPaint::DrawVLine(const int yStart, const int yEnd, const int x, const RGBColor &LineColor)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
#ifdef WIN32
#ifndef MSVC6  // There are problems with VC6 and these std lib template classes
/*
        if (yStart < std::numeric_limits<short int>::min() ||yStart > std::numeric_limits<short int>::max()
                || yEnd < std::numeric_limits<short int>::min() ||yEnd > std::numeric_limits<short int>::max()
                || x < std::numeric_limits<short int>::min() ||x > std::numeric_limits<short int>::max())
        {
                throw(ExceptionRange("HPaint::DrawVLine : Out of range - converting int to short int!"));
        }
*/
#endif // MSVC6
#endif // WIN32

        SDL_Rect Rect;
        Rect.x = static_cast<short int>(x);
        Rect.y = static_cast<short int>( min(yStart, yEnd) );
        Rect.w = 1;
        Rect.h = static_cast<short int>( max(yEnd - yStart + 1, yStart - yEnd + 1) );
        SDL_FillRect(m_pSurface, &Rect, LineColor.SDLColor(m_pSurface->format));
}


void HPaint::DrawRect(const XRect &Rect, const bool bFilled, const RGBColor &BorderColor, const RGBColor &FillColor)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
        XRect RealRect( Rect );

        if (bFilled)
        {
                RealRect.w += 1;
                RealRect.h += 1;
                SDL_FillRect(m_pSurface, &RealRect, FillColor.SDLColor(m_pSurface->format));
        }
        
        if (!bFilled || (BorderColor != FillColor))
        {
                RealRect = Rect;

                DrawHLine(RealRect.x, RealRect.Right(), RealRect.y, BorderColor);
                DrawHLine(RealRect.x, RealRect.Right(), RealRect.Bottom(), BorderColor);
                DrawVLine(RealRect.y, RealRect.Bottom(), RealRect.x, BorderColor);
                DrawVLine(RealRect.y, RealRect.Bottom(), RealRect.Right(), BorderColor);
                RealRect.Grow(-1); //In case we have to fill the rect, then it's ready to go.
        }
}


void HPaint::DrawLine(const XPoint &Point1, const XPoint &Point2, const RGBColor &LineColor)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
        if (Point1.x == Point2.x)
        {
                DrawVLine(Point1.y, Point2.y, Point1.x, LineColor);
        }
        else
        {
                const double iSlope = double(Point2.y - Point1.y) / (Point2.x - Point1.x);
                if( iSlope <= 1.0 && iSlope >= -1.0 )
                {
                        XPoint StartPoint = (Point1.x < Point2.x) ? Point1 : Point2;
                        XPoint EndPoint = (Point1.x < Point2.x) ? Point2 : Point1;
                        for (int x = StartPoint.x; x <= EndPoint.x; ++x)
                        {
                                DrawPoint(XPoint(x, static_cast<int>(StartPoint.y + (x - StartPoint.x) * iSlope)), LineColor);
                        }
                }
                else
                {
                        XPoint StartPoint = (Point1.y < Point2.y) ? Point1 : Point2;
                        XPoint EndPoint = (Point1.y < Point2.y) ? Point2 : Point1;
                        for (int y = StartPoint.y; y <= EndPoint.y; ++y)
                        {
                                DrawPoint(XPoint(static_cast<int>(StartPoint.x + (y - StartPoint.y) / iSlope), y), LineColor);
                        }
                }
        }
}

void HPaint::DrawPoint(const XPoint &Point, const RGBColor &PointColor)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
        DrawPoint( m_pSurface , Point , PointColor );
}


void HPaint::DrawPoint( SDL_Surface *s , const XPoint &Point, const RGBColor &PointColor)
{
        if (!s)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
        XPoint RealPoint = Point;
        if (XRect(0, 0, s->w, s->h).HitTest(RealPoint) == XRect::RELPOS_INSIDE)
        {
                LockSurface();
                Uint8* PixelOffset = static_cast<Uint8*>(s->pixels) +
                        s->format->BytesPerPixel * RealPoint.x + s->pitch * RealPoint.y;
                switch (s->format->BytesPerPixel)
                {
                case 1: // 8 bpp
                        *reinterpret_cast<Uint8*>(PixelOffset) = static_cast<Uint8>(MixColor(ReadPoint(Point), PointColor).SDLColor(s->format));
                        break;
                case 2: // 16 bpp
                        *reinterpret_cast<Uint16*>(PixelOffset) = static_cast<Uint16>(MixColor(ReadPoint(Point), PointColor).SDLColor(s->format));
                        break;
                case 3:  // 24 bpp
                {
                        Uint32 PixelColor = MixColor(ReadPoint(Point), PointColor).SDLColor(s->format);
                        Uint8* pPixelSource = reinterpret_cast<Uint8*>(&PixelColor);
                        Uint8* pPixelDest = reinterpret_cast<Uint8*>(PixelOffset);
                        *pPixelDest = *pPixelSource;
                        *(++pPixelDest) = *(++pPixelSource);
                        *(++pPixelDest) = *(++pPixelSource);
                        break;
                }
                case 4: // 32 bpp
                        *reinterpret_cast<Uint32*>(PixelOffset) = static_cast<Uint32>(MixColor(ReadPoint(Point), PointColor).SDLColor(s->format));
                        break;
                default:
                        tron << "HPaint::DrawPoint : Unrecognized BytesPerPixel.\n";
                        break;
                }
                UnlockSurface();
        }
}


RGBColor HPaint::ReadPoint(const XPoint &Point)
{
        if (!m_pSurface)
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
        else
                return ReadPoint( m_pSurface , Point );
        return RGBColor( 0 , 0 ,0 );
}

RGBColor HPaint::ReadPoint( SDL_Surface *s , const XPoint &Point)
{
        if (!s)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return RGBColor( 0 , 0 ,0 );
        }
        XPoint RealPoint = Point;
        Uint32 PixelColor = 0;
        if (XRect(0, 0, s->w, s->h).HitTest(RealPoint) == XRect::RELPOS_INSIDE)
        {
                Uint8* PixelOffset = static_cast<Uint8*>(s->pixels) +
                        s->format->BytesPerPixel * RealPoint.x + s->pitch * RealPoint.y;
                switch (s->format->BytesPerPixel)
                {
                case 1: // 8 bpp
                        PixelColor = *reinterpret_cast<Uint8*>(PixelOffset);
                        break;
                case 2: // 16 bpp
                        PixelColor = *reinterpret_cast<Uint16*>(PixelOffset);
                        break;
                case 3: // 24 bpp
                {
                        Uint8* pPixelDest = reinterpret_cast<Uint8*>(&PixelColor);
                        Uint8* pPixelSource = reinterpret_cast<Uint8*>(PixelOffset);
                        *pPixelDest = *pPixelSource;
                        *(++pPixelDest) = *(++pPixelSource);
                        *(++pPixelDest) = *(++pPixelSource);
                        break;
                }
                case 4: // 32 bpp
                        PixelColor = *reinterpret_cast<Uint32*>(PixelOffset);
                        break;
                default:
                        tron << "HPaint::DrawPoint : Unrecognized BytesPerPixel.\n";
                        break;
                }
        }
        return RGBColor(&PixelColor, s->format);
}


void HPaint::LockSurface(void)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
        if (SDL_MUSTLOCK(m_pSurface))
        {
                if (SDL_LockSurface(m_pSurface) < 0)
                {
                        SDL_Delay(10);
                        if (SDL_LockSurface(m_pSurface) < 0)
                        {
                                tron << "Unable to lock surface.\n";
                        }
                }
        }
}


void HPaint::UnlockSurface(void)
{
        if (!m_pSurface)
        {
                tron<< "HPaint::HPaint : Invalid pointer to surface.\n";
                return ;
        }
        if (SDL_MUSTLOCK(m_pSurface))
                SDL_UnlockSurface(m_pSurface);
}


RGBColor HPaint::MixColor( const RGBColor &ColorBase, const RGBColor &ColorAdd )
{
        RGBColor MixedColor( 0x00, 0x00, 0x00, 0x00 );
        switch (m_PaintMode)
        {
        case PAINT_IGNORE:
                MixedColor = ColorBase;
                break;
        case PAINT_REPLACE:
                MixedColor = ColorAdd;
                break;
        case PAINT_NORMAL:
                MixedColor = ColorBase + ColorAdd;
                break;
        case PAINT_AND:
                MixedColor = ColorBase  &ColorAdd;
                break;
        case PAINT_OR:
                MixedColor = ColorBase | ColorAdd;
                break;
        case PAINT_XOR:
                MixedColor = ColorBase ^ ColorAdd;
                break;
        }

        return MixedColor;
}


void HPaint::ReplaceColor(const RGBColor &NewColor, const RGBColor &OldColor)
{
        for (int y = 0; y < m_pSurface->h; ++y)
        {
                for (int x = 0; x < m_pSurface->w; ++x)
                {
                        XPoint point(x, y);
                        if(ReadPoint(point) == OldColor)
                        {
                                DrawPoint(point, NewColor);
                        }
                }
        }
}


void HPaint::TransparentColor(const RGBColor &TransparentColor)
{
        SDL_SetColorKey(m_pSurface, SDL_SRCCOLORKEY, TransparentColor.SDLColor(m_pSurface->format));
}

Painter::Painter( void ) 
{
}

void Painter::Init( icstring &aStr )
{
        Cfg::Handler &h = Cfg::GetCfg();

        //      Font Id and Font height...
        icstring tmp = Rsrc::FindCrdOf( aStr , "fontid" );
        int     fid = Rsrc::GetInt( tmp );
        tmp     = Rsrc::FindCrdOf( aStr , "fonth" );
        int     fh = Rsrc::GetInt( tmp );

        if( fid >= 0 || fh >= 0 )
        {
                string  fntName = m_pFontEngine->GetFontFilename();

                if( fid >= 0 )
                {
                        char    tmp[20];
                        sprintf( tmp , "Font%d" , fid );
                        Cfg::Handler    &fnt = Cfg::GetCfg( h.GetCfgString( "Paths" , "Fonts" ) );
                        fntName = fnt.GetCfgFile( "" , tmp );
                }

                if( fh < 0 )
                        m_pFontEngine = ArsApplication::GetInstance()->GetFontEngine( fntName );
                else
                        m_pFontEngine = ArsApplication::GetInstance()->GetFontEngine( fntName , fh );
        }

        Thing::Init( aStr );
}

}

---