axmol/cocos/editor-support/cocostudio/WidgetReader/TextReader/TextReader.cpp

378 lines
12 KiB
C++
Raw Normal View History

2014-03-04 16:51:35 +08:00
#include "TextReader.h"
2014-03-11 17:13:54 +08:00
#include "ui/UIText.h"
#include "cocostudio/CocoLoader.h"
2014-10-11 15:50:44 +08:00
#include "CSParseBinary.pb.h"
2014-10-09 18:28:09 +08:00
#include "tinyxml2/tinyxml2.h"
2014-03-04 16:51:35 +08:00
2014-03-06 16:15:03 +08:00
USING_NS_CC;
using namespace ui;
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
IMPLEMENT_CLASS_WIDGET_READER_INFO(TextReader)
TextReader::TextReader()
{
}
TextReader::~TextReader()
{
}
TextReader* TextReader::getInstance()
{
if (!instanceTextReader)
{
instanceTextReader = new (std::nothrow) TextReader();
2014-03-04 16:51:35 +08:00
}
return 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){
2014-07-04 11:53:06 +08:00
std::string fontFilePath;
2014-07-07 15:22:14 +08:00
fontFilePath = binaryFilePath.append(value);
if (FileUtils::getInstance()->isFileExist(fontFilePath)) {
label->setFontName(fontFilePath);
}else{
label->setFontName(value);
}
}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-10-09 18:28:09 +08:00
void TextReader::setPropsFromProtocolBuffers(ui::Widget *widget, const protocolbuffers::NodeTree &nodeTree)
{
Text* label = static_cast<Text*>(widget);
const protocolbuffers::TextOptions& options = nodeTree.textoptions();
bool IsCustomSize = options.iscustomsize();
label->ignoreContentAdaptWithSize(!IsCustomSize);
WidgetReader::setPropsFromProtocolBuffers(widget, nodeTree);
label->setUnifySizeEnabled(false);
std::string protocolBuffersPath = GUIReader::getInstance()->getFilePath();
bool touchScaleChangeAble = options.touchscaleenable();
label->setTouchScaleChangeEnabled(touchScaleChangeAble);
const char* text = options.has_text() ? options.text().c_str() : "Text Label";
label->setString(text);
int fontSize = options.has_fontsize() ? options.fontsize() : 20;
label->setFontSize(fontSize);
std::string fontName = options.has_fontname() ? options.fontname() : "微软雅黑";
std::string fontFilePath = protocolBuffersPath.append(fontName);
if (FileUtils::getInstance()->isFileExist(fontFilePath))
{
label->setFontName(fontFilePath);
}
else{
label->setFontName(fontName);
}
bool aw = options.has_areawidth();
bool ah = options.has_areaheight();
if (aw && ah)
{
Size size = Size(options.areawidth(), options.areaheight());
label->setTextAreaSize(size);
}
bool ha = options.has_halignment();
if (ha)
{
label->setTextHorizontalAlignment((TextHAlignment)options.halignment());
}
bool va = options.has_valignment();
if (va)
{
label->setTextVerticalAlignment((TextVAlignment)options.valignment());
}
if (options.has_fontresource())
{
const protocolbuffers::ResourceData& resourceData = options.fontresource();
label->setFontName(protocolBuffersPath + resourceData.path());
}
// other commonly protperties
WidgetReader::setColorPropsFromProtocolBuffers(widget, nodeTree);
}
void TextReader::setPropsFromXML(cocos2d::ui::Widget *widget, const tinyxml2::XMLElement *objectData)
{
WidgetReader::setPropsFromXML(widget, objectData);
Text* label = static_cast<Text*>(widget);
std::string xmlPath = GUIReader::getInstance()->getFilePath();
float areaWidth = 0.0f, areaHeight = 0.0f;
int halignment = 0, valignment = 0;
int opacity = 255;
label->setUnifySizeEnabled(false);
label->setFontName("微软雅黑");
// attributes
const tinyxml2::XMLAttribute* attribute = objectData->FirstAttribute();
while (attribute)
{
std::string name = attribute->Name();
std::string value = attribute->Value();
if (name == "TouchScaleChangeAble")
{
label->setTouchScaleChangeEnabled((value == "True") ? true : false);
}
else if (name == "LabelText")
{
label->setString(value);
}
else if (name == "FontSize")
{
label->setFontSize(atoi(value.c_str()));
}
else if (name == "FontName")
{
label->setFontName(value);
}
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")
{
halignment = 0;
}
else if (value == "HT_Center")
{
halignment = 1;
}
else if (value == "HT_Right")
{
halignment = 2;
}
}
else if (name == "VerticalAlignmentType")
{
if (value == "VT_Top")
{
valignment = 0;
}
else if (value == "VT_Center")
{
valignment = 1;
}
else if (value == "VT_Bottom")
{
valignment = 2;
}
}
else if (name == "Alpha")
{
opacity = atoi(value.c_str());
}
attribute = attribute->Next();
}
// child elements
const tinyxml2::XMLElement* child = objectData->FirstChildElement();
while (child)
{
std::string name = child->Name();
if (name == "Size")
{
const tinyxml2::XMLAttribute* attribute = child->FirstAttribute();
float width = 0.0f, height = 0.0f;
while (attribute)
{
std::string name = attribute->Name();
std::string value = attribute->Value();
if (name == "X")
{
width = atof(value.c_str());
}
else if (name == "Y")
{
height = atof(value.c_str());
}
attribute = attribute->Next();
}
label->ignoreContentAdaptWithSize(false);
label->setContentSize(Size(width, height));
}
else if (name == "FontResource")
{
const tinyxml2::XMLAttribute* attribute = child->FirstAttribute();
int resourceType = 0;
std::string path = "", plistFile = "";
while (attribute)
{
std::string name = attribute->Name();
std::string value = attribute->Value();
if (name == "Path")
{
path = value;
}
else if (name == "Type")
{
resourceType = (value == "Normal" || value == "Default" || value == "MarkedSubImage") ? 0 : 1;
}
else if (name == "Plist")
{
plistFile = value;
}
attribute = attribute->Next();
}
switch (resourceType)
{
case 0:
{
label->setFontName(xmlPath + path);
break;
}
default:
break;
}
}
child = child->NextSiblingElement();
}
if (areaWidth != 0 || areaHeight != 0)
{
label->setTextAreaSize(Size(areaWidth, areaHeight));
}
label->setTextHorizontalAlignment((TextHAlignment)halignment);
label->setTextVerticalAlignment((TextVAlignment)valignment);
label->setOpacity(opacity);
}
2014-03-04 16:51:35 +08:00
}