OSDLPoint2D.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_POINT_2D_H_
#define OSDL_POINT_2D_H_


#include "OSDLVideoTypes.h"    // for Coordinate
#include "OSDLPoint.h"         // for inheritance

#include "OSDLTypes.h"

#include "Ceylan.h"            // for MatrixIndex, TextDisplayable

#include <string>
#include <list>



namespace OSDL
{


    
    namespace Video
    {
    
    
    
        namespace TwoDimensional
        {
        


        
            class OSDL_DLL Point2D : public Point
            {


                public:
    
        
        
                    explicit Point2D( Coordinate x = 0, Coordinate y = 0 ) ;



                    Point2D( const Point2D & source ) ;
                    
                    
                    
                    explicit Point2D( 
                        const Ceylan::Maths::Linear::Bipoint & source ) ;
                    
                    
                    
                    explicit Point2D( 
                        const Ceylan::Maths::Linear::Vector2 & source ) ;
                    
                     
                     
                    static Point2D & CreateFrom( FloatingPointCoordinate x = 0, 
                        FloatingPointCoordinate y = 0 ) ;



                    virtual ~Point2D() throw() ;
    
    
    
                    virtual void setTo( Coordinate x, Coordinate y ) ;
                    
                    
                    
                    virtual void setTo( FloatingPointCoordinate x, 
                        FloatingPointCoordinate y ) ;



                    virtual void setFrom( const Point2D & source ) ;
                    


                    virtual void setFrom( 
                        const Ceylan::Maths::Linear::Vector2 & source ) ;


                    
                    inline Coordinate getX() const ;
                    
                    
                    inline void setX( Coordinate newX ) ;
    
    
    
                    inline Coordinate getY() const ;
                    
                    
                    inline void setY( Coordinate newY ) ;



                    void translate( Offset x, Offset y ) ;
                    
                    
                    
                    virtual void flip() ;
                    
                    
                    
                    virtual void flipX() ;
                    
                    
        
                    virtual void flipY() ;
                    
                    
                    
                    virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) const ;
                        



                    // Static section.
                    
                    
                    
                    static const Point2D Origin ;
                    
                    
                    
                    
                    static void Translate( std::list<Point2D *> & pointList,
                        Offset x, Offset y ) ;
                    

                    static const Ceylan::Maths::Linear::MatrixIndex Dimensions 
                        = 2 ;
                    
                    
                    
                    
                protected:
    
    
                    Coordinate _coord[ Dimensions ] ;
                    
                    

            } ;
    
    
    
    
    
            // Inline section.
            
            
    
            Coordinate Point2D::getX() const
            {
            
                return _coord[0] ;
                
            }
    
    
    
            void Point2D::setX( Coordinate newX )
            {
            
                _coord[0] = newX ;
                
            }
    
    
    
            Coordinate Point2D::getY() const
            {
            
                return _coord[1] ;
                
            }
    
    
    
            void Point2D::setY( Coordinate newY )
            {
            
                _coord[1] = newY ;
                
            }
            
            
            
        }

    }
    
}



OSDL_DLL std::ostream & operator << ( std::ostream & os, 
    const OSDL::Video::TwoDimensional::Point2D & p ) ;



#endif // OSDL_POINT_2D_H_

---