ucolor.hpp

/* ***********************************************************************
 *
 *  ucolor.hpp: Color Attribute
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | http://www.enst.fr/~elc/ubit
 *
 * ***********************************************************************
 * COPYRIGHT NOTICE : 
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
 * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
 * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
 * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
 * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
 * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
 * ***********************************************************************/
#ifndef _ucolor_hpp_
#define _ucolor_hpp_ 1
#include <string.h>
#include <ubit/uattr.hpp>
namespace ubit {
  
  class URgba {
  public:
    URgba() {comps[0] = comps[1] = comps[2] = 0; comps[3] = 255u;}
        
    URgba(unsigned int r, unsigned int g, unsigned int b, unsigned int a = 255u) 
    {comps[0] = r; comps[1] = g; comps[2] = b; comps[3] = a;}
    
    URgba(float r, float g, float b, float a = 1.0f) {setRgbaF(r,g,b,a);}

    void setRgbaI(unsigned int r, unsigned int g, unsigned int b, unsigned int a = 255u) 
    {comps[0] = r; comps[1] = g; comps[2] = b; comps[3] = a;}
    
    void setRgbaF(float r, float g, float b, float a = 1.0f);

    bool operator==(const URgba& c) const {
      return (comps[0]==c.comps[0] && comps[1]==c.comps[1] 
              && comps[2]==c.comps[2] && comps[3]==c.comps[3]);
    }    

    //bool equals(unsigned int r, unsigned int g, unsigned int b, unsigned int a) const {
    //return components[0]==r && components[1]==g && components[2]==b && components[3]==a;}
    
    //bool equals(float r, float g, float b, float a) const;

    unsigned int getRedI()   const {return comps[0];}
    unsigned int getGreenI() const {return comps[1];}
    unsigned int getBlueI()  const {return comps[2];}
    unsigned int getAlphaI() const {return comps[3];}
    
    void setRedI(unsigned int c)   {comps[0] = c;}
    void setGreenI(unsigned int c) {comps[1] = c;}
    void setBlueI(unsigned int c)  {comps[2] = c;}
    void setAlphaI(unsigned int c) {comps[3] = c;}
    
    unsigned char comps[4];  // must be compatible with GLubyte
  };
  
  
  class UColor : public UAttr {
  public:
    UCLASS(UColor)
    
    static UColor none, inherit, white, black, grey, lightgrey, darkgrey, 
    navy, lightblue, blue, red, green, yellow, orange, wheat, teal, disabled;
    UColor();
    
    UColor(const UColor& color);
        
    UColor(const UColor& color, float a);

    UColor(const UColor& color, unsigned int a);

    UColor(const URgba&);
    
    UColor(float r, float g, float b, float a = 1.0f);
    UColor(unsigned int r, unsigned int g, unsigned int b, unsigned int a = 255u);
    UColor(const UStr& color_name, float a = 1.);

    ~UColor();
    
    UColor& operator=(const UColor& c);

    UColor& setRgba(const URgba&);
         
    UColor& setRgbaF(float r, float g, float b, float a = 1.0f);
    
    UColor& setRgbaI(unsigned int r, unsigned int g, unsigned int b, unsigned int a=255u);
    
    UColor& setNamedColor(const UStr& color_name, float a = 1.);
    const URgba& getRgba() const {return rgba;}
     
    bool operator==(const UColor& c) const {return equals(c);}
    bool operator!=(const UColor& c) const {return !equals(c);}
    
    virtual bool equals(const UColor&) const;
    virtual bool equals(const URgba&) const;
    virtual bool equals(float r, float g, float b, float a) const;
    virtual bool equals(unsigned int r, unsigned int g, unsigned int b, unsigned int a) const;
    
    virtual void update();  // redefinition

    virtual void putProp(UUpdateContext*, UElem&);   // redefinition
    
    static void addNamedColor(const char* name, const URgba&);
    
    static bool parseColor(const char* name, URgba&);
    
    // - - - impl - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  protected:
    friend class UGraph;
    URgba rgba;
#if WITH_2D_GRAPHICS
    mutable std::vector<unsigned long> pixels;
    void unsetPixels();
    unsigned long getPixel(UDisp*) const;
#endif
    UColor(unsigned int r, unsigned int g, unsigned int b, unsigned int a, UConst);
    //[Impl] creates a new CONSTANT color with a RGB value; @see UObject::UCONST.
    
    UColor(unsigned char special, UConst);
    //[Impl] creates a new CONSTANT color with a special value; @see UObject::UCONST.
    
#endif
  };
  
  
  inline UColor& ucolor() {return *new UColor();}
  
  inline UColor& ucolor(float r, float g, float b, float a = 1.) 
  {return *new UColor(r,g,b,a);}
  
  inline UColor& ucolor(unsigned int r, unsigned int g, unsigned int b, unsigned int a = 255) 
  {return *new UColor(r,g,b,a);}
  
  inline UColor& ucolor(const UStr& color_name, float alpha = 1.) 
  {return *new UColor(color_name, alpha);}

}
#endif