ZXScreen.h

Go to the documentation of this file.

 
/* **************************************************************************/
#ifndef ZXSCREEN
#define ZXSCREEN
 
#include <string>
#include <functional>
#include <algorithm>
#include <utility>
#include <limits>
#include "zxecosystem/base/ZXChars.h"
#include "zxecosystem/base/ZXColors.h"
#include "zxecosystem/base/ZXGraphics.h"
#include "zxecosystem/core/ZXKeyboard.h"
#include "zxecosystem/core/ZXSound.h"
 
namespace zxeco
{
 
/******************************************************************************
*
*   Class: At
*
*******************************************************************************/
 
 
class At: public CharCursor
{
 public:
 
    using CharCursor::CharCursor;
 
    At(const CharCursor & cc):CharCursor{cc} {}
    At(CharCursor && cc):CharCursor{std::move(cc)} {}
    At & operator=(const CharCursor & cc) { return(*this = cc); }
    At & operator=(CharCursor && cc) { return(*this = std::move(cc)); }
};
 
 
/******************************************************************************
*
*   Class: Screen
*
*******************************************************************************/
 
 
class Screen
{
 public:
 
    /* -------------- Types, consts., etc. -------------- */
    using ExpandToken = std::function< std::string(uint8_t c)>;
 
    static const ExpandToken kInvExpandToken;
 
    static const ExpandToken kNudeExpandToken;
    
    static constexpr size_t kFontSize = 
        static_cast<size_t>(CHRFIRSTGB - CHRSPC) * 8;
 
 
    struct InputCallbacks
    {
        using PrintItem = std::function< bool(const std::string &) >;
        using GetNewKeyboard = std::function< void(const Keyboard &, 
                                                   Keyboard &, Membrane &,
                                                   std::string &) >;
        using Play = std::function< void(const Beep &) >;
        using CheckInput = std::function< bool(const std::string &) >;
        PrintItem printItem; 
        GetNewKeyboard getNewKeyboard; 
        Play play; 
        CheckInput checkInput; 
    }; 
 
 
 
    template <unsigned SW, unsigned SH>
    class ScaledTextPrinter
    {
     public:
 
        ScaledTextPrinter(Screen & scr, bool perfectchars = true);
 
        ScaledTextPrinter(const ScaledTextPrinter &) = delete;
        ScaledTextPrinter(ScaledTextPrinter &&) = delete;
        ScaledTextPrinter & operator=(const ScaledTextPrinter &) = delete;
        ScaledTextPrinter & operator=(ScaledTextPrinter &&) = delete;
 
 
        Screen & underlyingScreen(void) noexcept { return(scr_); }
 
        const CharArea & scaledDimensions(void) const noexcept 
            { return(scldims_); }
 
        Colors & colors(void) noexcept { return(cols_); }
 
        void setCursor(const CharCursor & stc);
 
        const CharCursor & getCursor(void) const noexcept { return(cur_); }
 
        PixRect getCursorRect(void) const noexcept;
 
        void print(const std::string & txt);
 
        void print(const uint8_t * bitmap);
 
     private:
 
        static constexpr size_t kWidthInBytes = static_cast<size_t>(SW);
        static constexpr size_t kHeightInScans = 
                                static_cast<size_t>(charDistToPixelDist(SH));
        static constexpr size_t kLenBM = kWidthInBytes * kHeightInScans;
 
        Screen & scr_;
        const bool perfectchars_;
        CharArea scldims_;
        CharCursor cur_;
        Colors cols_;
 
        void incCursor(void);
        Bitmap getBitmap(uint8_t c);
    };
 
    static void fillInitialFontBitmaps(uint8_t * p);
 
    static void fillInitialUDGBitmaps(uint8_t * p);
    
    static std::pair<CharArea,size_t> printArea(const CharArea & area, 
                                                const std::string & txt,
                                                const ExpandToken & expandtoken=
                                                    kNudeExpandToken);  
 
    static CharArea areaForPrint(const std::string & txt,
                                 const ExpandToken & expandtoken =
                                                    kNudeExpandToken)
 
        { auto res = printArea(CharArea{std::numeric_limits<CharDist>::max(),
                                        std::numeric_limits<CharDist>::max()},
                               txt,expandtoken); 
          return(res.first); }                                  
    
    Screen(const CharArea & dimensions = {SCREENCOLS,SCREENROWS},
           const ExpandToken expandtoken = kInvExpandToken);
 
    Screen(uint8_t * bitmap, uint8_t * attrmap,
           const CharArea & dimensions = {SCREENCOLS,SCREENROWS},
           const ExpandToken expandtoken = kInvExpandToken);
 
    Screen(Screen & oth, const CharRect & region,
           const ExpandToken expandtoken = kInvExpandToken);
 
    Screen(const Screen &) = delete;
    Screen & operator=(const Screen &) = delete; 
    Screen(Screen &&) = delete; 
    Screen & operator=(Screen &&) = delete; 
 
    virtual ~Screen(void);
 
    const DoubleArea & info(void) const noexcept { return(myinfo_); }
 
    const ExpandToken & expandToken(void) const noexcept {return(expandtoken_);}
 
    CharArea entireCharArea(void) const { return(myinfo_.chararea); }
 
    CharRect entireCharRect(void) const 
        { return(CharRect{{0,0},entireCharArea()}); }
 
    const CharRect & subRegion(void) const noexcept { return(subregion_); }
 
    bool inside(const CharRect & r) const noexcept
        { return(! ((r.corner.x >= myinfo_.chararea.width) ||
                    (r.corner.y >= myinfo_.chararea.height) ||
                    (r.corner.x + r.area.width > myinfo_.chararea.width) ||
                    (r.corner.y + r.area.height > myinfo_.chararea.height))); }
 
    void cls(void);
 
    void scrollUp(PixelDist howmany = 8, PixelCoord upperrow = 0);
 
    void scrollUpAttrs(CharDist howmany = 1, CharCoord upperrow = 0);
 
    void setBorder(BasicColor c) noexcept { mybordercol_ = c; }
 
    BasicColor border(void) const noexcept { return(mybordercol_); }
 
    Colors & colors(void) noexcept { return(currcmodes_); }
 
    DoubleGraphic & graphic(void) noexcept { return(mymap_); }
 
    const DoubleGraphic & graphic(void) const noexcept { return(mymap_); }
 
    const uint8_t * currentFontBitmap(void) const noexcept { return(pfont_); }
 
    void changeFontBitmap(const uint8_t * pfont) noexcept { pfont_ = pfont; }
 
    void copyFontBitmap(uint8_t * dest) const;
 
    const uint8_t * currentUDGsBitmap(void) const noexcept { return(pudgs_); }
 
    void changeUDGsBitmap(const uint8_t * pudgs) noexcept { pudgs_ = pudgs; }
 
    uint8_t recognizeCharInFont(const Bitmap & charbitmap,
                                uint8_t howmany = CHRFIRSTGB - CHRSPC,
                                bool evenwithinv = true) const;
 
    uint8_t recognizeCharInGrBlocks(const Bitmap & charbitmap) const;
 
    uint8_t attrForPrints(const CharCursor & pos, const Colors & desired) const;
 
    uint8_t attrForPrints(size_t offset, const Colors & desired) const;
 
    void setTextCursor(const CharCursor & pos) { cursor_ = pos; }
 
    const CharCursor & getTextCursor(void) const noexcept { return(cursor_); }
 
    void put(uint8_t c)
 
        { if ((c >= CHRSPC) && 
              (c < CHRFIRSTTOKEN)) putChar(c,cursor_,currcmodes_); 
          else putChar(CHRINVALID,cursor_,currcmodes_); }
 
    void putChar(const uint8_t * d) { putCharBitmap(d,cursor_,currcmodes_); }
 
    size_t print(const std::string & txt, size_t printmax = 0) 
    
        { size_t prmax{printmax}; 
          return(printRaw(txt,cursor_,currcmodes_,true,prmax)); }
 
    size_t printSize(const std::string & txt, CharCursor & cur,
                     CharArea & area, size_t & nscrlls) const;
 
    Screen & operator<<(const std::string & txt) 
        { print(txt); return(*this); }
    Screen & operator<<(uint8_t c) // also for char 
        { print(std::string(1,static_cast<char>(c))); return(*this); }
    Screen & operator<<(const CharCursor & at) 
        { setTextCursor(at); return(*this); }
    Screen & operator<<(Paper p)
        { print(zxString(CHRPAPER,static_cast<uint8_t>(p))); return(*this); }
    Screen & operator<<(Ink i)
        { print(zxString(CHRINK,static_cast<uint8_t>(i))); return(*this); }
    Screen & operator<<(Bright b)
        { print(zxString(CHRBRIGHT,static_cast<uint8_t>(b))); return(*this); }
    Screen & operator<<(Flash f)
        { print(zxString(CHRFLASH,static_cast<uint8_t>(f))); return(*this); }
    Screen & operator<<(Inverse i)
        { print(zxString(CHRINVERSE,static_cast<uint8_t>(i))); return(*this); }
    Screen & operator<<(Over o)
        { print(zxString(CHROVER,static_cast<uint8_t>(o))); return(*this); }
 
    void printRectangle(const CharRect & rect, char c, 
                        const Colors * cmc = nullptr);
 
    bool flatInput_printItem(const std::string & item);
 
    void input(std::string & res, const InputCallbacks & callbacks,
               const CharCursor & pos, const Colors & c0, const Keyboard & k0,
               bool withquotes, CharDist maxscrolls, size_t maxlen = 0,
               const Beep & b  = Beep{});
 
    bool validPixel(const PixCursor & pos) const noexcept
        { return((pos.x < myinfo_.pixarea.width) && 
                 (pos.y < myinfo_.pixarea.height)); }
 
    bool point(const PixCursor & pos) const;
 
    void plot(const PixCursor & pos, const Colors * cmc = nullptr);
 
    const PixCursor & lastPlot(void) const noexcept { return(lastplot_); }
 
    void draw(IntDist incx, IntDist incy, const Colors * cmc = nullptr);
 
    void draw(IntDist incx, IntDist incy, double arc,
              const Colors * cmc = nullptr);
 
    void circle(const PixCursor & center, PixelDist r, 
                const Colors * cmc = nullptr);
 
    void rectangle(const PixRect & rect, const Colors * cmc = nullptr);
 
 private:
 
    static const std::vector< std::string > TOKENTEXTS;
    static const LinearGraphic::GraphOp GRAPHOPSFORMODES_[2][2];
 
    static uint8_t changeBitsByPlot(uint8_t oldbyte, uint8_t maskbit,
                                    bool inverse, bool over) noexcept;
    static void clipSegmentLeft(double xd0, double yd0, double dxdy,
                                double & xd1, double & yd1)
        { yd1 = -xd0 / dxdy + yd0; xd1 = 0.0; }
    static void clipSegmentRight(double xd0, double yd0, double dxdy,
                                 double w1,
                                 double & xd1, double & yd1)
        { yd1 = (w1 - xd0) / dxdy + yd0; xd1 = w1; }
    static void clipSegmentTop(double xd0, double yd0, double dxdy,
                               double & xd1, double & yd1)
        { xd1 = -yd0 * dxdy + xd0; yd1 = 0.0; }
    static void clipSegmentBottom(double xd0, double yd0, double dxdy,
                                  double h1,
                                  double & xd1, double & yd1)
        { xd1 = (h1 - yd0) * dxdy + xd0; yd1 = h1; }
    static double angleWithChordError(double r);
    static void advanceCursor(CharCursor & cur, bool newline = false) noexcept;
 
    ExpandToken expandtoken_;
    DoubleGraphic mymap_;
    const DoubleArea myinfo_;
    const CharRect subregion_;
    BasicColor mybordercol_;
    Colors currcmodes_;
    CharCursor cursor_;
    PixCursor lastplot_;
    const uint8_t * pfont_;
    const uint8_t * pudgs_;
 
    size_t adjustCursorToPrint(CharCursor & cur, bool scroll = true) noexcept;
    void putChar(uint8_t c, const CharCursor & cur, const Colors & cmc);
    void putCharBitmap(const uint8_t * bitmap, 
                       const CharCursor & cur, const Colors & cmc);
    size_t printRaw(const std::string & txt, CharCursor & cur, Colors & cols,
                    bool printit, size_t & maxprint, 
                    CharArea * printbound = nullptr,
                    size_t * printlength = nullptr);
    uint8_t attrForPlots(const PixCursor & pos,
                         bool colorsembedded,
                         const Colors & cmc) const;
    void plotWithAttrColors(const PixCursor & pos, bool colorsembedded,
                            const Colors & cmc);
    bool drawHoriz(PixelDist incx, bool colorsembedded,
                   const Colors & cmc);
    bool drawVert(PixelDist incy, bool colorsembedded,
                  const Colors & cmc);
    bool drawWithAttrColors(IntDist incx, IntDist incy, bool colorsembedded,
                            const Colors & cmc);
    double yCoordInPlane(double y) const noexcept
        { return(static_cast<double>(myinfo_.pixarea.height - 1) - y); }
    bool drawArc(IntDist xi0, IntDist yi0, IntDist xi1, IntDist yi1, double g,
                 bool colorsembedded, const Colors &cmc);
    bool drawWithAttrColors(IntDist incx, IntDist incy, double arc,
                            bool colorsembedded,
                            const Colors &cmc);
    bool drawCircleWithAttrColors(const PixCursor & center, PixelDist r,
                                  bool colorsembedded,
                                  const Colors &cmc);
 
};
 
 
/******************************************************************************
*
*   Class: BASICScreen
*
*******************************************************************************/
 
 
class BASICScreen
{
 public:
 
    /* @name -------------- Types, consts., etc. -------------- */
    using KeyWait = std::function < Keyboard (void) >;
 
    struct ScrollInfo
    {
        bool acceptedScroll; 
        size_t howmanyScrolls; 
        bool newlineDone; 
 
        ScrollInfo(void):acceptedScroll{true},
                         howmanyScrolls{0},
                         newlineDone{false} {}
 
        bool add(const ScrollInfo & si1) noexcept
            { acceptedScroll = acceptedScroll && si1.acceptedScroll; 
              howmanyScrolls += si1.howmanyScrolls; 
              newlineDone = newlineDone || si1.newlineDone;
              return(acceptedScroll); }
 
        std::string to_string(void) const
            { return(std::string{"ScrollInfo("} + 
                     (acceptedScroll ? "no-break" : "BREAK") + ", " +
                     std::to_string(howmanyScrolls) + " scrolls, " +
                     (newlineDone ? "no-nl" : "NEWLINE") + ")"); }
    };
 
    static const CharDist kInitialRowsK = 2;
 
    static const PixelDist kInitialHeightK = charDistToPixelDist(kInitialRowsK);
 
    /* @name -------------- Class methods -------------- */
    static void checkChannel(char c, const std::string & place = "")
 
        { if ((c != 'S') && (c != 'K'))
            RUNTIMEEXCEP("Invalid channel '" + std::string{c} + "'"); }
 
    /* @name -------------- Constructors -------------- */
    BASICScreen(Screen & scr, const KeyWait & keywait =
                                    [](void) -> Keyboard
                                    {
                                        return(Keyboard{});
                                    });
 
    BASICScreen(const BASICScreen &) = delete;
    BASICScreen(BASICScreen &&) = delete;
    BASICScreen & operator=(const BASICScreen &)=delete;
    BASICScreen & operator=(BASICScreen &&) = delete;
 
    virtual ~BASICScreen(void) = default;
 
    /* @name -------------- Transformations to flat coordinates ------------- */
    size_t flatBitmap(size_t offset) const;
 
    size_t flatAttrmap(size_t offset) const { return(offset); }
 
    CharCursor flatTextCoords(char channel, const CharCursor & pos) const;
 
    PixCursor flatPixelCoords(const PixCursor & pos) const;
 
    /* @name ----------- Transformations from flat coordinates -------------- */
    size_t nonflatBitmap(size_t offset) const;
 
    size_t nonflatAttrmap(size_t offset) const { return(offset); }
 
    CharCursor nonflatTextCoords(char channel, const CharCursor & pos) const;
 
    PixCursor nonflatPixelCoords(const PixCursor & pos) const;
 
    /* @name -------------- General methods -------------- */
    Screen & flat(void) const { return(screen_); }
 
    void reset(void);
 
    void resetChannelK(void) { resetK(true); }
 
    CharDist scrollCnt(void) const noexcept { return(howmanyuntilaskscroll_); }
 
    void setScrollCnt(CharDist newcnt) { howmanyuntilaskscroll_ = newcnt; }
 
    /* @name -------------- Color methods -------------- */
    void fillKColors(BasicColor b, Colors & colors) const;
 
    void changeGlobalColors(char channel, const Colors & newcols);
 
    void getGlobalColors(char channel, Colors & colors) const;
 
    void restoreGlobalColors(char channel);
 
    /* @name -------------- Cursor methods -------------- */
    void changeChannel(char c);
 
    char getChannel(void) const { return(curch_); }
 
    void setTextCursor(char channel, const CharCursor & pos);
 
    CharCursor getTextCursor(char ch = 0x00) const;
 
    bool columnAtLeft(void) const { return(getTextCursor().x == 0); }
 
    /* @name -------------- Text printing methods -------------- */
    ScrollInfo print(const std::string & txt);
 
    void moveNewLine(void) { advanceCursor(true); }
 
    /* -------------- Drawing methods -------------- */
    void plot(const PixCursor & pos, const Colors * cmc = nullptr);
 
    void draw(IntDist incx, IntDist incy, const Colors * cmc = nullptr);
 
    void draw(IntDist incx, IntDist incy, double arc, 
              const Colors * cmc = nullptr);
 
    void circle(const PixCursor & center, PixelDist r, 
                const Colors * cmc = nullptr);
 
    bool point(const PixCursor & pos) const
 
        {// in the original ZX, the K area is ignored for drawing/plotting
            return(screen_.point(flatPixelCoords(pos))); }
 
    /* @name -------------- Input methods -------------- */
    bool originalInput_printItem(const std::string & txt);
 
    std::string input(bool withquotes, const Keyboard & k0,
                      const Screen::InputCallbacks::GetNewKeyboard & cbk,
                      const Screen::InputCallbacks::Play & cbp,
                      const Screen::InputCallbacks::CheckInput & cnci);
 
    /* @name -------------- Miscellaneous methods -------------- */
    std::string to_string(void) const;
 
 private:
 
    Screen & screen_;
    KeyWait keywait_;
 
    char curch_;
 
    CharDist initflatfirstrowofK_; // in the flat model
    CharDist curflatfirstrowofK_; // in the flat model
    CharCursor curflatK_; // in the flat model
    Colors globalattrsK_;
    Colors curattrsK_;
 
    CharCursor curflatS_; // in the flat model
    Colors globalattrsS_,curattrsS_;
    CharDist howmanyuntilaskscroll_;
 
 
    CharCursor & curCurChannel(char c) 
        { return(c == 'S' ? curflatS_ : curflatK_);}
    Colors & curColorsChannel(char c) 
        { return(c == 'S' ? curattrsS_ : curattrsK_);}
    Colors & globalColorsChannel(char c) 
        { return(c == 'S' ? globalattrsS_ : globalattrsK_);}
    void useGlobalAttrsOfChannel(char c)
        { screen_.colors() = (c == 'S' ? globalattrsS_ : globalattrsK_); }
    void useCurrentAttrsOfChannel(char c)
        { screen_.colors() = (c == 'S' ? curattrsS_ : curattrsK_); }
    void getCurrentAttrsOfChannel(char c)
        { if (c=='S') curattrsS_ = screen_.colors(); 
          else curattrsK_ = screen_.colors(); }
    void useCursorChannel(char c)
        { screen_.setTextCursor(curCurChannel(c)); }
    void getCursorChannel(char c)
        { curCurChannel(c) = screen_.getTextCursor(); }
    void printSpcRect(const CharRect & rect);
    void resetS(void);
    void resetK(bool byinput = false);
    Key printMsgK(const std::string & msg);
    ScrollInfo scrollIfNeededS(void);
    ScrollInfo scrollIfNeededK(void);
    ScrollInfo scrollIfNeeded(void)
        { if (curch_ == 'S') return(scrollIfNeededS()); 
          else return(scrollIfNeededK()); }
    ScrollInfo adjustCursorToPrint(void) noexcept;
    ScrollInfo advanceCursor(bool newline = false) noexcept;
    ScrollInfo printNonCtrlChar(uint8_t c);
    ScrollInfo printCtrlChar(uint8_t c, uint8_t p1 = 0, uint8_t p2 = 0);
 
};
 
 
 
 
 
 
/*============================================================================
 
    TEMPLATE IMPLEMENTATIONS
 
==============================================================================*/
 
 
 
/*****************************************************************************
*
*   Template subclass: Screen::ScaledTextPrinter
*
*******************************************************************************/
 
template <unsigned SCW, unsigned SCH>
void Screen::ScaledTextPrinter<SCW,SCH>::incCursor(void)
{
    ++cur_.x;
    if (cur_.x >= scldims_.width)
    {
        cur_.x = 0;
        ++cur_.y;
        if (cur_.y >= scldims_.height) return;
    }
}
 
template <unsigned SCW, unsigned SCH>
Bitmap Screen::ScaledTextPrinter<SCW,SCH>::getBitmap(uint8_t c)
// Return an already scaled bitmap if SCW == 1 (hald-width) and perfectchars_
{
    if ((c < CHRSPC) || (c > CHRLASTGB)) c = CHRINVALID;
 
    if constexpr(SCW == 0) // compile-time #if -> half width chars
    {
        // just to be created in that template case
        static const uint8_t kPerfectFont[] = 
        { // by Andrew Owen 2007 (except noted modifications):
          //   https://chuntey.wordpress.com/2010/01/08/64-column-print/ 
          // 2 chars into each 8-byte chunk, each one in 4 bits
            0x00,0x02,0x02,0x02,0x02,0x00,0x02,0x00, // spc, ! -> 32 and 33
            0x00,0x55,0x57,0x05,0x05,0x07,0x05,0x00, // # modified
            0x00,0x25,0x71,0x62,0x32,0x74,0x25,0x00,
            0x00,0x22,0x42,0x30,0x50,0x50,0x30,0x00,
            0x00,0x14,0x22,0x41,0x41,0x41,0x22,0x14,
            0x00,0x20,0x70,0x22,0x57,0x02,0x00,0x00,
            0x00,0x00,0x00,0x00,0x07,0x00,0x20,0x20,
            0x00,0x01,0x01,0x02,0x02,0x04,0x14,0x00,
            0x00,0x22,0x56,0x52,0x52,0x52,0x27,0x00,
            0x00,0x27,0x51,0x12,0x21,0x45,0x72,0x00,
            0x00,0x57,0x54,0x56,0x71,0x15,0x12,0x00,
            0x00,0x17,0x21,0x61,0x52,0x52,0x22,0x00,
            0x00,0x22,0x55,0x25,0x53,0x52,0x24,0x00,
            0x00,0x00,0x00,0x22,0x00,0x00,0x22,0x02,
            0x00,0x00,0x10,0x27,0x40,0x27,0x10,0x00,
            0x00,0x02,0x45,0x21,0x12,0x20,0x42,0x00,
            0x00,0x23,0x55,0x75,0x77,0x45,0x35,0x00,
            0x00,0x63,0x54,0x64,0x54,0x54,0x63,0x00,
            0x00,0x67,0x54,0x56,0x54,0x54,0x67,0x00,
            0x00,0x73,0x44,0x64,0x45,0x45,0x43,0x00,
            0x00,0x57,0x52,0x72,0x52,0x52,0x57,0x00,
            0x00,0x35,0x15,0x16,0x55,0x55,0x25,0x00,
            0x00,0x45,0x47,0x45,0x45,0x45,0x75,0x00,
            0x00,0x62,0x55,0x55,0x55,0x55,0x52,0x00,
            0x00,0x62,0x55,0x55,0x65,0x45,0x43,0x00,
            0x00,0x63,0x54,0x52,0x61,0x55,0x52,0x00,
            0x00,0x75,0x25,0x25,0x25,0x25,0x22,0x00,
            0x00,0x55,0x55,0x55,0x55,0x27,0x25,0x00,
            0x00,0x55,0x55,0x25,0x22,0x52,0x52,0x00,
            0x00,0x73,0x12,0x22,0x22,0x42,0x72,0x03,
            0x00,0x46,0x42,0x22,0x22,0x12,0x12,0x06,
            0x00,0x20,0x50,0x00,0x00,0x00,0x00,0x0F,
            0x00,0xE0,0x80,0x43,0xE5,0x85,0xE3,0x00, // pound modified
            0x00,0x40,0x40,0x63,0x54,0x54,0x63,0x00,
            0x00,0x10,0x10,0x32,0x55,0x56,0x33,0x00,
            0x00,0x10,0x20,0x73,0x25,0x25,0x43,0x06,
            0x00,0x42,0x40,0x66,0x52,0x52,0x57,0x00,
            0x00,0x14,0x04,0x35,0x16,0x15,0x55,0x20,
            0x00,0x60,0x20,0x25,0x27,0x25,0x75,0x00,
            0x00,0x00,0x00,0x62,0x55,0x55,0x52,0x00,
            0x00,0x00,0x00,0x63,0x55,0x55,0x63,0x41,
            0x00,0x00,0x00,0x53,0x66,0x43,0x46,0x00,
            0x00,0x00,0x20,0x75,0x25,0x25,0x12,0x00,
            0x00,0x00,0x00,0x55,0x55,0x27,0x25,0x00,
            0x00,0x00,0x00,0x55,0x25,0x25,0x53,0x06,
            0x00,0x03,0x02,0x72,0x34,0x62,0x72,0x03, // { modified
            0x00,0x26,0x22,0x22,0x21,0x22,0x22,0x06, // } modified
            0x00,0x56,0xA9,0x06,0x04,0x06,0x09,0x06
        };
 
        if (perfectchars_ && (c < CHRFIRSTGB))
        {
            Bitmap g{CharPixArea{1,8}};
            c = c - CHRSPC;
            size_t ind8 = (static_cast<size_t>(c) / 2) * 8;
            bool leftorright = (c % 2) == 0; // 0-left, 1-right
            uint8_t by;
            for (size_t boff = 0; boff < 8; ++boff)
            {
                by = kPerfectFont[ind8++];
                if (leftorright) by = (by & 0xF0);// must scale to the high nibb
                else by = (by & 0x0F) << 4;
                g.setByteUnsafe(boff,by);
            }
            return(g);
        }
    }
 
    Bitmap gprev{c,const_cast<uint8_t *>(scr_.pfont_)}; // no owner
 
    return(Bitmap{gprev,{{0,0},{1,8}}}); // get ownership
}
 
template <unsigned SCW, unsigned SCH>
Screen::ScaledTextPrinter<SCW,SCH>::ScaledTextPrinter(Screen & scr, 
                                                      bool perfectchars): 
                                            scr_{scr},
                                            perfectchars_{perfectchars},
                                            cur_{0,0},
                                            scldims_{scr.entireCharArea()},
                                            cols_{scr.colors()}
{
    static_assert(SCH > 0, "SCH parameter in ScaledTextPrinter must be > 0");
    static_assert(((SCW == 0) && (SCH == 1)) || (SCH > 0),
                  "SCH must be 1 if SCW is 0 in ScaledTextPrinter");
 
    if constexpr(SCW == 0) scldims_.width *= 2;
    else
    {
        scldims_.width /= SCW;
        scldims_.height /= SCH;
    }
}
 
template <unsigned SCW, unsigned SCH>
void Screen::ScaledTextPrinter<SCW,SCH>::setCursor(const CharCursor & stc)
{
    if (!CharRect{{0,0},scldims_}.contains(stc))
        RUNTIMEEXCEP("Tried to put scaled cursor out of screen");
    cur_ = stc;
}
 
template <unsigned SCW, unsigned SCH>
PixRect Screen::ScaledTextPrinter<SCW,SCH>::getCursorRect(void) const noexcept
{
    if constexpr(SCW == 0) // compile-time #if -> half width chars
    {
        auto px = static_cast<PixelCoord>( pixelOfCharX(cur_.x / 2) +
                                            ((cur_.x % 2) == 1 ? 4 : 0) );
        auto py = pixelOfCharY(cur_.y);
        return(PixRect{{px,py},{4,8}});
    }
    else
    {
        auto px = pixelOfCharX(cur_.x * SCW);
        auto py = pixelOfCharY(cur_.y * SCH);
        return(PixRect{{px,py},
                       {static_cast<PixelDist>(SCW * 8),
                        static_cast<PixelDist>(SCH * 8)}});
    }   
}
 
template <unsigned SCW, unsigned SCH>
void Screen::ScaledTextPrinter<SCW,SCH>::print(const std::string & txt)
{
    if constexpr(SCW == 0) // compile-time #if -> half width chars
    {
        for (size_t f = 0; f < txt.size(); ++f)
        {
            // get bitmap
            uint8_t c = txt[f];
            auto g = getBitmap(c); // ownership in G, already scaled if perfect
            if ((!perfectchars_) || (c >= CHRFIRSTGB))
            {
                // halve the G bitmap automatically onto high nibble of G
                uint8_t bh,bhr,mask1,mask2,pls;
                for (uint8_t b = 0; b < 8; ++b)
                {
                    bh = g.getByteUnsafe(b);
                    bhr = 0;
                    mask1 = 0b01000000;
                    mask2 = 0b10000000;
                    pls = 1;
                    for (uint8_t d = 0; d < 8; d += 2)
                    {
                        bhr |= ((bh & mask1) << pls);
                        if (!ISGRAPHICBLOCK(c)) 
                        {
                            bhr |= ((bh & mask2) << pls);
                            mask2 >>= 2;
                        }
                        mask1 >>= 2; 
                        ++pls;
                    }
                    g.setByteUnsafe(b,bhr);
                }
            }
 
            // print it
            print(g.getAllBytes());
        }
    }
    else
    {       
        static uint8_t bm[kLenBM];
        for (size_t f = 0; f < txt.size(); ++f)
        {
            // get bitmap
            uint8_t c = txt[f];
            auto g = getBitmap(c);
 
            // scale the bitmap
            if constexpr(SCW != 1) std::fill(bm,bm + kLenBM,0); 
            size_t off{0};
            for (size_t scan = 0; scan < 8; ++scan)
            {
                uint8_t b = g.getByteUnsafe(scan);
                if constexpr(SCW == 1) bm[off++] = b;
                else
                {
                    size_t oldoff{off};
                    uint8_t mask = 0b10000000;
                    int8_t atbit = 7;
                    for (uint8_t bi = 0; bi < 8; ++bi)
                    {
                        uint8_t bivat0 = (b & mask) >> (7-bi);
                        for (unsigned f = 0; f < SCW; ++f)
                        {
                            bm[off] |= bivat0 << static_cast<uint8_t>(atbit);
                            --atbit;
                            if (atbit < 0)
                            {
                                ++off;
                                atbit = 7;
                            }
                        }
                        mask >>= 1;
                    }
                    for (unsigned f = 0; f < SCH-1; ++f)
                    {
                        std::copy(bm + oldoff, bm + oldoff + kWidthInBytes, 
                                  bm + off);
                        off += kWidthInBytes;
                    }
                }
            }
 
            // print it
            print(bm);
        }
    }
}
 
template <unsigned SCW, unsigned SCH>
void Screen::ScaledTextPrinter<SCW,SCH>::print(const uint8_t * bitmap)
{
    if constexpr(SCW == 0) // compile-time #if
    {
        Bitmap g{{1,8}}; // empty, to be filled
 
        uint8_t invmask = 0x00; 
        if (cols_.inverse())
        {
            if (cur_.x % 2) invmask = 0x0f;
            else invmask = 0xf0; 
        }
        if (cur_.x % 2)
            for (uint8_t b = 0; b < 8; ++b)
                g.setByteUnsafe(b,(bitmap[b] >> 4) ^ invmask);
        else
            for (uint8_t b = 0; b < 8; ++b)
                g.setByteUnsafe(b,(bitmap[b] & 0xf0) ^ invmask);
 
        // put char
        static const Bitmap gleft{138}; // solid nibble to the left
        static const Bitmap gright{133}; // solid nibble to the right
        auto & grscr = scr_.graphic();
        CharPixCursor cpcur{getCharPixCursor(cur_)};
        cpcur.x /= 2;
        if (cols_.over())
            grscr.bitmap.merge(g,cpcur,LinearGraphic::GraphOp::XOR);
        else
        {
            grscr.bitmap.merge(cur_.x % 2 ? gleft : gright,
                               cpcur,LinearGraphic::GraphOp::AND);
            grscr.bitmap.merge(g,cpcur,LinearGraphic::GraphOp::OR);
        }
        CharCursor cccur{cur_};
        cccur.x /= 2;
        grscr.attrmap.setByte(cccur,scr_.attrForPrints(cccur,cols_));
    }
    else
    {       
        Bitmap g{{static_cast<CharDist>(kWidthInBytes),
                  static_cast<CharDist>(kHeightInScans)}}; // empty, to fill
 
        uint8_t invmask = cols_.inverse() ? 0xff : 0x00;
        for (size_t f = 0; f < g.size(); ++f)
            g.setByteUnsafe(f,bitmap[f] ^ invmask);
 
        // put char
        auto & grscr = scr_.graphic();
        CharCursor cccur{cur_};
        cccur.x *= SCW;
        cccur.y *= SCH;
        CharPixCursor cpcur{getCharPixCursor(cccur)};
        grscr.bitmap.merge(g,cpcur,cols_.over() ? LinearGraphic::GraphOp::XOR :
                                                  LinearGraphic::GraphOp::COPY);
        for (CharDist row = 0; row < SCH; ++row)
            for (CharDist col = 0; col < SCW; ++col)
            {
                grscr.attrmap.setByte(cccur,scr_.attrForPrints(cccur,cols_));
                ++cccur.x;
                if ((col == SCW - 1) || 
                    (cccur.x >= scr_.entireCharArea().width))
                {
                    cccur.x = cur_.x * SCW;
                    ++cccur.y;
                    if (cccur.y >= scr_.entireCharArea().height) 
                        { row = SCH; break; }
                }
            }
    }
 
    incCursor();
}
 
 
 
} // end namespace zxeco
 
#endif
 
 // ZXScreen