cairocoloraccumulator.h

Go to the documentation of this file.

/* === S Y N F I G ========================================================= */
/* ========================================================================= */

#ifndef __SYNFIG_COLOR_CAIROCOLORACUMULATOR_H
#define __SYNFIG_COLOR_CAIROCOLORACUMULATOR_H

#include <synfig/color/common.h>

namespace synfig {

class CairoColor;

class CairoColorAccumulator
{
    friend class CairoColor;
public:
    typedef float value_type;
    
private:
    value_type a_, r_, g_, b_;
    
public:
    
    CairoColorAccumulator &
    operator+=(const CairoColorAccumulator &rhs)
    {
        r_+=rhs.r_;
        g_+=rhs.g_;
        b_+=rhs.b_;
        a_+=rhs.a_;
        return *this;
    }
    
    CairoColorAccumulator &
    operator-=(const CairoColorAccumulator &rhs)
    {
        r_-=rhs.r_;
        g_-=rhs.g_;
        b_-=rhs.b_;
        a_-=rhs.a_;
        return *this;
    }
    
    CairoColorAccumulator &
    operator*=(const float &rhs)
    {
        r_*=rhs;
        g_*=rhs;
        b_*=rhs;
        a_*=rhs;
        return *this;
    }
    
    CairoColorAccumulator &
    operator/=(const float &rhs)
    {
        const float temp(value_type(1)/rhs);
        r_*=temp;
        g_*=temp;
        b_*=temp;
        a_*=temp;
        return *this;
    }
    
    CairoColorAccumulator
    operator+(const CairoColorAccumulator &rhs)const
    { return CairoColorAccumulator(*this)+=rhs; }
    
    CairoColorAccumulator
    operator-(const CairoColorAccumulator &rhs)const
    { return CairoColorAccumulator(*this)-=rhs; }
    
    CairoColorAccumulator
    operator*(const float &rhs)const
    { return CairoColorAccumulator(*this)*=rhs; }
    
    CairoColorAccumulator
    operator/(const float &rhs)const
    { return CairoColorAccumulator(*this)/=rhs; }
    
    bool
    operator==(const CairoColorAccumulator &rhs)const
    { return r_==rhs.r_ && g_==rhs.g_ && b_==rhs.b_ && a_!=rhs.a_; }
    
    bool
    operator!=(const CairoColorAccumulator &rhs)const
    { return r_!=rhs.r_ || g_!=rhs.g_ || b_!=rhs.b_ || a_!=rhs.a_; }
    
    CairoColorAccumulator
    operator-()const
    { return CairoColorAccumulator(-r_,-g_,-b_,-a_); }
    
    bool is_valid()const
    { return !isnan(r_) && !isnan(g_) && !isnan(b_) && !isnan(a_); }
    
public:
    CairoColorAccumulator(): a_(), r_(), g_(), b_() { }
    
    CairoColorAccumulator(const value_type& R, const value_type& G, const value_type& B, const value_type& A=1):
    a_(A),
    r_(R),
    g_(G),
    b_(B) { }
    
    CairoColorAccumulator(const CairoColorAccumulator& c):
    a_(c.a_),
    r_(c.r_),
    g_(c.g_),
    b_(c.b_) { }
    
    CairoColorAccumulator(const CairoColor& c):
    a_(c.get_a()/CairoColor::range),
    r_(c.get_r()/CairoColor::range),
    g_(c.get_g()/CairoColor::range),
    b_(c.get_b()/CairoColor::range) { }
    
    CairoColorAccumulator(int c): a_(c),r_(c), g_(c), b_(c) { }
    
    const value_type& get_r()const { return r_; }
    
    const value_type& get_g()const { return g_; }
    
    const value_type& get_b()const { return b_; }
    
    const value_type& get_a()const { return a_; }
    
    const value_type& get_alpha()const { return get_a(); }
    
    CairoColorAccumulator& set_r(const value_type& x) { r_ = x; return *this; }
    
    CairoColorAccumulator& set_g(const value_type& x) { g_ = x; return *this; }
    
    CairoColorAccumulator& set_b(const value_type& x) { b_ = x; return *this; }
    
    CairoColorAccumulator& set_a(const value_type& x) { a_ = x; return *this; }
    
    CairoColorAccumulator& set_alpha(const value_type& x) { return set_a(x); }
};


} // synfig namespace

#endif // __SYNFIG_COLOR_CAIROCOLORACUMULATOR_H