ZXColors.h

Go to the documentation of this file.

 
/* **************************************************************************/
#ifndef ZXCOLORS
#define ZXCOLORS
 
#include <vector>
#include "zxecosystem/ancillary/ColorImages.h"
#include "zxecosystem/ancillary/CppAddons.h"
 
namespace zxeco
{
 
/* ***************************************************************************
*
*    Color system for the screen
*
*    We have different types of color classes (plus some commodity constants).
*
*******************************************************************************/
 
/* ------------------------------ Constants --------------------------------- */
 
enum ColorBaseType: uint8_t {
    BLACK = 0, BLUE, RED, MAGENTA, GREEN, CYAN, YELLOW, WHITE,
    NUMBASICCOLORS, 
 
    TRANSPARENT = NUMBASICCOLORS,
    CONTRAST,
    NUMPRINTCOLORS
     };
 
enum ColorModVal: uint8_t {
        OFF = 0, ON = 1, 
        TRANSP = TRANSPARENT, 
    };
 
 
extern const RGBPalette kZXPalette; 
 
 
/* ------------------------------ Flash, Bright, Inverse, Over -------------- */
 
class Flash
{
 public:
 
    explicit Flash(ColorModVal cmv);
    explicit Flash(bool f = true):val_{static_cast<ColorModVal>(f)} {}
 
    operator ColorModVal(void) const noexcept { return(val_); }
 
 
 private:
 
    ColorModVal val_;
};
 
 
class Bright
{
 public:
 
    explicit Bright(ColorModVal cmv);
    explicit Bright(bool b = true):val_{static_cast<ColorModVal>(b)} {}
 
    operator ColorModVal(void) const noexcept { return(val_); }
 
 
 private:
 
    ColorModVal val_;
};
 
 
class Inverse
{
 public:
 
    explicit Inverse(ColorModVal cmv);
    explicit Inverse(bool i = true):val_{static_cast<ColorModVal>(i)} {}
 
    operator ColorModVal(void) const noexcept { return(val_); }
 
 
 private:
 
    ColorModVal val_;
};
 
 
class Over
{
 public:
 
    explicit Over(ColorModVal cmv);
    explicit Over(bool o = true):val_{static_cast<ColorModVal>(o)} {}
 
    operator ColorModVal(void) const noexcept { return(val_); }
 
 
 private:
 
    ColorModVal val_;
};
 
 
 
/* ----------------------------- BasicColor --------------------------------- */
 
class BasicColor
{
 public:
 
    BasicColor(ColorBaseType cbt = BLACK);
 
        /* --------------- Methods ------------------ */
 
    operator ColorBaseType(void) const noexcept { return(color_); }
 
    BasicColor contrasting(void) const noexcept
        { return(BasicColor{ color_ > MAGENTA ? BLACK : WHITE }); }
 
    void setNext(bool circular = true);
 
    std::string to_string(void) const;
 
 private:
 
    ColorBaseType color_;
};
 
 
/* ------------------------------ BrightColor ---------------------------- */
 
 
class BrightColor
{
 public:
 
        /* -------------- Types, consts., etc. ------------------- */
 
    static constexpr RGBPalette::Size NUMLINEARCOLORS = NUMBASICCOLORS * 2;
 
    static constexpr RGBPalette::Index FIRSTLINEARCOLORWBRIGHT = NUMBASICCOLORS;
    
        /* -------------- Constructors ------------------- */
 
    BrightColor(BasicColor bc = BLACK, bool br = false):    basicc_{bc},
                                                            brightc_{br} {}
 
    BrightColor(RGBPalette::Index li);
 
    BrightColor(const RGBColor & col): 
                BrightColor{static_cast<RGBPalette::Index>(
                                            kZXPalette.closestColor(col))} {}
 
        /* -------------- Methods ------------------- */
 
    BasicColor color(void) const noexcept { return(basicc_); }
 
    bool bright(void) const noexcept { return(brightc_); }
    
    RGBPalette::Index linear(void) const noexcept
        { return( static_cast<RGBPalette::Index>(basicc_) +
                  (brightc_ ? FIRSTLINEARCOLORWBRIGHT : 0));}
 
    const RGBColor & rgbColor(void) const noexcept 
        { return(kZXPalette[linear()]); }
 
    std::string to_string(void) const;
 
 private:
 
    BasicColor basicc_; // not using bitfields for some implementation-dependent
    bool brightc_; // traits of that language construct
};
 
 
/* ------------------------------ PrintColor, Paper, Ink -------------------- */
 
class PrintColor
{
 public:
 
    PrintColor(ColorBaseType cbt = BLACK);
 
    PrintColor(const BasicColor & bc) noexcept:
                                PrintColor{static_cast<ColorBaseType>(bc)} {}
 
        /* --------------- Methods ------------------ */
 
    operator ColorBaseType(void) const noexcept { return(color_); }
 
    BasicColor basic(void) const;
 
    bool isBasic(void) const noexcept { return(color_ < NUMBASICCOLORS); }
 
    std::string to_string(void) const;
 
 private:
 
    ColorBaseType color_;
};
 
 
class Paper: public PrintColor
{
 public:
 
    explicit Paper(PrintColor p):PrintColor{p} {}
};
 
 
class Ink: public PrintColor
{
 public:
 
    explicit Ink(PrintColor p):PrintColor{p} {}
};
 
 
/* ------------------------------ AttrColors ------------------------------- */
 
 
class AttrColors 
{
 public:
 
        /* -------------- Constructors ------------------- */
 
    AttrColors(void): flashc_{OFF},brightc_{OFF},paperc_{WHITE},inkc_{BLACK} {}
 
    AttrColors(Flash f, Bright b, Paper p, Ink i):  flashc_{f},
                                                    brightc_{b},
                                                    paperc_{p},
                                                    inkc_{i} {}
 
    AttrColors(uint8_t attr);
 
        /* -------------- Methods ------------------- */
 
    uint8_t toAttr(void) const;
 
    ColorModVal flash(void) const noexcept { return(flashc_); }
 
    ColorModVal bright(void) const noexcept { return(brightc_); }
 
    PrintColor paper(void) const noexcept { return(paperc_); }
 
    PrintColor ink(void) const noexcept { return(inkc_); }
 
    bool rgb(RGBColor & ink, RGBColor & paper) const;
 
    void setFlash(ColorModVal f) noexcept { flashc_ = f; }
 
    void setFlash(bool f = true) noexcept 
        { flashc_ = static_cast<ColorModVal>(f); }
 
    void setBright(ColorModVal b) noexcept { brightc_ = b; }
 
    void setBright(bool b = true) noexcept 
        { brightc_ = static_cast<ColorModVal>(b); }
 
    void setPaper(PrintColor p) noexcept { paperc_ = p; }
 
    void setInk(PrintColor i) noexcept { inkc_ = i; }
 
    void swapPaperAndInk(void) noexcept { std::swap(paperc_,inkc_); }
 
    AttrColors swapped(void) const noexcept 
        { AttrColors res{*this}; res.swapPaperAndInk(); return(res); }
 
    void adjustByExisting(const AttrColors & ex);
 
    std::string to_string(bool shorttxt = false) const;
 
 private:
 
    ColorModVal flashc_;
    ColorModVal brightc_;
    PrintColor paperc_;
    PrintColor inkc_; 
};
 
 
/* ------------------------------ Colors --------------------------- */
 
 
class Colors: public AttrColors
{
 public:
 
    Colors(void): AttrColors{},inv_{OFF},ov_{OFF} {}
 
    Colors(AttrColors cc, Inverse inv, Over ov): AttrColors{cc},
                                                 inv_{inv},ov_{ov} {}
 
 
    ColorModVal inverse(void) const noexcept { return(inv_); }
 
    void setInverse(ColorModVal inv) noexcept { inv_ = inv; }
 
    void setInverse(bool i = true) noexcept 
        { inv_ = static_cast<ColorModVal>(i); }
 
    ColorModVal over(void) const noexcept { return(ov_); }
 
    void setOver(ColorModVal ov) noexcept { ov_ = ov; }
    
    void setOver(bool o = true) noexcept { ov_ = static_cast<ColorModVal>(o); }
 
    Colors & operator<<(Paper p) noexcept { setPaper(p); return(*this); }
    Colors & operator<<(Ink i) noexcept { setInk(i); return(*this); }
    Colors & operator<<(Bright b) noexcept { setBright(b); return(*this); }
    Colors & operator<<(Flash f) noexcept { setFlash(f); return(*this); }
    Colors & operator<<(Inverse f) noexcept { setInverse(f); return(*this); }
    Colors & operator<<(Over o) noexcept { setOver(o); return(*this); }
 
    std::string to_string(void) const
        { return("Colors " + AttrColors::to_string() + ", inverse " +
                 (inv_ == ON ? "ON" : "OFF") + ", over " + 
                 (ov_ == ON ? "ON" : "OFF")); }                                                    
 
 private:
 
    ColorModVal inv_;
    ColorModVal ov_;
};
 
 
 
} // end namespace zxeco
 
#endif
 // ZXColors