void RichText::handleTextRenderer(const char *text, const char *fontName, float fontSize, const Color3B &color, GLubyte opacity)
{
Label* textRenderer = Label::create(text, fontName, fontSize);
float textRendererWidth = textRenderer->getContentSize().width;
_leftSpaceWidth -= textRendererWidth;
if (_leftSpaceWidth < 0.0f)
{
float overstepPercent = (-_leftSpaceWidth) / textRendererWidth;
std::string curText = text;
size_t stringLength = _calcCharCount(text);
int leftLength = stringLength * (1.0f - overstepPercent);
std::string leftWords = curText.substr(0, leftLength);
std::string cutWords = curText.substr(leftLength, curText.length()-1);
if (leftLength > 0)
{
Label* leftRenderer = Label::create(leftWords.substr(0, leftLength).c_str(), fontName, fontSize);
leftRenderer->setColor(color);
leftRenderer->setOpacity(opacity);
pushToContainer(leftRenderer);
}
addNewLine();
handleTextRenderer(cutWords.c_str(), fontName, fontSize, color, opacity);
}
else
{
textRenderer->setColor(color);
textRenderer->setOpacity(opacity);
pushToContainer(textRenderer);
}
}
void Textbox::addText( std::string newText, glm::vec3 color, GLboolean newLine ) {
if ( newText.size() == 0 )
return;
appendText( newText, color );
if ( newLine ) {
addNewLine();
}
}
void RichText::handleTextRenderer(const std::string& text, const std::string& fontName, float fontSize, const Color3B &color, GLubyte opacity)
{
auto fileExist = FileUtils::getInstance()->isFileExist(fontName);
Label* textRenderer = nullptr;
if (fileExist)
{
textRenderer = Label::createWithTTF(text, fontName, fontSize);
}
else
{
textRenderer = Label::createWithSystemFont(text, fontName, fontSize);
}
float textRendererWidth = textRenderer->getContentSize().width;
_leftSpaceWidth -= textRendererWidth;
if (_leftSpaceWidth < 0.0f)
{
float overstepPercent = (-_leftSpaceWidth) / textRendererWidth;
std::string curText = text;
size_t stringLength = StringUtils::getCharacterCountInUTF8String(text);
int leftLength = stringLength * (1.0f - overstepPercent);
//The minimum cut length is 1, otherwise will cause the infinite loop.
if (0 == leftLength) leftLength = 1;
std::string leftWords = Helper::getSubStringOfUTF8String(curText,0,leftLength);
std::string cutWords = Helper::getSubStringOfUTF8String(curText, leftLength, stringLength - leftLength);
if (leftLength > 0)
{
Label* leftRenderer = nullptr;
if (fileExist)
{
leftRenderer = Label::createWithTTF(Helper::getSubStringOfUTF8String(leftWords, 0, leftLength), fontName, fontSize);
}
else
{
leftRenderer = Label::createWithSystemFont(Helper::getSubStringOfUTF8String(leftWords, 0, leftLength), fontName, fontSize);
}
if (leftRenderer)
{
leftRenderer->setColor(color);
leftRenderer->setOpacity(opacity);
pushToContainer(leftRenderer);
}
}
addNewLine();
handleTextRenderer(cutWords.c_str(), fontName, fontSize, color, opacity);
}
else
{
textRenderer->setColor(color);
textRenderer->setOpacity(opacity);
pushToContainer(textRenderer);
}
}
void Textbox::appendText( std::string newText, glm::vec3 color ) {
// get edges
GLuint leftEdge = pos.x + paddingHorizontal + borderSize;
GLuint rightEdge = pos.x + size.x - paddingHorizontal - borderSize - btnSize.x;
// loop through each token of text
std::string delimiter = " ";
GLfloat delimOffset = getStringWidth( " " );
std::string token;
GLuint start = 0;
GLuint end = newText.find( delimiter );
while ( end != std::string::npos ) {
// get the next token
token = newText.substr( start, end - start );
// calculate the width of the token
GLfloat width = getStringWidth( token );
// check to see if token fits on the same line
if ( leftEdge + currHorizontalOffset + width > rightEdge ) {
addNewLine();
}
tokens.push_back( StringToken( token, currHorizontalOffset, currentLineNumber, color ) );
// move horizontal offset
currHorizontalOffset += width + delimOffset;
start = end + delimiter.length();
end = newText.find( delimiter, start );
}
token = newText.substr( start, newText.size() );
GLfloat width = getStringWidth( token );
if ( leftEdge + currHorizontalOffset + width > rightEdge ) {
addNewLine();
}
tokens.push_back( StringToken( token, currHorizontalOffset, currentLineNumber, color ) );
currHorizontalOffset += width + delimOffset;
}
void RichText::handleTextRenderer(const std::string& text, const std::string& fontName, float fontSize, const Color3B &color, GLubyte opacity)
{
auto fileExist = FileUtils::getInstance()->isFileExist(fontName);
Label* textRenderer = nullptr;
if (fileExist)
{
textRenderer = Label::createWithTTF(text, fontName, fontSize);
}
else
{
textRenderer = Label::createWithSystemFont(text, fontName, fontSize);
}
float textRendererWidth = textRenderer->getContentSize().width;
_leftSpaceWidth -= textRendererWidth;
if (_leftSpaceWidth < 0.0f)
{
float overstepPercent = (-_leftSpaceWidth) / textRendererWidth;
std::string curText = text;
size_t stringLength = _calcCharCount(text.c_str());
int leftLength = stringLength * (1.0f - overstepPercent);
std::string leftWords = curText.substr(0, leftLength);
std::string cutWords = curText.substr(leftLength, curText.length()-1);
if (leftLength > 0)
{
Label* leftRenderer = nullptr;
if (fileExist)
{
leftRenderer = Label::createWithTTF(leftWords.substr(0, leftLength).c_str(), fontName, fontSize);
}
else
{
leftRenderer = Label::createWithSystemFont(leftWords.substr(0, leftLength).c_str(), fontName, fontSize);
}
if (leftRenderer)
{
leftRenderer->setColor(color);
leftRenderer->setOpacity(opacity);
pushToContainer(leftRenderer);
}
}
addNewLine();
handleTextRenderer(cutWords.c_str(), fontName, fontSize, color, opacity);
}
else
{
textRenderer->setColor(color);
textRenderer->setOpacity(opacity);
pushToContainer(textRenderer);
}
}
//--------------------------------------------------------------
void ofApp::draw(){
if(useMinimalGUI)
{
newLineString.clear();
addNewLine("Light Life = " + ofToString(magicCircle.lightLife) + " frame");
addNewLine("Light Fade Out Speed = " + ofToString(magicCircle.lightFadeOutSpeed));
addNewLine("Perc Max Distance Circle = " + ofToString(magicCircle.percMaxDistanceCircle));
ofPushStyle();
ofSetColor(17,139,145);
ofRect(0, 0, ofGetWindowWidth(), ofGetWindowHeight());
ofSetColor(120,14,81);
for(int a = 0; a < newLineString.size(); a++)
{
font.drawString(newLineString[a], 20, 20*(a+1));
}
ofPopStyle();
}
else
{
magicCircle.draw();
gui.draw();
}
}
void RichText::handleCustomRenderer(cocos2d::Node *renderer)
{
Size imgSize = renderer->getContentSize();
_leftSpaceWidth -= imgSize.width;
if (_leftSpaceWidth < 0.0f)
{
addNewLine();
pushToContainer(renderer);
_leftSpaceWidth -= imgSize.width;
}
else
{
pushToContainer(renderer);
}
}
void RTContent::handleCustomRenderer(cocos2d::Node *renderer)
{
Size imgSize = renderer->getBoundingBox().size;
_leftSpaceWidth -= imgSize.width;
if (_leftSpaceWidth < 0.0f)
{
addNewLine();
pushToContainer(renderer);
_leftSpaceWidth -= imgSize.width;
}
else
{
pushToContainer(renderer);
}
}
TileSelection::TileSelection( QWidget * parent, const char * name )
:ItemSelection( parent, name )
{
TilePresentation * pres;
_tiles = new QList<TilePresentation *>;
_sizeG = new QButtonGroup( this );
_sizeG->setExclusive( true );
for( int i = 1; i < 4; i++ ) {
QPushButton * pb = new QPushButton( QString("x%1").arg(i), this );
pb->setCheckable( true );
pb->setFixedWidth( 50 );
_sizeG->addButton( pb, i );
addNewWidget( pb );
}
_eff = new QButtonGroup( this );
_eff->setExclusive( true );
QPushButton * pb = new QPushButton( QString("Auto-transition"), this );
pb->setCheckable( true );
pb->setFixedSize( QSize( 40, 40 ).expandedTo( pb->sizeHint() ) );
_eff->addButton( pb,1 );
addNewWidget( pb );
addNewLine();
//_sizeG->setId(1);
for( int i = 1; i < DataTheme.tiles.count(); i++ ) {
//addButton( ImageTheme.cells[i]->image( 0 ), i, i == 0 );
pres = new TilePresentation( this );
pres->setCell( DataTheme.tiles.at(i) );
pres->getButton()->setCheckable( true );
_bg->addButton( pres->getButton(), i );
pres->getButton()->setFixedSize( QSize(40,40).expandedTo(pres->getButton()->sizeHint() ) );
addNewWidget( pres );
_tiles->append( pres );
}
}
void RichText::formatText()
{
if (_formatTextDirty)
{
_elementRenderersContainer->removeAllChildren();
_elementRenders.clear();
if (_ignoreSize)
{
addNewLine();
for (ssize_t i=0; i<_richElements.size(); i++)
{
RichElement* element = _richElements.at(i);
Node* elementRenderer = nullptr;
switch (element->_type)
{
case RichElement::Type::TEXT:
{
RichElementText* elmtText = static_cast<RichElementText*>(element);
if (FileUtils::getInstance()->isFileExist(elmtText->_fontName))
{
elementRenderer = Label::createWithTTF(elmtText->_text.c_str(), elmtText->_fontName, elmtText->_fontSize);
}
else
{
elementRenderer = Label::createWithSystemFont(elmtText->_text.c_str(), elmtText->_fontName, elmtText->_fontSize);
}
break;
}
case RichElement::Type::IMAGE:
{
RichElementImage* elmtImage = static_cast<RichElementImage*>(element);
elementRenderer = Sprite::create(elmtImage->_filePath.c_str());
break;
}
case RichElement::Type::CUSTOM:
{
RichElementCustomNode* elmtCustom = static_cast<RichElementCustomNode*>(element);
elementRenderer = elmtCustom->_customNode;
break;
}
default:
break;
}
elementRenderer->setColor(element->_color);
elementRenderer->setOpacity(element->_opacity);
pushToContainer(elementRenderer);
}
}
else
{
addNewLine();
for (ssize_t i=0; i<_richElements.size(); i++)
{
RichElement* element = static_cast<RichElement*>(_richElements.at(i));
switch (element->_type)
{
case RichElement::Type::TEXT:
{
RichElementText* elmtText = static_cast<RichElementText*>(element);
handleTextRenderer(elmtText->_text.c_str(), elmtText->_fontName.c_str(), elmtText->_fontSize, elmtText->_color, elmtText->_opacity);
break;
}
case RichElement::Type::IMAGE:
{
RichElementImage* elmtImage = static_cast<RichElementImage*>(element);
handleImageRenderer(elmtImage->_filePath.c_str(), elmtImage->_color, elmtImage->_opacity);
break;
}
case RichElement::Type::CUSTOM:
{
RichElementCustomNode* elmtCustom = static_cast<RichElementCustomNode*>(element);
handleCustomRenderer(elmtCustom->_customNode);
break;
}
default:
break;
}
}
}
formarRenderers();
_formatTextDirty = false;
}
}
void RTContent::handleTextRenderer(const std::string& text, const std::string& fontName, float fontSize, const Color3B &color, GLubyte opacity)
{
auto fileExist = FileUtils::getInstance()->isFileExist(fontName);
Label* textRenderer = nullptr;
if (fileExist)
{
textRenderer = Label::createWithTTF(text, fontName, fontSize);
}
else
{
textRenderer = Label::createWithSystemFont(text, fontName, fontSize);
}
float textRendererWidth = textRenderer->getContentSize().width;
float tmpLeftSpaceWidth = _leftSpaceWidth;
tmpLeftSpaceWidth -= textRendererWidth;
if (tmpLeftSpaceWidth < 0.0f)
{
//percent cut words
float overstepPercent = (-tmpLeftSpaceWidth) / textRendererWidth;
std::string curText = text;
size_t stringLength = StringUtils::getCharacterCountInUTF8String(text);
int leftLength = stringLength * (1.0f - overstepPercent);
std::string leftWords = Helper::getSubStringOfUTF8String(curText, 0, leftLength);
std::string cutWords = Helper::getSubStringOfUTF8String(curText, leftLength, stringLength - leftLength);
Label* leftRenderer = nullptr;
if (leftWords.length() > 0) {
if (fileExist)
{
leftRenderer = Label::createWithTTF(leftWords, fontName, fontSize);
}
else
{
leftRenderer = Label::createWithSystemFont(leftWords, fontName, fontSize);
}
}
if (!leftRenderer) {
return;
}
// 处理需截文本字宽度不均，前半部分超出的情况 例如 "测试文本测试文本12341234"，取宽度10/16 前半部分宽度10则超出很多
while (true) {
if (leftWords.length() > 0)
{
leftRenderer->setString(leftWords);
float leftRendererWidth = leftRenderer->getContentSize().width;
tmpLeftSpaceWidth = _leftSpaceWidth;
tmpLeftSpaceWidth -= leftRendererWidth;
if (tmpLeftSpaceWidth < 0.0f) {
int leftWordsLen = (int)leftWords.length();
if (leftWordsLen <= 0) {
break;
}
else {
//cut char one by one to get the fit length
while (true) {
leftLength -= 1;
leftWords = Helper::getSubStringOfUTF8String(curText, 0, leftLength);
cutWords = Helper::getSubStringOfUTF8String(curText, leftLength, stringLength - leftLength);
if (leftWords.length() == 0) {
break;
}
if (leftWords.length() < leftWordsLen) {
break;
}
}
}
}
else {
//if _leftSpaceWidth > 0 break
break;
}
}
else {
//if leftWords is empty, break
break;
}
}
// 处理需截文本字宽度不均，后半部分超出的情况 例如 "12341234测试文本测试文本"，取宽度10/16 前半部分宽度10则缺少很多
std::string lastLeftWords = leftWords;
std::string lastCutWords = cutWords;
float lastTmpLeftSpaceWidth = tmpLeftSpaceWidth;
while (true) {
if (cutWords.length() > 0)
{
int leftWordsLen = (int)leftWords.length();
while (true) {
leftLength += 1;
leftWords = Helper::getSubStringOfUTF8String(curText, 0, leftLength);
cutWords = Helper::getSubStringOfUTF8String(curText, leftLength, stringLength - leftLength);
if (cutWords.length() == 0) {
break;
}
if (leftWords.length() > leftWordsLen) {
break;
}
}
leftRenderer->setString(leftWords);
float leftRendererWidth = leftRenderer->getContentSize().width;
tmpLeftSpaceWidth = _leftSpaceWidth;
tmpLeftSpaceWidth -= leftRendererWidth;
if (tmpLeftSpaceWidth < 0.0f) {
leftWords = lastLeftWords;
cutWords = lastCutWords;
tmpLeftSpaceWidth = lastTmpLeftSpaceWidth;
leftRenderer->setString(leftWords);
break;
}
else {
lastLeftWords = leftWords;
lastCutWords = cutWords;
lastTmpLeftSpaceWidth = tmpLeftSpaceWidth;
}
}
else {
//if cutWords is empty, break
leftWords = lastLeftWords;
cutWords = lastCutWords;
tmpLeftSpaceWidth = lastTmpLeftSpaceWidth;
leftRenderer->setString(leftWords);
break;
}
}
_leftSpaceWidth = tmpLeftSpaceWidth;
leftRenderer->setColor(color);
leftRenderer->setOpacity(opacity);
pushToContainer(leftRenderer);
_leftSpaceWidth = tmpLeftSpaceWidth;
addNewLine();
handleTextRenderer(cutWords.c_str(), fontName, fontSize, color, opacity);
}
else
{
_leftSpaceWidth = tmpLeftSpaceWidth;
textRenderer->setColor(color);
textRenderer->setOpacity(opacity);
pushToContainer(textRenderer);
}
}
void addBlankLine() {
addNewLine();
addNewLine();
}
void RichText::formatText()
{
if (_formatTextDirty)
{
_elementRenderersContainer->removeAllChildren();
_elementRenders.clear();
if (_ignoreSize)
{
addNewLine();
for (unsigned int i=0; i<_richElements->count(); i++)
{
RichElement* element = static_cast<RichElement*>(_richElements->objectAtIndex(i));
CCNode* elementRenderer = NULL;
switch (element->_type)
{
case RICH_TEXT:
{
RichElementText* elmtText = static_cast<RichElementText*>(element);
elementRenderer = CCLabelTTF::create(elmtText->_text.c_str(), elmtText->_fontName.c_str(), elmtText->_fontSize);
break;
}
case RICH_IMAGE:
{
RichElementImage* elmtImage = static_cast<RichElementImage*>(element);
elementRenderer = CCSprite::create(elmtImage->_filePath.c_str());
break;
}
case RICH_CUSTOM:
{
RichElementCustomNode* elmtCustom = static_cast<RichElementCustomNode*>(element);
elementRenderer = elmtCustom->_customNode;
break;
}
default:
break;
}
CCRGBAProtocol* colorRenderer = dynamic_cast<CCRGBAProtocol*>(elementRenderer);
colorRenderer->setColor(element->_color);
colorRenderer->setOpacity(element->_opacity);
pushToContainer(elementRenderer);
}
}
else
{
addNewLine();
for (unsigned int i=0; i<_richElements->count(); i++)
{
RichElement* element = static_cast<RichElement*>(_richElements->objectAtIndex(i));
switch (element->_type)
{
case RICH_TEXT:
{
RichElementText* elmtText = static_cast<RichElementText*>(element);
handleTextRenderer(elmtText->_text.c_str(), elmtText->_fontName.c_str(), elmtText->_fontSize, elmtText->_color, elmtText->_opacity);
break;
}
case RICH_IMAGE:
{
RichElementImage* elmtImage = static_cast<RichElementImage*>(element);
handleImageRenderer(elmtImage->_filePath.c_str(), elmtImage->_color, elmtImage->_opacity);
break;
}
case RICH_CUSTOM:
{
RichElementCustomNode* elmtCustom = static_cast<RichElementCustomNode*>(element);
handleCustomRenderer(elmtCustom->_customNode);
break;
}
default:
break;
}
}
}
formarRenderers();
_formatTextDirty = false;
}
}
