ZXEcosystem.h

Go to the documentation of this file.

 
/***************************************************************************/
#ifndef ZXECOSYSTEM
#define ZXECOSYSTEM
 
#include <cstdint>
#include <string>
#include <mutex>
#include <atomic>
#include <chrono>
#include <functional>
#include "zxecosystem/ancillary/CppAddons.h"
#include "zxecosystem/ancillary/SimpleStatistics.h"
#include "zxecosystem/desktop/DesktopInterface.h"
#include "zxecosystem/core/ZXScreen.h"
#include "zxecosystem/core/ZXKeyboard.h"
#include "zxecosystem/core/ZXPointing.h"
#include "zxecosystem/core/ZXSound.h"
 
 
namespace zxeco
{
 
/*****************************************************************************
*
*   Singleton class: ZXEco
*
*******************************************************************************/
 
 
class ZXEco
{
 public:
 
    enum class RefreshType {
                                SCREEN = 1,
                                EVENTS = 2,
                                BOTH = 3   
                                           // (must be the OR of the others).
                           };
 
    enum class RefreshMode {
                                NEVER, 
                                PERIODIC 
                           };
 
    typedef SimpleStats<double,SSOvPol_IgnoreMoreData<double> > LongTimeStat;
 
    typedef std::function<void (ZXEco &)> UserCode;
 
    static const UserCode kNullUserCode;
 
    class RawGeometry 
    {
     public:
 
        RawGeometry(void) = default;
 
        RawGeometry(const DoubleArea & sizes,
                    unsigned bw, unsigned bh,
                    unsigned sx, unsigned sy);
 
 
        const DoubleArea & basics(void) const noexcept { return(dispdef_); }
 
        const BorderRect & topBorder(void) const noexcept { return(btop_); }
 
        const BorderRect & leftBorder(void) const noexcept { return(bleft_); }
 
        const BorderRect & rightBorder(void) const noexcept { return(bright_); }
 
        const BorderRect & bottomBorder(void) const noexcept {return(bbottom_);}
 
        unsigned borderH(void) const noexcept { return(borderh_); }
 
        unsigned borderW(void) const noexcept { return(borderw_); }
 
        unsigned firstH(void) const noexcept { return(borderh_); }
 
        unsigned firstW(void) const noexcept { return(borderw_); }
 
        unsigned lastH(void) const noexcept { return(lasth_); }
 
        unsigned lastW(void) const noexcept { return(lastw_); }
 
        unsigned totH(void) const noexcept { return(toth_); }
 
        unsigned totW(void) const noexcept { return(totw_); }
 
        unsigned winH(void) const noexcept { return(windowh_); }
 
        unsigned winW(void) const noexcept { return(windoww_); }
 
        unsigned scaleX(void) const noexcept { return(scalex_); }
 
        unsigned scaleY(void) const noexcept { return(scaley_); }
        
        std::string to_string(void) const;
 
     private:
 
        DoubleArea dispdef_;
        BorderRect btop_,bleft_,bright_,bbottom_;
        unsigned scalex_,scaley_;
        unsigned borderw_,borderh_;
        unsigned lastw_,lasth_;
        unsigned totw_,toth_;
        unsigned windoww_,windowh_;
    };
 
    static ZXEco & theZXEco(DesktopInterface * desktop = nullptr);
 
    ZXEco(const ZXEco &) = delete; 
    ZXEco & operator=(const ZXEco &) = delete; 
    ZXEco(ZXEco && disptomove) = delete; 
    ZXEco & operator=(ZXEco && disptomove) = delete; 
 
    virtual ~ZXEco(void);
 
    DesktopInterface & myDesktopInterface(void) noexcept { return(*mydesktop_);}
 
    void activate(const std::string & title,
                  PixelDist borderwidth, PixelDist borderheight,
                  unsigned scalex = 1,
                  unsigned scaley = 1,
                  const PixArea & size = {SCREENW,SCREENH},
                  const Screen::ExpandToken & exptok = Screen::kInvExpandToken,
                  uint8_t * bitmap = nullptr, uint8_t * attrmap = nullptr);
 
    void close(void);
 
    bool valid(void);
 
 
    const std::string & windowTitle(void) const;
 
    std::chrono::time_point<std::chrono::steady_clock> startTime(void) noexcept
        { return(t0_); }
 
    const RawGeometry & rawGeometry(void) const;
 
    Screen & screen(void) const;
 
    void refreshCode(const UserCode & codetorun, 
                     RefreshMode rm = RefreshMode::PERIODIC, 
                     RefreshType rt = RefreshType::BOTH, 
                     unsigned period = 20, 
                     const PalettizedWindow::Event::IDSet & whichevents =
                        {{PalettizedWindow::Event::ID::W_CLOSED}},
                     const UserCode & periodiccode = kNullUserCode);
 
    bool isInRefreshingCode(void) const noexcept { return(isincode_); }
 
    void refresh(RefreshType rt = RefreshType::BOTH,
                 const PalettizedWindow::Event::IDSet & whichevents = {true});
 
    bool extractEvent(PalettizedWindow::Event & ev,
                      const PalettizedWindow::Event::IDSet & which 
                                = {true},
                      const PalettizedWindow::Event::IDSet & equalstoskip 
                                = {false}) noexcept;
 
    void clearEvents(void) noexcept;
 
    RefreshType refreshType(void) const noexcept { return(refreshtype_); }
 
    RefreshMode refreshMode(void) const noexcept { return(refreshmode_); }
 
    const PalettizedWindow::Event::IDSet & refreshWhichEvents(void) const 
                                                                    noexcept
 
        { return(refreshwhichevents_); }
 
    const LongTimeStat & refreshStats(void);
 
    void resetRefreshStats(void);
 
    bool refreshingScreen(void) const noexcept { return(isrefreshing_); }
 
    bool inkAndPaperSwappedByFlash(void) const noexcept;
 
    void activateDecolourMode(const CharRect & rect = {});
 
    void deactivateDecolourMode(void);
 
    bool decolourModeActive(void) const noexcept { return(decolour_mode_); }
 
    void windowUpdate(const PixRect & rect = PixRect{});
 
    void windowRefresh(const PixRect & rect = PixRect{});
 
    void windowBorderUpdate(const BorderRect & rect = BorderRect{});
 
    void windowBorderRefresh(const BorderRect & rect = BorderRect{});
 
    PalettizedWindow & desktopWindow(void);
 
    bool pointingStatus(PointingStatus & ps) noexcept;
 
    bool desktopKeyPressed(DesktopInterface::KeyID k) ;
 
    Membrane membrane(void);
 
    Keyboard keyboard(std::string * lastprstr = nullptr);
 
    bool waitForKey(Keyboard & kb, unsigned millis = 20, bool zxandpc = false);
 
    void waitForNoKey(unsigned millis = 20, bool zxandpc = false);
 
    Keyboard waitOneKey(unsigned ms = 20)
        { waitForNoKey(ms); Keyboard kb; waitForKey(kb,ms); waitForNoKey(ms); 
          return(kb); }
 
    Keyboard waitForKeyChange(const Keyboard & oldkb,
                              std::string * lastprstr = nullptr,
                              unsigned millis = 20);
 
    void forceCapsLock(bool state = true);
 
    void setVolume(double v);
 
    double volume(void) const noexcept { return(soundvol_); }
 
    void play(const Beep &b, bool async = false);
 
    Screen::InputCallbacks flatInputCallbacks(void);
 
 private:
 
    static const unsigned COLBORDERINK_;
 
    static DesktopInterface * mydesktop_;
 
    static uint8_t zxColToPal(BrightColor bc) noexcept
        { return(bc.linear()); }
 
    static uint8_t pixelToPalCol(uint8_t pixelval,
                                 const AttrColors & cs) noexcept
        { return(zxColToPal({pixelval ? cs.ink().basic() :
                                        cs.paper().basic(),
                             static_cast<bool>(cs.bright())})); }
    static void bothPixelPalCols(const AttrColors & cs,
                                 uint8_t & palcolpap,
                                 uint8_t & palcolink) noexcept
        {
            palcolink = zxColToPal({cs.ink().basic(),
                                    static_cast<bool>(cs.bright())});
            palcolpap = zxColToPal({cs.paper().basic(),
                                    static_cast<bool>(cs.bright())});
        }
    RawGeometry dispinfo_;
    std::string mywindowtitle_;
    PalettizedWindow * mywindow_;
    Screen * myscreen_;
    PalettizedWindow::ListOfEvents lastevents_;
    RefreshType refreshtype_;
    PalettizedWindow::Event::IDSet refreshwhichevents_;
    RefreshMode refreshmode_;
    LongTimeStat refreshexectimes_;
    std::atomic<bool> isrefreshing_;
    std::atomic<bool> decolour_mode_;
    CharRect decolour_rect_;
    std::atomic<bool> isincode_;
    DesktopInterface::KeypressMap kpmap_;
    Membrane membr_;
    Keyboard keybd_;
    double soundvol_;
    std::chrono::time_point<std::chrono::steady_clock> t0_;
    std::mutex winmux_,runcodemux_,keymux_,pointmux_,soundmux_;
 
    ZXEco(void) noexcept;
 
    bool activated(void) const noexcept { return(mywindow_ != nullptr); }
    void deactivate(void) noexcept;
    void checkActivated(void) const 
        { if (!activated()) 
            RUNTIMEEXCEP("No screen since the ecosystem is inactive"); }
 
    template <class RECT>
    PalettizedWindow::Rectangle winRectFrom(const RECT & r) noexcept
        { return(PalettizedWindow::Rectangle{static_cast<unsigned>(r.corner.x +
                                                        dispinfo_.borderW()),
                                             static_cast<unsigned>(r.corner.y +
                                                        dispinfo_.borderH()),
                                        static_cast<unsigned>(r.area.width),
                                        static_cast<unsigned>(r.area.height)});}
 
    void updateWindowContent(const PixRect & rect = PixRect{});
    void refreshWindowAndEvents(const PixRect & rect = PixRect{});
    bool decolourGridForCursor(const CharCursor & c) const;
    void printAtWindow(uint8_t c, unsigned x0, unsigned y0,
                       unsigned inkpalcol = COLBORDERINK_);
    void printDecolourGuides(void);
    void updateBorder(BasicColor col, const BorderRect & rect = BorderRect{});
    bool swapPixels(bool pass);
 
    void zxmapFromKMap(Membrane & m) const noexcept;
};
 
constexpr bool operator&(ZXEco::RefreshType a, ZXEco::RefreshType b)
    { return( (static_cast<int>(a) & static_cast<int>(b)) != 0 ); }
 
} // end namespace zxeco
 
#endif
 // ZXEcosystem