cell.hh

Go to the documentation of this file.

#ifndef bqtCellHH
#define bqtCellHH
#include <cstdint>
#include <cstring>
 
struct Cell
{
    // 24-bit color foreground,background = 48 bits total
    // 32-bit character
    std::uint_least32_t fgcolor;            
    std::uint_least32_t bgcolor;            
    char32_t            ch;                 
    bool                bold: 1;            
    bool                dim: 1;             
    bool                italic: 1;          
    bool                underline: 1;       
    bool                underline2: 1;      
    bool                overstrike: 1;      
    bool                inverse: 1;         
    bool                framed: 1;          
    bool                encircled: 1;       
    bool                overlined: 1;       
    bool                fraktur: 1;         
    bool                conceal: 1;         
    unsigned char       render_size: 2;     
    unsigned char       blink: 2;           
 
    unsigned char       scriptsize: 2;      
    bool                proportional: 1;    
    bool                ideo_underline:  1; 
    bool                ideo_underline2: 1; 
    bool                ideo_overline:  1;  
    bool                ideo_overline2: 1;  
    bool                ideo_stress: 1;     
    unsigned padding: 6;                    
 
    bool                protect: 1;         
    bool                dirty: 1;           
 
    /* Total size: 4 * 32 bits = 128 bits (16 bytes) */
 
    /* Constructor: Initializes the object with default attributes.
     * Sets the character as a space, color as light-gray on black, and the dirty flag.
     */
    Cell()
    {
        std::memset(this, 0, sizeof(Cell));
        fgcolor = 0xCCCCCC;
        bgcolor = 0x000000;
        ch      = U' ';
        dirty   = true;
    }
 
    bool operator== (const Cell& b) const
    {
        Cell tmp1 = *this;
        Cell tmp2 = b;
        tmp1.dirty = false; tmp1.protect = false;
        tmp2.dirty = false; tmp2.protect = false;
        return std::memcmp(&tmp1, &tmp2, sizeof(Cell)) == 0;
        /*
        return std::tuple(fgcolor,bgcolor,ch,bold,dim,italic,
                          underline,underline2,overstrike,inverse,blink,
                          framed,encircled,fraktur,conceal,overlined,
                          scriptsize,proportional,
                          ideo_underline,ideo_underline2,ideo_overline,ideo_overline2,ideo_stress,
                          render_size)
            == std::tuple(b.fgcolor,b.bgcolor,b.ch,b.bold,b.dim,b.italic,
                          b.underline,b.underline2,b.overstrike,b.inverse,b.blink,
                          b.framed,b.encircled,b.fraktur,b.conceal,b.overlined,
                          b.scriptsize,b.proportional,
                          b.ideo_underline,b.ideo_underline2,b.ideo_overline,b.ideo_overline2,b.ideo_stress,
                          b.render_size);
        */
    }
 
    bool operator!= (const Cell& b) const
    {
        return !operator==(b);
    }
};
 
#endif