Margin.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <ostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <limits>
 
#include "Point.h"
#include "Size.h"
#include "Bounds.h"
 
namespace Gorgon { namespace Geometry {
    
    template <class T_>
    class basic_Margin {
    public:
        typedef T_ BaseType;
        
        basic_Margin() {}
        
        basic_Margin(T_ all) : Left(all), Top(all), Right(all), Bottom(all) { }
        
        basic_Margin(T_ horizontal, T_ vertical) : Left(horizontal), Right(horizontal), 
        Top(vertical), Bottom(vertical) { }
        
        basic_Margin(T_ left, T_ top, T_ right, T_ bottom) : 
            Left(left), Top(top), Right(right), Bottom(bottom) { }
 
        explicit operator std::string() const {
            std::ostringstream str;
            str<<"("<<Left<<", "<<Top<<", "<<Right<<", "<<Bottom<<")";
 
            return str.str();
        }
        
        basic_Margin CombinePadding(const basic_Margin &other) const {
            return {
                (Left < 0 || other.Left < 0) ? Left + other.Left : std::max(Left, other.Left),
                (Top < 0 || other.Top < 0) ? Top + other.Top : std::max(Top, other.Top),
                (Right < 0 || other.Right < 0) ? Right + other.Right : std::max(Right, other.Right),
                (Bottom < 0 || other.Bottom < 0) ? Bottom + other.Bottom : std::max(Bottom, other.Bottom),
            };
        }
 
        basic_Margin CombineMargins(const basic_Margin &other) const {
            return {
                (Left < 0 || other.Right< 0) ? Left + other.Right : std::max(Left, other.Right),
                (Top < 0 || other.Bottom < 0) ? Top + other.Bottom : std::max(Top, other.Bottom),
                (Right < 0 || other.Left < 0) ? Right + other.Left : std::max(Right, other.Left),
                (Bottom < 0 || other.Top < 0) ? Bottom + other.Top : std::max(Bottom, other.Top),
            };
        }
        
        T_ TotalX() const  { return Right+Left; }
        
        T_ TotalY() const { return Bottom+Top;  }
 
        T_ Horizontal() const  { return Right+Left; }
        
        T_ Vertical() const { return Bottom+Top;  }
 
        basic_Size<T_> Total() const  { return {Right+Left, Bottom+Top}; }
        
        basic_Margin operator +(const basic_Margin &right) const {
            return basic_Margin(Left+right.Left, Top+right.Top, Right+right.Right, Bottom+right.Bottom);
        }
 
        basic_Margin operator -(const basic_Margin &right) const {
            return basic_Margin(Left-right.Left, Top-right.Top, Right-right.Right, Bottom-right.Bottom);
        }
 
        basic_Margin &operator +=(const basic_Margin &right) {
            Left+=right.Left;
            Top+=right.Top;
            Right+=right.Right;
            Bottom+=right.Bottom;
 
            return *this;
        }
 
        basic_Margin &operator -=(const basic_Margin &right) {
            Left-=right.Left;
            Top-=right.Top;
            Right-=right.Right;
            Bottom-=right.Bottom;
 
            return *this;
        }
 
        bool operator ==(const basic_Margin &margin) const {
            return Left==margin.Left && Right==margin.Right && Top==margin.Top && Bottom==margin.Bottom;
        }
 
        bool operator !=(const basic_Margin &margin) const {
            return Left!=margin.Left || Right!=margin.Right || Top!=margin.Top || Bottom!=margin.Bottom;
        }
 
        basic_Margin AddToLeft(T_ width,basic_Margin Margin=0) {
            return basic_Margin(Left+Margin.TotalX()+width, Top, Right, Bottom);
        }
        
        basic_Margin AddToTop(T_ height,const basic_Margin &Margin=0) {
            return basic_Margin(Left, Top+Margin.TotalY()+height, Right, Bottom);
        }
 
        basic_Margin AddToRight(T_ width,basic_Margin Margin=0) {
            return basic_Margin(Left, Top, Right+Margin.TotalX()+width, Bottom);
        }
 
        basic_Margin AddToBottom(T_ height,basic_Margin Margin=0) {
            return basic_Margin(Left, Top, Right, Bottom+Margin.TotalY()+height);
        }
 
        basic_Point<T_> TopLeft() const {
            return {Left, Top};
        }
 
        T_ Left;
        
        T_ Top;
        
        T_ Right;
        
        T_ Bottom;
    };
 
    template <typename T_, typename R_>
    basic_Size<T_> operator +(const basic_Size<T_> &s, const basic_Margin<R_> &m) {
        return basic_Size<T_>(s.Width+m.TotalX(), s.Height+m.TotalY());
    }
 
    template <typename T_, typename R_>
    basic_Size<T_> operator -(const basic_Size<T_> &s, const basic_Margin<R_> &m) {
        return basic_Size<T_>(s.Width-m.TotalX(), s.Height-m.TotalY());
    }
 
    template <typename T_, typename R_>
    basic_Margin<T_> operator -(const basic_Bounds<T_> &b1, const basic_Bounds<R_> &b2) {
        return basic_Margin<T_>(
            b2.Left-b1.Left, b2.Top-b1.Top, b1.Right-b2.Right, b1.Bottom-b2.Bottom
        );
    }
 
    template <typename T_, typename R_>
    basic_Bounds<T_> operator +(const basic_Bounds<T_> &b, const basic_Margin<R_> &m) {
        return basic_Bounds<T_>(
            b.Left-m.Left, b.Top-m.Top, b.Right+m.Right, b.Bottom+m.Bottom
            );
    }
 
    template <typename T_, typename R_>
    basic_Bounds<T_> operator -(const basic_Bounds<T_> &b, const basic_Margin<R_> &m) {
        return basic_Bounds<T_>(
            b.Left+m.Left, b.Top+m.Top, b.Right-m.Right, b.Bottom-m.Bottom
        );
    }
 
    template <class T_>
    std::ostream &operator << (std::ostream &out, const basic_Margin<T_> &Margin) {
        out<<"("<<Margin.Left<<", "<<Margin.Right<<", "<<Margin.Top<<", "<<Margin.Bottom<<")";
 
        return out;
    }
    
    template <class T_>
    std::istream &operator >> (std::istream &in, basic_Margin<T_> &Margin) {
        while(in.peek()==' ' || in.peek()=='(')
            in.ignore(1);
 
        std::string s;
        std::stringstream ss;
 
        while(in.peek()!=',' && !in.eof())
            s.append(1, (char)in.get());
 
        in.ignore(1);
 
        ss.str(s);
        ss>>Margin.Left;
 
        s="";
 
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        while(in.peek()!=',' && !in.eof())
            s.append(1, (char)in.get());
 
        in.ignore(1);
 
        ss.str(s);
        ss.clear();
        ss>>Margin.Top;
 
        s="";
 
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        while(in.peek()!=',' && !in.eof())
            s.append(1, (char)in.get());
 
        in.ignore(1);
 
        ss.str(s);
        ss.clear();
        ss>>Margin.Right;
 
        s="";
 
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        while(in.peek()!='>' && in.peek()!=' ' && in.peek()!='\t' && in.peek()!='\n' && in.peek()!='\r' && !in.eof())
            s.append(1, in.get());
 
 
        ss.str(s);
        ss.clear();
        ss>>Margin.Bottom;
 
        if(in.peek()==')')
            in.ignore(1);
 
        return in;
    }
 
 
    typedef basic_Margin<int> Margin;
} }