AViewContainerBase.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/Views.h>
#include <AUI/View/AView.h>
#include "AUI/Common/SharedPtr.h"
#include "AUI/Enum/AOverflow.h"
#include "AUI/Util/ABitField.h"
#include <glm/glm.hpp>
#include "AUI/Layout/ALayout.h"
#include "AUI/Common/AVector.h"
#include "AUI/Render/IRenderer.h"
#include "AUI/Render/RenderHints.h"
#include "AUI/Render/ARenderContext.h"
#include "glm/fwd.hpp"
 
 
AUI_ENUM_FLAG(AViewLookupFlags) {
    NONE = 0,
 
    IGNORE_VISIBILITY = 0b1,
 
    ONLY_ONE_PER_CONTAINER = 0b10,
 
    ONLY_THAT_CONSUMES_CLICK = 0b100,
};
 
class API_AUI_VIEWS AViewContainerBase : public AView {
public:
    friend class AView;
 
    struct PointerEventsMapping {
        APointerIndex pointerIndex;
        _weak<AView> targetView;
        bool isBlockClicksWhenPressed = true;
    };
 
    AViewContainerBase();
    ~AViewContainerBase() override = 0; // this class is intended to be derived; use AViewContainer for trivial
                                        // container
 
 
 
    void render(ARenderContext context) override;
 
    void onMouseEnter() override;
 
    void onPointerMove(glm::vec2 pos, const APointerMoveEvent& event) override;
 
    void onMouseLeave() override;
 
    void onDpiChanged() override;
 
    void onClickPrevented() override;
 
    int getContentMinimumWidth() override;
 
    int getContentMinimumHeight() override;
 
    void onPointerPressed(const APointerPressedEvent& event) override;
 
    void onPointerDoubleClicked(const APointerPressedEvent& event) override;
 
    void onPointerReleased(const APointerReleasedEvent& event) override;
 
    void onScroll(const AScrollEvent& event) override;
 
    bool onGesture(const glm::ivec2& origin, const AGestureEvent& event) override;
 
    bool consumesClick(const glm::ivec2& pos) override;
 
    void setSize(glm::ivec2 size) override;
 
    void setEnabled(bool enabled = true) override;
 
    auto begin() const {
        return mViews.cbegin();
    }
 
    auto end() const {
        return mViews.cend();
    }
 
    const AVector<_<AView>>& getViews() const {
        return mViews;
    }
 
 
    [[nodiscard]]
    const _unique<ALayout>& getLayout() const noexcept {
        return mLayout;
    }
 
    [[nodiscard]]
    virtual _<AView> getViewAt(glm::ivec2 pos, ABitField<AViewLookupFlags> flags = AViewLookupFlags::NONE) const noexcept;
 
    [[nodiscard]]
    _<AView> getViewAtRecursive(glm::ivec2 pos, ABitField<AViewLookupFlags> flags = AViewLookupFlags::NONE) const noexcept;
 
    template<aui::predicate<_<AView>> Callback>
    bool getViewAtRecursive(glm::ivec2 pos, const Callback& callback, ABitField<AViewLookupFlags> flags = AViewLookupFlags::NONE) {
        _<AView> possibleOutput; // for case if anyone does not consumesClick
        auto process = [&](const _<AView>& view) {
            if (callback(view))
                return true;
            if (auto container = _cast<AViewContainerBase>(view)) {
                if (container->getViewAtRecursive(pos - view->getPosition(), callback, flags)) {
                    return true;
                }
            }
            return false;
        };
 
        for (const auto& view : aui::reverse_iterator_wrap(mViews)) {
            auto targetPos = pos - view->getPosition();
 
            if (targetPos.x < 0 || targetPos.y < 0 || targetPos.x >= view->getSize().x || targetPos.y >= view->getSize().y) {
                continue;
            }
            if (!flags.test(AViewLookupFlags::IGNORE_VISIBILITY) && !(view->getVisibility() & Visibility::FLAG_CONSUME_CLICKS)) {
                continue;
            }
 
            if (view->consumesClick(targetPos)) {
                if (flags.test(AViewLookupFlags::IGNORE_VISIBILITY) || !!(view->getVisibility() & Visibility::FLAG_CONSUME_CLICKS)) {
                    if (process(view)) {
                        return true;
                    }
 
                    if (flags.test(AViewLookupFlags::ONLY_ONE_PER_CONTAINER)) {
                        return false;
                    }
                }
            } else {
                if (possibleOutput == nullptr) {
                    possibleOutput = view;
                }
            }
        }
        if (possibleOutput) {
            return process(possibleOutput);
        }
 
        return false;
    }
 
    template<aui::predicate<_<AView>> Callback>
    bool visitsViewRecursive(Callback&& callback, ABitField<AViewLookupFlags> flags = AViewLookupFlags::NONE) {
        for (auto it = mViews.rbegin(); it != mViews.rend(); ++it) {
            auto view = *it;
            if (flags.test(AViewLookupFlags::IGNORE_VISIBILITY) || !!(view->getVisibility() & Visibility::FLAG_CONSUME_CLICKS)) {
                if (callback(view))
                    return true;
                if (auto container = _cast<AViewContainerBase>(view)) {
                    if (container->visitsViewRecursive(callback, flags)) {
                        return true;
                    }
                }
                if (flags.test(AViewLookupFlags::ONLY_ONE_PER_CONTAINER)) {
                    break;
                }
            }
        }
        return false;
    }
 
 
    template<typename T>
    _<T> getViewAtRecursiveOfType(glm::ivec2 pos, ABitField<AViewLookupFlags> flags = AViewLookupFlags::NONE) {
        _<T> result;
        getViewAtRecursive(pos, [&] (const _<AView>& v) { return bool(result = _cast<T>(v)); }, flags);
        return result;
    }
 
    void setFocusChainTarget(_weak<AView> target) {
        if (auto v = target.lock()) {
            AUI_ASSERT(v->mParent == this);
        }
        mFocusChainTarget = std::move(target);
    }
    _<AView> focusChainTarget() {
        if (auto v = mFocusChainTarget.lock()) {
            if (v->mParent != this) {
                mFocusChainTarget.reset();
                return nullptr;
            }
            return v;
        }
        return nullptr;
    }
 
 
    void applyGeometryToChildrenIfNecessary();
 
    void onKeyDown(AInput::Key key) override;
 
    void onKeyRepeat(AInput::Key key) override;
 
    void onKeyUp(AInput::Key key) override;
 
    void onCharEntered(char16_t c) override;
 
    bool capturesFocus() override;
 
    const ASmallVector<PointerEventsMapping, 1>& pointerEventsMapping() const noexcept {
        return mPointerEventsMapping;
    }
 
    void forceUpdateLayoutRecursively() override;
 
    void markMinContentSizeInvalid() override;
    void markPixelDataInvalid(ARect<int> invalidArea) override;
 
protected:
    AVector<_<AView>> mViews;
    bool mWantsLayoutUpdate = true;
    glm::ivec2 mLastLayoutUpdateSize{0, 0};
 
    void drawView(const _<AView>& view, ARenderContext contextOfTheContainer);
 
    template<typename Iterator>
    void drawViews(Iterator begin, Iterator end, ARenderContext contextPassedToContainer) {
        switch (mOverflow) {
            case AOverflow::VISIBLE: break;
            case AOverflow::HIDDEN:
            case AOverflow::HIDDEN_FROM_THIS:
                contextPassedToContainer.clip(ARect<int>{
                    .p1 = {0, 0},
                    .p2 = getSize(),
                });
        }
        
        for (auto i = begin; i != end; ++i) {
            drawView(*i, contextPassedToContainer);
        }
    }
 
    void invalidateAllStyles() override;
    void onViewGraphSubtreeChanged() override;
    void invalidateAssHelper() override;
 
    void setViews(AVector<_<AView>> views);
 
    void addViewCustomLayout(const _<AView>& view);
 
    void addViews(AVector<_<AView>> views);
 
    void addView(const _<AView>& view);
 
    void addView(size_t index, const _<AView>& view);
 
    void removeView(const _<AView>& view);
 
    void removeView(AView* view);
 
    void removeView(size_t index);
 
    void removeAllViews();
 
    void setContents(const _<AViewContainer>& container);
 
    void setLayout(_unique<ALayout> layout);
 
    void renderChildren(ARenderContext contextPassedToContainer) {
        drawViews(mViews.begin(), mViews.end(), contextPassedToContainer);
    }
 
    virtual void applyGeometryToChildren();
 
signals:
    emits<> childrenChanged;
 
private:
    _unique<ALayout> mLayout;
    bool mSizeSet = false;
 
 
    struct RepaintTrap {
        bool triggered = false;
    };
    AOptional<RepaintTrap> mRepaintTrap;
 
    struct ConsumesClickCache {
        glm::ivec2 position;
        bool value;
    };
 
    AOptional<ConsumesClickCache> mConsumesClickCache;
 
    _weak<AView> mFocusChainTarget;
 
    ASmallVector<PointerEventsMapping, 1> mPointerEventsMapping;
 
    void notifyParentEnabledStateChanged(bool enabled) override;
    void invalidateCaches();
 
    _<AView> pointerEventsMapping(APointerIndex index);
};