SizeProperty.h

Go to the documentation of this file.

#pragma once
 
#include "PointProperty.h"
#include "Size.h"
#include "../Property.h"
 
namespace Gorgon { namespace Geometry {
    
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    class basic_SizeProperty : public Property<C_, T_, Getter_, Setter_> {
    public:
        
        basic_SizeProperty(C_ *object) : 
        Property<C_,T_, Getter_, Setter_>(object), 
        Width(this), Height(this)
        { }
 
        basic_SizeProperty(C_ &object) : basic_SizeProperty(&object)
        { }
 
        basic_SizeProperty(basic_SizeProperty &&) = default;
        
        basic_SizeProperty& operator=(basic_SizeProperty &&) = default;
 
        operator T_() { 
            return (this->Object.*Getter_)(); 
        }
 
        operator const T_() const { 
            return (this->Object.*Getter_)(); 
        }
 
        basic_SizeProperty &operator =(const T_ &value) { 
            (this->Object.*Setter_)(value);
 
            return *this;
        }
 
        T_ operator - (const T_ &point) const {
            return this->Get() - point;
        }
 
        T_ operator -() const {
            return -this->Get();
        }
 
        T_ operator + (const T_ &point) const {
            return this->Get() + point;
        }
 
        template <class O_>
        T_ operator * (O_ value) const {
            return this->Get() * value;
        }
 
        T_ operator *(const T_ &value) const {
            return this->Get() * value;
        }
 
        template <class O_>
        T_ operator / (O_ value) const {
            return this->Get() / value;
        }
 
        basic_SizeProperty &operator -= (const T_ &point) {
            this->Set(this->Get() - point);
 
            return *this;
        }
 
        basic_SizeProperty &operator += (const T_ &point) {
            this->Set(this->Get() + point);
 
            return *this;
        }
 
        template <class O_>
        basic_SizeProperty &operator *= (O_ value) {
            this->Set(this->Get() * value);
 
            return *this;
        }
 
        template <class O_>
        basic_SizeProperty &operator /= (O_ value) {
            this->Set(this->Get() / value);
 
            return *this;
        }
 
        T_ CrossProduct(const T_ &value) const {
            return this->Get().CrossProduct(value);
        }
 
        T_ DotProduct(const T_ &value) const {
            return this->Get().DotProduct(value);
        }
 
 
        Float Distance(const T_ &target) const {
            return this->Get().Distance(target);
        }
        Float EuclideanSquare(const T_ &target) const {
            return this->Get().EuclideanSquare(target);
        }
        Float Distance() const {
            return this->Get().Distance();
        }
 
        Float EuclideanSquare() const {
            return this->Get().EuclideanSquare();
        }
        Float ManhattanDistance(const T_ &target) const {
            return this->Get().ManhattanDistance(target);
        }
 
        Float ManhattanDistance() const {
            return this->Get().ManhattanDistance();
        }
        
        T_ Normalize() const {
            return this->Get().Normalize();
        }
        
        T_ Perpendicular() const {
            return this->Get().Perpendicular();
        }
 
        Float Angle(const T_ &origin) const {
            return this->Get().Angle(origin);
        }
 
        Float Angle() const {
            return this->Get().Angle();
        }
 
        Float Slope(const T_ &point) const {
            return this->Get().Slope(point);
        }
 
        Float Slope() const {
            return this->Get().Slop();
        }
 
        bool Compare(const T_ &point) const {
            return this->Get().Compare(point);
        }
 
        bool operator == (const T_ &point) const {
            return Compare(point);
        }
 
        bool operator !=(const T_ &point) const {
            return !Compare(point);
        }
 
        typename T_::BaseType GetWidth() const {
            return this->Get().Width;
        }
        
        void SetWidth(const typename T_::BaseType &value) {
            this->Set({value, this->Get().Height});
        }
        
        typename T_::BaseType GetHeight() const {
            return this->Get().Height;
        }
        
        void SetHeight(const typename T_::BaseType &value) {
            this->Set({this->Get().Width, value});
        }
        
        NumericProperty<basic_SizeProperty, typename T_::BaseType, &basic_SizeProperty::GetWidth, &basic_SizeProperty::SetWidth> Width;
        NumericProperty<basic_SizeProperty, typename T_::BaseType, &basic_SizeProperty::GetHeight, &basic_SizeProperty::SetHeight> Height;
    };
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void Scale(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const basic_Size<O_> &size) {
        auto p = point.Get();
        Scale(p, size);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void Scale(basic_SizeProperty<C_, T_, Getter_, Setter_> &l, const O_ &size) {
        auto s = l.Get();
        Scale(s, size);
        l.Set(s);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O1_, class O2_>
    void Scale(basic_SizeProperty<C_, T_, Getter_, Setter_> &l, const O1_ &sizex, const O2_ &sizey) {
        auto s = l.Get();
        Scale(s, sizex, sizey);
        l.Set(s);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void Scale(basic_SizeProperty<C_, T_, Getter_, Setter_> &l, const basic_Size<O_> &size) {
        auto s = l.Get();
        Scale(s, size);
        l.Set(s);
    }
 
 
    template<class C_, Size(C_::*Getter_)() const, void(C_::*Setter_)(const Size &)>
    using SizeProperty = basic_SizeProperty<C_, Size, Getter_, Setter_>;
    
    template<class C_, Sizef(C_::*Getter_)() const, void(C_::*Setter_)(const Sizef &)>
    using SizefProperty = basic_SizeProperty<C_, Sizef, Getter_, Setter_>;
    
} }