示例#1
0
bool MainScene::init() {
	if (!Layer::init())
		return false;

	auto director = Director::getInstance();
	auto pView = director->getOpenGLView();
	pView->setDesignResolutionSize(RESOLUTION_WIDTH, RESOLUTION_HEIGHT, ResolutionPolicy::SHOW_ALL);

	Size visibleSize = director->getVisibleSize();
	Vec2 origin = director->getVisibleOrigin();

	//Title 'Kid Sudoku'
	auto labelTitle = Label::createWithTTF("Kid Remember It", "fonts/Marker Felt.ttf", 188);
	labelTitle->setTextColor(Color4B(0xe3, 0x54, 0xf4, 0xff));
	labelTitle->setPosition(Vec2(origin.x + visibleSize.width / 2,
						 	origin.y + visibleSize.height - labelTitle->getContentSize().height/2 - 40)
						);
	this->addChild(labelTitle);

	//Cool Papa-Legend announcement
	auto labelAnn = Label::createWithTTF("Cool Papa-Legend :   Produce product for our kids.", "fonts/Marker Felt.ttf", 30);
	labelAnn->setTextColor(Color4B(0x00, 0xff, 0x00, 0xff));
	labelAnn->setPosition(Vec2(origin.x + visibleSize.width / 2,
						 	labelTitle->getPosition().y - labelTitle->getContentSize().height/2 - 60 - labelAnn->getContentSize().height / 2)
						);
	this->addChild(labelAnn);

	//Campaign Button
	auto btnPlay = ui::Button::create("btn-menu-0.png",
											  "btn-menu-1.png",
											  "btn-menu-2.png");
	btnPlay->setScale9Enabled(true);
	btnPlay->setCapInsets(Rect(15, 15, 4, 4));
	btnPlay->setTitleText("Play");
	btnPlay->setTitleFontSize(40);
	btnPlay->setContentSize(Size(300, 90));
	btnPlay->setPosition(Vec2(origin.x + visibleSize.width / 2,
			 	 	 	   	 	  labelAnn->getPosition().y - labelAnn->getContentSize().height / 2 - 140 - btnPlay->getContentSize().height/2)
							);
	btnPlay->addClickEventListener(CC_CALLBACK_1(MainScene::onMenuPlayClicked, this));
	this->addChild(btnPlay, 1);

	//Exit Button
	auto btnExit = ui::Button::create("btn-menu-0.png",
											  "btn-menu-1.png",
											  "btn-menu-2.png");
	btnExit->setScale9Enabled(true);
	btnExit->setCapInsets(Rect(15, 15, 4, 4));
	btnExit->setTitleText("Exit");
	btnExit->setTitleFontSize(40);
	btnExit->setContentSize(Size(300, 90));
	btnExit->setPosition(Vec2(origin.x + visibleSize.width / 2,
							btnPlay->getPosition().y - btnPlay->getContentSize().height / 2 - 40 - btnExit->getContentSize().height/2)
							);
	btnExit->addClickEventListener(CC_CALLBACK_1(MainScene::onMenuExitClicked, this));
	this->addChild(btnExit, 1);
	return true;
}
void ImageView::loadTexture(const std::string& fileName, TextureResType texType)
{
    if (fileName.empty() || (_textureFile == fileName && _imageTexType == texType))
    {
        return;
    }
    _textureFile = fileName;
    _imageTexType = texType;
    switch (_imageTexType)
    {
        case TextureResType::LOCAL:
            _imageRenderer->initWithFile(fileName);
            break;
        case TextureResType::PLIST:
            _imageRenderer->initWithSpriteFrameName(fileName);
            break;
        default:
            break;
    }
    setCapInsets(_capInsets);// keep old setting while reloadTexture
    _imageTextureSize = _imageRenderer->getContentSize();
  
    this->updateChildrenDisplayedRGBA();

    updateContentSizeWithTextureSize(_imageTextureSize);
    _imageRendererAdaptDirty = true;
}
示例#3
0
void UIImageView::setScale9Enabled(bool able)
{
    if (m_bScale9Enabled == able)
    {
        return;
    }
    
    
    m_bScale9Enabled = able;
    m_pRenderer->removeChild(m_pImageRenderer, true);
    m_pImageRenderer = NULL;
    if (m_bScale9Enabled)
    {
        m_pImageRenderer = extension::CCScale9Sprite::create();
    }
    else
    {
        m_pImageRenderer = CCSprite::create();
    }
    loadTexture(m_strTextureFile.c_str(),m_eImageTexType);
    m_pRenderer->addChild(m_pImageRenderer);
    if (m_bScale9Enabled)
    {
        bool ignoreBefore = m_bIgnoreSize;
        ignoreContentAdaptWithSize(false);
        m_bPrevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(m_bPrevIgnoreSize);
    }
    setCapInsets(m_capInsets);
}
示例#4
0
void LoadingBar::setScale9Enabled(bool enabled)
{
    if (_scale9Enabled == enabled)
    {
        return;
    }
    _scale9Enabled = enabled;
    removeProtectedChild(_barRenderer);
    _barRenderer = nullptr;
    if (_scale9Enabled)
    {
        _barRenderer = extension::Scale9Sprite::create();
    }
    else
    {
        _barRenderer = Sprite::create();
    }
    loadTexture(_textureFile,_renderBarTexType);
    addProtectedChild(_barRenderer, BAR_RENDERER_Z, -1);
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
    setPercent(_percent);
}
示例#5
0
void UILoadingBar::setScale9Enabled(bool enabled)
{
    if (m_bScale9Enabled == enabled)
    {
        return;
    }
    m_bScale9Enabled = enabled;
    m_pRenderer->removeChild(m_pBarRenderer, true);
    m_pBarRenderer = NULL;
    if (m_bScale9Enabled)
    {
        m_pBarRenderer = Scale9Sprite::create();
    }
    else
    {
        m_pBarRenderer = Sprite::create();
    }
    loadTexture(m_strTextureFile.c_str(),m_eRenderBarTexType);
    m_pRenderer->addChild(m_pBarRenderer);
    if (m_bScale9Enabled)
    {
        bool ignoreBefore = m_bIgnoreSize;
        ignoreContentAdaptWithSize(false);
        m_bPrevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(m_bPrevIgnoreSize);
    }
    setCapInsets(m_capInsets);
}
示例#6
0
void LoadingBar::setScale9Enabled(bool enabled)
{
    if (_scale9Enabled == enabled)
    {
        return;
    }
    _scale9Enabled = enabled;
    CCNodeRGBA::removeChild(_barRenderer, true);
    _barRenderer = NULL;
    if (_scale9Enabled)
    {
        _barRenderer = extension::CCScale9Sprite::create();
    }
    else
    {
        _barRenderer = CCSprite::create();
    }
    loadTexture(_textureFile.c_str(),_renderBarTexType);
    CCNodeRGBA::addChild(_barRenderer, BAR_RENDERER_Z, -1);
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
}
示例#7
0
void LoadingBar::setScale9Enabled(bool enabled)
{
    if (_scale9Enabled == enabled)
    {
        return;
    }
    _scale9Enabled = enabled;

    _barRenderer->setScale9Enabled(_scale9Enabled);

    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);

    updateProgressBar();
    _barRendererAdaptDirty = true;
}
示例#8
0
void ImageView::setScale9Enabled(bool able)
{
    if (_scale9Enabled == able)
    {
        return;
    }
    
    
    _scale9Enabled = able;
    if (_scale9Enabled) {
        _imageRenderer->setRenderingType(Scale9Sprite::RenderingType::SLICE);
    }else{
        _imageRenderer->setRenderingType(Scale9Sprite::RenderingType::SIMPLE);
    }
    
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
    _imageRendererAdaptDirty = true;
}
示例#9
0
void UILoadingBar::setScale9Enabled(bool enabled)
{
    if (_scale9Enabled == enabled)
    {
        return;
    }
    _scale9Enabled = enabled;
    _renderer->removeChild(_barRenderer, true);
    _barRenderer = NULL;
    if (_scale9Enabled)
    {
        _barRenderer = Scale9Sprite::create();
    }
    else
    {
        _barRenderer = CCSprite::create();
    }
    loadTexture(_textureFile.c_str(),_renderBarTexType);
    _renderer->addChild(_barRenderer);
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
}
示例#10
0
void UIImageView::setScale9Enabled(bool able)
{
    if (_scale9Enabled == able)
    {
        return;
    }
    
    
    _scale9Enabled = able;
    _renderer->removeChild(_imageRenderer, true);
    _imageRenderer = nullptr;
    if (_scale9Enabled)
    {
        _imageRenderer = cocos2d::extension::Scale9Sprite::create();
    }
    else
    {
        _imageRenderer = cocos2d::Sprite::create();
    }
    loadTexture(_textureFile.c_str(),_imageTexType);
    _renderer->addChild(_imageRenderer);
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
}
void ImageView::setScale9Enabled(bool able)
{
    if (_scale9Enabled == able)
    {
        return;
    }


    _scale9Enabled = able;
    removeProtectedChild(_imageRenderer);
    _imageRenderer = nullptr;
    if (_scale9Enabled)
    {
        _imageRenderer = extension::Scale9Sprite::create();
    }
    else
    {
        _imageRenderer = Sprite::create();
    }
    loadTexture(_textureFile,_imageTexType);
    addProtectedChild(_imageRenderer, IMAGE_RENDERER_Z, -1);
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
}
void ImageView::setScale9Enabled(bool able)
{
    if (_scale9Enabled == able)
    {
        return;
    }
    
    
    _scale9Enabled = able;
    CCNode::removeChild(_imageRenderer, true);
    _imageRenderer = NULL;
    if (_scale9Enabled)
    {
        _imageRenderer = extension::CCScale9Sprite::create();
    }
    else
    {
        _imageRenderer = CCSprite::create();
    }
    loadTexture(_textureFile.c_str(),_imageTexType);
    CCNode::addChild(_imageRenderer, IMAGE_RENDERER_Z, -1);
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
}
示例#13
0
void UIImageView::copySpecialProperties(UIWidget *widget)
{
    UIImageView* imageView = dynamic_cast<UIImageView*>(widget);
    if (imageView)
    {
        m_bPrevIgnoreSize = imageView->m_bPrevIgnoreSize;
        setScale9Enabled(imageView->m_bScale9Enabled);
        loadTexture(imageView->m_strTextureFile.c_str(), imageView->m_eImageTexType);
        setCapInsets(imageView->m_capInsets);
    }
}
void ImageView::copySpecialProperties(Widget *widget)
{
    ImageView* imageView = dynamic_cast<ImageView*>(widget);
    if (imageView)
    {
        _prevIgnoreSize = imageView->_prevIgnoreSize;
        setScale9Enabled(imageView->_scale9Enabled);
        loadTexture(imageView->_textureFile.c_str(), imageView->_imageTexType);
        setCapInsets(imageView->_capInsets);
    }
}
示例#15
0
void UILoadingBar::copySpecialProperties(UIWidget *widget)
{
    UILoadingBar* loadingBar = dynamic_cast<UILoadingBar*>(widget);
    if (loadingBar)
    {
        m_bPrevIgnoreSize = loadingBar->m_bPrevIgnoreSize;
        setScale9Enabled(loadingBar->m_bScale9Enabled);
        loadTexture(loadingBar->m_strTextureFile.c_str(), loadingBar->m_eRenderBarTexType);
        setCapInsets(loadingBar->m_capInsets);
        setPercent(loadingBar->m_nPercent);
    }
}
示例#16
0
void LoadingBar::copySpecialProperties(Widget *widget)
{
    LoadingBar* loadingBar = dynamic_cast<LoadingBar*>(widget);
    if (loadingBar)
    {
        _prevIgnoreSize = loadingBar->_prevIgnoreSize;
        setScale9Enabled(loadingBar->_scale9Enabled);
        loadTexture(loadingBar->_textureFile.c_str(), loadingBar->_renderBarTexType);
        setCapInsets(loadingBar->_capInsets);
        setPercent(loadingBar->_percent);
    }
}
示例#17
0
void UIButton::setScale9Enabled(bool able)
{
    if (m_bScale9Enabled == able)
    {
        return;
    }
    m_eBrightStyle = BRIGHT_NONE;
    m_bScale9Enabled = able;


    m_pRenderer->removeChild(m_pButtonNormalRenderer, true);
    m_pRenderer->removeChild(m_pButtonClickedRenderer, true);
    m_pRenderer->removeChild(m_pButtonDisableRenderer, true);

    m_pButtonNormalRenderer = NULL;
    m_pButtonClickedRenderer = NULL;
    m_pButtonDisableRenderer = NULL;
    if (m_bScale9Enabled)
    {
        m_pButtonNormalRenderer = CCScale9Sprite::create();
        m_pButtonClickedRenderer = CCScale9Sprite::create();
        m_pButtonDisableRenderer = CCScale9Sprite::create();
    }
    else
    {
        m_pButtonNormalRenderer = CCSprite::create();
        m_pButtonClickedRenderer = CCSprite::create();
        m_pButtonDisableRenderer = CCSprite::create();
    }

//    setTextures(m_strNormalFileName.c_str(), m_strClickedFileName.c_str(), m_strDisabledFileName.c_str(),getUseMergedTexture());
    loadTextureNormal(m_strNormalFileName.c_str(), m_eNormalTexType);
    loadTexturePressed(m_strClickedFileName.c_str(), m_ePressedTexType);
    loadTextureDisabled(m_strDisabledFileName.c_str(), m_eDisabledTexType);
    m_pRenderer->addChild(m_pButtonNormalRenderer,-1);
    m_pRenderer->addChild(m_pButtonClickedRenderer,-1);
    m_pRenderer->addChild(m_pButtonDisableRenderer,-1);
    if (m_bScale9Enabled)
    {
        bool ignoreBefore = m_bIgnoreSize;
        ignoreContentAdaptWithSize(false);
        m_bPrevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(m_bPrevIgnoreSize);
    }
    setCapInsets(m_capInsets);
    setBright(m_bBright);
}
示例#18
0
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    if ( !LayerColor::initWithColor(Constants::BACKGROUND_COLOR) )
    {
        return false;
    }
    
    Size visibleSize = Director::getInstance()->getVisibleSize();
    Vec2 origin = Director::getInstance()->getVisibleOrigin();

    auto learnBtn = ui::Button::create("BtnNormal", "BtnPressed", "", ui::Widget::TextureResType::PLIST);
    learnBtn->setScale9Enabled(true);
    learnBtn->setCapInsets(Rect(12, 12, 12, 12));
    learnBtn->setSize(Size(177, 58));
    learnBtn->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + visibleSize.height/2 + 39));
    learnBtn->getTitleRenderer()->setBMFontFilePath(Constants::FONT_BOLD30);
    learnBtn->setTitleText("Learn");
    learnBtn->addTouchEventListener(CC_CALLBACK_2(HelloWorld::touchEvent, this));
    this->addChild(learnBtn, 1, 1);
    
    auto testBtn = ui::Button::create("BtnBlueNormal", "BtnBluePressed", "", ui::Widget::TextureResType::PLIST);
    testBtn->setScale9Enabled(true);
    testBtn->setCapInsets(Rect(12, 12, 12, 12));
    testBtn->setSize(Size(177, 58));
    testBtn->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + visibleSize.height/2 - 39));
    testBtn->getTitleRenderer()->setBMFontFilePath(Constants::FONT_BOLD30);
    testBtn->setTitleText("Test");
    testBtn->addTouchEventListener(CC_CALLBACK_2(HelloWorld::touchEvent, this));
    this->addChild(testBtn, 2, 2);
    
    auto rateBtn = ui::Button::create("RateBtn", "", "", ui::Widget::TextureResType::PLIST);
    rateBtn->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + 30));
    rateBtn->addTouchEventListener(CC_CALLBACK_2(HelloWorld::touchEvent, this));
    this->addChild(rateBtn, 3, 3);

    return true;
}
示例#19
0
void ImageView::copySpecialProperties(Widget *widget)
{
    ImageView* imageView = dynamic_cast<ImageView*>(widget);
    if (imageView)
    {
        _prevIgnoreSize = imageView->_prevIgnoreSize;
        setScale9Enabled(imageView->_scale9Enabled);
        auto imageSprite = imageView->_imageRenderer->getSprite();
        if(nullptr != imageSprite)
        {
            loadTexture(imageSprite->getSpriteFrame());
        }
        setCapInsets(imageView->_capInsets);
    }
}
示例#20
0
void LoadingBar::copySpecialProperties(Widget *widget)
{
    LoadingBar* loadingBar = dynamic_cast<LoadingBar*>(widget);
    if (loadingBar)
    {
        _prevIgnoreSize = loadingBar->_prevIgnoreSize;
        setScale9Enabled(loadingBar->_scale9Enabled);
        auto barSprite = loadingBar->_barRenderer->getSprite();
        if(nullptr != barSprite)
        {
            loadTexture(barSprite->getSpriteFrame());
        }
        setCapInsets(loadingBar->_capInsets);
        setPercent(loadingBar->_percent);
        setDirection(loadingBar->_direction);
    }
}
示例#21
0
void LoadingBar::copySpecialProperties(Widget *widget)
{
    LoadingBar* loadingBar = dynamic_cast<LoadingBar*>(widget);
    if (loadingBar)
    {
        _prevIgnoreSize = loadingBar->_prevIgnoreSize;
        setScale9Enabled(loadingBar->_scale9Enabled);

        // clone the inner sprite: https://github.com/cocos2d/cocos2d-x/issues/16930
        loadingBar->_barRenderer->copyTo(_barRenderer);
        setupTexture();

        setCapInsets(loadingBar->_capInsets);
        setPercent(loadingBar->_percent);
        setDirection(loadingBar->_direction);
        _textureFile = loadingBar->_textureFile;
        _totalLength = loadingBar->_totalLength;
        _barRendererTextureSize = loadingBar->_barRendererTextureSize;
    }
}
void UIButton::setScale9Enable(bool able)
{
    if (m_bScale9Enable == able)
    {
        return;
    }
    m_nPrevPressstate = WidgetStateNone;
    m_nCurPressState = WidgetStateNone;
    m_bScale9Enable = able;
    
    m_pRender->removeChild(m_pButtonNormal, true);
    m_pRender->removeChild(m_pButtonClicked, true);
    m_pRender->removeChild(m_pButtonDisable, true);
    
    m_pButtonNormal = NULL;
    m_pButtonClicked = NULL;
    m_pButtonDisable = NULL;
    if (m_bScale9Enable)
    {
        m_pButtonNormal = CCScale9Sprite::create();
        m_pButtonClicked = CCScale9Sprite::create();
        m_pButtonDisable = CCScale9Sprite::create();
    }
    else
    {
        m_pButtonNormal = CCSprite::create();
        m_pButtonClicked = CCSprite::create();
        m_pButtonDisable = CCSprite::create();
    }
//    setTextures(m_strNormalFileName.c_str(), m_strClickedFileName.c_str(), m_strDisabledFileName.c_str(),getUseMergedTexture());
    setNormalTexture(m_strNormalFileName.c_str(), m_eNormalTexType);
    setPressedTexture(m_strClickedFileName.c_str(), m_ePressedTexType);
    setDisabledTexture(m_strDisabledFileName.c_str(), m_eDisabledTexType);
    m_pRender->addChild(m_pButtonNormal,-1);
    m_pRender->addChild(m_pButtonClicked,-1);
    m_pRender->addChild(m_pButtonDisable,-1);
    initPressState(WidgetStateNormal);
    setCapInsets(m_capInsets);
    setScale9Size(m_scale9Size);
}
示例#23
0
void LoadingBar::setScale9Enabled(bool enabled)
{
    if (_scale9Enabled == enabled)
    {
        return;
    }
    _scale9Enabled = enabled;
    _barRenderer->setScale9Enabled(_scale9Enabled);
    
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
    setPercent(_percent);
}
示例#24
0
void UISlider::setScale9Enabled(bool able)
{
    if (m_bScale9Enabled == able)
    {
        return;
    }
    
    m_bScale9Enabled = able;
    m_pRenderer->removeChild(m_pBarRenderer, true);
    m_pRenderer->removeChild(m_pProgressBarRenderer, true);
    m_pBarRenderer = NULL;
    m_pProgressBarRenderer = NULL;
    if (m_bScale9Enabled)
    {
        m_pBarRenderer = CCScale9Sprite::create();
        m_pProgressBarRenderer = CCScale9Sprite::create();
    }
    else
    {
        m_pBarRenderer = CCSprite::create();
        m_pProgressBarRenderer = CCSprite::create();
    }
    loadBarTexture(m_strTextureFile.c_str(), m_eBarTexType);
    loadProgressBarTexture(m_strProgressBarTextureFile.c_str(), m_eProgressBarTexType);
    m_pRenderer->addChild(m_pBarRenderer, -1);
    m_pRenderer->addChild(m_pProgressBarRenderer, -1);
    if (m_bScale9Enabled)
    {
        bool ignoreBefore = m_bIgnoreSize;
        ignoreContentAdaptWithSize(false);
        m_bPrevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(m_bPrevIgnoreSize);
    }
    setCapInsets(m_capInsets);
}
示例#25
0
void ImageView::setScale9Enabled(bool able)
{
    if (_scale9Enabled == able)
    {
        return;
    }
    
    
    _scale9Enabled = able;
    _imageRenderer->setScale9Enabled(_scale9Enabled);
    
    if (_scale9Enabled)
    {
        bool ignoreBefore = _ignoreSize;
        ignoreContentAdaptWithSize(false);
        _prevIgnoreSize = ignoreBefore;
    }
    else
    {
        ignoreContentAdaptWithSize(_prevIgnoreSize);
    }
    setCapInsets(_capInsets);
}
void UISlider::setScale9Enable(bool able)
{
    if (m_bBarScale9Enable == able)
    {
        return;
    }
    
    m_bBarScale9Enable = able;
    m_pRender->removeChild(m_pBarNode, true);
    m_pBarNode = NULL;
    if (m_bBarScale9Enable)
    {
        m_pBarNode = CCScale9Sprite::create();
    }
    else
    {
        m_pBarNode = CCSprite::create();
    }
    setBarTexture(m_strTextureFile.c_str(), m_eBarTexType);
    setCapInsets(m_capInsets);
    setScale9Size(m_scale9Size);
    m_pRender->addChild(m_pBarNode, -1);
}
示例#27
0
void ExControlButton::updateUI()
{
    // prepare and set sprite frame and set color for each layer in each state
    string          strSpriteFrameName          = "";
    string          strTemplateSpriteName       = "";
    string          strFunctional               = _strFuncName;
    SpriteFrame*    pSpriteFrame                = nullptr;
    
    // temp data for iterator all the item
    std::map<Control::State, string> mapTemp;
    mapTemp[Control::State::NORMAL]             = "%s_%s_%02d.png";
    mapTemp[Control::State::HIGH_LIGHTED]       = "%s_%s_%02d.png";
    mapTemp[Control::State::DISABLED]           = "%s_%s_%02d.png";
    
    std::map<Control::State, string> mapTempState;
    mapTempState[Control::State::NORMAL]         = "normal";
    mapTempState[Control::State::HIGH_LIGHTED]   = "select";
    mapTempState[Control::State::DISABLED]       = "disable";
    
    std::map<int, std::map<Control::State, Color3B> > mapTempColorForSrite;
    mapTempColorForSrite[0]                     = _mapBgState;
    mapTempColorForSrite[1]                     = _mapIconState;
    mapTempColorForSrite[2]                     = _mapBorderState;
    
    
    for(auto iter = mapTemp.begin(); iter != mapTemp.end(); iter++)
    {
//        // set color of the title first
//        if(_mapTextState.count(iter->first) > 0)
//        {
//            this->setTitleColorForState(_mapTextState[iter->first], iter->first);
//        }
        
        // need to do this wway because getBackgroundSpriteForState func return ui::Scale9Sprite* type not relative with Sprite* type
        // first look it so complicated but it must be that
        // get the sprite content
        auto pScale9Sprite              = this->getBackgroundSpriteForState(iter->first);
//        Sprite* pSprite = nullptr;
        
        // check if it all null
        if(pScale9Sprite == nullptr)
        {
            continue;
        }
        
        for(int nLayer = 0; nLayer < 3; nLayer++)
        {
            // reset var
            pSpriteFrame                = nullptr;
            strSpriteFrameName          = "";
            strTemplateSpriteName       = "";
            
            // build the sprite frame name
            strTemplateSpriteName   = iter->second;
            if(mapTempState.count(iter->first) > 0)
            {
                strSpriteFrameName      = __String::createWithFormat(strTemplateSpriteName.c_str(),
                                                                     strFunctional.c_str(),
                                                                     mapTempState[iter->first].c_str(),
                                                                     (int)(nLayer + 1))->getCString();
            }
            
            pSpriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(strSpriteFrameName);
            
            // check if pSpriteFrame continue null -> continue
            if(pSpriteFrame == nullptr)
            {
                continue;
            }
            
            if(nLayer == 0)
            {
                // set color for this
//                if (pSprite)
//                {
//                    if(mapTempColorForSrite[nLayer].count(iter->first) > 0)
//                    {
//                        pSprite->setColor(mapTempColorForSrite[nLayer][iter->first]);
//                    }
//                    pSprite->setSpriteFrame(pSpriteFrame);
//                }
                
                if(pScale9Sprite)
                {
                    if(mapTempColorForSrite[nLayer].count(iter->first) > 0)
                    {
                        pScale9Sprite->setColor(mapTempColorForSrite[nLayer][iter->first]);
                    }
                    pScale9Sprite->setSpriteFrame(pSpriteFrame);
                }
            }
            else
            {
                // check and get if exist
                Sprite*     pSpriteChild    = nullptr;
                auto        pChild          = /*pSprite != nullptr ?  (pSprite->getChildByTag((int)(nLayer + 1))) :*/
                                                    (pScale9Sprite != nullptr ? pScale9Sprite->getChildByTag((int)(nLayer + 1)) : nullptr);
                if(pChild != nullptr)
                {
                    pSpriteChild = dynamic_cast<Sprite*>(pChild);
                }
                
                // check if null -> create and add it
                if(pSpriteChild == nullptr)
                {
                    pSpriteChild = Sprite::createWithSpriteFrame(pSpriteFrame);
                }
                
                // if it not null -> add an continue
                if(pSpriteChild != nullptr)
                {
                    pSpriteChild->setAnchorPoint(Vec2::ZERO);
                    
                    if(mapTempColorForSrite[nLayer].count(iter->first) > 0)
                    {
                        pScale9Sprite->setColor(mapTempColorForSrite[nLayer][iter->first]);
                    }
                    
                    // add to root
//                    if (pSprite)
//                    {
//                        if(pSprite->getChildren().find(pSpriteChild) == pSprite->getChildren().end())
//                        {
//                            pSprite->addChild(pSpriteChild, 0, (int)(nLayer + 1));
//                        }
//                    }
                    
                    if (pScale9Sprite)
                    {
                        if(pScale9Sprite->getChildren().find(pSpriteChild) == pScale9Sprite->getChildren().end())
                        {
                            cocos2d::Rect rect;
                            rect.size = pSpriteChild->getContentSize();
                            pScale9Sprite->setCapInsets(rect);
                            pScale9Sprite->addChild(pSpriteChild, 0, (int)(nLayer + 1));
                        }
                    }
                    
                    // set tag for sure
                    pSpriteChild->setTag((int)(nLayer + 1));
                }
            }
        }
    }
}
示例#28
0
// on "init" you need to initialize your instance
bool LearnScene::init()
{
    if ( !LayerColor::initWithColor(Constants::BACKGROUND_COLOR) )
    {
        return false;
    }
    
    Size visibleSize = Director::getInstance()->getVisibleSize();
    Vec2 origin = Director::getInstance()->getVisibleOrigin();
    
    // Home btn
    auto btn = ui::Button::create("HomeBtn", "HomeBtn", "", ui::Widget::TextureResType::PLIST);
    btn->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
    btn->setPosition(Vec2(origin.x + visibleSize.width, origin.y + visibleSize.height));
    btn->addTouchEventListener(CC_CALLBACK_2(LearnScene::touchEvent, this));
    this->addChild(btn, 1, 1);
    
    // Learn progress txt
    float retainedPercent = round(Constants::getRetainedWordCount() * 100 / Constants::getTotalWordCount());
    std::stringstream stm;
    stm << "Learning progress: " << retainedPercent << "%";
    auto label = Label::createWithBMFont(Constants::FONT_BOLD12, stm.str());
    label->setColor(Color3B::BLACK);
    label->setAnchorPoint(Vec2::ANCHOR_MIDDLE_LEFT);
    label->setPosition(origin.x + 14, origin.y + visibleSize.height - 28);
    this->addChild(label, 2, 2);
    
    // Learn progress bar
    auto sprite9 = ui::Scale9Sprite::createWithSpriteFrameName("PbBg", Rect(2, 2, 2, 2));
    sprite9->setContentSize(Size(visibleSize.width - 28, 18));
    sprite9->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + visibleSize.height - 60));
    this->addChild(sprite9, 3, 3);
    
    auto pb = ui::Scale9Sprite::createWithSpriteFrameName("PbProgress", Rect(2, 2, 2, 2));
    Size pbSize = sprite9->getContentSize();
    pbSize.width *= retainedPercent / 100;
    if(pbSize.width < 6) pbSize.width = 6;
    pb->setContentSize(pbSize);
    pb->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
    sprite9->addChild(pb, 1, 1);
    
    // Text area
    sprite9 = ui::Scale9Sprite::createWithSpriteFrameName("TextArea", Rect(12, 12, 12, 12));
    sprite9->setContentSize(Size(visibleSize.width-28, visibleSize.height - 264));
    sprite9->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + visibleSize.height - 86 - sprite9->getContentSize().height / 2));
    this->addChild(sprite9, 4, 4);
    
    // choices
    btn = ui::Button::create("ChoiceBg", "ChoiceSelectedBg", "", ui::Widget::TextureResType::PLIST);
    btn->setScale9Enabled(true);
    btn->setCapInsets(Rect(5, 5, 5, 5));
    btn->setSize(Size(visibleSize.width-28, 30));
    btn->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + 148));
    btn->getTitleRenderer()->setBMFontFilePath(Constants::FONT_REGULAR12);
    btn->getTitleRenderer()->setColor(Color3B::BLACK);
    btn->setTitleText("I know this word.");
    btn->addTouchEventListener(CC_CALLBACK_2(LearnScene::touchEvent, this));
    this->addChild(btn, 5, 5);
    btn = ui::Button::create("ChoiceBg", "ChoiceSelectedBg", "", ui::Widget::TextureResType::PLIST);
    btn->setScale9Enabled(true);
    btn->setCapInsets(Rect(5, 5, 5, 5));
    btn->setSize(Size(visibleSize.width-28, 30));
    btn->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + 103));
    btn->getTitleRenderer()->setBMFontFilePath(Constants::FONT_REGULAR12);
    btn->getTitleRenderer()->setColor(Color3B::BLACK);
    btn->setTitleText("Not yet!");
    btn->addTouchEventListener(CC_CALLBACK_2(LearnScene::touchEvent, this));
    this->addChild(btn, 6, 6);
    
    // check btn
    btn = ui::Button::create("BtnNormal", "BtnPressed", "BtnDisabled", ui::Widget::TextureResType::PLIST);
    btn->setScale9Enabled(true);
    btn->setCapInsets(Rect(12, 12, 12, 12));
    btn->setSize(Size(visibleSize.width-28, 58));
    btn->setPosition(Vec2(origin.x + visibleSize.width/2, origin.y + 45));
    btn->getTitleRenderer()->setBMFontFilePath(Constants::FONT_BOLD30);
    btn->setTitleText("Check");
    btn->addTouchEventListener(CC_CALLBACK_2(LearnScene::touchEvent, this));
    this->addChild(btn, 7, 7);
    btn->setEnabled(false);
    btn->setBright(false);
    
    // term
    std::string nextWord = Constants::getNextWordToLearn();
    label = Label::createWithBMFont(Constants::FONT_BOLD30, nextWord);
    label->setColor(Color3B::BLACK);
    label->setPosition(sprite9->getContentSize().width/2, sprite9->getContentSize().height/2);
    sprite9->addChild(label, 1, 1);
    
    // definition
    const ValueMap& wInfo = Configuration::getInstance()->getValue("words").asValueMap().at(nextWord).asValueMap();
    auto it = wInfo.find("ldef");
    std::string ldef = it != wInfo.end() ? it->second.asString() : "Missing definition";
    label = Label::createWithBMFont(Constants::FONT_REGULAR14, ldef);
    label->setColor(Color3B::BLACK);
    label->setWidth(sprite9->getContentSize().width - 28);
    label->setAlignment(TextHAlignment::LEFT);
    label->setPosition(sprite9->getContentSize().width/2, sprite9->getContentSize().height/2);
    sprite9->addChild(label, 2, 2);
    label->setOpacity(0);
    label->setVisible(false);
    
    // play sound
    Constants::playText(nextWord);
    
    // init vars
    this->startTime = time(0);
    this->showNext = false;
    this->answerChoice = -1;
    
    return true;
}