ZXGUIGeneral.h

Go to the documentation of this file.

 
/* **************************************************************************/
#ifndef ZXGUIGENERAL
#define ZXGUIGENERAL
 
#define ZXGUIVER "3.0.0"
 
 
#include <string>
#include <vector>
#include <functional>
#include <filesystem>
#include <utility>
#include "zxecosystem/base/ZXColors.h"
#include "zxecosystem/base/ZXGraphics.h"
#include "zxecosystem/core/ZXScreen.h"
 
 
namespace zxeco
{
 
namespace gui
{
 
 
/*****************************************************************************
*
*   Class: WinColors
*
*******************************************************************************/
 
struct WinColors
{
 
    static const WinColors kLight; 
    static const WinColors kDark; 
 
 
    AttrColors title;       
    BrightColor backpaper;  
    BasicColor mainink;     
    BasicColor maindisink;  
    BasicColor decink;      
    BasicColor decdisink;   
    BrightColor typingpaper;    
    BrightColor typingdispaper; 
    BrightColor typingmarkpaper; 
    AttrColors cursor;      
    AttrColors tooltip;     
 
 
    uint8_t attrForBackground(void) const 
        { return(AttrColors{Flash{OFF},Bright{backpaper.bright()},
                            Paper{backpaper.color()}, Ink{mainink}}.toAttr()); }
 
    void setTitleColorsFor(Screen & scr, bool forborder = false) const
        { scr.colors() = {(forborder ? 
                            AttrColors{Flash{OFF},Bright{backpaper.bright()}, 
                                       Paper{backpaper.color()},Ink{mainink}} :
                            title), Inverse{OFF},Over{OFF}}; }
 
    void setBackgroundColorsFor(Screen & scr) const
        { scr.colors() = {{Flash{OFF},Bright{backpaper.bright()},
                           Paper{backpaper.color()},Ink{mainink}},
                          Inverse{OFF},Over{OFF}}; }
 
    void setMainColorsFor(Screen & scr, bool enabled) const
        { scr.colors() = {{Flash{OFF},Bright{backpaper.bright()},
                           Paper{backpaper.color()}, 
                          Ink{enabled ? mainink : maindisink}},
                          Inverse{OFF},Over{OFF}}; }
 
    void setDecorColorsFor(Screen & scr, bool enabled) const
        { scr.colors() = {{Flash{OFF},Bright{backpaper.bright()},
                           Paper{backpaper.color()}, 
                          Ink{enabled ? decink : decdisink}},
                          Inverse{OFF},Over{OFF}}; }
 
    void setTypingColorsFor(Screen & scr, bool enabled) const
        { const BrightColor & pc = enabled ? typingpaper : typingdispaper;
          scr.colors() = {{Flash{OFF},Bright{pc.bright()},
                           Paper{pc.color()},Ink{pc.color().contrasting()}},
                          Inverse{OFF},Over{OFF}}; }
 
    void setCursorColorsFor(Screen & scr) const
        { scr.colors() = {cursor,Inverse{OFF},Over{OFF}}; }
 
 
    std::string to_string(void) const
        { return("WinColors{ title: " + title.to_string() + 
                 "; background paper: " + backpaper.to_string() +
                 "; main ink: " + 
                 endistext(mainink.to_string(),maindisink.to_string()) + 
                 "; decorations ink: " +
                 endistext(decink.to_string(),decdisink.to_string()) +
                 "; typing paper: " + 
                 endistext(typingpaper.to_string(),typingdispaper.to_string()) + 
                 "; cursor colors: " +
                 cursor.to_string() + " }"); }
 
 private:
 
    static std::string endistext(const std::string & entxt, 
                                 const std::string & distxt)
        { return(entxt + " (enabled) or " + distxt + " (disabled)"); }
};
 
    
/*****************************************************************************
*
*   Helper Class: TypingZone
*
*******************************************************************************/
 
class TypingZone
{
 public:
 
    TypingZone(void): typing_zone_{{0,0},{0,0}} {}
 
    void set(const CharRect & zone) noexcept { typing_zone_ = zone; }
 
    const CharRect & get(void) const noexcept { return(typing_zone_); }
 
    void move(IntDist xdiff, IntDist ydiff) noexcept
        { typing_zone_.corner.addDiff(xdiff,ydiff); }
 
    void clear(Screen & globscr, const WinColors & wincols, bool enabled);
 
 private:
 
    CharRect typing_zone_;
};
 
 
/*****************************************************************************
*
*   Class: Label
*
*******************************************************************************/
 
 
class Label
{
 public:
 
    using Vector = std::vector<Label>;
 
 
    Label(void) {}
 
    Label(const std::string & initlabel) { set(initlabel); }
 
    Label(const char * initlabel) { set(initlabel); }
 
    void set(const std::string & label);
 
    void set(const char * label);
 
    const std::string & get(void) const noexcept { return(label_); }
 
 
 private:
 
    std::string label_;
};
 
 
/*****************************************************************************
*
*   Class: LabelList
*
*******************************************************************************/
 
 
class LabelList
{
 public:
 
    using Observer = std::function<void(char)>;
 
    using Indexes = std::vector<size_t>;
 
    class Iterator
    {
     public:
 
        enum : uint8_t {
                        IT_VISIBLE = 1,     
                        IT_INVISIBLE = 2,   
                        IT_MARKED = 4,      
                        IT_UNMARKED = 8     
                       };
 
        static const uint8_t IT_ANY_VISIBILITY = IT_VISIBLE | IT_INVISIBLE;
 
        static const uint8_t IT_ANY_MARKABILITY = IT_MARKED | IT_UNMARKED;
 
        static const uint8_t IT_ALL =   IT_ANY_VISIBILITY | IT_ANY_MARKABILITY;
 
        static const uint8_t IT_ALL_VISIBLE = IT_VISIBLE | IT_ANY_MARKABILITY;
 
        enum IniPos: uint8_t {
                        BEGIN,  
                        END     
                       };
 
        static bool labelSatisfiesCondition(uint8_t conditions,
                                            const LabelList & l,
                                            size_t who, unsigned marking = 0);
 
        Iterator(void);
 
        Iterator(const LabelList & l, uint8_t conditions = IT_ALL,
                 unsigned marking = 0, IniPos inip = BEGIN);
 
        Iterator(const Iterator & oth, uint8_t newconds,
                 unsigned newmarking = 0) noexcept;
 
        Iterator(const Iterator & oth) { copyFrom(oth); }
        Iterator(Iterator && oth) { moveFrom(std::move(oth)); }
        Iterator & operator=(const Iterator & oth)
            { if (this != &oth) copyFrom(oth); return(*this); }
        Iterator & operator=(Iterator && oth)
            { if (this != &oth) { moveFrom(std::move(oth)); } return(*this); }
 
 
        uint8_t conditions(void) const noexcept { return(conditions_); }
 
        unsigned marking(void) const noexcept { return(marking_); }
 
        size_t operator*(void) const;
 
        size_t advance(size_t n) noexcept;
 
        size_t retreat(size_t n) noexcept;
 
        Iterator & operator++(void) noexcept;
 
        Iterator & operator--(void) noexcept;
 
        bool operator==(const Iterator & oth) const;
 
        bool operator!=(const Iterator & oth) const;
 
        int operator-(const Iterator & rhs) const;
 
        std::string to_string(void) const;
 
     private:
 
        LabelList * l_;
        uint8_t conditions_;
        unsigned marking_;
 
        bool isend_;
        size_t pos_;
        size_t dist_;
        size_t begpos_;
 
        void checkderef(void) const;
        bool testconditions(void) const noexcept;
        void copyFrom(const Iterator & oth) noexcept;
        void moveFrom(Iterator && oth) noexcept;
    };
 
    static const Observer kNullObserver;
 
    const std::string kMarkingMultips; 
    const size_t kNumOfMarkings; 
 
 
    LabelList(const std::string & markingmultips,
              const Observer & obs = kNullObserver );
 
    LabelList(LabelList & oth, size_t begin, size_t length,
              const Observer & obs = kNullObserver) noexcept;
 
    LabelList(const Label::Vector & labels, const std::string & markingmultips,
              const Observer & obs = kNullObserver);
 
 
    LabelList(const LabelList & oth);
    LabelList(LabelList && oth);
    LabelList & operator=(const LabelList & oth);
    LabelList & operator=(LabelList && oth);
 
    virtual ~LabelList(void) {}
 
    virtual LabelList * clone(void) const { return(new LabelList{*this}); }
 
 
    void checkMarking(unsigned marking) const;
 
    void checkIndex(size_t who) const;
 
    size_t size(void) const noexcept;
 
    bool empty(void) const noexcept { return(size() == 0); }
 
    CharArea areaForEntireList(void) const;
 
    const Observer & observer(void) const noexcept { return(obs_); }
 
    void changeObserver(const Observer & obs) { obs_ = obs; }
 
    Iterator begin(uint8_t conditions = Iterator::IT_ALL, 
                   unsigned marking = 0) const;
 
    Iterator end(void) const { return(Iterator{}); }
 
    size_t sizeByIterator(Iterator it) const noexcept;
 
    size_t longestLabel(Iterator it) const noexcept;
 
    virtual std::string labelText(size_t who) const;
 
    Label & label(size_t who);
 
    bool marked(size_t who, unsigned marking = 0) const;
 
    bool visible(size_t who) const;
 
    LabelList sublist(const Indexes & inds) const;
 
    bool mark(size_t who, unsigned marking = 0);
 
    bool markAll(unsigned marking = 0);
 
    bool unmark(size_t who, unsigned marking = 0);
 
    bool unmarkAll(unsigned marking = 0);
 
    void toggle(size_t who, unsigned marking = 0);
 
    void toggleAll(unsigned marking = 0);
 
    virtual void setVisible(size_t who);
 
    virtual void setInvisible(size_t who);
 
    virtual void toggleVisible(size_t who);
 
 
    virtual void clear(void);
 
    size_t push_back(const Label & l) { return(insert(l,size())); }
 
    void push_back(const Label::Vector & v) 
    
        { for (const auto & l: v) push_back(l); }
 
    virtual size_t insert(const Label & l, size_t beforewho);
 
    void insert(const Label::Vector & v, size_t beforewho)
        { for (const auto & l: v) { insert(l,beforewho); ++beforewho; } }
 
    virtual void erase(size_t who);
 
    bool eraseMarked(unsigned marking = 0);
 
    void append(const LabelList & oth);
 
    void append(LabelList && oth);
 
    virtual void sort(char mode = 'A', std::vector<size_t> * order = nullptr);
 
    void fillWithFiles(const std::filesystem::path & path = {},
                       char mode = 'T', bool onlyfiles = false,
                       std::vector<std::string> * entries = nullptr);
 
    virtual std::string to_string(void) const;
 
 
 protected:
 
    class IndsRange
    {
     public:
 
        using IntervalType = Interval<size_t>;
 
        IndsRange(void) { clear(); }
 
        IndsRange(size_t b, size_t e):begin_{b},end_{e}
            { if (b > e) RUNTIMEEXCEP("Invalid index range for labellist"); }
 
        IndsRange(const IntervalType & i)
            { if (i.empty()) clear(); 
              else { begin_ = i.minimum(); end_ = i.maximum() + 1; } }
 
        
        size_t begin(void) const noexcept { return(begin_); }
        size_t end(void) const noexcept { return(end_); }
 
        bool empty(void) const noexcept { return(begin_ == end_); }
        size_t length(void) const noexcept 
            { return(empty() ? 0 : end_ - begin_); }
 
        size_t first(void) const  
            { if (empty()) RUNTIMEEXCEP("Empty labellist range has no first"); 
              return(begin_); }
        size_t last(void) const  
            { if (empty()) RUNTIMEEXCEP("Empty labellist range has no last");
              return(end_ - 1); }
        size_t nth(size_t offset) const
            { size_t i{first() + offset};
              if (i > last())
                RUNTIMEEXCEP("Invalid offset within a labellist range");
              return(i); }
 
        void clear(void) { begin_ = 0; end_ = 0; }
 
        void expand(size_t l) 
            { if (l == 0) return;
              if (empty()) RUNTIMEEXCEP("Cannot expand empty labellist range");
              end_ += l; }
 
        void contract(size_t l)
            { if (l == 0) return;
              if (l > length()) 
                RUNTIMEEXCEP("Cannot contract labellist range so much");
              end_ -= l; }
 
        Indexes toIndexes(void) const 
            { Indexes res; 
              if (!empty()) 
                for (size_t f = begin_; f < end_; ++f) res.push_back(f);
              return(res); }
 
        IntervalType toInterval(void) const
            { return(empty() ? IntervalType{0,0,IntervalCl::OPENED} :
                               IntervalType{first(),last()}); }
 
        std::string to_string(void) const 
            { return("labellist-range(" + 
                     (empty() ? "empty)" : std::to_string(first()) + " to " +
                                           std::to_string(last()) + "; " +
                                           std::to_string(length()) + 
                                           " label(s))")); }
 
     private:
 
        size_t begin_,end_;
    };
 
    using Marks = std::vector<bool>;
 
    Observer obs_;
    bool owner_;
    Label::Vector labels_; 
    std::vector<Marks> markings_;
    Marks visible_;
    LabelList * sect_;
    IndsRange sectrange_;
 
    void copyFrom(const LabelList & oth);
    void moveFrom(LabelList && oth);
 
 private:
 
    size_t actualPos(size_t p) const noexcept
        { return(owner_ ? p : sectrange_.nth(p)); }
    void checkOtherCompatibility(const LabelList & oth) const;
    void checkMultiple(unsigned marking = 0) const;
 
    void overwriteElement(const LabelList & oth, size_t pos, size_t dest);
    void overwriteSection(const LabelList & oth);
};
 
 
/*****************************************************************************
*
*   Class: LabelTree
*
*******************************************************************************/
 
 
class LabelTree: public LabelList
{
 public:
 
 
    class DepthFirstInserter
    {
     public:
 
        DepthFirstInserter(LabelTree & lt, size_t parentpos = 0): 
                                                        tree_{lt},
                                                        parent_{parentpos},
                                                        lastadded_{lt.size()} {}
 
        size_t add(const Label & l);
 
        void add(const Label::Vector & v) { for (const auto & l: v) add(l); }
            
        void openSubtree(void);
 
        void closeSubtree(void);
 
     private:
 
        LabelTree & tree_;
        size_t parent_;
        size_t lastadded_;
    };
 
 
    LabelTree(const std::string & markingmultips, 
              const Observer & obs = kNullObserver);
 
    LabelTree(const LabelTree & oth);
    LabelTree(LabelTree && oth);
    LabelTree & operator=(const LabelTree & oth);
    LabelTree & operator=(LabelTree && oth);
 
    LabelList * clone(void) const override { return(new LabelTree{*this}); }
 
    const std::string & preffixChars(void) const noexcept { return(chars_); }
 
    void changePreffixChars(const std::string & preffixchars);
 
    virtual std::string preffixForLabel(size_t who, 
                                        size_t * posdeploy = nullptr) const;
 
    std::string labelText(size_t who) const override
 
        { return(preffixForLabel(who) + LabelList::labelText(who)); }
 
    size_t depth(size_t pos) const;
 
    size_t depth(void) const;
 
    bool hasChildren(size_t parent) const
 
        { checkIndex(parent); return(!subtreeRange(parent,false).empty()); }
 
    Indexes firstBorn(size_t parent) const;
 
    LabelTree subtree(size_t parent, bool withparent = false, 
                      Indexes * indexmap = nullptr) const;
 
    size_t insert(const Label & l, size_t beforewho) override;
 
    virtual size_t insert_child(const Label & l, size_t parent);
 
    void erase(size_t who) override;
 
    virtual void erase_children(size_t who);
 
    void setVisible(size_t who) override 
 
        { changeSubtreeVisible(who,true,true); }
 
    void setInvisible(size_t who) override 
 
        { changeSubtreeVisible(who,false,true); }
 
    void toggleVisible(size_t who) override 
 
        { toggleSubtreeVisible(who,true); }
 
    virtual void changeVisibilityDepth(size_t fromdepth, bool visib);
 
    virtual void toggleFolding(size_t who);
 
    void sort(char mode = 'A', 
              std::vector<size_t> * order = nullptr) override;
 
 
    void clear(void) override;
    std::string to_string(void) const override;
 
 
 protected:
 
    std::string chars_;
    std::vector<size_t> depths_;
 
    Observer skipObserver(void);
    void retrieveObserver(const Observer & obs, char reason);
 
    IndsRange subtreeRange(size_t pos, bool withparent = true) const;
    size_t parent(size_t pos) const;
    size_t prevSibling(size_t pos) const;
    size_t nextSibling(size_t pos) const;
    size_t lastRoot(void) const;
 
 
 private:
 
    void copyFrom(const LabelTree & oth);
    void moveFrom(LabelTree && oth);
    
    void toggleSubtreeVisible(size_t root, bool withroot);
    void changeSubtreeVisible(size_t root, bool visi, bool withroot);
};
 
 
/*****************************************************************************
*
*   Class: LabelDirBrowser
*
*******************************************************************************/
 
 
class LabelDirBrowser: public LabelTree
{
 public:
 
    LabelDirBrowser(const std::string & markingmultips,
                    const Observer & obs = kNullObserver);
 
    LabelDirBrowser(const LabelDirBrowser & oth);
    LabelDirBrowser(LabelDirBrowser && oth);
    LabelDirBrowser & operator=(const LabelDirBrowser & oth);
    LabelDirBrowser & operator=(LabelDirBrowser && oth);
 
    LabelList * clone(void) const override {return(new LabelDirBrowser{*this});}
 
    void clear(void);
 
    size_t readStartingPath(const std::filesystem::path & p);
 
    std::string preffixForLabel(size_t who, 
                                size_t * posdeploy = nullptr) const override;
 
    std::filesystem::path absolutePath(size_t who) const;
 
    bool isParent(size_t who) const;
 
    void toggleFolding(size_t who) override;
 
 private:
 
    std::string getlastdirname(const std::filesystem::path & path);
 
    std::vector<std::string> entries_;
    std::vector<bool> explored_;
 
    void copyFrom(const LabelDirBrowser & oth);
    void moveFrom(LabelDirBrowser && oth);
 
    void insert_children(size_t p);
    void erase_children(size_t p) override;
 
    // Change to private (from a virtual reference, the base methods will still
    // be visible; they are only private for this derived class used as such).
    using LabelTree::insert;
    using LabelTree::insert_child;
    using LabelTree::erase;
    using LabelTree::setVisible;
    using LabelTree::setInvisible;
    using LabelTree::toggleVisible;
    using LabelTree::changeVisibilityDepth;
    using LabelTree::sort;
};
 
 
 
} // end namespace gui
} // end namespace zxeco
 
#endif
 // ZXWindows