DesktopInterface.h

Go to the documentation of this file.

 
/* *************************************************************************/
#ifndef DESKTOPINTERFACE
#define DESKTOPINTERFACE
 
#include <cstddef>
#include <string>
#include <memory>
#include <map>
#include <vector>
#include <list>
#include <bitset>
#include <set>
#include <algorithm>
#include <functional>
#include "zxecosystem/ancillary/ColorImages.h"
 
 
class DesktopInterface; // forward declarations. This class is the main one
class PalettizedWindow;
 
 
/* ****************************************************************************
 
    Abstract class: DesktopInterface
 
*******************************************************************************/
 
 
class DesktopInterface
{
 public:
 
    /* ------------------------- Types, consts, etc. ----------------- */
 
 
    enum KeyID { K_ESC =0, K_F1, K_F2, K_F3, K_F4, K_F5, K_F6, K_F7, K_F8, K_F9,
                 K_F10, K_F11, K_F12, K_1, K_2, K_3, K_4, K_5, K_6, K_7, K_8,
                 K_9, K_0, K_BACK, K_DEL, // back-> del prev char; del-> cur.chr
                 K_TAB, K_BEGIN, K_END,K_PGUP,K_PGDOWN,
                 K_Q, K_W, K_E, K_R, K_T, K_Y, K_U,
                 K_I, K_O, K_P, K_ENTER, K_CAPSLOCK, K_A, K_S, K_D, K_F, K_G,
                 K_H, K_J, K_K, K_L, K_CAPSLEFT, K_Z, K_X, K_C, K_V, K_B, K_N,
                 K_M, K_COMMA, K_PERIOD, K_CAPSRIGHT, K_CTRLLEFT, K_ALTLEFT,
                 K_SPACE, K_ALTRIGHT, K_CTRLRIGHT, K_LEFT, K_DOWN, K_UP,
                 K_RIGHT, K_MINUS, K_PLUS, K_DIV, K_MULT, K_BSLASH, K_UNDERS,
                 K_SQUBRO, K_SQUBRC, K_CURBRO, K_CURBRC, K_EXCL, K_DQUOTE, 
                 K_AT, K_SHARP, K_DOLLAR, K_PERC, K_AMPER, K_PARO, K_PARC,
                 K_EQUAL, K_QUEST, K_VERT, K_CIRC, K_APOST, K_LESS, K_GREAT,
                 K_SEMIC, K_COLON,
                 NUM_OF_KEY_IDS};
 
    class KeypressMap: public std::map<KeyID,bool>
    {
     public:
 
        KeypressMap(void);
 
        virtual ~KeypressMap(void) = default;
 
        // Leave the compiler to generate default copy and move constructors
        
        
        bool anyKeyPressed(void) const;
    };
 
    static const std::vector<std::string> KeyNames;
 
    static bool keyIsNumber(KeyID kid) noexcept
        { return((kid >= KeyID::K_1) && (kid <= KeyID::K_0)); }
 
    static bool keyIsLetter(KeyID kid) noexcept
        { return(((kid >= KeyID::K_Q) && (kid <= KeyID::K_P)) ||
                 ((kid >= KeyID::K_A) && (kid <= KeyID::K_L)) ||
                 ((kid >= KeyID::K_Z) && (kid <= KeyID::K_M))); }
 
    static bool keyIsFunction(KeyID kid) noexcept
        { return((kid >= KeyID::K_F1) && (kid <= KeyID::K_F12)); }
 
    static bool keyIsForMotion(KeyID kid) noexcept
        { return((kid == KeyID::K_TAB) ||
                 (kid == KeyID::K_BEGIN) || (kid == KeyID::K_END) ||
                 (kid == KeyID::K_PGUP) || (kid == KeyID::K_PGDOWN) ||
                 (kid == KeyID::K_LEFT) || (kid == KeyID::K_RIGHT) ||
                 (kid == KeyID::K_DOWN) || (kid == KeyID::K_UP)); }
    
    
    typedef std::function<double (double t, uint64_t i,
                                  unsigned l, unsigned pos)> SoundMonoProducer;
 
    static const SoundMonoProducer SilenceMonoProducer;
 
    struct SoundPlayerParms
    {
        double sampling_period; 
        unsigned sample_size; 
        SoundPlayerParms(void): SoundPlayerParms{1.0/44100.0,1024} {}
                                
        SoundPlayerParms(double sper, unsigned ss): sampling_period{sper},
                                                    sample_size{ss} { check(); }
                                
        void check(void) const;
    };
    
 
    virtual ~DesktopInterface(void) = default;
 
    DesktopInterface(const DesktopInterface &) = delete;
    DesktopInterface & operator=(const DesktopInterface &) = delete;
    DesktopInterface(const DesktopInterface &&) = delete;
    DesktopInterface & operator=(const DesktopInterface &&) = delete;
 
    virtual RGBImage readPNGImageFile(const std::string & filepath) = 0;
 
    virtual void writePNGImageFile(const RGBImage & img, 
                                   const std::string & filepath) = 0;
 
    virtual void getDesktopResolution(unsigned &w, unsigned &h) = 0;
 
    virtual PalettizedWindow * createWindow(const std::string & title,
                                            unsigned dimw, unsigned dimh,
                                            unsigned scalex, unsigned scaley)=0;
 
    const SoundPlayerParms & playerParms(void) const noexcept 
        { return(playerparms_); }
 
    virtual void playSound(double secs, const SoundMonoProducer & waveprod,
                           bool async) = 0;
 
    virtual void pausePlaying(void) = 0;
 
    virtual void resumePlaying(void) = 0;
 
    virtual bool playingPaused(void) = 0;
 
    virtual bool soundPlaying(void) const noexcept = 0;
 
    virtual void nextSoundPlayingTime(double &t) noexcept = 0;
 
    virtual const SoundMonoProducer & lastSoundProducer(void) const = 0;
 
    virtual double lastSoundDuration(void) const noexcept = 0;
 
    virtual void enableTextEvents(void) = 0;
 
    virtual void disableTextEvents(void) = 0;
 
    virtual bool textEventsEnabled(void) const = 0;
 
    virtual std::string copyFromClipboard(void) const = 0;
 
    virtual void copyToClipboard(const std::string & txt) const = 0;
 
 protected:
 
    SoundPlayerParms playerparms_;
 
    DesktopInterface(const SoundPlayerParms & spps): playerparms_{spps} {}
 
};
 
 
/* ****************************************************************************
 
    Abstract class: PalettizedWindow
 
*******************************************************************************/
 
 
class PalettizedWindow
{
 public:
 
    /* -------------------- Types and consts --------------------------- */
 
    typedef uint8_t PaletteLevel; 
    typedef uint8_t PaletteIndex; 
 
    struct Rectangle
    {
        unsigned x0,y0; 
        unsigned w,h; 
        Rectangle(void) noexcept:x0{0},y0{0},w{0},h{0} {}
 
        Rectangle(unsigned x, unsigned y, 
                  unsigned wi, unsigned he) noexcept: x0{x},y0{y},w{wi},h{he} {}
 
        bool empty(void) const noexcept { return((w == 0) || (h == 0)); }
        
        std::string to_string(void) const 
            { return("winrect{{" + std::to_string(x0) + "," +
                                   std::to_string(y0) + "},{" +
                                   std::to_string(w) + "," +
                                   std::to_string(h) + "}}"); }
    };
 
    static constexpr unsigned NUMCOLSPAL = 256; 
 
 
    struct Event
    {
        enum class ID {
                        // Events for the window in general (they have no data):
 
                        W_CLOSED = 0, 
                        W_MINIMIZED,  
                        W_RESTORED,   
                        W_MOVED,      
                        W_EXPOSED,    
 
                        // Events for the keyboard:
 
                        K_PRESSED,    
                        K_UNPRESSED,  
                        K_TEXT,       
                        // Events for the mouse:
 
                        M_MOVED,            
                        M_BUTTONCLICKED,    
                        M_BUTTONUNCLICKED,  
                        M_WHEEL             
                     };
 
        static const uint8_t N_IDS = static_cast<uint8_t>(ID::M_WHEEL) + 1; 
 
        class IDSet: public std::bitset<N_IDS>
        {
         public:
 
            IDSet(bool all = false) noexcept
                { if (all) set(); }
 
            IDSet(const std::set<ID> & sids)
                { for (auto id : sids) set(static_cast<size_t>(id)); }
 
            bool contains(ID id) const noexcept
                { return(operator[](static_cast<size_t>(id))); }
        };
 
        ID id; 
        union {
                struct {
                        DesktopInterface::KeyID key; 
                        } keyboard; 
                struct {
                        char utf8char[7]; 
                       } textkey; 
                struct {
                        int32_t incx;   
                        int32_t incy;   
                        unsigned x,y; 
                        bool buttons[2]; 
                        } motion; 
                struct {
                        char which; 
                        unsigned x,y; 
                        } button; 
                struct {
                        int32_t incvert;    
                        } wheel; 
              } data; 
 
 
        std::string to_string(void) const;
    };
 
 
    class ListOfEvents: public std::list<Event>
    {
     public:
 
        using Base = std::list<Event>; 
        using Base::Base; 
 
        bool contains(Event::ID eid) const noexcept
            { return(std::find_if(cbegin(),cend(),
                                  [eid](const Event & e)->bool
                                  { return(e.id == eid); }) != cend()); }
 
        std::string to_string(void) const;
    };
 
 
    class Cursor
    {
     public:
 
        Cursor(const PalettizedWindow & palwin,
                unsigned x=0, unsigned y=0,
                size_t bytesperpixel = 1) noexcept;
 
        virtual ~Cursor(void) = default;
 
        unsigned x(void) const noexcept { return(x_); }
 
        unsigned y(void) const noexcept { return(y_); }
 
        bool outside(void) const noexcept { return(false); }
 
        void incX(void) noexcept { ++o_; ++x_; }
 
        void incY(void) noexcept { o_ += pitch_; ++y_; }
 
        size_t offset(void) const noexcept { return(o_); }
 
        std::string to_string(void) const noexcept;
 
     protected:
 
        unsigned x_,y_; 
        size_t pitch_; 
        size_t o_; 
    };
 
 
    class CursorCheck: public Cursor
    {
     public:
 
        CursorCheck(const PalettizedWindow & palwin,
                    unsigned x=0, unsigned y=0,
                    size_t bytesperpixel = 1) noexcept;
 
        bool outside(void) const noexcept;
 
        void incX(void) noexcept;
 
        void incY(void) noexcept;
 
        std::string to_string(void) const noexcept;
 
     protected:
 
        size_t n_; 
    };
 
 
    virtual ~PalettizedWindow(void);
 
    PalettizedWindow(const PalettizedWindow &) = delete; 
    PalettizedWindow & operator=(const PalettizedWindow &) = delete; 
    PalettizedWindow(PalettizedWindow &&) = delete; 
    PalettizedWindow & operator=(PalettizedWindow &&) = delete; 
 
    unsigned width(void) const noexcept { return(width_); }
 
    unsigned height(void) const noexcept { return(height_); }
 
    virtual void refresh(const Rectangle & rect = Rectangle{}) = 0;
 
    virtual void serveEvents(const PalettizedWindow::Event::IDSet & whichevents 
                                = {true},
                             ListOfEvents * evs = nullptr) = 0;
 
    virtual void setPaletteColors(const PaletteLevel * colors,
                                  PaletteIndex first,
                                  PaletteIndex count) = 0;
 
    virtual Cursor getCursor(unsigned x = 0, unsigned y = 0) noexcept = 0;
 
    virtual CursorCheck getCursorCheck(unsigned x = 0, unsigned y = 0) = 0;
 
    virtual PaletteIndex getPixel(const Cursor & cursor) = 0;
 
    virtual void setPixel(const Cursor & cursor, PaletteIndex b) = 0;
 
    virtual void fillRect(const Rectangle &r, PaletteIndex c) = 0;
 
    virtual bool getPointingInWindow(unsigned &x, unsigned &y,
                                     bool & leftbutton, bool & rightbutton) = 0;
 
    virtual bool keyPressed(DesktopInterface::KeyID k) = 0;
 
    virtual void updateKeypressMap(DesktopInterface::KeypressMap & map) = 0;
 
 protected:
 
    const std::string title_; 
    const unsigned width_,height_; 
    const size_t size_; 
    const unsigned scx_,scy_; 
    const unsigned swidth_,sheight_; 
    PalettizedWindow(const std::string & tit, unsigned dimw, unsigned dimh,
                     unsigned scalex, unsigned scaley);
 
};
 
 
#endif
 // DesktopInterface