ds_view.h

/* Copyright (C) 2017 - 2024, Thornwave Labs Inc - All Rights Reserved.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 * Written by Razvan Turiac <razvan.turiac@thornwave.com>
*/
 
#ifndef _DS_VIEW_H
#define _DS_VIEW_H
 
 
#include <stdint.h>
 
#include <ds_types.h>
#include <ds_color.h>
#include <ds_renderer.h>
#include <ds_event.h>
 
 
class DsScreen;
 
class DsView
{
public:
    class StateObserver
    {
    public:
        virtual void onViewStateChange(DsView* view, bool isVisible) = 0;
    };
 
 
    DsView(DsView* parent, const DsPoint &pos = DsPoint(), const DsSize &size = DsSize());
 
    DsView(DsView* parent, DsOrientation layout_orientation);
 
    
    void addChild(DsView* view);
    
    void removeChild(DsView* view);
 
    void removeAllChildren(void);
 
    void bringFront(void);
 
    void sendBack(void);
 
    DsView* getParent(void) const;
 
    void setParent(DsView* parent);
    
 
    const DsPoint& getPosition(void) const;
 
 
    DsFPoint getCenterPoint(void) const;
 
    
    DsPoint translatePositionInParentCoordinates(const DsView* parent, DsPoint pos) const;
 
 
    DsPoint translatePositionInParentCoordinates(uint32_t parent_level, DsPoint pos) const;
 
    
    DsPoint getPositionInParentCoordinates(const DsView* parent) const;
    
    
    void setPosition(const DsPoint &pos);
 
 
    void setCenterPosition(const DsPoint &pos);
 
 
    void centerVertically(DsView* view);
 
 
    void centerHorizontally(DsView* view);
 
    
    const DsSize& getParentSize(void) const;
 
 
    const DsSize& getSize(void) const;
 
 
    void setMinimumSize(const DsSize &size);
 
    
    void setSize(const DsSize &size);
 
    
    void setWidth(int32_t width);
 
    
    void setHeight(int32_t height);
 
 
    DsRect getRegion(void) const;
 
    
    DsRect getRegionInParentCoordinates(const DsView* parent) const;
    
    
    void alignInParent(void);
 
    void alignInParent(const DsAlignment &alignment, int32_t padding_top, int32_t padding_left, int32_t padding_bottom, int32_t padding_right);
 
 
    DsView* setPaddingTop(int16_t padding, uint16_t proportion = 0);
 
    DsView* setPaddingBottom(int16_t padding, uint16_t proportion = 0);
 
    DsView* setPaddingLeft(int32_t padding, uint16_t proportion = 0);
 
    DsView* setPaddingRight(int16_t padding, uint16_t proportion = 0);
 
    DsView* setPadding(int16_t padding, uint16_t proportion = 0);
 
 
    DsView* setPaddingHorizontal(int16_t padding, uint16_t proportion = 0);
 
 
    DsView* setPaddingVertical(int16_t padding, uint16_t proportion = 0);
 
 
    DsView* setProportion(uint32_t proportion);
 
 
    DsAlignment getParentAlignment(void) const;
    
 
    DsView* setParentAlignment(const DsAlignment &alignment);
 
 
    void reserveSpace(bool state);
 
    
    void setAutoLayout(DsOrientation orientation, bool enable);
 
 
    virtual DsSize fitContent(void);
    
    
    void doLayout(void);
 
    
    void setBackgroundColor(DsColor color);
 
 
    void setBackgroundImage(const DsSurface* surface);
 
 
    void setPanelColor(DsColor color);
 
    
    void setPanelBorderColor(DsColor color);
 
    
    void setPanelCornerRadius(uint16_t radius);
 
 
    void setPanelBorderThickness(uint8_t thickness);
 
 
    DsScreen& getScreen(void);
 
    
    bool isFocused(void);
 
    
    bool getIsVisible(void) const;
 
    
    bool isVisible(void) const;
 
    
    bool isParentVisible(void) const;
    
    
    inline bool show(void)
    {
        return setVisible(true);
    }
    
    
    inline bool hide(void)
    {
        return setVisible(false);
    }
 
    
    bool setVisible(bool is_visible);
 
    
    virtual void onShow(void);
 
    
    virtual void onHide(void);
 
    
    void enable(bool state);
 
    
    bool isEnabled(void) const;
 
 
    void enableTouch(bool state);
 
    
    bool isTouchEnabled(void) const;
 
 
    void sendTap(DsPoint pos);
 
    void setOnTapCallback(const lambda<void(const DsPoint &p)> &cb);
 
    
    void setOnLongTapCallback(const lambda<void(const DsPoint &p)> &cb);
 
    
    void setOnTouchActiveCallback(const lambda<void(const DsPoint &p)> &cb);
 
    
    void setOnTouchReleaseCallback(const lambda<void(void)> &cb);
    
    
    void setLongTapDetection(uint32_t delay_ms);
    
    
    bool isInputInside(void) const;
    
    
    const DsPoint& getTouchPosition(void) const;
 
    
    void enableHorizontalScroll(bool state);
 
    
    void enableVerticalScroll(bool state);
 
    
    void setScrollbarColor(DsColor color);
 
    
    virtual void invalidate(void);
 
    
    virtual void invalidateRegion(DsRect region);
 
    
    void addStateObserver(StateObserver* observer);
 
 
    void removeStateObserver(StateObserver* observer);
 
 
protected:
    DsPoint mScrollPosition;
    DsPoint mPreviousScrollPosition;
    DsPoint mScrollPositionBase;
    DsColor mScrollbarColor;
 
    DsPoint mTouchPos;
    uint32_t mTouchTimestamp;   
 
 
    virtual void onChildAdd(DsView* child);
 
    virtual void onSizeChange(void);
    
    
    virtual void onPaint(DsRenderer &renderer);
 
    
    virtual void onPaintOver(DsRenderer &renderer);
 
 
    virtual bool onTouch(const DsTouchEvent &event);
 
    virtual void onVSync(void);
 
    
    virtual void onKeyboard(int32_t key);
    
 
    void inputCapture(void);
 
    bool isInputCaptured(void) const;
 
 
    void skipInput(void);
 
 
    void forAllChildren(const lambda<void(DsView* child)> &lambda);
 
    
    void forAllChildrenBackwards(const lambda<void(DsView* child)> &lambda);
 
 
private:
    friend class DsScreen;
    friend class DsList;
    friend class DsGrid;
    friend class DsBookView;
 
    struct StateObserverLink
    {
        StateObserver* observer;
        StateObserverLink* next;
    };
 
    DsView* mPrev;
    DsView* mNext;
    DsView* mChildrenHead;
    DsView* mChildrenTail;
 
    DsScreen* mScreen;
    DsView* mParent;
 
    DsPoint mPosition;
    DsSize mMinimumSize;
    DsSize mSize;
 
    DsOrientation mLayoutOrientation;
    uint32_t mLayoutTotalProportion;
 
    int16_t mPaddingTop;
    int16_t mPaddingBottom;
    int16_t mPaddingLeft;
    int16_t mPaddingRight;
 
    uint16_t mPaddingProportionTop;
    uint16_t mPaddingProportionBottom;
    uint16_t mPaddingProportionLeft;
    uint16_t mPaddingProportionRight;
 
    uint32_t mProportion;
    DsAlignment mParentAlignment;
    DsSize mChildrenExtent;
 
    DsColor mBackgroundColor;
    const DsSurface* mBackgroundSurface;
    DsColor mPanelColor;
    DsColor mPanelBorderColor;
    uint16_t mPanelCornerRadius;
    uint8_t mPanelBorderThickness;
 
    //used by the touch detector
    lambda<void(const DsPoint&)>* mOnTapCallback;
    lambda<void(const DsPoint&)>* mOnLongTapCallback;
    lambda<void(const DsPoint&)>* mOnTouchActiveCallback;
    lambda<void(void)>* mOnTouchReleaseCallback;
 
    DsView* mInputCaptureView;          //contains the view that captured the input
    uint32_t mLongTapDelay;
 
    StateObserverLink* mStateObservers;
 
    struct 
    {
        uint16_t mIsInputInside: 1;
        uint16_t mSkipInput: 1;
        uint16_t mIsTouchActive: 1;
        uint16_t mIsLongTouchActive: 1;
        uint16_t mIsScrollActive: 1;
        uint16_t mIsTouchEnabled: 1;
        uint16_t mIsVisible: 1;
        uint16_t mIsEnabled: 1;
        uint16_t mIsSpaceReserved: 1;
        uint16_t mIsLayoutEnabled: 1;
        uint16_t mIsHorizontalScrollEnabled: 1;
        uint16_t mIsVerticalScrollEnabled: 1;
    };
    
 
    DsView(const DsView &rhs) = delete;
    DsView& operator=(const DsView &rhs) = delete;
 
    void bringFront(DsView* view);
    void sendBack(DsView* view);
 
    void inputRelease(void);
    bool parentIsScrolling(void) const;
 
    void setScreen(DsScreen* screen);
    void onParentVisibilityChanged(bool is_visible);
 
    void processPaintEvent(const DsSurface* parent_surface, DsRenderer &renderer);
    bool processTouchEvent(DsTouchEvent event);
    void processVSyncEvent(void);
};
 
 
#include <ds_screen.h>
 
 
#endif