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
    
    //default color string
    static const tString DEFAULT_COLORS[];
    //number of default color
    static const tFlag  DEFAULT_COLORS_NUMBER;
    //default color index
    static tFlag DEFAULT_COLOR_INDEX; 

    //value of the color
    tUInt  mValue;

    //opacity of the color
    tUChar mOpacity;

    //factor for darker or lighter transformation
    static tFloat FACTOR;
    
    // ASSOCIATIONS
  
  
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    CORE_Color(const tUChar& r,const tUChar& g,const tUChar& b);
    CORE_Color(const tUChar& r,const tUChar& g,const tUChar& b,const tUChar& a);
    CORE_Color(const tUInt& rgb);
    CORE_Color(const tString& str);
    CORE_Color();
  
  
    // DESTRUCTORS 
  

    virtual ~CORE_Color(void);
  
public:     
  
    inline static SP::CORE_Color New(const tUChar& r,const tUChar& g,const tUChar& 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(const tUChar& r,const tUChar& g,const tUChar& b,const tUChar& 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(const tUInt& 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 tFlag& index,
                                                 const tBoolean& variing) {
        return New(getDefaultColorString(index,
                                         variing));
    };
  
  
    inline void setBlack() {setColor((tUChar)0,(tUChar)0,(tUChar)0);};
    inline void setWhite() {setColor((tUChar)255,(tUChar)255,(tUChar)255);};
    inline void setRed() {setColor((tUChar)255,(tUChar)0,(tUChar)0);};
    inline void setGreen() {setColor((tUChar)0,(tUChar)255,(tUChar)0);};
    inline void setBlue() {setColor((tUChar)0,(tUChar)0,(tUChar)255);};
    inline void setOrange() { setColor((tUChar)255,(tUChar)108,(tUChar)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 tUChar& opacity) {mOpacity=opacity;}
 
    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,const tFloat&  f); 
    void setColor(const tUChar& r,const tUChar& g,const tUChar& b); 
    inline void setColor(const tFloat& r,const tFloat& g,const tFloat& b) {
        setColor((tUChar) (r*255),(tUChar) (g*255),(tUChar) (b*255));
    };
     
    inline void setRGB(const tUInt& rgb) { 
        mValue = 0xff000000 | rgb;
    };
    inline void toColor(const tFloat& tau,
                        const SPC::CORE_Color& fromColor,
                        const SP::CORE_Color& color) const {
        toColor(tau,*fromColor.get(),*color.get());
    };
    void toColor(const tFloat& tau,
                 const CORE_Color& fromColor,
                 CORE_Color& color) const;
 
    // GET methods  

  
    inline const tUChar& 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 tFlag& index) { 
        return getDefaultColorString(index,false);
        
    }; 
    inline static tString getDefaultColorString(const tFlag& index,
                                                const tBoolean& variing) { 
        DEFAULT_COLOR_INDEX=index%DEFAULT_COLORS_NUMBER;
        return getDefaultColorString(variing);
    
    }; 
    inline static tString getDefaultColorString() { 
        return getDefaultColorString(false);
    };

  
 
    tUChar getRed() const; 
    tUChar getGreen() const;
    tUChar getBlue() const;
    tUChar getAlpha() const;
    inline const tUInt& getRGB() const {
        return mValue;
    }

    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(tUChar& r,tUChar& g,tUChar& b) const {
        r=getRed();
        b=getBlue();
        g=getGreen();
    };
    inline void getRGBColor(tUChar& r,tUChar& g,tUChar& b,tUChar& 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;
    inline string name() const {
        return toString("color[r,g,b,a]");
    }
    
    virtual string toString() const {
        return toString("color[r,g,b]");
    }
   

    string toString(const tString& format) const;
  
  



  
            
  
};

#endif