Dimension.hpp

Go to the documentation of this file.

#pragma once

#include <etk/types.hpp>
#include <etk/math/Vector2D.hpp>

namespace esvg {
    enum distance {
        distance_pourcent=0, 
        distance_pixel, 
        distance_meter, 
        distance_centimeter, 
        distance_millimeter, 
        distance_kilometer, 
        distance_inch, 
        distance_foot, 
        distance_element, 
        distance_ex, 
        distance_point, 
        distance_pc 
    };
    class Dimension {
        private:
            vec2 m_data;
            enum distance m_type;
        public:
            Dimension();
            Dimension(const vec2& _size, enum esvg::distance _type=esvg::distance_pixel);
            Dimension(const std::string& _config) :
              m_data(0,0),
              m_type(esvg::distance_pixel) {
                set(_config);
            };
            Dimension(const std::string& _configX, const std::string& _configY) :
              m_data(0,0),
              m_type(esvg::distance_pixel) {
                set(_configX, _configY);
            };
            ~Dimension();
            
            operator std::string() const;
            
            const vec2& getValue() const {
                return m_data;
            }
            enum distance getType() const {
                return m_type;
            };
            void set(const vec2& _size, enum distance _type);
            
        public:
            void set(std::string _config);
            void set(std::string _configX, std::string _configY);
        public:
            vec2 getPixel(const vec2& _upperSize) const;
            /*****************************************************
             *    = assigment
             *****************************************************/
            const Dimension& operator= (const Dimension& _obj ) {
                if (this!=&_obj) {
                    m_data = _obj.m_data;
                    m_type = _obj.m_type;
                }
                return *this;
            }
            /*****************************************************
             *    == operator
             *****************************************************/
            bool operator ==  (const Dimension& _obj) const {
                if(    m_data == _obj.m_data
                    && m_type == _obj.m_type) {
                    return true;
                }
                return false;
            }
            /*****************************************************
             *    != operator
             *****************************************************/
            bool operator!= (const Dimension& _obj) const {
                if(    m_data != _obj.m_data
                    || m_type != _obj.m_type) {
                    return true;
                }
                return false;
            }
    };
    std::ostream& operator <<(std::ostream& _os, enum esvg::distance _obj);
    std::ostream& operator <<(std::ostream& _os, const esvg::Dimension& _obj);
    class Dimension1D {
        private:
            float m_data;
            enum distance m_type;
        public:
            Dimension1D();
            Dimension1D(float _size, enum esvg::distance _type=esvg::distance_pixel);
            Dimension1D(const std::string& _config) :
              m_data(0.0f),
              m_type(esvg::distance_pixel) {
                set(_config);
            };
            ~Dimension1D();
            
            operator std::string() const;
            
            const float& getValue() const {
                return m_data;
            }
            enum distance getType() const {
                return m_type;
            };
            void set(float _size, enum distance _type);
            
        public:
            void set(std::string _config);
        public:
            float getPixel(float _upperSize) const;
            /*****************************************************
             *    = assigment
             *****************************************************/
            const Dimension1D& operator= (const Dimension1D& _obj ) {
                if (this!=&_obj) {
                    m_data = _obj.m_data;
                    m_type = _obj.m_type;
                }
                return *this;
            }
            /*****************************************************
             *    == operator
             *****************************************************/
            bool operator ==  (const Dimension1D& _obj) const {
                if(    m_data == _obj.m_data
                    && m_type == _obj.m_type) {
                    return true;
                }
                return false;
            }
            /*****************************************************
             *    != operator
             *****************************************************/
            bool operator!= (const Dimension1D& _obj) const {
                if(    m_data != _obj.m_data
                    || m_type != _obj.m_type) {
                    return true;
                }
                return false;
            }
    };
    std::ostream& operator <<(std::ostream& _os, const esvg::Dimension1D& _obj);
}