widget.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later OR BSD-3-Clause
// SPDX-FileCopyrightText: 2004 - 2008 Olof Naessén and Per Larsson
// SPDX-FileCopyrightText: 2013 - 2026 Fifengine contributors
 
#ifndef INCLUDE_FIFECHAN_WIDGET_HPP_
#define INCLUDE_FIFECHAN_WIDGET_HPP_
 
#include <limits>
#include <list>
#include <string>
#include <type_traits>
 
#include "fifechan/color.hpp"
#include "fifechan/rectangle.hpp"
#include "fifechan/size.hpp"
#include "fifechan/widgetlistener.hpp"
 
namespace fcn
{
    class ActionListener;
    class DeathListener;
    class DefaultFont;
    class FocusHandler;
    class FocusListener;
    class Font;
    class Graphics;
    class KeyInput;
    class KeyListener;
    class MouseInput;
    class MouseListener;
    class VisibilityEventHandler;
    class WidgetListener;

    class FIFEGUI_API Widget
    {
    public:
        enum class SelectionMode : uint8_t
        {
            None       = 0,
            Border     = 1,
            Background = 2
        };

        Widget();
 
        virtual ~Widget();
 
        Widget(Widget const &)            = delete;
        Widget& operator=(Widget const &) = delete;
        Widget(Widget&&)                  = delete;
        Widget& operator=(Widget&&)       = delete;

        virtual void draw(Graphics* graphics) = 0;

        virtual void drawOutline(Graphics* graphics);

        virtual void drawBorder(Graphics* graphics);

        virtual void drawSelectionFrame(Graphics* graphics);

        void setOutlineSize(unsigned int size);

        unsigned int getOutlineSize() const;

        void setBorderSize(unsigned int size);

        /**
         * Gets the size of the widget's border. The border is considered as part of
         * the widget.
         *
         * A border size of 0 means that the widget has no border. The default border size
         * is 0.
         *
         * @return The size of the widget's border.
         * @see setBorderSize, drawBorder
         */
        unsigned int getBorderSize() const;

        void setMargin(int margin);

        void setMarginTop(int margin);

        int getMarginTop() const;

        void setMarginRight(int margin);

        int getMarginRight() const;

        void setMarginBottom(int margin);

        int getMarginBottom() const;

        void setMarginLeft(int margin);

        int getMarginLeft() const;

        void setPadding(unsigned int padding);

        void setPaddingTop(unsigned int padding);

        unsigned int getPaddingTop() const;

        void setPaddingRight(unsigned int padding);

        unsigned int getPaddingRight() const;

        void setPaddingBottom(unsigned int padding);

        unsigned int getPaddingBottom() const;

        void setPaddingLeft(unsigned int padding);

        unsigned int getPaddingLeft() const;

        virtual void logic() { }

        virtual Widget* getParent() const;

        virtual Widget* getTop() const;

        void setWidth(int width);

        int getWidth() const;

        void setHeight(int height);

        int getHeight() const;

        void setSize(int width, int height);

        void setX(int x);

        int getX() const;

        void setY(int y);

        int getY() const;

        void setPosition(int x, int y);

        void setDimension(Rectangle const & dimension);

        Rectangle const & getDimension() const;

        unsigned int getChildrenCount() const;

        unsigned int getVisibleChildrenCount() const;

        void setMinSize(Size const & size);

        Size const & getMinSize() const;

        void setMaxSize(Size const & size);

        Size const & getMaxSize() const;

        void setFixedSize(Size const & size);

        Size const & getFixedSize() const;

        bool isFixedSize() const;

        void setFocusable(bool focusable);

        bool isFocusable() const;

        virtual bool isFocused() const;

        void setEnabled(bool enabled);

        bool isEnabled() const;

        void setVisible(bool visible);

        bool isVisible() const;

        bool isSetVisible() const;

        virtual void setBaseColor(Color const & color);

        Color const & getBaseColor() const;

        virtual void setForegroundColor(Color const & color);

        Color const & getForegroundColor() const;

        virtual void setBackgroundColor(Color const & color);

        Color const & getBackgroundColor() const;

        virtual void setSelectionColor(Color const & color);

        Color const & getSelectionColor() const;

        virtual void setOutlineColor(Color const & color);

        Color const & getOutlineColor() const;

        virtual void setBorderColor(Color const & color);

        Color const & getBorderColor() const;

        virtual void setSelectionMode(SelectionMode mode);

        SelectionMode getSelectionMode() const;

        virtual void requestFocus();

        virtual void requestMoveToTop();

        virtual void requestMoveToBottom();

        virtual void _draw(Graphics* graphics);

        virtual void _logic();

        virtual void _setFocusHandler(FocusHandler* focusHandler);

        virtual FocusHandler* _getFocusHandler();

        void addActionListener(ActionListener* actionListener);

        void removeActionListener(ActionListener* actionListener);

        void addDeathListener(DeathListener* deathListener);

        void removeDeathListener(DeathListener* deathListener);

        void addMouseListener(MouseListener* mouseListener);

        void removeMouseListener(MouseListener* mouseListener);

        void addKeyListener(KeyListener* keyListener);

        void removeKeyListener(KeyListener* keyListener);

        void addFocusListener(FocusListener* focusListener);

        void removeFocusListener(FocusListener* focusListener);

        void addWidgetListener(WidgetListener* widgetListener);

        void removeWidgetListener(WidgetListener* widgetListener);

        void setActionEventId(std::string const & actionEventId);

        std::string const & getActionEventId() const;

        virtual void getAbsolutePosition(int& x, int& y) const;

        virtual void _setParent(Widget* parent);

        Font* getFont() const;

        static void setGlobalFont(Font* font);

        virtual void setFont(Font* font);

        virtual void fontChanged() { }

        static bool widgetExists(Widget const * widget);

        bool isTabInEnabled() const;

        void setTabInEnabled(bool enabled);

        bool isTabOutEnabled() const;

        void setTabOutEnabled(bool enabled);

        virtual bool isModalFocusable() const;

        virtual bool isModalMouseInputFocusable() const;

        virtual void requestModalFocus();

        virtual void requestModalMouseInputFocus();

        virtual void releaseModalFocus();

        virtual void releaseModalMouseInputFocus();

        virtual bool isModalFocused() const;

        virtual bool isModalMouseInputFocused() const;

        Widget* getWidgetAt(int x, int y)
        {
            return getWidgetAt(x, y, nullptr);
        }

        virtual Widget* getWidgetAt(int x, int y, Widget* exclude);

        std::list<Widget*> getWidgetsIn(Rectangle const & area)
        {
            return getWidgetsIn(area, nullptr);
        }

        virtual std::list<Widget*> getWidgetsIn(Rectangle const & area, Widget* ignore);

        virtual std::list<MouseListener*> const & _getMouseListeners();

        virtual std::list<KeyListener*> const & _getKeyListeners();

        virtual std::list<FocusListener*> const & _getFocusListeners();

        virtual Rectangle getChildrenArea();

        virtual FocusHandler* _getInternalFocusHandler();

        void setInternalFocusHandler(FocusHandler* internalFocusHandler);

        virtual void moveToTop(Widget* widget);

        virtual void moveToBottom(Widget* widget);

        virtual void focusNext();

        virtual void focusPrevious();

        virtual void showWidgetPart(Widget* widget, Rectangle area);

        void setId(std::string const & id);

        std::string const & getId() const;

        virtual void showPart(Rectangle rectangle);

        static void _setVisibilityEventHandler(VisibilityEventHandler* visibilityEventHandler);

        static VisibilityEventHandler* _getVisibilityEventHandler();

        static void _setGuiDeathListener(DeathListener* deathListener);

        static DeathListener* _getGuiDeathListener();

        void setVerticalExpand(bool expand);

        bool isVerticalExpand() const;

        void setHorizontalExpand(bool expand);

        bool isHorizontalExpand() const;

        void adaptLayout()
        {
            adaptLayout(true);
        }

        virtual void adaptLayout(bool top);

        void resizeToContent()
        {
            resizeToContent(true);
        }

        virtual void resizeToContent(bool recursion) { }

        virtual void adjustSize() { }

        void expandContent()
        {
            expandContent(true);
        }

        virtual void expandContent(bool recursion) { }

        virtual bool isLayouted()
        {
            return false;
        }

        void getLastPosition(int& x, int& y) const;

        void setLastPosition(int x, int y);

        bool isLastPositionSet() const;
 
    protected:
        void distributeActionEvent();

        void distributeResizedEvent();

        void distributeMovedEvent();

        void distributeHiddenEvent();

        void distributeShownEvent();

        void distributeAncestorMovedEvent(Widget* ancestor);

        void distributeAncestorHiddenEvent(Widget* ancestor);

        void distributeAncestorShownEvent(Widget* ancestor);

        void add(Widget* widget);

        virtual void remove(Widget* widget);

        virtual void removeAllChildren();

        virtual Widget* findWidgetById(std::string const & id);

        void resizeToChildren();

        void calculateSize();

        std::list<Widget*> const & getChildren() const;

        std::list<MouseListener*> mMouseListeners;

        std::list<KeyListener*> mKeyListeners;

        std::list<ActionListener*> mActionListeners;

        std::list<DeathListener*> mDeathListeners;

        std::list<FocusListener*> mFocusListeners;

        std::list<WidgetListener*> mWidgetListeners;

        Color mForegroundColor{0x1f2933};

        Color mBackgroundColor{0xf9fafb};

        Color mBaseColor{0xe5e7eb};

        Color mSelectionColor{0x3b82f6};

        Color mOutlineColor{0x9ca3af};

        Color mBorderColor{0xd1d5db};

        FocusHandler* mFocusHandler{nullptr};

        FocusHandler* mInternalFocusHandler{nullptr};

        Widget* mParent{nullptr};

        Rectangle mDimension;

        Rectangle mOffsetRect;

        unsigned int mOutlineSize{0};

        unsigned int mBorderSize{0};

        SelectionMode mSelectionMode{SelectionMode::None};

        int mMarginTop{0};

        int mMarginRight{0};

        int mMarginBottom{0};

        int mMarginLeft{0};

        unsigned int mPaddingTop{0};

        unsigned int mPaddingRight{0};

        unsigned int mPaddingBottom{0};

        unsigned int mPaddingLeft{0};

        std::string mActionEventId;

        bool mFocusable{false};

        bool mVisible{true};

        bool mTabIn{true};

        bool mTabOut{true};

        bool mEnabled{true};

        std::string mId;

        Size mMinSize{0, 0};

        Size mMaxSize{std::numeric_limits<int>::max(), std::numeric_limits<int>::max()};

        Size mFixedSize{-1, -1};

        bool mFixedSizeUsed{false};

        bool mVExpand{false};

        bool mHExpand{false};

        Font* mCurrentFont{nullptr};

        static DefaultFont mDefaultFont;

        static Font* mGlobalFont;

        static std::list<Widget*> mWidgetInstances;

        static VisibilityEventHandler* mVisibilityEventHandler;

        static DeathListener* mGuiDeathListener;

        std::list<Widget*> mChildren;

        int mLastX{0};

        int mLastY{0};
    };
} // namespace fcn
 
// Bitwise operators for Widget::SelectionMode (enum class)
namespace fcn
{
    constexpr Widget::SelectionMode operator|(Widget::SelectionMode a, Widget::SelectionMode b) noexcept
    {
        using T = std::underlying_type_t<Widget::SelectionMode>;
        return static_cast<Widget::SelectionMode>(static_cast<T>(a) | static_cast<T>(b));
    }
 
    constexpr Widget::SelectionMode operator&(Widget::SelectionMode a, Widget::SelectionMode b) noexcept
    {
        using T = std::underlying_type_t<Widget::SelectionMode>;
        return static_cast<Widget::SelectionMode>(static_cast<T>(a) & static_cast<T>(b));
    }
 
    constexpr Widget::SelectionMode& operator|=(Widget::SelectionMode& a, Widget::SelectionMode b) noexcept
    {
        a = a | b;
        return a;
    }
 
    constexpr Widget::SelectionMode& operator&=(Widget::SelectionMode& a, Widget::SelectionMode b) noexcept
    {
        a = a & b;
        return a;
    }
} // namespace fcn
 
#endif // INCLUDE_FIFECHAN_WIDGET_HPP_