ZXGraphics.h

Go to the documentation of this file.

 
/* **************************************************************************/
#ifndef ZXGRAPHICS
#define ZXGRAPHICS
 
#include <string>
#include <cstdint>
#include <type_traits>
#include <limits>
#include <memory>
#include <utility>
#include <functional>
#include "zxecosystem/ancillary/CppAddons.h"
#include "zxecosystem/ancillary/ColorImages.h"
#include "zxecosystem/desktop/DesktopInterface.h"
#include "zxecosystem/base/ZXColors.h"
#include "zxecosystem/base/ZXChars.h"
 
namespace zxeco
{
 
/* ***************************************************************************
*
*    Coordinate system for the screen, both for pixels and characters.
*
*******************************************************************************/
 
using PixelCoord = uint16_t; 
using CharCoord = uint16_t; 
 
using PixelDist = uint16_t; 
using CharDist = uint16_t; 
 
using IntDist = int16_t; 
 
using BorderCoord = int16_t; 
using BorderDist = uint16_t; 
 
 
constexpr PixelCoord kMaxPixelCoord = std::numeric_limits<PixelCoord>::max();
 
constexpr CharCoord kMaxCharCoord = std::numeric_limits<CharCoord>::max();
 
constexpr PixelDist kMaxPixelDist = std::numeric_limits<PixelDist>::max();
 
constexpr CharDist kMaxCharDist = std::numeric_limits<CharDist>::max();
 
constexpr IntDist kMinIntDist = std::numeric_limits<IntDist>::min();
 
constexpr IntDist kMaxIntDist = std::numeric_limits<IntDist>::max();
 
constexpr BorderCoord kMaxBorderCoord = std::numeric_limits<BorderCoord>::max();
 
constexpr BorderDist kMaxBorderDist = std::numeric_limits<BorderDist>::max();
 
 
/* ---------------------- PixelCoord functions ------------------ */
 
 
constexpr CharCoord charOfPixelX(PixelCoord pc) noexcept 
    { return(pc / 8); }
 
 
constexpr CharCoord charOfPixelY(PixelCoord pc) noexcept 
    { return(pc / 8); }
 
 
constexpr PixelCoord firstPixelInCharX(PixelCoord pc) noexcept
    { return(pc & (~7)); }
 
 
constexpr PixelCoord firstPixelInCharY(PixelCoord pc) noexcept
    { return(pc & (~7)); }
 
 
constexpr unsigned char bitOfPixelX(PixelCoord pc) noexcept
    { return(7 - (pc % 8)); }
 
 
/* ---------------------- CharCoord functions ------------------ */
 
 
constexpr PixelCoord pixelOfCharX(CharCoord cc) noexcept
    { return(static_cast<PixelCoord>(cc) * 8); }
 
 
constexpr PixelCoord pixelOfCharY(CharCoord cc) noexcept
    { return(static_cast<PixelCoord>(cc) * 8); }
 
 
/* ---------------------- PixelDist consts and functions ------------------ */
 
constexpr PixelDist SCREENW = 256;
constexpr PixelDist SCREENH = 192;
constexpr BorderDist TOPBORDERH = 56;
 
constexpr BorderDist BOTTOMBORDERH = 56;
constexpr BorderDist LEFTBORDERW = 32;
constexpr BorderDist RIGHTBORDERW = 64;
constexpr CharDist SCREENCHARCOLS = 32;
constexpr CharDist SCREENCHARROWS = 24;
constexpr size_t BITMAPLEN = 6144;
constexpr size_t ATTRMAPLEN = 768;
constexpr size_t DISPLAYLEN = BITMAPLEN + ATTRMAPLEN;
 
 
constexpr PixelDist charDistToPixelDist(CharDist pc) noexcept 
    { return(static_cast<PixelDist>(pc) * 8); }
 
/* ---------------------- CharDist functions ------------------ */
 
 
constexpr CharDist pixelDistToCharDist(PixelDist cc, bool toceil =true) noexcept
    { return(static_cast<CharDist>(toceil ? 
                                    (cc % 8 > 0 ? (cc / 8 + 1) : (cc / 8)) :
                                    (cc / 8))); }
 
constexpr CharDist SCREENROWS = pixelDistToCharDist(SCREENH);
 
constexpr CharDist SCREENCOLS = pixelDistToCharDist(SCREENW);
 
/*****************************************************************************
*
*   Type trait base classes: CoordT, DistT
*   Type traits classes: CharCoordT, PixelCoordT, LongestCoordT, 
*                        CharDistT, PixelDistT, LongestDistT,
*                        IntDistT, BorderCoordT, BorderDistT
*
*******************************************************************************/
 
 
struct CoordT
{
};
 
 
struct DistT
{
};
 
struct CharCoordT: public CoordT
{
    using type = CharCoord; 
 
    static constexpr const char * name = "CharC"; 
 
    type value; 
};
 
struct PixelCoordT: public CoordT
{
    using type = PixelCoord; 
 
    static constexpr const char * name = "PixC"; 
 
    type value; 
};
 
struct CharDistT: public DistT
{
    using type = CharDist; 
 
    using coord_typeT = CharCoordT; 
 
    static constexpr const char * name = "CharD"; 
 
    type value; 
};
 
struct PixelDistT: public DistT
{
    using type = PixelDist; 
 
    using coord_typeT = PixelCoordT; 
 
    static constexpr const char * name = "PixD"; 
 
    type value; 
};
 
 
struct IntDistT
{
    using type = IntDist; 
 
    static constexpr const char * name = "IntD"; 
 
    type value; 
};
 
struct BorderCoordT: public CoordT
{
    using type = BorderCoord; 
 
    static constexpr const char * name = "BorderC"; 
 
    type value; 
};
 
struct BorderDistT: public DistT
{
    using type = BorderDist; 
 
    using coord_typeT = BorderCoordT; 
 
    static constexpr const char * name = "BorderD"; 
 
    type value; 
};
 
/*****************************************************************************
*
*   Template class: Cursor
*   Class aliases: CharCursor, PixCursor, CharPixCursor, BorderCursor
*   Functions: getPixCursor, getCharPixCursor
*
*******************************************************************************/
 
 
template <typename WRES, typename HRES>
class Cursor
{
 public:
 
    using WidthType = WRES; 
    using HeightType = HRES; 
 
    typename WidthType::type x; 
    typename HeightType::type y; 
 
    static const Cursor & theZero(void) noexcept 
        { static const Cursor kz{0,0}; return(kz); }
    
    static Cursor max(const Cursor & c0, const Cursor & c1) noexcept
        { return(Cursor{(c0.x >= c1.x) && (c0.y >= c1.y) ? c0 : c1}); }
    
 
    Cursor(typename WidthType::type xc, 
           typename HeightType::type yc): x{xc},y{yc} {}
 
    Cursor(WidthType xc, HeightType yc): x{xc.value},y{yc.value} {}
    
 
    void newRow(void) noexcept { ++y; x = 0; }
 
    void newCol(void) noexcept { ++x; }
 
    void incRow(void) noexcept { ++y; }
 
    bool zero(void) const noexcept { return((x == 0) && (y == 0)); }
 
    bool before(const Cursor & oth) const noexcept
 
        { return((oth.y > y) || ((oth.x > x) && (oth.y == y))); }
 
    bool rightBelow(const Cursor & oth) const noexcept
 
        { return((y >= oth.y) && (x >= oth.x)); }
 
    IntDist xDiff(const Cursor & oth) const noexcept 
        { return(static_cast<IntDist>(x - oth.x)); }
 
    IntDist yDiff(const Cursor & oth) const noexcept 
        { return(static_cast<IntDist>(y - oth.y)); }
 
    void addDiff(IntDist xdiff, IntDist ydiff) noexcept
        { x = static_cast<typename WidthType::type>(
                                        static_cast<IntDist>(x) + xdiff);
          y = static_cast<typename HeightType::type>(
                                        static_cast<IntDist>(y) + ydiff); }
                                        
    bool operator==(const Cursor & oth) const noexcept
        { return((oth.x == x) && (oth.y == y)); }
 
    bool operator!=(const Cursor & oth) const noexcept
        { return(!operator==(oth)); }
 
    Cursor operator+(const Cursor & oth) const
        { return(Cursor{static_cast<typename WidthType::type>(x + oth.x), 
                        static_cast<typename HeightType::type>(y + oth.y)}); }
 
    Cursor & operator+=(const Cursor & oth)
        { *this = *this + oth; return(*this); }
 
    Cursor operator-(const Cursor & oth) const 
        { if (this->rightBelow(oth)) 
            return(Cursor{ static_cast<typename WidthType::type>(x - oth.x), 
                           static_cast<typename HeightType::type>(y - oth.y)}); 
          else RUNTIMEEXCEP("Substracting incorrect cursors"); }
 
    Cursor & operator-=(const Cursor & oth)
        { *this = *this - oth; return(*this); }
 
    std::string to_string(bool withtype = true) const
        { if (withtype)
            return(std::string{"Cursor<"} + WidthType::name + "," + 
                 HeightType::name + 
                 ">(x: " + std::to_string(x) + ", y: " +
                 std::to_string(y) + ")");
          return(std::string{"(x: "} + std::to_string(x) + ", y: " +
                 std::to_string(y) + ")"); }
 
static_assert(std::is_base_of<CoordT,WRES>::value &&
              std::is_base_of<CoordT,HRES>::value,
              "WRES and HRES types in Cursor<> must be derived from CoordT");
};
 
using CharCursor = Cursor<CharCoordT,CharCoordT>;
 
using PixCursor = Cursor<PixelCoordT,PixelCoordT>;
 
using CharPixCursor = Cursor<CharCoordT,PixelCoordT>;
 
using BorderCursor = Cursor<BorderCoordT,BorderCoordT>;
 
 
inline PixCursor getPixCursor(const CharCursor & cc)
    { return(PixCursor{pixelOfCharX(cc.x),pixelOfCharY(cc.y)}); }
 
inline PixCursor getPixCursor(const CharPixCursor & cc)
    { return(PixCursor{pixelOfCharX(cc.x),cc.y}); }
 
inline CharPixCursor getCharPixCursor(const CharCursor & cc)
    { return(CharPixCursor{cc.x,pixelOfCharY(cc.y)}); } 
    
 
/*****************************************************************************
*
*   Template class: Area
*   Class aliases: CharArea, PixArea, CharPixArea, BorderArea
*   Function: getPixArea, getCharPixArea
*
*******************************************************************************/
 
template <typename WRES, typename HRES>
class Area
{
 public:
 
    using WidthType = WRES; 
    using HeightType = HRES; 
    using CursorType = Cursor<typename WRES::coord_typeT,
                              typename HRES::coord_typeT>; 
 
    typename WidthType::type width; 
    typename HeightType::type height; 
    
    static const Area & theEmpty(void) noexcept 
        { static const Area kz{0,0}; return(kz); }
    
 
    Area(typename WidthType::type w, 
         typename HeightType::type h): width{w},height{h} {}
 
    Area(WidthType w, HeightType h): width{w.value},height{h.value} {}
 
 
    Area(const CursorType & c0, const CursorType & c1)
        { if (!c1.rightBelow(c0)) RUNTIMEEXCEP("Invalid corners for area");
          width = c1.x - c0.x + 1; height = c1.y - c0.y + 1; }
 
    bool empty(void) const noexcept { return((width == 0) || (height == 0)); }
 
    size_t area(void) const noexcept 
        { return(static_cast<size_t>(width) * static_cast<size_t>(height)); }
 
    bool containedInto(const Area & oth) const noexcept
        { return((width <= oth.width) && (height <= oth.height)); }
 
    Area operator+(const Area & oth) const noexcept
        { return(Area{static_cast<typename WidthType::type>(width + oth.width), 
                      static_cast<typename HeightType::type>(height +oth.height)
                     }); }
 
    Area & operator+=(const Area & oth) noexcept
        { width += oth.width; height += oth.height; return(*this); }
 
    Area operator-(const Area & oth) const
        { if (!oth.containedInto(*this))
                 RUNTIMEEXCEP("Cannot substract larger area");
          return(Area{static_cast<typename WidthType::type>(width - oth.width), 
                      static_cast<typename HeightType::type>(height -oth.height)
                     }); }
 
    Area & operator-=(const Area & oth)
        { if (!oth.containedInto(*this))
                 RUNTIMEEXCEP("Cannot substract larger area");
          width -= oth.width; height -= oth.height; return(*this); }
 
    Area operator*(const Area & oth) const 
        { return(Area{std::min(width,oth.width),std::min(height,oth.height)}); } 
 
    Area & operator*=(const Area & oth)
        {   width = std::min(width,oth.width); 
            height = std::min(height,oth.height); return(*this); }
 
    bool operator==(const Area & oth) const noexcept
        { return((width == oth.width) && (height == oth.height)); }
 
    bool operator!=(const Area & oth) const noexcept
        { return(!operator==(oth)); }
 
    std::string to_string(bool withtype = true) const
        { if (withtype)
            return(std::string{"Area<"} + WidthType::name + "," + 
                 HeightType::name + 
                 ">[w: " + std::to_string((unsigned)width) + ", h: " +
                 std::to_string((unsigned)height) + "]");
          return(std::string{"[w: "} + 
                 std::to_string((unsigned)width) + ", h: " +
                 std::to_string((unsigned)height) + "]"); }
 
static_assert(std::is_base_of<DistT,WRES>::value &&
              std::is_base_of<DistT,HRES>::value,
              "WRES and HRES types in Area<> must be derived from DistT");
};
 
using CharArea = Area<CharDistT,CharDistT>;
 
using PixArea = Area<PixelDistT,PixelDistT>;
 
using CharPixArea = Area<CharDistT,PixelDistT>;
 
using BorderArea = Area<BorderDistT,BorderDistT>;
 
 
inline PixArea getPixArea(const CharArea & cc)
    { return(PixArea{charDistToPixelDist(cc.width),
                     charDistToPixelDist(cc.height)}); }
 
inline PixArea getPixArea(const CharPixArea & cc)
    { return(PixArea{charDistToPixelDist(cc.width),cc.height}); }
 
inline CharPixArea getCharPixArea(const CharArea & cc)
    { return(CharPixArea{cc.width,charDistToPixelDist(cc.height)}); }
 
 
/*****************************************************************************
*
*   Template class: Rect
*   Class aliases: CharRect, PixRect, BorderRect
*   Function: getPixRect, getCharPixRect
*
*******************************************************************************/
 
 
template <typename WRES, typename HRES>
struct Rect
{
    using cursor_type = Cursor<typename WRES::coord_typeT,
                               typename HRES::coord_typeT>;
    using area_type = Area<WRES,HRES>;
 
    cursor_type corner; 
    area_type area; 
 
    static const Rect & theEmpty(void) noexcept 
        { static const Rect kz{cursor_type::theZero(),
                               area_type::theEmpty()}; return(kz); }
 
 
    Rect(const cursor_type & c = cursor_type{0,0},
         const area_type & a = area_type{0,0}): corner{c},area{a} {}
 
    bool empty(void) const noexcept { return(area.empty()); }
 
    bool contains(const cursor_type & cur) const noexcept;
    
    cursor_type bottomRight(void) const noexcept
        { return(cursor_type{static_cast<typename WRES::coord_typeT::type>(
                                corner.x + area.width - 1),
                             static_cast<typename HRES::coord_typeT::type>(
                                corner.y + area.height - 1)}); }
 
    bool applyConstrainedDiffs(IntDist & xdiff, IntDist & ydiff,
                               const Rect & oth) noexcept;
 
    Rect compose(const Rect & reloth) const
 
        { return(Rect{corner + reloth.corner,
                      reloth.area}); }
 
    Rect subRect(const cursor_type & reltopleft) const
        { return(Rect{corner + reltopleft,
                      {static_cast<CharDist>(area.width - reltopleft.x),
                       static_cast<CharDist>(area.height - reltopleft.y)}}); }
 
    Rect intersect(const Rect & oth) const noexcept;
 
    Rect align_area(const area_type & areaneeded,
                    char horalign, char vertalign) const;
 
    bool operator==(const Rect & oth) const noexcept
        { return((corner == oth.corner) && (area == oth.area)); }
 
    bool operator!=(const Rect & oth) const noexcept 
        { return(!operator==(oth)); }
 
    std::string to_string(bool withtype = true) const
        { if (withtype)
            return(std::string{"Rect<"} + WRES::name + "," + HRES::name + 
                 ">{" + corner.to_string() + "; " +
                 area.to_string() + "}"); 
          else return(std::string{"{"} + corner.to_string(false) + "; " +
                 area.to_string(false) + "}"); }
 
static_assert(std::is_base_of<DistT,WRES>::value &&
              std::is_base_of<DistT,HRES>::value,
              "WRES and HRES types in Rect<> must be derived from DistT");
};
 
using CharRect = Rect<CharDistT,CharDistT>;
 
using PixRect = Rect<PixelDistT,PixelDistT>;
 
using CharPixRect = Rect<CharDistT,PixelDistT>;
 
using BorderRect = Rect<BorderDistT,BorderDistT>;
 
 
inline PixRect getPixRect(const CharRect & cc)
    { return(PixRect{getPixCursor(cc.corner),getPixArea(cc.area)}); }
 
inline PixRect getPixRect(const CharPixRect & cc)
    { return(PixRect{getPixCursor(cc.corner),getPixArea(cc.area)}); }
 
inline CharPixRect getCharPixRect(const CharRect & cc)
    { return(CharPixRect{getCharPixCursor(cc.corner),
                         getCharPixArea(cc.area)}); }
 
 
/*****************************************************************************
*
*    Classes: DoubleArea, DoubleRect
*
*******************************************************************************/
 
class DoubleArea
{
 public:
 
    CharArea chararea;  
    PixArea pixarea;    
 
    /* -------------- Constructors -------------- */
    DoubleArea(const CharArea & area = CharArea::theEmpty()):chararea{area},
                                                      pixarea{getPixArea(area)} 
        {}
 
    DoubleArea(const CharArea & carea, const PixArea & parea): chararea{carea},
                                                               pixarea{parea} 
        {}
 
    std::string to_string(void) const
        { return("DoubleArea: " + chararea.to_string() + " | " + 
                 pixarea.to_string()); }
};
 
 
class DoubleRect
{
 public:
 
    CharRect charrect;  
    PixRect pixrect;    
 
    /* -------------- Constructors -------------- */
    DoubleRect(const CharRect & rect = CharRect::theEmpty()):charrect{rect},
                                                   pixrect{getPixRect(rect)} 
        {}
 
    DoubleRect(const CharRect & crect, const PixRect & prect): charrect{crect},
                                                               pixrect{prect} 
        {}
 
    std::string to_string(void) const
        { return("DoubleRect: " + charrect.to_string() + " | " + 
                 pixrect.to_string()); }
};
 
 
/*****************************************************************************
*
*    Base Abstract Class: LinearGraphic
*
*******************************************************************************/
 
class LinearGraphic
{
 public:
 
        /* -------------- Types, consts, etc. -------------- */
 
    enum class GraphOp: unsigned char {
                 COPY,  
                 INV,   
                 OR,    
                 INVOR, 
                 AND,   
                 INVAND, 
                 XOR,   
                 INVXOR 
             };
 
 
         /* -------------- Class methods ----------- */
 
    template <LinearGraphic::GraphOp op>
        static constexpr uint8_t doGraphOp(uint8_t b0, uint8_t b1) noexcept;
    /* Constexpr's are inherently inline.
    (Specializations of this template are at the end of the class)*/
 
 
       /* -------------- Constructors -------------- */
 
    LinearGraphic(void);
 
    LinearGraphic(size_t s);
 
    LinearGraphic(size_t s, uint8_t b);
 
    LinearGraphic(uint8_t * bs, size_t s);
 
    LinearGraphic(LinearGraphic & oth, size_t firstoff, 
                  size_t chunksize, size_t gap, size_t numchunks);
 
    LinearGraphic(const LinearGraphic &) = delete; 
    LinearGraphic & operator=(const LinearGraphic &) = delete; 
    LinearGraphic(LinearGraphic &&og);
    LinearGraphic & operator=(LinearGraphic &&og);
 
    virtual ~LinearGraphic(void);
 
 
       /* -------------- Methods -------------- */
 
    bool external(void) const noexcept { return(external_); }
 
    bool owner(void) const noexcept { return(owner_); }
 
    size_t size(void) const noexcept { return(s_); }
 
    bool oneByte(void) const noexcept { return(onebyte_); }
 
    uint8_t getByte(size_t offset) const;
 
    uint8_t getByteUnsafe(size_t offset) const noexcept;
 
    uint8_t * getAllBytes(void);
 
    void setByte(size_t offset, uint8_t b);
 
    void setByteUnsafe(size_t offset, uint8_t b) noexcept;
 
    void setAllBytes(uint8_t b) noexcept;
 
    void merge(size_t destoffset, const LinearGraphic & oth, size_t origoffset,
               size_t howmany, GraphOp op = GraphOp::COPY);
 
    void mergeUnsafe(size_t destoffset, 
                     const LinearGraphic & oth, size_t origoffset,
                     size_t howmany, GraphOp op = GraphOp::COPY);
 
    int compare(const LinearGraphic & oth, bool withinv = false) const noexcept;
 
    size_t similarity(const LinearGraphic & oth) const noexcept;
 
    std::string to_string(void) const;
 
 
 protected:
 
    bool owner_;
    size_t s_;
 
    void clear(void);
    void reset(void);
    void moveFrom(LinearGraphic && og);
 
 private:
 
    bool external_;
    bool onebyte_;
    union {
           uint8_t thebyte; // if non-external, one-byte
           uint8_t * bytes; // if non-external, non-one-byte
           struct {
                    LinearGraphic * other;
                    size_t firstoff;
                    size_t chunksize;
                    size_t gap;
                    size_t numchunks;
                  } external; // if external
          } data_;  
};
 
 
/*****************************************************************************
*
*   Template Class: DimsGraphic
*   Function: graphicDimensionsTooLarge
*
*******************************************************************************/
 
 
template <typename HEIGHTRESOL>
class DimsGraphic: public LinearGraphic
{
 public:
 
    using CursorType = Cursor<CharCoordT,typename HEIGHTRESOL::coord_typeT>; 
    using AreaType = Area<CharDistT,HEIGHTRESOL>; 
    using RectType = Rect<CharDistT,HEIGHTRESOL>;
 
 
         /* -------------- Attributes -------------- */
 
    AreaType dims; 
 
 
       /* -------------- Constructors -------------- */
 
    DimsGraphic(void): LinearGraphic{}, dims{0,0} {}
 
    DimsGraphic(const AreaType & a):    LinearGraphic{sizeForDimensions(a)},
                                        dims{a} {}
 
    DimsGraphic(const AreaType & a, uint8_t b): 
                                        LinearGraphic{sizeForDimensions(a),b},
                                        dims{a} {}
 
    DimsGraphic(uint8_t *bs, const AreaType & a): 
                                        LinearGraphic{bs,sizeForDimensions(a)},
                                        dims{a} {}
 
    DimsGraphic(DimsGraphic & g, const RectType & region, bool copy = true);
 
    DimsGraphic(DimsGraphic && oth): dims{0,0} { moveFrom(std::move(oth)); }
 
    DimsGraphic & operator=(DimsGraphic && oth) 
        { if (this != &oth) { LinearGraphic::clear(); moveFrom(std::move(oth));}
          return(*this); }
        
       /* -------------- Methods -------------- */
 
    size_t offset(const CursorType & pos) const;
 
    CursorType coords(size_t offset) const;
 
    using LinearGraphic::getByte;
 
    uint8_t getByte(const CursorType & pos) const
        { return(LinearGraphic::getByteUnsafe(offset(pos))); }
 
    using LinearGraphic::setByte;
 
    void setByte(const CursorType & pos, uint8_t b)
 
        { LinearGraphic::setByteUnsafe(offset(pos),b); }
 
    void merge(const DimsGraphic & oth, const CursorType & pos,
               GraphOp mode = GraphOp::COPY);
 
 
    typename HEIGHTRESOL::type scrollUp(typename HEIGHTRESOL::type howmany, 
                                        typename HEIGHTRESOL::type upperrow,
                                        uint8_t fillb)
        { return(scrollUpRegion({{0,0},dims},howmany,upperrow,fillb)); }
 
    std::string to_string(void) const;
 
 
 private:
 
    static size_t sizeForDimensions(const AreaType & a)
        { return(static_cast<size_t>(a.width) * static_cast<size_t>(a.height));}
 
    void moveFrom(DimsGraphic && og)
        { // requires LinearGraphic::clear before if this contains anything
          dims = og.dims; 
          LinearGraphic::moveFrom(std::move(og)); 
          og.dims = {0,0}; 
        }
 
    typename HEIGHTRESOL::type scrollUpRegion(const RectType & region,
                                            typename HEIGHTRESOL::type howmany, 
                                            typename HEIGHTRESOL::type upperrow,
                                            uint8_t fillb);
 
static_assert(std::is_base_of<DistT,HEIGHTRESOL>::value,
              "HEIGHTRESOL type in DimsGraphic<> must be derived from DistT");  
 
};
 
 
template <typename WIDTHRESOL, typename HEIGHTRESOL>
inline bool graphicDimensionsTooLarge(unsigned sx, unsigned sy) noexcept
    { return((sx > FIntTraits<typename WIDTHRESOL::type>::maxval) ||
             (sy > FIntTraits<typename HEIGHTRESOL::type>::maxval)); }
 
 
/*****************************************************************************
*
*    Class: Bitmap
*
*******************************************************************************/
 
class Bitmap: public DimsGraphic<PixelDistT>
{
 public:
 
    using BaseGr = DimsGraphic<PixelDistT>;
 
 
       /* -------------- Constructors -------------- */
 
    using BaseGr::BaseGr;
 
    Bitmap(DesktopInterface & desktop, const std::string & pngfile);
 
    Bitmap(uint8_t ascii, uint8_t * chartable = nullptr);
 
       /* -------------- Methods -------------- */
 
    using BaseGr::merge;
 
    void merge(const Bitmap & oth, const PixCursor & pos,
               GraphOp mode = GraphOp::COPY);
 
    std::string to_string(void) const { return(BaseGr::to_string()); }
 
};
 
 
/*****************************************************************************
*
*    Class: Attrmap
*
*******************************************************************************/
 
class Attrmap: public DimsGraphic<CharDistT>
{
 public:
 
    using BaseGr = DimsGraphic<CharDistT>;
 
       /* -------------- Constructors -------------- */
 
    using BaseGr::BaseGr;
 
 
       /* -------------- Methods -------------- */
 
    void swapPaperInk(void);
 
    std::string to_string(void) const { return(BaseGr::to_string()); }
};
 
 
/*****************************************************************************
*
*    Class: DoubleGraphic
*
*******************************************************************************/
 
class DoubleGraphic
{
 public:
 
       /* -------------- Types, consts, etc. -------------- */
    
    enum class PNGConversionMode {
                                    ToNearestPlain, 
                                    Dither  
                                 };
 
    enum class PNGConversionSubmode {
                                        None,       
                                        FixedPattern, 
                                        Noise       
                                    };
                            
    using NumDithLevels = uint8_t;                          
                                    
    struct PNGConversionParms
    {
        PNGConversionMode mode; 
        PNGConversionSubmode submode; 
        struct { 
                } tonearestplain; 
        struct {
                NumDithLevels numlevels; 
                } dither; 
    };                                  
    
    
       /* -------------- Members -------------- */  
 
    Bitmap bitmap;
    Attrmap attrmap;
 
 
       /* -------------- Constructors -------------- */
 
    DoubleGraphic(const CharArea & dims):
                                bitmap{getCharPixArea(dims)},
                                attrmap{dims} {}
 
    DoubleGraphic(uint8_t * bs, uint8_t * as, const CharArea & a): 
                                bitmap{bs,getCharPixArea(a)},
                                attrmap{as,a} {}
 
    DoubleGraphic(DoubleGraphic & g, const CharRect & region, bool copy = true):
                                bitmap{g.bitmap,getCharPixRect(region),copy},
                                attrmap{g.attrmap,region,copy} {}
 
    DoubleGraphic(DesktopInterface & desktop, const std::string & pngfile,
                  const PNGConversionParms & parms = 
                    {PNGConversionMode::ToNearestPlain,
                     PNGConversionSubmode::None});
 
    DoubleGraphic(const DoubleGraphic &) = delete;
    DoubleGraphic & operator=(const DoubleGraphic &) = delete;
    DoubleGraphic(DoubleGraphic && oth):DoubleGraphic{CharArea{0,0}} 
        { moveFrom(std::move(oth)); }
    DoubleGraphic & operator=(DoubleGraphic && oth)
        { if (this != &oth) moveFrom(std::move(oth)); return(*this); }
        
    virtual ~DoubleGraphic(void);
 
 
       /* -------------- Methods -------------- */
 
 
    void merge(const DoubleGraphic & oth, const CharCursor & pos,
               LinearGraphic::GraphOp mode = LinearGraphic::GraphOp::COPY)
        { bitmap.merge(oth.bitmap,getCharPixCursor(pos));
          attrmap.merge(oth.attrmap,pos); }
          
 
    void savePNG(DesktopInterface & desktop, const std::string & pngfile);            
 
    std::string to_string(void) const 
        { return("Bitmap: " + bitmap.to_string() +
                 "; Attrmap: " + attrmap.to_string()); }
 
 private:
 
    using ColCountInCell = uint8_t; // max == 64
    using ColFreq = std::pair<RGBPalette::Index,ColCountInCell>;
    using ZXColorDecisor = std::function<
        std::pair<BrightColor,BrightColor>(const PNGConversionParms &,
                                           ColFreq *, 
                                           size_t) >;
 
    using ZXBitmapDecisor = std::function<
        bool(const PNGConversionParms &,
             const RasterCursor<1,1> &,
             const RGBColor &, const std::pair<BrightColor,BrightColor>) >;
 
    class DitheringSystem
    {
     public:
 
        using DitherLevel = NumDithLevels;
 
        static constexpr NumDithLevels kMinDiths = 3; // 2 pure + 1 dithered
        static constexpr NumDithLevels kMaxDiths = 101; // 2 pure + 99 dithd
 
        static constexpr RGBPalette::Size kNumPureColors =
                                BrightColor::NUMLINEARCOLORS - 1;
        static constexpr RGBPalette::Size kNumColorsButBright =
                                BrightColor::NUMLINEARCOLORS / 2;
        static constexpr RGBPalette::Size kClusterSizeButBright =
                                (kNumColorsButBright - 1) * 
                                kNumColorsButBright / 
                                2; // explanations in .cpp
        static constexpr RGBPalette::Size kClusterSize = 
                                kClusterSizeButBright * 2;
 
 
        class Color
        {
         public:
 
            friend DitheringSystem; // for DitheringSystem to be the factory
 
            RGBPalette::Index indexInPal(void) const noexcept 
                { return(palcolor_); }
 
            RGBColor rgbColor(void) const;
 
            RGBPalette::Index firstExtreme(void) const noexcept 
                { return(c0_); } // in ZX palette
            RGBPalette::Index secondExtreme(void) const noexcept 
                { return(c1_); } // in ZX palette
            DitherLevel ditherLevel(void) const noexcept { return(l_); }
 
            bool notDithered(void) const noexcept 
                { return((l_ == 0) || (l_ == dsys_->maxDithLevel())); }
 
            bool equalExtremesOrder(const Color & oc) const noexcept
                { checkSameLevs(oc); return((oc.c0_ == c0_) && (oc.c1_ ==c1_));}
 
            bool equalExtremesNotOrder(const Color & oc) const noexcept
                { checkSameLevs(oc); return((oc.c0_ == c1_) && (oc.c1_ ==c0_));}        
                
            bool equalExtremes(const Color & oc) const noexcept
                { checkSameLevs(oc);
                  return(equalExtremesOrder(oc) || equalExtremesNotOrder(oc)); }
 
            Color makeCompatibleWith(const Color & oc) const noexcept;
            
            std::string to_string(void) const;
            
         private:
 
            const DitheringSystem * dsys_;
            RGBPalette::Index palcolor_; // index of the color in dithered pal
            RGBPalette::Index c0_,c1_; // extreme colors of the color in ZX pal
            DitherLevel l_; 
            Color(RGBPalette::Index palind, const DitheringSystem & dithsys);
            Color(const RGBColor & rgb, const DitheringSystem & dithsys);
            
            void checkSameLevs(const Color & oth) const;            
            int closestLevel(const Color &oc) const;
        };  
 
 
        DitheringSystem(NumDithLevels nlvs): numlvs_{nlvs} 
            { if ((nlvs < kMinDiths) || (nlvs > kMaxDiths))
                RUNTIMEEXCEP("Out of range number of dithering levels"); }
        DitheringSystem(const DitheringSystem &) = delete;
        DitheringSystem(DitheringSystem &&) = delete;
        DitheringSystem & operator=(const DitheringSystem &) = delete;
        DitheringSystem & operator=(DitheringSystem &&) = delete;
 
        constexpr NumDithLevels numDithLevels(void) const noexcept
            { return(numlvs_); }
 
        constexpr NumDithLevels maxDithLevel(void) const noexcept
            { return(numlvs_ - 1); }
 
        constexpr DitherLevel inverseDithLevel(DitherLevel dl) const noexcept
            { return(maxDithLevel() - dl); }
 
        constexpr RGBPalette::Size numClusters(void) const noexcept
            { return(numlvs_ - 2); }
 
        constexpr RGBPalette::Size totalColors(void) const noexcept
            { return(kNumPureColors + // pure colors
                     kClusterSize * numClusters()); } // clusters of dithered
 
        double dithLevDegree(DitherLevel dl) const;
 
        const RGBPalette & ditheredPalette(void) const noexcept;
 
        Color deployColor(const RGBColor & rgb) const
            { return(Color{rgb,*this}); }
 
        Color deployColor(RGBPalette::Index palind) const
            { return(Color(palind,*this)); }
 
 
    private: // DitheringSystem
 
        static RGBColor rgbOfDitheredColor(const RGBColor & rgb0, 
                                           const RGBColor & rgb1,
                                           double ditherdegree); 
 
 
        NumDithLevels numlvs_;
    };
 
 
    template <typename ColorIndex>
    static void fillFreqs(const PalettizedImage<ColorIndex> & img,
                          const RasterCursor<8,8> & cl,
                          ColFreq * freqs)
    {
        for (RGBPalette::Index f = 0; f < img.palette().numColors(); ++f) 
            freqs[f] = std::make_pair(f,0);
        auto curpix = cl.subCursor(); // to scan that CELL at pixel resol.
        do ++(freqs[img.pixel(curpix)].second);
        while (curpix.forward());
 
        std::sort(freqs,freqs + img.palette().numColors(),
                  [](const ColFreq & lhs, const ColFreq & rhs) -> bool
                  { return(lhs.second > rhs.second); });
    }                                                                               
 
    static void reduceColors(const RGBPalette & pal, ColFreq * freqs);
 
    static void fillGraphicFromZXNoClash(
                                    const PalettizedImage<uint8_t> & palimg,
                                    const PNGConversionParms & parms,
                                    const ZXColorDecisor & zxcoldec,
                                    const ZXBitmapDecisor & zxbmdec,
                                    Bitmap & bitmap, Attrmap & attrmap);
                                    
    void fillGraphicFromRGB_ToNearestPlain(const RGBImage & rgbimg,
                                    const PNGConversionParms & parms,
                                    Bitmap & bitmap, Attrmap & attrmap);
    void fillGraphicFromRGB_Dither(const RGBImage & rgbimg,
                                    const PNGConversionParms & parms,
                                    Bitmap & bitmap, Attrmap & attrmap);
 
 
    void moveFrom(DoubleGraphic && oth)
        { bitmap = std::move(oth.bitmap); attrmap = std::move(oth.attrmap); } 
};
 
 
 
 
 
/*============================================================================
 
    TEMPLATE IMPLEMENTATIONS
 
==============================================================================*/
 
 
/*****************************************************************************
*
*   Template class: Rect
*
*******************************************************************************/
 
template <typename WRES, typename HRES>
bool Rect<WRES,HRES>::contains(const cursor_type & cur) const noexcept
{
    if (!cur.rightBelow(corner)) return(false);
    return(area_type{corner,cur}.containedInto(area));
}
 
template <typename WRES, typename HRES>
bool Rect<WRES,HRES>::applyConstrainedDiffs(IntDist & xdiff, IntDist & ydiff,
                                            const Rect & oth) noexcept
{
    auto oldx = corner.x;
    auto oldy = corner.y;
    auto newx = static_cast<CharCoord>(static_cast<IntDist>(corner.x) + xdiff);
    auto newy = static_cast<CharCoord>(static_cast<IntDist>(corner.y) + ydiff);
    if ((xdiff < 0) && 
        (static_cast<CharCoord>(-xdiff) > corner.x)) 
        newx = 0;
    if ((ydiff < 0) && 
        (static_cast<CharCoord>(-ydiff) > corner.y)) 
        newy = 0;
    if (static_cast<int>(corner.x) + static_cast<int>(xdiff) +
        static_cast<int>(area.width) > oth.corner.x + oth.area.width)
        newx = 
            static_cast<CharCoord>(oth.corner.x + oth.area.width - area.width);
    if (static_cast<int>(corner.y) + static_cast<int>(ydiff) +
         static_cast<int>(area.height) > oth.corner.y + oth.area.height)
        newy = 
            static_cast<CharCoord>(oth.corner.y + oth.area.height -area.height);
    corner.x = newx;
    corner.y = newy;
    xdiff = static_cast<IntDist>(newx) - static_cast<IntDist>(oldx);
    ydiff = static_cast<IntDist>(newy) - static_cast<IntDist>(oldy);
    return((newx != oldx) || (newy != oldy)); 
}
 
template <typename WRES, typename HRES>
Rect<WRES,HRES> Rect<WRES,HRES>::intersect(const Rect & oth) const noexcept
{
    using WCoordType = typename WRES::coord_typeT::type;
    using HCoordType = typename HRES::coord_typeT::type;
    using WDistType = typename WRES::type;
    using HDistType = typename HRES::type;
 
    Rect res; // empty
    if ((!empty()) && (!oth.empty()))
    {
        auto myxint = Interval<WCoordType>{corner.x,
                                           static_cast<WCoordType>(
                                            corner.x + area.width - 1)};
        auto myyint = Interval<HCoordType>{corner.y,
                                           static_cast<HCoordType>(
                                            corner.y + area.height - 1)};
        auto othxint = Interval<WCoordType>{oth.corner.x,
                                            static_cast<WCoordType>(
                                             oth.corner.x + oth.area.width -1)};
        auto othyint = Interval<HCoordType>{oth.corner.y,
                                            static_cast<HCoordType>(
                                             oth.corner.y + oth.area.height-1)};
        auto intersx = myxint.intersect(othxint);
        auto intersy = myyint.intersect(othyint);
        if ((!intersx.empty()) && (!intersy.empty()))
        {
            res.corner = {intersx.minimum(), intersy.minimum()};
            res.area = {static_cast<WDistType>(intersx.width() + 1),
                        static_cast<HDistType>(intersy.width() + 1)};
        }
    }
    return(res); 
}
 
template <typename WRES, typename HRES>
Rect<WRES,HRES> Rect<WRES,HRES>::align_area(const area_type & areaneeded, 
                                            char horalign, char vertalign) const
{
    if (!areaneeded.containedInto(area))
        RUNTIMEEXCEP("Cannot align needed area: greater than available zone");
    cursor_type cur = cursor_type::theZero();
    if (area.width > areaneeded.width)
    { // it has spare room horizontally
        switch (horalign)
        {
            case 'C':
            { 
                cur.x = (area.width - areaneeded.width) / 2; 
                break;
            }
            case 'R':
            { 
                cur.x = area.width - areaneeded.width; 
                break;
            }
        }
    }
    if (area.height > areaneeded.height)
    { // it has spare room vertically
        switch (vertalign)
        {
                case 'M':
                {
                    cur.y = (area.height - areaneeded.height) / 2; 
                    break;
                }
                case 'B':
                { 
                    cur.y = area.height - areaneeded.height; 
                    break;
                }
        }
    }
    return(Rect{corner + cur,areaneeded});
}                                            
 
 
 
/*****************************************************************************
*
*   LinearGraphic
*
*******************************************************************************/
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::COPY>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return(b1); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::INV>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return(~b1); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::OR>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return(b1 | b0); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::INVOR>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return((~b1) | b0); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::AND>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return(b1 & b0); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::INVAND>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return((~b1) & b0); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::XOR>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return(b1 ^ b0); }
 
template<>
constexpr uint8_t LinearGraphic::doGraphOp<LinearGraphic::GraphOp::INVXOR>(
                                                            uint8_t b0,
                                                            uint8_t b1) noexcept
    { return((~b1) ^ b0); }
 
 
/*****************************************************************************
*
*   Template Class: DimsGraphic
*
*******************************************************************************/
 
template <typename HEIGHTRESOL>
typename HEIGHTRESOL::type DimsGraphic<HEIGHTRESOL>::scrollUpRegion(
                                        const RectType & region,
                                        typename HEIGHTRESOL::type howmany, 
                                        typename HEIGHTRESOL::type upperrow,
                                        uint8_t fillb) 
// upperrow is relative to region (0 for top)
{
    if ((howmany == 0) || (howmany >= region.area.height) ||
        (upperrow >= region.area.height) || oneByte()) 
        return(upperrow);
 
    if (upperrow < howmany) 
        upperrow = static_cast<typename HEIGHTRESOL::type>(howmany);
    // The rest of rows dissapear, not move.
    // From now on, upperrow >= howmany
 
    const typename HEIGHTRESOL::type firstoverwritten = upperrow - howmany;
    const typename HEIGHTRESOL::type rowstomove = region.area.height - upperrow;
    size_t offsetfirstrow = // in the container graphic
        static_cast<size_t>(upperrow + region.corner.y) * 
            static_cast<size_t>(dims.width) + 
        static_cast<size_t>(region.corner.x);
    size_t offsetfirstoverwritten = 
        static_cast<size_t>(firstoverwritten + region.corner.y) * 
            static_cast<size_t>(dims.width) + 
        static_cast<size_t>(region.corner.x);
 
    // scroll up 
    for (typename HEIGHTRESOL::type f = 0; f < rowstomove; ++f)
    {
        LinearGraphic::mergeUnsafe(offsetfirstoverwritten,*this,offsetfirstrow,
                                   region.area.width); 
        offsetfirstrow += dims.width;
        offsetfirstoverwritten += dims.width;
    }
 
    // clear last rows
    offsetfirstrow = static_cast<size_t>(region.area.height - 1 + 
                                         region.corner.y) *
                        static_cast<size_t>(dims.width) +
                     static_cast<size_t>(region.corner.x);
    const LinearGraphic blankline{region.area.width,fillb};
    for (typename HEIGHTRESOL::type f = 0; f < howmany; ++f)
    {
        LinearGraphic::mergeUnsafe(offsetfirstrow,blankline,0,
                                   region.area.width);
        offsetfirstrow -= dims.width;
    }
    
    return(upperrow);
}
 
template <typename HEIGHTRESOL>
DimsGraphic<HEIGHTRESOL>::DimsGraphic(DimsGraphic & g, const RectType & region,
                                      bool copy): DimsGraphic{{0,0},54}
{
    if ((g.dims.width == 0) || (g.dims.height == 0))
        RUNTIMEEXCEP("Cannot construct empty DimsGraphic from another "
                     "DimsGraphic; g.width: " + std::to_string(g.dims.width) +
                     ", g.height: " + std::to_string(g.dims.height) +
                     "; g: " + g.to_string());
 
    if ((region.corner.x >= g.dims.width) ||
        (region.corner.y >= g.dims.height)) return; // all outside: empty result
 
    RectType reg = region;
    if (region.area.empty()) 
    {
        reg.area.width = g.dims.width - region.corner.x;
        reg.area.height = g.dims.height - region.corner.y;
    }
 
    auto w = std::min(reg.area.width, 
                      static_cast<CharDist>(
                            g.dims.width - reg.corner.x));
    auto h = std::min(reg.area.height, 
                      static_cast<
                        typename HEIGHTRESOL::coord_typeT::type>(
                            g.dims.height - reg.corner.y));
 
    if (copy)
    {
        // copy from G to this
        size_t offseting = g.offset(reg.corner);
        size_t offsetinthis = 0;
        *this = DimsGraphic{reg.area}; // create room
        for (typename HEIGHTRESOL::type y = 0; y < h ; ++y)
        {
            LinearGraphic::mergeUnsafe(offsetinthis, g, offseting, w);
            offsetinthis += dims.width;
            offseting += g.dims.width;
        }
    }
    else
    {
        // form a reference to G
        this->LinearGraphic::operator=(
                        LinearGraphic{g,g.offset(reg.corner),w,
                                      static_cast<size_t>(g.dims.width - w),
                                      reg.area.height}); 
        dims = reg.area;
    }
}
 
template <typename HEIGHTRESOL>
size_t DimsGraphic<HEIGHTRESOL>::offset(const CursorType & pos) const
{ 
    if ((pos.x >= dims.width) || (pos.y >= dims.height))
        RUNTIMEEXCEP(std::string{"Coordinates "} + pos.to_string() + 
                     " out of range in DimsGraphic " + to_string());            
     return(static_cast<size_t>(pos.y) *
            static_cast<size_t>(dims.width) +
            static_cast<size_t>(pos.x)); 
}
 
template <typename HEIGHTRESOL>
typename DimsGraphic<HEIGHTRESOL>::CursorType 
    DimsGraphic<HEIGHTRESOL>::coords(size_t offset) const
{ 
    if (offset >= s_) RUNTIMEEXCEP("Offset out of range in DimsGraphic");
    return(CursorType{static_cast<typename HEIGHTRESOL::coord_typeT::type>
                        (offset % dims.width),
                      static_cast<CharCoord>(offset / dims.width)}); 
}
 
template <typename HEIGHTRESOL>
void DimsGraphic<HEIGHTRESOL>::merge(const DimsGraphic & oth, 
                                     const CursorType & pos,
                                     GraphOp mode)
{
    if (oneByte()) 
        RUNTIMEEXCEP("Cannot merge nothing on a one-byte DimsGraphic");
 
    if ((oth.dims.width == 0) || (oth.dims.height == 0)) return;
 
    // pointer to the byte of the first byte in this graphic
    size_t thisoffset = static_cast<size_t>(pos.y) *
                        static_cast<size_t>(dims.width) +
                        static_cast<size_t>(pos.x);
 
    const CharDist firstinvisiblebinthis =
        std::min(oth.dims.width, static_cast<CharDist>(dims.width - pos.x));
    const typename HEIGHTRESOL::type firstinvisibleyg =
        std::min(oth.dims.height, static_cast<typename HEIGHTRESOL::type>(
                                                        dims.height - pos.y));
 
    for (typename HEIGHTRESOL::coord_typeT::type yg = 0; 
         yg < firstinvisibleyg; ++yg)
    {
        LinearGraphic::mergeUnsafe(thisoffset, // destination
                                   oth, oth.offset({0,yg}), // origin
                                   firstinvisiblebinthis, // howmany
                                   mode);
        thisoffset += static_cast<size_t>(dims.width);
    }
}
 
template <typename HEIGHTRESOL>
std::string DimsGraphic<HEIGHTRESOL>::to_string(void) const
{ 
    return(std::string{"DimsGraphic<"} + 
             AreaType::HeightType::name + ">{ width: " +
             std::to_string((unsigned)dims.width) + ", height: " +
             std::to_string((unsigned)dims.height) + "; " +
             LinearGraphic::to_string() + " }"); 
}
 
 
 
/*============================================================================
 
    GLOBAL ASSERTS
 
==============================================================================*/
 
 
static_assert(std::is_integral<PixelCoord>::value &&
              std::is_unsigned<PixelCoord>::value,
              "PixelCoord type must be integral and unsigned");
static_assert(std::is_integral<CharCoord>::value &&
              std::is_unsigned<CharCoord>::value,
              "CharCoord type must be integral and unsigned");
static_assert(std::is_integral<PixelDist>::value &&
              std::is_unsigned<PixelDist>::value,
              "PixelDist type must be integral and unsigned");
static_assert(std::is_integral<CharDist>::value &&
              std::is_unsigned<CharDist>::value,
              "CharDist type must be integral and unsigned");
static_assert(std::is_integral<IntDist>::value &&
              std::is_signed<IntDist>::value,
              "IntDist type must be integral and signed");
 
 
} // end namespace zxeco
 
#endif
 // ZXGraphics