Frame.h

Go to the documentation of this file.

#pragma once

#include <cstdint>
#include "Animation.h"
#include "Color.h"
#include "Theme.h"
#include "ImageStore.h"
#include "Visual.h"

namespace rose {

    enum UseBorder {
        None,       
        BevelOut,   
        BevelIn,    
        NotchOut,   
        NotchIn,    
    };

    class FrameElements {
    protected:
        color::RGBA mBaseColor;
        color::RGBA mInvertColor;
        color::RGBA mTopColor;
        color::RGBA mBotColor;
        color::RGBA mLeftColor;
        color::RGBA mRightColor;
        color::RGBA mActiveColor;
        color::RGBA mInactiveColor;
        float mColorValue{};
        int mFrameWidth{2};
        Padding mFramePadding{};
        CornerStyle mCornerStyle{CornerStyle::Round};
        bool mInvert{};
        gm::Texture mBorder{};
        gm::Texture mInactiveBG{};
        gm::Texture mAnimatedBG{};

        FrameSettings mFrameSettings{};

        enum SelectedCorners : uint32_t {
            NoCorners = 0,
            TopLeftCorner = 0x8,
            TopRightCorner = 0x4,
            TopCorners = TopLeftCorner | TopRightCorner,
            BottomLeftCorner = 0x2,
            BottomRightCorner = 0x1,
            BottomCorners = BottomLeftCorner | BottomRightCorner,
            LeftCorners = TopLeftCorner | BottomLeftCorner,
            RightCorners = TopRightCorner | BottomRightCorner,
            AllCorners = 0xf,
        };

        enum SelectedSides : uint32_t {
            NoSides = 0,
            TopSide = 1,
            BotSide = 2,
            LeftSide = 4,
            RightSide = 8,
            AllSides = TopSide | BotSide | LeftSide | RightSide,
            TabTopSides = TopSide | LeftSide | RightSide,
        };

        static void
        trimCorners(gm::Surface &surface, color::RGBA color, FrameElements::SelectedCorners selectedCorners, Size cornerSize,
                    Size frameSize);

        static void
        renderSelectedCorners(gm::Context &context, SelectedCorners selectedCorners, ImageId corner,
                              const Size &size);

        void
        renderSelectedSides(gm::Context &context, FrameElements::SelectedSides selectedSides, BorderStyle useBorder,
                            ImageId corner, const Size &size, int extend = 0);

        void drawBackground(gm::Context &context, Rectangle &src, Rectangle &dst);

        gm::Texture
        createBackgroundTexture(gm::Context &context, Rectangle &src, Rectangle &dst, const color::RGBA &color);

        std::tuple<UseBorder,SelectedCorners> decoration();

        void drawFrame(gm::Context &context, Rectangle widgetRect);

        void buttonDisplayStateChange(ButtonDisplayState buttonDisplayState);

    public:
        FrameElements();
        virtual ~FrameElements() = default;

        explicit FrameElements(int padding) : mFramePadding(padding) {}

        void set(const CornerStyle cornerStyle) {
            mCornerStyle = cornerStyle;
            mBorder.reset();
            mAnimatedBG.reset();
            mInactiveBG.reset();
        }

        void setState(bool state) {
            mInvert = state;
            mBorder.reset();
            mAnimatedBG.reset();
            mInactiveBG.reset();
        }

        void setAnimateColor(const color::RGBA &color) {
            mActiveColor = color;
            mAnimatedBG.reset();
        }

        void setInactiveColor(const color::RGBA &color) {
            mInactiveColor = color;
            mInactiveBG.reset();
        }

        [[nodiscard]] bool getState() const { return mInvert; }

        static gm::Texture
        createBackgroundMask(gm::Context &context, Size size, int frameWidth, bool roundCorners = false);

        static void colorBackgroundMask(gm::Context &context, gm::Texture &mask, const color::RGBA &base,
                                        const color::RGBA &active, float value);

        void frameSettings(const FrameSettings& frameSettings) {
            mFrameSettings = frameSettings;
            mBorder.reset();
            mInactiveBG.reset();
            mAnimatedBG.reset();
        }
    };

    class FrameLayoutManager : public LayoutManager {
    public:
        FrameLayoutManager() {
            mMaxContent = 1;
        }

        ~FrameLayoutManager() override = default;

        Rectangle layoutContent(gm::Context &context, const Rectangle &screenRect, LayoutManager::Itr first,
                                        LayoutManager::Itr last) override;

    };

    class Frame : public Manager, public FrameElements, public Animation {
    public:
        Frame() noexcept : Manager(), FrameElements() {
            mLayoutManager = std::make_unique<FrameLayoutManager>();
            mAnimationCallback = [&](gm::Context &context, const Position<int> &position, uint32_t frame) {
                if (mActionCurve) {
                    auto idx = frame % mActionCurve->size();
                    mColorValue = (*mActionCurve)[idx];
                    draw(context, position);
                } else {
                    removeAnimation(getWindow(), getNode<Animation>());
                }
            };

            mAnimationEnableStateCallback = [&](AnimationEnable animationEnable){
                if (animationEnable == AnimationEnable::Disable && mAnimationEnableState == AnimationEnable::Enable) {
                    removeAnimation(getWindow(), getNode<Animation>());
                }
            };
        }

        explicit Frame(bool invert) noexcept : Frame() {
            mInvert = invert;
        }

        ~Frame() override = default;

        explicit Frame(int padding) noexcept : Frame() {
            mPadding = Padding{padding};
        }

        static constexpr std::string_view id = "Frame";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        void drawAnimate(gm::Context &context, const Position<int> &containerPosition);

        void draw(gm::Context &context, const Position<int> &containerPosition) override {
            if (mActionCurve && mAnimationEnableState == AnimationEnable::Enable)
                setAnimation(getWindow(), getNode<Animation>(), containerPosition);
            drawAnimate(context,containerPosition);
        }

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;

    };

    enum class FrameColorType {
        InactiveColor,
        AnimateColor,
    };

    struct FrameColor {
        FrameColorType type{};
        color::RGBA rgba{};

        explicit FrameColor(FrameColorType type, color::RGBA color) : type(type), rgba(color) {}
    };
}

template<typename ManagerClass>
inline std::shared_ptr<ManagerClass> operator<<(std::shared_ptr<ManagerClass> manager, const rose::CornerStyle cornerStyle) {
    static_assert(std::is_base_of_v<rose::FrameElements,ManagerClass>, "ManagerClass must be derived from rose::FrameElements." );
    manager->set(cornerStyle);
    return manager;
}

template <class ManagerClass>
inline std::shared_ptr<ManagerClass> operator<<(std::shared_ptr<ManagerClass> manager, const rose::FrameColor& frameColor) {
    static_assert(std::is_base_of_v<rose::FrameElements,ManagerClass>, "ManagerClass must be derived from rose::FrameElements." );
    switch (frameColor.type) {
        case rose::FrameColorType::InactiveColor:
            manager->setInactiveColor(frameColor.rgba);
            break;
        case rose::FrameColorType::AnimateColor:
            manager->setAnimateColor(frameColor.rgba);
            break;
    }
    return manager;
}

template <class ManagerClass>
inline std::shared_ptr<ManagerClass> operator<<(std::shared_ptr<ManagerClass> manager, const rose::FrameSettings& frameSettings) {
    static_assert(std::is_base_of_v<rose::FrameElements, ManagerClass>,
                  "ManagerClass must be derived from rose::FrameElements.");
    manager->frameSettings(frameSettings);
    return manager;
}