ZXWidgetsBase.h

Go to the documentation of this file.

 
/* **************************************************************************/
#ifndef ZXWIDGETS_BASE
#define ZXWIDGETS_BASE
 
#include <string>
#include <sstream>
#include <functional>
#include <memory>
#include <vector>
#include <utility>
#include <algorithm>
#include "zxecosystem/core/ZXEcosystem.h"
#include "zxecosystem/gui/ZXGUIGeneral.h"
 
 
namespace zxeco
{
 
namespace gui
{
 
class Window; // declared elsewhere
class ContainerWidget; // forwardly declared
 
/*****************************************************************************
*
*   Abstract Base Class: Widget
*
*******************************************************************************/
 
 
class Widget
{
friend ContainerWidget; // For containers to call private methods of Widget
 
 public:
 
    /* -------------- General types, consts, etc. -------------- */
 
    using ID = int;
 
 
    using Ptr = std::shared_ptr<Widget>;
 
    class PVector: public std::vector<Ptr>
    {
     public:
 
        using Base = std::vector<Ptr>; 
 
        using Base::Base; 
 
        Widget * addChildOf(const Ptr & w, Widget & parent)
 
            { push_back(w); back()->setParent(&parent); return(back().get()); }
    };
 
 
    class Path: public std::vector<Widget *>
    {
     public:
 
        using Base = std::vector<Widget *>;
 
        Path(bool downorup):Base{},downorup_{downorup} {}
 
        Path(Widget * pw);
 
        bool isDownwards(void) const noexcept { return(downorup_); }
 
        bool isUpwards(void) const noexcept { return(!downorup_); }
 
        std::string to_string(void) const;
 
     private:
 
        bool downorup_;
    };
 
 
    enum class TravResult {
                            FINISH_OK,  
                            FINISH_FAIL,
                            BACKTRACK,
                            CONTINUE
                          };
 
    using TraverseObserver = std::function< TravResult(Widget &) >;
 
    /* -------------- Drawing types, consts, etc. -------------- */
    struct AreaFitting
    {
        using Vector = std::vector<AreaFitting>; 
 
        enum class Fit {
                        UNFIT,      
                        FIT,        
                        FLEXFIT     
                       };
 
 
        enum : uint8_t {
                        FLEX_HOR = 1,       
                        FLEX_VER = 2        
                     };
 
 
        LongestUnsignedType creattime; 
        Widget * widget; 
        Widget * widgetcause; 
        CharArea provided; 
        Fit fitting; 
        CharArea needed; 
        uint8_t flexdim; 
        std::string explanation; 
 
 
        AreaFitting(const CharArea & prov, Widget * wi, 
                    const std::string & expl = ""): 
                                creattime{utime_now()},
                                widget{wi},widgetcause{wi},
                                provided{prov},
                                fitting{Fit::UNFIT},
                                needed{0,0},flexdim{0},
                                explanation{expl} {}
 
        AreaFitting(const CharArea & prov, Widget * wi, 
                    const CharArea & ndd, uint8_t fds = 0): 
                                creattime{utime_now()},
                                widget{wi},widgetcause{nullptr},
                                provided{prov},
                                fitting{Fit::FLEXFIT},
                                needed{ndd},flexdim{fds}
            { if (fds == 0) fitting = Fit::FIT; }
 
        AreaFitting(Widget * wi, const CharArea & ndd, 
                    const CharArea & availablearea);
 
        AreaFitting(Widget * wi, const AreaFitting & oaf):AreaFitting{oaf}
            { widget = wi; }
 
        AreaFitting(Widget * wi, AreaFitting && oaf):AreaFitting{std::move(oaf)}
 
            { widget = wi; }
 
        AreaFitting & operator=(const AreaFitting & oaf)
            { copyFrom(oaf); return(*this); }
 
        AreaFitting & operator=(AreaFitting && oaf)
            { if (this != &oaf) moveFrom(std::move(oaf)); return(*this); }
 
        void assign(Widget * wi, const AreaFitting & oaf)
            { copyFrom(oaf); widget = wi; }
 
        void assign(Widget * wi, AreaFitting && oaf)
 
            { if (this != &oaf) moveFrom(std::move(oaf)); 
              widget = wi; creattime = utime_now(); }
 
 
        operator bool(void) const noexcept { return(fitting != Fit::UNFIT); }
 
        std::string to_string(void) const;
 
     private:
 
        AreaFitting(const AreaFitting & oaf):needed{0,0},provided{0,0}
            { copyFrom(oaf); creattime = utime_now(); }
        AreaFitting(AreaFitting && oaf):needed{0,0},provided{0,0} 
            { moveFrom(std::move(oaf)); }
 
        void copyFrom(const AreaFitting & oaf);
        void moveFrom(AreaFitting && oaf);
    };
 
    enum class HorAlign {
                            LEFT,
                            RIGHT,
                            CENTER
                           };
 
    enum class VertAlign {
                            TOP,
                            BOTTOM,
                            MIDDLE
                           };
 
    /* -------------- Event types, consts, etc. -------------- */
    enum class EventType {
                            MOUSE,      
                            KEYBOARD,   
                            FOCUS       
                         };
 
    enum class SubEvType {
                            MOUSE_MOVE,     
                            MOUSE_CLICK,    
                            MOUSE_UNCLICK,  
                            MOUSE_WHEEL,    
                            KEYB_PRESS,     
                            KEYB_UNPRESS,   
                            KEYB_TEXT,      
                            FOCUS_GOT,      
                            FOCUS_LOST      
                          };
 
 
 
    struct EventData
    {
        EventType evt;      
        SubEvType subevt;   
        struct EvData { // better not to be union: contains non-trivial string
                        // and also because key events also store the last known
                        // mouse position (to decide about being those keys
                        // pressed while the mouse is over some widget).
                int32_t wheelincr{0}; 
                PointingStatus mouse; 
                DesktopInterface::KeyID key{
                    DesktopInterface::KeyID::NUM_OF_KEY_IDS}; 
 
                std::string text; 
                EvData(int32_t wi):wheelincr{wi} {}
                EvData(const PointingStatus & m):mouse{m} {}
                EvData(const DesktopInterface::KeyID k):key{k} {}
                EvData(const char * chutf8):text(chutf8) {}
                EvData(const EvData & o) { copyFrom(o); }
                EvData(EvData && o) { copyFrom(o); }
                EvData & operator=(const EvData & o) 
                    { copyFrom(o); return(*this); }
                EvData & operator=(EvData && o) 
                    { copyFrom(o); return(*this); }
                ~EvData(void) {}
 
               private:
 
                void copyFrom(const EvData & o)
                    { wheelincr = o.wheelincr; mouse = o.mouse; key = o.key;
                      text = o.text; }
 
              } evdata; 
 
        EventData(void): evt{EventType::FOCUS},subevt{SubEvType::FOCUS_LOST},
                         evdata{DesktopInterface::KeyID::NUM_OF_KEY_IDS} {}
 
        EventData(int32_t wincr): evt{EventType::MOUSE},
                                  subevt{SubEvType::MOUSE_WHEEL},
                                  evdata{wincr} {}
 
        EventData(EventType e, SubEvType s, const PointingStatus & m);
 
        EventData(SubEvType s, DesktopInterface::KeyID key);
 
        EventData(const char * chutf8) : evt{EventType::KEYBOARD},
                                         subevt{SubEvType::KEYB_TEXT},
                                         evdata{chutf8} {}
 
        EventData(const EventData & o):EventData{} { copyFrom(o); }
        EventData(EventData && o):EventData{} { copyFrom(o); }
        EventData & operator=(const EventData & o)
            { copyFrom(o); return(*this); }
        EventData & operator=(EventData && o)
            { copyFrom(o); return(*this); }
 
        DesktopInterface::KeyID keyOrWheelIntoKey(void) const;
 
        bool isMouseClick(void) const noexcept
            { return((evt == EventType::MOUSE) &&
                     (subevt == SubEvType::MOUSE_CLICK)); }
 
        bool isMouseUnclick(void) const noexcept
            { return((evt == EventType::MOUSE) &&
                     (subevt == SubEvType::MOUSE_UNCLICK)); }
 
        bool isMouseRightClick(void) const noexcept
            { return(isMouseClick() && evdata.mouse.buttonright); }
 
        bool isMouseLeftClick(void) const noexcept
            { return(isMouseClick() && evdata.mouse.buttonleft); }
 
        bool isMouseRightUnclick(void) const noexcept
            { return(isMouseUnclick() && (!evdata.mouse.buttonright)); }
 
        bool isMouseLeftUnclick(void) const noexcept
            { return(isMouseUnclick() && (!evdata.mouse.buttonleft)); }
 
        bool isMouseMove(void) const noexcept
            { return((evt == EventType::MOUSE) &&
                     (subevt == SubEvType::MOUSE_MOVE)); }
 
        bool isMouseWheel(void) const noexcept
            { return((evt == EventType::MOUSE) &&
                     (subevt == SubEvType::MOUSE_WHEEL)); }
 
        bool isKeyPressed(void) const noexcept
 
            { return((evt == EventType::KEYBOARD) &&
                     (subevt == SubEvType::KEYB_PRESS)); }
 
        bool isKeyUnpressed(void) const noexcept
 
            { return((evt == EventType::KEYBOARD) &&
                     (subevt == SubEvType::KEYB_UNPRESS)); }
 
        bool isRecognizedText(void) const noexcept
            { return((evt == EventType::KEYBOARD) &&
                     (subevt == SubEvType::KEYB_TEXT)); }
 
        bool isGotFocus(void) const noexcept
            { return((evt == EventType::FOCUS) && 
                     (subevt == SubEvType::FOCUS_GOT)); }
 
        bool isLostFocus(void) const noexcept
            { return((evt == EventType::FOCUS) && 
                     (subevt == SubEvType::FOCUS_LOST)); }
 
        bool needsFocus(void) const noexcept
 
            { return(// needs focus to lose the focus:
                     isLostFocus() || 
                     // needs focus if it is a non-motion key:
                     (isKeyPressed() || isKeyUnpressed()) ||
// The following prevented motion keys for being dealt with by focused widgets
// that could benefit from them when they were not pressed/unpressed within the
// widgets spatial area.                     
//                   ((isKeyPressed() || isKeyUnpressed()) 
//                      && (!DesktopInterface::keyIsForMotion(evdata.key))) ||
                     // needs focus if it is a typed text:
                     isRecognizedText()); }
 
        bool hasMouse(void) const noexcept
            { return((!isLostFocus()) && 
                     (!isKeyPressed()) && (!isKeyUnpressed())); }
 
 
        std::string to_string(void) const;
 
     private:
 
        void copyFrom(const EventData & o)
            { evt = o.evt; subevt = o.subevt; evdata = o.evdata; }
 
    };
 
 
    struct ChainEventResult
    {
        enum { 
                PROCESSED_OK,   
                PROCESSED_FINISH, 
                NOT_PROCESSED, 
                WINCLOSE 
             };
 
 
        int result; 
        Widget * who; 
        ChainEventResult(bool winclose = false):result{winclose? WINCLOSE :
                                                                 NOT_PROCESSED},
                                                who{nullptr} {}
 
        ChainEventResult(int r):result{r},who{nullptr} {}
 
        ChainEventResult(int r, Widget * p):result{r},who{p} {}
 
        std::string to_string(void) const
            { return(std::string{result == PROCESSED_OK ? "PROCESSED_OK" :
                                    result == PROCESSED_FINISH ? 
                                        "PROCESSED_FINISH" :
                                            result == WINCLOSE ?
                                                "WINCLOSE" : "NOT_PROCESSED"} +
                    (who == nullptr ? std::string{", no leaf widget"} :
                                      (std::string{", leaf widget ID "} +
                                         std::to_string(who->getID())))); }
 
    };
 
 
    struct CallbackParms
    {
        char moment; 
        Widget * whoprocessed; 
        const EventData * pevd; 
 
 
        bool isAfterWithData(void) const noexcept 
            { return((moment == 'A') && (pevd != nullptr)); }
 
        bool isBeforeWithData(void) const noexcept
            { return((moment == 'B') && (pevd != nullptr)); }
 
        bool isToGetFocus(void) const noexcept
            { return(isBeforeWithData() && pevd->isGotFocus()); }
 
 
        bool hasBeenLeftClicked(void) const noexcept
            { return(isAfterWithData() && pevd->isMouseLeftUnclick()); }
 
 
        bool hasPressedKey(DesktopInterface::KeyID k) const noexcept
            { return(isAfterWithData() && pevd->isKeyUnpressed() &&
                     (pevd->evdata.key == k)); }
 
        bool hasPressedEnter(void) const noexcept
            { return(hasPressedKey(DesktopInterface::K_ENTER)); }
 
        bool hasBeenLeftClickedOrEnter(void) const noexcept
            { return(hasBeenLeftClicked() || hasPressedEnter()); } 
 
 
        std::string to_string(void) const
            { return("CallbackParms: moment = " + std::string(1,moment) +
                     ", whoprocessed = " + (whoprocessed == nullptr ? "null" :
                                                whoprocessed->idText()) +
                     ", eventadata = " + (pevd == nullptr ? "null" :
                                            pevd->to_string())); }
    };
 
    using CallbackRout = std::function< bool(Widget &, const CallbackParms &)>;
 
    static const CallbackRout NullCallback;
 
    /* -------------- Tracing errors -------------- */
 
    struct Trace
    {
        using Type = uint8_t;
 
        enum : Type {
                        Drawing = 1 
                        // TODO: Events = 2,  ///< All events except mouse move.
                        // TODO: EvMMove = 4, ///< Mouse move events
                       };
    };
 
    static const std::string kTraceBegin;
    static const std::string kTraceEnd;
 
    static void addGlobalTraces(Trace::Type traces) noexcept 
        { traces_ |= traces; }
 
    static void delGlobalTraces(Trace::Type traces) noexcept 
        { traces_ &= ~traces; }
 
    static inline Trace::Type isTracing(Trace::Type traces) noexcept
        { return(traces_ & traces); }
 
    static void printTrace(Trace::Type trace, const std::string & tr); 
 
    static void printIfTrace(Trace::Type trace, const std::string & tr); 
 
    /* -------------- Constructors -------------- */
    Widget(ID id, const std::string & name,
            const std::string & tooltiptext = "",
            HorAlign hal = HorAlign::LEFT, 
            VertAlign val = VertAlign::TOP):    
                                    id_{id},
                                    name_{nonCtrlString(name)},
                                    visible_{true},
                                    enabled_{true},
                                    focused_{false},
                                    drawn_{false},
                                    callback_{NullCallback},
                                    hal_{hal},val_{val},
                                    fitting_needs_{{0,0},this},
                                    pwin_{nullptr},
                                    pwincols_{nullptr},
                                    parent_{nullptr},
                                    explaindrawing_{false},
                                    udgs_{nullptr} 
        { setTooltip(tooltiptext); }
 
    Widget(const Widget &) = delete;
    Widget(Widget &&) = delete;
    Widget & operator=(const Widget &) = delete;
    Widget & operator=(Widget &&) = delete;
 
    virtual ~Widget(void) = default;
 
    /* -------------- General Methods -------------- */
    virtual const char * className(void) const noexcept = 0;
 
    std::string idText(bool withpointer = false) const;
 
    virtual bool isContainer(void) const noexcept { return(false); }
 
    bool isUserContainer(void) const noexcept;
 
    ID getID(void) const noexcept { return(id_); }
 
    void changeID(ID id) noexcept { id_ = id; }
 
    const std::string & getName(void) const noexcept { return(name_); }
 
    bool operator==(const Widget & oth) const noexcept { return(this == & oth);}
 
    bool operator!=(const Widget & oth) const noexcept { return(this != & oth);}
 
    virtual std::pair<bool,const CharRect *> hasFocusZone(void) const noexcept
 
        { return(std::make_pair(false,nullptr)); }
 
    virtual void setWindow(Window & win) noexcept { pwin_ = & win; }
 
    virtual void setWinColors(const WinColors & wincols) noexcept 
        { pwincols_ = & wincols; }
 
    const WinColors & getWinColors(void) const noexcept { return(*pwincols_); }
 
    virtual void setUDGs(const uint8_t * udgs) { udgs_ = udgs; }        
 
    const uint8_t * getUDGs(void) { return(udgs_); }        
 
    virtual void setTooltip(const std::string & ttt) 
    
        { tooltiptext_ = nonCtrlString(ttt); }
 
    const std::string & getTooltip(void) const noexcept { return(tooltiptext_);}
 
    /* -------------- Widget tree methods -------------- */
    void setParent(Widget * parent);
 
    Widget * getParent(void) const noexcept { return(parent_); }
 
    Widget * getRoot(void);
 
    bool isRoot(void) const noexcept { return(parent_ == nullptr); }
 
    bool isDescendantOf(Widget & w) const;
 
    Widget * searchID(ID id) const;
 
    ID maxUsedID(void) const;
 
    TravResult traverse(const TraverseObserver & obs);
 
    TravResult revTraverse(const TraverseObserver & obs);
 
    /* -------------- Visibility, enabling and focus methods -------------- */
    void setVisibility(bool visible = true); 
 
    void setVisibilityNoRedrawing(bool vis) noexcept { visible_ = vis; }
 
    bool getVisibility(void) const noexcept;
 
    void setEnabled(bool enabled = true);
 
    bool getEnabled(void) const noexcept;
 
    bool isFocusable(bool drawntoo = true) const;
 
    bool isInFocusPath(void) const noexcept { return(focused_); }
 
    bool isLeafFocused(void) const noexcept
        { return(isInFocusPath() && !isContainer()); }
 
    Widget * whoIsFocused(void);
 
    void acquireFocus(const PointingStatus * m = nullptr);
 
    void releaseFocus(void);
 
    /* -------------- General, Top-Level Drawing Methods -------------- */
    void drawAll(const CharRect & rect);
 
    Widget * redrawAll(void);
 
    void redrawMe(void);
 
    void drawMe(void);
 
    /* --- Parts of the calculation, placement & drawing general process --- */
    virtual const AreaFitting & calcFittingNeeds(const CharArea & area) = 0; 
 
    const AreaFitting & fittingNeeds(void) const noexcept 
 
        { return(fitting_needs_); }
 
    virtual Widget * setDrawingZone(const CharRect & zone);
 
    const CharRect & drawingZone(void) const noexcept
 
        { return(drawing_zone_); }
 
    const CharRect & alignedDrawingZone(void) const noexcept
 
        { return(aligned_drawing_zone_); }
 
    virtual void moveDrawingZones(IntDist incx, IntDist incy) noexcept;
 
    bool drawn(void) const noexcept { return(drawn_); }
 
    void undraw(void) noexcept { drawn_ = false; }
 
    /* --------- Getting explanations of drawing of one widget -------------- */
    /* (NOTICE THAT FOR TRACING ERRORS MAYBE BETTER TO USE THE TRACING GLOBAL
        ONES -SEE ABOVE- ) */
    void setExplanations(bool setit = true) noexcept 
 
        { explaindrawing_ = setit; }
 
    bool getExplanations(void) const noexcept { return(explaindrawing_); }
 
    std::string traceOfDrawing(bool withoutprivate = true) const
 
        { std::stringstream ss; traceOfDrawingRecursive(0,ss,withoutprivate); 
          return(ss.str()); }
 
    virtual void traceOfDrawingRecursive(size_t level, 
                                         std::stringstream & ss,
                                         bool withoutprivate = true) const;
 
    /* -------------- Interaction Methods -------------- */
    virtual ChainEventResult chainEvent(const EventData & data);
 
    virtual void setCallback(const CallbackRout & callback = NullCallback) 
    
        { callback_ = callback; }
 
    const CallbackRout & getCallback(void) const noexcept { return(callback_); } 
 
    void addCallback(const CallbackRout & cbk);
 
 protected:
 
    static Trace::Type traces_; 
 
 
    ID id_;
    const std::string name_;
 
    const WinColors * pwincols_;
    const uint8_t * udgs_;
    Window * pwin_;
 
    // use the public methods to change these
    // (read them directly without problems, though)
    CallbackRout callback_; 
    std::string tooltiptext_;
    HorAlign hal_;
    VertAlign val_;
    AreaFitting fitting_needs_;
    CharRect drawing_zone_;
    CharRect aligned_drawing_zone_;
    Widget * parent_;
    bool explaindrawing_;
 
 
    virtual void drawRaw(void) {}
 
    virtual int processEvent(const EventData & evdata, Widget * who) 
    
        { return(1); }
 
    void addLineToExplanation(const std::string & line);
 
 private:
 
    static const std::string & traceName(Trace::Type trace);
 
    bool visible_; 
    bool enabled_; 
    bool focused_; 
    bool drawn_;   
 
    CharRect alignArea(const CharRect & availablezone,
                       const CharArea & areaneeded) const
        { return(availablezone.align_area(areaneeded,
                            hal_ == HorAlign::CENTER ? 'C' :
                                (hal_ == HorAlign::RIGHT ? 'R' : 'L'),
                            val_ == VertAlign::MIDDLE ? 'M' :
                                (val_ == VertAlign::BOTTOM ? 'B' : 'T'))); }
    bool decideCanQuitFocus(const Path & mypathtoroot) const;
    void updateFocus(bool focusgotorlost);
    Widget * recalcDrawingZones(bool directparent,
                                CharRect & old_drawing_zone_,
                                Widget * & ptrcause);
    Widget * drawAllFrom(Widget * from, const CharRect & rect, 
                         bool onlyifchanged);
    void draw(bool cls = true);
    bool coversTargetOfEvent(const EventData & evdata, CharCursor & cc) const;
};
 
 
/*****************************************************************************
*
*   Class: ContainerWidget
*
*******************************************************************************/
 
 
class ContainerWidget: public Widget
{
 public:
 
    /* -------------- Types, consts, etc. -------------- */
    enum class OrType {
                            VERTICAL,   
                            HORIZONTAL, 
                            DEEP        
                        };
 
    enum class CCType {
                            USER,       
                            OWN         
                          };
 
 
    enum class FMType {
                            NORMAL,     
                            PRESERVE
                          };
 
    /* -------------- Constructors -------------- */
    ContainerWidget(ID id, const std::string & name, 
                    CCType cctype = CCType::USER,
                    OrType ortype = OrType::VERTICAL, 
                    FMType foctype = FMType::NORMAL,
                    bool withframe = false, 
                    const std::string & title = "",
                    HorAlign hal = HorAlign::LEFT, 
                    VertAlign val = VertAlign::TOP,
                    const std::string & tooltiptext = ""):
                                            Widget{id,name,tooltiptext,hal,val},
                                            cctype_{cctype},
                                            ortype_{ortype},
                                            focustype_{foctype},
                                            whodeep_{0},
                                            withframe_{withframe},
                                            title_{nonCtrlString(title,'L')} {}
 
    /* -------------- Container methods -------------- */
    CCType ccType(void) const noexcept { return(cctype_); }
 
    OrType orType(void) const noexcept { return(ortype_); }
 
    FMType focusMngType(void) const noexcept { return(focustype_); }
 
    bool getFrame(void) const noexcept { return(withframe_); }
 
    const std::string & getTitle(void) const noexcept { return(title_); }
 
    bool cursorInTopFrame(const CharCursor & cc) const;
 
    const PVector & children(void) noexcept { return(children_); }
 
    Widget * addChild(const Ptr & ch)
 
        { return(children_.addChildOf(ch,*this)); }
 
    void setDeepSelected(PVector::size_type who);
 
    PVector::size_type getDeepSelected(void) const;
 
    /* -------------- Widget methods -------------- */
    const char * className(void) const noexcept { return("ContainerWidget"); }
    bool isContainer(void) const noexcept override { return(true); } 
    const AreaFitting & calcFittingNeeds(const CharArea & area); 
    void drawRaw(void);
    Widget * setDrawingZone(const CharRect & zone) override;
    void moveDrawingZones(IntDist incx, IntDist incy) noexcept override;
    void setWindow(Window & win) noexcept override;
    void setWinColors(const WinColors & wincols) noexcept override;
    ChainEventResult chainEvent(const EventData & data) override;
 
 private:
 
    static const std::vector<uint8_t> kContUDGs;
 
 
    CCType cctype_;
    OrType ortype_;
    FMType focustype_;
    PVector children_;
    PVector::size_type whodeep_;
    bool withframe_;
    std::string title_; 
 
 
    bool isTabbedDeep(void) const noexcept;
    bool isFramed(void) const noexcept;
    CharDist tabTitleSize(const CharArea & area) const;
    size_t tabClicked(CharCoord x) const;
    void calcFrameDims(const CharArea & area,
                       CharDist & framewidthchars,
                       CharDist & frameheightchars,
                       CharDist & titlewidthchars,
                       CharCursor & bodytopleft) const;
    void drawFrameTitle(Screen & scr) const;
    Widget * calcChildrenOccupation(const CharArea & availablearea,
                                bool calcfitting,
                                size_t & howmanychildrenvisible,
                                CharDist & totwidth, CharDist & totheight,
                                size_t & howmanyflexvert, 
                                size_t & howmanyflexhor,
                                std::string & explanation); 
    void calcShareExcessForChildren(const CharArea & area,
                                   CharDist excess,
                                   std::vector<CharDist> & sharing,
                                   size_t howmanychildrenareflex,
                                   size_t howmanychildrenarevisible,
                                   CharDist totdim, OrType dir);
    void traceOfDrawingRecursive(size_t level, std::stringstream & ss,
                                 bool withoutprivate = true) const;
};
 
 
} // end namespace gui
} // end namespace zxeco
 
#endif
 // ZXWidgetsBase