arspaint.h

Go to the documentation of this file.

#if !defined( __ARSPAINT_H__ )
#define __ARSPAINT_H__

namespace Ars
{
class HPaint {
public:
        enum EPaintMode {
                PAINT_IGNORE = 0,  
                PAINT_REPLACE,  
                PAINT_NORMAL,  
                PAINT_OR,  
                PAINT_AND,  
                PAINT_XOR  
        };
protected:

        friend class View;

        SDL_Surface *&m_pSurface;  

        EPaintMode m_PaintMode;  

        FontEngine *m_pFontEngine;  

        mutable XPoint m_CachedBoundedDimensions;  
        mutable XPoint m_OriginOffset;  
        mutable std::vector<XRect> m_CachedCharacterRects;  
        mutable bool m_bCachedMetricsValid;  
        char m_MaskChar; 
        int m_MaxFontHeight; 
        XPoint  textSize;

private:

        unsigned long   states; 

public:

        static SDL_Surface *NoSurface;

        HPaint( void );

        HPaint( SDL_Surface *&surface );

        const EPaintMode SetMode( const EPaintMode aNewMode )
        {
                EPaintMode      ans = m_PaintMode;
                m_PaintMode = aNewMode;
                return ans;
        }

        FontEngine *SetFont( FontEngine *aFontEngine )  
        {
                FontEngine *ans = m_pFontEngine;
                m_pFontEngine = aFontEngine;
                m_bCachedMetricsValid = false;
                return ans;
        }
        FontEngine *GetFont( void )     {       return m_pFontEngine;   }

        const int       GetFontSize( void ) const       {       return m_pFontEngine->GetFontSize();    }

        XPoint GetTextSize( const string &str );

        void GetMetrics( const string &str , XPoint* pBoundedDimensions, XPoint* pOriginOffset, std::vector<XRect>* pCharacterRects = 0) const;

        void SetTextAlign( const int vAlign , const int hAlign = -1 )
        {       
                if( vAlign != -1 )
                {
                        states &= ~VALIGN_MASK;
                        states |= vAlign;
                }
                if( hAlign != -1 )
                {
                        states &= ~HALIGN_MASK;
                        states |= vAlign;
                }
        }
        virtual const unsigned long GetStates( void ) const     {       return states;  }

        unsigned int GetMaxFontHeight( void );

        virtual void TextOutStr( const XRect &BoundingRect, const std::string &str , const RGBColor &FontColor );

        void SetMaskChar( const char MaskChar ) { m_MaskChar = MaskChar; }

        void _TextOut( XRect &drawRect , XPoint &OriginPoint , const std::string &str , const RGBColor &FontColor );

        void SetGDI( SDL_Surface *&surface )    {       m_pSurface = surface;   }

        SDL_Surface *&GetGDI( void ) const      {       return m_pSurface;      }

        void DrawHLine( const int xStart, const int xEnd, const int y, const RGBColor& LineColor );

        void DrawVLine( const int yStart, const int yEnd, const int x, const RGBColor& LineColor );

        void DrawRect( const XRect& Rect, const bool bFilled, const RGBColor& BorderColor , const RGBColor& FillColor );

        void DrawLine( const XPoint& StartPoint, const XPoint& EndPoint, const RGBColor& LineColor );

        void DrawPoint(const XPoint& Point, const RGBColor& PointColor );
        void DrawPoint( SDL_Surface *s , const XPoint& Point, const RGBColor& PointColor );

        RGBColor ReadPoint(const XPoint& Point);
        RGBColor ReadPoint( SDL_Surface *s , const XPoint &Point);

        void ReplaceColor(const RGBColor& NewColor, const RGBColor& OldColor);

        void TransparentColor(const RGBColor& TransparentColor);


protected:
        void LockSurface(void);

        void UnlockSurface(void);

        RGBColor MixColor(const RGBColor& ColorBase, const RGBColor& ColorAdd);
};

class Painter : public HPaint , public Thing    {
public:

        Painter( void );

        virtual ~Painter( void ) { }

        virtual void Init( icstring &aStr );

        void SetTextAlign( const int vAlign , const int hAlign = -1 )
        {       
                if( vAlign != -1 )
                {
                        ResetState( VALIGN_MASK );
                        SetState( vAlign );
                }
                if( hAlign != -1 )
                {
                        ResetState( HALIGN_MASK );
                        SetState( hAlign );
                }
        }
        virtual const unsigned long GetStates( void ) const     {       return Thing::GetStates();      }
};
}

#endif

---