AScrollArea.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 "AViewContainer.h"
#include "AScrollAreaViewport.h"
#include "AScrollbar.h"
#include "glm/fwd.hpp"
 
 
class API_AUI_VIEWS AScrollArea: public AViewContainerBase {
public:
    class Builder;
 
public:
    AScrollArea();
 
    void setSize(glm::ivec2 size) override;
    void setContents(_<AView> content) {
        mInner->setContents(std::move(content));
    }
 
    int getContentMinimumWidth() override;
    int getContentMinimumHeight() override;
 
    void onPointerPressed(const APointerPressedEvent& event) override;
    void onPointerReleased(const APointerReleasedEvent& event) override;
 
    void setScroll(glm::uvec2 scroll) {
        setScrollX(scroll.x);
        setScrollY(scroll.y);
    }
 
    void setScrollX(unsigned scroll) {
        AUI_NULLSAFE(mHorizontalScrollbar)->setScroll(int(scroll));
        else mInner->setScrollX(scroll);
    }
 
    void setScrollY(unsigned scroll) {
        AUI_NULLSAFE(mVerticalScrollbar)->setScroll(int(scroll));
        else mInner->setScrollY(scroll);
    }
 
    void setStickToEnd(bool stickToEnd) {
        AUI_NULLSAFE(mHorizontalScrollbar)->setStickToEnd(stickToEnd);
        AUI_NULLSAFE(mVerticalScrollbar)->setStickToEnd(stickToEnd);
    }
 
    void scroll(glm::ivec2 by) noexcept {
        scroll(by.x, by.y);
    }
 
    void scroll(int deltaByX, int deltaByY) noexcept {
        AUI_NULLSAFE(mHorizontalScrollbar)->scroll(deltaByX);
        else mInner->setScrollX(mInner->scroll().x + deltaByX);
        AUI_NULLSAFE(mVerticalScrollbar)->scroll(deltaByY);
        else mInner->setScrollY(mInner->scroll().y + deltaByY);
    }
 
    bool onGesture(const glm::ivec2 &origin, const AGestureEvent &event) override;
 
    void onScroll(const AScrollEvent& event) override;
 
    void setScrollbarAppearance(ass::ScrollbarAppearance scrollbarAppearance) {
        AUI_NULLSAFE(mHorizontalScrollbar)->setAppearance(scrollbarAppearance.getHorizontal());
        AUI_NULLSAFE(mVerticalScrollbar)->setAppearance(scrollbarAppearance.getVertical());
    }
 
    void scrollTo(const _<AView>& target, bool nearestBorder = true) {
        if (!target) {
            // nullptr target???
            return;
        }
        scrollTo(ARect<int>::fromTopLeftPositionAndSize(target->getPositionInWindow(), target->getSize()), nearestBorder);
    }
 
    void scrollTo(ARect<int> target, bool nearestBorder = true);
 
    void setWheelScrollable(bool value) {
        mIsWheelScrollable = value;
    }
 
    class Builder {
    friend class AScrollArea;
    private:
        _<AScrollbar> mExternalVerticalScrollbar;
        _<AScrollbar> mExternalHorizontalScrollbar;
        _<AView> mContents;
        bool mExpanding = false;
 
    public:
        Builder() = default;
 
        Builder& withExternalVerticalScrollbar(_<AScrollbar> externalVerticalScrollbar) {
            mExternalVerticalScrollbar = std::move(externalVerticalScrollbar);
            return *this;
        }
 
        Builder& withExternalHorizontalScrollbar(_<AScrollbar> externalHorizontalScrollbar) {
            mExternalHorizontalScrollbar = std::move(externalHorizontalScrollbar);
            return *this;
        }
 
        Builder& withContents(_<AView> contents) {
            mContents = std::move(contents);
            return *this;
        }
 
        Builder& withExpanding() {
            mExpanding = true;
            return *this;
        }
 
        _<AScrollArea> build() {
            return aui::ptr::manage(new AScrollArea(*this));
        }
 
        operator _<AView>() {
            return build();
        }
        operator _<AViewContainerBase>() {
            return build();
        }
    };
 
    [[nodiscard]]
    const _<AView>& contents() const noexcept {
        return mInner->contents();
    }
 
    [[nodiscard]]
    const _<AScrollbar>& verticalScrollbar() const noexcept {
        return mVerticalScrollbar;
    }
 
    [[nodiscard]]
    const _<AScrollbar>& horizontalScrollbar() const noexcept {
        return mHorizontalScrollbar;
    }
    
    [[nodiscard]]
    glm::uvec2 scroll() const noexcept {
        return mInner->scroll();
    }
protected:
    explicit AScrollArea(const Builder& builder);
 
private:
    _<AScrollAreaViewport> mInner;
    _<AScrollbar> mVerticalScrollbar;
    _<AScrollbar> mHorizontalScrollbar;
 
    bool mIsWheelScrollable = true;
};