Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update that avoid crash during load resource which serialize by flat buffers

This commit is contained in:
pipu 2014-12-17 19:00:24 +08:00
parent e7fc2a5607
commit 79acf80fb1
15 changed files with 1371 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
cocos/editor-support/cocostudio/WidgetReader/ButtonReader/ButtonReader.cpp
View File

@ -547,21 +547,195 @@ namespace cocostudio
bool scale9Enabled = options->scale9Enabled();
button->setScale9Enabled(scale9Enabled);
bool normalFileExist = false;
std::string normalErrorFilePath = "";
auto normalDic = options->normalData();
int normalType = normalDic->resourceType();
std::string normalTexturePath = normalDic->path()->c_str();
button->loadTextureNormal(normalTexturePath, (Widget::TextureResType)normalType);
std::string normalTexturePath = this->getResourcePath(normalDic->path()->c_str(), (Widget::TextureResType)normalType);
switch (normalType)
{
case 0:
if (FileUtils::getInstance()->isFileExist(normalTexturePath))
{
normalFileExist = true;
}
else
{
normalErrorFilePath = normalTexturePath;
normalFileExist = false;
}
break;
case 1:
{
std::string plist = normalDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(normalTexturePath);
if (spriteFrame)
{
normalFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
normalErrorFilePath = textureFileName;
}
}
else
{
normalErrorFilePath = plist;
}
normalFileExist = false;
}
break;
}
default:
break;
}
if (normalFileExist)
{
button->loadTextureNormal(normalTexturePath, (Widget::TextureResType)normalType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", normalErrorFilePath.c_str())->getCString());
button->addChild(label);
}
bool pressedFileExist = false;
std::string pressedErrorFilePath = "";
auto pressedDic = options->pressedData();
int pressedType = pressedDic->resourceType();
std::string pressedTexturePath = pressedDic->path()->c_str();
button->loadTexturePressed(pressedTexturePath, (Widget::TextureResType)pressedType);
std::string pressedTexturePath = this->getResourcePath(pressedDic->path()->c_str(), (Widget::TextureResType)pressedType);
switch (pressedType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(pressedTexturePath))
{
pressedFileExist = true;
}
else
{
pressedErrorFilePath = pressedTexturePath;
pressedFileExist = false;
}
break;
}
case 1:
{
std::string plist = pressedDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(pressedTexturePath);
if (spriteFrame)
{
pressedFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
pressedErrorFilePath = textureFileName;
}
}
else
{
pressedErrorFilePath = plist;
}
pressedFileExist = false;
}
break;
}
default:
break;
}
if (pressedFileExist)
{
button->loadTexturePressed(pressedTexturePath, (Widget::TextureResType)pressedType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", pressedErrorFilePath.c_str())->getCString());
button->addChild(label);
}
bool disabledFileExist = false;
std::string disabledErrorFilePath = "";
auto disabledDic = options->disabledData();
int disabledType = disabledDic->resourceType();
std::string disabledTexturePath = disabledDic->path()->c_str();
std::string disabledTexturePath = this->getResourcePath(disabledDic->path()->c_str(), (Widget::TextureResType)disabledType);
switch (disabledType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(disabledTexturePath))
{
disabledFileExist = true;
}
else
{
disabledErrorFilePath = disabledTexturePath;
disabledFileExist = false;
}
break;
}
case 1:
{
std::string plist = disabledDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(disabledTexturePath);
if (spriteFrame)
{
disabledFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
disabledErrorFilePath = textureFileName;
}
}
else
{
disabledErrorFilePath = plist;
}
disabledFileExist = false;
}
break;
}
default:
break;
}
if (disabledFileExist)
{
button->loadTextureDisabled(disabledTexturePath, (Widget::TextureResType)disabledType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", disabledErrorFilePath.c_str())->getCString());
button->addChild(label);
}
std::string titleText = options->text()->c_str();
button->setTitleText(titleText);
@ -577,11 +751,31 @@ namespace cocostudio
button->setTitleFontName(titleFontName);
auto resourceData = options->fontResource();
bool fileExist = false;
std::string errorFilePath = "";
std::string path = resourceData->path()->c_str();
if (path != "")
{
if (FileUtils::getInstance()->isFileExist(path))
{
fileExist = true;
}
else
{
errorFilePath = path;
fileExist = false;
}
if (fileExist)
{
button->setTitleFontName(path);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
button->addChild(label);
}
}
bool displaystate = options->displaystate();
button->setBright(displaystate);

305
cocos/editor-support/cocostudio/WidgetReader/CheckBoxReader/CheckBoxReader.cpp
View File

@ -429,34 +429,329 @@ namespace cocostudio
CheckBox* checkBox = static_cast<CheckBox*>(node);
//load background image
bool backGroundFileExist = false;
std::string backGroundErrorFilePath = "";
auto backGroundDic = options->backGroundBoxData();
int backGroundType = backGroundDic->resourceType();
std::string backGroundTexturePath = backGroundDic->path()->c_str();
std::string backGroundTexturePath = this->getResourcePath(backGroundDic->path()->c_str(), (Widget::TextureResType)backGroundType);
switch (backGroundType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(backGroundTexturePath))
{
backGroundFileExist = true;
}
else
{
backGroundErrorFilePath = backGroundTexturePath;
backGroundFileExist = false;
}
break;
}
case 1:
{
std::string plist = backGroundDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(backGroundTexturePath);
if (spriteFrame)
{
backGroundFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
backGroundErrorFilePath = textureFileName;
}
}
else
{
backGroundErrorFilePath = plist;
}
backGroundFileExist = false;
}
break;
}
default:
break;
}
if (backGroundFileExist)
{
checkBox->loadTextureBackGround(backGroundTexturePath, (Widget::TextureResType)backGroundType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", backGroundErrorFilePath.c_str())->getCString());
checkBox->addChild(label);
}
//load background selected image
bool backGroundSelectedfileExist = false;
std::string backGroundSelectedErrorFilePath = "";
auto backGroundSelectedDic = options->backGroundBoxSelectedData();
int backGroundSelectedType = backGroundSelectedDic->resourceType();
std::string backGroundSelectedTexturePath = backGroundSelectedDic->path()->c_str();
std::string backGroundSelectedTexturePath = this->getResourcePath(backGroundSelectedDic->path()->c_str(), (Widget::TextureResType)backGroundSelectedType);
switch (backGroundSelectedType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(backGroundSelectedTexturePath))
{
backGroundSelectedfileExist = true;
}
else
{
backGroundSelectedErrorFilePath = backGroundSelectedTexturePath;
backGroundSelectedfileExist = false;
}
break;
}
case 1:
{
std::string plist = backGroundSelectedDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(backGroundSelectedTexturePath);
if (spriteFrame)
{
backGroundSelectedfileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
backGroundSelectedErrorFilePath = textureFileName;
}
}
else
{
backGroundSelectedErrorFilePath = plist;
}
backGroundSelectedfileExist = false;
}
break;
}
default:
break;
}
if (backGroundSelectedfileExist)
{
checkBox->loadTextureBackGroundSelected(backGroundSelectedTexturePath, (Widget::TextureResType)backGroundSelectedType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", backGroundSelectedErrorFilePath.c_str())->getCString());
checkBox->addChild(label);
}
//load frontCross image
bool frontCrossFileExist = false;
std::string frontCrossErrorFilePath = "";
auto frontCrossDic = options->frontCrossData();
int frontCrossType = frontCrossDic->resourceType();
std::string frontCrossFileName = frontCrossDic->path()->c_str();
std::string frontCrossFileName = this->getResourcePath(frontCrossDic->path()->c_str(), (Widget::TextureResType)frontCrossType);
switch (frontCrossType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(frontCrossFileName))
{
frontCrossFileExist = true;
}
else
{
frontCrossErrorFilePath = frontCrossFileName;
frontCrossFileExist = false;
}
break;
}
case 1:
{
std::string plist = frontCrossDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(frontCrossFileName);
if (spriteFrame)
{
frontCrossFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
frontCrossErrorFilePath = textureFileName;
}
}
else
{
frontCrossErrorFilePath = plist;
}
frontCrossFileExist = false;
}
break;
}
default:
break;
}
if (frontCrossFileExist)
{
checkBox->loadTextureFrontCross(frontCrossFileName, (Widget::TextureResType)frontCrossType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", frontCrossErrorFilePath.c_str())->getCString());
checkBox->addChild(label);
}
//load backGroundBoxDisabledData
bool backGroundBoxDisabledFileExist = false;
std::string backGroundBoxDisabledErrorFilePath = "";
auto backGroundDisabledDic = options->backGroundBoxDisabledData();
int backGroundDisabledType = backGroundDisabledDic->resourceType();
std::string backGroundDisabledFileName = backGroundDisabledDic->path()->c_str();
std::string backGroundDisabledFileName = this->getResourcePath(backGroundDisabledDic->path()->c_str(), (Widget::TextureResType)backGroundDisabledType);
switch (backGroundDisabledType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(backGroundDisabledFileName))
{
backGroundBoxDisabledFileExist = true;
}
else
{
backGroundBoxDisabledErrorFilePath = backGroundDisabledFileName;
backGroundBoxDisabledFileExist = false;
}
break;
}
case 1:
{
std::string plist = backGroundDisabledDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(backGroundDisabledFileName);
if (spriteFrame)
{
backGroundBoxDisabledFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
backGroundBoxDisabledErrorFilePath = textureFileName;
}
}
else
{
backGroundBoxDisabledErrorFilePath = plist;
}
backGroundBoxDisabledFileExist = false;
}
break;
}
default:
break;
}
if (backGroundBoxDisabledFileExist)
{
checkBox->loadTextureBackGroundDisabled(backGroundDisabledFileName, (Widget::TextureResType)backGroundDisabledType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", backGroundBoxDisabledErrorFilePath.c_str())->getCString());
checkBox->addChild(label);
}
///load frontCrossDisabledData
bool frontCrossDisabledFileExist = false;
std::string frontCrossDisabledErrorFilePath = "";
auto frontCrossDisabledDic = options->frontCrossDisabledData();
int frontCrossDisabledType = frontCrossDisabledDic->resourceType();
std::string frontCrossDisabledFileName = frontCrossDisabledDic->path()->c_str();
std::string frontCrossDisabledFileName = this->getResourcePath(frontCrossDisabledDic->path()->c_str(), (Widget::TextureResType)frontCrossDisabledType);
switch (frontCrossDisabledType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(frontCrossDisabledFileName))
{
frontCrossDisabledFileExist = true;
}
else
{
frontCrossDisabledErrorFilePath = frontCrossDisabledFileName;
frontCrossDisabledFileExist = false;
}
break;
}
case 1:
{
std::string plist = frontCrossDisabledDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(frontCrossDisabledFileName);
if (spriteFrame)
{
frontCrossDisabledFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
frontCrossDisabledErrorFilePath = textureFileName;
}
}
else
{
frontCrossDisabledErrorFilePath = plist;
}
frontCrossDisabledFileExist = false;
}
break;
}
default:
break;
}
if (frontCrossDisabledFileExist)
{
checkBox->loadTextureFrontCrossDisabled(frontCrossDisabledFileName, (Widget::TextureResType)frontCrossDisabledType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", frontCrossDisabledErrorFilePath.c_str())->getCString());
checkBox->addChild(label);
}
bool selectedstate = options->selectedState();
checkBox->setSelected(selectedstate);

29
cocos/editor-support/cocostudio/WidgetReader/GameMapReader/GameMapReader.cpp
View File

@ -134,17 +134,22 @@ namespace cocostudio
auto options = (GameMapOptions*)gameMapOptions;
auto fileNameData = options->fileNameData();
bool fileExist = false;
std::string errorFilePath = "";
std::string path = fileNameData->path()->c_str();
int resourceType = fileNameData->resourceType();
switch (resourceType)
{
case 0:
{
std::string path = fileNameData->path()->c_str();
const char* tmxFile = path.c_str();
if (tmxFile && strcmp("", tmxFile) != 0)
if (FileUtils::getInstance()->isFileExist(path))
{
tmx = TMXTiledMap::create(tmxFile);
fileExist = true;
}
else
{
errorFilePath = path;
fileExist = false;
}
break;
}
@ -152,11 +157,23 @@ namespace cocostudio
default:
break;
}
if (fileExist)
{
tmx = TMXTiledMap::create(path);
if (tmx)
{
setPropsWithFlatBuffers(tmx, (Table*)gameMapOptions);
}
}
else
{
Node* node = Node::create();
setPropsWithFlatBuffers(node, (Table*)gameMapOptions);
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
node->addChild(label);
return node;
}
return tmx;
}

61
cocos/editor-support/cocostudio/WidgetReader/ImageViewReader/ImageViewReader.cpp
View File

@ -291,10 +291,69 @@ namespace cocostudio
auto options = (ImageViewOptions*)imageViewOptions;
bool fileExist = false;
std::string errorFilePath = "";
auto imageFileNameDic = options->fileNameData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
std::string imageFileName = this->getResourcePath(imageFileNameDic->path()->c_str(), (Widget::TextureResType)imageFileNameType);
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
fileExist = true;
}
else
{
errorFilePath = imageFileName;
fileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
default:
break;
}
if (fileExist)
{
imageView->loadTexture(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
imageView->addChild(label);
}
bool scale9Enabled = options->scale9Enabled();
imageView->setScale9Enabled(scale9Enabled);

65
cocos/editor-support/cocostudio/WidgetReader/LayoutReader/LayoutReader.cpp
View File

@ -598,10 +598,72 @@ namespace cocostudio
panel->setBackGroundColorOpacity(bgColorOpacity);
bool fileExist = false;
std::string errorFilePath = "";
auto imageFileNameDic = options->backGroundImageData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
std::string imageFileName = this->getResourcePath(imageFileNameDic->path()->c_str(), (Widget::TextureResType)imageFileNameType);
if (imageFileName != "")
{
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
fileExist = true;
}
else
{
errorFilePath = imageFileName;
fileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
default:
break;
}
if (fileExist)
{
panel->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
panel->addChild(label);
}
}
auto widgetOptions = options->widgetOptions();
auto f_color = widgetOptions->color();
@ -614,6 +676,7 @@ namespace cocostudio
auto widgetReader = WidgetReader::getInstance();
widgetReader->setPropsWithFlatBuffers(node, (Table*)options->widgetOptions());
if (backGroundScale9Enabled)
{
auto f_capInsets = options->capInsets();

69
cocos/editor-support/cocostudio/WidgetReader/ListViewReader/ListViewReader.cpp
View File

@ -426,10 +426,72 @@ namespace cocostudio
listView->setBackGroundColorOpacity(bgColorOpacity);
bool fileExist = false;
std::string errorFilePath = "";
auto imageFileNameDic = options->backGroundImageData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
if (imageFileName != "")
{
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
fileExist = true;
}
else
{
errorFilePath = imageFileName;
fileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
default:
break;
}
if (fileExist)
{
listView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
listView->addChild(label);
}
}
auto widgetOptions = options->widgetOptions();
auto f_color = widgetOptions->color();
@ -442,9 +504,15 @@ namespace cocostudio
auto f_innerSize = options->innerSize();
Size innerSize(f_innerSize->width(), f_innerSize->height());
listView->setInnerContainerSize(innerSize);
// int direction = options->direction();
// listView->setDirection((ScrollView::Direction)direction);
bool bounceEnabled = options->bounceEnabled();
listView->setBounceEnabled(bounceEnabled);
// int gravityValue = options->gravity();
// ListView::Gravity gravity = (ListView::Gravity)gravityValue;
// listView->setGravity(gravity);
std::string directionType = options->directionType()->c_str();
if (directionType == "")
{
@ -499,7 +567,6 @@ namespace cocostudio
}
else
{
auto widgetOptions = options->widgetOptions();
if (!listView->isIgnoreContentAdaptWithSize())
{
Size contentSize(widgetOptions->size()->width(), widgetOptions->size()->height());

61
cocos/editor-support/cocostudio/WidgetReader/LoadingBarReader/LoadingBarReader.cpp
View File

@ -241,10 +241,69 @@ namespace cocostudio
LoadingBar* loadingBar = static_cast<LoadingBar*>(node);
auto options = (LoadingBarOptions*)loadingBarOptions;
bool fileExist = false;
std::string errorFilePath = "";
auto imageFileNameDic = options->textureData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
std::string imageFileName = this->getResourcePath(imageFileNameDic->path()->c_str(), (Widget::TextureResType)imageFileNameType);
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
fileExist = true;
}
else
{
errorFilePath = imageFileName;
fileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
default:
break;
}
if (fileExist)
{
loadingBar->loadTexture(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
loadingBar->addChild(label);
}
int direction = options->direction();
loadingBar->setDirection(LoadingBar::Direction(direction));

65
cocos/editor-support/cocostudio/WidgetReader/PageViewReader/PageViewReader.cpp
View File

@ -339,11 +339,72 @@ namespace cocostudio
pageView->setBackGroundColorOpacity(bgColorOpacity);
bool fileExist = false;
std::string errorFilePath = "";
auto imageFileNameDic = options->backGroundImageData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
pageView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
std::string imageFileName = this->getResourcePath(imageFileNameDic->path()->c_str(), (Widget::TextureResType)imageFileNameType);
if (imageFileName != "")
{
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
fileExist = true;
}
else
{
errorFilePath = imageFileName;
fileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
default:
break;
}
if (fileExist)
{
pageView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
pageView->addChild(label);
}
}
auto widgetOptions = options->widgetOptions();
auto f_color = widgetOptions->color();

27
cocos/editor-support/cocostudio/WidgetReader/ParticleReader/ParticleReader.cpp
View File

@ -134,15 +134,22 @@ namespace cocostudio
auto options = (ParticleSystemOptions*)particleOptions;
auto fileNameData = options->fileNameData();
bool fileExist = false;
std::string errorFilePath = "";
std::string path = fileNameData->path()->c_str();
int resourceType = fileNameData->resourceType();
switch (resourceType)
{
case 0:
{
std::string path = fileNameData->path()->c_str();
if (path != "")
if (FileUtils::getInstance()->isFileExist(path))
{
particle = ParticleSystemQuad::create(path);
fileExist = true;
}
else
{
errorFilePath = path;
fileExist = false;
}
break;
}
@ -150,11 +157,23 @@ namespace cocostudio
default:
break;
}
if (fileExist)
{
particle = ParticleSystemQuad::create(path);
if (particle)
{
setPropsWithFlatBuffers(particle, (Table*)particleOptions);
}
}
else
{
Node* node = Node::create();
setPropsWithFlatBuffers(node, (Table*)particleOptions);
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
node->addChild(label);
return node;
}
return particle;
}

64
cocos/editor-support/cocostudio/WidgetReader/ScrollViewReader/ScrollViewReader.cpp
View File

@ -425,10 +425,72 @@ namespace cocostudio
scrollView->setBackGroundColorOpacity(bgColorOpacity);
bool fileExist = false;
std::string errorFilePath = "";
auto imageFileNameDic = options->backGroundImageData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
std::string imageFileName = this->getResourcePath(imageFileNameDic->path()->c_str(), (Widget::TextureResType)imageFileNameType);
if (imageFileName != "")
{
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
fileExist = true;
}
else
{
errorFilePath = imageFileName;
fileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
default:
break;
}
if (fileExist)
{
scrollView->setBackGroundImage(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
scrollView->addChild(label);
}
}
auto widgetOptions = options->widgetOptions();
auto f_color = widgetOptions->color();

305
cocos/editor-support/cocostudio/WidgetReader/SliderReader/SliderReader.cpp
View File

@ -463,34 +463,329 @@ namespace cocostudio
int percent = options->percent();
slider->setPercent(percent);
bool imageFileExist = false;
std::string imageErrorFilePath = "";
auto imageFileNameDic = options->barFileNameData();
int imageFileNameType = imageFileNameDic->resourceType();
std::string imageFileName = imageFileNameDic->path()->c_str();
std::string imageFileName = this->getResourcePath(imageFileNameDic->path()->c_str(), (Widget::TextureResType)imageFileNameType);
switch (imageFileNameType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(imageFileName))
{
imageFileExist = true;
}
else
{
imageErrorFilePath = imageFileName;
imageFileExist = false;
}
break;
}
case 1:
{
std::string plist = imageFileNameDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(imageFileName);
if (spriteFrame)
{
imageFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
imageErrorFilePath = textureFileName;
}
}
else
{
imageErrorFilePath = plist;
}
imageFileExist = false;
}
break;
}
default:
break;
}
if (imageFileExist)
{
slider->loadBarTexture(imageFileName, (Widget::TextureResType)imageFileNameType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", imageErrorFilePath.c_str())->getCString());
slider->addChild(label);
}
//loading normal slider ball texture
bool normalFileExist = false;
std::string normalErrorFilePath = "";
auto normalDic = options->ballNormalData();
int normalType = normalDic->resourceType();
std::string normalFileName = normalDic->path()->c_str();
std::string normalFileName = this->getResourcePath(normalDic->path()->c_str(), (Widget::TextureResType)normalType);
switch (normalType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(normalFileName))
{
normalFileExist = true;
}
else
{
normalErrorFilePath = normalFileName;
normalFileExist = false;
}
break;
}
case 1:
{
std::string plist = normalDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(normalFileName);
if (spriteFrame)
{
normalFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
normalErrorFilePath = textureFileName;
}
}
else
{
normalErrorFilePath = plist;
}
normalFileExist = false;
}
break;
}
default:
break;
}
if (normalFileExist)
{
slider->loadSlidBallTextureNormal(normalFileName, (Widget::TextureResType)normalType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", normalErrorFilePath.c_str())->getCString());
slider->addChild(label);
}
//loading slider ball press texture
bool pressedFileExist = false;
std::string pressedErrorFilePath = "";
auto pressedDic = options->ballPressedData();
int pressedType = pressedDic->resourceType();
std::string pressedFileName = pressedDic->path()->c_str();
std::string pressedFileName = this->getResourcePath(pressedDic->path()->c_str(), (Widget::TextureResType)pressedType);
switch (pressedType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(pressedFileName))
{
pressedFileExist = true;
}
else
{
pressedErrorFilePath = pressedFileName;
pressedFileExist = false;
}
break;
}
case 1:
{
std::string plist = pressedDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(pressedFileName);
if (spriteFrame)
{
pressedFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
pressedErrorFilePath = textureFileName;
}
}
else
{
pressedErrorFilePath = plist;
}
pressedFileExist = false;
}
break;
}
default:
break;
}
if (pressedFileExist)
{
slider->loadSlidBallTexturePressed(pressedFileName, (Widget::TextureResType)pressedType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", pressedErrorFilePath.c_str())->getCString());
slider->addChild(label);
}
//loading silder ball disable texture
bool disabledFileExist = false;
std::string disabledErrorFilePath = "";
auto disabledDic = options->ballDisabledData();
int disabledType = disabledDic->resourceType();
std::string disabledFileName = disabledDic->path()->c_str();
std::string disabledFileName = this->getResourcePath(disabledDic->path()->c_str(), (Widget::TextureResType)disabledType);
switch (disabledType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(disabledFileName))
{
disabledFileExist = true;
}
else
{
disabledErrorFilePath = disabledFileName;
disabledFileExist = false;
}
break;
}
case 1:
{
std::string plist = disabledDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(disabledFileName);
if (spriteFrame)
{
disabledFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
disabledErrorFilePath = textureFileName;
}
}
else
{
disabledErrorFilePath = plist;
}
disabledFileExist = false;
}
break;
}
default:
break;
}
if (disabledFileExist)
{
slider->loadSlidBallTextureDisabled(disabledFileName, (Widget::TextureResType)disabledType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", disabledErrorFilePath.c_str())->getCString());
slider->addChild(label);
}
//load slider progress texture
bool progressFileExist = false;
std::string progressErrorFilePath = "";
auto progressBarDic = options->progressBarData();
int progressBarType = progressBarDic->resourceType();
std::string progressBarFileName = progressBarDic->path()->c_str();
std::string progressBarFileName = this->getResourcePath(progressBarDic->path()->c_str(), (Widget::TextureResType)progressBarType);
switch (progressBarType)
{
case 0:
{
if (FileUtils::getInstance()->isFileExist(progressBarFileName))
{
progressFileExist = true;
}
else
{
progressErrorFilePath = progressBarFileName;
progressFileExist = false;
}
break;
}
case 1:
{
std::string plist = progressBarDic->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(progressBarFileName);
if (spriteFrame)
{
progressFileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
progressErrorFilePath = textureFileName;
}
}
else
{
progressErrorFilePath = plist;
}
progressFileExist = false;
}
break;
}
default:
break;
}
if (progressFileExist)
{
slider->loadProgressBarTexture(progressBarFileName, (Widget::TextureResType)progressBarType);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", progressErrorFilePath.c_str())->getCString());
slider->addChild(label);
}
bool displaystate = options->displaystate();
slider->setBright(displaystate);

46
cocos/editor-support/cocostudio/WidgetReader/SpriteReader/SpriteReader.cpp
View File

@ -141,24 +141,54 @@ namespace cocostudio
auto fileNameData = options->fileNameData();
int resourceType = fileNameData->resourceType();
std::string path = fileNameData->path()->c_str();
bool fileExist = false;
std::string errorFilePath = "";
switch (resourceType)
{
case 0:
{
std::string path = fileNameData->path()->c_str();
if (path != "")
if (FileUtils::getInstance()->isFileExist(path))
{
sprite->setTexture(path);
fileExist = true;
}
else
{
errorFilePath = path;
fileExist = false;
}
break;
}
case 1:
{
std::string path = fileNameData->path()->c_str();
if (path != "")
std::string plist = fileNameData->plistFile()->c_str();
SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(path);
if (spriteFrame)
{
sprite->setSpriteFrame(path);
sprite->setSpriteFrame(spriteFrame);
fileExist = true;
}
else
{
if (FileUtils::getInstance()->isFileExist(plist))
{
ValueMap value = FileUtils::getInstance()->getValueMapFromFile(plist);
ValueMap metadata = value["metadata"].asValueMap();
std::string textureFileName = metadata["textureFileName"].asString();
if (!FileUtils::getInstance()->isFileExist(textureFileName))
{
errorFilePath = textureFileName;
}
}
else
{
errorFilePath = plist;
}
fileExist = false;
}
break;
}
@ -166,6 +196,12 @@ namespace cocostudio
default:
break;
}
if (!fileExist)
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
sprite->addChild(label);
}
auto nodeReader = NodeReader::getInstance();

40
cocos/editor-support/cocostudio/WidgetReader/TextBMFontReader/TextBMFontReader.cpp
View File

@ -2,6 +2,7 @@
#include "TextBMFontReader.h"
#include "2d/CCFontAtlasCache.h"
#include "ui/UITextBMFont.h"
#include "cocostudio/CocoLoader.h"
#include "cocostudio/CSParseBinary_generated.h"
@ -190,23 +191,50 @@ namespace cocostudio
auto options = (TextBMFontOptions*)textBMFontOptions;
auto cmftDic = options->fileNameData();
bool fileExist = false;
std::string errorFilePath = "";
std::string errorContent = "";
std::string path = cmftDic->path()->c_str();
int cmfType = cmftDic->resourceType();
switch (cmfType)
{
case 0:
{
const char* cmfPath = cmftDic->path()->c_str();
labelBMFont->setFntFile(cmfPath);
if (FileUtils::getInstance()->isFileExist(path))
{
FontAtlas* newAtlas = FontAtlasCache::getFontAtlasFNT(path);
if (newAtlas)
{
fileExist = true;
}
else
{
errorContent = "has problem";
fileExist = false;
}
}
else
{
errorContent = "missed";
fileExist = false;
}
break;
}
case 1:
CCLOG("Wrong res type of LabelAtlas!");
break;
default:
break;
}
if (fileExist)
{
labelBMFont->setFntFile(path);
}
else
{
errorFilePath = path;
auto label = Label::create();
label->setString(__String::createWithFormat("%s %s", errorFilePath.c_str(), errorContent.c_str())->getCString());
labelBMFont->addChild(label);
}
std::string text = options->text()->c_str();
labelBMFont->setString(text);

22
cocos/editor-support/cocostudio/WidgetReader/TextFieldReader/TextFieldReader.cpp
View File

@ -303,12 +303,32 @@ namespace cocostudio
}
bool fileExist = false;
std::string errorFilePath = "";
auto resourceData = options->fontResource();
std::string path = resourceData->path()->c_str();
if (path != "")
{
if (FileUtils::getInstance()->isFileExist(path))
{
fileExist = true;
}
else
{
errorFilePath = path;
fileExist = false;
}
if (fileExist)
{
textField->setFontName(path);
}
else
{
auto label = Label::create();
label->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
textField->addChild(label);
}
}
auto widgetReader = WidgetReader::getInstance();
widgetReader->setPropsWithFlatBuffers(node, (Table*)options->widgetOptions());
@ -323,6 +343,8 @@ namespace cocostudio
Size contentSize(widgetOptions->size()->width(), widgetOptions->size()->height());
textField->setContentSize(contentSize);
}
}
Node* TextFieldReader::createNodeWithFlatBuffers(const flatbuffers::Table *textFieldOptions)

22
cocos/editor-support/cocostudio/WidgetReader/TextReader/TextReader.cpp
View File

@ -294,6 +294,7 @@ namespace cocostudio
bool touchScaleEnabled = options->touchScaleEnable();
label->setTouchScaleChangeEnabled(touchScaleEnabled);
std::string text = options->text()->c_str();
label->setString(text);
@ -315,12 +316,32 @@ namespace cocostudio
TextVAlignment v_alignment = (TextVAlignment)options->vAlignment();
label->setTextVerticalAlignment((TextVAlignment)v_alignment);
bool fileExist = false;
std::string errorFilePath = "";
auto resourceData = options->fontResource();
std::string path = resourceData->path()->c_str();
if (path != "")
{
if (FileUtils::getInstance()->isFileExist(path))
{
fileExist = true;
}
else
{
errorFilePath = path;
fileExist = false;
}
if (fileExist)
{
label->setFontName(path);
}
else
{
auto alert = Label::create();
alert->setString(__String::createWithFormat("%s missed", errorFilePath.c_str())->getCString());
label->addChild(alert);
}
}
auto widgetReader = WidgetReader::getInstance();
widgetReader->setPropsWithFlatBuffers(node, (Table*)options->widgetOptions());
@ -336,6 +357,7 @@ namespace cocostudio
Size contentSize(widgetOptions->size()->width(), widgetOptions->size()->height());
label->setContentSize(contentSize);
}
}
Node* TextReader::createNodeWithFlatBuffers(const flatbuffers::Table *textOptions)