axmol/extensions/cocostudio/WidgetReader/TextReader/TextReader.cpp

576 lines
20 KiB
C++
Raw Normal View History

2014-03-04 16:51:35 +08:00
#include "cocostudio/WidgetReader/TextReader/TextReader.h"
2014-11-21 15:15:38 +08:00
2014-03-11 17:13:54 +08:00
#include "ui/UIText.h"
2019-11-24 23:15:56 +08:00
#include "2d/CCLabel.h"
2016-04-18 15:09:21 +08:00
#include "platform/CCFileUtils.h"
#include "cocostudio/CocoLoader.h"
#include "cocostudio/CSParseBinary_generated.h"
#include "cocostudio/LocalizationManager.h"
2014-11-21 15:15:38 +08:00
#include "flatbuffers/flatbuffers.h"
2014-03-04 16:51:35 +08:00
2014-03-06 16:15:03 +08:00
USING_NS_CC;
using namespace ui;
2014-11-21 15:15:38 +08:00
using namespace flatbuffers;
2014-03-06 16:15:03 +08:00
2014-03-04 16:51:35 +08:00
namespace cocostudio
{
static const char* P_TouchScaleEnable = "touchScaleEnable";
static const char* P_Text = "text";
static const char* P_FontSize = "fontSize";
static const char* P_FontName = "fontName";
static const char* P_AreaWidth = "areaWidth";
static const char* P_AreaHeight = "areaHeight";
static const char* P_HAlignment = "hAlignment";
static const char* P_VAlignment = "vAlignment";
static TextReader* instanceTextReader = nullptr;
2014-03-04 16:51:35 +08:00
2014-11-21 15:15:38 +08:00
IMPLEMENT_CLASS_NODE_READER_INFO(TextReader)
2014-03-04 16:51:35 +08:00
TextReader::TextReader()
{
}
TextReader::~TextReader()
{
}
TextReader* TextReader::getInstance()
{
if (!instanceTextReader)
{
instanceTextReader = new (std::nothrow) TextReader();
2014-03-04 16:51:35 +08:00
}
return instanceTextReader;
}
2015-03-30 16:46:33 +08:00
void TextReader::destroyInstance()
{
CC_SAFE_DELETE(instanceTextReader);
}
2014-06-23 10:02:09 +08:00
void TextReader::setPropsFromBinary(cocos2d::ui::Widget *widget, CocoLoader *cocoLoader, stExpCocoNode *cocoNode)
{
2014-06-11 09:35:24 +08:00
this->beginSetBasicProperties(widget);
2014-07-01 16:31:17 +08:00
stExpCocoNode *stChildArray = cocoNode->GetChildArray(cocoLoader);
Text* label = static_cast<Text*>(widget);
2014-07-02 10:08:04 +08:00
2014-07-07 15:22:14 +08:00
std::string binaryFilePath = GUIReader::getInstance()->getFilePath();
2014-07-02 10:08:04 +08:00
2014-06-23 10:02:09 +08:00
for (int i = 0; i < cocoNode->GetChildNum(); ++i) {
std::string key = stChildArray[i].GetName(cocoLoader);
2014-07-01 16:31:17 +08:00
std::string value = stChildArray[i].GetValue(cocoLoader);
2014-06-19 15:16:56 +08:00
//read all basic properties of widget
CC_BASIC_PROPERTY_BINARY_READER
//read all color related properties of widget
CC_COLOR_PROPERTY_BINARY_READER
else if (key == P_TouchScaleEnable) {
label->setTouchScaleChangeEnabled(valueToBool(value));
}
else if(key == P_Text){
label->setString(value);
}else if(key == P_FontSize){
label->setFontSize(valueToInt(value));
}else if(key == P_FontName){
2020-08-04 10:55:30 +08:00
auto& fontFilePath = binaryFilePath.append(value);
label->setFontName(fontFilePath);
}else if(key == P_AreaWidth){
label->setTextAreaSize(Size(valueToFloat(value), label->getTextAreaSize().height));
}else if(key == P_AreaHeight){
label->setTextAreaSize(Size(label->getTextAreaSize().width, valueToFloat(value)));
}else if(key == P_HAlignment){
label->setTextHorizontalAlignment((TextHAlignment)valueToInt(value));
}else if(key == P_VAlignment){
label->setTextVerticalAlignment((TextVAlignment)valueToInt(value));
}
} //end of for loop
2014-06-11 09:35:24 +08:00
this->endSetBasicProperties(widget);
}
2014-03-04 16:51:35 +08:00
void TextReader::setPropsFromJsonDictionary(Widget *widget, const rapidjson::Value &options)
{
WidgetReader::setPropsFromJsonDictionary(widget, options);
std::string jsonPath = GUIReader::getInstance()->getFilePath();
Text* label = static_cast<Text*>(widget);
bool touchScaleChangeAble = DICTOOL->getBooleanValue_json(options, P_TouchScaleEnable);
2014-03-04 16:51:35 +08:00
label->setTouchScaleChangeEnabled(touchScaleChangeAble);
2014-07-01 10:57:12 +08:00
const char* text = DICTOOL->getStringValue_json(options, P_Text,"Text Label");
2014-05-14 15:26:14 +08:00
label->setString(text);
2014-07-01 10:57:12 +08:00
label->setFontSize(DICTOOL->getIntValue_json(options, P_FontSize,20));
std::string fontName = DICTOOL->getStringValue_json(options, P_FontName, "");
2014-07-01 10:57:12 +08:00
std::string fontFilePath = jsonPath.append(fontName);
2014-07-09 16:38:26 +08:00
if (FileUtils::getInstance()->isFileExist(fontFilePath))
{
label->setFontName(fontFilePath);
}
else{
label->setFontName(fontName);
}
2014-07-01 10:57:12 +08:00
bool aw = DICTOOL->checkObjectExist_json(options, P_AreaWidth);
bool ah = DICTOOL->checkObjectExist_json(options, P_AreaHeight);
2014-03-04 16:51:35 +08:00
if (aw && ah)
{
Size size = Size(DICTOOL->getFloatValue_json(options, P_AreaWidth),DICTOOL->getFloatValue_json(options,P_AreaHeight));
2014-03-04 16:51:35 +08:00
label->setTextAreaSize(size);
}
bool ha = DICTOOL->checkObjectExist_json(options, P_HAlignment);
2014-03-04 16:51:35 +08:00
if (ha)
{
label->setTextHorizontalAlignment((TextHAlignment)DICTOOL->getIntValue_json(options, P_HAlignment));
2014-03-04 16:51:35 +08:00
}
bool va = DICTOOL->checkObjectExist_json(options, P_VAlignment);
2014-03-04 16:51:35 +08:00
if (va)
{
label->setTextVerticalAlignment((TextVAlignment)DICTOOL->getIntValue_json(options, P_VAlignment));
2014-03-04 16:51:35 +08:00
}
WidgetReader::setColorPropsFromJsonDictionary(widget, options);
2014-12-01 12:46:29 +08:00
}
2014-10-09 18:28:09 +08:00
2019-11-24 23:15:56 +08:00
Offset<Table> TextReader::createOptionsWithFlatBuffers(pugi::xml_node objectData,
2014-11-21 15:15:38 +08:00
flatbuffers::FlatBufferBuilder *builder)
2014-10-09 18:28:09 +08:00
{
2014-11-21 15:15:38 +08:00
auto temp = WidgetReader::getInstance()->createOptionsWithFlatBuffers(objectData, builder);
auto widgetOptions = *(Offset<WidgetOptions>*)(&temp);
bool touchScaleEnabled = false;
bool isCustomSize = false;
2020-08-04 10:55:30 +08:00
std::string fontName;
2014-11-21 15:15:38 +08:00
int fontSize = 20;
std::string text = "Text Label";
bool isLocalized = false;
2014-11-21 15:15:38 +08:00
int areaWidth = 0;
int areaHeight = 0;
int h_alignment = 0;
int v_alignment = 0;
2015-04-08 16:54:58 +08:00
bool outlineEnabled = false;
Color4B outlineColor = Color4B::BLACK;
int outlineSize = 1;
bool shadowEnabled = false;
Color4B shadowColor = Color4B::BLACK;
Size shadowOffset = Size(2, -2);
int shadowBlurRadius = 0;
2019-11-24 23:15:56 +08:00
2020-08-04 10:55:30 +08:00
// since x-studio reader 10.0.593.0
2019-11-24 23:15:56 +08:00
bool glowEnabled = false;
Color4B glowColor = Color4B::BLACK;
bool boldEnabled = false, underlineEnabled = false, italicsEnabled = false, strikethroughEnabled = false;
2014-11-21 15:15:38 +08:00
2020-08-04 10:55:30 +08:00
std::string path;
std::string plistFile;
2014-11-21 15:15:38 +08:00
int resourceType = 0;
2014-10-09 18:28:09 +08:00
// attributes
2019-11-24 23:15:56 +08:00
auto attribute = objectData.first_attribute();
2014-10-09 18:28:09 +08:00
while (attribute)
{
2019-11-24 23:15:56 +08:00
std::string name = attribute.name();
std::string value = attribute.value();
2014-10-09 18:28:09 +08:00
if (name == "TouchScaleChangeAble")
{
2014-11-21 15:15:38 +08:00
touchScaleEnabled = (value == "True") ? true : false;
2014-10-09 18:28:09 +08:00
}
else if (name == "LabelText")
{
2014-11-21 15:15:38 +08:00
text = value;
2014-10-09 18:28:09 +08:00
}
else if (name == "IsLocalized")
{
isLocalized = (value == "True") ? true : false;
}
2014-10-09 18:28:09 +08:00
else if (name == "FontSize")
{
2014-11-21 15:15:38 +08:00
fontSize = atoi(value.c_str());
2014-10-09 18:28:09 +08:00
}
else if (name == "FontName")
{
2014-11-21 15:15:38 +08:00
fontName = value;
2014-10-09 18:28:09 +08:00
}
else if (name == "AreaWidth")
{
areaWidth = atoi(value.c_str());
}
else if (name == "AreaHeight")
{
areaHeight = atoi(value.c_str());
}
else if (name == "HorizontalAlignmentType")
{
if (value == "HT_Left")
{
2014-11-21 15:15:38 +08:00
h_alignment = 0;
2014-10-09 18:28:09 +08:00
}
else if (value == "HT_Center")
{
2014-11-21 15:15:38 +08:00
h_alignment = 1;
2014-10-09 18:28:09 +08:00
}
else if (value == "HT_Right")
{
2014-11-21 15:15:38 +08:00
h_alignment = 2;
2014-10-09 18:28:09 +08:00
}
}
else if (name == "VerticalAlignmentType")
{
if (value == "VT_Top")
{
2014-11-21 15:15:38 +08:00
v_alignment = 0;
2014-10-09 18:28:09 +08:00
}
else if (value == "VT_Center")
{
2014-11-21 15:15:38 +08:00
v_alignment = 1;
2014-10-09 18:28:09 +08:00
}
else if (value == "VT_Bottom")
{
2014-11-21 15:15:38 +08:00
v_alignment = 2;
2014-10-09 18:28:09 +08:00
}
}
2014-11-21 15:15:38 +08:00
else if (name == "IsCustomSize")
2014-10-09 18:28:09 +08:00
{
2014-11-21 15:15:38 +08:00
isCustomSize = (value == "True") ? true : false;
2014-10-09 18:28:09 +08:00
}
2015-04-08 16:54:58 +08:00
else if (name == "OutlineEnabled")
{
outlineEnabled = (value == "True") ? true : false;
}
else if (name == "OutlineSize")
{
outlineSize = atoi(value.c_str());
}
else if (name == "ShadowEnabled")
{
shadowEnabled = (value == "True") ? true : false;
}
else if (name == "ShadowOffsetX")
{
shadowOffset.width = atof(value.c_str());
}
else if (name == "ShadowOffsetY")
{
shadowOffset.height = atof(value.c_str());
}
else if (name == "ShadowBlurRadius")
{
shadowBlurRadius = atoi(value.c_str());
}
2019-11-24 23:15:56 +08:00
else if (name == "GlowEnabled") {
glowEnabled = (value == "True") ? true : false;
}
else if (name == "BoldEnabled")
{
boldEnabled = (value == "True") ? true : false;
}
else if (name == "UnderlineEnabled") {
underlineEnabled = (value == "True") ? true : false;
}
else if (name == "ItalicsEnabled") {
italicsEnabled = (value == "True") ? true : false;
}
else if (name == "StrikethroughEnabled") {
strikethroughEnabled = (value == "True") ? true : false;
}
2014-10-09 18:28:09 +08:00
2019-11-24 23:15:56 +08:00
attribute = attribute.next_attribute();
2014-10-09 18:28:09 +08:00
}
// child elements
2019-11-24 23:15:56 +08:00
auto child = objectData.first_child();
2014-10-09 18:28:09 +08:00
while (child)
{
2019-11-24 23:15:56 +08:00
std::string name = child.name();
2014-10-09 18:28:09 +08:00
2014-11-21 15:15:38 +08:00
if (name == "FontResource")
2014-10-09 18:28:09 +08:00
{
2019-11-24 23:15:56 +08:00
attribute = child.first_attribute();
2014-10-09 18:28:09 +08:00
while (attribute)
{
2019-11-24 23:15:56 +08:00
name = attribute.name();
std::string value = attribute.value();
2014-10-09 18:28:09 +08:00
if (name == "Path")
{
path = value;
}
else if (name == "Type")
{
2014-11-21 15:15:38 +08:00
resourceType = 0;
2014-10-09 18:28:09 +08:00
}
else if (name == "Plist")
{
plistFile = value;
}
2019-11-24 23:15:56 +08:00
attribute = attribute.next_attribute();
2014-10-09 18:28:09 +08:00
}
}
2015-04-08 16:54:58 +08:00
else if (name == "OutlineColor")
{
2019-11-24 23:15:56 +08:00
attribute = child.first_attribute();
2015-04-08 16:54:58 +08:00
while (attribute)
{
2019-11-24 23:15:56 +08:00
name = attribute.name();
std::string value = attribute.value();
2015-04-08 16:54:58 +08:00
if (name == "A")
{
outlineColor.a = atoi(value.c_str());
}
else if (name == "R")
{
outlineColor.r = atoi(value.c_str());
}
else if (name == "G")
{
outlineColor.g = atoi(value.c_str());
}
else if (name == "B")
{
outlineColor.b = atoi(value.c_str());
}
2019-11-24 23:15:56 +08:00
attribute = attribute.next_attribute();
2015-04-08 16:54:58 +08:00
}
}
else if (name == "ShadowColor")
{
2019-11-24 23:15:56 +08:00
attribute = child.first_attribute();
2015-04-08 16:54:58 +08:00
while (attribute)
{
2019-11-24 23:15:56 +08:00
name = attribute.name();
std::string value = attribute.value();
2015-04-08 16:54:58 +08:00
if (name == "A")
{
shadowColor.a = atoi(value.c_str());
}
else if (name == "R")
{
shadowColor.r = atoi(value.c_str());
}
else if (name == "G")
{
shadowColor.g = atoi(value.c_str());
}
else if (name == "B")
{
shadowColor.b = atoi(value.c_str());
}
2019-11-24 23:15:56 +08:00
attribute = attribute.next_attribute();
2015-04-08 16:54:58 +08:00
}
}
2019-11-24 23:15:56 +08:00
else if(name == "GlowColor") {
attribute = child.first_attribute();
while (attribute)
{
name = attribute.name();
std::string value = attribute.value();
if (name == "A")
{
glowColor.a = atoi(value.c_str());
}
else if (name == "R")
{
glowColor.r = atoi(value.c_str());
}
else if (name == "G")
{
glowColor.g = atoi(value.c_str());
}
else if (name == "B")
{
glowColor.b = atoi(value.c_str());
}
attribute = attribute.next_attribute();
}
}
2014-10-09 18:28:09 +08:00
2019-11-24 23:15:56 +08:00
child = child.next_sibling();
2014-10-09 18:28:09 +08:00
}
2015-04-08 16:54:58 +08:00
flatbuffers::Color f_outlineColor(outlineColor.a, outlineColor.r, outlineColor.g, outlineColor.b);
flatbuffers::Color f_shadowColor(shadowColor.a, shadowColor.r, shadowColor.g, shadowColor.b);
2019-11-24 23:15:56 +08:00
flatbuffers::Color f_glowColor(glowColor.a, glowColor.r, glowColor.g, glowColor.b);
2015-04-08 16:54:58 +08:00
2014-11-21 15:15:38 +08:00
auto options = CreateTextOptions(*builder,
widgetOptions,
CreateResourceData(*builder,
builder->CreateString(path),
builder->CreateString(plistFile),
resourceType),
builder->CreateString(fontName),
fontSize,
builder->CreateString(text),
areaWidth,
areaHeight,
h_alignment,
v_alignment,
touchScaleEnabled,
2015-04-08 16:54:58 +08:00
isCustomSize,
outlineEnabled,
&f_outlineColor,
outlineSize,
shadowEnabled,
&f_shadowColor,
shadowOffset.width,
shadowOffset.height,
shadowBlurRadius,
2019-11-24 23:15:56 +08:00
isLocalized,
glowEnabled,
&f_glowColor, boldEnabled, underlineEnabled, italicsEnabled, strikethroughEnabled);
2014-11-21 15:15:38 +08:00
return *(Offset<Table>*)(&options);
}
void TextReader::setPropsWithFlatBuffers(cocos2d::Node *node, const flatbuffers::Table *textOptions)
{
Text* label = static_cast<Text*>(node);
auto options = (TextOptions*)textOptions;
bool touchScaleEnabled = options->touchScaleEnable() != 0;
2014-11-21 15:15:38 +08:00
label->setTouchScaleChangeEnabled(touchScaleEnabled);
2014-11-21 15:15:38 +08:00
int fontSize = options->fontSize();
label->setFontSize(fontSize);
2014-11-21 15:15:38 +08:00
Size areaSize = Size(options->areaWidth(), options->areaHeight());
if (!areaSize.equals(Size::ZERO))
2014-10-09 18:28:09 +08:00
{
2014-11-21 15:15:38 +08:00
label->setTextAreaSize(areaSize);
2014-10-09 18:28:09 +08:00
}
2020-08-04 10:55:30 +08:00
auto resourceDataDic = (options->fontResource());
std::string path = resourceDataDic->path()->c_str();
if (!path.empty() && FileUtils::getInstance()->isFileExist(path))
2014-11-21 15:15:38 +08:00
{
label->setFontName(path);
}
else
{
2020-08-04 10:55:30 +08:00
path = options->fontName()->c_str();
label->setFontName(path);
2014-11-21 15:15:38 +08:00
}
TextHAlignment h_alignment = (TextHAlignment)options->hAlignment();
label->setTextHorizontalAlignment(h_alignment);
TextVAlignment v_alignment = (TextVAlignment)options->vAlignment();
label->setTextVerticalAlignment((TextVAlignment)v_alignment);
bool outlineEnabled = options->outlineEnabled() != 0;
2015-04-08 16:54:58 +08:00
if (outlineEnabled)
{
auto f_outlineColor = options->outlineColor();
if (f_outlineColor)
{
Color4B outlineColor(f_outlineColor->r(), f_outlineColor->g(), f_outlineColor->b(), f_outlineColor->a());
2015-04-08 16:54:58 +08:00
label->enableOutline(outlineColor, options->outlineSize());
}
}
bool shadowEnabled = options->shadowEnabled() != 0;
2015-04-08 16:54:58 +08:00
if (shadowEnabled)
{
auto f_shadowColor = options->shadowColor();
if (f_shadowColor)
{
Color4B shadowColor(f_shadowColor->r(), f_shadowColor->g(), f_shadowColor->b(), f_shadowColor->a());
2015-04-08 16:54:58 +08:00
label->enableShadow(shadowColor, Size(options->shadowOffsetX(), options->shadowOffsetY()), options->shadowBlurRadius());
}
}
2019-11-24 23:15:56 +08:00
if (options->glowEnabled() != 0) {
auto f_glowColor = options->glowColor();
if (f_glowColor)
{
Color4B glowColor(f_glowColor->r(), f_glowColor->g(), f_glowColor->b(), f_glowColor->a());
label->enableGlow(glowColor);
}
}
std::string text = options->text()->c_str();
bool isLocalized = options->isLocalized() != 0;
if (isLocalized)
{
ILocalizationManager* lm = LocalizationHelper::getCurrentManager();
label->setString(lm->getLocalizationString(text));
}
else
{
label->setString(text);
}
// Save node color before set widget properties
auto oldColor = node->getColor();
2014-11-21 15:15:38 +08:00
auto widgetReader = WidgetReader::getInstance();
widgetReader->setPropsWithFlatBuffers(node, (Table*)options->widgetOptions());
// restore node color and set color to text to fix shadow & outline color won't show correct bug
node->setColor(oldColor);
auto optionsWidget = (WidgetOptions*)options->widgetOptions();
auto f_color = optionsWidget->color();
Color4B color(f_color->r(), f_color->g(), f_color->b(), f_color->a());
((Text *)node)->setTextColor(color);
label->setUnifySizeEnabled(false);
bool IsCustomSize = options->isCustomSize() != 0;
label->ignoreContentAdaptWithSize(!IsCustomSize);
auto widgetOptions = options->widgetOptions();
2014-12-08 15:48:24 +08:00
if (!label->isIgnoreContentAdaptWithSize())
{
Size contentSize(widgetOptions->size()->width(), widgetOptions->size()->height());
label->setContentSize(contentSize);
}
2019-11-24 23:15:56 +08:00
auto labelRenderer = dynamic_cast<cocos2d::Label*>(label->getVirtualRenderer());
if (options->boldEnabled())
labelRenderer->enableBold();
if (options->underlineEnabled())
labelRenderer->enableUnderline();
if (options->italicsEnabled())
labelRenderer->enableItalics();
if (options->strikethroughEnabled())
labelRenderer->enableStrikethrough();
2014-11-21 15:15:38 +08:00
}
Node* TextReader::createNodeWithFlatBuffers(const flatbuffers::Table *textOptions)
2014-11-21 15:15:38 +08:00
{
2020-08-04 00:14:35 +08:00
Text* text = Text::create();
2014-11-21 15:15:38 +08:00
setPropsWithFlatBuffers(text, (Table*)textOptions);
2014-10-09 18:28:09 +08:00
2014-11-21 15:15:38 +08:00
return text;
2014-10-09 18:28:09 +08:00
}
2014-03-04 16:51:35 +08:00
}