void Framework::loadJoint( MyGUI::xml::ElementPtr node,RigidPtr parent )
{
ObjectFactory& factory = ObjectFactory::getSingleton();
string typeName = node->findAttribute("type");
JointPtr jpt = boost::dynamic_pointer_cast<Joint>(factory.createObject(typeName));
if(jpt)
{
if( parent )
{
jpt->mRigid[0] = parent;
}
addJoint(jpt);
jpt->load(node);
MyGUI::xml::ElementEnumerator ce = node->getElementEnumerator();
while(ce.next())
{
MyGUI::xml::ElementPtr child = ce.current();
if( child->getName() == "rigid" )
{
loadRigid(child, jpt);
}
break;
}
}
else
{
WARNING_LOG("Factory can't make "<<typeName);
}
}
void SkinItem::deserialization(MyGUI::xml::Element* _node, MyGUI::Version _version)
{
mName = _node->findAttribute("name");
mStates.destroyAllChilds();
mSeparators.destroyAllChilds();
mRegions.destroyAllChilds();
MyGUI::xml::ElementEnumerator nodes = _node->getElementEnumerator();
while (nodes.next())
{
MyGUI::xml::Element* node = nodes.current();
if (node->getName() == "PropertySet")
{
mPropertySet->deserialization(node, _version);
}
else if (node->getName() == "StateItem")
{
StateItem* item = mStates.createChild();
item->deserialization(node, _version);
}
else if (node->getName() == "SeparatorItem")
{
SeparatorItem* item = mSeparators.createChild();
item->deserialization(node, _version);
}
else if (node->getName() == "RegionItem")
{
RegionItem* item = mRegions.createChild();
item->deserialization(node, _version);
}
}
}
void Framework::loadRigid( MyGUI::xml::ElementPtr node,JointPtr parent )
{
ObjectFactory& factory = ObjectFactory::getSingleton();
RigidPtr rgp = boost::dynamic_pointer_cast<Rigid>(factory.createObject("Rigid"));
if(rgp)
{
rgp->load(node);
if( parent )
{
parent->mRigid[1] = rgp;
parent->linkRigid(parent->mRigid[0], parent->mRigid[1]);
}
MyGUI::xml::ElementEnumerator ce = node->getElementEnumerator();
while(ce.next())
{
MyGUI::xml::ElementPtr child = ce.current();
if( child->getName() == "joint" )
{
loadJoint( child,rgp );
}
}
}
else
{
WARNING_LOG("Factory can't make Rigid object!");
}
}
void EditorState::load()
{
SkinManager::getInstance().clear();
MyGUI::xml::Document doc;
if (doc.open(mFileName))
{
bool result = false;
MyGUI::xml::Element* root = doc.getRoot();
if (root->getName() == "Root")
{
MyGUI::xml::ElementEnumerator nodes = root->getElementEnumerator();
while (nodes.next("SkinManager"))
{
SkinManager::getInstance().deserialization(nodes.current(), MyGUI::Version());
result = true;
if (mFileName != mDefaultFileName)
RecentFilesManager::getInstance().addRecentFile(mFileName);
break;
}
}
if (!result)
{
/*MyGUI::Message* message =*/ MessageBoxManager::getInstance().create(
replaceTags("Error"),
replaceTags("MessageIncorrectFileFormat"),
MyGUI::MessageBoxStyle::IconError
| MyGUI::MessageBoxStyle::Yes);
mFileName = mDefaultFileName;
addUserTag("CurrentFileName", mFileName);
updateCaption();
}
}
else
{
/*MyGUI::Message* message =*/ MessageBoxManager::getInstance().create(
replaceTags("Error"),
doc.getLastError(),
MyGUI::MessageBoxStyle::IconError
| MyGUI::MessageBoxStyle::Yes);
}
ActionManager::getInstance().setChanges(false);
}
void SettingsManager::loadSettings(const MyGUI::UString& _fileName, bool _internal)
{
std::string _instance = "Editor";
MyGUI::xml::Document doc;
if (_internal)
{
MyGUI::DataStreamHolder data = MyGUI::DataManager::getInstance().getData(_fileName);
if (data.getData() != nullptr)
{
if (!doc.open(data.getData()))
{
MYGUI_LOGGING(LogSection, Error, _instance << " : " << doc.getLastError());
return;
}
}
}
else
{
if (!doc.open(_fileName))
{
MYGUI_LOGGING(LogSection, Error, _instance << " : " << doc.getLastError());
return;
}
}
MyGUI::xml::ElementPtr root = doc.getRoot();
if (!root || (root->getName() != "MyGUI"))
{
MYGUI_LOGGING(LogSection, Error, _instance << " : '" << _fileName << "', tag 'MyGUI' not found");
return;
}
std::string type;
if (root->findAttribute("type", type))
{
if (type == "Settings")
{
// берем детей и крутимся
MyGUI::xml::ElementEnumerator field = root->getElementEnumerator();
while (field.next())
loadSector(field.current());
}
}
}
void ExportManager::exportSkin(const MyGUI::UString& _fileName)
{
MyGUI::xml::Document doc;
MyGUI::xml::Element* root = doc.createRoot("Root");
SkinManager::getInstance().serialization(root, MyGUI::Version());
MyGUI::xml::Document docOut;
docOut.createDeclaration();
MyGUI::xml::Element* rootOut = docOut.createRoot("MyGUI");
rootOut->addAttribute("type", "Resource");
rootOut->addAttribute("version", "1.1");
MyGUI::xml::ElementEnumerator skins = root->getElementEnumerator();
while (skins.next())
convertSkin(skins.current(), rootOut->createChild("Resource"));
docOut.save(_fileName);
}
void DemoKeeper::loadFromFile(const std::string& _filename)
{
MyGUI::xml::Document doc;
if (!doc.open(_filename))
return;
MyGUI::xml::ElementPtr root = doc.getRoot();
if (root == nullptr || root->getName() != "AnimationGraph")
return;
MyGUI::xml::ElementEnumerator node = root->getElementEnumerator();
while (node.next())
{
if (node->getName() == "Node")
{
BaseAnimationNode* anim_node = createNode(node->findAttribute("type"), node->findAttribute("name"));
anim_node->deserialization(node.current());
}
else if (node->getName() == "Connections")
{
MyGUI::xml::ElementEnumerator conn = node->getElementEnumerator();
BaseAnimationNode* anim_node = getNodeByName(node.current()->findAttribute("node"));
if (anim_node)
{
while (conn.next("Connection"))
{
BaseAnimationNode* anim_node2 = getNodeByName(conn.current()->findAttribute("node"));
if (anim_node2)
{
//соединить точки в ноде
const std::string& from_point = conn.current()->findAttribute("from");
const std::string& to_point = conn.current()->findAttribute("to");
wraps::BaseGraphConnection* from_conn = anim_node->getConnectionByName(from_point, "EventOut");
if (!from_conn) from_conn = anim_node->getConnectionByName(from_point, "PositionOut");
if (!from_conn) from_conn = anim_node->getConnectionByName(from_point, "WeightOut");
wraps::BaseGraphConnection* to_conn = anim_node2->getConnectionByName(to_point, "EventIn");
if (!to_conn) to_conn = anim_node2->getConnectionByName(to_point, "PositionIn");
if (!to_conn) to_conn = anim_node2->getConnectionByName(to_point, "WeightIn");
if (from_conn && to_conn)
{
from_conn->addConnectionPoint(to_conn);
connectPoints(anim_node, anim_node2, from_point, to_point);
}
}
}
}
}
else if (node->getName() == "EditorData")
{
MyGUI::xml::ElementEnumerator item_data = node->getElementEnumerator();
while (item_data.next("Node"))
{
BaseAnimationNode* anim_node = getNodeByName(item_data.current()->findAttribute("name"));
if (anim_node)
{
anim_node->setCoord(MyGUI::IntCoord::parse(item_data.current()->findAttribute("coord")));
}
}
}
}
}
void ExportManager::convertSkin(MyGUI::xml::Element* _from, MyGUI::xml::Element* _to)
{
_to->addAttribute("type", "ResourceSkin");
_to->addAttribute("name", _from->findAttribute("name"));
MyGUI::xml::ElementEnumerator nodes = _from->getElementEnumerator();
while (nodes.next())
{
MyGUI::UString coordValue;
MyGUI::UString textureValue;
MyGUI::xml::Element* node = nodes.current();
if (node->getName() == "PropertySet")
{
MyGUI::xml::ElementEnumerator propertyNodes = node->getElementEnumerator();
while (propertyNodes.next("Property"))
{
MyGUI::xml::Element* propertyNode = propertyNodes.current();
std::string name;
if (propertyNode->findAttribute("name", name))
{
if (name == "Coord")
{
MyGUI::IntCoord coord = MyGUI::IntCoord::parse(propertyNode->getContent());
coordValue = coord.size().print();
}
else if (name == "Texture")
{
textureValue = propertyNode->getContent();
}
}
}
_to->addAttribute("size", coordValue);
_to->addAttribute("texture", textureValue);
break;
}
else if (node->getName() == "RegionItem")
{
bool regionVisible = true;
MyGUI::xml::ElementEnumerator regionNodes = node->getElementEnumerator();
while (regionNodes.next("PropertySet"))
{
MyGUI::xml::ElementEnumerator propertyNodes = regionNodes->getElementEnumerator();
while (propertyNodes.next("Property"))
{
MyGUI::xml::Element* propertyNode = propertyNodes.current();
std::string name;
if (propertyNode->findAttribute("name", name))
{
if (name == "Visible")
{
if (propertyNode->getContent() != "True")
regionVisible = false;
}
else if (name == "Enabled")
{
if (propertyNode->getContent() != "True")
regionVisible = false;
}
}
}
break;
}
if (!regionVisible)
continue;
MyGUI::xml::Element* region = _to->createChild("BasisSkin");
MyGUI::IntCoord regionCoord;
MyGUI::UString regionTypeValue;
MyGUI::UString regionOffsetValue;
MyGUI::UString alignValue;
regionNodes = node->getElementEnumerator();
while (regionNodes.next("PropertySet"))
{
MyGUI::xml::ElementEnumerator regionPropertyNode = regionNodes->getElementEnumerator();
while (regionPropertyNode.next("Property"))
{
std::string name;
if (regionPropertyNode->findAttribute("name", name))
{
if (name == "RegionType")
{
regionTypeValue = regionPropertyNode->getContent();
}
else if (name == "Position")
{
regionCoord = MyGUI::IntCoord::parse(regionPropertyNode->getContent());
regionOffsetValue = regionCoord.print();
}
else if (name == "Align")
{
alignValue = regionPropertyNode->getContent();
}
}
}
bool tileHor = true;
bool tileVer = true;
if (regionTypeValue == "TileRect Hor")
{
regionTypeValue = "TileRect";
tileVer = false;
}
else if (regionTypeValue == "TileRect Ver")
{
regionTypeValue = "TileRect";
tileHor = false;
}
region->addAttribute("type", regionTypeValue);
region->addAttribute("offset", regionOffsetValue);
region->addAttribute("align", alignValue);
MyGUI::xml::ElementEnumerator stateNodes = _from->getElementEnumerator();
while (stateNodes.next("StateItem"))
{
bool stateVisible = true;
MyGUI::xml::ElementEnumerator propertySetNodes = stateNodes->getElementEnumerator();
while (propertySetNodes.next("PropertySet"))
{
MyGUI::xml::ElementEnumerator statePropertyNode = propertySetNodes->getElementEnumerator();
while (statePropertyNode.next("Property"))
{
std::string name;
if (statePropertyNode->findAttribute("name", name))
{
if (name == "Visible")
{
if (statePropertyNode->getContent() != "True")
stateVisible = false;
}
}
}
break;
}
if (!stateVisible)
continue;
MyGUI::xml::Element* state = region->createChild("State");
MyGUI::UString stateOffsetValue;
MyGUI::UString textColourValue;
MyGUI::UString textShiftValue;
propertySetNodes = stateNodes->getElementEnumerator();
while (propertySetNodes.next("PropertySet"))
{
MyGUI::xml::ElementEnumerator propertyNodes = propertySetNodes->getElementEnumerator();
while (propertyNodes.next("Property"))
{
MyGUI::xml::Element* propertyNode = propertyNodes.current();
std::string name;
if (propertyNode->findAttribute("name", name))
{
if (name == "Position")
{
MyGUI::IntCoord coord = regionCoord + MyGUI::IntPoint::parse(propertyNode->getContent());
stateOffsetValue = coord.print();
}
else if (name == "TextColour")
{
textColourValue = propertyNode->getContent();
}
else if (name == "TextShift")
{
textShiftValue = propertyNode->getContent();
}
}
}
break;
}
MyGUI::UString stateNameValue = stateNodes->findAttribute("name");
state->addAttribute("name", convertStateName(stateNameValue));
if (regionTypeValue == "SimpleText" || regionTypeValue == "EditText")
{
state->addAttribute("colour", textColourValue);
state->addAttribute("shift", textShiftValue);
}
else
{
state->addAttribute("offset", stateOffsetValue);
if (stateNameValue == "Normal")
{
if (regionTypeValue == "TileRect")
{
MyGUI::xml::Element* prop = state->createChild("Property");
prop->addAttribute("key", "TileSize");
prop->addAttribute("value", regionCoord.size().print());
prop = state->createChild("Property");
prop->addAttribute("key", "TileH");
prop->addAttribute("value", MyGUI::utility::toString(tileHor));
prop = state->createChild("Property");
prop->addAttribute("key", "TileV");
prop->addAttribute("value", MyGUI::utility::toString(tileVer));
}
}
}
}
break;
}
}
}
}
