UIToolBar.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Texture/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/UI/UIButton.hpp"
#include "CeresEngine/UI/UIView.hpp"
 
namespace CeresEngine {
 
    class UIToolBarItem;
    class UIToolBarDelegate;
 
    class UIToolBar : public UIView {
    private:
        Vector<SPtr<UIToolBarItem>> mItems;
 
        UIToolBarDelegate* mDelegate = nullptr;
 
    public:
        UIToolBar() : UIToolBar(kDefaultFrame) {}
        explicit UIToolBar(const UIRect& frame);
        ~UIToolBar() override;
 
    public:
        const Vector<SPtr<UIToolBarItem>>& getItems() const noexcept { return mItems; }
 
        UIToolBarItem* insertItem(const SPtr<UIToolBarItem>& item, UInt32 index = ~0u);
 
        template<typename T = UIToolBarItem, typename... Args> T* addItem(Args&&... args) { return insertItem(ce_shared_new<T>(std::forward<Args>(args)...)); }
 
        void removeItem(const String& itemIdentifier);
 
    public:
        void didChangeBounds(const UIRect& oldBounds) override;
 
        UISize getIntrinsicContentSize() const override;
 
        void layoutSubviews() override;
 
        void draw(UIGraphicsContext& context, const UIRect& dirtyRect) override;
 
        [[nodiscard]] bool getClearsContextBeforeDrawing() const noexcept override { return false; }
 
    private: // UIToolBarItem interface
        friend class UIToolBarItem;
        friend class UIToolBarItemGroup;
 
        void notifyItemDirty(UIToolBarItem* item);
 
    private:
        class Button : public UIButton {
        private:
            SPtr<UIToolBarItem> mItem;
 
        public:
            explicit Button(const SPtr<UIToolBarItem>& item);
            ~Button() override;
 
        public:
        };
    };
 
    class UIToolBarDelegate {
    public:
        virtual void toolbarWillAddItem(UIToolBar* toolBar, UIToolBarItem* item) {}
 
        virtual void toolbarDidRemoveItem(UIToolBar* toolBar, UIToolBarItem* item) {}
    };
 
    class UIToolBarItem {
        friend class UIToolBar;
 
    private:
        String mItemIdentifier;
 
        UIToolBar* mToolBar = nullptr;
 
        String mLabel;
 
        String mToolTip;
 
        String mTitle;
 
        bool mBordered = true;
 
        bool mNavigational = false;
 
        bool mEnabled = true;
 
        HTexture mTexture = nullptr;
 
        RC<UIView> mView = nullptr;
 
        RC<UIView> mActualView = nullptr;
 
    public:
        Event<void()> didSelect;
 
    public:
        explicit UIToolBarItem(const String& itemIdentifier);
        virtual ~UIToolBarItem();
 
    public:
        [[nodiscard]] const String& getItemIdentifier() const noexcept { return mItemIdentifier; }
 
        [[nodiscard]] UIToolBar* getToolBar() const noexcept { return mToolBar; }
 
        [[nodiscard]] const String& getLabel() const noexcept { return mLabel; }
 
        void setLabel(const String& label);
 
        [[nodiscard]] const String& getToolTip() const noexcept { return mToolTip; }
 
        void setToolTip(const String& toolTip);
 
        [[nodiscard]] const String& getTitle() const noexcept { return mTitle; }
 
        void setTitle(const String& title);
 
        [[nodiscard]] bool isBordered() const noexcept { return mBordered; }
 
        void setBordered(bool bordered);
 
        [[nodiscard]] bool isNavigational() const noexcept { return mNavigational; }
 
        void setNavigational(bool navigational);
 
        [[nodiscard]] bool isEnabled() const noexcept { return mEnabled; }
 
        void setEnabled(bool enabled);
 
        [[nodiscard]] const HTexture& getTexture() const noexcept { return mTexture; }
 
        void setTexture(const HTexture& texture);
 
        [[nodiscard]] UIView* getView() const noexcept { return mView.get(); }
 
        void setView(UIView* view);
    };
 
    class UIToolBarItemGroup : public UIToolBarItem {
    private:
        Vector<SPtr<UIToolBarItem>> mSubItems;
 
    public:
        UIToolBarItemGroup(const String& itemIdentifier, const Vector<SPtr<UIToolBarItem>>& subItems);
        ~UIToolBarItemGroup() override;
 
    public:
        [[nodiscard]] const Vector<SPtr<UIToolBarItem>>& getSubItems() const noexcept { return mSubItems; }
 
        void getSubItems(const Vector<SPtr<UIToolBarItem>>& subItems);
    };
 
} // namespace CeresEngine