/****************************************************************************
Copyright (c) 2013-2016 Chukong Technologies Inc.
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
Copyright (c) 2019-present Axmol Engine contributors (see AUTHORS.md).

https://axmolengine.github.io/

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/

#include "ui/UIScrollView.h"
#include "base/Director.h"
#include "base/Utils.h"
#include "platform/Device.h"
#include "ui/UIScrollViewBar.h"
#include "2d/TweenFunction.h"
#include "2d/Camera.h"
NS_AX_BEGIN

namespace
{
constexpr float DEFAULT_TIME_IN_SEC_FOR_SCROLL_TO_ITEM  = 1.0f;
constexpr int NUMBER_OF_GATHERED_TOUCHES_FOR_MOVE_SPEED = 5;
constexpr float OUT_OF_BOUNDARY_BREAKING_FACTOR         = 0.05f;
constexpr float BOUNCE_BACK_DURATION                    = 1.0f;

float convertDistanceFromPointToInch(const Vec2& dis)
{
    auto glView    = Director::getInstance()->getGLView();
    int dpi        = Device::getDPI();
    float distance = Vec2(dis.x * glView->getScaleX() / dpi, dis.y * glView->getScaleY() / dpi).getLength();
    return distance;
}
}  // namespace

#define MOVE_INCH (7.0f / 160.0f)

namespace ui
{

IMPLEMENT_CLASS_GUI_INFO(ScrollView)

ScrollView::ScrollView()
    : _innerContainer(nullptr)
    , _direction(Direction::VERTICAL)
    , _topBoundary(0.0f)
    , _bottomBoundary(0.0f)
    , _leftBoundary(0.0f)
    , _rightBoundary(0.0f)
    , _bePressed(false)
    , _childFocusCancelOffsetInInch(MOVE_INCH)
    , _touchMovePreviousTimestamp(0)
    , _touchTotalTimeThreshold(0.5f)
    , _scrolling(false)
    , _autoScrolling(false)
    , _autoScrollAttenuate(true)
    , _autoScrollTotalTime(0)
    , _autoScrollAccumulatedTime(0)
    , _autoScrollCurrentlyOutOfBoundary(false)
    , _autoScrollBraking(false)
    , _inertiaScrollEnabled(true)
    , _bounceEnabled(false)
    , _outOfBoundaryAmount(Vec2::ZERO)
    , _outOfBoundaryAmountDirty(true)
    , _scrollBarEnabled(true)
    , _verticalScrollBar(nullptr)
    , _horizontalScrollBar(nullptr)
    , _scrollViewEventListener(nullptr)
    , _eventCallback(nullptr)
    , _scrollTime(DEFAULT_TIME_IN_SEC_FOR_SCROLL_TO_ITEM)
{
    setTouchEnabled(true);
    _propagateTouchEvents = false;
}

ScrollView::~ScrollView()
{
    _verticalScrollBar       = nullptr;
    _horizontalScrollBar     = nullptr;
    _scrollViewEventListener = nullptr;
}

ScrollView* ScrollView::create()
{
    ScrollView* widget = new ScrollView();
    if (widget->init())
    {
        widget->autorelease();
        return widget;
    }
    AX_SAFE_DELETE(widget);
    return nullptr;
}

void ScrollView::onEnter()
{
    Layout::onEnter();
    scheduleUpdate();
}

void ScrollView::onExit()
{
    Layout::onExit();
    stopOverallScroll();
}

bool ScrollView::init()
{
    if (Layout::init())
    {
        setClippingEnabled(true);
        _innerContainer->setTouchEnabled(false);
        if (_scrollBarEnabled)
        {
            initScrollBar();
        }
        return true;
    }
    return false;
}

void ScrollView::initRenderer()
{
    Layout::initRenderer();
    _innerContainer = Layout::create();
    _innerContainer->setColor(Color3B(255, 255, 255));
    _innerContainer->setOpacity(255);
    _innerContainer->setCascadeColorEnabled(true);
    _innerContainer->setCascadeOpacityEnabled(true);
    addProtectedChild(_innerContainer, 1, 1);
}

void ScrollView::onSizeChanged()
{
    Layout::onSizeChanged();
    _topBoundary               = _contentSize.height;
    _rightBoundary             = _contentSize.width;
    Vec2 innerSize             = _innerContainer->getContentSize();
    float orginInnerSizeWidth  = innerSize.width;
    float orginInnerSizeHeight = innerSize.height;
    float innerSizeWidth       = MAX(orginInnerSizeWidth, _contentSize.width);
    float innerSizeHeight      = MAX(orginInnerSizeHeight, _contentSize.height);
    _innerContainer->setContentSize(Vec2(innerSizeWidth, innerSizeHeight));
    setInnerContainerPosition(Vec2(0.0f, _contentSize.height - _innerContainer->getContentSize().height));

    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->onScrolled(getHowMuchOutOfBoundary());
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->onScrolled(getHowMuchOutOfBoundary());
    }
}

void ScrollView::setInnerContainerSize(const Vec2& size)
{
    float innerSizeWidth   = _contentSize.width;
    float innerSizeHeight  = _contentSize.height;
    Vec2 originalInnerSize = _innerContainer->getContentSize();
    if (size.width >= innerSizeWidth)
    {
        innerSizeWidth = size.width;
    }
    if (size.height >= innerSizeHeight)
    {
        innerSizeHeight = size.height;
    }
    _innerContainer->setContentSize(Vec2(innerSizeWidth, innerSizeHeight));

    // Calculate and set the position of the inner container.
    Vec2 pos               = _innerContainer->getPosition();
    const auto boundingBox = _innerContainer->getBoundingBox();
    const auto rBoundary   = boundingBox.origin.x + boundingBox.size.width;
    const auto bBoundary   = boundingBox.origin.y;
    if (rBoundary < _contentSize.width)
    {
        // When the right border does not fit to the width,
        // consider left-side fitting or right-side fitting.
        const auto lBoundary = boundingBox.origin.x;
        if (rBoundary - lBoundary > _contentSize.width)
        {
            // The width of _innerContainer is greater than _contentSize.width,use right-side fitting.
            pos.x = _contentSize.width -
                    (1.f - _innerContainer->getAnchorPoint().x) * _innerContainer->getContentSize().width;
        }
        else
        {
            // or use left-side fitting.
            pos.x = _innerContainer->getAnchorPoint().x * _innerContainer->getContentSize().width;
        }
    }
    if (bBoundary > 0.f)
    {
        // Same as horizontal direction.
        const auto tBoundary = boundingBox.origin.y + boundingBox.size.height;
        if (tBoundary - bBoundary > _contentSize.height)
        {
            pos.y = _innerContainer->getAnchorPoint().y * _innerContainer->getContentSize().height;
        }
        else
        {
            pos.y = _contentSize.height -
                    (1.0f - _innerContainer->getAnchorPoint().y) * _innerContainer->getContentSize().height;
        }
    }
    // In the vertical direction, if the _innerContainer initially contains content larger than _contentSize.height,
    // this will result in bottom alignment.Obviously this is not what I want,
    // so here is the rule : when the height of _innerContainer and _contentSize are equal,
    // if the position of _innerContainer needs to be changed at this point,align _innerContainer to the top.
    if (Direction::VERTICAL == _direction && originalInnerSize.height == _contentSize.height)
    {
        pos.y = _contentSize.height - innerSizeHeight;
    }

    setInnerContainerPosition(pos);

    updateScrollBar(Vec2::ZERO);
}

const Vec2& ScrollView::getInnerContainerSize() const
{
    return _innerContainer->getContentSize();
}

void ScrollView::setInnerContainerPosition(const Vec2& position)
{
    if (position == _innerContainer->getPosition())
    {
        return;
    }
    _innerContainer->setPosition(position);
    _outOfBoundaryAmountDirty = true;

    // Process bouncing events
    if (_bounceEnabled)
    {
        for (int direction = (int)MoveDirection::TOP; direction < (int)MoveDirection::RIGHT; ++direction)
        {
            if (isOutOfBoundary((MoveDirection)direction))
            {
                processScrollEvent((MoveDirection)direction, true);
            }
        }
    }

    this->retain();
    if (_eventCallback)
    {
        _eventCallback(this, EventType::CONTAINER_MOVED);
    }
    if (_ccEventCallback)
    {
        _ccEventCallback(this, static_cast<int>(EventType::CONTAINER_MOVED));
    }
    this->release();
}

const Vec2& ScrollView::getInnerContainerPosition() const
{
    return _innerContainer->getPosition();
}

void ScrollView::addChild(Node* child)
{
    ScrollView::addChild(child, child->getLocalZOrder(), child->getTag());
}

void ScrollView::addChild(Node* child, int localZOrder)
{
    ScrollView::addChild(child, localZOrder, child->getTag());
}

void ScrollView::addChild(Node* child, int zOrder, int tag)
{
    child->setGlobalZOrder(_globalZOrder);
    _innerContainer->addChild(child, zOrder, tag);
}

void ScrollView::addChild(Node* child, int zOrder, std::string_view name)
{
    child->setGlobalZOrder(_globalZOrder);
    _innerContainer->addChild(child, zOrder, name);
}

void ScrollView::removeAllChildren()
{
    removeAllChildrenWithCleanup(true);
}

void ScrollView::removeAllChildrenWithCleanup(bool cleanup)
{
    _innerContainer->removeAllChildrenWithCleanup(cleanup);
}

void ScrollView::removeChild(Node* child, bool cleanup)
{
    return _innerContainer->removeChild(child, cleanup);
}

Vector<Node*>& ScrollView::getChildren()
{
    return _innerContainer->getChildren();
}

const Vector<Node*>& ScrollView::getChildren() const
{
    return _innerContainer->getChildren();
}

ssize_t ScrollView::getChildrenCount() const
{
    return _innerContainer->getChildrenCount();
}

Node* ScrollView::getChildByTag(int tag) const
{
    return _innerContainer->getChildByTag(tag);
}

Node* ScrollView::getChildByName(std::string_view name) const
{
    return _innerContainer->getChildByName(name);
}

void ScrollView::moveInnerContainer(const Vec2& deltaMove, bool canStartBounceBack)
{
    Vec2 adjustedMove = flattenVectorByDirection(deltaMove);

    setInnerContainerPosition(getInnerContainerPosition() + adjustedMove);

    Vec2 outOfBoundary = getHowMuchOutOfBoundary();
    updateScrollBar(outOfBoundary);

    if (_bounceEnabled && canStartBounceBack)
    {
        startBounceBackIfNeeded();
    }
}

void ScrollView::updateScrollBar(const Vec2& outOfBoundary)
{
    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->onScrolled(outOfBoundary);
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->onScrolled(outOfBoundary);
    }
}

Vec2 ScrollView::calculateTouchMoveVelocity() const
{
    float totalTime = 0;
    for (auto&& timeDelta : _touchMoveTimeDeltas)
    {
        totalTime += timeDelta;
    }
    if (totalTime == 0 || totalTime >= _touchTotalTimeThreshold)
    {
        return Vec2::ZERO;
    }

    Vec2 totalMovement;
    for (auto&& displacement : _touchMoveDisplacements)
    {
        totalMovement += displacement;
    }
    return totalMovement / totalTime;
}

void ScrollView::startInertiaScroll(const Vec2& touchMoveVelocity)
{
    const float MOVEMENT_FACTOR = 0.7f;
    Vec2 inertiaTotalMovement   = touchMoveVelocity * MOVEMENT_FACTOR;
    startAttenuatingAutoScroll(inertiaTotalMovement, touchMoveVelocity);
}

bool ScrollView::startBounceBackIfNeeded()
{
    if (!_bounceEnabled)
    {
        return false;
    }
    Vec2 bounceBackAmount = getHowMuchOutOfBoundary();
    if (fltEqualZero(bounceBackAmount))
    {
        return false;
    }

    startAutoScroll(bounceBackAmount, BOUNCE_BACK_DURATION, true);
    return true;
}

Vec2 ScrollView::flattenVectorByDirection(const Vec2& vector)
{
    Vec2 result = vector;
    result.x    = (_direction == Direction::VERTICAL ? 0 : result.x);
    result.y    = (_direction == Direction::HORIZONTAL ? 0 : result.y);
    return result;
}

Vec2 ScrollView::getHowMuchOutOfBoundary(const Vec2& addition)
{
    if (addition == Vec2::ZERO && !_outOfBoundaryAmountDirty)
    {
        return _outOfBoundaryAmount;
    }

    Vec2 outOfBoundaryAmount(Vec2::ZERO);
    if (_innerContainer->getLeftBoundary() + addition.x > _leftBoundary)
    {
        outOfBoundaryAmount.x = _leftBoundary - (_innerContainer->getLeftBoundary() + addition.x);
    }
    else if (_innerContainer->getRightBoundary() + addition.x < _rightBoundary)
    {
        outOfBoundaryAmount.x = _rightBoundary - (_innerContainer->getRightBoundary() + addition.x);
    }

    if (_innerContainer->getTopBoundary() + addition.y < _topBoundary)
    {
        outOfBoundaryAmount.y = _topBoundary - (_innerContainer->getTopBoundary() + addition.y);
    }
    else if (_innerContainer->getBottomBoundary() + addition.y > _bottomBoundary)
    {
        outOfBoundaryAmount.y = _bottomBoundary - (_innerContainer->getBottomBoundary() + addition.y);
    }

    if (addition == Vec2::ZERO)
    {
        _outOfBoundaryAmount      = outOfBoundaryAmount;
        _outOfBoundaryAmountDirty = false;
    }
    return outOfBoundaryAmount;
}

bool ScrollView::isOutOfBoundary(MoveDirection dir)
{
    Vec2 outOfBoundary = getHowMuchOutOfBoundary();
    switch (dir)
    {
    case MoveDirection::TOP:
        return outOfBoundary.y > 0;
    case MoveDirection::BOTTOM:
        return outOfBoundary.y < 0;
    case MoveDirection::LEFT:
        return outOfBoundary.x < 0;
    case MoveDirection::RIGHT:
        return outOfBoundary.x > 0;
    }
    return false;
}

bool ScrollView::isOutOfBoundary()
{
    return !fltEqualZero(getHowMuchOutOfBoundary());
}

void ScrollView::startAutoScrollToDestination(const Vec2& destination, float timeInSec, bool attenuated)
{
    startAutoScroll(destination - _innerContainer->getPosition(), timeInSec, attenuated);
}

static float calculateAutoScrollTimeByInitialSpeed(float initialSpeed)
{
    // Calculate the time from the initial speed according to quintic polynomial.
    float time = sqrtf(sqrtf(initialSpeed / 5));
    return time;
}

void ScrollView::startAttenuatingAutoScroll(const Vec2& deltaMove, const Vec2& initialVelocity)
{
    float time = calculateAutoScrollTimeByInitialSpeed(initialVelocity.length());
    startAutoScroll(deltaMove, time, true);
}

void ScrollView::startAutoScroll(const Vec2& deltaMove, float timeInSec, bool attenuated)
{
    Vec2 adjustedDeltaMove = flattenVectorByDirection(deltaMove);

    _autoScrolling                  = true;
    _autoScrollTargetDelta          = adjustedDeltaMove;
    _autoScrollAttenuate            = attenuated;
    _autoScrollStartPosition        = _innerContainer->getPosition();
    _autoScrollTotalTime            = timeInSec;
    _autoScrollAccumulatedTime      = 0;
    _autoScrollBraking              = false;
    _autoScrollBrakingStartPosition = Vec2::ZERO;

    // If the destination is also out of boundary of same side, start brake from beginning.
    Vec2 currentOutOfBoundary = getHowMuchOutOfBoundary();
    if (!fltEqualZero(currentOutOfBoundary))
    {
        _autoScrollCurrentlyOutOfBoundary = true;
        Vec2 afterOutOfBoundary           = getHowMuchOutOfBoundary(adjustedDeltaMove);
        if (currentOutOfBoundary.x * afterOutOfBoundary.x > 0 || currentOutOfBoundary.y * afterOutOfBoundary.y > 0)
        {
            _autoScrollBraking = true;
        }
    }
}

void ScrollView::stopScroll()
{
    if (_scrolling)
    {
        if (_verticalScrollBar != nullptr)
        {
            _verticalScrollBar->onTouchEnded();
        }
        if (_horizontalScrollBar != nullptr)
        {
            _horizontalScrollBar->onTouchEnded();
        }

        _scrolling = false;
        _bePressed = false;

        startBounceBackIfNeeded();

        dispatchEvent(EventType::SCROLLING_ENDED);
    }
}

void ScrollView::stopAutoScroll()
{
    if (_autoScrolling)
    {
        if (_verticalScrollBar != nullptr)
        {
            _verticalScrollBar->onTouchEnded();
        }
        if (_horizontalScrollBar != nullptr)
        {
            _horizontalScrollBar->onTouchEnded();
        }

        _autoScrolling             = false;
        _autoScrollAttenuate       = true;
        _autoScrollTotalTime       = 0;
        _autoScrollAccumulatedTime = 0;

        dispatchEvent(EventType::AUTOSCROLL_ENDED);
    }
}

void ScrollView::stopOverallScroll()
{
    stopScroll();
    stopAutoScroll();
}

bool ScrollView::isNecessaryAutoScrollBrake()
{
    if (_autoScrollBraking)
    {
        return true;
    }

    if (isOutOfBoundary())
    {
        // It just went out of boundary.
        if (!_autoScrollCurrentlyOutOfBoundary)
        {
            _autoScrollCurrentlyOutOfBoundary = true;
            _autoScrollBraking                = true;
            _autoScrollBrakingStartPosition   = getInnerContainerPosition();
            return true;
        }
    }
    else
    {
        _autoScrollCurrentlyOutOfBoundary = false;
    }
    return false;
}

float ScrollView::getAutoScrollStopEpsilon() const
{
    return FLT_EPSILON;
}

bool ScrollView::fltEqualZero(const Vec2& point) const
{
    return (fabsf(point.x) <= 0.0001f && fabsf(point.y) <= 0.0001f);
}

void ScrollView::processAutoScrolling(float deltaTime)
{
    // Make auto scroll shorter if it needs to deaccelerate.
    float brakingFactor = (isNecessaryAutoScrollBrake() ? OUT_OF_BOUNDARY_BREAKING_FACTOR : 1);

    // Elapsed time
    _autoScrollAccumulatedTime += deltaTime * (1 / brakingFactor);

    // Calculate the progress percentage
    float percentage = MIN(1, _autoScrollAccumulatedTime / _autoScrollTotalTime);
    if (_autoScrollAttenuate)
    {
        // Use quintic(5th degree) polynomial
        percentage = tweenfunc::quintEaseOut(percentage);
    }

    // Calculate the new position
    Vec2 newPosition = _autoScrollStartPosition + (_autoScrollTargetDelta * percentage);
    bool reachedEnd  = std::abs(percentage - 1) <= this->getAutoScrollStopEpsilon();

    if (reachedEnd)
    {
        newPosition = _autoScrollStartPosition + _autoScrollTargetDelta;
    }

    if (_bounceEnabled)
    {
        // The new position is adjusted if out of boundary
        newPosition = _autoScrollBrakingStartPosition + (newPosition - _autoScrollBrakingStartPosition) * brakingFactor;
    }
    else
    {
        // Don't let go out of boundary
        Vec2 moveDelta     = newPosition - getInnerContainerPosition();
        Vec2 outOfBoundary = getHowMuchOutOfBoundary(moveDelta);
        if (!fltEqualZero(outOfBoundary))
        {
            newPosition += outOfBoundary;
            reachedEnd = true;
        }
    }

    // Finish auto scroll if it ended
    if (reachedEnd)
    {
        _autoScrolling = false;
        dispatchEvent(EventType::AUTOSCROLL_ENDED);
    }

    moveInnerContainer(newPosition - getInnerContainerPosition(), reachedEnd);
}

void ScrollView::jumpToDestination(const Vec2& des)
{
    _autoScrolling = false;
    moveInnerContainer(des - getInnerContainerPosition(), true);
}

void ScrollView::scrollChildren(const Vec2& deltaMove)
{
    Vec2 realMove = deltaMove;
    if (_bounceEnabled)
    {
        // If the position of the inner container is out of the boundary, the offsets should be divided by two.
        Vec2 outOfBoundary = getHowMuchOutOfBoundary();
        realMove.x *= (outOfBoundary.x == 0 ? 1 : 0.5f);
        realMove.y *= (outOfBoundary.y == 0 ? 1 : 0.5f);
    }

    if (!_bounceEnabled)
    {
        Vec2 outOfBoundary = getHowMuchOutOfBoundary(realMove);
        realMove += outOfBoundary;
    }

    bool scrolledToLeft   = false;
    bool scrolledToRight  = false;
    bool scrolledToTop    = false;
    bool scrolledToBottom = false;
    if (realMove.y > 0.0f)  // up
    {
        float icBottomPos = _innerContainer->getBottomBoundary();
        if (icBottomPos + realMove.y >= _bottomBoundary)
        {
            scrolledToBottom = true;
        }
    }
    else if (realMove.y < 0.0f)  // down
    {
        float icTopPos = _innerContainer->getTopBoundary();
        if (icTopPos + realMove.y <= _topBoundary)
        {
            scrolledToTop = true;
        }
    }

    if (realMove.x < 0.0f)  // left
    {
        float icRightPos = _innerContainer->getRightBoundary();
        if (icRightPos + realMove.x <= _rightBoundary)
        {
            scrolledToRight = true;
        }
    }
    else if (realMove.x > 0.0f)  // right
    {
        float icLeftPos = _innerContainer->getLeftBoundary();
        if (icLeftPos + realMove.x >= _leftBoundary)
        {
            scrolledToLeft = true;
        }
    }
    moveInnerContainer(realMove, false);

    if (realMove.x != 0 || realMove.y != 0)
    {
        processScrollingEvent();
    }
    if (scrolledToBottom)
    {
        processScrollEvent(MoveDirection::BOTTOM, false);
    }
    if (scrolledToTop)
    {
        processScrollEvent(MoveDirection::TOP, false);
    }
    if (scrolledToLeft)
    {
        processScrollEvent(MoveDirection::LEFT, false);
    }
    if (scrolledToRight)
    {
        processScrollEvent(MoveDirection::RIGHT, false);
    }
}

void ScrollView::scrollToBottom(float timeInSec, bool attenuated)
{
    startAutoScrollToDestination(Vec2(_innerContainer->getPosition().x, 0.0f), timeInSec, attenuated);
}

void ScrollView::scrollToTop(float timeInSec, bool attenuated)
{
    startAutoScrollToDestination(
        Vec2(_innerContainer->getPosition().x, _contentSize.height - _innerContainer->getContentSize().height),
        timeInSec, attenuated);
}

void ScrollView::scrollToLeft(float timeInSec, bool attenuated)
{
    startAutoScrollToDestination(Vec2(0.0f, _innerContainer->getPosition().y), timeInSec, attenuated);
}

void ScrollView::scrollToRight(float timeInSec, bool attenuated)
{
    startAutoScrollToDestination(
        Vec2(_contentSize.width - _innerContainer->getContentSize().width, _innerContainer->getPosition().y), timeInSec,
        attenuated);
}

void ScrollView::scrollToTopLeft(float timeInSec, bool attenuated)
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    startAutoScrollToDestination(Vec2(0.0f, _contentSize.height - _innerContainer->getContentSize().height), timeInSec,
                                 attenuated);
}

void ScrollView::scrollToTopRight(float timeInSec, bool attenuated)
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    startAutoScrollToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width,
                                      _contentSize.height - _innerContainer->getContentSize().height),
                                 timeInSec, attenuated);
}

void ScrollView::scrollToBottomLeft(float timeInSec, bool attenuated)
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    startAutoScrollToDestination(Vec2::ZERO, timeInSec, attenuated);
}

void ScrollView::scrollToBottomRight(float timeInSec, bool attenuated)
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    startAutoScrollToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width, 0.0f), timeInSec,
                                 attenuated);
}

void ScrollView::scrollToPercentVertical(float percent, float timeInSec, bool attenuated)
{
    float minY = _contentSize.height - _innerContainer->getContentSize().height;
    float h    = -minY;
    startAutoScrollToDestination(Vec2(_innerContainer->getPosition().x, minY + percent * h / 100.0f), timeInSec,
                                 attenuated);
}

void ScrollView::scrollToPercentHorizontal(float percent, float timeInSec, bool attenuated)
{
    float w = _innerContainer->getContentSize().width - _contentSize.width;
    startAutoScrollToDestination(Vec2(-(percent * w / 100.0f), _innerContainer->getPosition().y), timeInSec,
                                 attenuated);
}

void ScrollView::scrollToPercentBothDirection(const Vec2& percent, float timeInSec, bool attenuated)
{
    if (_direction != Direction::BOTH)
    {
        return;
    }
    float minY = _contentSize.height - _innerContainer->getContentSize().height;
    float h    = -minY;
    float w    = _innerContainer->getContentSize().width - _contentSize.width;
    startAutoScrollToDestination(Vec2(-(percent.x * w / 100.0f), minY + percent.y * h / 100.0f), timeInSec, attenuated);
}

float ScrollView::getScrolledPercentVertical() const
{
    const float minY = getContentSize().height - getInnerContainerSize().height;
    return (1.f - getInnerContainerPosition().y / minY) * 100.f;
}
float ScrollView::getScrolledPercentHorizontal() const
{
    const float minX = getContentSize().width - getInnerContainerSize().width;
    return getInnerContainerPosition().x / minX * 100.f;
}
Vec2 ScrollView::getScrolledPercentBothDirection() const
{
    return {getScrolledPercentHorizontal(), getScrolledPercentVertical()};
}

void ScrollView::jumpToBottom()
{
    jumpToDestination(Vec2(_innerContainer->getPosition().x, 0.0f));
}

void ScrollView::jumpToTop()
{
    jumpToDestination(
        Vec2(_innerContainer->getPosition().x, _contentSize.height - _innerContainer->getContentSize().height));
}

void ScrollView::jumpToLeft()
{
    jumpToDestination(Vec2(0.0f, _innerContainer->getPosition().y));
}

void ScrollView::jumpToRight()
{
    jumpToDestination(
        Vec2(_contentSize.width - _innerContainer->getContentSize().width, _innerContainer->getPosition().y));
}

void ScrollView::jumpToTopLeft()
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    jumpToDestination(Vec2(0.0f, _contentSize.height - _innerContainer->getContentSize().height));
}

void ScrollView::jumpToTopRight()
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    jumpToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width,
                           _contentSize.height - _innerContainer->getContentSize().height));
}

void ScrollView::jumpToBottomLeft()
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    jumpToDestination(Vec2::ZERO);
}

void ScrollView::jumpToBottomRight()
{
    if (_direction != Direction::BOTH)
    {
        AXLOG("Scroll direction is not both!");
        return;
    }
    jumpToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width, 0.0f));
}

void ScrollView::jumpToPercentVertical(float percent)
{
    float minY = _contentSize.height - _innerContainer->getContentSize().height;
    float h    = -minY;
    jumpToDestination(Vec2(_innerContainer->getPosition().x, minY + percent * h / 100.0f));
}

void ScrollView::jumpToPercentHorizontal(float percent)
{
    float w = _innerContainer->getContentSize().width - _contentSize.width;
    jumpToDestination(Vec2(-(percent * w / 100.0f), _innerContainer->getPosition().y));
}

void ScrollView::jumpToPercentBothDirection(const Vec2& percent)
{
    if (_direction != Direction::BOTH)
    {
        return;
    }
    float minY = _contentSize.height - _innerContainer->getContentSize().height;
    float h    = -minY;
    float w    = _innerContainer->getContentSize().width - _contentSize.width;
    jumpToDestination(Vec2(-(percent.x * w / 100.0f), minY + percent.y * h / 100.0f));
}

bool ScrollView::calculateCurrAndPrevTouchPoints(Touch* touch, Vec3* currPt, Vec3* prevPt)
{
    if (nullptr == _hittedByCamera || false == hitTest(touch->getLocation(), _hittedByCamera, currPt) ||
        false == hitTest(touch->getPreviousLocation(), _hittedByCamera, prevPt))
    {
        return false;
    }
    return true;
}

void ScrollView::gatherTouchMove(const Vec2& delta)
{
    while (_touchMoveDisplacements.size() >= NUMBER_OF_GATHERED_TOUCHES_FOR_MOVE_SPEED)
    {
        _touchMoveDisplacements.pop_front();
        _touchMoveTimeDeltas.pop_front();
    }
    _touchMoveDisplacements.emplace_back(delta);

    long long timestamp = utils::getTimeInMilliseconds();
    _touchMoveTimeDeltas.emplace_back((timestamp - _touchMovePreviousTimestamp) / 1000.0f);
    _touchMovePreviousTimestamp = timestamp;
}

void ScrollView::handlePressLogic(Touch* /*touch*/)
{
    _bePressed     = true;
    _autoScrolling = false;

    // Clear gathered touch move information
    {
        _touchMovePreviousTimestamp = utils::getTimeInMilliseconds();
        _touchMoveDisplacements.clear();
        _touchMoveTimeDeltas.clear();
    }

    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->onTouchBegan();
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->onTouchBegan();
    }
}

void ScrollView::handleMoveLogic(Touch* touch)
{
    if (!_bePressed)
        return;

    Vec3 currPt, prevPt;
    if (!calculateCurrAndPrevTouchPoints(touch, &currPt, &prevPt))
    {
        return;
    }
    Vec3 delta3 = currPt - prevPt;
    Vec2 delta(delta3.x, delta3.y);
    scrollChildren(delta);

    // Gather touch move information for speed calculation
    gatherTouchMove(delta);
}

void ScrollView::handleReleaseLogic(Touch* touch)
{
    if (!_bePressed)
        return;

    // Gather the last touch information when released
    {
        Vec3 currPt, prevPt;
        if (calculateCurrAndPrevTouchPoints(touch, &currPt, &prevPt))
        {
            Vec3 delta3 = currPt - prevPt;
            Vec2 delta(delta3.x, delta3.y);
            gatherTouchMove(delta);
        }
    }

    _bePressed = false;

    bool bounceBackStarted = startBounceBackIfNeeded();
    if (!bounceBackStarted && _inertiaScrollEnabled)
    {
        Vec2 touchMoveVelocity = calculateTouchMoveVelocity();
        if (touchMoveVelocity != Vec2::ZERO)
        {
            startInertiaScroll(touchMoveVelocity);
        }
    }

    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->onTouchEnded();
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->onTouchEnded();
    }

    if (_scrolling)
    {
        processScrollingEndedEvent();
    }
}

bool ScrollView::onTouchBegan(Touch* touch, Event* unusedEvent)
{
    bool pass = Layout::onTouchBegan(touch, unusedEvent);
    if (!_isInterceptTouch)
    {
        if (_hitted)
        {
            handlePressLogic(touch);
        }
    }
    return pass;
}

void ScrollView::onTouchMoved(Touch* touch, Event* unusedEvent)
{
    Layout::onTouchMoved(touch, unusedEvent);
    if (!_isInterceptTouch)
    {
        handleMoveLogic(touch);
    }
}

void ScrollView::onTouchEnded(Touch* touch, Event* unusedEvent)
{
    Layout::onTouchEnded(touch, unusedEvent);
    if (!_isInterceptTouch)
    {
        handleReleaseLogic(touch);
    }
    _isInterceptTouch = false;
}

void ScrollView::onTouchCancelled(Touch* touch, Event* unusedEvent)
{
    Layout::onTouchCancelled(touch, unusedEvent);
    if (!_isInterceptTouch)
    {
        handleReleaseLogic(touch);
    }
    _isInterceptTouch = false;
}

void ScrollView::update(float dt)
{
    if (_autoScrolling)
    {
        processAutoScrolling(dt);
    }
}

void ScrollView::interceptTouchEvent(Widget::TouchEventType event, Widget* sender, Touch* touch)
{
    if (!_touchEnabled)
    {
        Layout::interceptTouchEvent(event, sender, touch);
        return;
    }
    if (_direction == Direction::NONE)
        return;
    Vec2 touchPoint = touch->getLocation();
    switch (event)
    {
    case TouchEventType::BEGAN:
    {
        _isInterceptTouch   = true;
        _touchBeganPosition = touch->getLocation();
        handlePressLogic(touch);
    }
    break;
    case TouchEventType::MOVED:
    {
        _touchMovePosition = touch->getLocation();
        // calculates move offset in points
        float offsetInInch = 0;
        switch (_direction)
        {
        case Direction::HORIZONTAL:
            offsetInInch =
                convertDistanceFromPointToInch(Vec2(std::abs(sender->getTouchBeganPosition().x - touchPoint.x), 0.0f));
            break;
        case Direction::VERTICAL:
            offsetInInch =
                convertDistanceFromPointToInch(Vec2(0.0f, std::abs(sender->getTouchBeganPosition().y - touchPoint.y)));
            break;
        case Direction::BOTH:
            offsetInInch = convertDistanceFromPointToInch(sender->getTouchBeganPosition() - touchPoint);
            break;
        default:
            break;
        }
        if (offsetInInch > _childFocusCancelOffsetInInch)
        {
            sender->setHighlighted(false);
            handleMoveLogic(touch);
        }
    }
    break;

    case TouchEventType::CANCELED:
    case TouchEventType::ENDED:
    {
        _touchEndPosition = touch->getLocation();
        handleReleaseLogic(touch);
        if (sender->isSwallowTouches())
        {
            _isInterceptTouch = false;
        }
    }
    break;
    }
}

void ScrollView::processScrollEvent(MoveDirection dir, bool bounce)
{
    EventType eventType;
    switch (dir)
    {
    case MoveDirection::TOP:
    {
        eventType = (bounce ? EventType::BOUNCE_TOP : EventType::SCROLL_TO_TOP);
        break;
    }
    case MoveDirection::BOTTOM:
    {
        eventType = (bounce ? EventType::BOUNCE_BOTTOM : EventType::SCROLL_TO_BOTTOM);
        break;
    }
    case MoveDirection::LEFT:
    {
        eventType = (bounce ? EventType::BOUNCE_LEFT : EventType::SCROLL_TO_LEFT);
        break;
    }
    case MoveDirection::RIGHT:
    {
        eventType = (bounce ? EventType::BOUNCE_RIGHT : EventType::SCROLL_TO_RIGHT);
        break;
    }
    }
    dispatchEvent(eventType);
}

void ScrollView::processScrollingEvent()
{
    if (!_scrolling)
    {
        _scrolling = true;
        dispatchEvent(EventType::SCROLLING_BEGAN);
    }
    dispatchEvent(EventType::SCROLLING);
}

void ScrollView::processScrollingEndedEvent()
{
    _scrolling = false;
    dispatchEvent(EventType::SCROLLING_ENDED);
}

void ScrollView::dispatchEvent(EventType eventType)
{
    this->retain();
    if (_eventCallback)
    {
        _eventCallback(this, eventType);
    }
    if (_ccEventCallback)
    {
        _ccEventCallback(this, static_cast<int>(eventType));
    }
    this->release();
}

void ScrollView::addEventListener(const ccScrollViewCallback& callback)
{
    _eventCallback = callback;
}

void ScrollView::setDirection(Direction dir)
{
    _direction = dir;
    if (_scrollBarEnabled)
    {
        removeScrollBar();
        initScrollBar();
    }
}

ScrollView::Direction ScrollView::getDirection() const
{
    return _direction;
}

void ScrollView::setBounceEnabled(bool enabled)
{
    _bounceEnabled = enabled;
}

bool ScrollView::isBounceEnabled() const
{
    return _bounceEnabled;
}

void ScrollView::setInertiaScrollEnabled(bool enabled)
{
    _inertiaScrollEnabled = enabled;
}

bool ScrollView::isInertiaScrollEnabled() const
{
    return _inertiaScrollEnabled;
}

void ScrollView::setScrollBarEnabled(bool enabled)
{
    if (_scrollBarEnabled == enabled)
    {
        return;
    }

    if (_scrollBarEnabled)
    {
        removeScrollBar();
    }
    _scrollBarEnabled = enabled;
    if (_scrollBarEnabled)
    {
        initScrollBar();
    }
}

bool ScrollView::isScrollBarEnabled() const
{
    return _scrollBarEnabled;
}

void ScrollView::setScrollBarPositionFromCorner(const Vec2& positionFromCorner)
{
    if (_direction != Direction::HORIZONTAL)
    {
        setScrollBarPositionFromCornerForVertical(positionFromCorner);
    }
    if (_direction != Direction::VERTICAL)
    {
        setScrollBarPositionFromCornerForHorizontal(positionFromCorner);
    }
}

void ScrollView::setScrollBarPositionFromCornerForVertical(const Vec2& positionFromCorner)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    AXASSERT(_direction != Direction::HORIZONTAL, "Scroll view doesn't have a vertical scroll bar!");
    _verticalScrollBar->setPositionFromCorner(positionFromCorner);
}

Vec2 ScrollView::getScrollBarPositionFromCornerForVertical() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    AXASSERT(_direction != Direction::HORIZONTAL, "Scroll view doesn't have a vertical scroll bar!");
    return _verticalScrollBar->getPositionFromCorner();
}

void ScrollView::setScrollBarPositionFromCornerForHorizontal(const Vec2& positionFromCorner)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    AXASSERT(_direction != Direction::VERTICAL, "Scroll view doesn't have a horizontal scroll bar!");
    _horizontalScrollBar->setPositionFromCorner(positionFromCorner);
}

Vec2 ScrollView::getScrollBarPositionFromCornerForHorizontal() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    AXASSERT(_direction != Direction::VERTICAL, "Scroll view doesn't have a horizontal scroll bar!");
    return _horizontalScrollBar->getPositionFromCorner();
}

void ScrollView::setScrollBarWidth(float width)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->setWidth(width);
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->setWidth(width);
    }
}

float ScrollView::getScrollBarWidth() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        return _verticalScrollBar->getWidth();
    }
    else if (_horizontalScrollBar != nullptr)
    {
        return _horizontalScrollBar->getWidth();
    }
    return 0;
}

void ScrollView::setScrollBarColor(const Color3B& color)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->setColor(color);
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->setColor(color);
    }
}

const Color3B& ScrollView::getScrollBarColor() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        return _verticalScrollBar->getColor();
    }
    else if (_horizontalScrollBar != nullptr)
    {
        return _horizontalScrollBar->getColor();
    }
    return Color3B::WHITE;
}

void ScrollView::setScrollBarOpacity(uint8_t opacity)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->setOpacity(opacity);
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->setOpacity(opacity);
    }
}

uint8_t ScrollView::getScrollBarOpacity() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        return _verticalScrollBar->getOpacity();
    }
    else if (_horizontalScrollBar != nullptr)
    {
        return _horizontalScrollBar->getOpacity();
    }
    return -1;
}

void ScrollView::setScrollBarAutoHideEnabled(bool autoHideEnabled)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->setAutoHideEnabled(autoHideEnabled);
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->setAutoHideEnabled(autoHideEnabled);
    }
}

bool ScrollView::isScrollBarAutoHideEnabled() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        return _verticalScrollBar->isAutoHideEnabled();
    }
    else if (_horizontalScrollBar != nullptr)
    {
        return _horizontalScrollBar->isAutoHideEnabled();
    }
    return false;
}

void ScrollView::setScrollBarAutoHideTime(float autoHideTime)
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        _verticalScrollBar->setAutoHideTime(autoHideTime);
    }
    if (_horizontalScrollBar != nullptr)
    {
        _horizontalScrollBar->setAutoHideTime(autoHideTime);
    }
}

float ScrollView::getScrollBarAutoHideTime() const
{
    AXASSERT(_scrollBarEnabled, "Scroll bar should be enabled!");
    if (_verticalScrollBar != nullptr)
    {
        return _verticalScrollBar->getAutoHideTime();
    }
    else if (_horizontalScrollBar != nullptr)
    {
        return _horizontalScrollBar->getAutoHideTime();
    }
    return 0;
}

void ScrollView::setTouchTotalTimeThreshold(float touchTotalTimeThreshold)
{
    _touchTotalTimeThreshold = touchTotalTimeThreshold;
}

float ScrollView::getTouchTotalTimeThreshold() const
{
    return _touchTotalTimeThreshold;
}

Layout* ScrollView::getInnerContainer() const
{
    return _innerContainer;
}

void ScrollView::setLayoutType(Type type)
{
    _innerContainer->setLayoutType(type);
}

Layout::Type ScrollView::getLayoutType() const
{
    return _innerContainer->getLayoutType();
}

void ScrollView::doLayout()
{
    if (!_doLayoutDirty)
    {
        return;
    }
    _doLayoutDirty = false;
}

std::string ScrollView::getDescription() const
{
    return "ScrollView";
}

Widget* ScrollView::createCloneInstance()
{
    return ScrollView::create();
}

void ScrollView::copyClonedWidgetChildren(Widget* model)
{
    Layout::copyClonedWidgetChildren(model);
}

void ScrollView::copySpecialProperties(Widget* widget)
{
    ScrollView* scrollView = dynamic_cast<ScrollView*>(widget);
    if (scrollView)
    {
        Layout::copySpecialProperties(widget);
        setDirection(scrollView->_direction);
        setInnerContainerPosition(scrollView->getInnerContainerPosition());
        setInnerContainerSize(scrollView->getInnerContainerSize());
        _topBoundary                      = scrollView->_topBoundary;
        _bottomBoundary                   = scrollView->_bottomBoundary;
        _leftBoundary                     = scrollView->_leftBoundary;
        _rightBoundary                    = scrollView->_rightBoundary;
        _bePressed                        = scrollView->_bePressed;
        _childFocusCancelOffsetInInch     = scrollView->_childFocusCancelOffsetInInch;
        _touchMoveDisplacements           = scrollView->_touchMoveDisplacements;
        _touchMoveTimeDeltas              = scrollView->_touchMoveTimeDeltas;
        _touchMovePreviousTimestamp       = scrollView->_touchMovePreviousTimestamp;
        _scrolling                        = scrollView->_scrolling;
        _autoScrolling                    = scrollView->_autoScrolling;
        _autoScrollAttenuate              = scrollView->_autoScrollAttenuate;
        _autoScrollStartPosition          = scrollView->_autoScrollStartPosition;
        _autoScrollTargetDelta            = scrollView->_autoScrollTargetDelta;
        _autoScrollTotalTime              = scrollView->_autoScrollTotalTime;
        _autoScrollAccumulatedTime        = scrollView->_autoScrollAccumulatedTime;
        _autoScrollCurrentlyOutOfBoundary = scrollView->_autoScrollCurrentlyOutOfBoundary;
        _autoScrollBraking                = scrollView->_autoScrollBraking;
        _autoScrollBrakingStartPosition   = scrollView->_autoScrollBrakingStartPosition;
        setInertiaScrollEnabled(scrollView->_inertiaScrollEnabled);
        setBounceEnabled(scrollView->_bounceEnabled);
        _scrollViewEventListener = scrollView->_scrollViewEventListener;
        _eventCallback           = scrollView->_eventCallback;
        _ccEventCallback         = scrollView->_ccEventCallback;

        setScrollBarEnabled(scrollView->isScrollBarEnabled());
        if (isScrollBarEnabled())
        {
            if (_direction != Direction::HORIZONTAL)
            {
                setScrollBarPositionFromCornerForVertical(scrollView->getScrollBarPositionFromCornerForVertical());
            }
            if (_direction != Direction::VERTICAL)
            {
                setScrollBarPositionFromCornerForHorizontal(scrollView->getScrollBarPositionFromCornerForHorizontal());
            }
            setScrollBarWidth(scrollView->getScrollBarWidth());
            setScrollBarColor(scrollView->getScrollBarColor());
            setScrollBarAutoHideEnabled(scrollView->isScrollBarAutoHideEnabled());
            setScrollBarAutoHideTime(scrollView->getScrollBarAutoHideTime());
        }
    }
}

void ScrollView::initScrollBar()
{
    if (_direction != Direction::HORIZONTAL && _verticalScrollBar == nullptr)
    {
        _verticalScrollBar = ScrollViewBar::create(this, Direction::VERTICAL);
        addProtectedChild(_verticalScrollBar, 2);
    }
    if (_direction != Direction::VERTICAL && _horizontalScrollBar == nullptr)
    {
        _horizontalScrollBar = ScrollViewBar::create(this, Direction::HORIZONTAL);
        addProtectedChild(_horizontalScrollBar, 2);
    }
}

void ScrollView::removeScrollBar()
{
    if (_verticalScrollBar != nullptr)
    {
        removeProtectedChild(_verticalScrollBar);
        _verticalScrollBar = nullptr;
    }
    if (_horizontalScrollBar != nullptr)
    {
        removeProtectedChild(_horizontalScrollBar);
        _horizontalScrollBar = nullptr;
    }
}

Widget* ScrollView::findNextFocusedWidget(ax::ui::Widget::FocusDirection direction, ax::ui::Widget* current)
{
    if (this->getLayoutType() == Layout::Type::VERTICAL || this->getLayoutType() == Layout::Type::HORIZONTAL)
    {
        return _innerContainer->findNextFocusedWidget(direction, current);
    }
    else
    {
        return Widget::findNextFocusedWidget(direction, current);
    }
}

void ScrollView::setScrollDuration(float time)
{
    if (time >= 0)
        _scrollTime = time;
}

float ScrollView::getScrollDuration() const
{
    return _scrollTime;
}

Vec2 ScrollView::calculateItemPositionWithAnchor(const Node* node, const Vec2& itemAnchorPoint)
{
    auto boundingBox = node->getBoundingBox();
    Vec2 origin(boundingBox.origin.x, boundingBox.origin.y);
    Vec2 size = node->getContentSize();
    return origin + Vec2(size.width * itemAnchorPoint.x, size.height * itemAnchorPoint.y);
}

Vec2 ScrollView::calculateItemDestination(const Vec2& positionRatioInView, const Node* item, const Vec2& itemAnchorPoint)
{
    const Vec2& contentSize = getContentSize();
    Vec2 positionInView;
    positionInView.x += contentSize.width * positionRatioInView.x;
    positionInView.y += contentSize.height * positionRatioInView.y;

    Vec2 itemPosition = calculateItemPositionWithAnchor(item, itemAnchorPoint);
    return -(itemPosition - positionInView);
}

void ScrollView::scrollToItem(Node* item, const Vec2& positionRatioInView, const Vec2& itemAnchorPoint)
{
    scrollToItem(item, positionRatioInView, itemAnchorPoint, _scrollTime);
}

void ScrollView::scrollToItem(Node* item, const Vec2& positionRatioInView, const Vec2& itemAnchorPoint, float timeInSec)
{
    if (item == nullptr)
    {
        return;
    }
    auto destination = calculateItemDestination(positionRatioInView, item, itemAnchorPoint);
    startAutoScrollToDestination(destination, timeInSec, true);
}
}  // namespace ui

NS_AX_END