CORE_Color.h

Go to the documentation of this file.

#ifndef CORE_Color_H
#define CORE_Color_H


#include <string>
#include "CORE_Object.h"
#include "CORE_Pointers.h"
#include "CORE_ListPointers.h"
#include "types.h"


DEFINE_SPTR(CORE_Color)
class CORE_Color : public CORE_Object  {
    SP_OBJECT(CORE_Color);



private: 
    // ATTRIBUTES
    static const tString DEFAULT_COLORS[];
    static const int DEFAULT_COLORS_NUMBER;
    static int DEFAULT_COLOR_INDEX; 
  
    int mValue;
    int mOpacity;
    static double FACTOR;
    // ASSOCIATIONS
  
  
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    CORE_Color(int r,int g,int b);
    CORE_Color(int r,int g,int b,int a);
    CORE_Color(int rgb);
    CORE_Color(const tString& str);
    CORE_Color();
  
  
    // DESTRUCTORS 
  

    virtual ~CORE_Color(void);
  
public:     
  
    inline static SP::CORE_Color New(int r,int g,int b){
        SP::CORE_Color p(new CORE_Color(r,g,b),CORE_Color::Delete());
        p->setThis(p);
        return p;
    };
  
    inline static SP::CORE_Color New(int r,int g,int b,int a){
        SP::CORE_Color p(new CORE_Color(r,g,b,a),CORE_Color::Delete()); 
        p->setThis(p);
        return p;
    }; 
    inline static SP::CORE_Color New(int rgb){
        SP::CORE_Color p(new CORE_Color(rgb),CORE_Color::Delete()); 
        p->setThis(p);
        return p;
    }; 
    inline static SP::CORE_Color New(){
        SP::CORE_Color p(new CORE_Color(),CORE_Color::Delete()); 
        p->setThis(p);
        return p;
    }; 
    inline static SP::CORE_Color New(const tString& value){
        SP::CORE_Color p(new CORE_Color(value),CORE_Color::Delete()); 
        p->setThis(p);
        return p;
    };
    inline static SP::CORE_Color New(const CORE_Color& c){
        SP::CORE_Color p(new CORE_Color(c.getRed(),c.getGreen(),c.getBlue()),CORE_Color::Delete()); 
        p->setThis(p);
        return p;     
    };
    inline static SP::CORE_Color NewDefaultColor(const tBoolean& variing) {
        return New(getDefaultColorString(variing));
   
    };
    inline static SP::CORE_Color NewDefaultColor() {
        return NewDefaultColor(false);
    }; 
    inline static SP::CORE_Color NewDefaultColor(const int& index,
                                                 const tBoolean& variing) {
        return New(getDefaultColorString(index,
                                         variing));
    };
  
  
    inline void setBlack() {setColor(0,0,0);};
    inline void setWhite() {setColor(255,255,255);};
    inline void setRed() {setColor(255,0,0);};
    inline void setGreen() {setColor(0,255,0);};
    inline void setBlue() {setColor(0,0,255);};
    inline void setOrange() { setColor(255,108,0);};
    inline void setYellow() { setColor("#ffff00");};
    inline void setCyan() { setColor("#00ffff");};
    inline void setPurple() { setColor("#800080");};
    inline void setPink() { setColor("#FD6C9E");};
    
    
    // OPERATORS

    tBoolean isEquals(const SPC::CORE_Color& x) {
        return (x->getRGB()==getRGB());
    }
  
    // SET methosd
    inline void setOpacity(const int& opacity) {mOpacity=opacity;}
 

    // GET methods  

  
    inline int getOpacity() const {return mOpacity;};

    inline static tString getDefaultColorString(const tBoolean& variing) { 
        tString c=DEFAULT_COLORS[DEFAULT_COLOR_INDEX];
        if (variing) 
            DEFAULT_COLOR_INDEX=(DEFAULT_COLOR_INDEX+1)%DEFAULT_COLORS_NUMBER;
        return c;
    };

    inline static tString getDefaultColorString(const int& index) { 
        return getDefaultColorString(index,false);
    
    }; 
    inline static tString getDefaultColorString(const int& index,
                                                const tBoolean& variing) { 
        DEFAULT_COLOR_INDEX=index%DEFAULT_COLORS_NUMBER;
        return getDefaultColorString(variing);
    
    }; 
    inline static tString getDefaultColorString() { 
        return getDefaultColorString(false);
    };

  
 
    unsigned char * getRGBToArray() const;
    int getRed() const; 
    int getGreen() const;
    int getBlue() const;
    int getAlpha() const;
    int getRGB() const;

    inline void getRGBColor(double& r,double& g,double& b) const {
        r=((double)getRed())/((double)255.0);
        b=((double)getBlue())/((double)255.0);
        g=((double)getGreen())/((double) 255.0);
    };
    inline void getRGBColor(int& r,int& g,int& b) const {
        r=getRed();
        b=getBlue();
        g=getGreen();
    };
    inline void getRGBColor(int& r,int& g,int& b,int& opacity) const {
        r=getRed();
        b=getBlue();
        g=getGreen();
        opacity=getOpacity();
    };
  
  
  
    // OTHERS methods 
    void darker(const SP::CORE_Color& color) const;
    void brighter(const SP::CORE_Color& color) const;
  
    virtual string toString() const {
        return toString("color[r,g,b]");
    }
    inline string name() const {
        return toString("color[r,g,b,a]");
    }

    string toString(const tString& format) const;
  
    void setColor(const SPC::CORE_Color& c);
    void setColor(const SPC::CORE_Color* c){
        if (c!=null) setColor(*c);
    }; 
    inline void setColor(const CORE_Color& c) {
        setColor(c.toString());
    };
    inline void setColor(const CORE_Color* c) {
        if (c!=null) setColor(c->toString());
    };
    void setColor(const tString& c);
    
    void setColor(const SPC::CORE_Color& c0,const SPC::CORE_Color& c1,float f); 
    void setColor(int r,int g,int b); 
    inline void setColor(double r,double g,double b) {
        setColor((int) r*255,(int) g*255,(int) b*255);
    };
    inline void setRGB(const int& rgb) { 
        mValue = 0xff000000 | rgb;
    };
    inline void toColor(const tReal& tau,
                        const SPC::CORE_Color& fromColor,
                        const SP::CORE_Color& color) const {
        toColor(tau,*fromColor.get(),*color.get());
    };
    void toColor(const tReal& tau,
                 const CORE_Color& fromColor,
                 CORE_Color& color) const;
 


private:
    static tBoolean testColorValueRange(int r, int g, int b, int a);

  
            
  
};

#endif