From f4d317f1fd3b6e78b2799c027703a7315b299fa1 Mon Sep 17 00:00:00 2001 From: XiaoFeng Date: Thu, 19 Nov 2015 15:21:14 +0800 Subject: [PATCH 01/20] Combine Studio change for get program file full path. --- cocos/platform/win32/CCFileUtils-win32.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/cocos/platform/win32/CCFileUtils-win32.cpp b/cocos/platform/win32/CCFileUtils-win32.cpp index ea3f9e6f12..3469b11e61 100644 --- a/cocos/platform/win32/CCFileUtils-win32.cpp +++ b/cocos/platform/win32/CCFileUtils-win32.cpp @@ -137,7 +137,13 @@ static void _checkPath() if (s_resourcePath.empty()) { WCHAR *pUtf16ExePath = nullptr; - _get_wpgmptr(&pUtf16ExePath); +#ifdef CC_STUDIO_ENABLED_VIEW + WCHAR utf16Path[CC_MAX_PATH] = { 0 }; + GetModuleFileNameW(NULL, utf16Path, CC_MAX_PATH - 1); + pUtf16ExePath = &(utf16Path[0]); +#else + _get_wpgmptr(&pUtf16ExePath); // CocoStudio Notice : This function won't work under studio, will cause a assert in system library +#endif // We need only directory part without exe WCHAR *pUtf16DirEnd = wcsrchr(pUtf16ExePath, L'\\'); From ccdb2a75f9e57fff72b67e6dbb6d7f2b9e88ab8d Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Thu, 19 Nov 2015 16:06:13 +0800 Subject: [PATCH 02/20] Add Label Overflow and wrap option. Squashed commit of the following: commit 7176582def3686f78701f92ead4d0976bccd115d Author: zilongshanren Date: Thu Nov 19 10:30:54 2015 +0800 add char map font test commit 7ea7c251ff549e4a74d5c5c3faa49893fe5defc4 Author: zilongshanren Date: Wed Nov 18 15:00:17 2015 +0800 system font overflow is not supported commit a02fe0c7f94692b95a0bfd6f194a94c4519cee3a Author: zilongshanren Date: Wed Nov 18 11:04:15 2015 +0800 add system font test commit eb098da8b16f485c86929a9b2ba00a64068264e9 Author: zilongshanren Date: Tue Nov 17 10:29:35 2015 +0800 Finish resize height mode commit ca78ba35abdbacc23bf6f8315454ec0a356a6aca Author: zilongshanren Date: Mon Nov 16 11:01:27 2015 +0800 fix wrap issue commit baf1a5e0dc3a08da0a13500aea5afc82017b054a Author: zilongshanren Date: Sat Nov 14 08:28:57 2015 +0800 horizontal shrink still has a issue commit 7e8abc0990cdf299d23c8072c5c1d4aa561bf798 Author: zilongshanren Date: Fri Nov 13 11:42:34 2015 +0800 finish shrink without wrap commit c9c45bd1f304ba00a6f9a274fa5631659a075bc1 Author: zilongshanren Date: Fri Nov 13 10:09:46 2015 +0800 update shrink commit ad82010ea846679e4d1a09f5127be29ae2e6adae Author: zilongshanren Date: Thu Nov 12 17:55:15 2015 +0800 refactor shrink logic commit effc1ee1cd9f06eaa4f46dd5c2a1401f6a285af6 Author: zilongshanren Date: Wed Nov 11 18:25:34 2015 +0800 add resize overflow type commit 194d552adc2a4ba2c439eff969b082556315e0ae Author: zilongshanren Date: Wed Nov 11 11:49:51 2015 +0800 no wrap, shrink is working. commit e2222ef14d5392817bd727895b3c2caec5ce4faf Author: zilongshanren Date: Tue Nov 10 16:16:27 2015 +0800 add overflow type to label. 1. optimize the testcase commit b65e2de4bfb3cb86a0d0cfa118be891a3f9fe858 Author: zilongshanren Date: Mon Nov 9 17:22:34 2015 +0800 finish bmfont wrap by char commit f339ff0309dc9e2ca2871f03f4551d329afce5e1 Author: zilongshanren Date: Mon Nov 9 17:04:51 2015 +0800 finish bmfont wrap by word commit 4c8edc65204a1294ac81315e72f1299acbdf43c0 Author: zilongshanren Date: Mon Nov 9 11:29:21 2015 +0800 add BMFont size support commit 3282481bda9dcb0f88b41f2568f7e5c856af6d53 Author: zilongshanren Date: Mon Nov 9 09:58:01 2015 +0800 add font size support for BMFONT commit 0c8e2a0374983625507a183cb2eb53a0b1709e25 Author: zilongshanren Date: Fri Nov 6 16:36:27 2015 +0800 add toggle wrap option. 1. make hirozontal clamp working commit 19dcd3e80a34c54b20934d08937eb270e689a7db Author: zilongshanren Date: Fri Nov 6 15:12:59 2015 +0800 tweak label layout commit e36a40babf4817ea7e9830614ac7560f2e69c583 Author: zilongshanren Date: Thu Nov 5 11:11:02 2015 +0800 finish the test skeleton commit a144a3a5d388d15c4f37cbfc12563eccabffb8e1 Author: zilongshanren Date: Wed Nov 4 16:38:54 2015 +0800 add setFontSize api to label. 1. add new chinese-english bmfont 2. beautify base test commit b22551c9eb3738fbb1c38ae4a3bfd07a202dcaf0 Author: zilongshanren Date: Wed Nov 4 11:27:18 2015 +0800 add label layout test skeleton --- cocos/2d/CCFontAtlas.cpp | 13 + cocos/2d/CCFontAtlas.h | 7 + cocos/2d/CCFontFNT.cpp | 28 +- cocos/2d/CCFontFNT.h | 6 +- cocos/2d/CCLabel.cpp | 378 +++++++-- cocos/2d/CCLabel.h | 81 +- cocos/2d/CCLabelTextFormatter.cpp | 137 +++- .../Classes/LabelTest/LabelTestNew.cpp | 731 ++++++++++++++++++ .../Classes/LabelTest/LabelTestNew.h | 120 +++ .../Resources/fonts/enligsh-chinese.fnt | 108 +++ .../Resources/fonts/enligsh-chinese.png | Bin 0 -> 79233 bytes 11 files changed, 1503 insertions(+), 106 deletions(-) create mode 100644 tests/cpp-tests/Resources/fonts/enligsh-chinese.fnt create mode 100644 tests/cpp-tests/Resources/fonts/enligsh-chinese.png diff --git a/cocos/2d/CCFontAtlas.cpp b/cocos/2d/CCFontAtlas.cpp index 8593a0f666..4dbb0f72d4 100644 --- a/cocos/2d/CCFontAtlas.cpp +++ b/cocos/2d/CCFontAtlas.cpp @@ -157,6 +157,19 @@ void FontAtlas::addLetterDefinition(char16_t utf16Char, const FontLetterDefiniti _letterDefinitions[utf16Char] = letterDefinition; } +void FontAtlas::scaleFontLetterDefinition(float scaleFactor) +{ + for (auto&& fontDefinition : _letterDefinitions) { + FontLetterDefinition letterDefinition = fontDefinition.second; + letterDefinition.width *= scaleFactor; + letterDefinition.height *= scaleFactor; + letterDefinition.offsetX *= scaleFactor; + letterDefinition.offsetY *= scaleFactor; + letterDefinition.xAdvance *= scaleFactor; + _letterDefinitions[fontDefinition.first] = letterDefinition; + } +} + bool FontAtlas::getLetterDefinitionForChar(char16_t utf16Char, FontLetterDefinition &letterDefinition) { auto outIterator = _letterDefinitions.find(utf16Char); diff --git a/cocos/2d/CCFontAtlas.h b/cocos/2d/CCFontAtlas.h index 4e147aea96..433c47b705 100644 --- a/cocos/2d/CCFontAtlas.h +++ b/cocos/2d/CCFontAtlas.h @@ -115,6 +115,13 @@ protected: void conversionU16TOGB2312(const std::u16string& u16Text, std::unordered_map& charCodeMap); + /** + * Scale each font letter by scaleFactor. + * + * @param scaleFactor A float scale factor for scaling font letter info. + */ + void scaleFontLetterDefinition(float scaleFactor); + std::unordered_map _atlasTextures; std::unordered_map _letterDefinitions; float _lineHeight; diff --git a/cocos/2d/CCFontFNT.cpp b/cocos/2d/CCFontFNT.cpp index 1a2ea333e9..4971d8d57e 100644 --- a/cocos/2d/CCFontFNT.cpp +++ b/cocos/2d/CCFontFNT.cpp @@ -119,6 +119,8 @@ public://@public // Character Set defines the letters that actually exist in the font std::set *_characterSet; + //! Font Size + int _fontSize; public: /** * @js ctor @@ -225,6 +227,7 @@ BMFontConfiguration::BMFontConfiguration() , _commonHeight(0) , _kerningDictionary(nullptr) , _characterSet(nullptr) +, _fontSize(0) { } @@ -539,7 +542,7 @@ void BMFontConfiguration::parseInfoArguments(const char* line) // info face="Script" size=32 bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=1 aa=1 padding=1,4,3,2 spacing=0,0 outline=0 // info face="Cracked" size=36 bold=0 italic=0 charset="" unicode=0 stretchH=100 smooth=1 aa=1 padding=0,0,0,0 spacing=1,1 ////////////////////////////////////////////////////////////////////////// - + sscanf(strstr(line, "size=") + 5, "%d", &_fontSize); // padding sscanf(strstr(line,"padding=") + 8, "%d,%d,%d,%d", &_padding.top, &_padding.right, &_padding.bottom, &_padding.left); //CCLOG("cocos2d: padding: %d,%d,%d,%d", _padding.left, _padding.top, _padding.right, _padding.bottom); @@ -647,7 +650,7 @@ FontFNT * FontFNT::create(const std::string& fntFilePath, const Vec2& imageOffse } FontFNT *tempFont = new FontFNT(newConf,imageOffset); - + tempFont->setFontSize(newConf->_fontSize); if (!tempFont) { return nullptr; @@ -716,6 +719,16 @@ int FontFNT::getHorizontalKerningForChars(unsigned short firstChar, unsigned sh return ret; } +void FontFNT::setFontSize(float fontSize) +{ + _fontSize = fontSize; +} + +int FontFNT::getOriginalFontSize()const +{ + return _configuration->_fontSize; +} + FontAtlas * FontFNT::createFontAtlas() { FontAtlas *tempAtlas = new (std::nothrow) FontAtlas(*this); @@ -734,7 +747,16 @@ FontAtlas * FontFNT::createFontAtlas() return nullptr; // common height - tempAtlas->setLineHeight(_configuration->_commonHeight); + int originalFontSize = _configuration->_fontSize; + float originalLineHeight = _configuration->_commonHeight; + float factor = 0.0f; + if (fabs(_fontSize - originalFontSize) < FLT_EPSILON) { + factor = 1.0f; + }else { + factor = _fontSize / originalFontSize; + } + + tempAtlas->setLineHeight(originalLineHeight * factor); BMFontDef fontDef; diff --git a/cocos/2d/CCFontFNT.h b/cocos/2d/CCFontFNT.h index d2b83e9886..ba734ae1e9 100644 --- a/cocos/2d/CCFontFNT.h +++ b/cocos/2d/CCFontFNT.h @@ -46,7 +46,8 @@ public: static void purgeCachedData(); virtual int* getHorizontalKerningForTextUTF16(const std::u16string& text, int &outNumLetters) const override; virtual FontAtlas *createFontAtlas() override; - + void setFontSize(float fontSize); + int getOriginalFontSize()const; protected: FontFNT(BMFontConfiguration *theContfig, const Vec2& imageOffset = Vec2::ZERO); @@ -62,7 +63,8 @@ private: BMFontConfiguration * _configuration; Vec2 _imageOffset; - + //User defined font size + float _fontSize; }; /// @endcond diff --git a/cocos/2d/CCLabel.cpp b/cocos/2d/CCLabel.cpp index 638a51704c..074d7efc23 100644 --- a/cocos/2d/CCLabel.cpp +++ b/cocos/2d/CCLabel.cpp @@ -39,6 +39,7 @@ #include "base/CCEventListenerCustom.h" #include "base/CCEventDispatcher.h" #include "base/CCEventCustom.h" +#include "2d/CCFontFNT.h" NS_CC_BEGIN @@ -472,6 +473,12 @@ void Label::reset() _blendFunc = BlendFunc::ALPHA_PREMULTIPLIED; _isOpacityModifyRGB = false; _insideBounds = true; + _enableWrap = true; + _bmFontSize = -1; + _bmfontScale = 1.0f; + _overflow = Overflow::NORMAL; + _originalFontSize = 0.0f; + } void Label::updateShaderProgram() @@ -548,46 +555,37 @@ void Label::setFontAtlas(FontAtlas* atlas,bool distanceFieldEnabled /* = false * bool Label::setTTFConfig(const TTFConfig& ttfConfig) { - FontAtlas *newAtlas = FontAtlasCache::getFontAtlasTTF(&ttfConfig); - - if (!newAtlas) - { - reset(); - return false; - } - _systemFontDirty = false; - - _currentLabelType = LabelType::TTF; - setFontAtlas(newAtlas,ttfConfig.distanceFieldEnabled,true); - - _fontConfig = ttfConfig; - if (_fontConfig.outlineSize > 0) - { - _fontConfig.distanceFieldEnabled = false; - _useDistanceField = false; - _useA8Shader = false; - _currLabelEffect = LabelEffect::OUTLINE; - updateShaderProgram(); - } - else - { - _currLabelEffect = LabelEffect::NORMAL; - updateShaderProgram(); - } - - return true; + _originalFontSize = ttfConfig.fontSize; + return setTTFConfigInternal(ttfConfig); } -bool Label::setBMFontFilePath(const std::string& bmfontFilePath, const Vec2& imageOffset /* = Vec2::ZERO */) +bool Label::setBMFontFilePath(const std::string& bmfontFilePath, const Vec2& imageOffset, float fontSize) { FontAtlas *newAtlas = FontAtlasCache::getFontAtlasFNT(bmfontFilePath,imageOffset); - + if (!newAtlas) { reset(); return false; } + + //asign the default fontSize + if (fabs(fontSize) < FLT_EPSILON) { + FontFNT *bmFont = (FontFNT*)newAtlas->getFont(); + if (bmFont) { + float originalFontSize = bmFont->getOriginalFontSize(); + if(fabs(_bmFontSize+1) < FLT_EPSILON){ + _bmFontSize = originalFontSize / CC_CONTENT_SCALE_FACTOR(); + } + } + } + + if(fontSize > 0){ + _bmFontSize = fontSize; + } + _bmFontPath = bmfontFilePath; + _currentLabelType = LabelType::BMFONT; setFontAtlas(newAtlas); @@ -631,6 +629,9 @@ void Label::setMaxLineWidth(float maxLineWidth) void Label::setDimensions(float width, float height) { + if(_overflow == Overflow::RESIZE_HEIGHT){ + height = 0; + } if (height != _labelHeight || width != _labelWidth) { _labelWidth = width; @@ -640,7 +641,26 @@ void Label::setDimensions(float width, float height) _maxLineWidth = width; _contentDirty = true; - } + + if(_overflow == Overflow::SHRINK){ + if (_originalFontSize > 0) { + this->restoreFontSize(); + } + } + } +} + +void Label::restoreFontSize() +{ + if(_currentLabelType == LabelType::TTF){ + auto ttfConfig = this->getTTFConfig(); + ttfConfig.fontSize = _originalFontSize; + this->setTTFConfigInternal(ttfConfig); + }else if(_currentLabelType == LabelType::BMFONT){ + this->setBMFontSizeInternal(_originalFontSize); + }else if(_currentLabelType == LabelType::STRING_TEXTURE){ + this->setSystemFontSize(_originalFontSize); + } } void Label::setLineBreakWithoutSpace(bool breakWithoutSpace) @@ -695,61 +715,94 @@ void Label::updateLabelLetters() auto py = letterInfo.positionY - letterDef.height / 2 + _letterOffsetY; letterSprite->setPosition(px, py); + if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0) { + _reusedLetter->setScale(_bmfontScale); + }else{ + if(fabs(_bmFontSize)setScale(0); + }else{ + _reusedLetter->setScale(1.0); + } + } ++it; } } } } -void Label::alignText() +bool Label::alignText() { if (_fontAtlas == nullptr || _utf16Text.empty()) { setContentSize(Size::ZERO); - return; + return true; } - _fontAtlas->prepareLetterDefinitions(_utf16Text); - auto& textures = _fontAtlas->getTextures(); - if (textures.size() > _batchNodes.size()) - { - for (auto index = _batchNodes.size(); index < textures.size(); ++index) + bool ret = true; + do { + _fontAtlas->prepareLetterDefinitions(_utf16Text); + auto& textures = _fontAtlas->getTextures(); + if (textures.size() > _batchNodes.size()) { - auto batchNode = SpriteBatchNode::createWithTexture(textures.at(index)); - if (batchNode) + for (auto index = _batchNodes.size(); index < textures.size(); ++index) { - _isOpacityModifyRGB = batchNode->getTexture()->hasPremultipliedAlpha(); - _blendFunc = batchNode->getBlendFunc(); - batchNode->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT); - batchNode->setPosition(Vec2::ZERO); - _batchNodes.pushBack(batchNode); + auto batchNode = SpriteBatchNode::createWithTexture(textures.at(index)); + if (batchNode) + { + _isOpacityModifyRGB = batchNode->getTexture()->hasPremultipliedAlpha(); + _blendFunc = batchNode->getBlendFunc(); + batchNode->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT); + batchNode->setPosition(Vec2::ZERO); + _batchNodes.pushBack(batchNode); + } } } - } - if (_batchNodes.empty()) - { - return; - } - _reusedLetter->setBatchNode(_batchNodes.at(0)); + if (_batchNodes.empty()) + { + return true; + } + _reusedLetter->setBatchNode(_batchNodes.at(0)); + + _lengthOfString = 0; + _textDesiredHeight = 0.f; + _linesWidth.clear(); + if (_maxLineWidth > 0.f && !_lineBreakWithoutSpaces) + { + multilineTextWrapByWord(); + } + else + { + multilineTextWrapByChar(); + } + computeAlignmentOffset(); - _lengthOfString = 0; - _textDesiredHeight = 0.f; - _linesWidth.clear(); - if (_maxLineWidth > 0.f && !_lineBreakWithoutSpaces) - { - multilineTextWrapByWord(); - } - else - { - multilineTextWrapByChar(); - } - computeAlignmentOffset(); + if(_enableWrap && _overflow == Overflow::SHRINK){ + float fontSize = 0; + if (_currentLabelType == LabelType::BMFONT) { + fontSize = _bmFontSize; + }else if(_currentLabelType == LabelType::TTF){ + fontSize = this->getTTFConfig().fontSize; + } - updateQuads(); + if(fontSize > 0 && isVerticalClamp()){ + this->shrinkLabelToContentSize(CC_CALLBACK_0(Label::isVerticalClamp, this)); + } + } - updateLabelLetters(); + if(!updateQuads()){ + ret = false; + if(!_enableWrap && _overflow == Overflow::SHRINK){ + this->shrinkLabelToContentSize(CC_CALLBACK_0(Label::isHorizontalClamp, this)); + } + break; + } + + updateLabelLetters(); + + updateColor(); + }while (0); - updateColor(); + return ret; } bool Label::computeHorizontalKernings(const std::u16string& stringToRender) @@ -769,13 +822,15 @@ bool Label::computeHorizontalKernings(const std::u16string& stringToRender) return true; } -void Label::updateQuads() +bool Label::updateQuads() { + bool ret = true; for (auto&& batchNode : _batchNodes) { batchNode->getTextureAtlas()->removeAllQuads(); } + bool letterClamp = false; for (int ctr = 0; ctr < _lengthOfString; ++ctr) { if (_lettersInfo[ctr].valid) @@ -802,16 +857,114 @@ void Label::updateQuads() } } + if(!_enableWrap){ + auto px = _lettersInfo[ctr].positionX + letterDef.width/2; + if(_labelWidth > 0.f){ + if (px > _contentSize.width) { + if(_overflow == Overflow::CLAMP){ + _reusedRect.size.width = 0; + }else if(_overflow == Overflow::SHRINK){ + if (letterDef.width > 0 + && _contentSize.width > letterDef.width) { + letterClamp = true; + ret = false; + break; + }else{ + //clamp + _reusedRect.size.width = 0; + } + + } + } + } + } + if (_reusedRect.size.height > 0.f && _reusedRect.size.width > 0.f) { _reusedLetter->setTextureRect(_reusedRect, false, _reusedRect.size); _reusedLetter->setPosition(_lettersInfo[ctr].positionX + _linesOffsetX[_lettersInfo[ctr].lineIndex], py); auto index = static_cast(_batchNodes.at(letterDef.textureID)->getTextureAtlas()->getTotalQuads()); _lettersInfo[ctr].atlasIndex = index; + + if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0) { + _reusedLetter->setScale(_bmfontScale); + }else{ + if(fabs(_bmFontSize)setScale(0); + }else{ + _reusedLetter->setScale(1.0); + } + } + _batchNodes.at(letterDef.textureID)->insertQuadFromSprite(_reusedLetter, index); } } } + + + return ret; +} + +bool Label::setTTFConfigInternal(const TTFConfig& ttfConfig) +{ + FontAtlas *newAtlas = FontAtlasCache::getFontAtlasTTF(&ttfConfig); + + if (!newAtlas) + { + reset(); + return false; + } + _systemFontDirty = false; + + _currentLabelType = LabelType::TTF; + setFontAtlas(newAtlas,ttfConfig.distanceFieldEnabled,true); + + _fontConfig = ttfConfig; + + if (_fontConfig.outlineSize > 0) + { + _fontConfig.distanceFieldEnabled = false; + _useDistanceField = false; + _useA8Shader = false; + _currLabelEffect = LabelEffect::OUTLINE; + updateShaderProgram(); + } + else + { + _currLabelEffect = LabelEffect::NORMAL; + updateShaderProgram(); + } + return true; +} + +void Label::setBMFontSizeInternal(float fontSize) +{ + if(_currentLabelType == LabelType::BMFONT){ + this->setBMFontFilePath(_bmFontPath, Vec2::ZERO, fontSize); + _contentDirty = true; + } +} + +void Label::scaleFontSizeDown(float fontSize) +{ + bool shouldUpdateContent = true; + if(_currentLabelType == LabelType::TTF){ + auto ttfConfig = this->getTTFConfig(); + ttfConfig.fontSize = fontSize; + this->setTTFConfigInternal(ttfConfig); + }else if(_currentLabelType == LabelType::BMFONT){ + if (fabs(fontSize) < FLT_EPSILON) { + fontSize = 0.1f; + shouldUpdateContent = false; + } + this->setBMFontSizeInternal(fontSize); + }else if (_currentLabelType == LabelType::STRING_TEXTURE){ + this->setSystemFontSize(fontSize); + } + + if (shouldUpdateContent) { + this->updateContent(); + } } void Label::enableGlow(const Color4B& glowColor) @@ -1102,6 +1255,7 @@ void Label::updateContent() CC_SAFE_RELEASE_NULL(_textSprite); CC_SAFE_RELEASE_NULL(_shadowNode); + bool updateFinished = true; if (_fontAtlas) { @@ -1112,7 +1266,7 @@ void Label::updateContent() } computeHorizontalKernings(_utf16Text); - alignText(); + updateFinished = alignText(); } else { @@ -1123,7 +1277,9 @@ void Label::updateContent() createShadowSpriteForSystemFont(fontDef); } } - _contentDirty = false; + if(updateFinished){ + _contentDirty = false; + } #if CC_LABEL_DEBUG_DRAW _debugDrawNode->clear(); @@ -1138,6 +1294,17 @@ void Label::updateContent() #endif } +void Label::setBMFontSize(float fontSize) +{ + this->setBMFontSizeInternal(fontSize); + _originalFontSize = fontSize; +} + +float Label::getBMFontSize()const +{ + return _bmFontSize; +} + void Label::onDrawShadow(GLProgram* glProgram) { if (_currentLabelType == LabelType::TTF) @@ -1381,6 +1548,7 @@ void Label::setSystemFontSize(float fontSize) if (_systemFontSize != fontSize) { _systemFontSize = fontSize; + _originalFontSize = fontSize; _systemFontDirty = true; } } @@ -1468,16 +1636,16 @@ float Label::getLineHeight() const void Label::setLineSpacing(float height) { - if (_lineSpacing != height) - { - _lineSpacing = height; - _contentDirty = true; - } + if (_lineSpacing != height) + { + _lineSpacing = height; + _contentDirty = true; + } } float Label::getLineSpacing() const { - return _lineSpacing; + return _lineSpacing; } void Label::setAdditionalKerning(float space) @@ -1753,4 +1921,64 @@ void Label::setGlobalZOrder(float globalZOrder) } } +float Label::getRenderingFontSize()const +{ + float fontSize; + if (_currentLabelType == LabelType::BMFONT) { + fontSize = _bmFontSize; + }else if(_currentLabelType == LabelType::TTF){ + fontSize = this->getTTFConfig().fontSize; + }else if(_currentLabelType == LabelType::STRING_TEXTURE){ + fontSize = _systemFontSize; + }else{ //FIXME: find a way to caculate char map font size + fontSize = this->getLineHeight(); + } + return fontSize; +} + +void Label::enableWrap(bool enable) +{ + if(enable == _enableWrap || _overflow == Overflow::RESIZE_HEIGHT + || _currentLabelType == LabelType::STRING_TEXTURE){ + return; + } + + this->_enableWrap = enable; + auto renderingFontSize = this->getRenderingFontSize(); + if (fabs(_originalFontSize - renderingFontSize) >= 1) { + this->scaleFontSizeDown(_originalFontSize); + } + + _contentDirty = true; +} + +bool Label::isWrapEnabled()const +{ + return this->_enableWrap; +} + +void Label::setOverflow(Overflow overflow) +{ + if(_overflow == overflow || _currentLabelType == LabelType::CHARMAP){ + return; + } + + if(overflow == Overflow::RESIZE_HEIGHT){ + this->setDimensions(_labelDimensions.width,0); + this->enableWrap(true); + } + _overflow = overflow; + + auto renderingFontSize = this->getRenderingFontSize(); + if (fabs(_originalFontSize - renderingFontSize) >= 1) { + this->scaleFontSizeDown(_originalFontSize); + } + _contentDirty = true; +} + +Label::Overflow Label::getOverflow()const +{ + return _overflow; +} + NS_CC_END diff --git a/cocos/2d/CCLabel.h b/cocos/2d/CCLabel.h index e54ec0ee6b..c5884c926e 100644 --- a/cocos/2d/CCLabel.h +++ b/cocos/2d/CCLabel.h @@ -95,6 +95,23 @@ class EventListenerCustom; class CC_DLL Label : public Node, public LabelProtocol, public BlendProtocol { public: + enum class Overflow + { + //for keep back compatibility + NORMAL, + /** + * In SHRINK mode, the font size will change dynamically to adapt the content size. + */ + SHRINK, + /** + *In CLAMP mode, when label content goes out of the bounding box, it will be clipped. + */ + CLAMP, + /** + *In RESIZE_HEIGHT mode, you can only change the width of label and the height is changed automatically. + */ + RESIZE_HEIGHT + }; /// @name Creators /// @{ @@ -221,7 +238,7 @@ public: virtual const TTFConfig& getTTFConfig() const { return _fontConfig;} /** Sets a new bitmap font to Label */ - virtual bool setBMFontFilePath(const std::string& bmfontFilePath, const Vec2& imageOffset = Vec2::ZERO); + virtual bool setBMFontFilePath(const std::string& bmfontFilePath, const Vec2& imageOffset = Vec2::ZERO, float fontSize = 0); /** Returns the bitmap font used by the Label.*/ const std::string& getBMFontFilePath() const { return _bmFontPath;} @@ -366,12 +383,53 @@ public: */ void setMaxLineWidth(float maxLineWidth); float getMaxLineWidth() { return _maxLineWidth; } + /** + * Change font size of label type BMFONT + * Note: This function only scale the BMFONT letter to mimic the font size change effect. + * + * @param fontSize The desired font size in float. + */ + void setBMFontSize(float fontSize); + /** + * Return the user define BMFont size. + * + * @return The BMFont size in float value. + */ + float getBMFontSize()const; + + /** + * Toggle wrap option the label. + * Note: System font doesn't support manually toggle wrap. + * + * @param enable Set true to enable wrap and false to disable wrap. + */ + void enableWrap(bool enable); + + /** + * Query the wrap is enabled or not. + * Note: System font will always return true. + */ + bool isWrapEnabled()const; + + /** + * Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type. + * + * @param overflow see `Overflow` + */ + void setOverflow(Overflow overflow); + + /** + * Query the label's Overflow type. + * + * @return see `Overflow` + */ + Overflow getOverflow()const; /** * Makes the Label exactly this untransformed width. * * The Label's width be used for text align if the value not equal zero. - */ + */ void setWidth(float width) { setDimensions(width,_labelHeight);} float getWidth() const { return _labelWidth; } @@ -508,21 +566,30 @@ protected: bool multilineTextWrapByChar(); bool multilineTextWrapByWord(); + void shrinkLabelToContentSize(std::function lambda); + bool isHorizontalClamp(); + bool isVerticalClamp(); + float getRenderingFontSize()const; void updateLabelLetters(); - virtual void alignText(); + virtual bool alignText(); void computeAlignmentOffset(); bool computeHorizontalKernings(const std::u16string& stringToRender); void recordLetterInfo(const cocos2d::Vec2& point, char16_t utf16Char, int letterIndex, int lineIndex); void recordPlaceholderInfo(int letterIndex, char16_t utf16Char); - void updateQuads(); + bool updateQuads(); void createSpriteForSystemFont(const FontDefinition& fontDef); void createShadowSpriteForSystemFont(const FontDefinition& fontDef); virtual void updateShaderProgram(); + void updateBMFontScale(); + void scaleFontSizeDown(float fontSize); + bool setTTFConfigInternal(const TTFConfig& ttfConfig); + void setBMFontSizeInternal(float fontSize); + void restoreFontSize(); void reset(); @@ -614,6 +681,12 @@ protected: #if CC_LABEL_DEBUG_DRAW DrawNode* _debugDrawNode; #endif + + bool _enableWrap; + float _bmFontSize; + float _bmfontScale; + Overflow _overflow; + float _originalFontSize; private: CC_DISALLOW_COPY_AND_ASSIGN(Label); }; diff --git a/cocos/2d/CCLabelTextFormatter.cpp b/cocos/2d/CCLabelTextFormatter.cpp index b83748f996..cc22d83b8c 100644 --- a/cocos/2d/CCLabelTextFormatter.cpp +++ b/cocos/2d/CCLabelTextFormatter.cpp @@ -28,6 +28,7 @@ #include "base/ccUTF8.h" #include "base/CCDirector.h" #include "2d/CCFontAtlas.h" +#include "2d/CCFontFNT.h" NS_CC_BEGIN @@ -93,6 +94,18 @@ static int getFirstWordLen(const std::u16string& utf16Text, int startIndex, int return len; } +void Label::updateBMFontScale() +{ + auto font = _fontAtlas->getFont(); + if (_currentLabelType == LabelType::BMFONT) { + FontFNT *bmFont = (FontFNT*)font; + float originalFontSize = bmFont->getOriginalFontSize(); + _bmfontScale = _bmFontSize * CC_CONTENT_SCALE_FACTOR() / originalFontSize; + }else{ + _bmfontScale = 1.0f; + } +} + bool Label::multilineTextWrapByWord() { int textLen = getStringLength(); @@ -108,7 +121,9 @@ bool Label::multilineTextWrapByWord() float lowestY = 0.f; FontLetterDefinition letterDef; Vec2 letterPosition; - + + this->updateBMFontScale(); + for (int index = 0; index < textLen; ) { auto character = _utf16Text[index]; @@ -118,7 +133,7 @@ bool Label::multilineTextWrapByWord() letterRight = 0.f; lineIndex++; nextWordX = 0.f; - nextWordY -= _lineHeight + lineSpacing; + nextWordY -= _lineHeight*_bmfontScale + lineSpacing; recordPlaceholderInfo(index, character); index++; continue; @@ -146,14 +161,14 @@ bool Label::multilineTextWrapByWord() continue; } - auto letterX = (nextLetterX + letterDef.offsetX) / contentScaleFactor; - if (_maxLineWidth > 0.f && nextWordX > 0.f && letterX + letterDef.width > _maxLineWidth) + auto letterX = (nextLetterX + letterDef.offsetX * _bmfontScale) / contentScaleFactor; + if (_enableWrap && _maxLineWidth > 0.f && nextWordX > 0.f && letterX + letterDef.width * _bmfontScale > _maxLineWidth) { _linesWidth.push_back(letterRight); letterRight = 0.f; lineIndex++; nextWordX = 0.f; - nextWordY -= _lineHeight + lineSpacing; + nextWordY -= (_lineHeight*_bmfontScale + lineSpacing); newLine = true; break; } @@ -161,19 +176,19 @@ bool Label::multilineTextWrapByWord() { letterPosition.x = letterX; } - letterPosition.y = (nextWordY - letterDef.offsetY) / contentScaleFactor; + letterPosition.y = (nextWordY - letterDef.offsetY * _bmfontScale) / contentScaleFactor; recordLetterInfo(letterPosition, character, letterIndex, lineIndex); if (_horizontalKernings && letterIndex < textLen - 1) nextLetterX += _horizontalKernings[letterIndex + 1]; - nextLetterX += letterDef.xAdvance + _additionalKerning; + nextLetterX += letterDef.xAdvance * _bmfontScale + _additionalKerning; - wordRight = letterPosition.x + letterDef.width; + wordRight = letterPosition.x + letterDef.width * _bmfontScale; if (wordHighestY < letterPosition.y) wordHighestY = letterPosition.y; - if (wordLowestY > letterPosition.y - letterDef.height) - wordLowestY = letterPosition.y - letterDef.height; + if (wordLowestY > letterPosition.y - letterDef.height * _bmfontScale) + wordLowestY = letterPosition.y - letterDef.height * _bmfontScale; } if (newLine) @@ -196,7 +211,7 @@ bool Label::multilineTextWrapByWord() _linesWidth.push_back(letterRight); _numberOfLines = lineIndex + 1; - _textDesiredHeight = (_numberOfLines * _lineHeight) / contentScaleFactor; + _textDesiredHeight = (_numberOfLines * _lineHeight * _bmfontScale) / contentScaleFactor; if (_numberOfLines > 1) _textDesiredHeight += (_numberOfLines - 1) * _lineSpacing; Size contentSize(_labelWidth, _labelHeight); @@ -232,6 +247,8 @@ bool Label::multilineTextWrapByChar() FontLetterDefinition letterDef; Vec2 letterPosition; + this->updateBMFontScale(); + for (int index = 0; index < textLen; index++) { auto character = _utf16Text[index]; @@ -246,7 +263,7 @@ bool Label::multilineTextWrapByChar() letterRight = 0.f; lineIndex++; nextLetterX = 0.f; - nextLetterY -= _lineHeight + lineSpacing; + nextLetterY -= _lineHeight * _bmfontScale + lineSpacing; recordPlaceholderInfo(index, character); continue; } @@ -258,33 +275,33 @@ bool Label::multilineTextWrapByChar() continue; } - auto letterX = (nextLetterX + letterDef.offsetX) / contentScaleFactor; - if (_maxLineWidth > 0.f && nextLetterX > 0.f && letterX + letterDef.width > _maxLineWidth) + auto letterX = (nextLetterX + letterDef.offsetX * _bmfontScale) / contentScaleFactor; + if (_enableWrap && _maxLineWidth > 0.f && nextLetterX > 0.f && letterX + letterDef.width * _bmfontScale > _maxLineWidth) { _linesWidth.push_back(letterRight); letterRight = 0.f; lineIndex++; nextLetterX = 0.f; - nextLetterY -= _lineHeight + lineSpacing; - letterPosition.x = letterDef.offsetX / contentScaleFactor; + nextLetterY -= _lineHeight * _bmfontScale + lineSpacing; + letterPosition.x = letterDef.offsetX * _bmfontScale / contentScaleFactor; } else { letterPosition.x = letterX; } - letterPosition.y = (nextLetterY - letterDef.offsetY) / contentScaleFactor; + letterPosition.y = (nextLetterY - letterDef.offsetY * _bmfontScale) / contentScaleFactor; recordLetterInfo(letterPosition, character, index, lineIndex); if (_horizontalKernings && index < textLen - 1) nextLetterX += _horizontalKernings[index + 1]; - nextLetterX += letterDef.xAdvance + _additionalKerning; + nextLetterX += letterDef.xAdvance * _bmfontScale + _additionalKerning; - letterRight = letterPosition.x + letterDef.width; + letterRight = letterPosition.x + letterDef.width * _bmfontScale; if (highestY < letterPosition.y) highestY = letterPosition.y; - if (lowestY > letterPosition.y - letterDef.height) - lowestY = letterPosition.y - letterDef.height; + if (lowestY > letterPosition.y - letterDef.height * _bmfontScale) + lowestY = letterPosition.y - letterDef.height * _bmfontScale; if (longestLine < letterRight) longestLine = letterRight; } @@ -292,7 +309,7 @@ bool Label::multilineTextWrapByChar() _linesWidth.push_back(letterRight); _numberOfLines = lineIndex + 1; - _textDesiredHeight = (_numberOfLines * _lineHeight) / contentScaleFactor; + _textDesiredHeight = (_numberOfLines * _lineHeight * _bmfontScale) / contentScaleFactor; if (_numberOfLines > 1) _textDesiredHeight += (_numberOfLines - 1) * _lineSpacing; Size contentSize(_labelWidth, _labelHeight); @@ -300,6 +317,7 @@ bool Label::multilineTextWrapByChar() contentSize.width = longestLine; if (_labelHeight <= 0.f) contentSize.height = _textDesiredHeight; + setContentSize(contentSize); _tailoredTopY = contentSize.height; @@ -312,6 +330,81 @@ bool Label::multilineTextWrapByChar() return true; } +bool Label::isVerticalClamp() +{ + if (_textDesiredHeight > _contentSize.height) + { + return true; + } + else + { + return false; + } +} + +bool Label::isHorizontalClamp() +{ + bool letterClamp = false; + for (int ctr = 0; ctr < _lengthOfString; ++ctr) + { + if (_lettersInfo[ctr].valid) + { + auto& letterDef = _fontAtlas->_letterDefinitions[_lettersInfo[ctr].utf16Char]; + + auto px = _lettersInfo[ctr].positionX + letterDef.width/2; + if(_labelWidth > 0.f){ + if (px > _contentSize.width) { + letterClamp = true; + break; + } + } + } + } + + return letterClamp; +} + +void Label::shrinkLabelToContentSize(std::function lambda) +{ + float fontSize = this->getRenderingFontSize(); + + int i = 0; + auto letterDefinition = _fontAtlas->_letterDefinitions; + auto tempLetterDefinition = letterDefinition; + float originalLineHeight = this->getLineHeight(); + bool flag = true; + while (lambda()) { + ++i; + float newFontSize = fontSize - i; + flag = false; + if (newFontSize <= 0) { + break; + } + float scale = newFontSize / fontSize; + std::swap(_fontAtlas->_letterDefinitions, tempLetterDefinition); + _fontAtlas->scaleFontLetterDefinition(scale); + this->setLineHeight(originalLineHeight * scale); + if (_maxLineWidth > 0.f && !_lineBreakWithoutSpaces) + { + multilineTextWrapByWord(); + } + else + { + multilineTextWrapByChar(); + } + computeAlignmentOffset(); + tempLetterDefinition = letterDefinition; + } + this->setLineHeight(originalLineHeight); + std::swap(_fontAtlas->_letterDefinitions, letterDefinition); + + if (!flag) { + if (fontSize - i >= 0) { + this->scaleFontSizeDown(fontSize - i); + } + } +} + void Label::recordLetterInfo(const cocos2d::Vec2& point, char16_t utf16Char, int letterIndex, int lineIndex) { if (static_cast(letterIndex) >= _lettersInfo.size()) diff --git a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp index effdf3d436..09d7300e61 100644 --- a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp +++ b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp @@ -5,6 +5,7 @@ USING_NS_CC; using namespace ui; +using namespace extension; enum { kTagTileMap = 1, @@ -88,6 +89,14 @@ NewLabelTests::NewLabelTests() ADD_TEST_CASE(LabelIssue10688Test); ADD_TEST_CASE(LabelIssue13202Test); ADD_TEST_CASE(LabelIssue9500Test); + ADD_TEST_CASE(LabelWrapByWordTest); + ADD_TEST_CASE(LabelWrapByCharTest); + ADD_TEST_CASE(LabelShrinkByWordTest); + ADD_TEST_CASE(LabelShrinkByCharTest); + ADD_TEST_CASE(LabelResizeTest); + ADD_TEST_CASE(LabelToggleTypeTest); + ADD_TEST_CASE(LabelSystemFontTest); + ADD_TEST_CASE(LabelCharMapFontTest); }; LabelFNTColorAndOpacity::LabelFNTColorAndOpacity() @@ -2003,3 +2012,725 @@ std::string LabelIssue9500Test::subtitle() const { return "Spaces should not be lost if label created with Fingerpop.ttf"; } + +ControlStepper *LabelLayoutBaseTest::makeControlStepper() +{ + auto minusSprite = Sprite::create("extensions/stepper-minus.png"); + auto plusSprite = Sprite::create("extensions/stepper-plus.png"); + + return ControlStepper::create(minusSprite, plusSprite); +} + +LabelLayoutBaseTest::LabelLayoutBaseTest() +{ + auto size = Director::getInstance()->getVisibleSize(); + + this->initTestLabel(size); + + this->initFontSizeChange(size); + this->initToggleLabelTypeOption(size); + + this->initWrapOption(size); + + this->initAlignmentOption(size); + + this->initDrawNode(size); + + this->initSliders(size); +} + +void LabelLayoutBaseTest::initFontSizeChange(const cocos2d::Size& size) +{ + auto fontSizeLabel = Label::createWithSystemFont("font size:20", "Arial", 10); + fontSizeLabel->setName("fontSize"); + + ControlStepper *stepper = this->makeControlStepper(); + stepper->setPosition(size.width * 0.5 - stepper->getContentSize().width / 2, + size.height * 0.8); + stepper->setValue(20); + stepper->addTargetWithActionForControlEvents(this, + cccontrol_selector(LabelLayoutBaseTest::valueChanged), + Control::EventType::VALUE_CHANGED); + this->addChild(stepper); + stepper->setName("stepper"); + stepper->setScale(0.5); + + fontSizeLabel->setPosition(stepper->getPosition() - + Vec2(stepper->getContentSize().width/2 + fontSizeLabel->getContentSize().width/2,0)); + this->addChild(fontSizeLabel); +} + +void LabelLayoutBaseTest::initWrapOption(const cocos2d::Size& size) +{ + auto label = Label::createWithSystemFont("Enable Wrap:", "Arial", 10); + label->setColor(Color3B::WHITE); + label->setPosition(Vec2(size.width * 0.8f - 100, size.height * 0.8f)); + this->addChild(label); + + CheckBox* checkBox = CheckBox::create("cocosui/check_box_normal.png", + "cocosui/check_box_normal_press.png", + "cocosui/check_box_active.png", + "cocosui/check_box_normal_disable.png", + "cocosui/check_box_active_disable.png"); + checkBox->setPosition(Vec2(size.width * 0.8f - 55, size.height * 0.8f)); + checkBox->setScale(0.5); + checkBox->setSelected(true); + checkBox->setName("toggleWrap"); + + checkBox->addEventListener([=](Ref* ref, CheckBox::EventType event){ + if (event == CheckBox::EventType::SELECTED) { + _label->enableWrap(true); + }else{ + _label->enableWrap(false); + } + this->updateDrawNodeSize(_label->getContentSize()); + }); + this->addChild(checkBox); +} + +void LabelLayoutBaseTest::initToggleLabelTypeOption(const cocos2d::Size& size) +{ + auto label = Label::createWithSystemFont("Toggle Label Type:", "Arial", 10); + label->setColor(Color3B::WHITE); + label->setPosition(Vec2(size.width * 0.8f + 15, size.height * 0.8f)); + this->addChild(label); + + CheckBox* checkBox = CheckBox::create("cocosui/check_box_normal.png", + "cocosui/check_box_normal_press.png", + "cocosui/check_box_active.png", + "cocosui/check_box_normal_disable.png", + "cocosui/check_box_active_disable.png"); + checkBox->setPosition(Vec2(size.width * 0.8f + 70, size.height * 0.8f)); + checkBox->setScale(0.5); + checkBox->setName("toggleType"); + checkBox->setSelected(true); + + auto stepper = (ControlStepper*)this->getChildByName("stepper"); + + checkBox->addEventListener([=](Ref* ref, CheckBox::EventType event){ + float fontSize = stepper->getValue(); + + if (event == CheckBox::EventType::SELECTED) { + _labelType = 0; + auto ttfConfig = _label->getTTFConfig(); + ttfConfig.fontSize = fontSize; + _label->setTTFConfig(ttfConfig); + }else{ + _labelType = 1; + _label->setBMFontFilePath("fonts/enligsh-chinese.fnt"); + _label->setBMFontSize(fontSize); + } + }); + this->addChild(checkBox); + +} + +void LabelLayoutBaseTest::initAlignmentOption(const cocos2d::Size& size) +{ + //add text alignment settings + MenuItemFont::setFontSize(30); + auto menu = Menu::create( + MenuItemFont::create("Left", CC_CALLBACK_1(LabelLayoutBaseTest::setAlignmentLeft, this)), + MenuItemFont::create("Center", CC_CALLBACK_1(LabelLayoutBaseTest::setAlignmentCenter, this)), + MenuItemFont::create("Right", CC_CALLBACK_1(LabelLayoutBaseTest::setAlignmentRight, this)), + nullptr); + menu->alignItemsVerticallyWithPadding(4); + menu->setPosition(Vec2(50, size.height / 2 - 20)); + this->addChild(menu); + + menu = Menu::create( + MenuItemFont::create("Top", CC_CALLBACK_1(LabelLayoutBaseTest::setAlignmentTop, this)), + MenuItemFont::create("Middle", CC_CALLBACK_1(LabelLayoutBaseTest::setAlignmentMiddle, this)), + MenuItemFont::create("Bottom", CC_CALLBACK_1(LabelLayoutBaseTest::setAlignmentBottom, this)), + nullptr); + menu->alignItemsVerticallyWithPadding(4); + menu->setPosition(Vec2(size.width - 50, size.height / 2 - 20)); + this->addChild(menu); +} + +void LabelLayoutBaseTest::initSliders(const cocos2d::Size& size) +{ + auto slider = ui::Slider::create(); + slider->setTag(1); + slider->setTouchEnabled(true); + slider->loadBarTexture("cocosui/sliderTrack.png"); + slider->loadSlidBallTextures("cocosui/sliderThumb.png", "cocosui/sliderThumb.png", ""); + slider->loadProgressBarTexture("cocosui/sliderProgress.png"); + slider->setPosition(Vec2(size.width / 2.0f, size.height * 0.15f + slider->getContentSize().height * 2.0f - 5)); + slider->setPercent(52); + addChild(slider); + + auto slider2 = ui::Slider::create(); + slider2->setTag(2); + slider2->setTouchEnabled(true); + slider2->loadBarTexture("cocosui/sliderTrack.png"); + slider2->loadSlidBallTextures("cocosui/sliderThumb.png", "cocosui/sliderThumb.png", ""); + slider2->loadProgressBarTexture("cocosui/sliderProgress.png"); + slider2->setPosition(Vec2(size.width * 0.2f, size.height / 2.0)); + slider2->setRotation(90); + slider2->setPercent(52); + addChild(slider2); + auto winSize = Director::getInstance()->getVisibleSize(); + auto labelSize = _label->getContentSize(); + + slider->addEventListener([=](Ref* ref, Slider::EventType event){ + float percent = slider->getPercent(); + auto drawNodeSize = Size(percent / 100.0 * winSize.width, labelSize.height); + if(drawNodeSize.width <=0){ + drawNodeSize.width = 0.1f; + } + _label->setDimensions(drawNodeSize.width, drawNodeSize.height); + this->updateDrawNodeSize(drawNodeSize); + }); + + slider2->addEventListener([=](Ref* ref, Slider::EventType event){ + float percent = slider2->getPercent(); + auto drawNodeSize = Size( labelSize.width, percent / 100.0 * winSize.height); + if(drawNodeSize.height <= 0){ + drawNodeSize.height = 0.1f; + } + _label->setDimensions(drawNodeSize.width, drawNodeSize.height); + this->updateDrawNodeSize(drawNodeSize); + }); +} + +void LabelLayoutBaseTest::initTestLabel(const cocos2d::Size& size) +{ + auto center = VisibleRect::center(); + _label = Label::createWithTTF("五六七八This is a very long sentence一二三四.", "fonts/HKYuanMini.ttf", 20); + _label->setDimensions(size.width/2, size.height/2); + _label->setPosition(center); + _label->setName("Label"); + _label->setString("五六七八This is a very long sentence一二三."); + addChild(_label); + _labelType = 0; +} + +void LabelLayoutBaseTest::initDrawNode(const cocos2d::Size& size) +{ + _drawNode = DrawNode::create(); + + _drawNode->setTag(3); + addChild(_drawNode); + this->updateDrawNodeSize(_label->getContentSize()); +} + + +void LabelLayoutBaseTest::setAlignmentLeft(Ref* sender) +{ + _label->setHorizontalAlignment(TextHAlignment::LEFT); +} + +void LabelLayoutBaseTest::setAlignmentCenter(Ref* sender) +{ + _label->setHorizontalAlignment(TextHAlignment::CENTER); +} + +void LabelLayoutBaseTest::setAlignmentRight(Ref* sender) +{ + _label->setHorizontalAlignment(TextHAlignment::RIGHT); +} + +void LabelLayoutBaseTest::setAlignmentTop(Ref* sender) +{ + _label->setVerticalAlignment(TextVAlignment::TOP); +} + +void LabelLayoutBaseTest::setAlignmentMiddle(Ref* sender) +{ + _label->setVerticalAlignment(TextVAlignment::CENTER); +} + +void LabelLayoutBaseTest::setAlignmentBottom(Ref* sender) +{ + _label->setVerticalAlignment(TextVAlignment::BOTTOM); +} + + +void LabelLayoutBaseTest::valueChanged(cocos2d::Ref *sender, cocos2d::extension::Control::EventType controlEvent) +{ + ControlStepper* pControl = (ControlStepper*)sender; + // Change value of label. + auto fontSizeLabel = (Label*)this->getChildByName("fontSize"); + float fontSize = (float)pControl->getValue(); + fontSizeLabel->setString(StringUtils::format("font size:%d", (int)fontSize)); + + if (_labelType == 0) { + auto ttfConfig = _label->getTTFConfig(); + ttfConfig.fontSize = fontSize; + _label->setTTFConfig(ttfConfig); + }else if(_labelType == 1){ + _label->setBMFontSize(fontSize); + } + this->updateDrawNodeSize(_label->getContentSize()); +} + +void LabelLayoutBaseTest::updateDrawNodeSize(const cocos2d::Size &drawNodeSize) +{ + auto origin = Director::getInstance()->getWinSize(); + auto labelSize = _label->getContentSize(); + + origin.width = origin.width / 2 - (labelSize.width / 2); + origin.height = origin.height / 2 - (labelSize.height / 2); + + Vec2 vertices[4]= + { + Vec2(origin.width, origin.height), + Vec2(drawNodeSize.width + origin.width, origin.height), + Vec2(drawNodeSize.width + origin.width, drawNodeSize.height + origin.height), + Vec2(origin.width, drawNodeSize.height + origin.height) + }; + _drawNode->clear(); + _drawNode->drawLine(vertices[0], vertices[1], Color4F(1.0, 1.0, 1.0, 1.0)); + _drawNode->drawLine(vertices[0], vertices[3], Color4F(1.0, 1.0, 1.0, 1.0)); + _drawNode->drawLine(vertices[2], vertices[3], Color4F(1.0, 1.0, 1.0, 1.0)); + _drawNode->drawLine(vertices[1], vertices[2], Color4F(1.0, 1.0, 1.0, 1.0)); + +} + +LabelWrapByWordTest::LabelWrapByWordTest() +{ + _label->setLineSpacing(5); + _label->setAdditionalKerning(2); + _label->setVerticalAlignment(TextVAlignment::CENTER); + _label->setOverflow(Label::Overflow::CLAMP); + +} + +std::string LabelWrapByWordTest::title() const +{ + return "Clamp content Test: Word Wrap"; +} + +std::string LabelWrapByWordTest::subtitle() const +{ + return ""; +} + +LabelWrapByCharTest::LabelWrapByCharTest() +{ + _label->setLineBreakWithoutSpace(true); + _label->setLineSpacing(5); + _label->setAdditionalKerning(2); + _label->setVerticalAlignment(TextVAlignment::TOP); + _label->setOverflow(Label::Overflow::CLAMP); + +} + +std::string LabelWrapByCharTest::title() const +{ + return "Clamp content Test: Char Wrap"; +} + +std::string LabelWrapByCharTest::subtitle() const +{ + return ""; +} + +LabelShrinkByWordTest::LabelShrinkByWordTest() +{ + _label->setLineSpacing(5); + _label->setAdditionalKerning(2); + _label->setString("This is Hello World hehe I love 一二三"); + _label->setVerticalAlignment(TextVAlignment::TOP); + _label->setOverflow(Label::Overflow::SHRINK); +} + +std::string LabelShrinkByWordTest::title() const +{ + return "Shrink content Test: Word Wrap"; +} + +std::string LabelShrinkByWordTest::subtitle() const +{ + return ""; +} + +LabelShrinkByCharTest::LabelShrinkByCharTest() +{ + _label->setLineSpacing(5); + _label->setAdditionalKerning(2); + _label->setLineBreakWithoutSpace(true); + _label->setString("This is Hello World hehe I love 一二三"); + _label->setVerticalAlignment(TextVAlignment::CENTER); + _label->setOverflow(Label::Overflow::SHRINK); +} + +std::string LabelShrinkByCharTest::title() const +{ + return "Shrink content Test: Char Wrap"; +} + +std::string LabelShrinkByCharTest::subtitle() const +{ + return ""; +} + +LabelResizeTest::LabelResizeTest() +{ + _label->setLineSpacing(5); + _label->setAdditionalKerning(2); + _label->setVerticalAlignment(TextVAlignment::TOP); + _label->setOverflow(Label::Overflow::RESIZE_HEIGHT); + + + this->updateDrawNodeSize(_label->getContentSize()); + + auto slider1 = (ui::Slider*)this->getChildByTag(1); + + auto slider2 = (ui::Slider*)this->getChildByTag(2); + slider2->setVisible(false); + + auto winSize = Director::getInstance()->getVisibleSize(); + slider1->addEventListener([=](Ref* ref, Slider::EventType event){ + float percent = slider1->getPercent(); + auto drawNodeSize = Size(percent / 100.0 * winSize.width,_label->getContentSize().height); + if(drawNodeSize.height <= 0){ + drawNodeSize.height = 0.1f; + } + _label->setDimensions(drawNodeSize.width, drawNodeSize.height); + this->updateDrawNodeSize(drawNodeSize); + }); + + auto stepper = (ControlStepper*)this->getChildByName("stepper"); + stepper->setValue(12); + + auto label = Label::createWithSystemFont("Word Line break:", "Arial", 10); + label->setColor(Color3B::WHITE); + label->setPosition(Vec2(winSize.width * 0.1f, winSize.height * 0.8f)); + this->addChild(label); + + CheckBox* checkBox = CheckBox::create("cocosui/check_box_normal.png", + "cocosui/check_box_normal_press.png", + "cocosui/check_box_active.png", + "cocosui/check_box_normal_disable.png", + "cocosui/check_box_active_disable.png"); + checkBox->setPosition(Vec2(winSize.width * 0.2f , winSize.height * 0.8f)); + checkBox->setScale(0.5); + checkBox->setSelected(false); + checkBox->setName("LineBreak"); + + checkBox->addEventListener([=](Ref* ref, CheckBox::EventType event){ + if (event == CheckBox::EventType::SELECTED) { + _label->setLineBreakWithoutSpace(true); + }else{ + _label->setLineBreakWithoutSpace(false); + } + this->updateDrawNodeSize(_label->getContentSize()); + }); + this->addChild(checkBox); + +} + +std::string LabelResizeTest::title() const +{ + return "Resize content Test"; +} + +std::string LabelResizeTest::subtitle() const +{ + return ""; +} + +LabelToggleTypeTest::LabelToggleTypeTest() +{ + _label->setLineSpacing(5); + _label->setAdditionalKerning(2); + _label->setVerticalAlignment(TextVAlignment::CENTER); + _label->setOverflow(Label::Overflow::NORMAL); + + + this->updateDrawNodeSize(_label->getContentSize()); + + auto slider1 = (ui::Slider*)this->getChildByTag(1); + + auto slider2 = (ui::Slider*)this->getChildByTag(2); + slider2->setVisible(false); + + auto winSize = Director::getInstance()->getVisibleSize(); + slider1->addEventListener([=](Ref* ref, Slider::EventType event){ + float percent = slider1->getPercent(); + auto drawNodeSize = Size(percent / 100.0 * winSize.width,_label->getContentSize().height); + if(drawNodeSize.height <= 0){ + drawNodeSize.height = 0.1f; + } + _label->setDimensions(drawNodeSize.width, drawNodeSize.height); + this->updateDrawNodeSize(drawNodeSize); + }); + + auto stepper = (ControlStepper*)this->getChildByName("stepper"); + stepper->setValue(12); + + auto label = Label::createWithSystemFont("Word Line break:", "Arial", 10); + label->setColor(Color3B::WHITE); + label->setPosition(Vec2(winSize.width * 0.1f, winSize.height * 0.8f)); + this->addChild(label); + + CheckBox* checkBox = CheckBox::create("cocosui/check_box_normal.png", + "cocosui/check_box_normal_press.png", + "cocosui/check_box_active.png", + "cocosui/check_box_normal_disable.png", + "cocosui/check_box_active_disable.png"); + checkBox->setPosition(Vec2(winSize.width * 0.2f , winSize.height * 0.8f)); + checkBox->setScale(0.5); + checkBox->setSelected(false); + checkBox->setName("LineBreak"); + + checkBox->addEventListener([=](Ref* ref, CheckBox::EventType event){ + if (event == CheckBox::EventType::SELECTED) { + _label->setLineBreakWithoutSpace(true); + }else{ + _label->setLineBreakWithoutSpace(false); + } + this->updateDrawNodeSize(_label->getContentSize()); + }); + this->addChild(checkBox); + + this->initToggleCheckboxes(); +} + +void LabelToggleTypeTest::initToggleCheckboxes() +{ + const float BUTTON_WIDTH = 100; + float startPosX = 0; + Size winSize = Director::getInstance()->getVisibleSize(); + + // Create a radio button group + auto radioButtonGroup = RadioButtonGroup::create(); + this->addChild(radioButtonGroup); + + // Create the radio buttons + static const int NUMBER_OF_BUTTONS = 4; + startPosX = winSize.width / 2.0f - (NUMBER_OF_BUTTONS - 1 ) * 0.5 * BUTTON_WIDTH - 30; + std::vector labelTypes = {"Normal", "Clamp", "Shrink", "RESIZE"}; + + for(int i = 0; i < NUMBER_OF_BUTTONS; ++i) + { + + RadioButton* radioButton = RadioButton::create("cocosui/radio_button_off.png", "cocosui/radio_button_on.png"); + float posX = startPosX + BUTTON_WIDTH * i; + radioButton->setPosition(Vec2(posX, winSize.height / 2.0f + 70)); + radioButton->setScale(1.2f); + radioButton->addEventListener(CC_CALLBACK_2(LabelToggleTypeTest::onChangedRadioButtonSelect, this)); + radioButton->setTag(i); + radioButtonGroup->addRadioButton(radioButton); + this->addChild(radioButton); + + auto label = Label::createWithSystemFont(labelTypes.at(i), "Arial", 20); + label->setPosition(radioButton->getPosition() + Vec2(50,0)); + this->addChild(label); + } +} + +std::string LabelToggleTypeTest::title() const +{ + return "Toggle Label Type Test"; +} + +std::string LabelToggleTypeTest::subtitle() const +{ + return ""; +} + + +void LabelToggleTypeTest::onChangedRadioButtonSelect(RadioButton* radioButton, RadioButton::EventType type) +{ + if(radioButton == nullptr) + { + return; + } + + switch (type) + { + case RadioButton::EventType::SELECTED: + { + switch (radioButton->getTag()) { + case 0: + _label->setOverflow(Label::Overflow::NORMAL); + break; + case 1: + _label->setOverflow(Label::Overflow::CLAMP); + break; + case 2: + _label->setOverflow(Label::Overflow::SHRINK); + break; + case 3: + _label->setOverflow(Label::Overflow::RESIZE_HEIGHT); + break; + default: + break; + } + break; + } + default: + break; + } + auto checkbox = (CheckBox*)(this->getChildByName("toggleWrap")); + checkbox->setSelected(_label->isWrapEnabled()); + this->updateDrawNodeSize(_label->getContentSize()); +} + +LabelSystemFontTest::LabelSystemFontTest() +{ + _label->setLineSpacing(5); + _label->setVerticalAlignment(TextVAlignment::CENTER); + _label->setOverflow(Label::Overflow::NORMAL); + _label->setSystemFontName("Hiragino Sans GB"); + + this->updateDrawNodeSize(_label->getContentSize()); + + auto slider1 = (ui::Slider*)this->getChildByTag(1); + + auto slider2 = (ui::Slider*)this->getChildByTag(2); + slider2->setVisible(false); + + auto winSize = Director::getInstance()->getVisibleSize(); + slider1->addEventListener([=](Ref* ref, Slider::EventType event){ + float percent = slider1->getPercent(); + auto drawNodeSize = Size(percent / 100.0 * winSize.width,_label->getContentSize().height); + if(drawNodeSize.height <= 0){ + drawNodeSize.height = 0.1f; + } + _label->setDimensions(drawNodeSize.width, drawNodeSize.height); + this->updateDrawNodeSize(drawNodeSize); + }); + + + auto label = Label::createWithSystemFont("Word Line break:", "Arial", 10); + label->setColor(Color3B::WHITE); + label->setPosition(Vec2(winSize.width * 0.1f, winSize.height * 0.8f)); + this->addChild(label); + + CheckBox* checkBox = CheckBox::create("cocosui/check_box_normal.png", + "cocosui/check_box_normal_press.png", + "cocosui/check_box_active.png", + "cocosui/check_box_normal_disable.png", + "cocosui/check_box_active_disable.png"); + checkBox->setPosition(Vec2(winSize.width * 0.2f , winSize.height * 0.8f)); + checkBox->setScale(0.5); + checkBox->setSelected(false); + checkBox->setName("LineBreak"); + + checkBox->addEventListener([=](Ref* ref, CheckBox::EventType event){ + if (event == CheckBox::EventType::SELECTED) { + _label->setLineBreakWithoutSpace(true); + }else{ + _label->setLineBreakWithoutSpace(false); + } + this->updateDrawNodeSize(_label->getContentSize()); + }); + this->addChild(checkBox); + + this->initToggleCheckboxes(); +} + +void LabelSystemFontTest::initToggleCheckboxes() +{ + const float BUTTON_WIDTH = 100; + float startPosX = 0; + Size winSize = Director::getInstance()->getVisibleSize(); + + // Create a radio button group + auto radioButtonGroup = RadioButtonGroup::create(); + this->addChild(radioButtonGroup); + + // Create the radio buttons + static const int NUMBER_OF_BUTTONS = 4; + startPosX = winSize.width / 2.0f - (NUMBER_OF_BUTTONS - 1 ) * 0.5 * BUTTON_WIDTH - 30; + std::vector labelTypes = {"Normal", "Clamp", "Shrink", "RESIZE"}; + + for(int i = 0; i < NUMBER_OF_BUTTONS; ++i) + { + + RadioButton* radioButton = RadioButton::create("cocosui/radio_button_off.png", "cocosui/radio_button_on.png"); + float posX = startPosX + BUTTON_WIDTH * i; + radioButton->setPosition(Vec2(posX, winSize.height / 2.0f + 70)); + radioButton->setScale(1.2f); + radioButton->addEventListener(CC_CALLBACK_2(LabelSystemFontTest::onChangedRadioButtonSelect, this)); + radioButton->setTag(i); + radioButtonGroup->addRadioButton(radioButton); + this->addChild(radioButton); + + auto label = Label::createWithSystemFont(labelTypes.at(i), "Arial", 20); + label->setPosition(radioButton->getPosition() + Vec2(50,0)); + this->addChild(label); + } +} + +std::string LabelSystemFontTest::title() const +{ + return "System Font Test"; +} + +std::string LabelSystemFontTest::subtitle() const +{ + return ""; +} + + +void LabelSystemFontTest::onChangedRadioButtonSelect(RadioButton* radioButton, RadioButton::EventType type) +{ + if(radioButton == nullptr) + { + return; + } + + switch (type) + { + case RadioButton::EventType::SELECTED: + { + switch (radioButton->getTag()) { + case 0: + _label->setOverflow(Label::Overflow::NORMAL); + break; + case 1: + _label->setOverflow(Label::Overflow::CLAMP); + break; + case 2: + _label->setOverflow(Label::Overflow::SHRINK); + break; + case 3: + _label->setOverflow(Label::Overflow::RESIZE_HEIGHT); + break; + default: + break; + } + break; + } + default: + break; + } + auto checkbox = (CheckBox*)(this->getChildByName("toggleWrap")); + checkbox->setSelected(_label->isWrapEnabled()); + this->updateDrawNodeSize(_label->getContentSize()); +} + +LabelCharMapFontTest::LabelCharMapFontTest() +{ + _label->setLineSpacing(5); + _label->setVerticalAlignment(TextVAlignment::CENTER); + _label->setOverflow(Label::Overflow::NORMAL); + _label->setCharMap("fonts/tuffy_bold_italic-charmap.plist"); + _label->setString("Hello World, This is a char map test."); + _label->setScale(0.5f); + + auto stepper = (ControlStepper*)this->getChildByName("stepper"); + stepper->setEnabled(false); + + auto checkbox = (CheckBox*)(this->getChildByName("toggleType")); + checkbox->setEnabled(false); + + this->updateDrawNodeSize(_label->getContentSize()); + +} + + +std::string LabelCharMapFontTest::title() const +{ + return "CharMap Font Test"; +} + +std::string LabelCharMapFontTest::subtitle() const +{ + return ""; +} diff --git a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.h b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.h index 13cb6d24fa..a803f8d7dd 100644 --- a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.h +++ b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.h @@ -4,6 +4,7 @@ #include "../BaseTest.h" #include "renderer/CCCustomCommand.h" #include "ui/CocosGUI.h" +#include "extensions/cocos-ext.h" DEFINE_TEST_SUITE(NewLabelTests); @@ -635,4 +636,123 @@ public: virtual std::string subtitle() const override; }; +class LabelLayoutBaseTest : public AtlasDemoNew +{ +public: + LabelLayoutBaseTest(); + void updateDrawNodeSize(const cocos2d::Size &drawNodeSize); + cocos2d::extension::ControlStepper* makeControlStepper(); + void valueChanged(cocos2d::Ref* sender, cocos2d::extension::Control::EventType controlEvent); + +protected: + void setAlignmentLeft(cocos2d::Ref* sender); + void setAlignmentCenter(cocos2d::Ref* sender); + void setAlignmentRight(cocos2d::Ref* sender); + void setAlignmentTop(cocos2d::Ref* sender); + void setAlignmentMiddle(cocos2d::Ref* sender); + void setAlignmentBottom(cocos2d::Ref* sender); + + void initWrapOption(const cocos2d::Size& size); + void initToggleLabelTypeOption(const cocos2d::Size& size); + void initAlignmentOption(const cocos2d::Size& size); + void initFontSizeChange(const cocos2d::Size& size); + void initSliders(const cocos2d::Size& size); + void initTestLabel(const cocos2d::Size& size); + void initDrawNode(const cocos2d::Size& size); + cocos2d::DrawNode* _drawNode; + cocos2d::Label* _label; + int _labelType; +}; + +class LabelWrapByWordTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelWrapByWordTest); + + LabelWrapByWordTest(); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelWrapByCharTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelWrapByCharTest); + + LabelWrapByCharTest(); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelShrinkByWordTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelShrinkByWordTest); + + LabelShrinkByWordTest(); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelShrinkByCharTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelShrinkByCharTest); + + LabelShrinkByCharTest(); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelResizeTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelResizeTest); + + LabelResizeTest(); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelToggleTypeTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelToggleTypeTest); + + LabelToggleTypeTest(); + void initToggleCheckboxes(); + void onChangedRadioButtonSelect(cocos2d::ui::RadioButton* radioButton,cocos2d::ui::RadioButton::EventType type); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelSystemFontTest : public LabelLayoutBaseTest +{ +public: + CREATE_FUNC(LabelSystemFontTest); + + LabelSystemFontTest(); + void initToggleCheckboxes(); + void onChangedRadioButtonSelect(cocos2d::ui::RadioButton* radioButton,cocos2d::ui::RadioButton::EventType type); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; + +class LabelCharMapFontTest : public LabelSystemFontTest +{ +public: + CREATE_FUNC(LabelCharMapFontTest); + + LabelCharMapFontTest(); + + virtual std::string title() const override; + virtual std::string subtitle() const override; +}; #endif diff --git a/tests/cpp-tests/Resources/fonts/enligsh-chinese.fnt b/tests/cpp-tests/Resources/fonts/enligsh-chinese.fnt new file mode 100644 index 0000000000..e7c7b63d3c --- /dev/null +++ b/tests/cpp-tests/Resources/fonts/enligsh-chinese.fnt @@ -0,0 +1,108 @@ +info face="DFYuanW7-GBK" size=40 bold=1 italic=0 charset="" unicode=0 stretchH=100 smooth=1 aa=1 padding=1,1,1,1 spacing=2,2 +common lineHeight=43 base=34 scaleW=512 scaleH=256 pages=1 packed=0 +page id=0 file="enligsh-chinese.png" +chars count=104 +char id=32 x=261 y=151 width=0 height=0 xoffset=0 yoffset=37 xadvance=20 page=0 chnl=0 letter="space" +char id=33 x=368 y=82 width=10 height=33 xoffset=7 yoffset=4 xadvance=20 page=0 chnl=0 letter="!" +char id=34 x=44 y=151 width=14 height=15 xoffset=5 yoffset=0 xadvance=20 page=0 chnl=0 letter=""" +char id=35 x=419 y=47 width=20 height=33 xoffset=2 yoffset=5 xadvance=20 page=0 chnl=0 letter="#" +char id=36 x=231 y=2 width=21 height=39 xoffset=1 yoffset=1 xadvance=20 page=0 chnl=0 letter="$" +char id=37 x=480 y=2 width=22 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="%" +char id=38 x=74 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="&" +char id=39 x=60 y=151 width=11 height=14 xoffset=6 yoffset=0 xadvance=20 page=0 chnl=0 letter="'" +char id=40 x=10 y=2 width=15 height=40 xoffset=4 yoffset=1 xadvance=20 page=0 chnl=0 letter="(" +char id=41 x=27 y=2 width=15 height=40 xoffset=4 yoffset=1 xadvance=20 page=0 chnl=0 letter=")" +char id=42 x=212 y=117 width=23 height=26 xoffset=0 yoffset=8 xadvance=20 page=0 chnl=0 letter="*" +char id=43 x=23 y=151 width=19 height=21 xoffset=2 yoffset=10 xadvance=20 page=0 chnl=0 letter="+" +char id=44 x=107 y=151 width=9 height=13 xoffset=7 yoffset=28 xadvance=20 page=0 chnl=0 letter="," +char id=45 x=190 y=151 width=19 height=7 xoffset=2 yoffset=17 xadvance=20 page=0 chnl=0 letter="-" +char id=46 x=137 y=151 width=9 height=9 xoffset=7 yoffset=28 xadvance=20 page=0 chnl=0 letter="." +char id=47 x=254 y=2 width=21 height=39 xoffset=1 yoffset=2 xadvance=20 page=0 chnl=0 letter="/" +char id=48 x=176 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="0" +char id=49 x=355 y=82 width=11 height=33 xoffset=6 yoffset=4 xadvance=20 page=0 chnl=0 letter="1" +char id=50 x=196 y=82 width=18 height=33 xoffset=3 yoffset=3 xadvance=20 page=0 chnl=0 letter="2" +char id=51 x=216 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="3" +char id=52 x=441 y=47 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="4" +char id=53 x=236 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="5" +char id=54 x=256 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="6" +char id=55 x=276 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="7" +char id=56 x=296 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="8" +char id=57 x=316 y=82 width=18 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="9" +char id=58 x=495 y=117 width=10 height=24 xoffset=7 yoffset=13 xadvance=20 page=0 chnl=0 letter=":" +char id=59 x=200 y=117 width=10 height=28 xoffset=7 yoffset=13 xadvance=20 page=0 chnl=0 letter=";" +char id=60 x=47 y=117 width=20 height=31 xoffset=2 yoffset=5 xadvance=20 page=0 chnl=0 letter="<" +char id=61 x=86 y=151 width=19 height=13 xoffset=2 yoffset=14 xadvance=20 page=0 chnl=0 letter="=" +char id=62 x=69 y=117 width=20 height=31 xoffset=2 yoffset=5 xadvance=20 page=0 chnl=0 letter=">" +char id=63 x=97 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="?" +char id=64 x=120 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="@" +char id=65 x=143 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="A" +char id=66 x=451 y=82 width=21 height=32 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="B" +char id=67 x=166 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="C" +char id=68 x=474 y=82 width=21 height=32 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="D" +char id=69 x=25 y=117 width=20 height=32 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="E" +char id=70 x=463 y=47 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="F" +char id=71 x=189 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="G" +char id=72 x=485 y=47 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="H" +char id=73 x=390 y=82 width=7 height=33 xoffset=8 yoffset=4 xadvance=20 page=0 chnl=0 letter="I" +char id=74 x=212 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="J" +char id=75 x=2 y=82 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="K" +char id=76 x=24 y=82 width=20 height=33 xoffset=2 yoffset=3 xadvance=20 page=0 chnl=0 letter="L" +char id=77 x=2 y=47 width=22 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="M" +char id=78 x=46 y=82 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="N" +char id=79 x=26 y=47 width=22 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="O" +char id=80 x=235 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="P" +char id=81 x=258 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="Q" +char id=82 x=281 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="R" +char id=83 x=304 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="S" +char id=84 x=50 y=47 width=22 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="T" +char id=85 x=68 y=82 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="U" +char id=86 x=327 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="V" +char id=87 x=350 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="W" +char id=88 x=373 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="X" +char id=89 x=396 y=47 width=21 height=33 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="Y" +char id=90 x=2 y=117 width=21 height=32 xoffset=1 yoffset=4 xadvance=20 page=0 chnl=0 letter="Z" +char id=91 x=44 y=2 width=13 height=40 xoffset=5 yoffset=1 xadvance=20 page=0 chnl=0 letter="[" +char id=92 x=277 y=2 width=21 height=39 xoffset=1 yoffset=2 xadvance=20 page=0 chnl=0 letter="\" +char id=93 x=59 y=2 width=13 height=40 xoffset=5 yoffset=1 xadvance=20 page=0 chnl=0 letter="]" +char id=94 x=118 y=151 width=17 height=9 xoffset=3 yoffset=2 xadvance=20 page=0 chnl=0 letter="^" +char id=95 x=211 y=151 width=23 height=6 xoffset=0 yoffset=37 xadvance=20 page=0 chnl=0 letter="_" +char id=96 x=73 y=151 width=11 height=14 xoffset=6 yoffset=0 xadvance=20 page=0 chnl=0 letter="`" +char id=97 x=395 y=117 width=19 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="a" +char id=98 x=90 y=82 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="b" +char id=99 x=285 y=117 width=20 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="c" +char id=100 x=112 y=82 width=20 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="d" +char id=101 x=307 y=117 width=20 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="e" +char id=102 x=336 y=82 width=17 height=33 xoffset=3 yoffset=4 xadvance=20 page=0 chnl=0 letter="f" +char id=103 x=91 y=117 width=22 height=29 xoffset=1 yoffset=13 xadvance=20 page=0 chnl=0 letter="g" +char id=104 x=134 y=82 width=19 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="h" +char id=105 x=380 y=82 width=8 height=33 xoffset=8 yoffset=4 xadvance=20 page=0 chnl=0 letter="i" +char id=106 x=381 y=2 width=13 height=38 xoffset=5 yoffset=4 xadvance=20 page=0 chnl=0 letter="j" +char id=107 x=155 y=82 width=19 height=33 xoffset=2 yoffset=4 xadvance=20 page=0 chnl=0 letter="k" +char id=108 x=399 y=82 width=7 height=33 xoffset=8 yoffset=4 xadvance=20 page=0 chnl=0 letter="l" +char id=109 x=237 y=117 width=22 height=24 xoffset=1 yoffset=13 xadvance=20 page=0 chnl=0 letter="m" +char id=110 x=416 y=117 width=19 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="n" +char id=111 x=329 y=117 width=20 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="o" +char id=112 x=115 y=117 width=20 height=29 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="p" +char id=113 x=137 y=117 width=20 height=29 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="q" +char id=114 x=479 y=117 width=14 height=24 xoffset=5 yoffset=13 xadvance=20 page=0 chnl=0 letter="r" +char id=115 x=437 y=117 width=19 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="s" +char id=116 x=181 y=117 width=17 height=28 xoffset=3 yoffset=8 xadvance=20 page=0 chnl=0 letter="t" +char id=117 x=458 y=117 width=19 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="u" +char id=118 x=351 y=117 width=20 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="v" +char id=119 x=261 y=117 width=22 height=24 xoffset=1 yoffset=13 xadvance=20 page=0 chnl=0 letter="w" +char id=120 x=373 y=117 width=20 height=24 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="x" +char id=121 x=159 y=117 width=20 height=29 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="y" +char id=122 x=2 y=151 width=19 height=23 xoffset=2 yoffset=13 xadvance=20 page=0 chnl=0 letter="z" +char id=123 x=74 y=2 width=13 height=40 xoffset=5 yoffset=1 xadvance=20 page=0 chnl=0 letter="{" +char id=124 x=2 y=2 width=6 height=43 xoffset=9 yoffset=0 xadvance=20 page=0 chnl=0 letter="|" +char id=125 x=89 y=2 width=13 height=40 xoffset=5 yoffset=1 xadvance=20 page=0 chnl=0 letter="}" +char id=126 x=236 y=151 width=23 height=6 xoffset=0 yoffset=0 xadvance=20 page=0 chnl=0 letter="~" +char id=19968 x=148 y=151 width=40 height=7 xoffset=2 yoffset=16 xadvance=40 page=0 chnl=0 letter="一" +char id=19971 x=300 y=2 width=40 height=38 xoffset=1 yoffset=1 xadvance=40 page=0 chnl=0 letter="七" +char id=19977 x=439 y=2 width=39 height=36 xoffset=2 yoffset=3 xadvance=40 page=0 chnl=0 letter="三" +char id=20061 x=189 y=2 width=40 height=39 xoffset=2 yoffset=2 xadvance=40 page=0 chnl=0 letter="九" +char id=20108 x=408 y=82 width=41 height=32 xoffset=1 yoffset=6 xadvance=40 page=0 chnl=0 letter="二" +char id=20116 x=396 y=2 width=41 height=37 xoffset=1 yoffset=2 xadvance=40 page=0 chnl=0 letter="五" +char id=20843 x=104 y=2 width=41 height=39 xoffset=1 yoffset=2 xadvance=40 page=0 chnl=0 letter="八" +char id=20845 x=147 y=2 width=40 height=39 xoffset=2 yoffset=1 xadvance=40 page=0 chnl=0 letter="六" +char id=22235 x=342 y=2 width=37 height=38 xoffset=3 yoffset=3 xadvance=40 page=0 chnl=0 letter="四" diff --git a/tests/cpp-tests/Resources/fonts/enligsh-chinese.png b/tests/cpp-tests/Resources/fonts/enligsh-chinese.png new file mode 100644 index 0000000000000000000000000000000000000000..a3bc36f9750235000c97820e540d4b171e74b7e3 GIT binary patch literal 79233 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%0Dd>rBw|8vnJofL=i?ufC*Jk4B9Rqh}kU{wp> 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 Date: Thu, 19 Nov 2015 18:14:46 +0800 Subject: [PATCH 03/20] Add Overflow feature char map font. 1. fix single line clamp. --- cocos/2d/CCLabel.cpp | 51 ++++++++++--------- cocos/2d/CCLabel.h | 3 +- .../Classes/LabelTest/LabelTestNew.cpp | 4 +- 3 files changed, 33 insertions(+), 25 deletions(-) diff --git a/cocos/2d/CCLabel.cpp b/cocos/2d/CCLabel.cpp index 074d7efc23..356dcd636e 100644 --- a/cocos/2d/CCLabel.cpp +++ b/cocos/2d/CCLabel.cpp @@ -715,15 +715,7 @@ void Label::updateLabelLetters() auto py = letterInfo.positionY - letterDef.height / 2 + _letterOffsetY; letterSprite->setPosition(px, py); - if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0) { - _reusedLetter->setScale(_bmfontScale); - }else{ - if(fabs(_bmFontSize)setScale(0); - }else{ - _reusedLetter->setScale(1.0); - } - } + this->updateReusedLetterScale(); ++it; } } @@ -858,9 +850,9 @@ bool Label::updateQuads() } if(!_enableWrap){ - auto px = _lettersInfo[ctr].positionX + letterDef.width/2; + auto px = _lettersInfo[ctr].positionX + letterDef.width/2 + _linesOffsetX[_lettersInfo[ctr].lineIndex]; if(_labelWidth > 0.f){ - if (px > _contentSize.width) { + if (px > _contentSize.width || px < 0) { if(_overflow == Overflow::CLAMP){ _reusedRect.size.width = 0; }else if(_overflow == Overflow::SHRINK){ @@ -882,20 +874,13 @@ bool Label::updateQuads() if (_reusedRect.size.height > 0.f && _reusedRect.size.width > 0.f) { _reusedLetter->setTextureRect(_reusedRect, false, _reusedRect.size); - _reusedLetter->setPosition(_lettersInfo[ctr].positionX + _linesOffsetX[_lettersInfo[ctr].lineIndex], py); + float letterPositionX = _lettersInfo[ctr].positionX + _linesOffsetX[_lettersInfo[ctr].lineIndex]; + _reusedLetter->setPosition(letterPositionX, py); auto index = static_cast(_batchNodes.at(letterDef.textureID)->getTextureAtlas()->getTotalQuads()); _lettersInfo[ctr].atlasIndex = index; - if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0) { - _reusedLetter->setScale(_bmfontScale); - }else{ - if(fabs(_bmFontSize)setScale(0); - }else{ - _reusedLetter->setScale(1.0); - } - } - + this->updateReusedLetterScale(); + _batchNodes.at(letterDef.textureID)->insertQuadFromSprite(_reusedLetter, index); } } @@ -1959,7 +1944,8 @@ bool Label::isWrapEnabled()const void Label::setOverflow(Overflow overflow) { - if(_overflow == overflow || _currentLabelType == LabelType::CHARMAP){ + if(_overflow == overflow || + (_currentLabelType == LabelType::CHARMAP && overflow == Overflow::SHRINK)){ return; } @@ -1981,4 +1967,23 @@ Label::Overflow Label::getOverflow()const return _overflow; } +void Label::updateReusedLetterScale() +{ + if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0) + { + _reusedLetter->setScale(_bmfontScale); + } + else + { + if(fabs(_bmFontSize)setScale(0); + } + else + { + _reusedLetter->setScale(1.0); + } + } +} + NS_CC_END diff --git a/cocos/2d/CCLabel.h b/cocos/2d/CCLabel.h index c5884c926e..bd7e6c9255 100644 --- a/cocos/2d/CCLabel.h +++ b/cocos/2d/CCLabel.h @@ -413,7 +413,7 @@ public: bool isWrapEnabled()const; /** - * Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type. + * Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type. Char Map font also supports all the Overflow type except for SHRINK. * * @param overflow see `Overflow` */ @@ -590,6 +590,7 @@ protected: bool setTTFConfigInternal(const TTFConfig& ttfConfig); void setBMFontSizeInternal(float fontSize); void restoreFontSize(); + void updateReusedLetterScale(); void reset(); diff --git a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp index 09d7300e61..c58dbb63bc 100644 --- a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp +++ b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp @@ -2171,10 +2171,10 @@ void LabelLayoutBaseTest::initSliders(const cocos2d::Size& size) slider2->setPercent(52); addChild(slider2); auto winSize = Director::getInstance()->getVisibleSize(); - auto labelSize = _label->getContentSize(); slider->addEventListener([=](Ref* ref, Slider::EventType event){ float percent = slider->getPercent(); + auto labelSize = _label->getContentSize(); auto drawNodeSize = Size(percent / 100.0 * winSize.width, labelSize.height); if(drawNodeSize.width <=0){ drawNodeSize.width = 0.1f; @@ -2185,6 +2185,7 @@ void LabelLayoutBaseTest::initSliders(const cocos2d::Size& size) slider2->addEventListener([=](Ref* ref, Slider::EventType event){ float percent = slider2->getPercent(); + auto labelSize = _label->getContentSize(); auto drawNodeSize = Size( labelSize.width, percent / 100.0 * winSize.height); if(drawNodeSize.height <= 0){ drawNodeSize.height = 0.1f; @@ -2310,6 +2311,7 @@ std::string LabelWrapByWordTest::subtitle() const LabelWrapByCharTest::LabelWrapByCharTest() { _label->setLineBreakWithoutSpace(true); + _label->setString("五六七八This \nis a very long sentence一二三四."); _label->setLineSpacing(5); _label->setAdditionalKerning(2); _label->setVerticalAlignment(TextVAlignment::TOP); From 8c257493665dd12a75b4d74381178a564e160fde Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Fri, 20 Nov 2015 10:54:05 +0800 Subject: [PATCH 04/20] minor improvement --- cocos/2d/CCLabel.cpp | 22 ++++++++++++++-------- cocos/2d/CCLabel.h | 6 ++++-- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/cocos/2d/CCLabel.cpp b/cocos/2d/CCLabel.cpp index 356dcd636e..2852389849 100644 --- a/cocos/2d/CCLabel.cpp +++ b/cocos/2d/CCLabel.cpp @@ -769,12 +769,7 @@ bool Label::alignText() computeAlignmentOffset(); if(_enableWrap && _overflow == Overflow::SHRINK){ - float fontSize = 0; - if (_currentLabelType == LabelType::BMFONT) { - fontSize = _bmFontSize; - }else if(_currentLabelType == LabelType::TTF){ - fontSize = this->getTTFConfig().fontSize; - } + float fontSize = this->getRenderingFontSize(); if(fontSize > 0 && isVerticalClamp()){ this->shrinkLabelToContentSize(CC_CALLBACK_0(Label::isVerticalClamp, this)); @@ -1944,10 +1939,21 @@ bool Label::isWrapEnabled()const void Label::setOverflow(Overflow overflow) { - if(_overflow == overflow || - (_currentLabelType == LabelType::CHARMAP && overflow == Overflow::SHRINK)){ + if(_overflow == overflow){ return; } + + if (_currentLabelType == LabelType::CHARMAP) { + if (overflow == Overflow::SHRINK) { + return; + } + } + + if (_currentLabelType == LabelType::STRING_TEXTURE) { + if (overflow == Overflow::CLAMP || overflow == Overflow::SHRINK) { + return; + } + } if(overflow == Overflow::RESIZE_HEIGHT){ this->setDimensions(_labelDimensions.width,0); diff --git a/cocos/2d/CCLabel.h b/cocos/2d/CCLabel.h index bd7e6c9255..4870fccb5f 100644 --- a/cocos/2d/CCLabel.h +++ b/cocos/2d/CCLabel.h @@ -399,7 +399,7 @@ public: float getBMFontSize()const; /** - * Toggle wrap option the label. + * Toggle wrap option of the label. * Note: System font doesn't support manually toggle wrap. * * @param enable Set true to enable wrap and false to disable wrap. @@ -413,7 +413,9 @@ public: bool isWrapEnabled()const; /** - * Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type. Char Map font also supports all the Overflow type except for SHRINK. + * Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type. + * Char Map font supports all the Overflow type except for SHRINK, because we can't measure it's font size. + * System font only support Overflow::Normal and Overflow::RESIZE_HEIGHT. * * @param overflow see `Overflow` */ From 7ee82f20fce7b2d57f499fe83342448170187c05 Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Fri, 20 Nov 2015 16:39:48 +0800 Subject: [PATCH 05/20] fix getLetter crash issue. 1. make vertical clamp works in non-wrap mode. 2. make the lineHeight and letterSprite scale work correct. --- cocos/2d/CCLabel.cpp | 34 +++++++++++-------- cocos/2d/CCLabel.h | 3 +- cocos/2d/CCLabelTextFormatter.cpp | 2 +- .../Classes/LabelTest/LabelTestNew.cpp | 14 ++++++++ 4 files changed, 37 insertions(+), 16 deletions(-) diff --git a/cocos/2d/CCLabel.cpp b/cocos/2d/CCLabel.cpp index 2852389849..e9d3e93906 100644 --- a/cocos/2d/CCLabel.cpp +++ b/cocos/2d/CCLabel.cpp @@ -699,6 +699,8 @@ void Label::updateLabelLetters() uvRect.origin.x = letterDef.U; uvRect.origin.y = letterDef.V; + auto batchNode = _batchNodes.at(letterDef.textureID); + letterSprite->setTextureAtlas(batchNode->getTextureAtlas()); letterSprite->setTexture(_fontAtlas->getTexture(letterDef.textureID)); if (letterDef.width <= 0.f || letterDef.height <= 0.f) { @@ -715,7 +717,7 @@ void Label::updateLabelLetters() auto py = letterInfo.positionY - letterDef.height / 2 + _letterOffsetY; letterSprite->setPosition(px, py); - this->updateReusedLetterScale(); + this->updateLetterSpriteScale(letterSprite); ++it; } } @@ -768,7 +770,7 @@ bool Label::alignText() } computeAlignmentOffset(); - if(_enableWrap && _overflow == Overflow::SHRINK){ + if(_overflow == Overflow::SHRINK){ float fontSize = this->getRenderingFontSize(); if(fontSize > 0 && isVerticalClamp()){ @@ -874,7 +876,7 @@ bool Label::updateQuads() auto index = static_cast(_batchNodes.at(letterDef.textureID)->getTextureAtlas()->getTotalQuads()); _lettersInfo[ctr].atlasIndex = index; - this->updateReusedLetterScale(); + this->updateLetterSpriteScale(_reusedLetter); _batchNodes.at(letterDef.textureID)->insertQuadFromSprite(_reusedLetter, index); } @@ -1611,7 +1613,7 @@ void Label::setLineHeight(float height) float Label::getLineHeight() const { CCASSERT(_currentLabelType != LabelType::STRING_TEXTURE, "Not supported system font!"); - return _textSprite ? 0.0f : _lineHeight; + return _textSprite ? 0.0f : _lineHeight * _bmfontScale; } void Label::setLineSpacing(float height) @@ -1924,10 +1926,8 @@ void Label::enableWrap(bool enable) } this->_enableWrap = enable; - auto renderingFontSize = this->getRenderingFontSize(); - if (fabs(_originalFontSize - renderingFontSize) >= 1) { - this->scaleFontSizeDown(_originalFontSize); - } + + this->rescaleWithOriginalFontSize(); _contentDirty = true; } @@ -1961,11 +1961,17 @@ void Label::setOverflow(Overflow overflow) } _overflow = overflow; + this->rescaleWithOriginalFontSize(); + + _contentDirty = true; +} + +void Label::rescaleWithOriginalFontSize() +{ auto renderingFontSize = this->getRenderingFontSize(); - if (fabs(_originalFontSize - renderingFontSize) >= 1) { + if (_originalFontSize - renderingFontSize >= 1) { this->scaleFontSizeDown(_originalFontSize); } - _contentDirty = true; } Label::Overflow Label::getOverflow()const @@ -1973,21 +1979,21 @@ Label::Overflow Label::getOverflow()const return _overflow; } -void Label::updateReusedLetterScale() +void Label::updateLetterSpriteScale(Sprite* sprite) { if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0) { - _reusedLetter->setScale(_bmfontScale); + sprite->setScale(_bmfontScale); } else { if(fabs(_bmFontSize)setScale(0); + sprite->setScale(0); } else { - _reusedLetter->setScale(1.0); + sprite->setScale(1.0); } } } diff --git a/cocos/2d/CCLabel.h b/cocos/2d/CCLabel.h index 4870fccb5f..1bfa698a87 100644 --- a/cocos/2d/CCLabel.h +++ b/cocos/2d/CCLabel.h @@ -572,6 +572,7 @@ protected: bool isHorizontalClamp(); bool isVerticalClamp(); float getRenderingFontSize()const; + void rescaleWithOriginalFontSize(); void updateLabelLetters(); virtual bool alignText(); @@ -592,7 +593,7 @@ protected: bool setTTFConfigInternal(const TTFConfig& ttfConfig); void setBMFontSizeInternal(float fontSize); void restoreFontSize(); - void updateReusedLetterScale(); + void updateLetterSpriteScale(Sprite* sprite); void reset(); diff --git a/cocos/2d/CCLabelTextFormatter.cpp b/cocos/2d/CCLabelTextFormatter.cpp index cc22d83b8c..9e5f6d83a5 100644 --- a/cocos/2d/CCLabelTextFormatter.cpp +++ b/cocos/2d/CCLabelTextFormatter.cpp @@ -371,7 +371,7 @@ void Label::shrinkLabelToContentSize(std::function lambda) int i = 0; auto letterDefinition = _fontAtlas->_letterDefinitions; auto tempLetterDefinition = letterDefinition; - float originalLineHeight = this->getLineHeight(); + float originalLineHeight = _lineHeight; bool flag = true; while (lambda()) { ++i; diff --git a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp index c58dbb63bc..486d0a7725 100644 --- a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp +++ b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp @@ -2264,6 +2264,14 @@ void LabelLayoutBaseTest::valueChanged(cocos2d::Ref *sender, cocos2d::extension: _label->setBMFontSize(fontSize); } this->updateDrawNodeSize(_label->getContentSize()); + + //FIXME::When calling getLetter, the label Overflow feature will be invalid. +// auto letterSprite = _label->getLetter(1); +// auto moveBy = ScaleBy::create(1.0,2.0); +// letterSprite->stopAllActions(); +// letterSprite->runAction(Sequence::create(moveBy, moveBy->clone()->reverse(), nullptr )); +// +// CCLOG("label line height = %f", _label->getLineHeight()); } void LabelLayoutBaseTest::updateDrawNodeSize(const cocos2d::Size &drawNodeSize) @@ -2578,6 +2586,12 @@ LabelSystemFontTest::LabelSystemFontTest() _label->setVerticalAlignment(TextVAlignment::CENTER); _label->setOverflow(Label::Overflow::NORMAL); _label->setSystemFontName("Hiragino Sans GB"); + + auto stepper = (ControlStepper*)this->getChildByName("stepper"); + stepper->setEnabled(false); + + auto checkbox = (CheckBox*)(this->getChildByName("toggleType")); + checkbox->setEnabled(false); this->updateDrawNodeSize(_label->getContentSize()); From 7676b1cb73734dd332348c2c2d7749fcde85451a Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Mon, 23 Nov 2015 17:47:30 +0800 Subject: [PATCH 06/20] improve label layout logic --- cocos/2d/CCLabel.h | 1 + cocos/2d/CCLabelTextFormatter.cpp | 190 +++++------------- .../Classes/LabelTest/LabelTestNew.cpp | 6 +- 3 files changed, 57 insertions(+), 140 deletions(-) diff --git a/cocos/2d/CCLabel.h b/cocos/2d/CCLabel.h index 1bfa698a87..1d4e5188b9 100644 --- a/cocos/2d/CCLabel.h +++ b/cocos/2d/CCLabel.h @@ -568,6 +568,7 @@ protected: bool multilineTextWrapByChar(); bool multilineTextWrapByWord(); + bool multilineTextWrap(std::function lambda); void shrinkLabelToContentSize(std::function lambda); bool isHorizontalClamp(); bool isVerticalClamp(); diff --git a/cocos/2d/CCLabelTextFormatter.cpp b/cocos/2d/CCLabelTextFormatter.cpp index 9e5f6d83a5..9454b39e46 100644 --- a/cocos/2d/CCLabelTextFormatter.cpp +++ b/cocos/2d/CCLabelTextFormatter.cpp @@ -72,6 +72,11 @@ void Label::computeAlignmentOffset() } } +static int getFirstCharLen(const std::u16string& utf16Text, int startIndex, int textLen) +{ + return 1; +} + static int getFirstWordLen(const std::u16string& utf16Text, int startIndex, int textLen) { auto character = utf16Text[startIndex]; @@ -106,24 +111,24 @@ void Label::updateBMFontScale() } } -bool Label::multilineTextWrapByWord() +bool Label::multilineTextWrap(std::function nextTokenLen) { int textLen = getStringLength(); int lineIndex = 0; - float nextWordX = 0.f; - float nextWordY = 0.f; + float nextTokenX = 0.f; + float nextTokenY = 0.f; float longestLine = 0.f; float letterRight = 0.f; - - auto contentScaleFactor = CC_CONTENT_SCALE_FACTOR(); + + auto contentScaleFactor = CC_CONTENT_SCALE_FACTOR(); float lineSpacing = _lineSpacing * contentScaleFactor; float highestY = 0.f; float lowestY = 0.f; FontLetterDefinition letterDef; Vec2 letterPosition; - + this->updateBMFontScale(); - + for (int index = 0; index < textLen; ) { auto character = _utf16Text[index]; @@ -132,20 +137,20 @@ bool Label::multilineTextWrapByWord() _linesWidth.push_back(letterRight); letterRight = 0.f; lineIndex++; - nextWordX = 0.f; - nextWordY -= _lineHeight*_bmfontScale + lineSpacing; + nextTokenX = 0.f; + nextTokenY -= _lineHeight*_bmfontScale + lineSpacing; recordPlaceholderInfo(index, character); index++; continue; } - - auto wordLen = getFirstWordLen(_utf16Text, index, textLen); - float wordHighestY = highestY;; - float wordLowestY = lowestY; - float wordRight = letterRight; - float nextLetterX = nextWordX; + + auto tokenLen = nextTokenLen(_utf16Text, index, textLen); + float tokenHighestY = highestY;; + float tokenLowestY = lowestY; + float tokenRight = letterRight; + float nextLetterX = nextTokenX; bool newLine = false; - for (int tmp = 0; tmp < wordLen;++tmp) + for (int tmp = 0; tmp < tokenLen;++tmp) { int letterIndex = index + tmp; character = _utf16Text[letterIndex]; @@ -160,15 +165,15 @@ bool Label::multilineTextWrapByWord() CCLOG("LabelTextFormatter error:can't find letter definition in font file for letter: %c", character); continue; } - + auto letterX = (nextLetterX + letterDef.offsetX * _bmfontScale) / contentScaleFactor; - if (_enableWrap && _maxLineWidth > 0.f && nextWordX > 0.f && letterX + letterDef.width * _bmfontScale > _maxLineWidth) + if (_enableWrap && _maxLineWidth > 0.f && nextTokenX > 0.f && letterX + letterDef.width * _bmfontScale > _maxLineWidth) { _linesWidth.push_back(letterRight); letterRight = 0.f; lineIndex++; - nextWordX = 0.f; - nextWordY -= (_lineHeight*_bmfontScale + lineSpacing); + nextTokenX = 0.f; + nextTokenY -= (_lineHeight*_bmfontScale + lineSpacing); newLine = true; break; } @@ -176,40 +181,40 @@ bool Label::multilineTextWrapByWord() { letterPosition.x = letterX; } - letterPosition.y = (nextWordY - letterDef.offsetY * _bmfontScale) / contentScaleFactor; + letterPosition.y = (nextTokenY - letterDef.offsetY * _bmfontScale) / contentScaleFactor; recordLetterInfo(letterPosition, character, letterIndex, lineIndex); - + if (_horizontalKernings && letterIndex < textLen - 1) nextLetterX += _horizontalKernings[letterIndex + 1]; nextLetterX += letterDef.xAdvance * _bmfontScale + _additionalKerning; - - wordRight = letterPosition.x + letterDef.width * _bmfontScale; - - if (wordHighestY < letterPosition.y) - wordHighestY = letterPosition.y; - if (wordLowestY > letterPosition.y - letterDef.height * _bmfontScale) - wordLowestY = letterPosition.y - letterDef.height * _bmfontScale; + + tokenRight = letterPosition.x + letterDef.width * _bmfontScale; + + if (tokenHighestY < letterPosition.y) + tokenHighestY = letterPosition.y; + if (tokenLowestY > letterPosition.y - letterDef.height * _bmfontScale) + tokenLowestY = letterPosition.y - letterDef.height * _bmfontScale; } if (newLine) { continue; } - - nextWordX = nextLetterX; - letterRight = wordRight; - if (highestY < wordHighestY) - highestY = wordHighestY; - if (lowestY > wordLowestY) - lowestY = wordLowestY; + + nextTokenX = nextLetterX; + letterRight = tokenRight; + if (highestY < tokenHighestY) + highestY = tokenHighestY; + if (lowestY > tokenLowestY) + lowestY = tokenLowestY; if (longestLine < letterRight) longestLine = letterRight; - - index += wordLen; + + index += tokenLen; } - + _linesWidth.push_back(letterRight); - + _numberOfLines = lineIndex + 1; _textDesiredHeight = (_numberOfLines * _lineHeight * _bmfontScale) / contentScaleFactor; if (_numberOfLines > 1) @@ -220,114 +225,25 @@ bool Label::multilineTextWrapByWord() if (_labelHeight <= 0.f) contentSize.height = _textDesiredHeight; setContentSize(contentSize); - + _tailoredTopY = contentSize.height; _tailoredBottomY = 0.f; if (highestY > 0.f) _tailoredTopY = contentSize.height + highestY; if (lowestY < -_textDesiredHeight) _tailoredBottomY = _textDesiredHeight + lowestY; - + return true; } +bool Label::multilineTextWrapByWord() +{ + return multilineTextWrap(std::bind(getFirstWordLen, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); +} + bool Label::multilineTextWrapByChar() { - int textLen = getStringLength(); - int lineIndex = 0; - float nextLetterX = 0.f; - float nextLetterY = 0.f; - float longestLine = 0.f; - float letterRight = 0.f; - - auto contentScaleFactor = CC_CONTENT_SCALE_FACTOR(); - float lineSpacing = _lineSpacing * contentScaleFactor; - float highestY = 0.f; - float lowestY = 0.f; - FontLetterDefinition letterDef; - Vec2 letterPosition; - - this->updateBMFontScale(); - - for (int index = 0; index < textLen; index++) - { - auto character = _utf16Text[index]; - if (character == '\r') - { - recordPlaceholderInfo(index, character); - continue; - } - if (character == '\n') - { - _linesWidth.push_back(letterRight); - letterRight = 0.f; - lineIndex++; - nextLetterX = 0.f; - nextLetterY -= _lineHeight * _bmfontScale + lineSpacing; - recordPlaceholderInfo(index, character); - continue; - } - - if (_fontAtlas->getLetterDefinitionForChar(character, letterDef) == false) - { - recordPlaceholderInfo(index, character); - CCLOG("LabelTextFormatter error:can't find letter definition in font file for letter: %c", character); - continue; - } - - auto letterX = (nextLetterX + letterDef.offsetX * _bmfontScale) / contentScaleFactor; - if (_enableWrap && _maxLineWidth > 0.f && nextLetterX > 0.f && letterX + letterDef.width * _bmfontScale > _maxLineWidth) - { - _linesWidth.push_back(letterRight); - letterRight = 0.f; - lineIndex++; - nextLetterX = 0.f; - nextLetterY -= _lineHeight * _bmfontScale + lineSpacing; - letterPosition.x = letterDef.offsetX * _bmfontScale / contentScaleFactor; - } - else - { - letterPosition.x = letterX; - } - letterPosition.y = (nextLetterY - letterDef.offsetY * _bmfontScale) / contentScaleFactor; - recordLetterInfo(letterPosition, character, index, lineIndex); - - if (_horizontalKernings && index < textLen - 1) - nextLetterX += _horizontalKernings[index + 1]; - nextLetterX += letterDef.xAdvance * _bmfontScale + _additionalKerning; - - letterRight = letterPosition.x + letterDef.width * _bmfontScale; - - if (highestY < letterPosition.y) - highestY = letterPosition.y; - if (lowestY > letterPosition.y - letterDef.height * _bmfontScale) - lowestY = letterPosition.y - letterDef.height * _bmfontScale; - if (longestLine < letterRight) - longestLine = letterRight; - } - - _linesWidth.push_back(letterRight); - - _numberOfLines = lineIndex + 1; - _textDesiredHeight = (_numberOfLines * _lineHeight * _bmfontScale) / contentScaleFactor; - if (_numberOfLines > 1) - _textDesiredHeight += (_numberOfLines - 1) * _lineSpacing; - Size contentSize(_labelWidth, _labelHeight); - if (_labelWidth <= 0.f) - contentSize.width = longestLine; - if (_labelHeight <= 0.f) - contentSize.height = _textDesiredHeight; - - setContentSize(contentSize); - - _tailoredTopY = contentSize.height; - _tailoredBottomY = 0.f; - if (highestY > 0.f) - _tailoredTopY = contentSize.height + highestY; - if (lowestY < -_textDesiredHeight) - _tailoredBottomY = _textDesiredHeight + lowestY; - - return true; + return multilineTextWrap(std::bind(getFirstCharLen, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); } bool Label::isVerticalClamp() diff --git a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp index 486d0a7725..71147954cc 100644 --- a/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp +++ b/tests/cpp-tests/Classes/LabelTest/LabelTestNew.cpp @@ -2405,7 +2405,7 @@ LabelResizeTest::LabelResizeTest() auto stepper = (ControlStepper*)this->getChildByName("stepper"); stepper->setValue(12); - auto label = Label::createWithSystemFont("Word Line break:", "Arial", 10); + auto label = Label::createWithSystemFont("Char Line break:", "Arial", 10); label->setColor(Color3B::WHITE); label->setPosition(Vec2(winSize.width * 0.1f, winSize.height * 0.8f)); this->addChild(label); @@ -2471,7 +2471,7 @@ LabelToggleTypeTest::LabelToggleTypeTest() auto stepper = (ControlStepper*)this->getChildByName("stepper"); stepper->setValue(12); - auto label = Label::createWithSystemFont("Word Line break:", "Arial", 10); + auto label = Label::createWithSystemFont("Char Line break:", "Arial", 10); label->setColor(Color3B::WHITE); label->setPosition(Vec2(winSize.width * 0.1f, winSize.height * 0.8f)); this->addChild(label); @@ -2612,7 +2612,7 @@ LabelSystemFontTest::LabelSystemFontTest() }); - auto label = Label::createWithSystemFont("Word Line break:", "Arial", 10); + auto label = Label::createWithSystemFont("char Line break:", "Arial", 10); label->setColor(Color3B::WHITE); label->setPosition(Vec2(winSize.width * 0.1f, winSize.height * 0.8f)); this->addChild(label); From aa38dfba89439812d59adfc76cc2f9081d63674b Mon Sep 17 00:00:00 2001 From: yangxiao Date: Tue, 24 Nov 2015 18:11:16 +0800 Subject: [PATCH 07/20] release default fbo --- cocos/renderer/CCFrameBuffer.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cocos/renderer/CCFrameBuffer.cpp b/cocos/renderer/CCFrameBuffer.cpp index 7d679261bd..fbff5ed432 100644 --- a/cocos/renderer/CCFrameBuffer.cpp +++ b/cocos/renderer/CCFrameBuffer.cpp @@ -397,7 +397,6 @@ FrameBuffer::FrameBuffer() FrameBuffer::~FrameBuffer() { - if(!isDefaultFBO()) { CC_SAFE_RELEASE_NULL(_rt); CC_SAFE_RELEASE_NULL(_rtDepthStencil); @@ -407,6 +406,8 @@ FrameBuffer::~FrameBuffer() #if CC_ENABLE_CACHE_TEXTURE_DATA Director::getInstance()->getEventDispatcher()->removeEventListener(_dirtyFBOListener); #endif + if (isDefaultFBO()) + _defaultFBO = nullptr; } } From c0f7ecfcde2a664b10c1aa1e69054c576625592a Mon Sep 17 00:00:00 2001 From: XiaoFeng Date: Wed, 25 Nov 2015 09:49:19 +0800 Subject: [PATCH 08/20] User GetModuleFileNameW in all condition, it is more safe than _get_wpgmptr --- cocos/platform/win32/CCFileUtils-win32.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/cocos/platform/win32/CCFileUtils-win32.cpp b/cocos/platform/win32/CCFileUtils-win32.cpp index 3469b11e61..c4c376ded1 100644 --- a/cocos/platform/win32/CCFileUtils-win32.cpp +++ b/cocos/platform/win32/CCFileUtils-win32.cpp @@ -136,14 +136,9 @@ static void _checkPath() { if (s_resourcePath.empty()) { - WCHAR *pUtf16ExePath = nullptr; -#ifdef CC_STUDIO_ENABLED_VIEW WCHAR utf16Path[CC_MAX_PATH] = { 0 }; GetModuleFileNameW(NULL, utf16Path, CC_MAX_PATH - 1); - pUtf16ExePath = &(utf16Path[0]); -#else - _get_wpgmptr(&pUtf16ExePath); // CocoStudio Notice : This function won't work under studio, will cause a assert in system library -#endif + WCHAR *pUtf16ExePath = &(utf16Path[0]); // We need only directory part without exe WCHAR *pUtf16DirEnd = wcsrchr(pUtf16ExePath, L'\\'); From 5221f8a6fc76bf6566f8424a15378848f2fbd761 Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Thu, 26 Nov 2015 12:03:18 +0800 Subject: [PATCH 09/20] improve the code by code review suggestions. --- cocos/2d/CCFontAtlas.cpp | 3 +-- cocos/2d/CCLabel.cpp | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/cocos/2d/CCFontAtlas.cpp b/cocos/2d/CCFontAtlas.cpp index 4dbb0f72d4..37c360294d 100644 --- a/cocos/2d/CCFontAtlas.cpp +++ b/cocos/2d/CCFontAtlas.cpp @@ -160,13 +160,12 @@ void FontAtlas::addLetterDefinition(char16_t utf16Char, const FontLetterDefiniti void FontAtlas::scaleFontLetterDefinition(float scaleFactor) { for (auto&& fontDefinition : _letterDefinitions) { - FontLetterDefinition letterDefinition = fontDefinition.second; + auto& letterDefinition = fontDefinition.second; letterDefinition.width *= scaleFactor; letterDefinition.height *= scaleFactor; letterDefinition.offsetX *= scaleFactor; letterDefinition.offsetY *= scaleFactor; letterDefinition.xAdvance *= scaleFactor; - _letterDefinitions[fontDefinition.first] = letterDefinition; } } diff --git a/cocos/2d/CCLabel.cpp b/cocos/2d/CCLabel.cpp index e9d3e93906..ede619ef3a 100644 --- a/cocos/2d/CCLabel.cpp +++ b/cocos/2d/CCLabel.cpp @@ -580,7 +580,7 @@ bool Label::setBMFontFilePath(const std::string& bmfontFilePath, const Vec2& ima } } - if(fontSize > 0){ + if(fontSize > 0.0f){ _bmFontSize = fontSize; } From d744c167b7d54ddec3ba312276eeeacbadd1914f Mon Sep 17 00:00:00 2001 From: XiaoFeng Date: Thu, 26 Nov 2015 13:49:32 +0800 Subject: [PATCH 10/20] Fix button texture loaded mark has set to wrong value bug --- cocos/ui/UIButton.cpp | 33 ++++++++++++++++++--------------- cocos/ui/UIButton.h | 6 +++--- 2 files changed, 21 insertions(+), 18 deletions(-) diff --git a/cocos/ui/UIButton.cpp b/cocos/ui/UIButton.cpp index 25be951bec..bfdd983805 100644 --- a/cocos/ui/UIButton.cpp +++ b/cocos/ui/UIButton.cpp @@ -232,10 +232,11 @@ void Button::loadTextureNormal(const std::string& normal,TextureResType texType) { _normalFileName = normal; _normalTexType = texType; - + bool textureLoaded = true; if (normal.empty()) { _buttonNormalRenderer->init(); + textureLoaded = false; } else { @@ -251,10 +252,10 @@ void Button::loadTextureNormal(const std::string& normal,TextureResType texType) break; } } - this->setupNormalTexture(); + this->setupNormalTexture(textureLoaded); } -void Button::setupNormalTexture() +void Button::setupNormalTexture(bool textureLoaded) { _normalTextureSize = _buttonNormalRenderer->getContentSize(); // force update _customSize, fixed issue: @@ -274,24 +275,25 @@ void Button::setupNormalTexture() { updateContentSizeWithTextureSize(_normalTextureSize); } - _normalTextureLoaded = true; + _normalTextureLoaded = textureLoaded; _normalTextureAdaptDirty = true; } void Button::loadTextureNormal(SpriteFrame* normalSpriteFrame) { _buttonNormalRenderer->initWithSpriteFrame(normalSpriteFrame); - this->setupNormalTexture(); + this->setupNormalTexture(nullptr != normalSpriteFrame); } void Button::loadTexturePressed(const std::string& selected,TextureResType texType) { _clickedFileName = selected; _pressedTexType = texType; - + bool textureLoade = true; if (selected.empty()) { _buttonClickedRenderer->init(); + textureLoade = false; } else { @@ -307,33 +309,34 @@ void Button::loadTexturePressed(const std::string& selected,TextureResType texTy break; } } - this->setupPressedTexture(); + this->setupPressedTexture(textureLoade); } -void Button::setupPressedTexture() +void Button::setupPressedTexture(bool textureLoaded) { _pressedTextureSize = _buttonClickedRenderer->getContentSize(); this->updateChildrenDisplayedRGBA(); - _pressedTextureLoaded = true; + _pressedTextureLoaded = textureLoaded; _pressedTextureAdaptDirty = true; } void Button::loadTexturePressed(SpriteFrame* pressedSpriteFrame) { _buttonClickedRenderer->initWithSpriteFrame(pressedSpriteFrame); - this->setupPressedTexture(); + this->setupPressedTexture(nullptr != pressedSpriteFrame); } void Button::loadTextureDisabled(const std::string& disabled,TextureResType texType) { _disabledFileName = disabled; _disabledTexType = texType; - + bool textureLoaded = true; if (disabled.empty()) { _buttonDisabledRenderer->init(); + textureLoaded = false; } else { @@ -349,23 +352,23 @@ void Button::loadTextureDisabled(const std::string& disabled,TextureResType texT break; } } - this->setupDisabledTexture(); + this->setupDisabledTexture(textureLoaded); } -void Button::setupDisabledTexture() +void Button::setupDisabledTexture(bool textureLoaded) { _disabledTextureSize = _buttonDisabledRenderer->getContentSize(); this->updateChildrenDisplayedRGBA(); - _disabledTextureLoaded = true; + _disabledTextureLoaded = textureLoaded; _disabledTextureAdaptDirty = true; } void Button::loadTextureDisabled(SpriteFrame* disabledSpriteFrame) { _buttonDisabledRenderer->initWithSpriteFrame(disabledSpriteFrame); - this->setupDisabledTexture(); + this->setupDisabledTexture(nullptr != disabledSpriteFrame); } void Button::setCapInsets(const Rect &capInsets) diff --git a/cocos/ui/UIButton.h b/cocos/ui/UIButton.h index f216c907c3..1cb996f3ef 100644 --- a/cocos/ui/UIButton.h +++ b/cocos/ui/UIButton.h @@ -322,11 +322,11 @@ protected: virtual void onSizeChanged() override; void loadTextureNormal(SpriteFrame* normalSpriteFrame); - void setupNormalTexture(); + void setupNormalTexture(bool textureLoaded); void loadTexturePressed(SpriteFrame* pressedSpriteFrame); - void setupPressedTexture(); + void setupPressedTexture(bool textureLoaded); void loadTextureDisabled(SpriteFrame* disabledSpriteFrame); - void setupDisabledTexture(); + void setupDisabledTexture(bool textureLoaded); void normalTextureScaleChangedWithSize(); void pressedTextureScaleChangedWithSize(); From 3296476c43424abcb6288ab10ab7b7a33d44b5d5 Mon Sep 17 00:00:00 2001 From: CocosRobot Date: Thu, 26 Nov 2015 05:53:45 +0000 Subject: [PATCH 11/20] [AUTO][ci skip]: updating cocos2dx_files.json --- templates/cocos2dx_files.json | 2 ++ 1 file changed, 2 insertions(+) diff --git a/templates/cocos2dx_files.json b/templates/cocos2dx_files.json index 9ecf2ac219..4a42163666 100644 --- a/templates/cocos2dx_files.json +++ b/templates/cocos2dx_files.json @@ -402,6 +402,8 @@ "cocos/base/CCScheduler.h", "cocos/base/CCScriptSupport.cpp", "cocos/base/CCScriptSupport.h", + "cocos/base/CCStencilStateManager.cpp", + "cocos/base/CCStencilStateManager.hpp", "cocos/base/CCTouch.cpp", "cocos/base/CCTouch.h", "cocos/base/CCUserDefault-android.cpp", From 390a37e1239691cfda430e59c379de3ee9b7fb5d Mon Sep 17 00:00:00 2001 From: CocosRobot Date: Thu, 26 Nov 2015 05:56:34 +0000 Subject: [PATCH 12/20] [AUTO][ci skip]: updating cocos2dx_files.json --- templates/cocos2dx_files.json | 2 ++ 1 file changed, 2 insertions(+) diff --git a/templates/cocos2dx_files.json b/templates/cocos2dx_files.json index 9ecf2ac219..4a42163666 100644 --- a/templates/cocos2dx_files.json +++ b/templates/cocos2dx_files.json @@ -402,6 +402,8 @@ "cocos/base/CCScheduler.h", "cocos/base/CCScriptSupport.cpp", "cocos/base/CCScriptSupport.h", + "cocos/base/CCStencilStateManager.cpp", + "cocos/base/CCStencilStateManager.hpp", "cocos/base/CCTouch.cpp", "cocos/base/CCTouch.h", "cocos/base/CCUserDefault-android.cpp", From 58912c88b949fd17ac5a56f244bbfe1dc58e77ad Mon Sep 17 00:00:00 2001 From: CocosRobot Date: Thu, 26 Nov 2015 06:00:46 +0000 Subject: [PATCH 13/20] [ci skip][AUTO]: updating luabinding & jsbinding automatically --- .../js-bindings/auto/jsb_cocos2dx_ui_auto.cpp | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp index 1523739391..be7803f52b 100644 --- a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp +++ b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp @@ -2526,7 +2526,7 @@ bool js_cocos2dx_ui_Layout_getRenderFile(JSContext *cx, uint32_t argc, jsval *vp if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -3397,7 +3397,7 @@ bool js_cocos2dx_ui_Button_getDisabledFile(JSContext *cx, uint32_t argc, jsval * if (argc == 0) { cocos2d::ResouceData ret = cobj->getDisabledFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -3471,7 +3471,7 @@ bool js_cocos2dx_ui_Button_getNormalFile(JSContext *cx, uint32_t argc, jsval *vp if (argc == 0) { cocos2d::ResouceData ret = cobj->getNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -3945,7 +3945,7 @@ bool js_cocos2dx_ui_Button_getPressedFile(JSContext *cx, uint32_t argc, jsval *v if (argc == 0) { cocos2d::ResouceData ret = cobj->getPressedFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4369,7 +4369,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getBackDisabledFile(JSContext *cx, uint3 if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackDisabledFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4387,7 +4387,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getCrossDisabeldFile(JSContext *cx, uint if (argc == 0) { cocos2d::ResouceData ret = cobj->getCrossDisabeldFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4465,7 +4465,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getCrossNormalFile(JSContext *cx, uint32 if (argc == 0) { cocos2d::ResouceData ret = cobj->getCrossNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4503,7 +4503,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getBackPressedFile(JSContext *cx, uint32 if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackPressedFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4694,7 +4694,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getBackNormalFile(JSContext *cx, uint32_ if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -6053,7 +6053,7 @@ bool js_cocos2dx_ui_ImageView_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -7087,7 +7087,7 @@ bool js_cocos2dx_ui_TextAtlas_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -7412,7 +7412,7 @@ bool js_cocos2dx_ui_LoadingBar_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -9934,7 +9934,7 @@ bool js_cocos2dx_ui_Slider_getBallNormalFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getBallNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -9990,7 +9990,7 @@ bool js_cocos2dx_ui_Slider_getBallPressedFile(JSContext *cx, uint32_t argc, jsva if (argc == 0) { cocos2d::ResouceData ret = cobj->getBallPressedFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -10132,7 +10132,7 @@ bool js_cocos2dx_ui_Slider_getProgressBarFile(JSContext *cx, uint32_t argc, jsva if (argc == 0) { cocos2d::ResouceData ret = cobj->getProgressBarFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -10198,7 +10198,7 @@ bool js_cocos2dx_ui_Slider_getBackFile(JSContext *cx, uint32_t argc, jsval *vp) if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -10274,7 +10274,7 @@ bool js_cocos2dx_ui_Slider_getBallDisabeldFile(JSContext *cx, uint32_t argc, jsv if (argc == 0) { cocos2d::ResouceData ret = cobj->getBallDisabeldFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -12321,7 +12321,7 @@ bool js_cocos2dx_ui_TextBMFont_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } From 51cfbca5231b426749524a76c09bc475f7c73e47 Mon Sep 17 00:00:00 2001 From: CocosRobot Date: Thu, 26 Nov 2015 06:02:24 +0000 Subject: [PATCH 14/20] [ci skip][AUTO]: updating luabinding & jsbinding automatically --- .../js-bindings/auto/jsb_cocos2dx_ui_auto.cpp | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp index 1523739391..be7803f52b 100644 --- a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp +++ b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_ui_auto.cpp @@ -2526,7 +2526,7 @@ bool js_cocos2dx_ui_Layout_getRenderFile(JSContext *cx, uint32_t argc, jsval *vp if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -3397,7 +3397,7 @@ bool js_cocos2dx_ui_Button_getDisabledFile(JSContext *cx, uint32_t argc, jsval * if (argc == 0) { cocos2d::ResouceData ret = cobj->getDisabledFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -3471,7 +3471,7 @@ bool js_cocos2dx_ui_Button_getNormalFile(JSContext *cx, uint32_t argc, jsval *vp if (argc == 0) { cocos2d::ResouceData ret = cobj->getNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -3945,7 +3945,7 @@ bool js_cocos2dx_ui_Button_getPressedFile(JSContext *cx, uint32_t argc, jsval *v if (argc == 0) { cocos2d::ResouceData ret = cobj->getPressedFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4369,7 +4369,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getBackDisabledFile(JSContext *cx, uint3 if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackDisabledFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4387,7 +4387,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getCrossDisabeldFile(JSContext *cx, uint if (argc == 0) { cocos2d::ResouceData ret = cobj->getCrossDisabeldFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4465,7 +4465,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getCrossNormalFile(JSContext *cx, uint32 if (argc == 0) { cocos2d::ResouceData ret = cobj->getCrossNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4503,7 +4503,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getBackPressedFile(JSContext *cx, uint32 if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackPressedFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -4694,7 +4694,7 @@ bool js_cocos2dx_ui_AbstractCheckButton_getBackNormalFile(JSContext *cx, uint32_ if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -6053,7 +6053,7 @@ bool js_cocos2dx_ui_ImageView_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -7087,7 +7087,7 @@ bool js_cocos2dx_ui_TextAtlas_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -7412,7 +7412,7 @@ bool js_cocos2dx_ui_LoadingBar_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -9934,7 +9934,7 @@ bool js_cocos2dx_ui_Slider_getBallNormalFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getBallNormalFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -9990,7 +9990,7 @@ bool js_cocos2dx_ui_Slider_getBallPressedFile(JSContext *cx, uint32_t argc, jsva if (argc == 0) { cocos2d::ResouceData ret = cobj->getBallPressedFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -10132,7 +10132,7 @@ bool js_cocos2dx_ui_Slider_getProgressBarFile(JSContext *cx, uint32_t argc, jsva if (argc == 0) { cocos2d::ResouceData ret = cobj->getProgressBarFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -10198,7 +10198,7 @@ bool js_cocos2dx_ui_Slider_getBackFile(JSContext *cx, uint32_t argc, jsval *vp) if (argc == 0) { cocos2d::ResouceData ret = cobj->getBackFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -10274,7 +10274,7 @@ bool js_cocos2dx_ui_Slider_getBallDisabeldFile(JSContext *cx, uint32_t argc, jsv if (argc == 0) { cocos2d::ResouceData ret = cobj->getBallDisabeldFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } @@ -12321,7 +12321,7 @@ bool js_cocos2dx_ui_TextBMFont_getRenderFile(JSContext *cx, uint32_t argc, jsval if (argc == 0) { cocos2d::ResouceData ret = cobj->getRenderFile(); jsval jsret = JSVAL_NULL; - jsret = resoucedata_to_jsval(cx, ret); + #pragma warning NO CONVERSION FROM NATIVE FOR ResouceData; args.rval().set(jsret); return true; } From f5d2ea11b754c6d4f7d2cc15b0c94d09c0003da4 Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Fri, 27 Nov 2015 10:58:48 +0800 Subject: [PATCH 15/20] Update CHANGELOG --- CHANGELOG | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG b/CHANGELOG index 30f44ad00a..0108fbd1df 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,5 +1,6 @@ cocos2d-x-3.10 December ? 2015 [NEW] Core: Added Application::getVersion() to get the app version. +[NEW] UI: Add PageView indicator. [REFINE] UI: RichText support new line element. [REFINE] UI: Set focus to Widget when touched. From d6ddb365b6981496ed25d69487ce8677c6112d6c Mon Sep 17 00:00:00 2001 From: Xpol Wan Date: Fri, 27 Nov 2015 14:43:25 +0800 Subject: [PATCH 16/20] Remove boring logs in cocos studio supporting module. They are helpless for debugging, we should use break points for debugging. --- .../ActionTimeline/CCActionTimelineCache.cpp | 2 -- .../cocostudio/ActionTimeline/CSLoader.cpp | 14 -------------- .../cocostudio/CCActionManagerEx.cpp | 3 --- cocos/editor-support/cocostudio/CCSSceneReader.cpp | 3 --- 4 files changed, 22 deletions(-) diff --git a/cocos/editor-support/cocostudio/ActionTimeline/CCActionTimelineCache.cpp b/cocos/editor-support/cocostudio/ActionTimeline/CCActionTimelineCache.cpp index db9ed09714..4b7ed41437 100644 --- a/cocos/editor-support/cocostudio/ActionTimeline/CCActionTimelineCache.cpp +++ b/cocos/editor-support/cocostudio/ActionTimeline/CCActionTimelineCache.cpp @@ -139,7 +139,6 @@ ActionTimeline* ActionTimelineCache::createAction(const std::string& filename) std::string path = filename; size_t pos = path.find_last_of('.'); std::string suffix = path.substr(pos + 1, path.length()); - CCLOG("suffix = %s", suffix.c_str()); ActionTimelineCache* cache = ActionTimelineCache::getInstance(); @@ -507,7 +506,6 @@ Timeline* ActionTimelineCache::loadTimelineWithFlatBuffers(const flatbuffers::Ti if(property == "") return nullptr; - CCLOG("property = %s", property.c_str()); if(property != "") { diff --git a/cocos/editor-support/cocostudio/ActionTimeline/CSLoader.cpp b/cocos/editor-support/cocostudio/ActionTimeline/CSLoader.cpp index ccb532481f..f967fb4d68 100644 --- a/cocos/editor-support/cocostudio/ActionTimeline/CSLoader.cpp +++ b/cocos/editor-support/cocostudio/ActionTimeline/CSLoader.cpp @@ -264,7 +264,6 @@ Node* CSLoader::createNode(const std::string& filename) std::string path = filename; size_t pos = path.find_last_of('.'); std::string suffix = path.substr(pos + 1, path.length()); - CCLOG("suffix = %s", suffix.c_str()); CSLoader* load = CSLoader::getInstance(); @@ -285,7 +284,6 @@ Node* CSLoader::createNode(const std::string &filename, const ccNodeLoadCallback std::string path = filename; size_t pos = path.find_last_of('.'); std::string suffix = path.substr(pos + 1, path.length()); - CCLOG("suffix = %s", suffix.c_str()); CSLoader* load = CSLoader::getInstance(); @@ -335,7 +333,6 @@ std::string CSLoader::getExtentionName(const std::string& name) ActionTimeline* CSLoader::createTimeline(const std::string &filename) { std::string suffix = getExtentionName(filename); - CCLOG("suffix = %s", suffix.c_str()); ActionTimelineCache* cache = ActionTimelineCache::getInstance(); @@ -354,7 +351,6 @@ ActionTimeline* CSLoader::createTimeline(const std::string &filename) ActionTimeline* CSLoader::createTimeline(const Data data, const std::string& filename) { std::string suffix = getExtentionName(filename); - CCLOG("suffix = %s", suffix.c_str()); ActionTimelineCache* cache = ActionTimelineCache::getInstance(); @@ -982,7 +978,6 @@ Node* CSLoader::nodeWithFlatBuffersFile(const std::string &fileName, const ccNod // decode plist auto textures = csparsebinary->textures(); int textureSize = textures->size(); - CCLOG("textureSize = %d", textureSize); for (int i = 0; i < textureSize; ++i) { SpriteFrameCache::getInstance()->addSpriteFramesWithFile(textures->Get(i)->c_str()); @@ -1007,7 +1002,6 @@ Node* CSLoader::nodeWithFlatBuffers(const flatbuffers::NodeTree *nodetree, const Node* node = nullptr; std::string classname = nodetree->classname()->c_str(); - CCLOG("classname = %s", classname.c_str()); auto options = nodetree->options(); @@ -1016,7 +1010,6 @@ Node* CSLoader::nodeWithFlatBuffers(const flatbuffers::NodeTree *nodetree, const auto reader = ProjectNodeReader::getInstance(); auto projectNodeOptions = (ProjectNodeOptions*)options->data(); std::string filePath = projectNodeOptions->fileName()->c_str(); - CCLOG("filePath = %s", filePath.c_str()); cocostudio::timeline::ActionTimeline* action = nullptr; if (filePath != "" && FileUtils::getInstance()->isFileExist(filePath)) @@ -1079,7 +1072,6 @@ Node* CSLoader::nodeWithFlatBuffers(const flatbuffers::NodeTree *nodetree, const { _callbackHandlers.pushBack(node); _rootNode = _callbackHandlers.back(); - CCLOG("after push back _rootNode name = %s", _rootNode->getName().c_str()); } /**/ // _loadingNodeParentHierarchy.push_back(node); @@ -1093,12 +1085,10 @@ Node* CSLoader::nodeWithFlatBuffers(const flatbuffers::NodeTree *nodetree, const auto children = nodetree->children(); int size = children->size(); - CCLOG("size = %d", size); for (int i = 0; i < size; ++i) { auto subNodeTree = children->Get(i); Node* child = nodeWithFlatBuffers(subNodeTree, callback); - CCLOG("child = %p", child); if (child) { PageView* pageView = dynamic_cast(node); @@ -1356,7 +1346,6 @@ Node* CSLoader::nodeWithFlatBuffersForSimulator(const flatbuffers::NodeTree *nod Node* node = nullptr; std::string classname = nodetree->classname()->c_str(); - CCLOG("classname = %s", classname.c_str()); auto options = nodetree->options(); @@ -1365,7 +1354,6 @@ Node* CSLoader::nodeWithFlatBuffersForSimulator(const flatbuffers::NodeTree *nod auto reader = ProjectNodeReader::getInstance(); auto projectNodeOptions = (ProjectNodeOptions*)options->data(); std::string filePath = projectNodeOptions->fileName()->c_str(); - CCLOG("filePath = %s", filePath.c_str()); cocostudio::timeline::ActionTimeline* action = nullptr; if (filePath != "" && FileUtils::getInstance()->isFileExist(filePath)) @@ -1431,12 +1419,10 @@ Node* CSLoader::nodeWithFlatBuffersForSimulator(const flatbuffers::NodeTree *nod auto children = nodetree->children(); int size = children->size(); - CCLOG("size = %d", size); for (int i = 0; i < size; ++i) { auto subNodeTree = children->Get(i); Node* child = nodeWithFlatBuffersForSimulator(subNodeTree); - CCLOG("child = %p", child); if (child) { PageView* pageView = dynamic_cast(node); diff --git a/cocos/editor-support/cocostudio/CCActionManagerEx.cpp b/cocos/editor-support/cocostudio/CCActionManagerEx.cpp index 6faed2ed76..efcba92117 100644 --- a/cocos/editor-support/cocostudio/CCActionManagerEx.cpp +++ b/cocos/editor-support/cocostudio/CCActionManagerEx.cpp @@ -63,7 +63,6 @@ void ActionManagerEx::initWithDictionary(const char* jsonName,const rapidjson::V std::string path = jsonName; ssize_t pos = path.find_last_of("/"); std::string fileName = path.substr(pos+1,path.length()); - CCLOG("filename == %s",fileName.c_str()); cocos2d::Vector actionList; int actionCount = DICTOOL->getArrayCount_json(dic, "actionlist"); for (int i=0; i actionList; stExpCocoNode *stChildArray = pCocoNode->GetChildArray(cocoLoader); @@ -118,7 +116,6 @@ ActionObject* ActionManagerEx::getActionByName(const char* jsonName,const char* std::string path = jsonName; ssize_t pos = path.find_last_of("/"); std::string fileName = path.substr(pos+1,path.length()); - CCLOG("find filename == %s",fileName.c_str()); auto iterator = _actionDic.find(fileName); if (iterator == _actionDic.end()) { diff --git a/cocos/editor-support/cocostudio/CCSSceneReader.cpp b/cocos/editor-support/cocostudio/CCSSceneReader.cpp index d9137358f1..17eb393652 100644 --- a/cocos/editor-support/cocostudio/CCSSceneReader.cpp +++ b/cocos/editor-support/cocostudio/CCSSceneReader.cpp @@ -110,7 +110,6 @@ cocos2d::Node* SceneReader::createNodeWithSceneFile(const std::string &fileName, { pCom = createComponent(comName); } - CCLOG("classname = %s", comName); if (pCom != nullptr) { data->_rData = nullptr; @@ -270,7 +269,6 @@ Node* SceneReader::createObject(const rapidjson::Value &dict, cocos2d::Node* par } const char *comName = DICTOOL->getStringValue_json(subDict, "classname"); Component *com = this->createComponent(comName); - CCLOG("classname = %s", comName); SerData *data = new (std::nothrow) SerData(); if (com != nullptr) { @@ -388,7 +386,6 @@ cocos2d::Node* SceneReader::createObject(CocoLoader *cocoLoader, stExpCocoNode * { pCom = createComponent(comName); } - CCLOG("classname = %s", comName); if (pCom != nullptr) { data->_rData = nullptr; From f0cc8e7f255da6e70a02677ba8d1c32a1e92c91b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=82=96=E5=B3=B0?= Date: Fri, 27 Nov 2015 15:44:35 +0800 Subject: [PATCH 17/20] Fix keyboard won't dismiss on iOS issue --- cocos/platform/ios/CCEAGLView-ios.mm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cocos/platform/ios/CCEAGLView-ios.mm b/cocos/platform/ios/CCEAGLView-ios.mm index 3edc3956c1..334fd30e88 100644 --- a/cocos/platform/ios/CCEAGLView-ios.mm +++ b/cocos/platform/ios/CCEAGLView-ios.mm @@ -378,8 +378,8 @@ Copyright (C) 2008 Apple Inc. All Rights Reserved. for(UIView* view in subviews) { if([view isKindOfClass:NSClassFromString(@"CCCustomUITextField")] || - [view isKindOfClass:NSClassFromString(@"UISingleLineTextField")] || - [view isKindOfClass:NSClassFromString(@"UIMultilineTextField")]) + [view isKindOfClass:NSClassFromString(@"CCUISingleLineTextField")] || + [view isKindOfClass:NSClassFromString(@"CCUIMultilineTextField")]) { if ([view isFirstResponder]) { From 9639208ce3c8ce58dc3cbc33b282ff888e90ebd8 Mon Sep 17 00:00:00 2001 From: zilongshanren Date: Fri, 27 Nov 2015 17:32:31 +0800 Subject: [PATCH 18/20] Update CHANGELOG --- CHANGELOG | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG b/CHANGELOG index 0108fbd1df..c2dc465d84 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,6 +1,7 @@ cocos2d-x-3.10 December ? 2015 [NEW] Core: Added Application::getVersion() to get the app version. [NEW] UI: Add PageView indicator. +[NEW] Label: Add three Overflow type to new label, see release note for more information. [REFINE] UI: RichText support new line element. [REFINE] UI: Set focus to Widget when touched. From 5c9084fd7d1ef3823240025cb43bb6fe0b1dc992 Mon Sep 17 00:00:00 2001 From: CocosRobot Date: Fri, 27 Nov 2015 09:41:59 +0000 Subject: [PATCH 19/20] [ci skip][AUTO]: updating luabinding & jsbinding automatically --- .../auto/api/jsb_cocos2dx_auto_api.js | 76 +++- .../js-bindings/auto/jsb_cocos2dx_auto.cpp | 170 ++++++++- .../js-bindings/auto/jsb_cocos2dx_auto.hpp | 8 +- .../scripting/lua-bindings/auto/api/Label.lua | 60 ++- .../lua-bindings/auto/lua_cocos2dx_auto.cpp | 341 +++++++++++++++++- .../lua-bindings/auto/lua_cocos2dx_auto.hpp | 6 + 6 files changed, 618 insertions(+), 43 deletions(-) diff --git a/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js b/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js index 993733e0c6..6d0eca5575 100644 --- a/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js +++ b/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js @@ -11963,6 +11963,16 @@ getBlendFunc : function ( return cc.BlendFunc; }, +/** + * @method enableWrap + * @param {bool} arg0 + */ +enableWrap : function ( +bool +) +{ +}, + /** * @method setWidth * @param {float} arg0 @@ -11973,6 +11983,16 @@ float { }, +/** + * @method getBMFontSize + * @return {float} + */ +getBMFontSize : function ( +) +{ + return 0; +}, + /** * @method getMaxLineWidth * @return {float} @@ -12027,11 +12047,13 @@ str * @method setBMFontFilePath * @param {String} arg0 * @param {vec2_object} arg1 + * @param {float} arg2 * @return {bool} */ setBMFontFilePath : function ( str, -vec2 +vec2, +float ) { return false; @@ -12057,6 +12079,16 @@ float { }, +/** + * @method setOverflow + * @param {cc.Label::Overflow} arg0 + */ +setOverflow : function ( +overflow +) +{ +}, + /** * @method getLineSpacing * @return {float} @@ -12245,6 +12277,18 @@ color4b { }, +/** + * @method getLetter + * @param {int} arg0 + * @return {cc.Sprite} + */ +getLetter : function ( +int +) +{ + return cc.Sprite; +}, + /** * @method setHeight * @param {float} arg0 @@ -12276,15 +12320,13 @@ color4b }, /** - * @method getLetter - * @param {int} arg0 - * @return {cc.Sprite} + * @method getOverflow + * @return {cc.Label::Overflow} */ -getLetter : function ( -int +getOverflow : function ( ) { - return cc.Sprite; + return 0; }, /** @@ -12347,6 +12389,16 @@ texthalignment { }, +/** + * @method isWrapEnabled + * @return {bool} + */ +isWrapEnabled : function ( +) +{ + return false; +}, + /** * @method setAlignment * @param {cc.TextHAlignment|cc.TextHAlignment} texthalignment @@ -12367,6 +12419,16 @@ requestSystemFontRefresh : function ( { }, +/** + * @method setBMFontSize + * @param {float} arg0 + */ +setBMFontSize : function ( +float +) +{ +}, + /** * @method createWithBMFont * @param {String} arg0 diff --git a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp index 5b6c247352..226143358d 100644 --- a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp +++ b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp @@ -37622,6 +37622,26 @@ bool js_cocos2dx_Label_getBlendFunc(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_getBlendFunc : wrong number of arguments: %d, was expecting %d", argc, 0); return false; } +bool js_cocos2dx_Label_enableWrap(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_enableWrap : Invalid Native Object"); + if (argc == 1) { + bool arg0; + arg0 = JS::ToBoolean(args.get(0)); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_enableWrap : Error processing arguments"); + cobj->enableWrap(arg0); + args.rval().setUndefined(); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_enableWrap : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_setWidth(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -37642,6 +37662,24 @@ bool js_cocos2dx_Label_setWidth(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_setWidth : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_getBMFontSize(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getBMFontSize : Invalid Native Object"); + if (argc == 0) { + double ret = cobj->getBMFontSize(); + jsval jsret = JSVAL_NULL; + jsret = DOUBLE_TO_JSVAL(ret); + args.rval().set(jsret); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_getBMFontSize : wrong number of arguments: %d, was expecting %d", argc, 0); + return false; +} bool js_cocos2dx_Label_getMaxLineWidth(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -37768,6 +37806,20 @@ bool js_cocos2dx_Label_setBMFontFilePath(JSContext *cx, uint32_t argc, jsval *vp args.rval().set(jsret); return true; } + if (argc == 3) { + std::string arg0; + cocos2d::Vec2 arg1; + double arg2 = 0; + ok &= jsval_to_std_string(cx, args.get(0), &arg0); + ok &= jsval_to_vector2(cx, args.get(1), &arg1); + ok &= JS::ToNumber( cx, args.get(2), &arg2) && !isnan(arg2); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_setBMFontFilePath : Error processing arguments"); + bool ret = cobj->setBMFontFilePath(arg0, arg1, arg2); + jsval jsret = JSVAL_NULL; + jsret = BOOLEAN_TO_JSVAL(ret); + args.rval().set(jsret); + return true; + } JS_ReportError(cx, "js_cocos2dx_Label_setBMFontFilePath : wrong number of arguments: %d, was expecting %d", argc, 1); return false; @@ -37812,6 +37864,26 @@ bool js_cocos2dx_Label_setSystemFontSize(JSContext *cx, uint32_t argc, jsval *vp JS_ReportError(cx, "js_cocos2dx_Label_setSystemFontSize : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_setOverflow(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_setOverflow : Invalid Native Object"); + if (argc == 1) { + cocos2d::Label::Overflow arg0; + ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_setOverflow : Error processing arguments"); + cobj->setOverflow(arg0); + args.rval().setUndefined(); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_setOverflow : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_getLineSpacing(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -38219,6 +38291,35 @@ bool js_cocos2dx_Label_setTextColor(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_setTextColor : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getLetter : Invalid Native Object"); + if (argc == 1) { + int arg0 = 0; + ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_getLetter : Error processing arguments"); + cocos2d::Sprite* ret = cobj->getLetter(arg0); + jsval jsret = JSVAL_NULL; + do { + if (ret) { + js_proxy_t *jsProxy = js_get_or_create_proxy(cx, (cocos2d::Sprite*)ret); + jsret = OBJECT_TO_JSVAL(jsProxy->obj); + } else { + jsret = JSVAL_NULL; + } + } while (0); + args.rval().set(jsret); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_getLetter : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_setHeight(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -38277,33 +38378,22 @@ bool js_cocos2dx_Label_enableGlow(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_enableGlow : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } -bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp) +bool js_cocos2dx_Label_getOverflow(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); - bool ok = true; JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); js_proxy_t *proxy = jsb_get_js_proxy(obj); cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); - JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getLetter : Invalid Native Object"); - if (argc == 1) { - int arg0 = 0; - ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); - JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_getLetter : Error processing arguments"); - cocos2d::Sprite* ret = cobj->getLetter(arg0); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getOverflow : Invalid Native Object"); + if (argc == 0) { + int ret = (int)cobj->getOverflow(); jsval jsret = JSVAL_NULL; - do { - if (ret) { - js_proxy_t *jsProxy = js_get_or_create_proxy(cx, (cocos2d::Sprite*)ret); - jsret = OBJECT_TO_JSVAL(jsProxy->obj); - } else { - jsret = JSVAL_NULL; - } - } while (0); + jsret = int32_to_jsval(cx, ret); args.rval().set(jsret); return true; } - JS_ReportError(cx, "js_cocos2dx_Label_getLetter : wrong number of arguments: %d, was expecting %d", argc, 1); + JS_ReportError(cx, "js_cocos2dx_Label_getOverflow : wrong number of arguments: %d, was expecting %d", argc, 0); return false; } bool js_cocos2dx_Label_setAdditionalKerning(JSContext *cx, uint32_t argc, jsval *vp) @@ -38420,6 +38510,24 @@ bool js_cocos2dx_Label_setHorizontalAlignment(JSContext *cx, uint32_t argc, jsva JS_ReportError(cx, "js_cocos2dx_Label_setHorizontalAlignment : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_isWrapEnabled(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_isWrapEnabled : Invalid Native Object"); + if (argc == 0) { + bool ret = cobj->isWrapEnabled(); + jsval jsret = JSVAL_NULL; + jsret = BOOLEAN_TO_JSVAL(ret); + args.rval().set(jsret); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_isWrapEnabled : wrong number of arguments: %d, was expecting %d", argc, 0); + return false; +} bool js_cocos2dx_Label_setAlignment(JSContext *cx, uint32_t argc, jsval *vp) { bool ok = true; @@ -38475,6 +38583,26 @@ bool js_cocos2dx_Label_requestSystemFontRefresh(JSContext *cx, uint32_t argc, js JS_ReportError(cx, "js_cocos2dx_Label_requestSystemFontRefresh : wrong number of arguments: %d, was expecting %d", argc, 0); return false; } +bool js_cocos2dx_Label_setBMFontSize(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_setBMFontSize : Invalid Native Object"); + if (argc == 1) { + double arg0 = 0; + ok &= JS::ToNumber( cx, args.get(0), &arg0) && !isnan(arg0); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_setBMFontSize : Error processing arguments"); + cobj->setBMFontSize(arg0); + args.rval().setUndefined(); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_setBMFontSize : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_createWithBMFont(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -38865,7 +38993,9 @@ void js_register_cocos2dx_Label(JSContext *cx, JS::HandleObject global) { JS_FN("disableEffect", js_cocos2dx_Label_disableEffect, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getTextColor", js_cocos2dx_Label_getTextColor, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getBlendFunc", js_cocos2dx_Label_getBlendFunc, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("enableWrap", js_cocos2dx_Label_enableWrap, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setWidth", js_cocos2dx_Label_setWidth, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("getBMFontSize", js_cocos2dx_Label_getBMFontSize, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getMaxLineWidth", js_cocos2dx_Label_getMaxLineWidth, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getHorizontalAlignment", js_cocos2dx_Label_getHorizontalAlignment, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setClipMarginEnabled", js_cocos2dx_Label_setClipMarginEnabled, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), @@ -38874,6 +39004,7 @@ void js_register_cocos2dx_Label(JSContext *cx, JS::HandleObject global) { JS_FN("setBMFontFilePath", js_cocos2dx_Label_setBMFontFilePath, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setLineHeight", js_cocos2dx_Label_setLineHeight, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setSystemFontSize", js_cocos2dx_Label_setSystemFontSize, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("setOverflow", js_cocos2dx_Label_setOverflow, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getLineSpacing", js_cocos2dx_Label_getLineSpacing, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("updateContent", js_cocos2dx_Label_updateContent, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getStringLength", js_cocos2dx_Label_getStringLength, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), @@ -38892,18 +39023,21 @@ void js_register_cocos2dx_Label(JSContext *cx, JS::HandleObject global) { JS_FN("getTTFConfig", js_cocos2dx_Label_getTTFConfig, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getVerticalAlignment", js_cocos2dx_Label_getVerticalAlignment, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setTextColor", js_cocos2dx_Label_setTextColor, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("getLetter", js_cocos2dx_Label_getLetter, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setHeight", js_cocos2dx_Label_setHeight, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getWidth", js_cocos2dx_Label_getWidth, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("enableGlow", js_cocos2dx_Label_enableGlow, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), - JS_FN("getLetter", js_cocos2dx_Label_getLetter, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("getOverflow", js_cocos2dx_Label_getOverflow, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setAdditionalKerning", js_cocos2dx_Label_setAdditionalKerning, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getSystemFontSize", js_cocos2dx_Label_getSystemFontSize, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setBlendFunc", js_cocos2dx_Label_setBlendFunc, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getTextAlignment", js_cocos2dx_Label_getTextAlignment, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getBMFontFilePath", js_cocos2dx_Label_getBMFontFilePath, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setHorizontalAlignment", js_cocos2dx_Label_setHorizontalAlignment, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("isWrapEnabled", js_cocos2dx_Label_isWrapEnabled, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setAlignment", js_cocos2dx_Label_setAlignment, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("requestSystemFontRefresh", js_cocos2dx_Label_requestSystemFontRefresh, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("setBMFontSize", js_cocos2dx_Label_setBMFontSize, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("ctor", js_cocos2dx_Label_ctor, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FS_END }; diff --git a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp index 5cb07c92a4..fc47a4ce20 100644 --- a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp +++ b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp @@ -2221,7 +2221,9 @@ bool js_cocos2dx_Label_getHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_disableEffect(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getTextColor(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getBlendFunc(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_enableWrap(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setWidth(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_getBMFontSize(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getMaxLineWidth(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getHorizontalAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setClipMarginEnabled(JSContext *cx, uint32_t argc, jsval *vp); @@ -2230,6 +2232,7 @@ bool js_cocos2dx_Label_setSystemFontName(JSContext *cx, uint32_t argc, jsval *vp bool js_cocos2dx_Label_setBMFontFilePath(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setLineHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setSystemFontSize(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_setOverflow(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getLineSpacing(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_updateContent(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getStringLength(JSContext *cx, uint32_t argc, jsval *vp); @@ -2248,18 +2251,21 @@ bool js_cocos2dx_Label_getLineHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getTTFConfig(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getVerticalAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setTextColor(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getWidth(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_enableGlow(JSContext *cx, uint32_t argc, jsval *vp); -bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_getOverflow(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setAdditionalKerning(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getSystemFontSize(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setBlendFunc(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getTextAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getBMFontFilePath(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setHorizontalAlignment(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_isWrapEnabled(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_requestSystemFontRefresh(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_setBMFontSize(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_createWithBMFont(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_create(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_createWithCharMap(JSContext *cx, uint32_t argc, jsval *vp); diff --git a/cocos/scripting/lua-bindings/auto/api/Label.lua b/cocos/scripting/lua-bindings/auto/api/Label.lua index 8d37a58725..2b2c13b211 100644 --- a/cocos/scripting/lua-bindings/auto/api/Label.lua +++ b/cocos/scripting/lua-bindings/auto/api/Label.lua @@ -65,6 +65,15 @@ -- @param self -- @return BlendFunc#BlendFunc ret (return value: cc.BlendFunc) +-------------------------------- +-- Toggle wrap option of the label.
+-- Note: System font doesn't support manually toggle wrap.
+-- param enable Set true to enable wrap and false to disable wrap. +-- @function [parent=#Label] enableWrap +-- @param self +-- @param #bool enable +-- @return Label#Label self (return value: cc.Label) + -------------------------------- -- Makes the Label exactly this untransformed width.
-- The Label's width be used for text align if the value not equal zero. @@ -73,6 +82,13 @@ -- @param #float width -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Return the user define BMFont size.
+-- return The BMFont size in float value. +-- @function [parent=#Label] getBMFontSize +-- @param self +-- @return float#float ret (return value: float) + -------------------------------- -- -- @function [parent=#Label] getMaxLineWidth @@ -114,6 +130,7 @@ -- @param self -- @param #string bmfontFilePath -- @param #vec2_table imageOffset +-- @param #float fontSize -- @return bool#bool ret (return value: bool) -------------------------------- @@ -138,6 +155,16 @@ -- @param #float fontSize -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type.
+-- Char Map font supports all the Overflow type except for SHRINK, because we can't measure it's font size.
+-- System font only support Overflow::Normal and Overflow::RESIZE_HEIGHT.
+-- param overflow see `Overflow` +-- @function [parent=#Label] setOverflow +-- @param self +-- @param #int overflow +-- @return Label#Label self (return value: cc.Label) + -------------------------------- -- -- @function [parent=#Label] getLineSpacing @@ -270,6 +297,14 @@ -- @param #color4b_table color -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Provides a way to treats each character like a Sprite.
+-- warning No support system font. +-- @function [parent=#Label] getLetter +-- @param self +-- @param #int lettetIndex +-- @return Sprite#Sprite ret (return value: cc.Sprite) + -------------------------------- -- Makes the Label exactly this untransformed height.
-- The Label's height be used for text align if the value not equal zero.
@@ -294,12 +329,11 @@ -- @return Label#Label self (return value: cc.Label) -------------------------------- --- Provides a way to treats each character like a Sprite.
--- warning No support system font. --- @function [parent=#Label] getLetter +-- Query the label's Overflow type.
+-- return see `Overflow` +-- @function [parent=#Label] getOverflow -- @param self --- @param #int lettetIndex --- @return Sprite#Sprite ret (return value: cc.Sprite) +-- @return int#int ret (return value: int) -------------------------------- -- Sets the additional kerning of the Label.
@@ -342,6 +376,13 @@ -- @param #int hAlignment -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Query the wrap is enabled or not.
+-- Note: System font will always return true. +-- @function [parent=#Label] isWrapEnabled +-- @param self +-- @return bool#bool ret (return value: bool) + -------------------------------- -- @overload self, int, int -- @overload self, int @@ -357,6 +398,15 @@ -- @param self -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Change font size of label type BMFONT
+-- Note: This function only scale the BMFONT letter to mimic the font size change effect.
+-- param fontSize The desired font size in float. +-- @function [parent=#Label] setBMFontSize +-- @param self +-- @param #float fontSize +-- @return Label#Label self (return value: cc.Label) + -------------------------------- -- Allocates and initializes a Label, with a bitmap font file.
-- param bmfontPath A bitmap font file, it's a FNT format.
diff --git a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp index 53bbc062c0..32e3b4a832 100644 --- a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp +++ b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp @@ -51038,6 +51038,56 @@ int lua_cocos2dx_Label_getBlendFunc(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_enableWrap(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_enableWrap'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + bool arg0; + + ok &= luaval_to_boolean(tolua_S, 2,&arg0, "cc.Label:enableWrap"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_enableWrap'", nullptr); + return 0; + } + cobj->enableWrap(arg0); + lua_settop(tolua_S, 1); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:enableWrap",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_enableWrap'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_setWidth(lua_State* tolua_S) { int argc = 0; @@ -51088,6 +51138,53 @@ int lua_cocos2dx_Label_setWidth(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_getBMFontSize(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getBMFontSize'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 0) + { + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getBMFontSize'", nullptr); + return 0; + } + double ret = cobj->getBMFontSize(); + tolua_pushnumber(tolua_S,(lua_Number)ret); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getBMFontSize",argc, 0); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getBMFontSize'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_getMaxLineWidth(lua_State* tolua_S) { int argc = 0; @@ -51389,6 +51486,26 @@ int lua_cocos2dx_Label_setBMFontFilePath(lua_State* tolua_S) tolua_pushboolean(tolua_S,(bool)ret); return 1; } + if (argc == 3) + { + std::string arg0; + cocos2d::Vec2 arg1; + double arg2; + + ok &= luaval_to_std_string(tolua_S, 2,&arg0, "cc.Label:setBMFontFilePath"); + + ok &= luaval_to_vec2(tolua_S, 3, &arg1, "cc.Label:setBMFontFilePath"); + + ok &= luaval_to_number(tolua_S, 4,&arg2, "cc.Label:setBMFontFilePath"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_setBMFontFilePath'", nullptr); + return 0; + } + bool ret = cobj->setBMFontFilePath(arg0, arg1, arg2); + tolua_pushboolean(tolua_S,(bool)ret); + return 1; + } luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:setBMFontFilePath",argc, 1); return 0; @@ -51546,6 +51663,56 @@ int lua_cocos2dx_Label_setSystemFontSize(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_setOverflow(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_setOverflow'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + cocos2d::Label::Overflow arg0; + + ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Label:setOverflow"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_setOverflow'", nullptr); + return 0; + } + cobj->setOverflow(arg0); + lua_settop(tolua_S, 1); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:setOverflow",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_setOverflow'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_getLineSpacing(lua_State* tolua_S) { int argc = 0; @@ -52474,6 +52641,56 @@ int lua_cocos2dx_Label_setTextColor(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_getLetter(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getLetter'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + int arg0; + + ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Label:getLetter"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getLetter'", nullptr); + return 0; + } + cocos2d::Sprite* ret = cobj->getLetter(arg0); + object_to_luaval(tolua_S, "cc.Sprite",(cocos2d::Sprite*)ret); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getLetter",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getLetter'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_setHeight(lua_State* tolua_S) { int argc = 0; @@ -52621,7 +52838,7 @@ int lua_cocos2dx_Label_enableGlow(lua_State* tolua_S) return 0; } -int lua_cocos2dx_Label_getLetter(lua_State* tolua_S) +int lua_cocos2dx_Label_getOverflow(lua_State* tolua_S) { int argc = 0; cocos2d::Label* cobj = nullptr; @@ -52641,32 +52858,29 @@ int lua_cocos2dx_Label_getLetter(lua_State* tolua_S) #if COCOS2D_DEBUG >= 1 if (!cobj) { - tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getLetter'", nullptr); + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getOverflow'", nullptr); return 0; } #endif argc = lua_gettop(tolua_S)-1; - if (argc == 1) + if (argc == 0) { - int arg0; - - ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Label:getLetter"); if(!ok) { - tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getLetter'", nullptr); + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getOverflow'", nullptr); return 0; } - cocos2d::Sprite* ret = cobj->getLetter(arg0); - object_to_luaval(tolua_S, "cc.Sprite",(cocos2d::Sprite*)ret); + int ret = (int)cobj->getOverflow(); + tolua_pushnumber(tolua_S,(lua_Number)ret); return 1; } - luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getLetter",argc, 1); + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getOverflow",argc, 0); return 0; #if COCOS2D_DEBUG >= 1 tolua_lerror: - tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getLetter'.",&tolua_err); + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getOverflow'.",&tolua_err); #endif return 0; @@ -52962,6 +53176,53 @@ int lua_cocos2dx_Label_setHorizontalAlignment(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_isWrapEnabled(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_isWrapEnabled'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 0) + { + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_isWrapEnabled'", nullptr); + return 0; + } + bool ret = cobj->isWrapEnabled(); + tolua_pushboolean(tolua_S,(bool)ret); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:isWrapEnabled",argc, 0); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_isWrapEnabled'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_setAlignment(lua_State* tolua_S) { int argc = 0; @@ -53068,6 +53329,56 @@ int lua_cocos2dx_Label_requestSystemFontRefresh(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_setBMFontSize(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_setBMFontSize'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + double arg0; + + ok &= luaval_to_number(tolua_S, 2,&arg0, "cc.Label:setBMFontSize"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_setBMFontSize'", nullptr); + return 0; + } + cobj->setBMFontSize(arg0); + lua_settop(tolua_S, 1); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:setBMFontSize",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_setBMFontSize'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_createWithBMFont(lua_State* tolua_S) { int argc = 0; @@ -53400,7 +53711,9 @@ int lua_register_cocos2dx_Label(lua_State* tolua_S) tolua_function(tolua_S,"setTTFConfig",lua_cocos2dx_Label_setTTFConfig); tolua_function(tolua_S,"getTextColor",lua_cocos2dx_Label_getTextColor); tolua_function(tolua_S,"getBlendFunc",lua_cocos2dx_Label_getBlendFunc); + tolua_function(tolua_S,"enableWrap",lua_cocos2dx_Label_enableWrap); tolua_function(tolua_S,"setWidth",lua_cocos2dx_Label_setWidth); + tolua_function(tolua_S,"getBMFontSize",lua_cocos2dx_Label_getBMFontSize); tolua_function(tolua_S,"getMaxLineWidth",lua_cocos2dx_Label_getMaxLineWidth); tolua_function(tolua_S,"getHorizontalAlignment",lua_cocos2dx_Label_getHorizontalAlignment); tolua_function(tolua_S,"setClipMarginEnabled",lua_cocos2dx_Label_setClipMarginEnabled); @@ -53410,6 +53723,7 @@ int lua_register_cocos2dx_Label(lua_State* tolua_S) tolua_function(tolua_S,"getFontAtlas",lua_cocos2dx_Label_getFontAtlas); tolua_function(tolua_S,"setLineHeight",lua_cocos2dx_Label_setLineHeight); tolua_function(tolua_S,"setSystemFontSize",lua_cocos2dx_Label_setSystemFontSize); + tolua_function(tolua_S,"setOverflow",lua_cocos2dx_Label_setOverflow); tolua_function(tolua_S,"getLineSpacing",lua_cocos2dx_Label_getLineSpacing); tolua_function(tolua_S,"updateContent",lua_cocos2dx_Label_updateContent); tolua_function(tolua_S,"getStringLength",lua_cocos2dx_Label_getStringLength); @@ -53428,18 +53742,21 @@ int lua_register_cocos2dx_Label(lua_State* tolua_S) tolua_function(tolua_S,"getTTFConfig",lua_cocos2dx_Label_getTTFConfig); tolua_function(tolua_S,"getVerticalAlignment",lua_cocos2dx_Label_getVerticalAlignment); tolua_function(tolua_S,"setTextColor",lua_cocos2dx_Label_setTextColor); + tolua_function(tolua_S,"getLetter",lua_cocos2dx_Label_getLetter); tolua_function(tolua_S,"setHeight",lua_cocos2dx_Label_setHeight); tolua_function(tolua_S,"getWidth",lua_cocos2dx_Label_getWidth); tolua_function(tolua_S,"enableGlow",lua_cocos2dx_Label_enableGlow); - tolua_function(tolua_S,"getLetter",lua_cocos2dx_Label_getLetter); + tolua_function(tolua_S,"getOverflow",lua_cocos2dx_Label_getOverflow); tolua_function(tolua_S,"setAdditionalKerning",lua_cocos2dx_Label_setAdditionalKerning); tolua_function(tolua_S,"getSystemFontSize",lua_cocos2dx_Label_getSystemFontSize); tolua_function(tolua_S,"setBlendFunc",lua_cocos2dx_Label_setBlendFunc); tolua_function(tolua_S,"getTextAlignment",lua_cocos2dx_Label_getTextAlignment); tolua_function(tolua_S,"getBMFontFilePath",lua_cocos2dx_Label_getBMFontFilePath); tolua_function(tolua_S,"setHorizontalAlignment",lua_cocos2dx_Label_setHorizontalAlignment); + tolua_function(tolua_S,"isWrapEnabled",lua_cocos2dx_Label_isWrapEnabled); tolua_function(tolua_S,"setAlignment",lua_cocos2dx_Label_setAlignment); tolua_function(tolua_S,"requestSystemFontRefresh",lua_cocos2dx_Label_requestSystemFontRefresh); + tolua_function(tolua_S,"setBMFontSize",lua_cocos2dx_Label_setBMFontSize); tolua_function(tolua_S,"createWithBMFont", lua_cocos2dx_Label_createWithBMFont); tolua_function(tolua_S,"create", lua_cocos2dx_Label_create); tolua_function(tolua_S,"createWithCharMap", lua_cocos2dx_Label_createWithCharMap); diff --git a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp index 9cc34867e0..74d55a4bac 100644 --- a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp +++ b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp @@ -2146,6 +2146,12 @@ int register_all_cocos2dx(lua_State* tolua_S); + + + + + + From 1d581264dffcf1f3c1e3a647e0b0dd1b8ca9b0ff Mon Sep 17 00:00:00 2001 From: CocosRobot Date: Fri, 27 Nov 2015 09:42:17 +0000 Subject: [PATCH 20/20] [ci skip][AUTO]: updating luabinding & jsbinding automatically --- .../auto/api/jsb_cocos2dx_auto_api.js | 76 +++- .../js-bindings/auto/jsb_cocos2dx_auto.cpp | 170 ++++++++- .../js-bindings/auto/jsb_cocos2dx_auto.hpp | 8 +- .../scripting/lua-bindings/auto/api/Label.lua | 60 ++- .../lua-bindings/auto/lua_cocos2dx_auto.cpp | 341 +++++++++++++++++- .../lua-bindings/auto/lua_cocos2dx_auto.hpp | 6 + 6 files changed, 618 insertions(+), 43 deletions(-) diff --git a/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js b/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js index 993733e0c6..6d0eca5575 100644 --- a/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js +++ b/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js @@ -11963,6 +11963,16 @@ getBlendFunc : function ( return cc.BlendFunc; }, +/** + * @method enableWrap + * @param {bool} arg0 + */ +enableWrap : function ( +bool +) +{ +}, + /** * @method setWidth * @param {float} arg0 @@ -11973,6 +11983,16 @@ float { }, +/** + * @method getBMFontSize + * @return {float} + */ +getBMFontSize : function ( +) +{ + return 0; +}, + /** * @method getMaxLineWidth * @return {float} @@ -12027,11 +12047,13 @@ str * @method setBMFontFilePath * @param {String} arg0 * @param {vec2_object} arg1 + * @param {float} arg2 * @return {bool} */ setBMFontFilePath : function ( str, -vec2 +vec2, +float ) { return false; @@ -12057,6 +12079,16 @@ float { }, +/** + * @method setOverflow + * @param {cc.Label::Overflow} arg0 + */ +setOverflow : function ( +overflow +) +{ +}, + /** * @method getLineSpacing * @return {float} @@ -12245,6 +12277,18 @@ color4b { }, +/** + * @method getLetter + * @param {int} arg0 + * @return {cc.Sprite} + */ +getLetter : function ( +int +) +{ + return cc.Sprite; +}, + /** * @method setHeight * @param {float} arg0 @@ -12276,15 +12320,13 @@ color4b }, /** - * @method getLetter - * @param {int} arg0 - * @return {cc.Sprite} + * @method getOverflow + * @return {cc.Label::Overflow} */ -getLetter : function ( -int +getOverflow : function ( ) { - return cc.Sprite; + return 0; }, /** @@ -12347,6 +12389,16 @@ texthalignment { }, +/** + * @method isWrapEnabled + * @return {bool} + */ +isWrapEnabled : function ( +) +{ + return false; +}, + /** * @method setAlignment * @param {cc.TextHAlignment|cc.TextHAlignment} texthalignment @@ -12367,6 +12419,16 @@ requestSystemFontRefresh : function ( { }, +/** + * @method setBMFontSize + * @param {float} arg0 + */ +setBMFontSize : function ( +float +) +{ +}, + /** * @method createWithBMFont * @param {String} arg0 diff --git a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp index 5b6c247352..226143358d 100644 --- a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp +++ b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp @@ -37622,6 +37622,26 @@ bool js_cocos2dx_Label_getBlendFunc(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_getBlendFunc : wrong number of arguments: %d, was expecting %d", argc, 0); return false; } +bool js_cocos2dx_Label_enableWrap(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_enableWrap : Invalid Native Object"); + if (argc == 1) { + bool arg0; + arg0 = JS::ToBoolean(args.get(0)); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_enableWrap : Error processing arguments"); + cobj->enableWrap(arg0); + args.rval().setUndefined(); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_enableWrap : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_setWidth(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -37642,6 +37662,24 @@ bool js_cocos2dx_Label_setWidth(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_setWidth : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_getBMFontSize(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getBMFontSize : Invalid Native Object"); + if (argc == 0) { + double ret = cobj->getBMFontSize(); + jsval jsret = JSVAL_NULL; + jsret = DOUBLE_TO_JSVAL(ret); + args.rval().set(jsret); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_getBMFontSize : wrong number of arguments: %d, was expecting %d", argc, 0); + return false; +} bool js_cocos2dx_Label_getMaxLineWidth(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -37768,6 +37806,20 @@ bool js_cocos2dx_Label_setBMFontFilePath(JSContext *cx, uint32_t argc, jsval *vp args.rval().set(jsret); return true; } + if (argc == 3) { + std::string arg0; + cocos2d::Vec2 arg1; + double arg2 = 0; + ok &= jsval_to_std_string(cx, args.get(0), &arg0); + ok &= jsval_to_vector2(cx, args.get(1), &arg1); + ok &= JS::ToNumber( cx, args.get(2), &arg2) && !isnan(arg2); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_setBMFontFilePath : Error processing arguments"); + bool ret = cobj->setBMFontFilePath(arg0, arg1, arg2); + jsval jsret = JSVAL_NULL; + jsret = BOOLEAN_TO_JSVAL(ret); + args.rval().set(jsret); + return true; + } JS_ReportError(cx, "js_cocos2dx_Label_setBMFontFilePath : wrong number of arguments: %d, was expecting %d", argc, 1); return false; @@ -37812,6 +37864,26 @@ bool js_cocos2dx_Label_setSystemFontSize(JSContext *cx, uint32_t argc, jsval *vp JS_ReportError(cx, "js_cocos2dx_Label_setSystemFontSize : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_setOverflow(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_setOverflow : Invalid Native Object"); + if (argc == 1) { + cocos2d::Label::Overflow arg0; + ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_setOverflow : Error processing arguments"); + cobj->setOverflow(arg0); + args.rval().setUndefined(); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_setOverflow : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_getLineSpacing(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -38219,6 +38291,35 @@ bool js_cocos2dx_Label_setTextColor(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_setTextColor : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getLetter : Invalid Native Object"); + if (argc == 1) { + int arg0 = 0; + ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_getLetter : Error processing arguments"); + cocos2d::Sprite* ret = cobj->getLetter(arg0); + jsval jsret = JSVAL_NULL; + do { + if (ret) { + js_proxy_t *jsProxy = js_get_or_create_proxy(cx, (cocos2d::Sprite*)ret); + jsret = OBJECT_TO_JSVAL(jsProxy->obj); + } else { + jsret = JSVAL_NULL; + } + } while (0); + args.rval().set(jsret); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_getLetter : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_setHeight(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -38277,33 +38378,22 @@ bool js_cocos2dx_Label_enableGlow(JSContext *cx, uint32_t argc, jsval *vp) JS_ReportError(cx, "js_cocos2dx_Label_enableGlow : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } -bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp) +bool js_cocos2dx_Label_getOverflow(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); - bool ok = true; JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); js_proxy_t *proxy = jsb_get_js_proxy(obj); cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); - JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getLetter : Invalid Native Object"); - if (argc == 1) { - int arg0 = 0; - ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); - JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_getLetter : Error processing arguments"); - cocos2d::Sprite* ret = cobj->getLetter(arg0); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_getOverflow : Invalid Native Object"); + if (argc == 0) { + int ret = (int)cobj->getOverflow(); jsval jsret = JSVAL_NULL; - do { - if (ret) { - js_proxy_t *jsProxy = js_get_or_create_proxy(cx, (cocos2d::Sprite*)ret); - jsret = OBJECT_TO_JSVAL(jsProxy->obj); - } else { - jsret = JSVAL_NULL; - } - } while (0); + jsret = int32_to_jsval(cx, ret); args.rval().set(jsret); return true; } - JS_ReportError(cx, "js_cocos2dx_Label_getLetter : wrong number of arguments: %d, was expecting %d", argc, 1); + JS_ReportError(cx, "js_cocos2dx_Label_getOverflow : wrong number of arguments: %d, was expecting %d", argc, 0); return false; } bool js_cocos2dx_Label_setAdditionalKerning(JSContext *cx, uint32_t argc, jsval *vp) @@ -38420,6 +38510,24 @@ bool js_cocos2dx_Label_setHorizontalAlignment(JSContext *cx, uint32_t argc, jsva JS_ReportError(cx, "js_cocos2dx_Label_setHorizontalAlignment : wrong number of arguments: %d, was expecting %d", argc, 1); return false; } +bool js_cocos2dx_Label_isWrapEnabled(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_isWrapEnabled : Invalid Native Object"); + if (argc == 0) { + bool ret = cobj->isWrapEnabled(); + jsval jsret = JSVAL_NULL; + jsret = BOOLEAN_TO_JSVAL(ret); + args.rval().set(jsret); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_isWrapEnabled : wrong number of arguments: %d, was expecting %d", argc, 0); + return false; +} bool js_cocos2dx_Label_setAlignment(JSContext *cx, uint32_t argc, jsval *vp) { bool ok = true; @@ -38475,6 +38583,26 @@ bool js_cocos2dx_Label_requestSystemFontRefresh(JSContext *cx, uint32_t argc, js JS_ReportError(cx, "js_cocos2dx_Label_requestSystemFontRefresh : wrong number of arguments: %d, was expecting %d", argc, 0); return false; } +bool js_cocos2dx_Label_setBMFontSize(JSContext *cx, uint32_t argc, jsval *vp) +{ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + bool ok = true; + JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); + js_proxy_t *proxy = jsb_get_js_proxy(obj); + cocos2d::Label* cobj = (cocos2d::Label *)(proxy ? proxy->ptr : NULL); + JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_Label_setBMFontSize : Invalid Native Object"); + if (argc == 1) { + double arg0 = 0; + ok &= JS::ToNumber( cx, args.get(0), &arg0) && !isnan(arg0); + JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_Label_setBMFontSize : Error processing arguments"); + cobj->setBMFontSize(arg0); + args.rval().setUndefined(); + return true; + } + + JS_ReportError(cx, "js_cocos2dx_Label_setBMFontSize : wrong number of arguments: %d, was expecting %d", argc, 1); + return false; +} bool js_cocos2dx_Label_createWithBMFont(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); @@ -38865,7 +38993,9 @@ void js_register_cocos2dx_Label(JSContext *cx, JS::HandleObject global) { JS_FN("disableEffect", js_cocos2dx_Label_disableEffect, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getTextColor", js_cocos2dx_Label_getTextColor, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getBlendFunc", js_cocos2dx_Label_getBlendFunc, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("enableWrap", js_cocos2dx_Label_enableWrap, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setWidth", js_cocos2dx_Label_setWidth, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("getBMFontSize", js_cocos2dx_Label_getBMFontSize, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getMaxLineWidth", js_cocos2dx_Label_getMaxLineWidth, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getHorizontalAlignment", js_cocos2dx_Label_getHorizontalAlignment, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setClipMarginEnabled", js_cocos2dx_Label_setClipMarginEnabled, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), @@ -38874,6 +39004,7 @@ void js_register_cocos2dx_Label(JSContext *cx, JS::HandleObject global) { JS_FN("setBMFontFilePath", js_cocos2dx_Label_setBMFontFilePath, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setLineHeight", js_cocos2dx_Label_setLineHeight, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setSystemFontSize", js_cocos2dx_Label_setSystemFontSize, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("setOverflow", js_cocos2dx_Label_setOverflow, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getLineSpacing", js_cocos2dx_Label_getLineSpacing, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("updateContent", js_cocos2dx_Label_updateContent, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getStringLength", js_cocos2dx_Label_getStringLength, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), @@ -38892,18 +39023,21 @@ void js_register_cocos2dx_Label(JSContext *cx, JS::HandleObject global) { JS_FN("getTTFConfig", js_cocos2dx_Label_getTTFConfig, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getVerticalAlignment", js_cocos2dx_Label_getVerticalAlignment, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setTextColor", js_cocos2dx_Label_setTextColor, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("getLetter", js_cocos2dx_Label_getLetter, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setHeight", js_cocos2dx_Label_setHeight, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getWidth", js_cocos2dx_Label_getWidth, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("enableGlow", js_cocos2dx_Label_enableGlow, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), - JS_FN("getLetter", js_cocos2dx_Label_getLetter, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("getOverflow", js_cocos2dx_Label_getOverflow, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setAdditionalKerning", js_cocos2dx_Label_setAdditionalKerning, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getSystemFontSize", js_cocos2dx_Label_getSystemFontSize, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setBlendFunc", js_cocos2dx_Label_setBlendFunc, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getTextAlignment", js_cocos2dx_Label_getTextAlignment, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("getBMFontFilePath", js_cocos2dx_Label_getBMFontFilePath, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setHorizontalAlignment", js_cocos2dx_Label_setHorizontalAlignment, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("isWrapEnabled", js_cocos2dx_Label_isWrapEnabled, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setAlignment", js_cocos2dx_Label_setAlignment, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("requestSystemFontRefresh", js_cocos2dx_Label_requestSystemFontRefresh, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), + JS_FN("setBMFontSize", js_cocos2dx_Label_setBMFontSize, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("ctor", js_cocos2dx_Label_ctor, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FS_END }; diff --git a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp index 5cb07c92a4..fc47a4ce20 100644 --- a/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp +++ b/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp @@ -2221,7 +2221,9 @@ bool js_cocos2dx_Label_getHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_disableEffect(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getTextColor(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getBlendFunc(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_enableWrap(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setWidth(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_getBMFontSize(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getMaxLineWidth(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getHorizontalAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setClipMarginEnabled(JSContext *cx, uint32_t argc, jsval *vp); @@ -2230,6 +2232,7 @@ bool js_cocos2dx_Label_setSystemFontName(JSContext *cx, uint32_t argc, jsval *vp bool js_cocos2dx_Label_setBMFontFilePath(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setLineHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setSystemFontSize(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_setOverflow(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getLineSpacing(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_updateContent(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getStringLength(JSContext *cx, uint32_t argc, jsval *vp); @@ -2248,18 +2251,21 @@ bool js_cocos2dx_Label_getLineHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getTTFConfig(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getVerticalAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setTextColor(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setHeight(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getWidth(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_enableGlow(JSContext *cx, uint32_t argc, jsval *vp); -bool js_cocos2dx_Label_getLetter(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_getOverflow(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setAdditionalKerning(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getSystemFontSize(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setBlendFunc(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getTextAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_getBMFontFilePath(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setHorizontalAlignment(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_isWrapEnabled(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_setAlignment(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_requestSystemFontRefresh(JSContext *cx, uint32_t argc, jsval *vp); +bool js_cocos2dx_Label_setBMFontSize(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_createWithBMFont(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_create(JSContext *cx, uint32_t argc, jsval *vp); bool js_cocos2dx_Label_createWithCharMap(JSContext *cx, uint32_t argc, jsval *vp); diff --git a/cocos/scripting/lua-bindings/auto/api/Label.lua b/cocos/scripting/lua-bindings/auto/api/Label.lua index 8d37a58725..2b2c13b211 100644 --- a/cocos/scripting/lua-bindings/auto/api/Label.lua +++ b/cocos/scripting/lua-bindings/auto/api/Label.lua @@ -65,6 +65,15 @@ -- @param self -- @return BlendFunc#BlendFunc ret (return value: cc.BlendFunc) +-------------------------------- +-- Toggle wrap option of the label.
+-- Note: System font doesn't support manually toggle wrap.
+-- param enable Set true to enable wrap and false to disable wrap. +-- @function [parent=#Label] enableWrap +-- @param self +-- @param #bool enable +-- @return Label#Label self (return value: cc.Label) + -------------------------------- -- Makes the Label exactly this untransformed width.
-- The Label's width be used for text align if the value not equal zero. @@ -73,6 +82,13 @@ -- @param #float width -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Return the user define BMFont size.
+-- return The BMFont size in float value. +-- @function [parent=#Label] getBMFontSize +-- @param self +-- @return float#float ret (return value: float) + -------------------------------- -- -- @function [parent=#Label] getMaxLineWidth @@ -114,6 +130,7 @@ -- @param self -- @param #string bmfontFilePath -- @param #vec2_table imageOffset +-- @param #float fontSize -- @return bool#bool ret (return value: bool) -------------------------------- @@ -138,6 +155,16 @@ -- @param #float fontSize -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Change the label's Overflow type, currently only TTF and BMFont support all the valid Overflow type.
+-- Char Map font supports all the Overflow type except for SHRINK, because we can't measure it's font size.
+-- System font only support Overflow::Normal and Overflow::RESIZE_HEIGHT.
+-- param overflow see `Overflow` +-- @function [parent=#Label] setOverflow +-- @param self +-- @param #int overflow +-- @return Label#Label self (return value: cc.Label) + -------------------------------- -- -- @function [parent=#Label] getLineSpacing @@ -270,6 +297,14 @@ -- @param #color4b_table color -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Provides a way to treats each character like a Sprite.
+-- warning No support system font. +-- @function [parent=#Label] getLetter +-- @param self +-- @param #int lettetIndex +-- @return Sprite#Sprite ret (return value: cc.Sprite) + -------------------------------- -- Makes the Label exactly this untransformed height.
-- The Label's height be used for text align if the value not equal zero.
@@ -294,12 +329,11 @@ -- @return Label#Label self (return value: cc.Label) -------------------------------- --- Provides a way to treats each character like a Sprite.
--- warning No support system font. --- @function [parent=#Label] getLetter +-- Query the label's Overflow type.
+-- return see `Overflow` +-- @function [parent=#Label] getOverflow -- @param self --- @param #int lettetIndex --- @return Sprite#Sprite ret (return value: cc.Sprite) +-- @return int#int ret (return value: int) -------------------------------- -- Sets the additional kerning of the Label.
@@ -342,6 +376,13 @@ -- @param #int hAlignment -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Query the wrap is enabled or not.
+-- Note: System font will always return true. +-- @function [parent=#Label] isWrapEnabled +-- @param self +-- @return bool#bool ret (return value: bool) + -------------------------------- -- @overload self, int, int -- @overload self, int @@ -357,6 +398,15 @@ -- @param self -- @return Label#Label self (return value: cc.Label) +-------------------------------- +-- Change font size of label type BMFONT
+-- Note: This function only scale the BMFONT letter to mimic the font size change effect.
+-- param fontSize The desired font size in float. +-- @function [parent=#Label] setBMFontSize +-- @param self +-- @param #float fontSize +-- @return Label#Label self (return value: cc.Label) + -------------------------------- -- Allocates and initializes a Label, with a bitmap font file.
-- param bmfontPath A bitmap font file, it's a FNT format.
diff --git a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp index 53bbc062c0..32e3b4a832 100644 --- a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp +++ b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp @@ -51038,6 +51038,56 @@ int lua_cocos2dx_Label_getBlendFunc(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_enableWrap(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_enableWrap'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + bool arg0; + + ok &= luaval_to_boolean(tolua_S, 2,&arg0, "cc.Label:enableWrap"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_enableWrap'", nullptr); + return 0; + } + cobj->enableWrap(arg0); + lua_settop(tolua_S, 1); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:enableWrap",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_enableWrap'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_setWidth(lua_State* tolua_S) { int argc = 0; @@ -51088,6 +51138,53 @@ int lua_cocos2dx_Label_setWidth(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_getBMFontSize(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getBMFontSize'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 0) + { + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getBMFontSize'", nullptr); + return 0; + } + double ret = cobj->getBMFontSize(); + tolua_pushnumber(tolua_S,(lua_Number)ret); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getBMFontSize",argc, 0); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getBMFontSize'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_getMaxLineWidth(lua_State* tolua_S) { int argc = 0; @@ -51389,6 +51486,26 @@ int lua_cocos2dx_Label_setBMFontFilePath(lua_State* tolua_S) tolua_pushboolean(tolua_S,(bool)ret); return 1; } + if (argc == 3) + { + std::string arg0; + cocos2d::Vec2 arg1; + double arg2; + + ok &= luaval_to_std_string(tolua_S, 2,&arg0, "cc.Label:setBMFontFilePath"); + + ok &= luaval_to_vec2(tolua_S, 3, &arg1, "cc.Label:setBMFontFilePath"); + + ok &= luaval_to_number(tolua_S, 4,&arg2, "cc.Label:setBMFontFilePath"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_setBMFontFilePath'", nullptr); + return 0; + } + bool ret = cobj->setBMFontFilePath(arg0, arg1, arg2); + tolua_pushboolean(tolua_S,(bool)ret); + return 1; + } luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:setBMFontFilePath",argc, 1); return 0; @@ -51546,6 +51663,56 @@ int lua_cocos2dx_Label_setSystemFontSize(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_setOverflow(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_setOverflow'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + cocos2d::Label::Overflow arg0; + + ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Label:setOverflow"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_setOverflow'", nullptr); + return 0; + } + cobj->setOverflow(arg0); + lua_settop(tolua_S, 1); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:setOverflow",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_setOverflow'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_getLineSpacing(lua_State* tolua_S) { int argc = 0; @@ -52474,6 +52641,56 @@ int lua_cocos2dx_Label_setTextColor(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_getLetter(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getLetter'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + int arg0; + + ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Label:getLetter"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getLetter'", nullptr); + return 0; + } + cocos2d::Sprite* ret = cobj->getLetter(arg0); + object_to_luaval(tolua_S, "cc.Sprite",(cocos2d::Sprite*)ret); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getLetter",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getLetter'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_setHeight(lua_State* tolua_S) { int argc = 0; @@ -52621,7 +52838,7 @@ int lua_cocos2dx_Label_enableGlow(lua_State* tolua_S) return 0; } -int lua_cocos2dx_Label_getLetter(lua_State* tolua_S) +int lua_cocos2dx_Label_getOverflow(lua_State* tolua_S) { int argc = 0; cocos2d::Label* cobj = nullptr; @@ -52641,32 +52858,29 @@ int lua_cocos2dx_Label_getLetter(lua_State* tolua_S) #if COCOS2D_DEBUG >= 1 if (!cobj) { - tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getLetter'", nullptr); + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_getOverflow'", nullptr); return 0; } #endif argc = lua_gettop(tolua_S)-1; - if (argc == 1) + if (argc == 0) { - int arg0; - - ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Label:getLetter"); if(!ok) { - tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getLetter'", nullptr); + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_getOverflow'", nullptr); return 0; } - cocos2d::Sprite* ret = cobj->getLetter(arg0); - object_to_luaval(tolua_S, "cc.Sprite",(cocos2d::Sprite*)ret); + int ret = (int)cobj->getOverflow(); + tolua_pushnumber(tolua_S,(lua_Number)ret); return 1; } - luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getLetter",argc, 1); + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:getOverflow",argc, 0); return 0; #if COCOS2D_DEBUG >= 1 tolua_lerror: - tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getLetter'.",&tolua_err); + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_getOverflow'.",&tolua_err); #endif return 0; @@ -52962,6 +53176,53 @@ int lua_cocos2dx_Label_setHorizontalAlignment(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_isWrapEnabled(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_isWrapEnabled'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 0) + { + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_isWrapEnabled'", nullptr); + return 0; + } + bool ret = cobj->isWrapEnabled(); + tolua_pushboolean(tolua_S,(bool)ret); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:isWrapEnabled",argc, 0); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_isWrapEnabled'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_setAlignment(lua_State* tolua_S) { int argc = 0; @@ -53068,6 +53329,56 @@ int lua_cocos2dx_Label_requestSystemFontRefresh(lua_State* tolua_S) return 0; } +int lua_cocos2dx_Label_setBMFontSize(lua_State* tolua_S) +{ + int argc = 0; + cocos2d::Label* cobj = nullptr; + bool ok = true; + +#if COCOS2D_DEBUG >= 1 + tolua_Error tolua_err; +#endif + + +#if COCOS2D_DEBUG >= 1 + if (!tolua_isusertype(tolua_S,1,"cc.Label",0,&tolua_err)) goto tolua_lerror; +#endif + + cobj = (cocos2d::Label*)tolua_tousertype(tolua_S,1,0); + +#if COCOS2D_DEBUG >= 1 + if (!cobj) + { + tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Label_setBMFontSize'", nullptr); + return 0; + } +#endif + + argc = lua_gettop(tolua_S)-1; + if (argc == 1) + { + double arg0; + + ok &= luaval_to_number(tolua_S, 2,&arg0, "cc.Label:setBMFontSize"); + if(!ok) + { + tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Label_setBMFontSize'", nullptr); + return 0; + } + cobj->setBMFontSize(arg0); + lua_settop(tolua_S, 1); + return 1; + } + luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Label:setBMFontSize",argc, 1); + return 0; + +#if COCOS2D_DEBUG >= 1 + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Label_setBMFontSize'.",&tolua_err); +#endif + + return 0; +} int lua_cocos2dx_Label_createWithBMFont(lua_State* tolua_S) { int argc = 0; @@ -53400,7 +53711,9 @@ int lua_register_cocos2dx_Label(lua_State* tolua_S) tolua_function(tolua_S,"setTTFConfig",lua_cocos2dx_Label_setTTFConfig); tolua_function(tolua_S,"getTextColor",lua_cocos2dx_Label_getTextColor); tolua_function(tolua_S,"getBlendFunc",lua_cocos2dx_Label_getBlendFunc); + tolua_function(tolua_S,"enableWrap",lua_cocos2dx_Label_enableWrap); tolua_function(tolua_S,"setWidth",lua_cocos2dx_Label_setWidth); + tolua_function(tolua_S,"getBMFontSize",lua_cocos2dx_Label_getBMFontSize); tolua_function(tolua_S,"getMaxLineWidth",lua_cocos2dx_Label_getMaxLineWidth); tolua_function(tolua_S,"getHorizontalAlignment",lua_cocos2dx_Label_getHorizontalAlignment); tolua_function(tolua_S,"setClipMarginEnabled",lua_cocos2dx_Label_setClipMarginEnabled); @@ -53410,6 +53723,7 @@ int lua_register_cocos2dx_Label(lua_State* tolua_S) tolua_function(tolua_S,"getFontAtlas",lua_cocos2dx_Label_getFontAtlas); tolua_function(tolua_S,"setLineHeight",lua_cocos2dx_Label_setLineHeight); tolua_function(tolua_S,"setSystemFontSize",lua_cocos2dx_Label_setSystemFontSize); + tolua_function(tolua_S,"setOverflow",lua_cocos2dx_Label_setOverflow); tolua_function(tolua_S,"getLineSpacing",lua_cocos2dx_Label_getLineSpacing); tolua_function(tolua_S,"updateContent",lua_cocos2dx_Label_updateContent); tolua_function(tolua_S,"getStringLength",lua_cocos2dx_Label_getStringLength); @@ -53428,18 +53742,21 @@ int lua_register_cocos2dx_Label(lua_State* tolua_S) tolua_function(tolua_S,"getTTFConfig",lua_cocos2dx_Label_getTTFConfig); tolua_function(tolua_S,"getVerticalAlignment",lua_cocos2dx_Label_getVerticalAlignment); tolua_function(tolua_S,"setTextColor",lua_cocos2dx_Label_setTextColor); + tolua_function(tolua_S,"getLetter",lua_cocos2dx_Label_getLetter); tolua_function(tolua_S,"setHeight",lua_cocos2dx_Label_setHeight); tolua_function(tolua_S,"getWidth",lua_cocos2dx_Label_getWidth); tolua_function(tolua_S,"enableGlow",lua_cocos2dx_Label_enableGlow); - tolua_function(tolua_S,"getLetter",lua_cocos2dx_Label_getLetter); + tolua_function(tolua_S,"getOverflow",lua_cocos2dx_Label_getOverflow); tolua_function(tolua_S,"setAdditionalKerning",lua_cocos2dx_Label_setAdditionalKerning); tolua_function(tolua_S,"getSystemFontSize",lua_cocos2dx_Label_getSystemFontSize); tolua_function(tolua_S,"setBlendFunc",lua_cocos2dx_Label_setBlendFunc); tolua_function(tolua_S,"getTextAlignment",lua_cocos2dx_Label_getTextAlignment); tolua_function(tolua_S,"getBMFontFilePath",lua_cocos2dx_Label_getBMFontFilePath); tolua_function(tolua_S,"setHorizontalAlignment",lua_cocos2dx_Label_setHorizontalAlignment); + tolua_function(tolua_S,"isWrapEnabled",lua_cocos2dx_Label_isWrapEnabled); tolua_function(tolua_S,"setAlignment",lua_cocos2dx_Label_setAlignment); tolua_function(tolua_S,"requestSystemFontRefresh",lua_cocos2dx_Label_requestSystemFontRefresh); + tolua_function(tolua_S,"setBMFontSize",lua_cocos2dx_Label_setBMFontSize); tolua_function(tolua_S,"createWithBMFont", lua_cocos2dx_Label_createWithBMFont); tolua_function(tolua_S,"create", lua_cocos2dx_Label_create); tolua_function(tolua_S,"createWithCharMap", lua_cocos2dx_Label_createWithCharMap); diff --git a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp index 9cc34867e0..74d55a4bac 100644 --- a/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp +++ b/cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.hpp @@ -2146,6 +2146,12 @@ int register_all_cocos2dx(lua_State* tolua_S); + + + + + +