OSDLUprightRectangle.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the OSDL library.
 *
 * The OSDL library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The OSDL 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 and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and of the GNU General Public License along with the OSDL library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef OSDL_UPRIGHT_RECTANGLE_H_
#define OSDL_UPRIGHT_RECTANGLE_H_


#include "OSDLVideoTypes.h"    // for Length, Coordinate, etc.
#include "OSDLPixel.h"         // for Pixels::ColorElement

#include "Ceylan.h"            // for Point2D



#if ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 

#include "SDL.h"             // for ColorDefinition

#endif // OSDL_USES_SDL



#include <iostream>            // for ostream
#include <string>



#if ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 

// No need to include SDL header here:
struct SDL_Rect ;
struct SDL_Color ;

#endif //  ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 




namespace OSDL 
{



    namespace Video 
    {
        
        
        
        namespace TwoDimensional
        {
        
        
        
            // Forward declaration to be able to define the operator ==.
            class UprightRectangle ;
            
            
            
            #if ! defined(OSDL_USES_SDL) || OSDL_USES_SDL
            
            // The internal actual rectangle object.
            typedef ::SDL_Rect LowLevelRect ;
                
            #else // OSDL_USES_SDL

            struct LowLevelRect {} ;
                
            #endif // OSDL_USES_SDL
            
            
        }
                
    }
    
}



// Operators should not be defined in a namespace.


OSDL_DLL bool operator == ( 
    const OSDL::Video::TwoDimensional::UprightRectangle & first, 
    const OSDL::Video::TwoDimensional::UprightRectangle & second ) ;



OSDL_DLL bool operator != ( 
    const OSDL::Video::TwoDimensional::UprightRectangle & first, 
    const OSDL::Video::TwoDimensional::UprightRectangle & second ) ;




namespace OSDL 
{


    namespace Video 
    {
        
        
        
        // UprightRectangle instances can be drawn into surfaces.
        class Surface ;
        
        
        
        namespace TwoDimensional
        {
        
        
        
            // UprightRectangle instances are defined thanks to 2D points.
            class Point2D ;
        
     
     
            
            class OSDL_DLL UprightRectangle: public Ceylan::TextDisplayable
            {
                    
                                    
                friend bool::operator == ( const UprightRectangle & first, 
                    const UprightRectangle & second ) ;
                    
                        
                        
                public:



                    UprightRectangle( const Point2D & upperLeftCorner,
                        const Point2D & lowerRightCorner ) ;
                    
                    
                    
                    UprightRectangle( const Point2D & upperLeftCorner, 
                        Length width, Length height ) ;
                    
                    
                    
                    UprightRectangle( Coordinate x, Coordinate y, Length width,
                         Length height ) ;
                     
                     
                     
                    explicit UprightRectangle( const LowLevelRect & source ) ;
        
        
        
                    virtual ~UprightRectangle() throw() ;
    
    
    
    
                    
                    // Section for upper-left corner.
                    
    
    
                    virtual Point2D getUpperLeftCorner() const ; 
                    
                    
                    
                    virtual void setUpperLeftCorner( 
                        Point2D & newUpperLeftCorner ) ; 
                    
                    
                    
                    
                    virtual Coordinate getUpperLeftAbscissa() const ;



                    virtual void setUpperLeftAbscissa( 
                        Coordinate newAbscissa ) ;


                    
                    virtual Coordinate getUpperLeftOrdinate() const ;
                    
                    
                    
                    virtual void setUpperLeftOrdinate( 
                        Coordinate newOrdinate ) ;
                    
                    
                    

                    
                    // Section for lower-right corner.
                    
    
    
                    virtual Point2D getLowerRightCorner() const ; 
                    
                    
                    
                    virtual void setLowerRightCorner( 
                        Point2D & newLowerRightCorner ) ; 
                    
                    
                    
                    virtual Coordinate getLowerRightAbscissa() const ;


                    virtual void setLowerRightAbscissa( 
                        Coordinate newAbscissa ) ;



                    
                    virtual Coordinate getLowerRightOrdinate() const ;
                    
                    
                    virtual void setLowerRightOrdinate( 
                        Coordinate newOrdinate ) ;
                    

                    
                    
                    virtual Length getWidth() const ;
                
                
                
                    virtual void setWidth( Length newWidth ) ;
    
    
    
    
                    virtual Length getHeight() const ;
                
                
                
                    virtual void setHeight( Length newHeight ) ;
                        
                        
    
                    virtual bool draw( 
                        Surface & target, 
                        Pixels::ColorElement red, 
                        Pixels::ColorElement blue, 
                        Pixels::ColorElement green, 
                        Pixels::ColorElement alpha = Pixels::AlphaOpaque,
                        bool filled = true ) const ;
                    
    
    
                    virtual bool draw( Surface & target, 
                        Pixels::ColorDefinition colorDef = Pixels::White,
                        bool filled = true ) const ;
                    
                    
                    
                    virtual bool drawWithRoundedCorners( 
                        Surface & target, Length edgeWidth = 3, 
                        Pixels::ColorDefinition edgeColorDef = Pixels::White, 
                        Pixels::ColorDefinition backgroundColorDef 
                            = Pixels::Transparent ) const ;
                    
                    
                    
                    virtual Length computeRadiusForRoundRectangle( 
                        Length edgeWidth ) const ;
                    
                    
                    
                    virtual LowLevelRect * toLowLevelRect() const ;

                
                
                    virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) const ;
                
    
    
    
    
                protected:
                
                
                
                    Coordinate _x ;
                
                
                    Coordinate _y ;
                
            
            
            
                private:
                
                
                
                    Length _width ;
                
                
                    Length _height ;            
                
                
                
                    explicit UprightRectangle( 
                        const UprightRectangle & source ) ;
            
            
            
                    UprightRectangle & operator = ( 
                        const UprightRectangle & source ) ;
    
    
            } ; 


        }
        
    }
    
}




std::ostream & operator << ( std::ostream & os, 
    OSDL::Video::TwoDimensional::UprightRectangle & rect ) ;



#endif // OSDL_UPRIGHT_RECTANGLE_H_

---