void ButtonWithImage::loadThumbnailTexture(const std::string &thumbnail, cocos2d::ui::Widget::TextureResType texType){
if(thumbnail.empty())
{
return;
}
_thumbnailFilename = thumbnail;
_thumbnailTexRes = texType;
//Does not supprt scale9
Sprite* thumbnailSprite = static_cast<Sprite*>(_thumbnailRenderer);
switch (texType) {
case cocos2d::ui::Widget::TextureResType::LOCAL:
thumbnailSprite->setTexture(thumbnail);
break;
case cocos2d::ui::Widget::TextureResType::PLIST:
thumbnailSprite->setSpriteFrame(thumbnail);
break;
default:
break;
}
_thumbnailTextureSize = _thumbnailRenderer->getContentSize();
updateFlippedX();
updateFlippedY();
updateContentSizeWithTextureSize(_thumbnailTextureSize);
//No true/false
//!!
}
void TextField::setString(const std::string& text)
{
std::string strText(text);
if (isMaxLengthEnabled())
{
int max = _textFieldRenderer->getMaxLength();
long text_count = StringUtils::getCharacterCountInUTF8String(text);
long total = text_count + StringUtils::getCharacterCountInUTF8String(getString());
if (total > max)
{
strText = Helper::getSubStringOfUTF8String(strText, 0, max);
}
}
const char* content = strText.c_str();
if (isPasswordEnabled())
{
_textFieldRenderer->setPasswordText(content);
_textFieldRenderer->setString("");
_textFieldRenderer->insertText(content, strlen(content));
}
else
{
_textFieldRenderer->setString(content);
}
_textFieldRendererAdaptDirty = true;
updateContentSizeWithTextureSize(_textFieldRenderer->getContentSize());
}
void Text::setFontSize(int size)
{
_fontSize = size;
_labelRenderer->setSystemFontSize(size);
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
void LoadingBar::setupTexture()
{
_barRendererTextureSize = _barRenderer->getContentSize();
switch (_direction)
{
case Direction::LEFT:
_barRenderer->setAnchorPoint(Vec2(0.0f,0.5f));
break;
case Direction::RIGHT:
_barRenderer->setAnchorPoint(Vec2(1.0f,0.5f));
break;
}
this->handleSpriteFlipX();
_barRenderer->setCapInsets(_capInsets);
this->updateChildrenDisplayedRGBA();
barRendererScaleChangedWithSize();
updateContentSizeWithTextureSize(_barRendererTextureSize);
this->updateProgressBar();
_barRendererAdaptDirty = true;
}
void CheckBox::loadTextureBackGround(const std::string& backGround,TextureResType texType)
{
if (backGround.empty())
{
return;
}
_backGroundFileName = backGround;
_backGroundTexType = texType;
switch (_backGroundTexType)
{
case TextureResType::LOCAL:
_backGroundBoxRenderer->setTexture(backGround);
break;
case TextureResType::PLIST:
_backGroundBoxRenderer->setSpriteFrame(backGround);
break;
default:
break;
}
updateFlippedX();
updateFlippedY();
this->updateChildrenDisplayedRGBA();
updateContentSizeWithTextureSize(_backGroundBoxRenderer->getContentSize());
_backGroundBoxRendererAdaptDirty = 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;
}
void Text::setFontName(const std::string& name)
{
_fontName = name;
_labelRenderer->setSystemFontName(name);
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
void TextAtlas::setString(const std::string& value)
{
_stringValue = value;
_labelAtlasRenderer->setString(value);
updateContentSizeWithTextureSize(_labelAtlasRenderer->getContentSize());
_labelAtlasRendererAdaptDirty = true;
// CCLOG("cssss w %f, h %f", _contentSize.width, _contentSize.height);
}
void AbstractCheckButton::setupBackgroundTexture()
{
this->updateChildrenDisplayedRGBA();
updateContentSizeWithTextureSize(_backGroundBoxRenderer->getContentSize());
_backGroundBoxRendererAdaptDirty = true;
}
void Slider::setupBarTexture()
{
this->updateChildrenDisplayedRGBA();
_barRendererAdaptDirty = true;
_progressBarRendererDirty = true;
updateContentSizeWithTextureSize(_barRenderer->getContentSize());
_barTextureSize = _barRenderer->getContentSize();
}
void TextField::setText(const std::string& text)
{
std::string strText(text);
if (isMaxLengthEnabled())
{
int max = _textFieldRenderer->getMaxLength();
int text_count = _calcCharCount(text.c_str());
int total = text_count + _calcCharCount(getStringValue().c_str());
if (total > max)
{
int ascii = 0;
int unicode = 0;
int end = 0;
int count = 0;
for (int i = 0; i < total * 3; ++i)
{
char value = text[i];
if (value >= 0 && value <= 127) // ascii
{
ascii++;
count++;
}
else
{
unicode++;
if (unicode % 3 == 0)
{
count++;
}
}
if (count == max)
{
break;
}
}
end = ascii + unicode;
strText = strText.substr(0, end);
}
}
const char* content = strText.c_str();
if (isPasswordEnabled())
{
_textFieldRenderer->setPasswordText(content);
_textFieldRenderer->setString("");
_textFieldRenderer->insertText(content, strlen(content));
}
else
{
_textFieldRenderer->setString(content);
}
_textFieldRendererAdaptDirty = true;
updateContentSizeWithTextureSize(_textFieldRenderer->getContentSize());
}
void ImageView::setupTexture()
{
_imageTextureSize = _imageRenderer->getContentSize();
this->updateChildrenDisplayedRGBA();
updateContentSizeWithTextureSize(_imageTextureSize);
_imageRendererAdaptDirty = true;
}
void LoadingBar::loadTexture(const std::string& texture,TextureResType texType)
{
if (texture.empty())
{
return;
}
_renderBarTexType = texType;
_textureFile = texture;
switch (_renderBarTexType)
{
case TextureResType::LOCAL:
_barRenderer->initWithFile(texture);
break;
case TextureResType::PLIST:
_barRenderer->initWithSpriteFrameName(texture);
break;
default:
break;
}
_barRendererTextureSize = _barRenderer->getContentSize();
switch (_direction)
{
case Direction::LEFT:
_barRenderer->setAnchorPoint(Vec2(0.0f,0.5f));
if (!_scale9Enabled)
{
auto innerSprite = _barRenderer->getSprite();
if (nullptr != innerSprite)
{
innerSprite->setFlippedX(false);
}
}
break;
case Direction::RIGHT:
_barRenderer->setAnchorPoint(Vec2(1.0f,0.5f));
if (!_scale9Enabled)
{
auto innerSprite = _barRenderer->getSprite();
if (nullptr != innerSprite)
{
innerSprite->setFlippedX(true);
}
}
break;
}
_barRenderer->setCapInsets(_capInsets);
this->updateChildrenDisplayedRGBA();
barRendererScaleChangedWithSize();
updateContentSizeWithTextureSize(_barRendererTextureSize);
this->updateProgressBar();
_barRendererAdaptDirty = true;
}
void Text::setString(const std::string &text)
{
if (text == _labelRenderer->getString())
{
return;
}
_labelRenderer->setString(text);
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
void Text::disableEffect(LabelEffect effect)
{
_labelRenderer->disableEffect(effect);
//only outline effect will affect the content size of label
if(LabelEffect::OUTLINE == effect)
{
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
}
void Text::setTextAreaSize(const Size &size)
{
_labelRenderer->setDimensions(size.width,size.height);
if (!_ignoreSize)
{
_customSize=size;
}
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
void TextBMFont::setString(const std::string& value)
{
_stringValue = value;
if (!_fntFileHasInit)
{
return;
}
_labelBMFontRenderer->setString(value);
updateContentSizeWithTextureSize(_labelBMFontRenderer->getContentSize());
_labelBMFontRendererAdaptDirty = true;
}
void Button::setupNormalTexture(bool textureLoaded)
{
_normalTextureSize = _buttonNormalRenderer->getContentSize();
this->updateChildrenDisplayedRGBA();
if (_unifySize )
{
if (!_scale9Enabled)
{
updateContentSizeWithTextureSize(this->getNormalSize());
}
}
else
{
updateContentSizeWithTextureSize(_normalTextureSize);
}
_normalTextureLoaded = textureLoaded;
_normalTextureAdaptDirty = true;
}
void TextAtlas::setProperty(const std::string& stringValue, const std::string& charMapFile, int itemWidth, int itemHeight, const std::string& startCharMap)
{
_stringValue = stringValue;
_charMapFileName = charMapFile;
_itemWidth = itemWidth;
_itemHeight = itemHeight;
_startCharMap = startCharMap;
_labelAtlasRenderer->initWithString(stringValue, charMapFile, itemWidth, itemHeight, (int)(startCharMap[0]));
updateContentSizeWithTextureSize(_labelAtlasRenderer->getContentSize());
_labelAtlasRendererAdaptDirty = true;
CCLOG("cs w %f, h %f", _contentSize.width, _contentSize.height);
}
void TextBMFont::setFntFile(const std::string& fileName)
{
if (fileName.empty())
{
return;
}
_fntFileName = fileName;
_labelBMFontRenderer->setBMFontFilePath(fileName);
updateContentSizeWithTextureSize(_labelBMFontRenderer->getContentSize());
_labelBMFontRendererAdaptDirty = true;
}
void TextField::setFontSize(int size)
{
if (_fontType == FontType::SYSTEM) {
_textFieldRenderer->setSystemFontSize(size);
} else {
TTFConfig config = _textFieldRenderer->getTTFConfig();
config.fontSize = size;
_textFieldRenderer->setTTFConfig(config);
}
_fontSize = size;
_textFieldRendererAdaptDirty = true;
updateContentSizeWithTextureSize(_textFieldRenderer->getContentSize());
}
void Button::loadTextureNormal(const std::string& normal,TextureResType texType)
{
if (normal.empty() || (_normalFileName == normal && _normalTexType == texType))
{
return;
}
_normalFileName = normal;
_normalTexType = texType;
switch (_normalTexType)
{
case TextureResType::LOCAL:
_buttonNormalRenderer->initWithFile(normal);
break;
case TextureResType::PLIST:
_buttonNormalRenderer->initWithSpriteFrameName(normal);
break;
default:
break;
}
_normalTextureSize = _buttonNormalRenderer->getContentSize();
this->updateChildrenDisplayedRGBA();
if (_unifySize )
{
if (!_scale9Enabled)
{
updateContentSizeWithTextureSize(this->getNormalSize());
}
}
else
{
updateContentSizeWithTextureSize(_normalTextureSize);
}
_normalTextureLoaded = true;
_normalTextureAdaptDirty = true;
}
void Button::setupNormalTexture()
{
_normalTextureSize = _buttonNormalRenderer->getContentSize();
// force update _customSize, fixed issue:
// https://github.com/cocos2d/cocos2d-x/issues/12249
_customSize = _normalTextureSize;
this->updateChildrenDisplayedRGBA();
if (_unifySize )
{
if (!_scale9Enabled)
{
updateContentSizeWithTextureSize(this->getNormalSize());
}
}
else
{
updateContentSizeWithTextureSize(_normalTextureSize);
}
_normalTextureLoaded = true;
_normalTextureAdaptDirty = true;
}
void Button::loadTextureNormal(const std::string& normal,TextureResType texType)
{
if (normal.empty())
{
return;
}
_normalFileName = normal;
_normalTexType = texType;
if (_scale9Enabled)
{
extension::Scale9Sprite* normalRendererScale9 = static_cast<extension::Scale9Sprite*>(_buttonNormalRenderer);
switch (_normalTexType)
{
case TextureResType::LOCAL:
normalRendererScale9->initWithFile(normal);
break;
case TextureResType::PLIST:
normalRendererScale9->initWithSpriteFrameName(normal);
break;
default:
break;
}
normalRendererScale9->setCapInsets(_capInsetsNormal);
}
else
{
Sprite* normalRenderer = static_cast<Sprite*>(_buttonNormalRenderer);
switch (_normalTexType)
{
case TextureResType::LOCAL:
normalRenderer->setTexture(normal);
break;
case TextureResType::PLIST:
normalRenderer->setSpriteFrame(normal);
break;
default:
break;
}
}
_normalTextureSize = _buttonNormalRenderer->getContentSize();
updateFlippedX();
updateFlippedY();
_buttonNormalRenderer->setColor(this->getColor());
_buttonNormalRenderer->setOpacity(this->getOpacity());
updateContentSizeWithTextureSize(_normalTextureSize);
_normalTextureLoaded = true;
_normalTextureAdaptDirty = true;
}
void Text::setFontSize(float size)
{
if (_type == Type::SYSTEM)
{
_labelRenderer->setSystemFontSize(size);
}
else
{
TTFConfig config = _labelRenderer->getTTFConfig();
config.fontSize = size;
_labelRenderer->setTTFConfig(config);
}
_fontSize = size;
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
void ImageView::loadTexture(const std::string& fileName, TextureResType texType)
{
if (fileName.empty())
{
return;
}
_textureFile = fileName;
_imageTexType = texType;
switch (_imageTexType)
{
case TextureResType::LOCAL:
if (_scale9Enabled)
{
extension::Scale9Sprite* imageRendererScale9 = STATIC_CAST_SCALE9SPRITE;
imageRendererScale9->initWithFile(fileName);
imageRendererScale9->setCapInsets(_capInsets);
}
else
{
Sprite* imageRenderer = STATIC_CAST_CCSPRITE;
imageRenderer->setTexture(fileName);
}
break;
case TextureResType::PLIST:
if (_scale9Enabled)
{
extension::Scale9Sprite* imageRendererScale9 = STATIC_CAST_SCALE9SPRITE;
imageRendererScale9->initWithSpriteFrameName(fileName);
imageRendererScale9->setCapInsets(_capInsets);
}
else
{
Sprite* imageRenderer = STATIC_CAST_CCSPRITE;
imageRenderer->setSpriteFrame(fileName);
}
break;
default:
break;
}
_imageTextureSize = _imageRenderer->getContentSize();
updateFlippedX();
updateFlippedY();
updateContentSizeWithTextureSize(_imageTextureSize);
_imageRendererAdaptDirty = true;
}
void Text::setFontName(const std::string& name)
{
if(FileUtils::getInstance()->isFileExist(name))
{
TTFConfig config = _labelRenderer->getTTFConfig();
config.fontFilePath = name;
_labelRenderer->setTTFConfig(config);
_type = Type::TTF;
}
else{
_labelRenderer->setSystemFontName(name);
_type = Type::SYSTEM;
}
_fontName = name;
updateContentSizeWithTextureSize(_labelRenderer->getContentSize());
_labelRendererAdaptDirty = true;
}
void TextField::setFontName(const std::string& name)
{
if(FileUtils::getInstance()->isFileExist(name))
{
TTFConfig config = _textFieldRenderer->getTTFConfig();
config.fontFilePath = name;
config.fontSize = _fontSize;
_textFieldRenderer->setTTFConfig(config);
_fontType = FontType::TTF;
} else {
_textFieldRenderer->setSystemFontName(name);
if (_fontType == FontType::TTF)
{
_textFieldRenderer->requestSystemFontRefresh();
}
_fontType = FontType::SYSTEM;
}
_fontName = name;
_textFieldRendererAdaptDirty = true;
updateContentSizeWithTextureSize(_textFieldRenderer->getContentSize());
}
void LoadingBar::setupTexture()
{
_barRendererTextureSize = _barRenderer->getContentSize();
switch (_direction)
{
case Direction::LEFT:
_barRenderer->setAnchorPoint(Vec2(0.0f,0.5f));
if (!_scale9Enabled)
{
auto innerSprite = _barRenderer->getSprite();
if (nullptr != innerSprite)
{
innerSprite->setFlippedX(false);
}
}
break;
case Direction::RIGHT:
_barRenderer->setAnchorPoint(Vec2(1.0f,0.5f));
if (!_scale9Enabled)
{
auto innerSprite = _barRenderer->getSprite();
if (nullptr != innerSprite)
{
innerSprite->setFlippedX(true);
}
}
break;
}
_barRenderer->setCapInsets(_capInsets);
this->updateChildrenDisplayedRGBA();
barRendererScaleChangedWithSize();
updateContentSizeWithTextureSize(_barRendererTextureSize);
this->updateProgressBar();
_barRendererAdaptDirty = true;
}
void Slider::loadBarTexture(const std::string& fileName, TextureResType texType)
{
if (fileName.empty())
{
return;
}
_textureFile = fileName;
_barTexType = texType;
switch (_barTexType)
{
case TextureResType::LOCAL:
if (_scale9Enabled)
{
static_cast<extension::Scale9Sprite*>(_barRenderer)->initWithFile(fileName);
}
else
{
static_cast<Sprite*>(_barRenderer)->setTexture(fileName);
}
break;
case TextureResType::PLIST:
if (_scale9Enabled)
{
static_cast<extension::Scale9Sprite*>(_barRenderer)->initWithSpriteFrameName(fileName);
}
else
{
static_cast<Sprite*>(_barRenderer)->setSpriteFrame(fileName);
}
break;
default:
break;
}
updateRGBAToRenderer(_barRenderer);
_barRendererAdaptDirty = true;
_progressBarRendererDirty = true;
updateContentSizeWithTextureSize(_barRenderer->getContentSize());
}
