AView.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 <chrono>
#include <functional>
#include <array>
 
#include <glm/glm.hpp>
 
#include "AUI/Common/ASmallVector.h"
#include <AUI/ASS/Property/IProperty.h>
#include <AUI/ASS/Property/ScrollbarAppearance.h>
#include "AUI/Common/ABoxFields.h"
#include "AUI/Common/ADeque.h"
#include "AUI/Common/AObject.h"
#include "AUI/Common/SharedPtr.h"
#include "AUI/Platform/ACursor.h"
#include "AUI/Platform/AInput.h"
#include "AUI/Reflect/AClass.h"
#include "AUI/Font/AFontStyle.h"
#include "AUI/Util/AFieldSignalEmitter.h"
#include "AUI/Render/ARenderContext.h"
#include "AUI/Util/IBackgroundEffect.h"
#include <AUI/ASS/PropertyListRecursive.h>
#include <AUI/Enum/AOverflow.h>
#include <AUI/Enum/Visibility.h>
#include <AUI/Enum/MouseCollisionPolicy.h>
#include <AUI/Util/ALayoutDirection.h>
#include <AUI/Action/AMenu.h>
 
#include <AUI/Event/AScrollEvent.h>
#include <AUI/Event/AGestureEvent.h>
#include <AUI/Event/APointerPressedEvent.h>
#include <AUI/Event/APointerReleasedEvent.h>
#include <AUI/Event/APointerMoveEvent.h>
#include <AUI/Render/ITexture.h>
#include <AUI/Render/IRenderViewToTexture.h>
#include <AUI/Enum/AFloat.h>
#include <AUI/Common/AProperty.h>
 
 
class AWindow;
class AWindowBase;
class AViewContainerBase;
class AAnimator;
class AAssHelper;
class AStylesheet;


class API_AUI_VIEWS AView: public AObject
{
   friend class AViewContainerBase;
   friend class AViewContainer;
   friend class IRenderViewToTexture;
public:
   AView();
   ~AView() override;
 

   auto enabled() const {
       return APropertyDef {
           this,
           &AView::mEnabled,
           &AView::setEnabled,
           mEnabledChanged,
       };
   }

   auto position() const {
       return APropertyDef {
           this,
           &AView::mPosition,
           &AView::setPosition,
           mPositionChanged,
       };
   }

   auto size() const {
       return APropertyDef {
           this,
           &AView::mSize,
           &AView::setSize,
           mSizeChanged,
       };
   }

   auto expanding() const {
       return APropertyDef {
           this,
           &AView::mExpanding,
           [](AView& self, glm::ivec2 expanding) { self.setExpanding(expanding); },
           mExpandingChanged,
       };
   }

   auto visibility() const {
       return APropertyDef {
           this,
           &AView::mVisibility,
           &AView::setVisibility,
           mVisibilityChanged,
       };
   }

   void redraw();

   AWindowBase* getWindow() const;
 
   virtual void drawStencilMask(ARenderContext ctx);

   virtual void render(ARenderContext ctx);

   virtual void postRender(ARenderContext ctx);
 
   void popStencilIfNeeded(ARenderContext ctx);
 
   [[nodiscard]]
   const AVector<AString>& getAssNames() const noexcept {
       return mAssNames;
   }

   [[nodiscard]]
   glm::ivec2 getPosition() const noexcept
   {
       return mPosition;
   }

   [[nodiscard]]
   glm::ivec2 getCenterPointInWindow() const noexcept
   {
       return getPositionInWindow() + *size() / 2;
   }

   [[nodiscard]]
   glm::ivec2 getSize() const noexcept
   {
       return mSize;
   }

   glm::ivec2 getMinSize() const noexcept {
       return mMinSize;
   }
 
   void setMinSize(glm::ivec2 minSize) noexcept {
       mMinSize = minSize;
   }

   virtual void markMinContentSizeInvalid();

   void setExtraStylesheet(_<AStylesheet> extraStylesheet) {
       mExtraStylesheet = std::move(extraStylesheet);
       invalidateAssHelper();
   }

   void setExtraStylesheet(AStylesheet&& extraStylesheet);

   [[nodiscard]]
   const _<AStylesheet>& extraStylesheet() const noexcept {
       return mExtraStylesheet;
   }

   AOverflow getOverflow() const
   {
       return mOverflow;
   }
   void setOverflow(AOverflow overflow)
   {
       mOverflow = overflow;
   }

   AOverflowMask getOverflowMask() const
   {
       return mOverflowMask;
   }
   void setOverflowMask(AOverflowMask overflow)
   {
       mOverflowMask = overflow;
   }

   float getBorderRadius() const {
       return mBorderRadius;
   }
   void setBorderRadius(float radius) {
       mBorderRadius = radius;
   }
 
   int getWidth() const
   {
       return mSize.x;
   }
 
   int getHeight() const
   {
       return mSize.y;
   }

   int getTotalOccupiedWidth() const
   {
       return !(mVisibility & Visibility::FLAG_CONSUME_SPACE) ? 0 : mSize.x + getTotalFieldHorizontal();
   }

   int getTotalOccupiedHeight() const
   {
       return !(mVisibility & Visibility::FLAG_CONSUME_SPACE) ? 0 : mSize.y + getTotalFieldVertical();
   }

   [[nodiscard]]
   glm::ivec2 getMinimumSizePlusMargin() {
       return getMinimumSize() + mMargin.occupiedSize();
   }

   [[nodiscard]]
   const ABoxFields& getMargin()
   {
       ensureAssUpdated();
       return mMargin;
   }

   void setMargin(const ABoxFields& margin) {
       mMargin = margin;
   }

   virtual bool consumesClick(const glm::ivec2& pos);

   [[nodiscard]]
   const ABoxFields& getPadding()
   {
       ensureAssUpdated();
       return mPadding;
   }

   void setPadding(const ABoxFields& padding) {
       mPadding = padding;
   }

   virtual AString debugString() const;

   [[nodiscard]]
   int getTotalFieldHorizontal() const {
       return mPadding.horizontal() + mMargin.horizontal();
   }

   [[nodiscard]]
   int getTotalFieldVertical() const {
       return mPadding.vertical() + mMargin.vertical();
   }

   [[nodiscard]]
   glm::ivec2 getTotalFieldSize() const {
       return { getTotalFieldHorizontal(), getTotalFieldVertical() };
   }

   AViewContainerBase* getParent() const
   {
       return mParent;
   }

   const AOptional<ACursor>& getCursor() const
   {
       return mCursor;
   }
   void setCursor(AOptional<ACursor> cursor);

   [[nodiscard]]
   virtual int getContentMinimumWidth();

   [[nodiscard]]
   virtual int getContentMinimumHeight();

   [[nodiscard]]
   glm::ivec2 getContentMinimumSize() noexcept {
       if (!mCachedMinContentSize) {
           glm::ivec2 minContentSize = glm::ivec2(getContentMinimumWidth(), getContentMinimumHeight());
           mCachedMinContentSize = minContentSize;
           return minContentSize;
       }
       return *mCachedMinContentSize;
   }
 
   [[nodiscard]]
   bool isContentMinimumSizeInvalidated() noexcept {
       return !mCachedMinContentSize.hasValue();
   }
 
   bool hasFocus() const;
 
   virtual int getMinimumWidth();
   virtual int getMinimumHeight();

   glm::ivec2 getMinimumSize() {
       return { getMinimumWidth(), getMinimumHeight() };
   }
 
   void setMaxSize(const glm::ivec2& maxSize) {
       mMaxSize = maxSize;
   }

   [[nodiscard]] const glm::ivec2& getMaxSize() const
   {
       return mMaxSize;
   }

   glm::ivec2 getContentSize() const { return { getContentWidth(), getContentHeight() }; }
 
   int getContentWidth() const
   {
       return static_cast<int>(mSize.x - mPadding.horizontal());
   }
 
   int getContentHeight() const
   {
       return static_cast<int>(mSize.y - mPadding.vertical());
   }
 
   [[nodiscard]]
   const glm::ivec2& getExpanding() const
   {
       return mExpanding;
   }

   void setExpanding(glm::ivec2 expanding)
   {
       if (mExpanding == expanding) [[unlikely]] {
           return;
       }
       mExpanding = expanding;
       emit mExpandingChanged(expanding);
       markMinContentSizeInvalid();
   }

   void setExpanding(int expanding)
   {
       setExpanding(glm::ivec2(expanding));
   }
   void setExpanding()
   {
       setExpanding(2);
   }
 
   const _<AAnimator>& getAnimator() const {
       return mAnimator;
   }
 
 
   void setAnimator(const _<AAnimator>& animator);
   void getTransform(glm::mat4& transform) const;
 
   [[nodiscard]]
   int getExpandingHorizontal() const
   {
       return mExpanding.x;
   }
 
   [[nodiscard]]
   int getExpandingVertical() const
   {
       return mExpanding.y;
   }
 
   [[nodiscard]] aui::float_within_0_1 getOpacity() const {
       return mOpacity;
   }
   void setOpacity(aui::float_within_0_1 opacity) {
       mOpacity = opacity;
   }
 
   virtual void setPosition(glm::ivec2 position);

   void setSizeForced(glm::ivec2 size) {
       mSize = size;
   }
   virtual void setSize(glm::ivec2 size);

   virtual void setGeometry(int x, int y, int width, int height);
   void setGeometry(const glm::ivec2& position, const glm::ivec2& size) {
       setGeometry(position.x, position.y, size.x, size.y);
   }
 
   bool isBlockClicksWhenPressed() const noexcept {
       return mBlockClicksWhenPressed;
   }
 
   void setBlockClicksWhenPressed(bool value) noexcept {
       mBlockClicksWhenPressed = value;
   }

   const glm::ivec2& getFixedSize() {
       return mFixedSize;
   }
   void setFixedSize(glm::ivec2 size) {
       AUI_ASSERTX(glm::all(glm::greaterThanEqual(size, glm::ivec2(-100000))), "abnormal fixed size");
       if (size == mFixedSize) [[unlikely]] {
           return;
       }
       mFixedSize = size;
       markMinContentSizeInvalid();
   }
 
   [[nodiscard]]
   bool isMouseHover() const noexcept
   {
       return mHovered;
   }
 
   [[nodiscard]]
   bool isPressed() const noexcept
   {
       return !mPressed.empty();
   }
 
   [[nodiscard]]
   bool isPressed(APointerIndex index) const noexcept
   {
       return mPressed.contains(index);
   }
 
   bool isFocused() const {
       return mHasFocus;
   }
   bool isMouseEntered() const {
       return mMouseEntered;
   }
 
   Visibility getVisibility() const
   {
       return mVisibility;
   }
 
   Visibility getVisibilityRecursive() const;
 
   void setVisibility(Visibility visibility) noexcept;
 
   void setVisible(bool visible) noexcept
   {
       setVisibility(visible ? Visibility::VISIBLE : Visibility::INVISIBLE);
   }
 
   [[nodiscard]]
   MouseCollisionPolicy getMouseCollisionPolicy() const {
       return mMouseCollisionPolicy;
   }
 
   void setMouseCollisionPolicy(MouseCollisionPolicy mouseCollisionPolicy) {
       mMouseCollisionPolicy = mouseCollisionPolicy;
   }

   void click() {
       emit clickedButton(APointerIndex::button(AInput::LBUTTON));
       emit clicked();
   }

   void pack();

    void focus(bool needFocusChainUpdate = true);

    virtual bool capturesFocus();

   bool hasIndirectParent(const _<AView>& v);

   [[nodiscard]] glm::ivec2 getPositionInWindow() const;

   void addAssName(const AString& assName);

   void removeAssName(const AString& assName);

   void setAssName(const AString& assName, bool value) {
       if (value) {
           addAssName(assName);
       } else {
           removeAssName(assName);
       }
   }

   inline AView& operator<<(const AString& assName) {
       addAssName(assName);
       return *this;
   }
 
   const _<AAssHelper>& getAssHelper() const {
       return mAssHelper;
   }
 
   const ass::PropertyListRecursive& getCustomAss() const {
       return mCustomStyleRule;
   }
 
   void setCustomStyle(ass::PropertyListRecursive rule);
 
   void ensureAssUpdated();
 
   [[nodiscard]]
   _<AView> sharedPtr() {
       return _cast<AView>(AObject::sharedPtr());
   }
 
   [[nodiscard]]
   _weak<AView> weakPtr() {
       return _weak<AView>(sharedPtr());
   }

   virtual bool onGesture(const glm::ivec2& origin, const AGestureEvent& event);
 
   virtual void onMouseEnter();

   virtual void onPointerMove(glm::vec2 pos, const APointerMoveEvent& event);
   virtual void onMouseLeave();
   virtual void onDpiChanged();

   virtual void onPointerPressed(const APointerPressedEvent& event);

   virtual void onPointerReleased(const APointerReleasedEvent& event);
   virtual void onPointerDoubleClicked(const APointerPressedEvent& event);

   virtual void onScroll(const AScrollEvent& event);
   virtual void onKeyDown(AInput::Key key);
   virtual void onKeyRepeat(AInput::Key key);
   virtual void onKeyUp(AInput::Key key);
   virtual void onFocusAcquired();
   virtual void onFocusLost();
   virtual void onCharEntered(char16_t c);

   virtual bool handlesNonMouseNavigation();
 
   virtual void forceUpdateLayoutRecursively();
 
   virtual void setEnabled(bool enabled = true);
 
   void setDisabled(bool disabled = true) {
       setEnabled(!disabled);
   }
 
   void updateEnableState();
 
   void enable()
   {
       setEnabled(true);
   }
   void disable()
   {
       setEnabled(false);
   }

   void operator&(ass::PropertyListRecursive rule) {
       setCustomStyle(std::move(rule));
   }

   virtual void onClickPrevented();

   virtual void invalidateAllStyles();

   void invalidateStateStyles() {
       invalidateStateStylesImpl(getMinimumSizePlusMargin());
   }

   virtual void invalidateAssHelper();

   [[nodiscard]]
   virtual bool wantsTouchscreenKeyboard();

   void setSkipUntilLayoutUpdate(bool skipUntilLayoutUpdate) {
       mSkipUntilLayoutUpdate = skipUntilLayoutUpdate;
   }

   void setFloating(AFloat f) noexcept
   {
       mFloating = f;
   }

   [[nodiscard]]
   AFloat getFloating() const noexcept
   {
       return mFloating;
   }
 
signals:
   emits<> viewGraphSubtreeChanged;

   emits<> redrawn;
 
   emits<bool> hoveredState;
   emits<> mouseEnter;
   emits<> mouseLeave;
 
   emits<bool, APointerIndex> pressedState;
   emits<APointerIndex> pressed;
   emits<APointerIndex> released;

   emits<APointerIndex> clickedButton;

   emits<> clicked;

   emits<glm::ivec2, glm::ivec2> geometryChanged;

   emits<glm::ivec2> scrolled;

   emits<AInput::Key> keyPressed;

   emits<AInput::Key> keyReleased;

   emits<> clickedRight;

   emits<> clickedRightOrLongPressed;
 
   emits<APointerIndex> doubleClicked;
 
   emits<> customCssPropertyChanged;

   emits<bool> focusState;
   emits<> focusAcquired;
   emits<> focusLost;
 
   emits<_<AView>> childFocused;
 
protected:
   AViewContainerBase* mParent = nullptr;

   std::array<ass::prop::IPropertyBase*, int(ass::prop::PropertySlot::COUNT)> mAss;

   ass::PropertyListRecursive mCustomStyleRule;

   AOptional<ACursor> mCursor = ACursor::DEFAULT;

   glm::ivec2 mPosition = { 0, 0 };

   emits<glm::ivec2> mPositionChanged;

   glm::ivec2 mSize = { 20, 20 };

   emits<glm::ivec2> mSizeChanged;
 
   AOptional<glm::ivec2> mCachedMinContentSize;
   bool mMarkedMinContentSizeInvalid = false;

   bool mRedrawRequested = false;

   glm::ivec2 mMinSize = {0, 0};

   glm::ivec2 mMaxSize = {0x7fffffff, 0x7fffffff};

   glm::ivec2 mFixedSize = {0, 0};

   ABoxFields mMargin;

   ABoxFields mPadding;

   AVector<AString> mAssNames;

   bool mSkipUntilLayoutUpdate = true;

   bool transformGestureEventsToDesktop(const glm::ivec2& origin, const AGestureEvent& event);
 
   void applyAssRule(const ass::PropertyList& propertyList);
   void applyAssRule(const ass::PropertyListRecursive& propertyList);

   virtual AMenuModel composeContextMenu();

   virtual void onViewGraphSubtreeChanged();

   virtual void markPixelDataInvalid(ARect<int> invalidArea);
 
   virtual void commitStyle();
 
private:
   _<AAnimator> mAnimator;

   AOverflowMask mOverflowMask = AOverflowMask::ROUNDED_RECT;

   Visibility mVisibility = Visibility::VISIBLE;
   emits<Visibility> mVisibilityChanged;

   _<AAssHelper> mAssHelper;

   float mBorderRadius = 0;

   MouseCollisionPolicy mMouseCollisionPolicy = MouseCollisionPolicy::DEFAULT;

   aui::float_within_0_1 mOpacity = 1;

   AOverflow mOverflow = AOverflow::VISIBLE;

   _<AStylesheet> mExtraStylesheet;

   virtual void notifyParentEnabledStateChanged(bool enabled);

   [[nodiscard]]
   ALayoutDirection parentLayoutDirection() const noexcept;

   bool mMouseEntered = false;

   bool mBlockClicksWhenPressed = true;
 
   AFieldSignalEmitter<bool> mHovered = AFieldSignalEmitter<bool>(hoveredState, mouseEnter, mouseLeave);
   ASmallVector<APointerIndex, 1> mPressed;
 
   bool mEnabled = true;
   emits<bool> mEnabledChanged;
 
   bool mDirectlyEnabled = true;
   bool mParentEnabled = true;
   AFieldSignalEmitter<bool> mHasFocus = AFieldSignalEmitter<bool>(focusState, focusAcquired, focusLost, false);
 
   glm::ivec2 mExpanding = glm::ivec2{0, 0};
   emits<glm::ivec2> mExpandingChanged;

   AFloat mFloating = AFloat::NONE;
 
   struct RenderToTexture {
       _unique<IRenderViewToTexture> rendererInterface;
       IRenderViewToTexture::InvalidArea invalidArea;
 
       bool drawFromTexture = true;

       bool skipRedrawUntilTextureIsPresented = false;
   };
   AOptional<RenderToTexture> mRenderToTexture;

   virtual void invalidateStateStylesImpl(glm::ivec2 prevMinimumSizePlusField);
 
   void notifyParentChildFocused(const _<AView>& view);
};
 
API_AUI_VIEWS std::ostream& operator<<(std::ostream& os, const AView& view);

© 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.