2012-09-10 14:13:55 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2012 cocos2d-x.org
|
|
|
|
Copyright (c) 2010 Sangwoo Im
|
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
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.
|
|
|
|
****************************************************************************/
|
2012-06-18 18:30:07 +08:00
|
|
|
|
|
|
|
#include "CCScrollView.h"
|
2014-01-31 08:51:43 +08:00
|
|
|
#include "CCGLView.h"
|
2014-01-17 13:58:14 +08:00
|
|
|
#include "platform/CCDevice.h"
|
2014-01-17 13:35:58 +08:00
|
|
|
#include "CCActionInstant.h"
|
|
|
|
#include "CCActionInterval.h"
|
|
|
|
#include "CCActionTween.h"
|
|
|
|
#include "CCDirector.h"
|
|
|
|
#include "renderer/CCRenderer.h"
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-09-12 20:47:15 +08:00
|
|
|
#include <algorithm>
|
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
NS_CC_EXT_BEGIN
|
|
|
|
|
|
|
|
#define SCROLL_DEACCEL_RATE 0.95f
|
|
|
|
#define SCROLL_DEACCEL_DIST 1.0f
|
|
|
|
#define BOUNCE_DURATION 0.15f
|
|
|
|
#define INSET_RATIO 0.2f
|
2013-02-16 19:36:21 +08:00
|
|
|
#define MOVE_INCH 7.0f/160.0f
|
|
|
|
|
|
|
|
static float convertDistanceFromPointToInch(float pointDis)
|
|
|
|
{
|
2014-01-24 07:36:55 +08:00
|
|
|
auto glview = Director::getInstance()->getOpenGLView();
|
|
|
|
float factor = ( glview->getScaleX() + glview->getScaleY() ) / 2;
|
2013-06-20 14:15:53 +08:00
|
|
|
return pointDis * factor / Device::getDPI();
|
2013-02-16 19:36:21 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
ScrollView::ScrollView()
|
2013-06-15 14:03:30 +08:00
|
|
|
: _zoomScale(0.0f)
|
|
|
|
, _minZoomScale(0.0f)
|
|
|
|
, _maxZoomScale(0.0f)
|
2014-01-07 22:16:24 +08:00
|
|
|
, _delegate(nullptr)
|
2013-07-26 22:55:41 +08:00
|
|
|
, _direction(Direction::BOTH)
|
2013-06-15 14:03:30 +08:00
|
|
|
, _dragging(false)
|
2014-01-07 22:16:24 +08:00
|
|
|
, _container(nullptr)
|
2013-06-15 14:03:30 +08:00
|
|
|
, _touchMoved(false)
|
|
|
|
, _bounceable(false)
|
|
|
|
, _clippingToBounds(false)
|
|
|
|
, _touchLength(0.0f)
|
|
|
|
, _minScale(0.0f)
|
|
|
|
, _maxScale(0.0f)
|
2013-10-25 16:06:52 +08:00
|
|
|
, _touchListener(nullptr)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
ScrollView::~ScrollView()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-09-12 14:42:56 +08:00
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
ScrollView* ScrollView::create(Size size, Node* container/* = NULL*/)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
ScrollView* pRet = new ScrollView();
|
2012-06-18 18:30:07 +08:00
|
|
|
if (pRet && pRet->initWithViewSize(size, container))
|
|
|
|
{
|
|
|
|
pRet->autorelease();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CC_SAFE_DELETE(pRet);
|
|
|
|
}
|
|
|
|
return pRet;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
ScrollView* ScrollView::create()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
ScrollView* pRet = new ScrollView();
|
2012-06-18 18:30:07 +08:00
|
|
|
if (pRet && pRet->init())
|
|
|
|
{
|
|
|
|
pRet->autorelease();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CC_SAFE_DELETE(pRet);
|
|
|
|
}
|
|
|
|
return pRet;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
bool ScrollView::initWithViewSize(Size size, Node *container/* = NULL*/)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
if (Layer::init())
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_container = container;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!this->_container)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
_container = Layer::create();
|
2014-01-07 22:16:24 +08:00
|
|
|
_container->ignoreAnchorPointForPosition(false);
|
|
|
|
_container->setAnchorPoint(Point(0.0f, 0.0f));
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
this->setViewSize(size);
|
|
|
|
|
2013-10-25 16:06:52 +08:00
|
|
|
setTouchEnabled(true);
|
2013-09-03 18:22:03 +08:00
|
|
|
|
2013-09-20 19:19:31 +08:00
|
|
|
_touches.reserve(EventTouch::MAX_TOUCHES);
|
2013-08-22 10:15:47 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_delegate = NULL;
|
|
|
|
_bounceable = true;
|
|
|
|
_clippingToBounds = true;
|
2013-07-12 14:47:36 +08:00
|
|
|
//_container->setContentSize(Size::ZERO);
|
2013-07-26 22:55:41 +08:00
|
|
|
_direction = Direction::BOTH;
|
2013-07-12 14:11:55 +08:00
|
|
|
_container->setPosition(Point(0.0f, 0.0f));
|
2013-06-15 14:03:30 +08:00
|
|
|
_touchLength = 0.0f;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
this->addChild(_container);
|
|
|
|
_minScale = _maxScale = 1.0f;
|
2013-09-03 18:22:03 +08:00
|
|
|
|
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
bool ScrollView::init()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-07-12 14:30:26 +08:00
|
|
|
return this->initWithViewSize(Size(200, 200), NULL);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
bool ScrollView::isNodeVisible(Node* node)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
const Point offset = this->getContentOffset();
|
|
|
|
const Size size = this->getViewSize();
|
2012-06-18 18:30:07 +08:00
|
|
|
const float scale = this->getZoomScale();
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Rect viewRect;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-07-12 14:30:26 +08:00
|
|
|
viewRect = Rect(-offset.x/scale, -offset.y/scale, size.width/scale, size.height/scale);
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-07-17 09:16:04 +08:00
|
|
|
return viewRect.intersectsRect(node->getBoundingBox());
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void ScrollView::pause(Ref* sender)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-10-26 15:04:01 +08:00
|
|
|
_container->pause();
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-12-17 17:45:29 +08:00
|
|
|
auto& children = _container->getChildren();
|
2013-12-20 05:34:41 +08:00
|
|
|
for(const auto &child : children) {
|
2013-11-28 18:23:06 +08:00
|
|
|
child->pause();
|
2013-12-20 05:34:41 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2014-02-20 10:53:49 +08:00
|
|
|
void ScrollView::resume(Ref* sender)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-12-17 17:45:29 +08:00
|
|
|
auto& children = _container->getChildren();
|
2013-12-20 05:34:41 +08:00
|
|
|
for(const auto &child : children) {
|
2013-11-28 18:23:06 +08:00
|
|
|
child->resume();
|
2013-12-20 05:34:41 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-10-26 15:04:01 +08:00
|
|
|
_container->resume();
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-11-20 11:35:04 +08:00
|
|
|
bool ScrollView::isTouchEnabled() const
|
|
|
|
{
|
|
|
|
return _touchListener != nullptr;
|
|
|
|
}
|
|
|
|
|
2013-10-25 16:06:52 +08:00
|
|
|
void ScrollView::setTouchEnabled(bool enabled)
|
|
|
|
{
|
2013-10-26 15:04:01 +08:00
|
|
|
_eventDispatcher->removeEventListener(_touchListener);
|
2013-11-20 11:35:04 +08:00
|
|
|
_touchListener = nullptr;
|
|
|
|
|
2013-10-25 16:06:52 +08:00
|
|
|
if (enabled)
|
|
|
|
{
|
|
|
|
_touchListener = EventListenerTouchOneByOne::create();
|
|
|
|
_touchListener->onTouchBegan = CC_CALLBACK_2(ScrollView::onTouchBegan, this);
|
|
|
|
_touchListener->onTouchMoved = CC_CALLBACK_2(ScrollView::onTouchMoved, this);
|
|
|
|
_touchListener->onTouchEnded = CC_CALLBACK_2(ScrollView::onTouchEnded, this);
|
|
|
|
_touchListener->onTouchCancelled = CC_CALLBACK_2(ScrollView::onTouchCancelled, this);
|
|
|
|
|
2013-10-26 15:04:01 +08:00
|
|
|
_eventDispatcher->addEventListenerWithSceneGraphPriority(_touchListener, this);
|
2013-10-25 16:06:52 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_dragging = false;
|
|
|
|
_touchMoved = false;
|
|
|
|
_touches.clear();
|
|
|
|
}
|
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setContentOffset(Point offset, bool animated/* = false*/)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (animated)
|
|
|
|
{ //animate scrolling
|
|
|
|
this->setContentOffsetInDuration(offset, BOUNCE_DURATION);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ //set the container position directly
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_bounceable)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
const Point minOffset = this->minContainerOffset();
|
|
|
|
const Point maxOffset = this->maxContainerOffset();
|
2012-06-18 18:30:07 +08:00
|
|
|
|
|
|
|
offset.x = MAX(minOffset.x, MIN(maxOffset.x, offset.x));
|
|
|
|
offset.y = MAX(minOffset.y, MIN(maxOffset.y, offset.y));
|
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_container->setPosition(offset);
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_delegate != NULL)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_delegate->scrollViewDidScroll(this);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setContentOffsetInDuration(Point offset, float dt)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
FiniteTimeAction *scroll, *expire;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
scroll = MoveTo::create(dt, offset);
|
2013-07-16 03:43:22 +08:00
|
|
|
expire = CallFuncN::create(CC_CALLBACK_1(ScrollView::stoppedAnimatedScroll,this));
|
2013-06-20 14:15:53 +08:00
|
|
|
_container->runAction(Sequence::create(scroll, expire, NULL));
|
|
|
|
this->schedule(schedule_selector(ScrollView::performedAnimatedScroll));
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Point ScrollView::getContentOffset()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
return _container->getPosition();
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setZoomScale(float s)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_container->getScale() != s)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
Point oldCenter, newCenter;
|
|
|
|
Point center;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_touchLength == 0.0f)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-07-12 14:11:55 +08:00
|
|
|
center = Point(_viewSize.width*0.5f, _viewSize.height*0.5f);
|
2012-06-18 18:30:07 +08:00
|
|
|
center = this->convertToWorldSpace(center);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
center = _touchPoint;
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
oldCenter = _container->convertToNodeSpace(center);
|
|
|
|
_container->setScale(MAX(_minScale, MIN(_maxScale, s)));
|
|
|
|
newCenter = _container->convertToWorldSpace(oldCenter);
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-07-11 16:38:58 +08:00
|
|
|
const Point offset = center - newCenter;
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_delegate != NULL)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_delegate->scrollViewDidZoom(this);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
2013-07-11 16:38:58 +08:00
|
|
|
this->setContentOffset(_container->getPosition() + offset);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
float ScrollView::getZoomScale()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
return _container->getScale();
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setZoomScale(float s, bool animated)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (animated)
|
|
|
|
{
|
|
|
|
this->setZoomScaleInDuration(s, BOUNCE_DURATION);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this->setZoomScale(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setZoomScaleInDuration(float s, float dt)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (dt > 0)
|
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_container->getScale() != s)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
ActionTween *scaleAction;
|
|
|
|
scaleAction = ActionTween::create(dt, "zoomScale", _container->getScale(), s);
|
2012-06-18 18:30:07 +08:00
|
|
|
this->runAction(scaleAction);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this->setZoomScale(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-14 20:36:37 +08:00
|
|
|
void ScrollView::updateTweenAction(float value, const std::string& key)
|
2014-01-14 20:03:12 +08:00
|
|
|
{
|
2014-01-14 20:33:02 +08:00
|
|
|
this->setZoomScale(value);
|
2014-01-14 20:03:12 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setViewSize(Size size)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_viewSize = size;
|
2013-06-20 14:15:53 +08:00
|
|
|
Layer::setContentSize(size);
|
2012-06-19 09:43:53 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Node * ScrollView::getContainer()
|
2012-06-19 09:43:53 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
return this->_container;
|
2012-06-19 09:43:53 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setContainer(Node * pContainer)
|
2012-06-19 09:43:53 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
// Make sure that '_container' has a non-NULL value since there are
|
|
|
|
// lots of logic that use '_container'.
|
2013-04-15 09:52:46 +08:00
|
|
|
if (NULL == pContainer)
|
|
|
|
return;
|
2012-06-19 09:43:53 +08:00
|
|
|
|
2013-04-15 09:52:46 +08:00
|
|
|
this->removeAllChildrenWithCleanup(true);
|
2013-06-15 14:03:30 +08:00
|
|
|
this->_container = pContainer;
|
2012-06-19 09:43:53 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
this->_container->ignoreAnchorPointForPosition(false);
|
2013-07-12 14:11:55 +08:00
|
|
|
this->_container->setAnchorPoint(Point(0.0f, 0.0f));
|
2012-06-19 09:43:53 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
this->addChild(this->_container);
|
2012-06-19 09:43:53 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
this->setViewSize(this->_viewSize);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::relocateContainer(bool animated)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
Point oldPoint, min, max;
|
2012-08-01 15:30:12 +08:00
|
|
|
float newX, newY;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
|
|
|
min = this->minContainerOffset();
|
|
|
|
max = this->maxContainerOffset();
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
oldPoint = _container->getPosition();
|
2012-06-18 18:30:07 +08:00
|
|
|
|
|
|
|
newX = oldPoint.x;
|
|
|
|
newY = oldPoint.y;
|
2013-07-26 22:55:41 +08:00
|
|
|
if (_direction == Direction::BOTH || _direction == Direction::HORIZONTAL)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
newX = MAX(newX, min.x);
|
2012-12-05 22:55:06 +08:00
|
|
|
newX = MIN(newX, max.x);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-07-26 22:55:41 +08:00
|
|
|
if (_direction == Direction::BOTH || _direction == Direction::VERTICAL)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
newY = MIN(newY, max.y);
|
|
|
|
newY = MAX(newY, min.y);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (newY != oldPoint.y || newX != oldPoint.x)
|
|
|
|
{
|
2013-07-12 14:11:55 +08:00
|
|
|
this->setContentOffset(Point(newX, newY), animated);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Point ScrollView::maxContainerOffset()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-07-12 14:11:55 +08:00
|
|
|
return Point(0.0f, 0.0f);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Point ScrollView::minContainerOffset()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-07-12 14:11:55 +08:00
|
|
|
return Point(_viewSize.width - _container->getContentSize().width*_container->getScaleX(),
|
2013-06-15 14:03:30 +08:00
|
|
|
_viewSize.height - _container->getContentSize().height*_container->getScaleY());
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::deaccelerateScrolling(float dt)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_dragging)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
this->unschedule(schedule_selector(ScrollView::deaccelerateScrolling));
|
2012-06-18 18:30:07 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-08-01 15:30:12 +08:00
|
|
|
float newX, newY;
|
2013-06-20 14:15:53 +08:00
|
|
|
Point maxInset, minInset;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-07-11 16:38:58 +08:00
|
|
|
_container->setPosition(_container->getPosition() + _scrollDistance);
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_bounceable)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
maxInset = _maxInset;
|
|
|
|
minInset = _minInset;
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
maxInset = this->maxContainerOffset();
|
|
|
|
minInset = this->minContainerOffset();
|
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
newX = _container->getPosition().x;
|
|
|
|
newY = _container->getPosition().y;
|
2012-12-05 04:32:13 +08:00
|
|
|
|
2013-07-11 16:38:58 +08:00
|
|
|
_scrollDistance = _scrollDistance * SCROLL_DEACCEL_RATE;
|
2013-07-12 14:11:55 +08:00
|
|
|
this->setContentOffset(Point(newX,newY));
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if ((fabsf(_scrollDistance.x) <= SCROLL_DEACCEL_DIST &&
|
|
|
|
fabsf(_scrollDistance.y) <= SCROLL_DEACCEL_DIST) ||
|
2014-01-14 21:22:55 +08:00
|
|
|
newY >= maxInset.y || newY <= minInset.y ||
|
|
|
|
newX >= maxInset.x || newX <= minInset.x)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
this->unschedule(schedule_selector(ScrollView::deaccelerateScrolling));
|
2012-06-18 18:30:07 +08:00
|
|
|
this->relocateContainer(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::stoppedAnimatedScroll(Node * node)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
this->unschedule(schedule_selector(ScrollView::performedAnimatedScroll));
|
2013-02-18 09:45:01 +08:00
|
|
|
// After the animation stopped, "scrollViewDidScroll" should be invoked, this could fix the bug of lack of tableview cells.
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_delegate != NULL)
|
2013-02-18 09:45:01 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_delegate->scrollViewDidScroll(this);
|
2013-02-18 09:45:01 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::performedAnimatedScroll(float dt)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_dragging)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
this->unschedule(schedule_selector(ScrollView::performedAnimatedScroll));
|
2012-06-18 18:30:07 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_delegate != NULL)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_delegate->scrollViewDidScroll(this);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
const Size& ScrollView::getContentSize() const
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
return _container->getContentSize();
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::setContentSize(const Size & size)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2012-09-09 22:34:32 +08:00
|
|
|
if (this->getContainer() != NULL)
|
|
|
|
{
|
|
|
|
this->getContainer()->setContentSize(size);
|
2012-09-09 22:46:31 +08:00
|
|
|
this->updateInset();
|
|
|
|
}
|
|
|
|
}
|
2012-09-09 22:34:32 +08:00
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::updateInset()
|
2012-09-09 22:46:31 +08:00
|
|
|
{
|
|
|
|
if (this->getContainer() != NULL)
|
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_maxInset = this->maxContainerOffset();
|
2013-07-12 14:11:55 +08:00
|
|
|
_maxInset = Point(_maxInset.x + _viewSize.width * INSET_RATIO,
|
2013-06-15 14:03:30 +08:00
|
|
|
_maxInset.y + _viewSize.height * INSET_RATIO);
|
|
|
|
_minInset = this->minContainerOffset();
|
2013-07-12 14:11:55 +08:00
|
|
|
_minInset = Point(_minInset.x - _viewSize.width * INSET_RATIO,
|
2013-06-15 14:03:30 +08:00
|
|
|
_minInset.y - _viewSize.height * INSET_RATIO);
|
2012-09-09 22:46:31 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
2012-09-09 22:46:31 +08:00
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
/**
|
|
|
|
* make sure all children go to the container
|
|
|
|
*/
|
2013-06-20 14:15:53 +08:00
|
|
|
void ScrollView::addChild(Node * child, int zOrder, int tag)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_container != child) {
|
|
|
|
_container->addChild(child, zOrder, tag);
|
2012-06-18 18:30:07 +08:00
|
|
|
} else {
|
2013-06-20 14:15:53 +08:00
|
|
|
Layer::addChild(child, zOrder, tag);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-07 17:46:24 +08:00
|
|
|
void ScrollView::beforeDraw()
|
|
|
|
{
|
2014-01-19 03:35:27 +08:00
|
|
|
_beforeDrawCommand.init(_globalZOrder);
|
2014-01-07 17:46:24 +08:00
|
|
|
_beforeDrawCommand.func = CC_CALLBACK_0(ScrollView::onBeforeDraw, this);
|
|
|
|
Director::getInstance()->getRenderer()->addCommand(&_beforeDrawCommand);
|
|
|
|
}
|
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
/**
|
|
|
|
* clip this view so that outside of the visible bounds can be hidden.
|
|
|
|
*/
|
2014-01-07 17:46:24 +08:00
|
|
|
void ScrollView::onBeforeDraw()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_clippingToBounds)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_scissorRestored = false;
|
2013-06-20 14:15:53 +08:00
|
|
|
Rect frame = getViewRect();
|
2014-01-24 07:36:55 +08:00
|
|
|
auto glview = Director::getInstance()->getOpenGLView();
|
|
|
|
|
|
|
|
if (glview->isScissorEnabled()) {
|
2013-06-15 14:03:30 +08:00
|
|
|
_scissorRestored = true;
|
2014-01-24 07:36:55 +08:00
|
|
|
_parentScissorRect = glview->getScissorRect();
|
2013-06-15 14:03:30 +08:00
|
|
|
//set the intersection of _parentScissorRect and frame as the new scissor rect
|
|
|
|
if (frame.intersectsRect(_parentScissorRect)) {
|
|
|
|
float x = MAX(frame.origin.x, _parentScissorRect.origin.x);
|
|
|
|
float y = MAX(frame.origin.y, _parentScissorRect.origin.y);
|
|
|
|
float xx = MIN(frame.origin.x+frame.size.width, _parentScissorRect.origin.x+_parentScissorRect.size.width);
|
|
|
|
float yy = MIN(frame.origin.y+frame.size.height, _parentScissorRect.origin.y+_parentScissorRect.size.height);
|
2014-01-24 07:36:55 +08:00
|
|
|
glview->setScissorInPoints(x, y, xx-x, yy-y);
|
2013-03-29 16:05:28 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
2014-01-24 07:36:55 +08:00
|
|
|
glview->setScissorInPoints(frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
|
2013-03-29 16:05:28 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-07 17:46:24 +08:00
|
|
|
void ScrollView::afterDraw()
|
|
|
|
{
|
2014-01-19 03:35:27 +08:00
|
|
|
_afterDrawCommand.init(_globalZOrder);
|
2014-01-07 17:46:24 +08:00
|
|
|
_afterDrawCommand.func = CC_CALLBACK_0(ScrollView::onAfterDraw, this);
|
|
|
|
Director::getInstance()->getRenderer()->addCommand(&_afterDrawCommand);
|
|
|
|
}
|
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
/**
|
|
|
|
* retract what's done in beforeDraw so that there's no side effect to
|
|
|
|
* other nodes.
|
|
|
|
*/
|
2014-01-07 17:46:24 +08:00
|
|
|
void ScrollView::onAfterDraw()
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_clippingToBounds)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_scissorRestored) {//restore the parent's scissor rect
|
2014-01-24 07:36:55 +08:00
|
|
|
auto glview = Director::getInstance()->getOpenGLView();
|
|
|
|
|
|
|
|
glview->setScissorInPoints(_parentScissorRect.origin.x, _parentScissorRect.origin.y, _parentScissorRect.size.width, _parentScissorRect.size.height);
|
2013-03-29 16:05:28 +08:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-01 08:10:48 +08:00
|
|
|
void ScrollView::visit(Renderer *renderer, const kmMat4 &parentTransform, bool parentTransformUpdated)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
// quick return if not visible
|
|
|
|
if (!isVisible())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-03-01 08:10:48 +08:00
|
|
|
bool dirty = parentTransformUpdated || _transformUpdated;
|
2014-02-28 13:43:54 +08:00
|
|
|
if(dirty)
|
2014-03-01 03:20:53 +08:00
|
|
|
_modelViewTransform = this->transform(parentTransform);
|
2014-03-01 08:10:48 +08:00
|
|
|
_transformUpdated = false;
|
2014-03-01 03:20:53 +08:00
|
|
|
|
|
|
|
// IMPORTANT:
|
|
|
|
// To ease the migration to v3.0, we still support the kmGL stack,
|
|
|
|
// but it is deprecated and your code should not rely on it
|
|
|
|
kmGLPushMatrix();
|
|
|
|
kmGLLoadMatrix(&_modelViewTransform);
|
2014-02-28 13:43:54 +08:00
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
this->beforeDraw();
|
|
|
|
|
2013-11-28 18:23:06 +08:00
|
|
|
if (!_children.empty())
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-09-08 11:26:38 +08:00
|
|
|
int i=0;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
|
|
|
// draw children zOrder < 0
|
2013-12-05 10:35:10 +08:00
|
|
|
for( ; i < _children.size(); i++ )
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-12-05 10:35:10 +08:00
|
|
|
Node *child = _children.at(i);
|
2014-01-20 15:03:30 +08:00
|
|
|
if ( child->getLocalZOrder() < 0 )
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2014-02-28 13:43:54 +08:00
|
|
|
child->visit(renderer, _modelViewTransform, dirty);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// this draw
|
2014-02-28 13:43:54 +08:00
|
|
|
this->draw(renderer, _modelViewTransform, dirty);
|
2013-09-12 20:47:15 +08:00
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
// draw children zOrder >= 0
|
2013-12-05 10:35:10 +08:00
|
|
|
for( ; i < _children.size(); i++ )
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-12-05 10:35:10 +08:00
|
|
|
Node *child = _children.at(i);
|
2014-02-28 13:43:54 +08:00
|
|
|
child->visit(renderer, _modelViewTransform, dirty);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-02-28 13:43:54 +08:00
|
|
|
this->draw(renderer, _modelViewTransform, dirty);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
this->afterDraw();
|
|
|
|
|
|
|
|
kmGLPopMatrix();
|
|
|
|
}
|
|
|
|
|
2013-09-03 18:22:03 +08:00
|
|
|
bool ScrollView::onTouchBegan(Touch* touch, Event* event)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (!this->isVisible())
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Rect frame = getViewRect();
|
2013-02-16 14:18:13 +08:00
|
|
|
|
2012-06-18 18:30:07 +08:00
|
|
|
//dispatcher does not know about clipping. reject touches outside visible bounds.
|
2013-09-12 14:42:56 +08:00
|
|
|
if (_touches.size() > 2 ||
|
2013-06-15 14:03:30 +08:00
|
|
|
_touchMoved ||
|
2013-12-16 18:20:10 +08:00
|
|
|
!frame.containsPoint(touch->getLocation()))
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-09-12 16:03:03 +08:00
|
|
|
if (std::find(_touches.begin(), _touches.end(), touch) == _touches.end())
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-09-12 14:42:56 +08:00
|
|
|
_touches.push_back(touch);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-09-12 14:42:56 +08:00
|
|
|
if (_touches.size() == 1)
|
2012-06-18 18:30:07 +08:00
|
|
|
{ // scrolling
|
2013-06-15 14:03:30 +08:00
|
|
|
_touchPoint = this->convertTouchToNodeSpace(touch);
|
|
|
|
_touchMoved = false;
|
|
|
|
_dragging = true; //dragging started
|
2013-07-12 14:11:55 +08:00
|
|
|
_scrollDistance = Point(0.0f, 0.0f);
|
2013-06-15 14:03:30 +08:00
|
|
|
_touchLength = 0.0f;
|
|
|
|
}
|
2013-09-12 14:42:56 +08:00
|
|
|
else if (_touches.size() == 2)
|
2013-06-15 14:03:30 +08:00
|
|
|
{
|
2013-09-12 14:42:56 +08:00
|
|
|
_touchPoint = (this->convertTouchToNodeSpace(_touches[0]).getMidpoint(
|
|
|
|
this->convertTouchToNodeSpace(_touches[1])));
|
2013-07-11 16:38:58 +08:00
|
|
|
|
2013-09-12 14:42:56 +08:00
|
|
|
_touchLength = _container->convertTouchToNodeSpace(_touches[0]).getDistance(
|
|
|
|
_container->convertTouchToNodeSpace(_touches[1]));
|
2013-07-11 16:38:58 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_dragging = false;
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-09-03 18:22:03 +08:00
|
|
|
void ScrollView::onTouchMoved(Touch* touch, Event* event)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (!this->isVisible())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-09-12 14:42:56 +08:00
|
|
|
if (std::find(_touches.begin(), _touches.end(), touch) != _touches.end())
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-09-12 14:42:56 +08:00
|
|
|
if (_touches.size() == 1 && _dragging)
|
2012-06-18 18:30:07 +08:00
|
|
|
{ // scrolling
|
2014-01-14 22:30:38 +08:00
|
|
|
Point moveDistance, newPoint;
|
2013-06-20 14:15:53 +08:00
|
|
|
Rect frame;
|
2012-08-01 15:30:12 +08:00
|
|
|
float newX, newY;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2013-02-16 14:18:13 +08:00
|
|
|
frame = getViewRect();
|
2012-10-08 14:12:34 +08:00
|
|
|
|
2013-09-12 14:42:56 +08:00
|
|
|
newPoint = this->convertTouchToNodeSpace(_touches[0]);
|
2013-07-11 16:38:58 +08:00
|
|
|
moveDistance = newPoint - _touchPoint;
|
2013-02-16 19:36:21 +08:00
|
|
|
|
|
|
|
float dis = 0.0f;
|
2013-07-26 22:55:41 +08:00
|
|
|
if (_direction == Direction::VERTICAL)
|
2013-02-16 19:36:21 +08:00
|
|
|
{
|
|
|
|
dis = moveDistance.y;
|
|
|
|
}
|
2013-07-26 22:55:41 +08:00
|
|
|
else if (_direction == Direction::HORIZONTAL)
|
2013-02-16 19:36:21 +08:00
|
|
|
{
|
|
|
|
dis = moveDistance.x;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dis = sqrtf(moveDistance.x*moveDistance.x + moveDistance.y*moveDistance.y);
|
|
|
|
}
|
2013-02-17 17:13:06 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_touchMoved && fabs(convertDistanceFromPointToInch(dis)) < MOVE_INCH )
|
2013-02-16 19:36:21 +08:00
|
|
|
{
|
2013-02-17 17:13:06 +08:00
|
|
|
//CCLOG("Invalid movement, distance = [%f, %f], disInch = %f", moveDistance.x, moveDistance.y);
|
2013-02-16 19:36:21 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
if (!_touchMoved)
|
2013-02-16 19:36:21 +08:00
|
|
|
{
|
2013-07-12 14:47:36 +08:00
|
|
|
moveDistance = Point::ZERO;
|
2013-02-16 19:36:21 +08:00
|
|
|
}
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_touchPoint = newPoint;
|
|
|
|
_touchMoved = true;
|
2012-06-18 18:30:07 +08:00
|
|
|
|
2012-08-01 15:30:12 +08:00
|
|
|
if (frame.containsPoint(this->convertToWorldSpace(newPoint)))
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
switch (_direction)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-07-26 22:55:41 +08:00
|
|
|
case Direction::VERTICAL:
|
2013-07-12 14:11:55 +08:00
|
|
|
moveDistance = Point(0.0f, moveDistance.y);
|
2012-06-18 18:30:07 +08:00
|
|
|
break;
|
2013-07-26 22:55:41 +08:00
|
|
|
case Direction::HORIZONTAL:
|
2013-07-12 14:11:55 +08:00
|
|
|
moveDistance = Point(moveDistance.x, 0.0f);
|
2012-06-18 18:30:07 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2012-12-05 04:32:13 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
newX = _container->getPosition().x + moveDistance.x;
|
|
|
|
newY = _container->getPosition().y + moveDistance.y;
|
2012-12-05 04:32:13 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_scrollDistance = moveDistance;
|
2013-07-12 14:11:55 +08:00
|
|
|
this->setContentOffset(Point(newX, newY));
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
2013-09-12 14:42:56 +08:00
|
|
|
else if (_touches.size() == 2 && !_dragging)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-09-12 14:42:56 +08:00
|
|
|
const float len = _container->convertTouchToNodeSpace(_touches[0]).getDistance(
|
|
|
|
_container->convertTouchToNodeSpace(_touches[1]));
|
2013-06-15 14:03:30 +08:00
|
|
|
this->setZoomScale(this->getZoomScale()*len/_touchLength);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-03 18:22:03 +08:00
|
|
|
void ScrollView::onTouchEnded(Touch* touch, Event* event)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (!this->isVisible())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2013-09-12 14:42:56 +08:00
|
|
|
|
|
|
|
auto touchIter = std::find(_touches.begin(), _touches.end(), touch);
|
|
|
|
|
|
|
|
if (touchIter != _touches.end())
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-09-12 14:42:56 +08:00
|
|
|
if (_touches.size() == 1 && _touchMoved)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-20 14:15:53 +08:00
|
|
|
this->schedule(schedule_selector(ScrollView::deaccelerateScrolling));
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
2013-09-12 14:42:56 +08:00
|
|
|
_touches.erase(touchIter);
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
|
2013-09-12 14:42:56 +08:00
|
|
|
if (_touches.size() == 0)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_dragging = false;
|
|
|
|
_touchMoved = false;
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-03 18:22:03 +08:00
|
|
|
void ScrollView::onTouchCancelled(Touch* touch, Event* event)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
|
|
|
if (!this->isVisible())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2013-09-12 14:42:56 +08:00
|
|
|
|
|
|
|
auto touchIter = std::find(_touches.begin(), _touches.end(), touch);
|
|
|
|
_touches.erase(touchIter);
|
|
|
|
|
|
|
|
if (_touches.size() == 0)
|
2012-06-18 18:30:07 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
_dragging = false;
|
|
|
|
_touchMoved = false;
|
2012-06-18 18:30:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
Rect ScrollView::getViewRect()
|
2013-02-16 14:18:13 +08:00
|
|
|
{
|
2013-07-12 14:47:36 +08:00
|
|
|
Point screenPos = this->convertToWorldSpace(Point::ZERO);
|
2013-02-16 14:18:13 +08:00
|
|
|
|
|
|
|
float scaleX = this->getScaleX();
|
|
|
|
float scaleY = this->getScaleY();
|
|
|
|
|
2013-06-20 14:15:53 +08:00
|
|
|
for (Node *p = _parent; p != NULL; p = p->getParent()) {
|
2013-02-16 14:18:13 +08:00
|
|
|
scaleX *= p->getScaleX();
|
|
|
|
scaleY *= p->getScaleY();
|
|
|
|
}
|
2013-04-30 23:17:38 +08:00
|
|
|
|
|
|
|
// Support negative scaling. Not doing so causes intersectsRect calls
|
|
|
|
// (eg: to check if the touch was within the bounds) to return false.
|
2013-06-20 14:15:53 +08:00
|
|
|
// Note, Node::getScale will assert if X and Y scales are different.
|
2013-04-30 23:17:38 +08:00
|
|
|
if(scaleX<0.f) {
|
2013-06-15 14:03:30 +08:00
|
|
|
screenPos.x += _viewSize.width*scaleX;
|
2013-04-30 23:17:38 +08:00
|
|
|
scaleX = -scaleX;
|
|
|
|
}
|
|
|
|
if(scaleY<0.f) {
|
2013-06-15 14:03:30 +08:00
|
|
|
screenPos.y += _viewSize.height*scaleY;
|
2013-04-30 23:17:38 +08:00
|
|
|
scaleY = -scaleY;
|
|
|
|
}
|
|
|
|
|
2013-07-12 14:30:26 +08:00
|
|
|
return Rect(screenPos.x, screenPos.y, _viewSize.width*scaleX, _viewSize.height*scaleY);
|
2013-02-16 14:18:13 +08:00
|
|
|
}
|
2012-06-18 18:30:07 +08:00
|
|
|
NS_CC_EXT_END
|