window.hh

Go to the documentation of this file.

#ifndef bqtRenderingScreenHH
#define bqtRenderingScreenHH
#include <cstdint>
#include <vector>
#include <tuple>
#include <cstring>
 
#include "cset.hh"
#include "cell.hh"
 
struct Window
{
    std::vector<Cell> cells; 
    std::size_t       xsize; 
    std::size_t       ysize; 
    std::size_t       cursx=0; 
    std::size_t       cursy=0; 
    bool              inverse   = false;            
    bool              cursorvis = true;             
    unsigned          cursorcolor = 0xFFFFFF;       
    unsigned          mousecolor1 = 0xFFFFFF;       
    unsigned          mousecolor2 = 0xFFFFFF;       
    unsigned          mouseselectcolor = 0xFFFFFF;  
    Cell blank {}; 
private:
    std::size_t lastcursx, lastcursy;
    unsigned    lasttimer=0;
public:
    Window(std::size_t xs, std::size_t ys) : cells(xs*ys), xsize(xs), ysize(ys)
    {
        Dirtify();
    }
 
    void FillBox(std::size_t x, std::size_t y, std::size_t width, std::size_t height)
    {
        for(std::size_t h=0; h<height; ++h)
            for(std::size_t w=0; w<width; ++w)
            {
                auto tx = x+w, ty = y+h;
                PutCh(tx, ty, blank);
            }
    }
    void FillBox(std::size_t x, std::size_t y, std::size_t width, std::size_t height, Cell with)
    {
        for(std::size_t h=0; h<height; ++h)
            for(std::size_t w=0; w<width; ++w)
            {
                auto tx = x+w, ty = y+h;
                if(with.ch != blank.ch || !cells[ty*xsize+tx].protect)
                    PutCh(tx, ty, with);
            }
    }
    void CopyText(std::size_t tgtx,std::size_t tgty, std::size_t srcx,std::size_t srcy,
                                                     std::size_t width,std::size_t height)
    {
        auto hcopy_oneline = [&](std::size_t ty, std::size_t sy)
        {
            if(tgtx < srcx)
                for(std::size_t w=0; w<width; ++w)
                    PutCh(tgtx+w, ty, cells[sy*xsize+(srcx+w)]);
            else
                for(std::size_t w=width; w-- > 0; )
                    PutCh(tgtx+w, ty, cells[sy*xsize+(srcx+w)]);
        };
        if(tgty < srcy)
            for(std::size_t h=0; h<height; ++h)
                hcopy_oneline(tgty+h, srcy+h);
        else
            for(std::size_t h=height; h-- > 0; )
                hcopy_oneline(tgty+h, srcy+h);
    }
 
    void Dirtify(std::size_t x, std::size_t y)
    {
        auto& tgt = cells[y*xsize+x];
        // Write an invalid character, to make sure it gets properly
        // cleared when a valid character gets written instead.
        // This glyph must _not_ register as doublewidth.
        tgt.ch    = 0xFFFE;
        tgt.dirty = true;
    }
    void Dirtify();
 
    void PutCh(std::size_t x, std::size_t y, const Cell& c)
    {
        auto& tgt = cells[y*xsize+x];
        if(tgt != c)
        {
            tgt = c;
            tgt.dirty = true;
        }
    }
 
    void PutCh(std::size_t x, std::size_t y, char32_t c, int cset = 0)
    {
        /*
        cset options:
        0 = ascii
        1 = dec graphics
        */
        Cell ch = blank;
        if(cset)
        {
            c = TranslateCSet(c, cset);
        }
        ch.ch = c;
        ch.render_size = cells[y*xsize+x].render_size;
        /*if(c != U' ')
        {
            fprintf(stderr, "Ch at (%zu,%zu): <%c>\n", x,y, int(c));
        }*/
        PutCh(x, y, ch);
    }
    void PutCh_KeepAttr(std::size_t x, std::size_t y, char32_t c, int cset = 0)
    {
        auto& cell = cells[y*xsize+x];
        Cell temp = cell;
        if(cset)
            c = TranslateCSet(c, cset);
        if(temp != cell)
        {
            cell = temp;
            cell.dirty = true;
        }
    }
    void PutCh_KeepChar(std::size_t x, std::size_t y, const Cell& c)
    {
        auto& cell = cells[y*xsize+x];
        Cell temp = c;
        temp.ch = cell.ch;
        if(temp != cell)
        {
            cell = temp;
            cell.dirty = true;
        }
    }
 
    void Render(std::size_t fx, std::size_t fy, std::uint32_t* pixels);
 
    void Resize(std::size_t newsx, std::size_t newsy);
 
    void LineSetRenderSize(unsigned val);
};
 
#endif