Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #13723 from neokim/add_scroll_to_item_and_magnetic_scroll_into_listview 

Add scrolling to item and magnetic scroll into ListView
This commit is contained in:
子龙山人 2015-09-11 17:48:40 +08:00
parent 04d3119871 f39644d129
commit 96d6221daf
6 changed files with 1063 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

327
cocos/ui/UIListView.cpp
View File

@ -27,6 +27,8 @@ THE SOFTWARE.
NS_CC_BEGIN NS_CC_BEGIN
static const float DEFAULT_TIME_IN_SEC_FOR_SCROLL_TO_ITEM = 1.0f;
namespace ui { namespace ui {
IMPLEMENT_CLASS_GUI_INFO(ListView) IMPLEMENT_CLASS_GUI_INFO(ListView)
@ -34,6 +36,8 @@ IMPLEMENT_CLASS_GUI_INFO(ListView)
ListView::ListView(): ListView::ListView():
_model(nullptr), _model(nullptr),
_gravity(Gravity::CENTER_VERTICAL), _gravity(Gravity::CENTER_VERTICAL),
_magneticType(MagneticType::NONE),
_magneticAllowedOutOfBoundary(true),
_itemsMargin(0.0f), _itemsMargin(0.0f),
_curSelectedIndex(-1), _curSelectedIndex(-1),
_refreshViewDirty(true), _refreshViewDirty(true),
@ -86,6 +90,16 @@ void ListView::setItemModel(Widget *model)
CC_SAFE_RETAIN(_model); CC_SAFE_RETAIN(_model);
} }
void ListView::handleReleaseLogic(Touch *touch)
{
ScrollView::handleReleaseLogic(touch);
if(!_autoScrolling)
{
startMagneticScroll();
}
}
void ListView::updateInnerContainerSize() void ListView::updateInnerContainerSize()
{ {
switch (_direction) switch (_direction)
@ -249,6 +263,7 @@ void ListView::addChild(cocos2d::Node *child, int zOrder, int tag)
if (nullptr != widget) if (nullptr != widget)
{ {
_items.pushBack(widget); _items.pushBack(widget);
_outOfBoundaryAmountDirty = true;
} }
} }
@ -270,6 +285,7 @@ void ListView::addChild(Node* child, int zOrder, const std::string &name)
if (nullptr != widget) if (nullptr != widget)
{ {
_items.pushBack(widget); _items.pushBack(widget);
_outOfBoundaryAmountDirty = true;
} }
} }
@ -291,6 +307,7 @@ void ListView::removeChild(cocos2d::Node *child, bool cleaup)
} }
} }
_items.eraseObject(widget); _items.eraseObject(widget);
_outOfBoundaryAmountDirty = true;
} }
ScrollView::removeChild(child, cleaup); ScrollView::removeChild(child, cleaup);
@ -306,6 +323,7 @@ void ListView::removeAllChildrenWithCleanup(bool cleanup)
ScrollView::removeAllChildrenWithCleanup(cleanup); ScrollView::removeAllChildrenWithCleanup(cleanup);
_items.clear(); _items.clear();
_curSelectedIndex = -1; _curSelectedIndex = -1;
_outOfBoundaryAmountDirty = true;
} }
void ListView::insertCustomItem(Widget* item, ssize_t index) void ListView::insertCustomItem(Widget* item, ssize_t index)
@ -318,6 +336,8 @@ void ListView::insertCustomItem(Widget* item, ssize_t index)
} }
} }
_items.insert(index, item); _items.insert(index, item);
_outOfBoundaryAmountDirty = true;
ScrollView::addChild(item); ScrollView::addChild(item);
remedyLayoutParameter(item); remedyLayoutParameter(item);
@ -379,6 +399,28 @@ void ListView::setGravity(Gravity gravity)
_refreshViewDirty = true; _refreshViewDirty = true;
} }
void ListView::setMagneticType(MagneticType magneticType)
{
_magneticType = magneticType;
_outOfBoundaryAmountDirty = true;
startMagneticScroll();
}
ListView::MagneticType ListView::getMagneticType() const
{
return _magneticType;
}
void ListView::setMagneticAllowedOutOfBoundary(bool magneticAllowedOutOfBoundary)
{
_magneticAllowedOutOfBoundary = magneticAllowedOutOfBoundary;
}
bool ListView::getMagneticAllowedOutOfBoundary() const
{
return _magneticAllowedOutOfBoundary;
}
void ListView::setItemsMargin(float margin) void ListView::setItemsMargin(float margin)
{ {
if (_itemsMargin == margin) if (_itemsMargin == margin)
@ -529,6 +571,142 @@ void ListView::interceptTouchEvent(TouchEventType event, Widget *sender, Touch*
} }
} }
static Vec2 calculateItemPositionWithAnchor(Widget* item, const Vec2& itemAnchorPoint)
{
Vec2 origin(item->getLeftBoundary(), item->getBottomBoundary());
Size size = item->getContentSize();
return origin + Vec2(size.width * itemAnchorPoint.x, size.height * itemAnchorPoint.y);
}
static Widget* findClosestItem(const Vec2& targetPosition, const Vector<Widget*>& items, const Vec2& itemAnchorPoint, ssize_t firstIndex, float distanceFromFirst, ssize_t lastIndex, float distanceFromLast)
{
CCASSERT(firstIndex >= 0 && lastIndex < items.size() && firstIndex <= lastIndex, "");
if (firstIndex == lastIndex)
{
return items.at(firstIndex);
}
if (lastIndex - firstIndex == 1)
{
if (distanceFromFirst <= distanceFromLast)
{
return items.at(firstIndex);
}
else
{
return items.at(lastIndex);
}
}
// Binary search
ssize_t midIndex = (firstIndex + lastIndex) / 2;
Vec2 itemPosition = calculateItemPositionWithAnchor(items.at(midIndex), itemAnchorPoint);
float distanceFromMid = (targetPosition - itemPosition).length();
if (distanceFromFirst <= distanceFromLast)
{
// Left half
return findClosestItem(targetPosition, items, itemAnchorPoint, firstIndex, distanceFromFirst, midIndex, distanceFromMid);
}
else
{
// Right half
return findClosestItem(targetPosition, items, itemAnchorPoint, midIndex, distanceFromMid, lastIndex, distanceFromLast);
}
}
Widget* ListView::getClosestItemToPosition(const Vec2& targetPosition, const Vec2& itemAnchorPoint) const
{
if (_items.empty())
{
return nullptr;
}
// Find the closest item through binary search
ssize_t firstIndex = 0;
Vec2 firstPosition = calculateItemPositionWithAnchor(_items.at(firstIndex), itemAnchorPoint);
float distanceFromFirst = (targetPosition - firstPosition).length();
ssize_t lastIndex = _items.size() - 1;
Vec2 lastPosition = calculateItemPositionWithAnchor(_items.at(lastIndex), itemAnchorPoint);
float distanceFromLast = (targetPosition - lastPosition).length();
return findClosestItem(targetPosition, _items, itemAnchorPoint, firstIndex, distanceFromFirst, lastIndex, distanceFromLast);
}
Widget* ListView::getClosestItemToPositionInCurrentView(const Vec2& positionRatioInView, const Vec2& itemAnchorPoint) const
{
// Calculate the target position
Size contentSize = getContentSize();
Vec2 targetPosition = -_innerContainer->getPosition();
targetPosition.x += contentSize.width * positionRatioInView.x;
targetPosition.y += contentSize.height * positionRatioInView.y;
return getClosestItemToPosition(targetPosition, itemAnchorPoint);
}
Widget* ListView::getCenterItemInCurrentView() const
{
return getClosestItemToPositionInCurrentView(Vec2::ANCHOR_MIDDLE, Vec2::ANCHOR_MIDDLE);
}
Widget* ListView::getLeftmostItemInCurrentView() const
{
if (_direction == Direction::HORIZONTAL)
{
return getClosestItemToPositionInCurrentView(Vec2::ANCHOR_MIDDLE_LEFT, Vec2::ANCHOR_MIDDLE);
}
return nullptr;
}
Widget* ListView::getRightmostItemInCurrentView() const
{
if (_direction == Direction::HORIZONTAL)
{
return getClosestItemToPositionInCurrentView(Vec2::ANCHOR_MIDDLE_RIGHT, Vec2::ANCHOR_MIDDLE);
}
return nullptr;
}
Widget* ListView::getTopmostItemInCurrentView() const
{
if (_direction == Direction::VERTICAL)
{
return getClosestItemToPositionInCurrentView(Vec2::ANCHOR_MIDDLE_TOP, Vec2::ANCHOR_MIDDLE);
}
return nullptr;
}
Widget* ListView::getBottommostItemInCurrentView() const
{
if (_direction == Direction::VERTICAL)
{
return getClosestItemToPositionInCurrentView(Vec2::ANCHOR_MIDDLE_BOTTOM, Vec2::ANCHOR_MIDDLE);
}
return nullptr;
}
void ListView::scrollToItem(int itemIndex, const Vec2& positionRatioInView, const Vec2& itemAnchorPoint)
{
scrollToItem(itemIndex, positionRatioInView, itemAnchorPoint, DEFAULT_TIME_IN_SEC_FOR_SCROLL_TO_ITEM);
}
void ListView::scrollToItem(int itemIndex, const Vec2& positionRatioInView, const Vec2& itemAnchorPoint, float timeInSec)
{
Widget* item = getItem(itemIndex);
if (item == nullptr)
{
return;
}
Size contentSize = getContentSize();
Vec2 positionInView;
positionInView.x += contentSize.width * positionRatioInView.x;
positionInView.y += contentSize.height * positionRatioInView.y;
Vec2 itemPosition = calculateItemPositionWithAnchor(item, itemAnchorPoint);
Vec2 destination = -(itemPosition - positionInView);
startAutoScrollToDestination(destination, timeInSec, true);
}
ssize_t ListView::getCurSelectedIndex() const ssize_t ListView::getCurSelectedIndex() const
{ {
return _curSelectedIndex; return _curSelectedIndex;
@ -574,5 +752,154 @@ void ListView::copySpecialProperties(Widget *widget)
} }
} }
Vec2 ListView::getHowMuchOutOfBoundary(const Vec2& addition)
{
if(!_magneticAllowedOutOfBoundary || _items.empty())
{
return ScrollView::getHowMuchOutOfBoundary(addition);
}
else if(_magneticType == MagneticType::NONE || _magneticType == MagneticType::BOTH_END)
{
return ScrollView::getHowMuchOutOfBoundary(addition);
}
else if(addition == Vec2::ZERO && !_outOfBoundaryAmountDirty)
{
return _outOfBoundaryAmount;
}
// If it is allowed to be out of boundary by magnetic, adjust the boundaries according to the magnetic type.
float leftBoundary = _leftBoundary;
float rightBoundary = _rightBoundary;
float topBoundary = _topBoundary;
float bottomBoundary = _bottomBoundary;
{
int lastItemIndex = _items.size() - 1;
Size contentSize = getContentSize();
Vec2 firstItemAdjustment, lastItemAdjustment;
if(_magneticType == MagneticType::CENTER)
{
firstItemAdjustment = (contentSize - _items.at(0)->getContentSize()) / 2;
lastItemAdjustment = (contentSize - _items.at(lastItemIndex)->getContentSize()) / 2;
}
else if(_magneticType == MagneticType::LEFT)
{
lastItemAdjustment = contentSize - _items.at(lastItemIndex)->getContentSize();
}
else if(_magneticType == MagneticType::RIGHT)
{
firstItemAdjustment = contentSize - _items.at(0)->getContentSize();
}
else if(_magneticType == MagneticType::TOP)
{
lastItemAdjustment = contentSize - _items.at(lastItemIndex)->getContentSize();
}
else if(_magneticType == MagneticType::BOTTOM)
{
firstItemAdjustment = contentSize - _items.at(0)->getContentSize();
}
leftBoundary += firstItemAdjustment.x;
rightBoundary -= lastItemAdjustment.x;
topBoundary -= firstItemAdjustment.y;
bottomBoundary += lastItemAdjustment.y;
}
// Calculate the actual amount
Vec2 outOfBoundaryAmount;
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;
}
static Vec2 getAnchorPointByMagneticType(ListView::MagneticType magneticType)
{
switch(magneticType)
{
case ListView::MagneticType::NONE: return Vec2::ZERO;
case ListView::MagneticType::BOTH_END: return Vec2::ANCHOR_TOP_LEFT;
case ListView::MagneticType::CENTER: return Vec2::ANCHOR_MIDDLE;
case ListView::MagneticType::LEFT: return Vec2::ANCHOR_MIDDLE_LEFT;
case ListView::MagneticType::RIGHT: return Vec2::ANCHOR_MIDDLE_RIGHT;
case ListView::MagneticType::TOP: return Vec2::ANCHOR_MIDDLE_TOP;
case ListView::MagneticType::BOTTOM: return Vec2::ANCHOR_MIDDLE_BOTTOM;
}
return Vec2::ZERO;
}
void ListView::startAttenuatingAutoScroll(const Vec2& deltaMove, const Vec2& initialVelocity)
{
Vec2 adjustedDeltaMove = deltaMove;
if(!_items.empty() && _magneticType != MagneticType::NONE)
{
adjustedDeltaMove = flattenVectorByDirection(adjustedDeltaMove);
// If the destination is out of boundary, do nothing here. Because it will be handled by bouncing back.
if(getHowMuchOutOfBoundary(adjustedDeltaMove) == Vec2::ZERO)
{
MagneticType magType = _magneticType;
if(magType == MagneticType::BOTH_END)
{
if(_direction == Direction::HORIZONTAL)
{
magType = (adjustedDeltaMove.x > 0 ? MagneticType::LEFT : MagneticType::RIGHT);
}
else if(_direction == Direction::VERTICAL)
{
magType = (adjustedDeltaMove.y > 0 ? MagneticType::BOTTOM : MagneticType::TOP);
}
}
// Adjust the delta move amount according to the magnetic type
Vec2 magneticAnchorPoint = getAnchorPointByMagneticType(magType);
Vec2 magneticPosition = -_innerContainer->getPosition();
magneticPosition.x += getContentSize().width * magneticAnchorPoint.x;
magneticPosition.y += getContentSize().height * magneticAnchorPoint.y;
Widget* pTargetItem = getClosestItemToPosition(magneticPosition - adjustedDeltaMove, magneticAnchorPoint);
Vec2 itemPosition = calculateItemPositionWithAnchor(pTargetItem, magneticAnchorPoint);
adjustedDeltaMove = magneticPosition - itemPosition;
}
}
ScrollView::startAttenuatingAutoScroll(adjustedDeltaMove, initialVelocity);
}
void ListView::startMagneticScroll()
{
if(_items.empty() || _magneticType == MagneticType::NONE)
{
return;
}
// Find the closest item
Vec2 magneticAnchorPoint = getAnchorPointByMagneticType(_magneticType);
Vec2 magneticPosition = -_innerContainer->getPosition();
magneticPosition.x += getContentSize().width * magneticAnchorPoint.x;
magneticPosition.y += getContentSize().height * magneticAnchorPoint.y;
Widget* pTargetItem = getClosestItemToPosition(magneticPosition, magneticAnchorPoint);
scrollToItem(getIndex(pTargetItem), magneticAnchorPoint, magneticAnchorPoint);
}
} }
NS_CC_END NS_CC_END

106
cocos/ui/UIListView.h
View File

@ -86,6 +86,22 @@ public:
ON_SELECTED_ITEM_END ON_SELECTED_ITEM_END
}; };
/**
* ListView supports magnetic scroll.
* With CENTER type, ListView tries to align its items in center of current view.
* With BOTH_END type, ListView tries to align its items in left or right end if it is horizontal, top or bottom in vertical. The aligning side (left or right, top or bottom) is determined by user's scroll direction.
*/
enum class MagneticType
{
NONE,
CENTER,
BOTH_END,
LEFT,
RIGHT,
TOP,
BOTTOM,
};
/** /**
* ListView item click callback. * ListView item click callback.
*/ */
@ -193,6 +209,27 @@ public:
*/ */
void setGravity(Gravity gravity); void setGravity(Gravity gravity);
/**
* Set magnetic type of ListView.
* @see `MagneticType`
*/
void setMagneticType(MagneticType magneticType);
/**
* Get magnetic type of ListView.
*/
MagneticType getMagneticType() const;
/**
* Set magnetic allowed out of boundary.
*/
void setMagneticAllowedOutOfBoundary(bool magneticAllowedOutOfBoundary);
/**
* Query whether the magnetic out of boundary is allowed.
*/
bool getMagneticAllowedOutOfBoundary() const;
/** /**
* Set the margin between each item in ListView. * Set the margin between each item in ListView.
* *
@ -200,7 +237,6 @@ public:
*/ */
void setItemsMargin(float margin); void setItemsMargin(float margin);
/** /**
* @brief Query margin between each item in ListView. * @brief Query margin between each item in ListView.
* *
@ -220,6 +256,63 @@ public:
virtual void removeAllChildrenWithCleanup(bool cleanup) override; virtual void removeAllChildrenWithCleanup(bool cleanup) override;
virtual void removeChild(Node* child, bool cleaup = true) override; virtual void removeChild(Node* child, bool cleaup = true) override;
/**
* @brief Query the closest item to a specific position in inner container.
*
* @param targetPosition Specifies the target position in inner container's coordinates.
* @param itemAnchorPoint Specifies an anchor point of each item for position to calculate distance.
* @return A item instance if list view is not empty. Otherwise, returns null.
*/
Widget* getClosestItemToPosition(const Vec2& targetPosition, const Vec2& itemAnchorPoint) const;
/**
* @brief Query the closest item to a specific position in current view.
* For instance, to find the item in the center of view, call 'getClosestItemToPositionInCurrentView(Vec2::ANCHOR_MIDDLE, Vec2::ANCHOR_MIDDLE)'.
*
* @param positionRatioInView Specifies the target position with ratio in list view's content size.
* @param itemAnchorPoint Specifies an anchor point of each item for position to calculate distance.
* @return A item instance if list view is not empty. Otherwise, returns null.
*/
Widget* getClosestItemToPositionInCurrentView(const Vec2& positionRatioInView, const Vec2& itemAnchorPoint) const;
/**
* @brief Query the center item
* @return A item instance.
*/
Widget* getCenterItemInCurrentView() const;
/**
* @brief Query the leftmost item in horizontal list
* @return A item instance.
*/
Widget* getLeftmostItemInCurrentView() const;
/**
* @brief Query the rightmost item in horizontal list
* @return A item instance.
*/
Widget* getRightmostItemInCurrentView() const;
/**
* @brief Query the topmost item in horizontal list
* @return A item instance.
*/
Widget* getTopmostItemInCurrentView() const;
/**
* @brief Query the bottommost item in horizontal list
* @return A item instance.
*/
Widget* getBottommostItemInCurrentView() const;
/**
* @brief Scroll to specific item
* @param positionRatioInView Specifies the position with ratio in list view's content size.
* @param itemAnchorPoint Specifies an anchor point of each item for position to calculate distance.
* @param timeInSec Scroll time
*/
void scrollToItem(int itemIndex, const Vec2& positionRatioInView, const Vec2& itemAnchorPoint);
void scrollToItem(int itemIndex, const Vec2& positionRatioInView, const Vec2& itemAnchorPoint, float timeInSec);
/** /**
* @brief Query current selected widget's idnex. * @brief Query current selected widget's idnex.
@ -270,6 +363,7 @@ CC_CONSTRUCTOR_ACCESS:
virtual bool init() override; virtual bool init() override;
protected: protected:
virtual void handleReleaseLogic(Touch *touch) override;
void updateInnerContainerSize(); void updateInnerContainerSize();
void remedyLayoutParameter(Widget* item); void remedyLayoutParameter(Widget* item);
@ -282,6 +376,13 @@ protected:
virtual void copyClonedWidgetChildren(Widget* model) override; virtual void copyClonedWidgetChildren(Widget* model) override;
void selectedItemEvent(TouchEventType event); void selectedItemEvent(TouchEventType event);
virtual void interceptTouchEvent(Widget::TouchEventType event,Widget* sender,Touch* touch) override; virtual void interceptTouchEvent(Widget::TouchEventType event,Widget* sender,Touch* touch) override;
virtual Vec2 getHowMuchOutOfBoundary(const Vec2& addition = Vec2::ZERO) override;
virtual void startAttenuatingAutoScroll(const Vec2& deltaMove, const Vec2& initialVelocity) override;
void startMagneticScroll();
protected: protected:
Widget* _model; Widget* _model;
@ -289,6 +390,9 @@ protected:
Gravity _gravity; Gravity _gravity;
MagneticType _magneticType;
bool _magneticAllowedOutOfBoundary;
float _itemsMargin; float _itemsMargin;
ssize_t _curSelectedIndex; ssize_t _curSelectedIndex;

426
cocos/ui/UIScrollView.cpp
View File

@ -31,8 +31,8 @@ THE SOFTWARE.
#include "2d/CCCamera.h" #include "2d/CCCamera.h"
NS_CC_BEGIN NS_CC_BEGIN
static const float OUT_OF_BOUND_TIME_RESCALE = 0.05f; static const int NUMBER_OF_GATHERED_TOUCHES_FOR_MOVE_SPEED = 5;
static const float OUT_OF_BOUND_DISTANCE_RESCALE = 0.05f; static const float OUT_OF_BOUNDARY_BREAKING_FACTOR = 0.05f;
static const float BOUNCE_BACK_DURATION = 1.0f; static const float BOUNCE_BACK_DURATION = 1.0f;
#define MOVE_INCH 7.0f/160.0f #define MOVE_INCH 7.0f/160.0f
@ -61,14 +61,13 @@ _childFocusCancelOffsetInInch(MOVE_INCH),
_touchMovePreviousTimestamp(0), _touchMovePreviousTimestamp(0),
_autoScrolling(false), _autoScrolling(false),
_autoScrollAttenuate(true), _autoScrollAttenuate(true),
_autoScrollDuration(0), _autoScrollTotalTime(0),
_autoScrollAccumulatedTime(0), _autoScrollAccumulatedTime(0),
_autoScrollCompleteCallback(nullptr), _autoScrollCurrentlyOutOfBoundary(false),
_autoScrollMoveCallback(nullptr), _autoScrollBraking(false),
_outOfBoundaryDuringInertiaScroll(false),
_inertiaScrollEnabled(true), _inertiaScrollEnabled(true),
_inertiaScrolling(false),
_bounceEnabled(false), _bounceEnabled(false),
_outOfBoundaryAmountDirty(true),
_scrollBarEnabled(true), _scrollBarEnabled(true),
_verticalScrollBar(nullptr), _verticalScrollBar(nullptr),
_horizontalScrollBar(nullptr), _horizontalScrollBar(nullptr),
@ -229,6 +228,19 @@ void ScrollView::setInnerContainerPosition(const Vec2 &position)
return; return;
} }
_innerContainer->setPosition(position); _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(); this->retain();
if (_eventCallback) if (_eventCallback)
@ -333,178 +345,222 @@ void ScrollView::updateScrollBar(const Vec2& outOfBoundary)
} }
} }
Vec2 ScrollView::calculateTouchMoveVelocity() const
{
float totalTime = 0;
for(auto &timeDelta : _touchMoveTimeDeltas)
{
totalTime += timeDelta;
}
if(totalTime == 0 || totalTime >= 0.1f)
{
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() bool ScrollView::startBounceBackIfNeeded()
{ {
if (!_bounceEnabled) if (!_bounceEnabled)
{ {
return false; return false;
} }
Vec2 outOfBoundary = getHowMuchOutOfBoundary(Vec2::ZERO); Vec2 bounceBackAmount = getHowMuchOutOfBoundary();
if(outOfBoundary == Vec2::ZERO) if(bounceBackAmount == Vec2::ZERO)
{ {
return false; return false;
} }
startAutoScroll(outOfBoundary, BOUNCE_BACK_DURATION, true, startAutoScroll(bounceBackAmount, BOUNCE_BACK_DURATION, true);
nullptr,
[this](const Vec2& moveDelta) {
if(moveDelta.x > 0)
{
processScrollEvent(MoveDirection::RIGHT, true);
}
else if(moveDelta.x < 0)
{
processScrollEvent(MoveDirection::LEFT, true);
}
if(moveDelta.y > 0)
{
processScrollEvent(MoveDirection::TOP, true);
}
else if(moveDelta.y < 0)
{
processScrollEvent(MoveDirection::BOTTOM, true);
}
}
);
return true; return true;
} }
Vec2 ScrollView::getHowMuchOutOfBoundary(const Vec2& addition) const Vec2 ScrollView::flattenVectorByDirection(const Vec2& vector)
{ {
Vec2 result; 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;
if(_innerContainer->getLeftBoundary() + addition.x > _leftBoundary) if(_innerContainer->getLeftBoundary() + addition.x > _leftBoundary)
{ {
result.x = _leftBoundary - (_innerContainer->getLeftBoundary() + addition.x); outOfBoundaryAmount.x = _leftBoundary - (_innerContainer->getLeftBoundary() + addition.x);
} }
else if(_innerContainer->getRightBoundary() + addition.x < _rightBoundary) else if(_innerContainer->getRightBoundary() + addition.x < _rightBoundary)
{ {
result.x = _rightBoundary - (_innerContainer->getRightBoundary() + addition.x); outOfBoundaryAmount.x = _rightBoundary - (_innerContainer->getRightBoundary() + addition.x);
} }
if(_innerContainer->getTopBoundary() + addition.y < _topBoundary) if(_innerContainer->getTopBoundary() + addition.y < _topBoundary)
{ {
result.y = _topBoundary - (_innerContainer->getTopBoundary() + addition.y); outOfBoundaryAmount.y = _topBoundary - (_innerContainer->getTopBoundary() + addition.y);
} }
else if(_innerContainer->getBottomBoundary() + addition.y > _bottomBoundary) else if(_innerContainer->getBottomBoundary() + addition.y > _bottomBoundary)
{ {
result.y = _bottomBoundary - (_innerContainer->getBottomBoundary() + addition.y); outOfBoundaryAmount.y = _bottomBoundary - (_innerContainer->getBottomBoundary() + addition.y);
} }
return result;
if(addition == Vec2::ZERO)
{
_outOfBoundaryAmount = outOfBoundaryAmount;
_outOfBoundaryAmountDirty = false;
}
return outOfBoundaryAmount;
} }
bool ScrollView::isOutOfBoundary(MoveDirection dir) const bool ScrollView::isOutOfBoundary(MoveDirection dir)
{ {
Vec2 outOfBoundary = getHowMuchOutOfBoundary();
switch(dir) switch(dir)
{ {
case MoveDirection::TOP: return _innerContainer->getTopBoundary() < _topBoundary; case MoveDirection::TOP: return outOfBoundary.y > 0;
case MoveDirection::BOTTOM: return _innerContainer->getBottomBoundary() > _bottomBoundary; case MoveDirection::BOTTOM: return outOfBoundary.y < 0;
case MoveDirection::LEFT: return _innerContainer->getLeftBoundary() > _leftBoundary; case MoveDirection::LEFT: return outOfBoundary.x < 0;
case MoveDirection::RIGHT: return _innerContainer->getRightBoundary() < _rightBoundary; case MoveDirection::RIGHT: return outOfBoundary.x > 0;
} }
return false; return false;
} }
bool ScrollView::isOutOfBoundaryTopOrBottom() const bool ScrollView::isOutOfBoundary()
{ {
return isOutOfBoundary(MoveDirection::TOP) || isOutOfBoundary(MoveDirection::BOTTOM); return getHowMuchOutOfBoundary() != Vec2::ZERO;
} }
bool ScrollView::isOutOfBoundaryLeftOrRight() const void ScrollView::startAutoScrollToDestination(const Vec2& destination, float timeInSec, bool attenuated)
{ {
return isOutOfBoundary(MoveDirection::LEFT) || isOutOfBoundary(MoveDirection::RIGHT); startAutoScroll(destination - _innerContainer->getPosition(), timeInSec, attenuated);
} }
bool ScrollView::isOutOfBoundary() const static float calculateAutoScrollTimeByInitialSpeed(float initialSpeed)
{ {
return isOutOfBoundaryTopOrBottom() || isOutOfBoundaryLeftOrRight(); // Calculate the time from the initial speed according to quintic polynomial.
float time = sqrtf(sqrtf(initialSpeed / 5));
return time;
} }
void ScrollView::startAutoScrollChildrenWithDestination(const Vec2& des, float second, bool attenuated) void ScrollView::startAttenuatingAutoScroll(const Vec2& deltaMove, const Vec2& initialVelocity)
{ {
startAutoScroll(des - _innerContainer->getPosition(), second, attenuated); float time = calculateAutoScrollTimeByInitialSpeed(initialVelocity.length());
startAutoScroll(deltaMove, time, true);
} }
void ScrollView::startAutoScroll(const Vec2& deltaMove, float duration, bool attenuated, std::function<void()> completeCallback, std::function<void(const Vec2&)> moveCallback) void ScrollView::startAutoScroll(const Vec2& deltaMove, float timeInSec, bool attenuated)
{ {
Vec2 adjustedDeltaMove = flattenVectorByDirection(deltaMove);
_autoScrolling = true; _autoScrolling = true;
_autoScrollTargetDelta = deltaMove; _autoScrollTargetDelta = adjustedDeltaMove;
_autoScrollAttenuate = attenuated; _autoScrollAttenuate = attenuated;
_autoScrollStartPosition = _innerContainer->getPosition(); _autoScrollStartPosition = _innerContainer->getPosition();
_autoScrollDuration = duration; _autoScrollTotalTime = timeInSec;
_autoScrollAccumulatedTime = 0; _autoScrollAccumulatedTime = 0;
_autoScrollCompleteCallback = completeCallback; _autoScrollBraking = false;
_autoScrollMoveCallback = moveCallback; _autoScrollBrakingStartPosition = Vec2::ZERO;
_outOfBoundaryDuringInertiaScroll = false;
_outOfBoundaryPositionDuringInertiaScroll = Vec2::ZERO; // If the destination is also out of boundary of same side, start brake from beggining.
Vec2 currentOutOfBoundary = getHowMuchOutOfBoundary();
if(currentOutOfBoundary != Vec2::ZERO)
{
_autoScrollCurrentlyOutOfBoundary = true;
Vec2 afterOutOfBoundary = getHowMuchOutOfBoundary(adjustedDeltaMove);
if(currentOutOfBoundary.x * afterOutOfBoundary.x > 0 || currentOutOfBoundary.y * afterOutOfBoundary.y > 0)
{
_autoScrollBraking = true;
}
}
}
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;
} }
void ScrollView::processAutoScrolling(float deltaTime) void ScrollView::processAutoScrolling(float deltaTime)
{ {
// Shorten the auto scroll distance and time if it is out of boundary during inertia scroll. // Make auto scroll shorter if it needs to deaccelerate.
float timeRescale = 1; float brakingFactor = (isNecessaryAutoScrollBrake() ? OUT_OF_BOUNDARY_BREAKING_FACTOR : 1);
float distanceRescale = 1;
{
bool currentlyOutOfBoundDuringInertiaScroll = (_inertiaScrolling && isOutOfBoundary());
if(!_outOfBoundaryDuringInertiaScroll && currentlyOutOfBoundDuringInertiaScroll)
{
_outOfBoundaryDuringInertiaScroll = true;
_outOfBoundaryPositionDuringInertiaScroll = getInnerContainerPosition();
}
timeRescale = (_outOfBoundaryDuringInertiaScroll ? OUT_OF_BOUND_TIME_RESCALE : 1);
distanceRescale = (_outOfBoundaryDuringInertiaScroll ? OUT_OF_BOUND_DISTANCE_RESCALE : 1);
}
// Calculate the percentage // Elapsed time
float percentage = 0; _autoScrollAccumulatedTime += deltaTime * (1 / brakingFactor);
// Calculate the progress percentage
float percentage = MIN(1, _autoScrollAccumulatedTime / _autoScrollTotalTime);
if(_autoScrollAttenuate)
{ {
_autoScrollAccumulatedTime += deltaTime * (1 / timeRescale); // Use quintic(5th degree) polynomial
percentage = MIN(1, _autoScrollAccumulatedTime / _autoScrollDuration); percentage = tweenfunc::quintEaseOut(percentage);
if(_autoScrollAttenuate)
{
// Use quintic(5th degree) polynomial
percentage = tweenfunc::quintEaseOut(percentage);
}
} }
// Calculate the new position // Calculate the new position
Vec2 deltaFromInitialPosition = _autoScrollTargetDelta * percentage; Vec2 newPosition = _autoScrollStartPosition + (_autoScrollTargetDelta * percentage);
Vec2 newPosition = _autoScrollStartPosition + deltaFromInitialPosition; bool reachedEnd = (percentage == 1);
bool reachedEnd = false;
// Adjust the new position according to the bounce opiton if(_bounceEnabled)
{ {
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(outOfBoundary != Vec2::ZERO)
{ {
newPosition = _outOfBoundaryPositionDuringInertiaScroll + (newPosition - _outOfBoundaryPositionDuringInertiaScroll) * distanceRescale; newPosition += outOfBoundary;
} reachedEnd = true;
else
{
Vec2 moveDelta = newPosition - getInnerContainerPosition();
Vec2 outOfBoundary = getHowMuchOutOfBoundary(moveDelta);
if(outOfBoundary != Vec2::ZERO)
{
newPosition += outOfBoundary;
reachedEnd = true;
}
} }
} }
moveChildrenToPosition(newPosition); moveChildrenToPosition(newPosition);
if(_autoScrollMoveCallback)
{
_autoScrollMoveCallback(getInnerContainerPosition() - newPosition);
}
// Finish auto scroll if it ended // Finish auto scroll if it ended
if(percentage == 1 || reachedEnd) if(reachedEnd)
{ {
_autoScrolling = false; _autoScrolling = false;
if(_autoScrollCompleteCallback) startBounceBackIfNeeded();
{
_autoScrollCompleteCallback();
}
} }
} }
@ -523,45 +579,6 @@ void ScrollView::jumpToDestination(const Vec2 &des)
moveChildrenToPosition(Vec2(finalOffsetX, finalOffsetY)); moveChildrenToPosition(Vec2(finalOffsetX, finalOffsetY));
} }
Vec2 ScrollView::calculateTouchMoveVelocity() const
{
float totalDuration = 0;
for(auto &timeDelta : _touchMoveTimeDeltas)
{
totalDuration += timeDelta;
}
if(totalDuration == 0 || totalDuration >= 0.5f)
{
return Vec2::ZERO;
}
Vec2 totalMovement;
for(auto &displacement : _touchMoveDisplacements)
{
totalMovement += displacement;
}
return totalMovement / totalDuration;
}
void ScrollView::startInertiaScroll(const Vec2& touchMoveVelocity)
{
Vec2 initialVelocity = touchMoveVelocity;
initialVelocity.x = (_direction == Direction::VERTICAL ? 0 : initialVelocity.x);
initialVelocity.y = (_direction == Direction::HORIZONTAL ? 0 : initialVelocity.y);
const float MOVEMENT_FACTOR = 0.7f;
Vec2 inertiaTotalDisplacement = initialVelocity * MOVEMENT_FACTOR;
// Calculate the duration from the initial velocity according to quintic polynomial.
float duration = sqrtf(sqrtf(initialVelocity.length() / 5));
_inertiaScrolling = true;
startAutoScroll(inertiaTotalDisplacement, duration, true, [this]() {
_inertiaScrolling = false;
startBounceBackIfNeeded();
});
}
bool ScrollView::scrollChildren(float touchOffsetX, float touchOffsetY) bool ScrollView::scrollChildren(float touchOffsetX, float touchOffsetY)
{ {
touchOffsetX = (_direction == Direction::VERTICAL ? 0 : touchOffsetX); touchOffsetX = (_direction == Direction::VERTICAL ? 0 : touchOffsetX);
@ -569,8 +586,9 @@ bool ScrollView::scrollChildren(float touchOffsetX, float touchOffsetY)
if(_bounceEnabled) if(_bounceEnabled)
{ {
// If the position of the inner container is out of the boundary, the offsets should be divided by two. // If the position of the inner container is out of the boundary, the offsets should be divided by two.
touchOffsetX *= (isOutOfBoundaryLeftOrRight() ? 0.5f : 1); Vec2 outOfBoundary = getHowMuchOutOfBoundary();
touchOffsetY *= (isOutOfBoundaryTopOrBottom() ? 0.5f : 1); touchOffsetX *= (outOfBoundary.x == 0 ? 1 : 0.5f);
touchOffsetY *= (outOfBoundary.y == 0 ? 1 : 0.5f);
} }
float realOffsetX = touchOffsetX; float realOffsetX = touchOffsetX;
@ -657,83 +675,83 @@ bool ScrollView::scrollChildren(float touchOffsetX, float touchOffsetY)
return scrollEnabledUpDown || scrollEnabledLeftRight; return scrollEnabledUpDown || scrollEnabledLeftRight;
} }
void ScrollView::scrollToBottom(float second, bool attenuated) void ScrollView::scrollToBottom(float timeInSec, bool attenuated)
{ {
startAutoScrollChildrenWithDestination(Vec2(_innerContainer->getPosition().x, 0.0f), second, attenuated); startAutoScrollToDestination(Vec2(_innerContainer->getPosition().x, 0.0f), timeInSec, attenuated);
} }
void ScrollView::scrollToTop(float second, bool attenuated) void ScrollView::scrollToTop(float timeInSec, bool attenuated)
{ {
startAutoScrollChildrenWithDestination(Vec2(_innerContainer->getPosition().x, startAutoScrollToDestination(Vec2(_innerContainer->getPosition().x,
_contentSize.height - _innerContainer->getContentSize().height), second, attenuated); _contentSize.height - _innerContainer->getContentSize().height), timeInSec, attenuated);
} }
void ScrollView::scrollToLeft(float second, bool attenuated) void ScrollView::scrollToLeft(float timeInSec, bool attenuated)
{ {
startAutoScrollChildrenWithDestination(Vec2(0.0f, _innerContainer->getPosition().y), second, attenuated); startAutoScrollToDestination(Vec2(0.0f, _innerContainer->getPosition().y), timeInSec, attenuated);
} }
void ScrollView::scrollToRight(float second, bool attenuated) void ScrollView::scrollToRight(float timeInSec, bool attenuated)
{ {
startAutoScrollChildrenWithDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width, startAutoScrollToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width,
_innerContainer->getPosition().y), second, attenuated); _innerContainer->getPosition().y), timeInSec, attenuated);
} }
void ScrollView::scrollToTopLeft(float second, bool attenuated) void ScrollView::scrollToTopLeft(float timeInSec, bool attenuated)
{ {
if (_direction != Direction::BOTH) if (_direction != Direction::BOTH)
{ {
CCLOG("Scroll direction is not both!"); CCLOG("Scroll direction is not both!");
return; return;
} }
startAutoScrollChildrenWithDestination(Vec2(0.0f, _contentSize.height - _innerContainer->getContentSize().height), second, attenuated); startAutoScrollToDestination(Vec2(0.0f, _contentSize.height - _innerContainer->getContentSize().height), timeInSec, attenuated);
} }
void ScrollView::scrollToTopRight(float second, bool attenuated) void ScrollView::scrollToTopRight(float timeInSec, bool attenuated)
{ {
if (_direction != Direction::BOTH) if (_direction != Direction::BOTH)
{ {
CCLOG("Scroll direction is not both!"); CCLOG("Scroll direction is not both!");
return; return;
} }
startAutoScrollChildrenWithDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width, startAutoScrollToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width,
_contentSize.height - _innerContainer->getContentSize().height), second, attenuated); _contentSize.height - _innerContainer->getContentSize().height), timeInSec, attenuated);
} }
void ScrollView::scrollToBottomLeft(float second, bool attenuated) void ScrollView::scrollToBottomLeft(float timeInSec, bool attenuated)
{ {
if (_direction != Direction::BOTH) if (_direction != Direction::BOTH)
{ {
CCLOG("Scroll direction is not both!"); CCLOG("Scroll direction is not both!");
return; return;
} }
startAutoScrollChildrenWithDestination(Vec2::ZERO, second, attenuated); startAutoScrollToDestination(Vec2::ZERO, timeInSec, attenuated);
} }
void ScrollView::scrollToBottomRight(float second, bool attenuated) void ScrollView::scrollToBottomRight(float timeInSec, bool attenuated)
{ {
if (_direction != Direction::BOTH) if (_direction != Direction::BOTH)
{ {
CCLOG("Scroll direction is not both!"); CCLOG("Scroll direction is not both!");
return; return;
} }
startAutoScrollChildrenWithDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width, 0.0f), second, attenuated); startAutoScrollToDestination(Vec2(_contentSize.width - _innerContainer->getContentSize().width, 0.0f), timeInSec, attenuated);
} }
void ScrollView::scrollToPercentVertical(float percent, float second, bool attenuated) void ScrollView::scrollToPercentVertical(float percent, float timeInSec, bool attenuated)
{ {
float minY = _contentSize.height - _innerContainer->getContentSize().height; float minY = _contentSize.height - _innerContainer->getContentSize().height;
float h = - minY; float h = - minY;
startAutoScrollChildrenWithDestination(Vec2(_innerContainer->getPosition().x, minY + percent * h / 100.0f), second, attenuated); startAutoScrollToDestination(Vec2(_innerContainer->getPosition().x, minY + percent * h / 100.0f), timeInSec, attenuated);
} }
void ScrollView::scrollToPercentHorizontal(float percent, float second, bool attenuated) void ScrollView::scrollToPercentHorizontal(float percent, float timeInSec, bool attenuated)
{ {
float w = _innerContainer->getContentSize().width - _contentSize.width; float w = _innerContainer->getContentSize().width - _contentSize.width;
startAutoScrollChildrenWithDestination(Vec2(-(percent * w / 100.0f), _innerContainer->getPosition().y), second, attenuated); startAutoScrollToDestination(Vec2(-(percent * w / 100.0f), _innerContainer->getPosition().y), timeInSec, attenuated);
} }
void ScrollView::scrollToPercentBothDirection(const Vec2& percent, float second, bool attenuated) void ScrollView::scrollToPercentBothDirection(const Vec2& percent, float timeInSec, bool attenuated)
{ {
if (_direction != Direction::BOTH) if (_direction != Direction::BOTH)
{ {
@ -742,7 +760,7 @@ void ScrollView::scrollToPercentBothDirection(const Vec2& percent, float second,
float minY = _contentSize.height - _innerContainer->getContentSize().height; float minY = _contentSize.height - _innerContainer->getContentSize().height;
float h = - minY; float h = - minY;
float w = _innerContainer->getContentSize().width - _contentSize.width; float w = _innerContainer->getContentSize().width - _contentSize.width;
startAutoScrollChildrenWithDestination(Vec2(-(percent.x * w / 100.0f), minY + percent.y * h / 100.0f), second, attenuated); startAutoScrollToDestination(Vec2(-(percent.x * w / 100.0f), minY + percent.y * h / 100.0f), timeInSec, attenuated);
} }
void ScrollView::jumpToBottom() void ScrollView::jumpToBottom()
@ -832,13 +850,37 @@ void ScrollView::jumpToPercentBothDirection(const Vec2& percent)
jumpToDestination(Vec2(-(percent.x * w / 100.0f), minY + percent.y * h / 100.0f)); 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.push_back(delta);
long long timestamp = utils::getTimeInMilliseconds();
_touchMoveTimeDeltas.push_back((timestamp - _touchMovePreviousTimestamp) / 1000.0f);
_touchMovePreviousTimestamp = timestamp;
}
void ScrollView::handlePressLogic(Touch *touch) void ScrollView::handlePressLogic(Touch *touch)
{ {
_bePressed = true; _bePressed = true;
_autoScrolling = false; _autoScrolling = false;
_inertiaScrolling = false;
// Initialize touch move information // Clear gathered touch move information
{ {
_touchMovePreviousTimestamp = utils::getTimeInMilliseconds(); _touchMovePreviousTimestamp = utils::getTimeInMilliseconds();
_touchMoveDisplacements.clear(); _touchMoveDisplacements.clear();
@ -858,9 +900,7 @@ void ScrollView::handlePressLogic(Touch *touch)
void ScrollView::handleMoveLogic(Touch *touch) void ScrollView::handleMoveLogic(Touch *touch)
{ {
Vec3 currPt, prevPt; Vec3 currPt, prevPt;
if (nullptr == _hittedByCamera || if(!calculateCurrAndPrevTouchPoints(touch, &currPt, &prevPt))
false == hitTest(touch->getLocation(), _hittedByCamera, &currPt) ||
false == hitTest(touch->getPreviousLocation(), _hittedByCamera, &prevPt))
{ {
return; return;
} }
@ -869,22 +909,22 @@ void ScrollView::handleMoveLogic(Touch *touch)
scrollChildren(delta.x, delta.y); scrollChildren(delta.x, delta.y);
// Gather touch move information for speed calculation // Gather touch move information for speed calculation
{ gatherTouchMove(delta);
while(_touchMoveDisplacements.size() > 5)
{
_touchMoveDisplacements.pop_front();
_touchMoveTimeDeltas.pop_front();
}
_touchMoveDisplacements.push_back(delta);
long long timestamp = utils::getTimeInMilliseconds();
_touchMoveTimeDeltas.push_back((timestamp - _touchMovePreviousTimestamp) / 1000.0f);
_touchMovePreviousTimestamp = timestamp;
}
} }
void ScrollView::handleReleaseLogic(Touch *touch) void ScrollView::handleReleaseLogic(Touch *touch)
{ {
// 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; _bePressed = false;
bool bounceBackStarted = startBounceBackIfNeeded(); bool bounceBackStarted = startBounceBackIfNeeded();
@ -1377,14 +1417,12 @@ void ScrollView::copySpecialProperties(Widget *widget)
_autoScrollAttenuate = scrollView->_autoScrollAttenuate; _autoScrollAttenuate = scrollView->_autoScrollAttenuate;
_autoScrollStartPosition = scrollView->_autoScrollStartPosition; _autoScrollStartPosition = scrollView->_autoScrollStartPosition;
_autoScrollTargetDelta = scrollView->_autoScrollTargetDelta; _autoScrollTargetDelta = scrollView->_autoScrollTargetDelta;
_autoScrollDuration = scrollView->_autoScrollDuration; _autoScrollTotalTime = scrollView->_autoScrollTotalTime;
_autoScrollAccumulatedTime = scrollView->_autoScrollAccumulatedTime; _autoScrollAccumulatedTime = scrollView->_autoScrollAccumulatedTime;
_outOfBoundaryDuringInertiaScroll = scrollView->_outOfBoundaryDuringInertiaScroll; _autoScrollCurrentlyOutOfBoundary = scrollView->_autoScrollCurrentlyOutOfBoundary;
_outOfBoundaryPositionDuringInertiaScroll = scrollView->_outOfBoundaryPositionDuringInertiaScroll; _autoScrollBraking = scrollView->_autoScrollBraking;
_autoScrollCompleteCallback = scrollView->_autoScrollCompleteCallback; _autoScrollBrakingStartPosition = scrollView->_autoScrollBrakingStartPosition;
_autoScrollMoveCallback = scrollView->_autoScrollMoveCallback;
setInertiaScrollEnabled(scrollView->_inertiaScrollEnabled); setInertiaScrollEnabled(scrollView->_inertiaScrollEnabled);
_inertiaScrolling = scrollView->_inertiaScrolling;
setBounceEnabled(scrollView->_bounceEnabled); setBounceEnabled(scrollView->_bounceEnabled);
_scrollViewEventListener = scrollView->_scrollViewEventListener; _scrollViewEventListener = scrollView->_scrollViewEventListener;
_scrollViewEventSelector = scrollView->_scrollViewEventSelector; _scrollViewEventSelector = scrollView->_scrollViewEventSelector;

81
cocos/ui/UIScrollView.h
View File

@ -156,83 +156,83 @@ public:
/** /**
* Scroll inner container to bottom boundary of scrollview. * Scroll inner container to bottom boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToBottom(float second, bool attenuated); void scrollToBottom(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to top boundary of scrollview. * Scroll inner container to top boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToTop(float second, bool attenuated); void scrollToTop(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to left boundary of scrollview. * Scroll inner container to left boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToLeft(float second, bool attenuated); void scrollToLeft(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to right boundary of scrollview. * Scroll inner container to right boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToRight(float time, bool attenuated); void scrollToRight(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to top and left boundary of scrollview. * Scroll inner container to top and left boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToTopLeft(float second, bool attenuated); void scrollToTopLeft(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to top and right boundary of scrollview. * Scroll inner container to top and right boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToTopRight(float time, bool attenuated); void scrollToTopRight(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to bottom and left boundary of scrollview. * Scroll inner container to bottom and left boundary of scrollview.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToBottomLeft(float second, bool attenuated); void scrollToBottomLeft(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to bottom and right boundary of scrollview. * Scroll inner container to bottom and right boundary of scrollview.
* @param second Time in seconds * @param timeInSec Time in seconds
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToBottomRight(float time, bool attenuated); void scrollToBottomRight(float timeInSec, bool attenuated);
/** /**
* Scroll inner container to vertical percent position of scrollview. * Scroll inner container to vertical percent position of scrollview.
* @param percent A value between 0 and 100. * @param percent A value between 0 and 100.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToPercentVertical(float percent, float second, bool attenuated); void scrollToPercentVertical(float percent, float timeInSec, bool attenuated);
/** /**
* Scroll inner container to horizontal percent position of scrollview. * Scroll inner container to horizontal percent position of scrollview.
* @param percent A value between 0 and 100. * @param percent A value between 0 and 100.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToPercentHorizontal(float percent, float second, bool attenuated); void scrollToPercentHorizontal(float percent, float timeInSec, bool attenuated);
/** /**
* Scroll inner container to both direction percent position of scrollview. * Scroll inner container to both direction percent position of scrollview.
* @param percent A value between 0 and 100. * @param percent A value between 0 and 100.
* @param second Time in seconds. * @param timeInSec Time in seconds.
* @param attenuated Whether scroll speed attenuate or not. * @param attenuated Whether scroll speed attenuate or not.
*/ */
void scrollToPercentBothDirection(const Vec2& percent, float second, bool attenuated); void scrollToPercentBothDirection(const Vec2& percent, float timeInSec, bool attenuated);
/** /**
* Move inner container to bottom boundary of scrollview. * Move inner container to bottom boundary of scrollview.
@ -565,22 +565,27 @@ protected:
virtual void initScrollBar(); virtual void initScrollBar();
virtual void removeScrollBar(); virtual void removeScrollBar();
bool isOutOfBoundary(MoveDirection dir) const; Vec2 flattenVectorByDirection(const Vec2& vector);
bool isOutOfBoundaryTopOrBottom() const;
bool isOutOfBoundaryLeftOrRight() const; virtual Vec2 getHowMuchOutOfBoundary(const Vec2& addition = Vec2::ZERO);
bool isOutOfBoundary() const; bool isOutOfBoundary(MoveDirection dir);
bool isOutOfBoundary();
void moveChildren(float offsetX, float offsetY); void moveChildren(float offsetX, float offsetY);
void moveChildrenToPosition(const Vec2& position); void moveChildrenToPosition(const Vec2& position);
bool calculateCurrAndPrevTouchPoints(Touch* touch, Vec3* currPt, Vec3* prevPt);
void gatherTouchMove(const Vec2& delta);
Vec2 calculateTouchMoveVelocity() const; Vec2 calculateTouchMoveVelocity() const;
void startInertiaScroll(const Vec2& touchMoveVelocity); virtual void startAttenuatingAutoScroll(const Vec2& deltaMove, const Vec2& initialVelocity);
void startAutoScroll(const Vec2& deltaMove, float timeInSec, bool attenuated);
void startAutoScroll(const Vec2& deltaMove, float duration, bool attenuated, std::function<void()> completeCallback = nullptr, std::function<void(const Vec2&)> moveCallback = nullptr); void startAutoScrollToDestination(const Vec2& des, float timeInSec, bool attenuated);
void startAutoScrollChildrenWithDestination(const Vec2& des, float second, bool attenuated); bool isNecessaryAutoScrollBrake();
void processAutoScrolling(float deltaTime); void processAutoScrolling(float deltaTime);
void startInertiaScroll(const Vec2& touchMoveVelocity);
bool startBounceBackIfNeeded(); bool startBounceBackIfNeeded();
void jumpToDestination(const Vec2& des); void jumpToDestination(const Vec2& des);
@ -597,8 +602,6 @@ protected:
void processScrollingEvent(); void processScrollingEvent();
void dispatchEvent(ScrollviewEventType scrollEventType, EventType eventType); void dispatchEvent(ScrollviewEventType scrollEventType, EventType eventType);
Vec2 getHowMuchOutOfBoundary(const Vec2& addition) const;
void updateScrollBar(const Vec2& outOfBoundary); void updateScrollBar(const Vec2& outOfBoundary);
protected: protected:
@ -624,19 +627,19 @@ protected:
bool _autoScrollAttenuate; bool _autoScrollAttenuate;
Vec2 _autoScrollStartPosition; Vec2 _autoScrollStartPosition;
Vec2 _autoScrollTargetDelta; Vec2 _autoScrollTargetDelta;
float _autoScrollDuration; float _autoScrollTotalTime;
float _autoScrollAccumulatedTime; float _autoScrollAccumulatedTime;
bool _outOfBoundaryDuringInertiaScroll; bool _autoScrollCurrentlyOutOfBoundary;
Vec2 _outOfBoundaryPositionDuringInertiaScroll; bool _autoScrollBraking;
std::function<void()> _autoScrollCompleteCallback; Vec2 _autoScrollBrakingStartPosition;
std::function<void(const Vec2& moveDelta)> _autoScrollMoveCallback;
// Inertia scroll
bool _inertiaScrollEnabled; bool _inertiaScrollEnabled;
bool _inertiaScrolling;
bool _bounceEnabled; bool _bounceEnabled;
Vec2 _outOfBoundaryAmount;
bool _outOfBoundaryAmountDirty;
bool _scrollBarEnabled; bool _scrollBarEnabled;
ScrollViewBar* _verticalScrollBar; ScrollViewBar* _verticalScrollBar;
ScrollViewBar* _horizontalScrollBar; ScrollViewBar* _horizontalScrollBar;

282
tests/cpp-tests/Classes/UITest/CocoStudioGUITest/UIListViewTest/UIListViewTest.cpp
View File

@ -7,8 +7,12 @@ const char* font_UIListViewTest = "fonts/Marker Felt.ttf";
UIListViewTests::UIListViewTests() UIListViewTests::UIListViewTests()
{ {
ADD_TEST_CASE(UIListViewTest_Vertical);
ADD_TEST_CASE(UIListViewTest_Horizontal); ADD_TEST_CASE(UIListViewTest_Horizontal);
ADD_TEST_CASE(UIListViewTest_Vertical);
ADD_TEST_CASE(UIListViewTest_ScrollToItemVertical);
ADD_TEST_CASE(UIListViewTest_ScrollToItemHorizontal);
ADD_TEST_CASE(UIListViewTest_MagneticVertical);
ADD_TEST_CASE(UIListViewTest_MagneticHorizontal);
ADD_TEST_CASE(Issue12692); ADD_TEST_CASE(Issue12692);
ADD_TEST_CASE(Issue8316); ADD_TEST_CASE(Issue8316);
} }
@ -67,10 +71,7 @@ bool UIListViewTest_Vertical::init()
listView->setBackGroundImage("cocosui/green_edit.png"); listView->setBackGroundImage("cocosui/green_edit.png");
listView->setBackGroundImageScale9Enabled(true); listView->setBackGroundImageScale9Enabled(true);
listView->setContentSize(Size(240, 130)); listView->setContentSize(Size(240, 130));
listView->setPosition(Vec2((widgetSize.width - backgroundSize.width) / 2.0f + listView->setPosition(Vec2((widgetSize - listView->getContentSize()) / 2.0f));
(backgroundSize.width - listView->getContentSize().width) / 2.0f,
(widgetSize.height - backgroundSize.height) / 2.0f +
(backgroundSize.height - listView->getContentSize().height) / 2.0f));
listView->addEventListener((ui::ListView::ccListViewCallback)CC_CALLBACK_2(UIListViewTest_Vertical::selectedItemEvent, this)); listView->addEventListener((ui::ListView::ccListViewCallback)CC_CALLBACK_2(UIListViewTest_Vertical::selectedItemEvent, this));
listView->addEventListener((ui::ListView::ccScrollViewCallback)CC_CALLBACK_2(UIListViewTest_Vertical::selectedItemEventScrollView,this)); listView->addEventListener((ui::ListView::ccScrollViewCallback)CC_CALLBACK_2(UIListViewTest_Vertical::selectedItemEventScrollView,this));
listView->setScrollBarPositionFromCorner(Vec2(7, 7)); listView->setScrollBarPositionFromCorner(Vec2(7, 7));
@ -84,8 +85,7 @@ bool UIListViewTest_Vertical::init()
Layout* default_item = Layout::create(); Layout* default_item = Layout::create();
default_item->setTouchEnabled(true); default_item->setTouchEnabled(true);
default_item->setContentSize(default_button->getContentSize()); default_item->setContentSize(default_button->getContentSize());
default_button->setPosition(Vec2(default_item->getContentSize().width / 2.0f, default_button->setPosition(Vec2(default_item->getContentSize() / 2.0f));
default_item->getContentSize().height / 2.0f));
default_item->addChild(default_button); default_item->addChild(default_button);
// set model // set model
@ -166,6 +166,40 @@ bool UIListViewTest_Vertical::init()
// set items margin // set items margin
listView->setItemsMargin(2.0f); listView->setItemsMargin(2.0f);
// Show the indexes of items on each boundary.
{
float position = 75;
// Labels
_indexLabels[0] = Text::create(" ", "fonts/Marker Felt.ttf", 12);
_indexLabels[0]->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_indexLabels[0]->setPosition(_uiLayer->getContentSize() / 2 + Size(0, position));
_uiLayer->addChild(_indexLabels[0]);
_indexLabels[1] = Text::create(" ", "fonts/Marker Felt.ttf", 12);
_indexLabels[1]->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_indexLabels[1]->setPosition(_uiLayer->getContentSize() / 2 + Size(140, 0));
_uiLayer->addChild(_indexLabels[1]);
_indexLabels[2] = Text::create(" ", "fonts/Marker Felt.ttf", 12);
_indexLabels[2]->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_indexLabels[2]->setPosition(_uiLayer->getContentSize() / 2 + Size(0, -position));
_uiLayer->addChild(_indexLabels[2]);
// Callback
listView->ScrollView::addEventListener([this](Ref* ref, ScrollView::EventType eventType) {
ListView* listView = dynamic_cast<ListView*>(ref);
if(listView == nullptr || eventType != ScrollView::EventType::CONTAINER_MOVED)
{
return;
}
auto bottom = listView->getBottommostItemInCurrentView();
auto center = listView->getCenterItemInCurrentView();
auto top = listView->getTopmostItemInCurrentView();
_indexLabels[0]->setString(StringUtils::format("Top index=%zd", listView->getIndex(top)));
_indexLabels[1]->setString(StringUtils::format("Center\nindex=%zd", listView->getIndex(center)));
_indexLabels[2]->setString(StringUtils::format("Bottom index=%zd", listView->getIndex(bottom)));
});
}
return true; return true;
} }
@ -545,3 +579,237 @@ bool Issue8316::init()
return false; return false;
} }
// UIListViewTest_ScrollToItem
bool UIListViewTest_ScrollToItem::init()
{
if(!UIScene::init())
{
return false;
}
Size layerSize = _uiLayer->getContentSize();
static int NUMBER_OF_ITEMS = 31;
_nextIndex = 0;
_titleLabel = Text::create("Scroll to item", "fonts/Marker Felt.ttf", 32);
_titleLabel->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_titleLabel->setPosition(Vec2(layerSize / 2) + Vec2(0, _titleLabel->getContentSize().height * 3.15f));
_uiLayer->addChild(_titleLabel, 3);
// Create the list view
_listView = ListView::create();
_listView->setDirection(getListViewDirection());
_listView->setBounceEnabled(true);
_listView->setBackGroundImage("cocosui/green_edit.png");
_listView->setBackGroundImageScale9Enabled(true);
_listView->setContentSize(layerSize / 2);
_listView->setScrollBarPositionFromCorner(Vec2(7, 7));
_listView->setItemsMargin(2.0f);
_listView->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_listView->setPosition(layerSize / 2);
_uiLayer->addChild(_listView);
// Guide line for center align
{
DrawNode* pNode = DrawNode::create();
Vec2 center = layerSize / 2;
if(getListViewDirection() == ScrollView::Direction::HORIZONTAL)
{
float halfY = 110;
pNode->drawLine(Vec2(center.x, center.y - halfY), Vec2(center.x, center.y + halfY), Color4F(0, 0, 0, 1));
}
else
{
float halfX = 150;
pNode->drawLine(Vec2(center.x - halfX, center.y), Vec2(center.x + halfX, center.y), Color4F(0, 0, 0, 1));
}
pNode->setLineWidth(2);
_uiLayer->addChild(pNode);
}
// Button
auto pButton = Button::create("cocosui/backtotoppressed.png", "cocosui/backtotopnormal.png");
pButton->setAnchorPoint(Vec2::ANCHOR_MIDDLE_LEFT);
pButton->setScale(0.8f);
pButton->setPosition(Vec2(layerSize / 2) + Vec2(120, -60));
pButton->setTitleText(StringUtils::format("Go to '%d'", _nextIndex));
pButton->addClickEventListener([this, pButton](Ref*) {
_listView->scrollToItem(_nextIndex, Vec2::ANCHOR_MIDDLE, Vec2::ANCHOR_MIDDLE);
_nextIndex = (_nextIndex + (NUMBER_OF_ITEMS / 2)) % NUMBER_OF_ITEMS;
pButton->setTitleText(StringUtils::format("Go to '%d'", _nextIndex));
});
_uiLayer->addChild(pButton);
// Add list items
static const Size BUTTON_SIZE(50, 40);
for (int i = 0; i < NUMBER_OF_ITEMS; ++i)
{
auto pButton = Button::create("cocosui/button.png", "cocosui/buttonHighlighted.png");
pButton->setContentSize(BUTTON_SIZE);
pButton->setScale9Enabled(true);
pButton->setTitleText(StringUtils::format("Button-%d", i));
_listView->pushBackCustomItem(pButton);
}
return true;
}
// UIListViewTest_Magnetic
bool UIListViewTest_Magnetic::init()
{
if(!UIScene::init())
{
return false;
}
Size layerSize = _uiLayer->getContentSize();
_titleLabel = Text::create("Magnetic scroll", "fonts/Marker Felt.ttf", 32);
_titleLabel->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_titleLabel->setPosition(Vec2(layerSize / 2) + Vec2(0, _titleLabel->getContentSize().height * 3.15f));
_uiLayer->addChild(_titleLabel, 3);
// Create the list view
_listView = ListView::create();
_listView->setDirection(getListViewDirection());
_listView->setBounceEnabled(true);
_listView->setBackGroundImage("cocosui/green_edit.png");
_listView->setBackGroundImageScale9Enabled(true);
_listView->setContentSize(layerSize / 2);
_listView->setScrollBarPositionFromCorner(Vec2(7, 7));
_listView->setItemsMargin(2.0f);
_listView->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_listView->setPosition(layerSize / 2);
_uiLayer->addChild(_listView);
// Guide line for center align
{
DrawNode* pNode = DrawNode::create();
Vec2 center = layerSize / 2;
if(getListViewDirection() == ScrollView::Direction::HORIZONTAL)
{
float halfY = 110;
pNode->drawLine(Vec2(center.x, center.y - halfY), Vec2(center.x, center.y + halfY), Color4F(0, 0, 0, 1));
}
else
{
float halfX = 150;
pNode->drawLine(Vec2(center.x - halfX, center.y), Vec2(center.x + halfX, center.y), Color4F(0, 0, 0, 1));
}
pNode->setLineWidth(2);
_uiLayer->addChild(pNode);
}
// Show the indexes of items on each boundary.
{
for(int i = 0; i < 5; ++i)
{
_indexLabels[i] = Text::create(" ", "fonts/Marker Felt.ttf", 12);
_indexLabels[i]->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
_uiLayer->addChild(_indexLabels[i]);
}
float deltaX = 145, deltaY = 90;
_indexLabels[0]->setPosition(_uiLayer->getContentSize() / 2 + Size(-deltaX, 0)); // left
_indexLabels[1]->setPosition(_uiLayer->getContentSize() / 2 + Size(deltaX, 0)); // right
_indexLabels[2]->setPosition(_uiLayer->getContentSize() / 2 + Size(0, deltaY)); // top
_indexLabels[3]->setPosition(_uiLayer->getContentSize() / 2 + Size(0, -deltaY)); // bottom
_indexLabels[4]->setPosition(_uiLayer->getContentSize() / 2 + Size(deltaX, deltaY)); // center
// Callback
_listView->ScrollView::addEventListener([this](Ref* ref, ScrollView::EventType eventType) {
ListView* listView = dynamic_cast<ListView*>(ref);
if(listView == nullptr || eventType != ScrollView::EventType::CONTAINER_MOVED)
{
return;
}
auto left = listView->getLeftmostItemInCurrentView();
auto right = listView->getRightmostItemInCurrentView();
auto top = listView->getTopmostItemInCurrentView();
auto bottom = listView->getBottommostItemInCurrentView();
auto center = listView->getCenterItemInCurrentView();
_indexLabels[0]->setString(StringUtils::format("Left\nindex=%zd", listView->getIndex(left)));
_indexLabels[1]->setString(StringUtils::format("RIght\nindex=%zd", listView->getIndex(right)));
_indexLabels[2]->setString(StringUtils::format("Top index=%zd", listView->getIndex(top)));
_indexLabels[3]->setString(StringUtils::format("Bottom index=%zd", listView->getIndex(bottom)));
_indexLabels[4]->setString(StringUtils::format("Center\nindex=%zd", listView->getIndex(center)));
});
}
// Initial magnetic type
_listView->setMagneticType(ListView::MagneticType::NONE);
_titleLabel->setString("MagneticType - NONE");
// Magnetic change button
auto pButton = Button::create("cocosui/backtotoppressed.png", "cocosui/backtotopnormal.png");
pButton->setAnchorPoint(Vec2::ANCHOR_MIDDLE_LEFT);
pButton->setScale(0.8f);
pButton->setPosition(Vec2(layerSize / 2) + Vec2(130, -60));
pButton->setTitleText("Next Magnetic");
pButton->addClickEventListener([this](Ref*) {
ListView::MagneticType eCurrentType = _listView->getMagneticType();
ListView::MagneticType eNextType;
std::string sString;
if(eCurrentType == ListView::MagneticType::NONE)
{
eNextType = ListView::MagneticType::CENTER;
sString = "CENTER";
}
else if(eCurrentType == ListView::MagneticType::CENTER)
{
eNextType = ListView::MagneticType::BOTH_END;
sString = "BOTH_END";
}
else if(eCurrentType == ListView::MagneticType::BOTH_END)
{
if(getListViewDirection() == ScrollView::Direction::HORIZONTAL)
{
eNextType = ListView::MagneticType::LEFT;
sString = "LEFT";
}
else
{
eNextType = ListView::MagneticType::TOP;
sString = "TOP";
}
}
else if(eCurrentType == ListView::MagneticType::LEFT)
{
eNextType = ListView::MagneticType::RIGHT;
sString = "RIGHT";
}
else if(eCurrentType == ListView::MagneticType::RIGHT)
{
eNextType = ListView::MagneticType::NONE;
sString = "NONE";
}
else if(eCurrentType == ListView::MagneticType::TOP)
{
eNextType = ListView::MagneticType::BOTTOM;
sString = "BOTTOM";
}
else if(eCurrentType == ListView::MagneticType::BOTTOM)
{
eNextType = ListView::MagneticType::NONE;
sString = "NONE";
}
_listView->setMagneticType(eNextType);
_titleLabel->setString(StringUtils::format("MagneticType - %s", sString.c_str()));
});
_uiLayer->addChild(pButton);
// Add list items
static const Size BUTTON_SIZE(100, 70);
for (int i = 0; i < 40; ++i)
{
auto pButton = Button::create("cocosui/button.png", "cocosui/buttonHighlighted.png");
pButton->setContentSize(BUTTON_SIZE);
pButton->setScale9Enabled(true);
pButton->setTitleText(StringUtils::format("Button-%d", i));
_listView->pushBackCustomItem(pButton);
}
return true;
}

69
tests/cpp-tests/Classes/UITest/CocoStudioGUITest/UIListViewTest/UIListViewTest.h
View File

@ -47,6 +47,8 @@ protected:
cocos2d::ui::Text* _displayValueLabel; cocos2d::ui::Text* _displayValueLabel;
std::vector<std::string> _array; std::vector<std::string> _array;
cocos2d::ui::Text* _indexLabels[3];
}; };
class UIListViewTest_Horizontal : public UIScene class UIListViewTest_Horizontal : public UIScene
@ -84,4 +86,71 @@ public:
virtual bool init() override; virtual bool init() override;
}; };
// Test for scroll to item
class UIListViewTest_ScrollToItem : public UIScene
{
protected:
virtual bool init() override;
virtual cocos2d::ui::ScrollView::Direction getListViewDirection() const = 0;
cocos2d::ui::ListView* _listView;
cocos2d::ui::Text* _titleLabel;
int _nextIndex;
};
class UIListViewTest_ScrollToItemVertical : public UIListViewTest_ScrollToItem
{
public:
CREATE_FUNC(UIListViewTest_ScrollToItemVertical);
virtual cocos2d::ui::ScrollView::Direction getListViewDirection() const
{
return cocos2d::ui::ScrollView::Direction::VERTICAL;
}
};
class UIListViewTest_ScrollToItemHorizontal : public UIListViewTest_ScrollToItem
{
public:
CREATE_FUNC(UIListViewTest_ScrollToItemHorizontal);
virtual cocos2d::ui::ScrollView::Direction getListViewDirection() const
{
return cocos2d::ui::ScrollView::Direction::HORIZONTAL;
}
};
// Test for magnetic scroll
class UIListViewTest_Magnetic : public UIScene
{
protected:
virtual bool init() override;
virtual cocos2d::ui::ScrollView::Direction getListViewDirection() const = 0;
cocos2d::ui::ListView* _listView;
cocos2d::ui::Text* _titleLabel;
cocos2d::ui::Text* _indexLabels[5];
};
class UIListViewTest_MagneticVertical : public UIListViewTest_Magnetic
{
public:
CREATE_FUNC(UIListViewTest_MagneticVertical);
virtual cocos2d::ui::ScrollView::Direction getListViewDirection() const
{
return cocos2d::ui::ScrollView::Direction::VERTICAL;
}
};
class UIListViewTest_MagneticHorizontal : public UIListViewTest_Magnetic
{
public:
CREATE_FUNC(UIListViewTest_MagneticHorizontal);
virtual cocos2d::ui::ScrollView::Direction getListViewDirection() const
{
return cocos2d::ui::ScrollView::Direction::HORIZONTAL;
}
};
#endif /* defined(__TestCpp__UIListViewTest__) */ #endif /* defined(__TestCpp__UIListViewTest__) */