faithcore/faith/color.h

Go to the documentation of this file.

#ifndef KDE__COLOR_H
#define KDE__COLOR_H

#include <faith/image.h>
#include <faith/tools.h>
#include <faith/core.h>
#include <faith/core.h>
#ifdef WIN32
#include <windows.h>
#endif

namespace Faith
{


class FAITH_CORE_EXPORT Color
{
#ifdef WIN32
        COLORREF color;
#else
        static int depth;
        static int cmapSize;

        static void (Color::*allocator)() const;


        enum State
        {
                Invalid,
                Valid,
                Allocated
        };

        mutable State mState;

        Faith::Rgb color;

        mutable unsigned int pix;
#endif
public:
        enum Spec {Rgb, Hsv};

        Color();

        Color(int r, int g, int b);

        Color(int x, int y, int z, Spec colorSpec);

        Color(Faith::Rgb rgb, unsigned int pixel = 0xffffffff);

        Color(const Color &col);


        Color &operator = (const Color &col);


/*
*/
        inline void rgb(int *red, int *green, int *blue) const
        {
#ifdef WIN32
                *red = GetRValue(color);
                *green = GetGValue(color);
                *red = GetRValue(color);
#else
                *red = qRed(color);
                *green = qGreen(color);
                *blue = qBlue(color);
#endif
        }

        inline Faith::Rgb rgb() const
        {
                return (Faith::Rgb)color;
        }

        inline void setRgb(int red, int green, int blue)
        {
                setRgb(qRgb(red, green, blue));
        }

        void setRgb(Faith::Rgb rgb);

        inline int red() const
        {
#ifdef WIN32
                return GetRValue(color);
#else
                return qRed(color);
#endif
        }

        inline int green() const
        {
#ifdef WIN32
                return GetGValue(color);
#else
                return qGreen(color);
#endif
        }

        inline int blue() const
        {
#ifdef WIN32
                return GetBValue(color);
#else
                return qBlue(color);
#endif
        }

        void hsv(int *hue, int *sat, int *value) const;


        void setHsv(int hue, int sat, int value);

        inline Color light(int f = 150) const
        {
                int h, s, v;
                hsv(&h, &s, &v);
                return Color(h, s, v*f / 100, Hsv);
        }

        inline Color dark(int f = 200) const
        {
                int h, s, v;
                hsv(&h, &s, &v);
                return Color(h, s, v*100 / f, Hsv);
        }

        bool operator == (const Color & c) const;

        inline bool operator!=(const Color & c) const
        {
                return !operator==(c);
        }

#ifdef WIN32
        inline COLORREF pixel() const
        {
                return color;   
        }
#else
        inline unsigned int pixel() const
        {
                alloc();
                return pix;
        }
#endif

        static void initialize();

        static void cleanup();

private:
#ifndef WIN32

        enum { INVALID = 1, UNALLOCATED = 2, FIXED = 4 };


        void truecolor24_alloc() const;
        void truecolor16_alloc() const;

        void truecolor_copy(const Color &col, bool del) const;

        void truecolor_dealloc() const;

        void alloc() const;
        inline bool isDirty() const
        {
                return mState <= Valid;
        }
        
        inline bool isValid() const
        {
                return mState >= Valid;
        }
        
#endif
};

extern Color black, white, darkGray, gray, lightGray, red, green, blue, cyan;
extern Color magenta, yellow, darkRed, darkGreen, darkBlue, darkCyan, darkMagenta;
extern Color darkYellow, color0, color1;

}

#endif

---