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_
 
// Standard library includes
#include <limits>
#include <list>
#include <string>
#include <type_traits>
 
// Platform config include
#include "fifechan/platform.hpp"
 
// Project headers (subdirs before local)
#include "fifechan/color.hpp"
#include "fifechan/events/dragevent.hpp"
#include "fifechan/listeners/widgetlistener.hpp"
#include "fifechan/rectangle.hpp"
#include "fifechan/size.hpp"
 
namespace fcn
{
    class ActionListener;
    class DeathListener;
    class DefaultFont;
    class FocusHandler;
    class FocusListener;
    class Font;
    class Graphics;
    class KeyInput;
    class KeyListener;
    class MouseEvent;
    class TextInputEvent;
    class MouseInput;
    class MouseListener;
    class VisibilityEventHandler;
    class WidgetListener;
    class DropTargetListener;

    class FIFEGUI_API Widget
    {
        public:
            enum BorderSide : uint8_t
            {
                BORDER_NONE   = 0,
                BORDER_LEFT   = 1 << 0,
                BORDER_TOP    = 1 << 1,
                BORDER_RIGHT  = 1 << 2,
                BORDER_BOTTOM = 1 << 3,
                BORDER_ALL    = BORDER_LEFT | BORDER_TOP | BORDER_RIGHT | BORDER_BOTTOM
            };

            enum BorderStyle : uint8_t
            {
                BORDER_STYLE_BEVEL = 0,
                BORDER_STYLE_FLAT  = 1
            };

            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;
 
            friend class DragHandler;

            virtual void draw(Graphics* graphics) = 0;

            virtual void drawOutline(Graphics* graphics);

            virtual void drawBorder(Graphics* graphics);

            void drawBorder(Graphics* graphics, unsigned int sides) const;

            virtual void drawSelectionFrame(Graphics* graphics);

            void setOutlineSize(unsigned int size);

            unsigned int getOutlineSize() const;

            void setBorderSize(unsigned int size);

            unsigned int getBorderSize() const;

            void setBorderSides(unsigned int sides);

            unsigned int getBorderSides() const;

            void setBorderStyle(unsigned int style);

            unsigned int getBorderStyle() const;

            void setBorderTop(unsigned int size, unsigned int style);

            void setBorderBottom(unsigned int size, unsigned int style);

            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 void textInput(TextInputEvent& event)
            {
            }

            virtual Widget* getParent() const;

            virtual Widget* getTop() const;

            virtual void setWidth(int width);

            int getWidth() const;

            virtual void setHeight(int height);

            int getHeight() const;

            bool contains(int x, int y) const;

            bool isMouseInside(MouseEvent const & mouseEvent) const;

            virtual 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);

            virtual 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;

            virtual void setFocused(bool focused);

            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 addDropTargetListener(DropTargetListener* listener);

            void removeDropTargetListener(DropTargetListener* listener);

            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);

            static void resetGlobalFont();

            virtual void setFont(Font* font);

            virtual void fontChanged()
            {
            }

            virtual void onFocusGained()
            {
            }

            virtual void onFocusLost()
            {
            }

            virtual void onFocusChanged()
            {
            }

            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 bool isModalFocused() const;

            virtual bool isUnderMouseModal() 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);

            virtual void resizeToContent(bool recursion = true)
            {
            }

            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;

            bool captureMouse();

            void releaseMouse();

            static Widget* getMouseCapture();

            bool hasMouseCapture() const;

            bool isDescendantOf(Widget const * ancestor) const noexcept;

            bool isInsideActiveMouseModal() const noexcept;
 
        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;

            bool distributeDragEnter(DragEvent& event);

            void distributeDragLeave(DragEvent& event);

            void distributeDragHover(DragEvent& event);

            void distributeDragDrop(DragEvent& event);

            std::list<MouseListener*> mMouseListeners;

            std::list<KeyListener*> mKeyListeners;

            std::list<ActionListener*> mActionListeners;

            std::list<DeathListener*> mDeathListeners;

            std::list<FocusListener*> mFocusListeners;

            std::list<WidgetListener*> mWidgetListeners;

            std::list<DropTargetListener*> mDropTargetListeners;

            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};

            unsigned int mBorderSides{BORDER_ALL};

            unsigned int mBorderStyle{BORDER_STYLE_FLAT};

            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 mFocused{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;

            static Widget* sMouseCapture;

            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_