AViewContainerBase.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 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 removeViews(aui::range<AVector<_<AView>>::iterator> views);

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

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.