void AssetsUpdateLayer::updateLayerMessageBox()
{
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("ccb/ccbResources/SystemLoading.plist");
CCLayer* layer = CCLayer::create();
layer->ignoreAnchorPointForPosition(false);
layer->setContentSize(Size(960, 640));
layer->setPosition(Point(Director::getInstance()->getWinSize().width * 0.5, Director::getInstance()->getWinSize().height * 0.5));
layer->setScale(Director::getInstance()->getWinSize().width / 960);
addChild(layer, 1);
Sprite* messageboxSprite = Sprite::createWithSpriteFrameName("set_floor_v1.png");
messageboxSprite->setPosition(Point(480, 320));
layer->addChild(messageboxSprite, 1);
LabelTTF* labelContent = LabelTTF::create(Localization::getInstance()->getValueByKey("Loading_warning_need_update"), "Helvetica",32);
labelContent->setPosition(Point(480, 420));
layer->addChild(labelContent, 1);
ControlButton* btn = ControlButton::create(LabelTTF::create(Localization::getInstance()->getValueByKey("BUTTON_DONE"), "Helvetica", 32), Scale9Sprite::createWithSpriteFrameName("set_button2.png"));
btn->setPreferredSize(CCSize(191,70));
btn->setPosition(Point(480, 220));
btn->addTargetWithActionForControlEvents(this, cccontrol_selector(AssetsUpdateLayer::GoToAppPage), Control::EventType::TOUCH_UP_INSIDE);
layer->addChild(btn, 1);
}
ControlButton* ControlButton::create(Node* label, Scale9Sprite* backgroundSprite)
{
ControlButton *pRet = new ControlButton();
pRet->initWithLabelAndBackgroundSprite(label, backgroundSprite);
pRet->autorelease();
return pRet;
}
ControlButton* ControlButton::create(Scale9Sprite* sprite)
{
ControlButton *pRet = new ControlButton();
pRet->initWithBackgroundSprite(sprite);
pRet->autorelease();
return pRet;
}
ControlButton* ControlButton::create(string title, const char * fontName, float fontSize)
{
ControlButton *pRet = new ControlButton();
pRet->initWithTitleAndFontNameAndFontSize(title, fontName, fontSize);
pRet->autorelease();
return pRet;
}
void GamepadPage::DetectControl(wxCommandEvent& event)
{
ControlButton* btn = (ControlButton*)event.GetEventObject();
// find device :/
Device* const dev = g_controller_interface.FindDevice(controller->default_device);
if (dev)
{
btn->SetLabel(_("[ waiting ]"));
// apparently, this makes the "waiting" text work on Linux
wxTheApp->Yield();
std::lock_guard<std::recursive_mutex> lk(m_plugin.controls_lock);
Device::Control* const ctrl = btn->control_reference->Detect(DETECT_WAIT_TIME, dev);
// if we got input, update expression and reference
if (ctrl)
{
wxString control_name = ctrl->GetName();
wxString expr;
GetExpressionForControl(expr, control_name);
btn->control_reference->expression = expr;
g_controller_interface.UpdateReference(btn->control_reference, controller->default_device);
}
}
UpdateGUI();
}
void ChoiceLayer::choicesCallback(Ref* sender, Control::EventType event)
{
ControlButton *pressedBtn = (ControlButton*)sender;
_selectedTag = pressedBtn->getTag();
CCLOG("Select tag : %d", _selectedTag);
for (auto child : getChildren())
child->setOpacity(0);
}
ControlButton* standardButtonWithTitle( const char * bgname, const char * bgseledname, const char * title){
//Creates and return a button with a default background and title color.
// Scale9Sprite *backgroundButton = Scale9Sprite::create(bgname);//按下前
// Scale9Sprite *backgroundHighlightedButton = Scale9Sprite::create(bgseledname);//按下后
ControlButton* btn = ControlButton::create();
btn->setPreferredSize(Size(522, 88));
Scale9Sprite* normal = Scale9Sprite::create(bgname);
Scale9Sprite* select = Scale9Sprite::create(bgseledname);
Scale9Sprite* hightlight = Scale9Sprite::create(bgseledname);
Scale9Sprite* disable = Scale9Sprite::create(bgname);
btn->setBackgroundSpriteForState(normal, Control::State::NORMAL);
btn->setBackgroundSpriteForState(select, Control::State::SELECTED);
btn->setBackgroundSpriteForState(hightlight, Control::State::HIGH_LIGHTED);
btn->setBackgroundSpriteForState(disable, Control::State::DISABLED);
LabelTTF *titleButton = LabelTTF::create(title, "AmericanTypewriter", 30);//添加文字
titleButton->setAnchorPoint(Point(0.5f, 0.5f));
titleButton->setPosition(Point(btn->getContentSize().width/2, btn->getContentSize().height/2));
titleButton->setColor(Color3B::BLACK);//设置文字点击前的颜色
titleButton->setTag(1000);
btn->addChild(titleButton);
return btn;
}
ControlButton* ControlButton::create()
{
ControlButton *pControlButton = new ControlButton();
if (pControlButton && pControlButton->init())
{
pControlButton->autorelease();
return pControlButton;
}
CC_SAFE_DELETE(pControlButton);
return nullptr;
}
void TDDSubMenu::setupHeader(const Color4B &headerColor)
{
GLfloat parentH = this->getContentSize().height;
GLfloat width = this->getContentSize().width;
GLfloat height = kHeaderHeight;
LayerColor *headerLayer = LayerColor::create(headerColor, width, height);
Point pos = Point(0, parentH - height);
headerLayer->setPosition(pos);
this->addChild(headerLayer);
// Setting Buttons
float scale = TDDHelper::getBestScale();
// Size screenSize = TDDHelper::getScreenSize();
int midY = height/2;
int buttonW = (int)(scale * 50);
int buttonH = height;
int leftButtonX = buttonW / 2;
int rightButtonX = width - leftButtonX;
int midX = width/2;
Size size = Size(buttonW, buttonH);
ControlButton *button;
pos.x = leftButtonX;
pos.y = midY;
button = createButton("back", kActionTagBack, pos, size);
headerLayer->addChild(button);
mBackButton = button;
pos.x = rightButtonX;
pos.y = midY;
button = createButton("hide", kActionTagToggle, pos, size);
headerLayer->addChild(button);
button->addTargetWithActionForControlEvents(this,
cccontrol_selector(TDDSubMenu::touchUpInsideAction),
Control::EventType::TOUCH_UP_INSIDE);
mToggleButton = button;
// Label
Label *title = Label::createWithSystemFont("MENU", "Arial", 15);
title->setColor(Color3B::WHITE);
title->setPosition(Point(midX, midY));
headerLayer->addChild(title);
//
mHeaderLayer = headerLayer;
}
bool LoginScene::init()
{
if (!Layer::init())
return false;
Size winSize = Director::getInstance()->getWinSize();
auto pBckSprite = Scale9Sprite::create("green_edit.png");
addChild(pBckSprite);
pBckSprite->setPosition(Vec2(winSize.width / 2, winSize.height / 2 + 25));
pBckSprite->setContentSize(Size(winSize.width / 2, 35));
m_txtUserName = ui::TextField::create(StringResUtil::instance()->getStringForKey("username"), "Arial",30);
m_txtUserName->setPlaceHolderColor(Color4B::WHITE);
m_txtUserName->setTextColor(Color4B::WHITE);
addChild(m_txtUserName);
m_txtUserName->setPosition(Vec2(winSize.width / 2, winSize.height / 2 + 25));
auto pPwdBckSprite = Scale9Sprite::create("green_edit.png");
addChild(pPwdBckSprite);
pPwdBckSprite->setPosition(Vec2(winSize.width / 2, winSize.height / 2 - 25));
pPwdBckSprite->setContentSize(Size(winSize.width / 2, 35));
m_txtPassword = ui::TextField::create(StringResUtil::instance()->getStringForKey("password"), "Arial",30);
m_txtPassword->setPlaceHolderColor(Color4B::WHITE);
m_txtPassword->setTextColor(Color4B::WHITE);
m_txtPassword->setPasswordEnabled(true);
addChild(m_txtPassword);
m_txtPassword->setPosition(Vec2(winSize.width / 2, winSize.height / 2 - 25));
/*auto starMenuItem = MenuItemImage::create(
"button.png",
"button.png", CC_CALLBACK_1(LoginScene::starMenuCallback, this));
starMenuItem->setPosition(Point::ZERO);
starMenuItem->setContentSize(Size(80, 30));
auto starMenu = Menu::create(starMenuItem, NULL);
starMenu->setPosition(Point(winSize.width / 2, winSize.height / 2 - 80));
this->addChild(starMenu, 1);*/
LabelTTF *label = LabelTTF::create("login", "Marker Felt", 30);
Scale9Sprite *normalBck = Scale9Sprite::create("button.png");
ControlButton *button = ControlButton::create(label, normalBck);
button->setContentSize(Size(80, 30));
button->setPosition(Point(winSize.width / 2, winSize.height / 2 - 80));
button->addTargetWithActionForControlEvents(this, cccontrol_selector(LoginScene::touchDown), Control::EventType::TOUCH_DOWN);
addChild(button);
return true;
}
ControlButton *ControlButtonTest_HelloVariableSize::standardButtonWithTitle(const char * title)
{
/** Creates and return a button with a default background and title color. */
auto backgroundButton = ui::Scale9Sprite::create("extensions/button.png");
auto backgroundHighlightedButton = ui::Scale9Sprite::create("extensions/buttonHighlighted.png");
auto titleButton = Label::createWithTTF(title, "fonts/Marker Felt.ttf", 30);
titleButton->setColor(Color3B(159, 168, 176));
ControlButton *button = ControlButton::create(titleButton, backgroundButton);
button->setBackgroundSpriteForState(backgroundHighlightedButton, Control::State::HIGH_LIGHTED);
button->setTitleColorForState(Color3B::WHITE, Control::State::HIGH_LIGHTED);
return button;
}
void SpineTest::changeAnime(Object *sender, Control::EventType type)
{
if(mAnime == NULL) {
log("mAnime is NULL");
return;
}
//
ControlButton *button = dynamic_cast<ControlButton *>(sender);
if(button == NULL) {
return;
}
//
int tag = button->getTag();
switch(tag) {
case kTagButtonWalk:
{
log("walk");
mAnime->setAnimation(0, "walk", true);
break;
}
case kTagButtonJump:
{
log("jump");
mAnime->setAnimation(0, "jump", true);
break;
}
case kTagButtonHurt:
{
log("hurt");
mAnime->setAnimation(0, "hurt", true);
break;
}
case kTagButtonIdle:
{
log("idle");
mAnime->setAnimation(0, "idle", true);
break;
}
}
}
bool UndercoverGameScene::init()
{
if ( !Layer::init() )
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
ControlButton* back = ControlButton::create("Back", "Arial", 40);
back->addTargetWithActionForControlEvents(this, cccontrol_selector(UndercoverGameScene::buttonBack), Control::EventType::TOUCH_UP_INSIDE);
back->setAnchorPoint(Point(0.5,0.5));
back->setZoomOnTouchDown(true);
back->setPosition(Vec2(visibleSize.width - 100,
visibleSize.height - 100));
this->addChild(back, 1);
return true;
}
void GameScene::answerAnimation( int answerIndex){
GameAnswerState st;
ControlButton* btn;
switch ( answerIndex ) {
case 1:
// st = answerOneState_;
btn = btn1;
break;
case 2:
// st = answerTwoState_;
btn = btn2;
break;
case 3:
// st = answerThreeState_;
btn = btn3;
break;
case 4:
// st = answerFouState_;
btn = btn4;
break;
default:
break;
}
st = answerStateArr_[ answerIndex - 1];
std::string correctwrongImgStr;
if ( st == GameStateAnswerStateRight ) {
//right
correctwrongImgStr = "play_correct.png";
}else{
correctwrongImgStr = "play_wrong.png";
}
btn->setEnabled(false);
Sprite* sp = Sprite::create(correctwrongImgStr);
sp->setPosition( Point( btn->getPositionX() - btn->getContentSize().width/2 + sp->getContentSize().width, btn->getPositionY()));
this->addChild(sp);
// CCLabelBMFont* label = CCLabelBMFont::create("23","prim30.fnt");
// label->setColor(Color3B::BLACK);
// label->setPosition(sp->getPosition());
// this->addChild(label);
}
ControlButton *AboutLayer::standardButtonWithTitle(const std::string& string)
{
/** Creates and return a button with a default background and title color. */
auto backgroundButton = Scale9Sprite::create("button.png");
auto backgroundHighlightedButton = Scale9Sprite::create("buttonHighlighted.png");
auto titleButton = LabelTTF::create(string, "Marker Felt", 50);
//auto label = LabelTTF::create("中国", "Marker Felt", 30);
titleButton->setColor(Color3B(159, 168, 176));
ControlButton *button = ControlButton::create(titleButton, backgroundButton);
button->setBackgroundSpriteForState(backgroundHighlightedButton, Control::State::HIGH_LIGHTED);
button->setTitleColorForState(Color3B::WHITE, Control::State::HIGH_LIGHTED);
button->addTargetWithActionForControlEvents(this, cccontrol_selector(AboutLayer::touchUpInsideAction), Control::EventType::TOUCH_UP_INSIDE);
this->addChild(button);
return button;
}
void SkillTableView::onTouchMoved(Touch *pTouch, Event *pEvent)
{
Point point = pTouch->getLocation();
if (m_pEditingSkill == NULL)
return;
m_pEditingSkill->setPosition(point);
if (m_pEditingBtn)
{
Rect rect;
rect.origin = m_pEditingBtn->convertToWorldSpace(Point::ZERO);
rect.size = m_pEditingBtn->getContentSize();
if (!rect.containsPoint(point))
{
m_pEditingSkill->setOpacity(127);
m_pEditingBtn->stopAllActions();
ScaleTo* scaleTo = ScaleTo::create(0.1f, 1.0f);
m_pEditingBtn->runAction(scaleTo);
m_pEditingBtn = NULL;
}
}
if (m_pEditingBtn == NULL)
{
for (unsigned int i=0; i<3; i++)
{
ControlButton* btn = GAME_UILAYER->getOperationMenu()->getSkillAttackBtn(i);
Rect rect;
rect.origin = btn->convertToWorldSpace(Point::ZERO);
rect.size = btn->getContentSize();
if (rect.containsPoint(point))
{
m_pEditingSkill->setOpacity(255);
m_pEditingBtn = btn;
m_pEditingBtn->stopAllActions();
ScaleTo* scaleTo = ScaleTo::create(0.1f, 1.1f);
m_pEditingBtn->runAction(scaleTo);
break;
}
}
}
}
void PropColumnMenu::onTouchMoved(Touch *pTouch, Event *pEvent)
{
Point point = pTouch->getLocation();
m_editProp->setPosition(point);
do
{
ControlButton* btn = GAME_UILAYER->getOperationMenu()->getDrugsBtn();
Rect rect;
rect.origin = btn->convertToWorldSpace(Point::ZERO);
rect.size = btn->getContentSize();
if (rect.containsPoint(point))
{
CC_BREAK_IF(m_editProp->getOpacity() == 255);
m_editProp->setOpacity(255);
btn->stopAllActions();
ScaleTo* scaleTo = ScaleTo::create(0.1f, 1.1f);
btn->runAction(scaleTo);
}
else
{
CC_BREAK_IF(m_editProp->getOpacity() == 127);
m_editProp->setOpacity(127);
btn->stopAllActions();
ScaleTo* scaleTo = ScaleTo::create(0.1f, 1.0f);
btn->runAction(scaleTo);
}
}
while (0);
}
bool SkillTableView::init()
{
if (!Node::init())
return false;
LayerColor* bg = LayerColor::create(Color4B(255, 255, 255, 127), 450, 500);
bg->setPosition(bg->getContentSize()/-2);
this->addChild(bg, -1);
CCLabelTTF* title = CCLabelTTF::create("技能列表", "fonts/Marker Felt.ttf", 40);
title->setPosition(Point(bg->getContentSize().width/2, bg->getContentSize().height-30));
bg->addChild(title);
ControlButton* button = ControlButton::create(Scale9Sprite::create("ui/closed_normal.png"));
button->setBackgroundSpriteForState(Scale9Sprite::create("ui/closed_selected.png"), Control::State::HIGH_LIGHTED);
button->setPreferredSize(Size(57, 58));
button->setPosition(ccpSub(ccpAdd(bg->getPosition(), bg->getContentSize()), button->getContentSize()/2));
this->addChild(button);
button->addTargetWithActionForControlEvents(GAME_UILAYER, cccontrol_selector(GameInfoUIController::removeSmallMenuAndButton), Control::EventType::TOUCH_UP_INSIDE);
// button->setTouchPriority(0);
m_skillTableView = TableView::create(this, Size(420, 420));
m_skillTableView->setPosition(Point(15, 15));
// m_skillTableView->setDirection(kCCScrollViewDirectionVertical);
m_skillTableView->setDelegate(this);
// m_skillTableView->setVerticalFillOrder(kCCTableViewFillTopDown);
bg->addChild(m_skillTableView);
m_skillTableView->reloadData();
return true;
}
bool PropColumnMenu::init()
{
if (!Layer::init())
return false;
this->setTouchEnabled(true);
Sprite* bg = Sprite::create("ui/prop_column.png");
this->addChild(bg);
m_propColumn = LayerColor::create(ccc4(255, 255, 255, 0), GRID_WIDTH*COL, GRID_HEIGHT*ROW);
m_propColumn->setContentSize(Size(GRID_WIDTH*COL, GRID_HEIGHT*ROW));
m_propColumn->setPosition(Point(PROP_X, PROP_Y));
bg->addChild(m_propColumn);
ControlButton* button = ControlButton::create(ui::Scale9Sprite::create("ui/closed_normal.png"));
button->setBackgroundSpriteForState(ui::Scale9Sprite::create("ui/closed_selected.png"), Control::State::HIGH_LIGHTED);
button->setPreferredSize(Size(57, 58));
button->setPosition(ccpSub(ccpAdd(bg->getPosition(), bg->getContentSize()/2), button->getContentSize()/2));
this->addChild(button);
button->addTargetWithActionForControlEvents(GAME_UILAYER, cccontrol_selector(GameInfoUIController::removeSmallMenuAndButton), Control::EventType::TOUCH_UP_INSIDE);
// button->setTouchPriority(0);
for (int i=0; i<12; i++)
{
m_propVec[i] = PropIconShow::create(PropSystem::getPropInfo(i+1));
m_propColumn->addChild(m_propVec[i]);
}
return true;
}
ControlButton *TDDSubMenu::createButton(const std::string &name, int tag,
const Point &pos, const Size &size)
{
Color3B colorNormal = Color3B::WHITE;
//Color3B colorSelected = colorNormal;
Scale9Sprite *bgButton = Scale9Sprite::create();
Scale9Sprite *bgHiliButton = Scale9Sprite::create();
// bgButton->setContentSize(Size(200, 50));
Label *titleButton = Label::createWithSystemFont(name.c_str(), "Arial", 15);
titleButton->setColor(colorNormal);
ControlButton *button = ControlButton::create(titleButton, bgButton);
button->setBackgroundSpriteForState(bgHiliButton, Control::State::HIGH_LIGHTED);
TDDHelper::setAlphaPremultiplied(button);
button->setTag(tag);
button->setContentSize(size);
button->setPosition(pos);
button->setSelected(false);
return button;
}
bool CGamePanelLayer::init()
{
do
{
BREAK_IF(!Layer::init());
ControlButton* btnBuild = CBaseLayer::createImageButton("huds/build.png");
BREAK_IF(!btnBuild);
btnBuild->setPosition(Point(240, 50));
btnBuild->addTargetWithActionForControlEvents(this, cccontrol_selector(CGamePanelLayer::onBuild), Control::EventType::TOUCH_UP_INSIDE);
addChild(btnBuild);
// ControlButton* btnBuild2 = CBaseLayer::createImageButton("build");
// BREAK_IF(!btnBuild2);
// btnBuild2->setPosition(Point(270, 50));
// btnBuild2->addTargetWithActionForControlEvents(this, cccontrol_selector(CGamePanelLayer::onBuild2), CCControlEventTouchUpInside);
// addChild(btnBuild2);
return true;
} while (false);
return false;
}
void TDDSubMenu::touchUpInsideAction(Ref *sender, Control::EventType controlEvent)
{
ControlButton *button = (ControlButton *)sender;
log("Button is clicked");
int tag = button->getTag();
switch(tag) {
case kActionTagToggle:
{
toggleMenu();
break;
}
case kActionTagBack:
{
closeTest();
break;
}
}
}
void SpineTest::testChangeAnimation(Object *sender)
{
log("testChangeAnimation");
// Setting the Animation
SkeletonAnimation *node = SkeletonAnimation::createWithFile("player.json", "player.atlas");
node->setAnimation(0, "walk", true);
node->setPosition(Point(200, 120));
node->setTag(kTagSpinePlayer);
addChild(node);
mAnime = node;
// Setting the buttons
std::vector<Node *> nodeArray;
ControlButton *button;
button = GUIHelper::createButton("Walk", this, cccontrol_selector(SpineTest::changeAnime), Point(0, 0));
button->setTag(kTagButtonWalk);
nodeArray.push_back(button);
button = GUIHelper::createButton("Jump", this, cccontrol_selector(SpineTest::changeAnime), Point(0, 0));
button->setTag(kTagButtonJump);
nodeArray.push_back(button);
button = GUIHelper::createButton("Hurt", this, cccontrol_selector(SpineTest::changeAnime), Point(0, 0));
button->setTag(kTagButtonHurt);
nodeArray.push_back(button);
button = GUIHelper::createButton("Idle", this, cccontrol_selector(SpineTest::changeAnime), Point(0, 0));
button->setTag(kTagButtonIdle);
nodeArray.push_back(button);
GUIHelper::addNodesToParent(this, nodeArray, 0, 50, 480, 10);
// hide the menu
hideMenu();
}
bool ControlButtonTest_Styling::init()
{
if (ControlScene::init())
{
auto screenSize = Director::getInstance()->getWinSize();
auto layer = Node::create();
addChild(layer, 1);
int space = 10; // px
double max_w = 0, max_h = 0;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
// Add the buttons
ControlButton *button = standardButtonWithTitle(StringUtils::format("%d",rand() % 30).c_str());
button->setAdjustBackgroundImage(false); // Tells the button that the background image must not be adjust
// It'll use the prefered size of the background image
button->setPosition(button->getContentSize().width / 2 + (button->getContentSize().width + space) * i,
button->getContentSize().height / 2 + (button->getContentSize().height + space) * j);
layer->addChild(button);
max_w = MAX(button->getContentSize().width * (i + 1) + space * i, max_w);
max_h = MAX(button->getContentSize().height * (j + 1) + space * j, max_h);
}
}
layer->setAnchorPoint(Vec2(0.5, 0.5));
layer->setContentSize(Size(max_w, max_h));
layer->setPosition(screenSize.width / 2.0f, screenSize.height / 2.0f);
// Add the black background
auto backgroundButton = ui::Scale9Sprite::create("extensions/buttonBackground.png");
backgroundButton->setContentSize(Size(max_w + 14, max_h + 14));
backgroundButton->setPosition(screenSize.width / 2.0f, screenSize.height / 2.0f);
addChild(backgroundButton);
return true;
}
return false;
}
ControlButton* ButtonUtils::createButton(const char *normalFrame,
const char *highLightFrame,
const char *disableFrame,
cocos2d::Size size,
const char *label,
float labelSize,
Color3B labelColor)
{
Scale9Sprite *normal = Scale9Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName(normalFrame));
Scale9Sprite *highLight = Scale9Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName(highLightFrame));
Scale9Sprite *disable = Scale9Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName(disableFrame));
ControlButton *btn = ControlButton::create(label, "Arial", labelSize);
btn->setPreferredSize(size);//设置按钮首选大小
btn->setBackgroundSpriteForState(normal, Control::State::NORMAL);
btn->setBackgroundSpriteForState(highLight, Control::State::HIGH_LIGHTED);
btn->setBackgroundSpriteForState(disable, Control::State::DISABLED);
btn->setTitleColorForState(labelColor, Control::State::NORMAL);
btn->setTitleColorForState(labelColor, Control::State::HIGH_LIGHTED);
btn->setTitleColorForState(labelColor, Control::State::DISABLED);
//btn->setTouchPriority(0);
return btn;
}
ControlButton * createBtn(float x, float y,
const char * normalBg, const char * pressBg,
Ref* target, Control::Handler action)
{
Scale9Sprite * spNormalBg = createDotaScale9Sprite(normalBg);
Scale9Sprite * spPressBg = createDotaScale9Sprite(pressBg);
ControlButton *btn = ControlButton::create(spNormalBg);
if (spPressBg)
btn->setBackgroundSpriteForState(spPressBg, Control::State::HIGH_LIGHTED);
btn->setAnchorPoint(Vec2(0, 0));
btn->setPosition(x, y);
btn->setZoomOnTouchDown(false);
btn->setPreferredSize(spNormalBg->getOriginalSize());
if (target && action)
btn->addTargetWithActionForControlEvents(target, action,
Control::EventType::TOUCH_UP_INSIDE);
return btn;
}
void ControlButtonLoader::onHandlePropTypeFloatScale(Node * pNode, Node * pParent, const char * pPropertyName, float pFloatScale, CCBReader * ccbReader) {
if(strcmp(pPropertyName, PROPERTY_FONTSIZE) == 0) {
((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::NORMAL);
((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::HIGH_LIGHTED);
((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::DISABLED);
((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::SELECTED);
((ControlButton *)pNode)->needsLayout();
} else if(strcmp(pPropertyName, PROPERTY_HORIZONTAL_PADDING) == 0) {
ControlButton * pControlButton = static_cast<ControlButton*>(pNode);
pControlButton->setMargins(pFloatScale, pControlButton->getVerticalMargin());
} else if(strcmp(pPropertyName, PROPERTY_VERTICAL_PADDING) == 0) {
ControlButton * pControlButton = static_cast<ControlButton*>(pNode);
pControlButton->setMargins(pControlButton->getHorizontalOrigin(), pFloatScale);
} else if(strcmp(pPropertyName, PROPERTY_OUTLINEWIDTH) == 0) {
// TODO:
} else if(strcmp(pPropertyName, PROPERTY_SHADOWBLURRADIUS) == 0) {
((CCBControlButton *)pNode)->setShadowBlurRadius(pFloatScale);
} else {
//ControlLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pFloatScale, ccbReader);
}
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !Layer::init() )
{
return false;
}
Size visibleSize = Director::getInstance()->getVisibleSize();
// Point origin = Director::getInstance()->getVisibleOrigin();
/////////////////////////////
// 2. add a menu item with "X" image, which is clicked to quit the program
// you may modify it.
// add a "close" icon to exit the progress. it's an autorelease object
auto closeItem = MenuItemImage::create(
"CloseNormal.png",
"CloseSelected.png",
CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));
closeItem->setAnchorPoint(Point(1, 0));
closeItem->setPosition(Point(visibleSize.width, 0));
// create menu, it's an autorelease object
auto menu = Menu::create(closeItem, NULL);
menu->setPosition(Point::ZERO);
this->addChild(menu, 1);
ControlButton* ccbBtn = ControlButton::create("CCB Test", "", 50);
ccbBtn->setPosition(visibleSize.width * 0.5f, visibleSize.height * 0.6);
ccbBtn->addTargetWithActionForControlEvents(this, cccontrol_selector(HelloWorld::onCCBTestButtonClicked), Control::EventType::TOUCH_UP_INSIDE);
addChild(ccbBtn);
ControlButton* matchBtn = ControlButton::create("Match Server Test", "", 50);
matchBtn->setPosition(visibleSize.width * 0.5f, visibleSize.height * 0.4);
matchBtn->addTargetWithActionForControlEvents(this, cccontrol_selector(HelloWorld::onMatchTestButtonClicked), Control::EventType::TOUCH_UP_INSIDE);
addChild(matchBtn);
return true;
}
void addButton( ControlButton& btn )
{
btn.setIndex( static_cast< STD1::uint16_t >( controls.size() + 7 ) );
controls.push_back( btn );
};
// 初始化
bool ChangeBGScene::init()
{
if (!Layer::init())
{
return false;
}
Size mysize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
//文字提示
Sprite *lb = Sprite::create("changbg.png");
lb->setPosition(Vec2(origin.x + mysize.width / 2, origin.y + mysize.height - 30));
this->addChild(lb, 2);
//四张背景图
//1
Scale9Sprite *sp1 = Scale9Sprite::create("11.png");
ControlButton *pbt1 = ControlButton::create(sp1);
pbt1->setPosition(Vec2(origin.x + mysize.width / 2 - 80, origin.y + mysize.height / 2 + 20));
pbt1->setPreferredSize(Size(150, 84));
this->addChild(pbt1, 2, 6001);
//绑定事件
pbt1->addTargetWithActionForControlEvents(
this,
cccontrol_selector(ChangeBGScene::changeBG),
Control::EventType::TOUCH_UP_INSIDE);
//2
Scale9Sprite *sp2 = Scale9Sprite::create("22.png");
ControlButton *pbt2 = ControlButton::create(sp2);
pbt2->setPosition(Vec2(origin.x + mysize.width / 2 + 80, origin.y + mysize.height / 2 + 20));
pbt2->setPreferredSize(Size(150, 84));
this->addChild(pbt2, 2, 6002);
//绑定事件
pbt2->addTargetWithActionForControlEvents(
this,
cccontrol_selector(ChangeBGScene::changeBG),
Control::EventType::TOUCH_UP_INSIDE);
//3
Scale9Sprite *sp3 = Scale9Sprite::create("33.png");
ControlButton *pbt3 = ControlButton::create(sp3);
pbt3->setPosition(Vec2(origin.x + mysize.width / 2 - 80, origin.y + mysize.height / 2 - 80));
pbt3->setPreferredSize(Size(150, 84));
this->addChild(pbt3, 2, 6003);
//绑定事件
pbt3->addTargetWithActionForControlEvents(
this,
cccontrol_selector(ChangeBGScene::changeBG),
Control::EventType::TOUCH_UP_INSIDE);
//4
Scale9Sprite *sp4 = Scale9Sprite::create("44.png");
ControlButton *pbt4 = ControlButton::create(sp4);
pbt4->setPosition(Vec2(origin.x + mysize.width / 2 + 80, origin.y + mysize.height / 2 - 80));
pbt4->setPreferredSize(Size(150, 84));
this->addChild(pbt4, 2, 6004);
//绑定事件
pbt4->addTargetWithActionForControlEvents(
this,
cccontrol_selector(ChangeBGScene::changeBG),
Control::EventType::TOUCH_UP_INSIDE);
//返回菜单
Scale9Sprite *spbk = Scale9Sprite::create("return.png");
ControlButton *pbtbk = ControlButton::create(spbk);
pbtbk->setPosition(Vec2(origin.x + mysize.width - 20, origin.y + mysize.height - 20));
pbtbk->setPreferredSize(Size(36, 36));
this->addChild(pbtbk, 2);
//绑定事件
pbtbk->addTargetWithActionForControlEvents(
this,
cccontrol_selector(ChangeBGScene::backToMenu),
Control::EventType::TOUCH_UP_INSIDE);
return true;
}
