void CCCGameScrollView::setCurPage( int nPage )
{
CCAssert(m_nCurPage >= 0 && m_nCurPage < m_nPageCount, "");
if (m_eDirection == kCCScrollViewDirectionHorizontal)
{
setContentOffset(ccp(-nPage * m_CellSize.width, 0));
}
else
{
setContentOffset(ccp(0, nPage * m_CellSize.height));
}
m_nCurPage = nPage;
}
void CScrollView::onTouchMoved(Touch *pTouch, float fDuration)
{
Vec2 tNodePoint = convertToNodeSpace(pTouch->getLocation());
if( m_pSelectedWidget )
{
if( m_eSelectedWidgetTouchModel == eWidgetTouchTransient && !m_bTouchMoved )
{
float fDistance = tNodePoint.getDistance(m_tTouchBeganPoint);
if(!m_bTouchMoved && fabs(ccScrollconvertPointToInch(fDistance)) < CSCROLLVIEW_MOVE_INCH)
{
m_pSelectedWidget->executeTouchMovedHandler(pTouch, fDuration);
return;
}
m_bTouchMoved = true;
m_pSelectedWidget->interruptTouch(pTouch, fDuration);
}
if(!m_pSelectedWidget->isTouchInterrupted())
{
m_pSelectedWidget->executeTouchMovedHandler(pTouch, fDuration);
if(!m_pSelectedWidget->isTouchInterrupted())
{
return;
}
}
}
if( !m_bDragging )
{
m_tTouchBeganPoint = tNodePoint;
m_tLastMovePoint = tNodePoint;
m_bDragging = true;
stoppedDeaccelerateScroll();
stoppedAnimatedScroll();
}
if( m_bDragable )
{
m_tScrollDistance = tNodePoint - m_tLastMovePoint;
m_tLastMovePoint = tNodePoint;
switch( m_eDirection )
{
case eScrollViewDirectionHorizontal:
m_tScrollDistance.y = 0;
break;
case eScrollViewDirectionVertical:
m_tScrollDistance.x = 0;
break;
default:
break;
}
setContentOffset( getContentOffset() + m_tScrollDistance );
}
}
void CScrollView::setContentOffsetToBottom()
{
if( m_eDirection == eScrollViewDirectionVertical )
{
setContentOffset(m_tMaxOffset);
}
}
// pull up data is appending at the end,
// so we should set the offset whitch refreshed before
void Pull2RefreshTableView::onPullUpRefreshComplete()
{
m_nPullActionStatus = kPull2RefreshStatusNormal;
CCPoint offset = getContentOffset();
reloadData();
setContentOffset(offset);
}
void CScrollView::setContentOffsetToLeft()
{
if( m_eDirection == eScrollViewDirectionHorizontal )
{
setContentOffset(m_tMaxOffset);
}
}
void WXTableView::navigateCellByIdx(unsigned int idx, CCPoint delta, bool animated)
{
unsigned int cellsCount = _dataSource->numberOfCellsInTableView(this);
if (idx<0 || idx>=cellsCount)
{
return;
}
CCSize cellSize = _dataSource->tableCellSizeForIndex(this, 0);//先cell固定大小吧
CCSize viewSize = getViewSize();
int offsetX = 0;
int offsetY = 0;
CCPoint maxInset, minInset;
maxInset = this->maxContainerOffset();
minInset = this->minContainerOffset();
switch (this->getDirection())
{
case ScrollView::Direction::HORIZONTAL:
{
offsetX = minInset.x + idx * cellSize.width + delta.x;
offsetX = MAX(offsetX, minInset.x);
offsetX = MIN(offsetX, maxInset.x);
}
break;
default://最底下的cell所在位置为（0,0）
{
offsetY = minInset.y + idx * cellSize.height + delta.y;
offsetY = MAX(offsetY, minInset.y);
offsetY = MIN(offsetY, maxInset.y);
}
break;
}
setContentOffset(ccp(offsetX, offsetY), animated);
}
void CScrollView::setContentOffsetToTop()
{
if( m_eDirection == eScrollViewDirectionVertical )
{
Vec2 tPoint(0, -(m_pContainer->getContentSize().height - _contentSize.height));
setContentOffset(tPoint);
}
}
//=============================================================
//=============================================================
void CCScrollLayer::stopDecelerate()
{
m_contentLayer->stopAllActions();
if(m_decelerateFlag)
{
m_decelerateFlag = false;
unschedule(schedule_selector(CCScrollLayer::decelerateTick));
}
//getCorrectPoint(m_contentLayer->getPosition());
// moveToEndPosition(false,m_contentLayer->getPosition());
setContentOffset(Point(0,0),false);
}
void ScrollPage::onTouchEnded(Touch *touch, Event *event)
{
ScrollView::onTouchEnded(touch, event);
if (_direction==Direction::VERTICAL) {
beginOffset=getContentOffset().y;
log("beginOffset:%f",beginOffset);
}
float height=getViewSize().height;
log("height:%f",height);
float page=beginOffset/height;
log("page:%f",page);
int page1=beginOffset/height;
log("page1:%d",page1);
if ((fabs(page)-fabs(page1))>0.5){
setContentOffset(Vec2(0,(page1-1)*height));
}else
{
setContentOffset(Vec2(0,page1*height));
}
}
/*
Ham xay dung noi dung cua dialog
*/
void SkillDetailDialog::createDisplaySkillInfo(Sprite* parent)
{
// Create skill image
auto skillImage = Sprite::create(_skillInfo.imagePath);
skillImage->setPosition(Vec2(skillImage->getContentSize().width + 40, parent->getContentSize().height / 2));
skillImage->setScale(2.0f);
parent->addChild(skillImage);
std::stringstream info;
info << "Name : " << _skillInfo.name << "\nId: " << _skillInfo.id << "\nMP: " << _skillInfo.mp_cost;
_statusLabel = LabelTTF::create(info.str().c_str(), "fonts/arial.ttf", 30);
_statusLabel->setColor(Color3B::RED);
_statusLabel->setHorizontalAlignment(TextHAlignment::LEFT);
// create scroll view info
if (_statusLabel->getContentSize().height > (parent->getContentSize().height - 200))
{
// Create scroll
auto scrollInfo = extension::ScrollView::create();
scrollInfo->setDirection(extension::ScrollView::Direction::VERTICAL); // cho scroll di chuyen theo chieu doc
scrollInfo->setViewSize(Size(parent->getContentSize().width / 2, 300));
scrollInfo->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
scrollInfo->setPosition(Vec2(parent->getContentSize().width / 2 - 70, 30));
scrollInfo->updateInset();
scrollInfo->setVisible(true);
parent->addChild(scrollInfo);
// Add layer to scroll
auto layer = Layer::create();
layer->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
layer->setContentSize(Size(parent->getContentSize().width / 2, _statusLabel->getContentSize().height + 50));
layer->setPosition(Vec2(0, -(layer->getContentSize().height / 2)));
scrollInfo->setContainer(layer);
// Add _statusLabel to layer
auto height = layer->getContentSize().height;
scrollInfo->setContentOffset(scrollInfo->minContainerOffset());
_statusLabel->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
_statusLabel->setPosition(Vec2(0, height - 20));
layer->addChild(_statusLabel);
}
else
{
_statusLabel->setPosition(Vec2(parent->getContentSize().width / 2 - 70, parent->getContentSize().height - 100));
_statusLabel->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
parent->addChild(_statusLabel);
}
}
bool ActivityPopupView::init()
{
if (!PopupBaseView::init()) {
return false;
}
setIsHDPanel(true);
CCLoadSprite::doResourceByCommonIndex(7, true);
CCLoadSprite::doResourceByCommonIndex(500, true);
setCleanFunction([](){
CCLoadSprite::doResourceByCommonIndex(7, false);
CCLoadSprite::doResourceByCommonIndex(500, false);
});
auto _rootNode = CCBLoadFile("ActivityHistoryView02", this, this);
if (CCCommonUtils::isIosAndroidPad())
{
_rootNode->setScale(1.8f);
}
setContentSize(CCDirector::sharedDirector()->getWinSize());
m_obj = ActivityController::getInstance()->getActObj(m_itemId);
if (!m_obj) {
return false;
}
CCCommonUtils::setButtonTitle(m_jumpBtn, _lang("115018").c_str());
m_titleLabel->setString(_lang("137516"));
m_nameLabel->setString(m_obj->name);
if (m_obj->story == "") {
m_storyLabel->setString(_lang(m_obj->desc_info));
} else {
m_storyLabel->setString(_lang(m_obj->story));
}
auto listSize = m_listNode->getContentSize();
auto labelSize = CCSize(m_storyLabel->getContentSize().width * m_storyLabel->getOriginScaleX(), m_storyLabel->getContentSize().height * m_storyLabel->getOriginScaleY());
if (labelSize.height > listSize.height) {
auto scrollView = CCScrollView::create(listSize);
scrollView->setDirection(kCCScrollViewDirectionVertical);
scrollView->setAnchorPoint(ccp(0, 0));
scrollView->setContentSize(CCSize(listSize.width, labelSize.height));
m_labelNode->getParent()->removeChild(m_labelNode, false);
m_labelNode->setPosition(ccp(0, 0));
scrollView->addChild(m_labelNode);
scrollView->setPosition(ccp(0, 0));
m_listNode->addChild(scrollView);
scrollView->setContentOffset(ccp(0, listSize.height - scrollView->getContentSize().height));
} else {
m_labelNode->setPosition(ccp(0, listSize.height / 2 - labelSize.height / 2));
}
return true;
}
void CATextView::calcCursorPosition()
{
int iCurLine = -1, iCurLineCharPos = 0;
for (int i = 0; i < m_vLinesTextView.size(); i++)
{
TextViewLineInfo& t = m_vLinesTextView[i];
if (m_iCurPos >= t.iStartCharPos && m_iCurPos <= t.iEndCharPos)
{
iCurLine = i; iCurLineCharPos = t.iStartCharPos;
break;
}
}
float fHalfLineHeight = m_iLineHeight / 2.0f;
float fLineSpaceValue = m_iLineHeight / 4.0f;
CCPoint cCurPosition;
if (iCurLine == -1)
{
cCurPosition.x = 0;
cCurPosition.y = fHalfLineHeight;
}
else
{
std::string s = m_szText.substr(iCurLineCharPos, m_iCurPos - iCurLineCharPos);
if (!s.empty() && s[0] == '\n')
{
s.erase(0, 1);
}
cCurPosition.x = getStringLength(s);
cCurPosition.y = (m_iLineHeight + fLineSpaceValue)*iCurLine + fHalfLineHeight;
}
if (m_pCursorMark)
{
m_pCursorMark->setCenterOrigin(cCurPosition);
}
float w = getBounds().size.height;
float y = cCurPosition.y - getContentOffset().y;
if (y < 0 || y > w)
{
y = y < 0 ? fHalfLineHeight : w - fHalfLineHeight;
setContentOffset(CCPointMake(0, cCurPosition.y-y), true);
}
}
//=============================================================
//=============================================================
bool CCScrollLayer::initWithColorWidthHeight(const Color4B color, GLfloat width, GLfloat height)
{
CCLayerColor::initWithColor(color, width, height);
setTouchEnabled(true);
setTouchMode(Touch::DispatchMode::ONE_BY_ONE);
m_contentLayer = CCLayer::create();
m_contentLayer->setAnchorPoint(Point(0,0));
m_contentLayer->setPosition(Point(0,0));
addChild(m_contentLayer);
//滑动条
m_scrollDotVSprite = CCSprite::create("scroll_dot.png");
//m_scrollDotVSprite->setAnchorPoint(Point(0.5,0));
Size size = getContentSize();
Size dotSize = m_scrollDotVSprite->getContentSize();
m_scrollDotVSprite->setPosition(Point(size.width-dotSize.width,size.height-dotSize.height));
addChild(m_scrollDotVSprite);
m_scrollDotHSprite = CCSprite::create("scroll_dot.png");
//m_scrollDotHSprite->setAnchorPoint(Point(0.5,0));
m_scrollDotHSprite->setPosition(Point(0,0));
m_scrollDotHSprite->setPosition(Point(dotSize.width,dotSize.height));
addChild(m_scrollDotHSprite);
m_scrollDotVSprite->setVisible(false);
m_scrollDotHSprite->setVisible(false);
m_scrollDotVSprite->setOpacity(255*0.5);
m_scrollDotHSprite->setOpacity(255*0.5);
setScrollContentSize(getContentSize());
setPageSize(getContentSize());
Point position = Point(0,m_contentLayer->getContentSize().height - getContentSize().height);
setContentOffset(position,false);
m_pageColumnsIndex = (m_contentLayer->getContentSize().height-1)/m_pageSize.height;
return true;
}
void GridView::onDrawCellViewH()
{
if (0 >= _cellCounts) return;
_rows = (_cellCounts % _cols == 0) ? _cellCounts / _cols : ceil(_cellCounts / _cols) + 1;
float fHeight = _contentSize.height;
float fWidth = _cols * _cellSize.width;
_cellSize.width = (_contentSize.width - (_cols - 1) * GRID_CELL_MARGIN) / _cols;
fWidth = std::max(_rows * _cellSize.width + (_rows - 1) * GRID_CELL_MARGIN, _contentSize.width);
_container->setContentSize(Size(fWidth, fHeight));
int nBeginRow(0)/*, nEndRow(0)*/;
// Vec2 Offset = getContentOffset();
// nBeginRow = cellBeginRowFromOffset(Offset);
// nEndRow = cellEndRowFromOffset(Offset);
int idx(0);
for(int row = nBeginRow; row < _rows; ++row)
{
if (idx < _cellCounts)
{
if( _idxIndices.find(idx) == _idxIndices.end() )
{
updateCellAtIndex(idx, row);
}
}
if (_rows - 1 == row && idx < _cellCounts)
{
row = -1;
}
idx++;
}
if (_container->getContentSize().height > _viewSize.width)
{
setContentOffset(Vec2(_viewSize.width - _container->getContentSize().width, 0));
}
}
void GridView::onDrawCellViewV()
{
if (0 >= _cellCounts) return;
_rows = (_cellCounts % _cols == 0) ? _cellCounts / _cols : ceil(_cellCounts / _cols) + 1;
float fHeight = _contentSize.height;
float fWidth = _cols * _cellSize.width;
_cellSize.width = (_contentSize.width - (_cols - 1) * GRID_CELL_MARGIN) / _cols;
fHeight = std::max(_rows * _cellSize.height + (_rows - 1) * GRID_CELL_MARGIN, _contentSize.height);
_container->setContentSize(Size(fWidth, fHeight));
int nBeginRow(0)/*, nEndRow(0) */;
// Vec2 Offset = getContentOffset();
// nBeginRow = cellBeginRowFromOffset(Offset);
// nEndRow = cellEndRowFromOffset(Offset);
for(int row = nBeginRow; /*row <= nEndRow && */ row < _rows; ++row)
{
int nCellBeginIndex = _cols * row;
int nCellEndIndx = nCellBeginIndex + _cols;
int idx = nCellBeginIndex;
for(; idx < nCellEndIndx && idx < _cellCounts; ++idx)
{
if( _idxIndices.find(idx) != _idxIndices.end() )
{
continue;
}
updateCellAtIndex(idx, row);
}
}
if (_container->getContentSize().height > _viewSize.height)
{
setContentOffset(Vec2(0, _viewSize.height - _container->getContentSize().height));
}
}
//=============================================================
//=============================================================
void CCScrollLayer::setScrollContentSize(Size contentSize)
{
m_contentLayer->setContentSize(contentSize);
Point position = Point(0,m_contentLayer->getContentSize().height - getContentSize().height);
setContentOffset(position,false);
Size size = getContentSize();
if(contentSize.width < size.width) contentSize.width = size.width;
if(contentSize.height < size.height) contentSize.height = size.height;
m_contentLayer->setContentSize(contentSize);
if(m_contentLayer->getContentSize().width > getContentSize().width) //横竖是否可移动
{
m_HMoveAbleFlag = true;
m_bShowHDot = true;
}
if(m_contentLayer->getContentSize().height > getContentSize().height)
{
m_VMoveAbleFlag = true;
m_bShowVDot = true;
}
//设置边条长度
refreshDotPosition();
}
void WHScrollView::onTouchMoved(cocos2d::Touch *pTouch, cocos2d::Event *pEvent)
{
if (m_PointerId != pTouch->getID())
return;
if (m_MoveCount < 8)
m_MoveCount++;
//CCScrollView::ccTouchMoved(pTouch, pEvent);
if (!isVisible())
return;
if (m_bScroll)
{
//if (_touches->containsObject(pTouch))
if (std::find(_touches.begin(), _touches.end(), pTouch) != _touches.end())
{
if (_touches.size() == 1 && _dragging)
{ // scrolling
CCPoint moveDistance, newPoint, maxInset, minInset;
CCRect frame;
float newX, newY;
_touchMoved = true;
CCPoint frameOriginal = getParent()->convertToWorldSpace(getPosition());
//frame = CCRectMake(frameOriginal.x, frameOriginal.y, m_tViewSize.width, m_tViewSize.height);
frame = CCRectMake(0, 0, _viewSize.width, _viewSize.height);
newPoint = convertTouchToNodeSpace((CCTouch*)_touches[0]);
moveDistance = ccpSub(newPoint, _touchPoint);
_touchPoint = newPoint;
CCSize contentsize = getContentSize();
CCPoint offset = getContentOffset();
if (offset.y <= _viewSize.height - contentsize.height)
{
moveDistance.y = moveDistance.y / m_MoveCount;
}
//if (frame.containsPoint(convertToWorldSpace(newPoint)))
if (frame.containsPoint(newPoint))
{
switch (_direction)
{
case ScrollView::Direction::VERTICAL:
moveDistance = ccp(0.0f, moveDistance.y);
break;
case ScrollView::Direction::HORIZONTAL:
moveDistance = ccp(moveDistance.x, 0.0f);
break;
default:
break;
}
_container->setPosition(ccpAdd(_container->getPosition(), moveDistance));
maxInset = _maxInset;
minInset = _minInset;
//check to see if offset lies within the inset bounds
newX = MIN(_container->getPosition().x, maxInset.x);
newX = MAX(newX, minInset.x);
newY = MIN(_container->getPosition().y, maxInset.y);
newY = MAX(newY, minInset.y);
_scrollDistance = ccpSub(moveDistance, ccp(newX - _container->getPosition().x, newY - _container->getPosition().y));
setContentOffset(ccp(newX, newY));
}
}
else if (_touches.size() == 2 && !_dragging)
{
const float len = ccpDistance(_container->convertTouchToNodeSpace((CCTouch*)_touches[0]),_container->convertTouchToNodeSpace((CCTouch*)_touches[1]));
setZoomScale(getZoomScale()*len / _touchLength);
}
}
}
for (int i = 0; i < m_TouchLayer.size(); i++)
{
if (m_TouchLayerTouched[i])
{
CCLayer* pTouchLayer = m_TouchLayer[i];
pTouchLayer->ccTouchMoved(pTouch, pEvent);
}
}
//CCScrollView::ccTouchMoved(pTouch, pEvent);
}
// on "init" you need to initialize your instance
bool ReadyScene::init()
{
//////////////////////////////
// 1. super init first
if (!Layer::init())
{
return false;
}
Singleton<WeaponDB>::getInstance();
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("clotharmor.plist");
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("thunder.plist");
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("ogre.plist");
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("pikachu.plist");
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("thunder_effect.plist");
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
s = nullptr;
auto backgroundSprite = Sprite::create("start_background.png");
backgroundSprite->setPosition(Point(visibleSize.width / 2 + origin.x, visibleSize.height / 2 + origin.y));
backgroundSprite->setScale(3);
this->addChild(backgroundSprite);
auto tmap = TMXTiledMap::create("StartMap.tmx");
gamemap = new GameMap(tmap);
player = new Player(this, gamemap);
player->getSpriteObject()->setScale(1.5f);
player->getSprite()->setPosition(Point(visibleSize.width * 7 / 24, visibleSize.height /2));
s = new Weapon(1);
player->setWeapon(s);
MenuItemImage* PlayMenu = MenuItemImage::create("play_button1.png", "play_button2.png", CC_CALLBACK_1(ReadyScene::onMenu, this));
PlayMenu->setScale(2.5f);
Menu* menu = Menu::create(PlayMenu, NULL);
menu->setPosition(visibleSize.width * 0.3f, visibleSize.height * 0.3f);
this->addChild(menu, 1);
MenuItemImage* LeftButton = MenuItemImage::create("left_button1.png", "left_button2.png", CC_CALLBACK_1(ReadyScene::onLeftButton, this));
LeftButton->setScale(2.5f);
Menu* left_bt = Menu::create(LeftButton, NULL);
left_bt->setPosition(Point(visibleSize.width / 6, visibleSize.height / 2));
this->addChild(left_bt, 1);
MenuItemImage* RightButton = MenuItemImage::create("right_button1.png", "right_button2.png", CC_CALLBACK_1(ReadyScene::onRightButton, this));
RightButton->setScale(2.5f);
Menu* right_bt = Menu::create(RightButton, NULL);
right_bt->setPosition(Point(visibleSize.width * 3 / 7, visibleSize.height / 2));
this->addChild(right_bt, 1);
auto weapon_sprite = Sprite::create("weapon_font.png");
weapon_sprite->setScale(2.0f);
weapon_sprite->setPosition(Point(visibleSize.width * 0.55f, visibleSize.height * 0.75f));
this->addChild(weapon_sprite);
auto scrollView = ScrollView::create(Size(Singleton<WeaponDB>::getInstance()->getWeaponDBSize() * 48, 48));
scrollView->setDirection(ScrollView::Direction::HORIZONTAL);
scrollView->setContentOffset(Vec2(0, 0));
scrollView->setContentOffsetInDuration(Vec2(0, 0), 10.f);
scrollView->setPosition(Point(visibleSize.width * 0.5f, visibleSize.height * 0.6f));
this->addChild(scrollView);
MenuItemImage *test;
Menu *menutest;
for (int i = 1; i <= Singleton<WeaponDB>::getInstance()->getWeaponDBSize(); i++)
{
std::string str = StringUtils::format("%s_menu.png", Singleton<WeaponDB>::getInstance()->getWeaponData(i).path.c_str());
test = MenuItemImage::create(str, str, CC_CALLBACK_1(ReadyScene::test2, this));
test->setScale(2.5f);
test->setTag(i);
menutest = ScrollMenu::create(test, NULL);
menutest->setPosition(Point((48 * i), 20));
scrollView->addChild(menutest);
}
this->schedule(schedule_selector(ReadyScene::gameLogic), 0.2);
return true;
}
void TestList::runThisTest()
{
_cellTouchEnabled = true;
auto director = Director::getInstance();
auto scene = Scene::create();
auto visibleSize = director->getVisibleSize();
auto origin = director->getVisibleOrigin();
auto tableView = TestCustomTableView::create(this, Size(400, visibleSize.height));
tableView->setPosition(origin.x + (visibleSize.width - 400) / 2, origin.y);
tableView->setDirection(ScrollView::Direction::VERTICAL);
tableView->setVerticalFillOrder(TableView::VerticalFillOrder::TOP_DOWN);
tableView->setDelegate(this);
scene->addChild(tableView);
tableView->reloadData();
if (_shouldRestoreTableOffset)
{
tableView->setContentOffset(_tableOffset);
}
if (_parentTest)
{
//Add back button.
TTFConfig ttfConfig("fonts/arial.ttf", 20);
auto label = Label::createWithTTF(ttfConfig, "Back");
auto menuItem = MenuItemLabel::create(label, std::bind(&TestBase::backsUpOneLevel, this));
auto menu = Menu::create(menuItem, nullptr);
menu->setPosition(Vec2::ZERO);
menuItem->setPosition(Vec2(VisibleRect::right().x - 50, VisibleRect::bottom().y + 25));
scene->addChild(menu, 1);
}
else
{
//Add close and "Start AutoTest" button.
auto closeItem = MenuItemImage::create(s_pathClose, s_pathClose, [](Ref* sender){
TestController::getInstance()->stopAutoTest();
TestController::destroyInstance();
Director::getInstance()->end();
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
exit(0);
#endif
});
closeItem->setPosition(VisibleRect::right().x - 30, VisibleRect::top().y - 30);
auto autoTestLabel = Label::createWithTTF("Start AutoTest","fonts/arial.ttf",16);
auto autoTestItem = MenuItemLabel::create(autoTestLabel, [&](Ref* sender){
TestController::getInstance()->startAutoTest();
});
autoTestItem->setPosition(Vec2(VisibleRect::right().x - 70, VisibleRect::bottom().y + 25));
auto menu = Menu::create(closeItem, autoTestItem, nullptr);
menu->setPosition(Vec2::ZERO);
scene->addChild(menu, 1);
}
director->replaceScene(scene);
}
void WXTableView::nextPageDeaccelerateScrolling(float dt)
{
if (_dragging)
{
this->unschedule(schedule_selector(WXTableView::nextPageDeaccelerateScrolling));
return;
}
CCPoint scrollDistance = CCPoint::ZERO;
CCPoint oldContainerPos = _container->getPosition();
CCPoint newContainerPos;
bool isUnschedule = false;
switch (this->getDirection())
{
case ScrollView::Direction::HORIZONTAL:
{
scrollDistance.x = m_fNextPageSpeed*dt;
if (m_desire_containerPos_nextPage.x-oldContainerPos.x<0)
{
scrollDistance.x = -scrollDistance.x;
}
newContainerPos = ccpAdd(oldContainerPos, scrollDistance);
if ((oldContainerPos.x<=m_desire_containerPos_nextPage.x && newContainerPos.x>=m_desire_containerPos_nextPage.x)\
|| (oldContainerPos.x>=m_desire_containerPos_nextPage.x && newContainerPos.x<=m_desire_containerPos_nextPage.x))
{
isUnschedule = true;
}
}
break;
default:
{
scrollDistance.y = m_fNextPageSpeed*dt;
if (m_desire_containerPos_nextPage.y-oldContainerPos.y<0)
{
scrollDistance.y = -scrollDistance.y;
}
newContainerPos = ccpAdd(oldContainerPos, scrollDistance);
if ((oldContainerPos.y<=m_desire_containerPos_nextPage.y && newContainerPos.y>=m_desire_containerPos_nextPage.y)\
|| (oldContainerPos.y>=m_desire_containerPos_nextPage.y && newContainerPos.y<=m_desire_containerPos_nextPage.y))
{
isUnschedule = true;
}
}
break;
}
if (isUnschedule)
{
this->unschedule(schedule_selector(WXTableView::nextPageDeaccelerateScrolling));
this->nextpageRelocateContainer(false);
}
else
{
CCPoint maxInset, minInset;
if (_bounceable)
{
maxInset = _maxInset;
minInset = _minInset;
}
else
{
maxInset = this->maxContainerOffset();
minInset = this->minContainerOffset();
}
float newX, newY;
newX = MIN(newContainerPos.x, maxInset.x);
newX = MAX(newX, minInset.x);
newY = MIN(newContainerPos.y, maxInset.y);
newY = MAX(newY, minInset.y);
_container->setPosition(newContainerPos);
setContentOffset(ccp(newX, newY));
}
}
