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

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