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 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::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 MYGUIManager::setupResources()
{
MyGUI::xml::Document doc;
if ( !_platform || !doc.open(_resourcePathFile) ) doc.getLastError();
MyGUI::xml::ElementPtr root = doc.getRoot();
if ( root==nullptr || root->getName()!="Paths" ) return;
MyGUI::xml::ElementEnumerator node = root->getElementEnumerator();
while ( node.next() )
{
if ( node->getName()=="Path" )
{
bool root = false, recursive = false;
if (!node->findAttribute("root").empty())
{
root = MyGUI::utility::parseBool( node->findAttribute("root") );
if ( root ) _rootMedia = node->getContent();
}
if (!node->findAttribute("recursive").empty())
{
recursive = MyGUI::utility::parseBool(node->findAttribute("recursive"));
}
_platform->getDataManagerPtr()->addResourceLocation(node->getContent(), recursive);
}
}
}
void WidgetTypes::loadValues(MyGUI::xml::ElementPtr _node, const std::string& _file, MyGUI::Version _version)
{
MyGUI::xml::ElementEnumerator widgets = _node->getElementEnumerator();
while (widgets.next("Value"))
{
std::string name = widgets->findAttribute("name");
PossibleValue* possible_value = getPossibleValue(name);
// тип мерджа переменных
std::string merge = widgets->findAttribute("merge");
// дополняем своими данными, по дефолту
if (merge == "add")
{
}
// удаляем и добавляем свои
else if (merge == "replace")
{
possible_value->values.clear();
}
// берем детей и крутимся
MyGUI::xml::ElementEnumerator field = widgets->getElementEnumerator();
while (field.next())
{
std::string key, value;
if (field->getName() == "Property")
{
if (!field->findAttribute("key", key))
continue;
possible_value->values.push_back(MyGUI::LanguageManager::getInstance().replaceTags(key));
}
}
}
}
void FadeNodeAnimator::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
MyGUI::xml::ElementEnumerator node = _node->getElementEnumerator();
while (node.next("Property"))
{
const std::string& key = node->findAttribute("key");
const std::string& value = node->findAttribute("value");
if (key == "FadeDuration") mFadeDuration = MyGUI::utility::parseFloat(value);
else if (key == "FadeType") mFadeType = MyGUI::utility::parseInt(value);//FIXME
}
}
void WobbleNodeAnimator::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
MyGUI::xml::ElementEnumerator node = _node->getElementEnumerator();
while (node.next("Property"))
{
const std::string& key = node->findAttribute("key");
const std::string& value = node->findAttribute("value");
if (key == "DragStrength") mDragStrength = MyGUI::utility::parseFloat(value);
else if (key == "ResizeStrength") mResizeStrength = MyGUI::utility::parseFloat(value);
}
}
void RTTLayer::deserialization(xml::ElementPtr _node, Version _version)
{
Base::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
while (propert.next("Property"))
{
const std::string& key = propert->findAttribute("key");
const std::string& value = propert->findAttribute("value");
if (key == "TextureSize") setTextureSize(utility::parseValue<IntSize>(value));
if (key == "TextureName") setTextureName(value);
}
}
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);
}
MyGUI::UString EditorState::convertProjectName(const MyGUI::UString& _fileName)
{
size_t pos = mFileName.find_last_of("\\/");
MyGUI::UString shortName = pos == MyGUI::UString::npos ? mFileName : mFileName.substr(pos + 1);
addUserTag("ResourceName", shortName);
size_t index = _fileName.find("|");
if (index == MyGUI::UString::npos)
return _fileName;
MyGUI::UString fileName = _fileName.substr(0, index);
MyGUI::UString itemIndexName = _fileName.substr(index + 1);
size_t itemIndex = MyGUI::utility::parseValue<size_t>(itemIndexName);
MyGUI::xml::Document doc;
if (!doc.open(fileName))
return _fileName;
MyGUI::xml::ElementPtr root = doc.getRoot();
if ((nullptr == root) || (root->getName() != "MyGUI"))
return _fileName;
if (root->findAttribute("type") == "Resource")
{
// берем детей и крутимся
MyGUI::xml::ElementEnumerator element = root->getElementEnumerator();
while (element.next("Resource"))
{
if (element->findAttribute("type") == "ResourceLayout")
{
if (itemIndex == 0)
{
// поменять на теги
std::string resourceName = element->findAttribute("name");
addUserTag("ResourceName", resourceName);
return MyGUI::utility::toString(fileName, " [", resourceName, "]");
}
else
{
itemIndex --;
}
}
}
}
return _fileName;
}
ResourceItemInfo::ResourceItemInfo(MyGUI::xml::ElementEnumerator _node, MyGUI::Version _version) :
IResource(_node, _version)
{
MyGUI::xml::ElementEnumerator node = _node->getElementEnumerator();
while (node.next()) {
if (node->getName() == "Name") mItemName = node->getContent();
else if (node->getName() == "Description") mItemDescription = node->getContent();
else if (node->getName() == "Image") mItemResourceImage = node->findAttribute("RefID");
};
}
//--------------------------------------------------------------------------------
void System::Setup()
{
MyGUI::xml::Document doc;
if (!doc.open(std::string("resources.xml")))
doc.getLastError();
MyGUI::xml::ElementPtr root = doc.getRoot();
if (root == nullptr || root->getName() != "Paths")
return;
MyGUI::xml::ElementEnumerator node = root->getElementEnumerator();
while (node.next())
{
if (node->getName() == "Path")
{
bool root = false;
if (node->findAttribute("root") != "")
{
root = MyGUI::utility::parseBool(node->findAttribute("root"));
if (root) mRootMedia = node->getContent();
}
mPlatform->getDataManagerPtr()->addResourceLocation(node->getContent(), false);
}
}
}
void ResourceSDLPointer::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
Base::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator info = _node->getElementEnumerator();
while (info.next())
{
if (info->getName() == "Property")
{
const std::string& key = info->findAttribute("key");
if (key == "SourceFile")
{
//std::string path = MyGUI::DataManager::getInstance().getDataPath(info->getContent());
//mCursorType = (size_t)LoadCursorFromFileA(path.c_str());
}
else if (key == "SourceSystem")
{
std::string value = info->getContent();
if (value == "SDL_SYSTEM_CURSOR_ARROW")
mCursorType = SDL_SYSTEM_CURSOR_ARROW;
else if (value == "SDL_SYSTEM_CURSOR_IBEAM")
mCursorType = SDL_SYSTEM_CURSOR_IBEAM;
else if (value == "SDL_SYSTEM_CURSOR_WAIT")
mCursorType = SDL_SYSTEM_CURSOR_WAIT;
else if (value == "SDL_SYSTEM_CURSOR_CROSSHAIR")
mCursorType = SDL_SYSTEM_CURSOR_CROSSHAIR;
else if (value == "SDL_SYSTEM_CURSOR_SIZENWSE")
mCursorType = SDL_SYSTEM_CURSOR_SIZENWSE;
else if (value == "SDL_SYSTEM_CURSOR_SIZENESW")
mCursorType = SDL_SYSTEM_CURSOR_SIZENESW;
else if (value == "SDL_SYSTEM_CURSOR_SIZEWE")
mCursorType = SDL_SYSTEM_CURSOR_SIZEWE;
else if (value == "SDL_SYSTEM_CURSOR_SIZENS")
mCursorType = SDL_SYSTEM_CURSOR_SIZENS;
else if (value == "SDL_SYSTEM_CURSOR_SIZEALL")
mCursorType = SDL_SYSTEM_CURSOR_SIZEALL;
else if (value == "SDL_SYSTEM_CURSOR_NO")
mCursorType = SDL_SYSTEM_CURSOR_NO;
else if (value == "SDL_SYSTEM_CURSOR_HAND")
mCursorType = SDL_SYSTEM_CURSOR_HAND;
}
}
}
}
void BaseManager::setupResources()
{
MyGUI::xml::Document doc;
if (!doc.open(std::string("resources.xml")))
doc.getLastError();
MyGUI::xml::ElementPtr root = doc.getRoot();
if (root == nullptr || root->getName() != "Paths")
return;
MyGUI::xml::ElementEnumerator node = root->getElementEnumerator();
while (node.next())
{
if (node->getName() == "Path")
{
if (node->findAttribute("root") != "")
{
bool root = MyGUI::utility::parseBool(node->findAttribute("root"));
if (root)
mRootMedia = node->getContent();
}
addResourceLocation(node->getContent(), false);
}
}
addResourceLocation(getRootMedia() + "/Common/Base");
}
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 HotkeyManager::_load( MyGUI::xml::ElementPtr root,const string xml )
{
if( root == nullptr || root->getName() != "HKS" )
{
WARNING_LOG("bad Hotkey config file "<<xml);
return;
}
MyGUI::xml::ElementEnumerator node = root->getElementEnumerator();
while( node.next() )
{
if( node->getName() == "hotkey" )
{
hotkey hk;
if( !node->findAttribute("name",hk.mName) )
{
WARNING_LOG("Hotkey config file "<<xml<<" invalid hotkey node");
continue;
}
node->findAttribute("caption",hk.mCaption);
node->findAttribute("tip",hk.mTip);
node->findAttribute("key",hk.mHotkey);
hk.mSHotkey = getStandardHotkeyName(hk.mHotkey);
mHotkeys.push_back( hk );
//设置对应Widget的User string，便于其显示出正常的热键
setWidgetHotkey( hk.mName,hk.mHotkey );
}
}
}
void OverlappedLayer::deserialization(xml::ElementPtr _node, Version _version)
{
mName = _node->findAttribute("name");
if (_version >= Version(1, 2))
{
MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
while (propert.next("Property"))
{
const std::string& key = propert->findAttribute("key");
const std::string& value = propert->findAttribute("value");
if (key == "Pick") mIsPick = utility::parseValue<bool>(value);
}
}
else
{
mIsPick = utility::parseBool(_version < Version(1, 0) ? _node->findAttribute("peek") : _node->findAttribute("pick"));
}
}
void RTTLayer::deserialization(xml::ElementPtr _node, Version _version)
{
Base::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator propert = _node->getElementEnumerator();
while (propert.next("Property"))
{
const std::string& key = propert->findAttribute("key");
const std::string& value = propert->findAttribute("value");
if (key == "TextureSize") setTextureSize(utility::parseValue<IntSize>(value));
#ifdef MYGUI_OGRE_PLATFORM
else if (key == "Entity") setEntity(value);
else if (key == "Material") setMaterial(value);
else if (key == "SceneManager") setSceneManager(value);
else if (key == "Camera") setCamera(value);
#endif
}
}
void SettingsSector::deserialization(MyGUI::xml::Element* _node, MyGUI::Version _version)
{
mName = _node->getName();
MyGUI::xml::ElementEnumerator prop = _node->getElementEnumerator();
while (prop.next("Property"))
{
std::string key;
if (!prop->findAttribute("key", key))
continue;
std::string value;
if (!prop->findAttribute("value", value))
continue;
mProperties[key] = value;
}
}
void ScalingLayer::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
MyGUI::OverlappedLayer::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator info = _node->getElementEnumerator();
while (info.next())
{
if (info->getName() == "Property")
{
const std::string& key = info->findAttribute("key");
const std::string& value = info->findAttribute("value");
if (key == "Size")
{
mViewSize = MyGUI::IntSize::parse(value);
}
}
}
}
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 ResourceImageSetPointerFix::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
Base::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator info = _node->getElementEnumerator();
while (info.next("Property"))
{
const std::string& key = info->findAttribute("key");
const std::string& value = info->findAttribute("value");
if (key == "Point")
mPoint = MyGUI::IntPoint::parse(value);
else if (key == "Size")
mSize = MyGUI::IntSize::parse(value);
else if (key == "Rotation")
mRotation = MyGUI::utility::parseInt(value);
else if (key == "Resource")
mImageSet = MyGUI::ResourceManager::getInstance().getByName(value)->castType<MyGUI::ResourceImageSet>();
}
}
void PanelControllers::loadControllerTypes(MyGUI::xml::ElementPtr _node, const std::string& _file, MyGUI::Version _version)
{
MyGUI::xml::ElementEnumerator controller = _node->getElementEnumerator();
while (controller.next("Controller"))
{
MyGUI::MapString controllerProperties;
std::string name = controller->findAttribute("name");
mControllerName->addItem(name);
MyGUI::xml::ElementEnumerator prop = controller->getElementEnumerator();
while (prop.next("Property"))
controllerProperties[prop->findAttribute("key")] = prop->findAttribute("type");
mControllersProperties[name] = controllerProperties;
}
}
void ResourceW32Pointer::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
Base::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator info = _node->getElementEnumerator();
while (info.next())
{
if (info->getName() == "Property")
{
const std::string& key = info->findAttribute("key");
if (key == "SourceFile")
{
std::string path = MyGUI::DataManager::getInstance().getDataPath(info->getContent());
mHandle = (size_t)LoadCursorFromFileA(path.c_str());
}
else if (key == "SourceSystem")
{
std::string value = info->getContent();
if (value == "IDC_ARROW")
mHandle = (size_t)::LoadCursor(NULL, IDC_ARROW);
else if (value == "IDC_IBEAM")
mHandle = (size_t)::LoadCursor(NULL, IDC_IBEAM);
else if (value == "IDC_WAIT")
mHandle = (size_t)::LoadCursor(NULL, IDC_WAIT);
else if (value == "IDC_CROSS")
mHandle = (size_t)::LoadCursor(NULL, IDC_CROSS);
else if (value == "IDC_UPARROW")
mHandle = (size_t)::LoadCursor(NULL, IDC_UPARROW);
else if (value == "IDC_SIZE")
mHandle = (size_t)::LoadCursor(NULL, IDC_SIZE);
else if (value == "IDC_ICON")
mHandle = (size_t)::LoadCursor(NULL, IDC_ICON);
else if (value == "IDC_SIZENWSE")
mHandle = (size_t)::LoadCursor(NULL, IDC_SIZENWSE);
else if (value == "IDC_SIZENESW")
mHandle = (size_t)::LoadCursor(NULL, IDC_SIZENESW);
else if (value == "IDC_SIZEWE")
mHandle = (size_t)::LoadCursor(NULL, IDC_SIZEWE);
else if (value == "IDC_SIZENS")
mHandle = (size_t)::LoadCursor(NULL, IDC_SIZENS);
else if (value == "IDC_SIZEALL")
mHandle = (size_t)::LoadCursor(NULL, IDC_SIZEALL);
else if (value == "IDC_NO")
mHandle = (size_t)::LoadCursor(NULL, IDC_NO);
else if (value == "IDC_HAND")
mHandle = (size_t)::LoadCursor(NULL, IDC_HAND);
else if (value == "IDC_APPSTARTING")
mHandle = (size_t)::LoadCursor(NULL, IDC_APPSTARTING);
else if (value == "IDC_HELP")
mHandle = (size_t)::LoadCursor(NULL, IDC_HELP);
}
}
}
}
void PropertiesPanelView::load(MyGUI::xml::ElementEnumerator _field)
{
MyGUI::xml::ElementEnumerator field = _field->getElementEnumerator();
VectorPanel::iterator iter = mPanels.begin();
while (field.next()) {
std::string key, value;
if (field->getName() == "Property")
{
if (false == field->findAttribute("key", key)) continue;
if (false == field->findAttribute("value", value)) continue;
if ((key == MyGUI::utility::toString("Panel"/*, i*/,"Minimized")) && (iter != mPanels.end()))
{
(*iter)->getPanelCell()->setMinimized(MyGUI::utility::parseBool(value));
++iter;
}
}
}
}
//===================================================================================
bool EditorState::isNeedSolutionLoad(MyGUI::xml::ElementEnumerator _field)
{
MyGUI::xml::ElementEnumerator field = _field->getElementEnumerator();
while (field.next())
{
std::string key, value;
if (field->getName() == "Property")
{
if (!field->findAttribute("key", key)) continue;
if (!field->findAttribute("value", value)) continue;
if (key == "MetaSolutionName")
{
return !value.empty();
}
}
}
return false;
}
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 WidgetTypes::loadWidgets(MyGUI::xml::ElementPtr _node, const std::string& _file, MyGUI::Version _version)
{
MyGUI::xml::ElementEnumerator widgets = _node->getElementEnumerator();
while (widgets.next("Widget"))
{
WidgetStyle* widget_type = getWidgetType(widgets->findAttribute("name"));
widget_type->internalType = widgets->findAttribute("internal") == "true";
// берем детей и крутимся
MyGUI::xml::ElementEnumerator field = widgets->getElementEnumerator();
while (field.next())
{
std::string key, value, group;
if (field->getName() == "Property")
{
if (!field->findAttribute("key", key))
continue;
if (!field->findAttribute("value", value))
continue;
field->findAttribute("group", group);
if (key == "Skin")
{
std::string button_name = field->findAttribute("name");
if (button_name.empty())
button_name = value;
if (group.empty())
group = DEFAULT_GOROUP_NAME;
mSkinGroups[group].push_back(SkinInfo(value, widget_type->name, button_name));
widget_type->skin.push_back(value);
}
else if (key == "DefaultSkin")
widget_type->default_skin = value;
else if (key == "Parent")
widget_type->parent = MyGUI::utility::parseBool(value);
else if (key == "Child")
widget_type->child = MyGUI::utility::parseBool(value);
else if (key == "Resizeable")
widget_type->resizeable = MyGUI::utility::parseBool(value);
else if (key == "ItemManager")
widget_type->many_items = MyGUI::utility::parseBool(value);
else if (key == "Base")
widget_type->base = value;
}
else if (field->getName() == "Parameter")
{
if (!field->findAttribute("key", key))
continue;
if (!field->findAttribute("value", value))
continue;
widget_type->parameter.push_back(MyGUI::PairString(key, value));
}
else if (field->getName() == "TemplateData")
{
if (!field->findAttribute("key", key))
continue;
if (!field->findAttribute("value", value))
continue;
widget_type->templateData.push_back(MyGUI::PairString(key, value));
}
else if (field->getName() == "ParameterData")
{
if (!field->findAttribute("key", key))
continue;
if (!field->findAttribute("value", value))
continue;
widget_type->parameterData.push_back(MyGUI::PairString(key, value));
}
}
if (widget_type->base.empty() && widget_type->name != "Widget")
widget_type->base = "Widget";
}
updateDeep();
}
void HotKeyManager::loadXml(MyGUI::xml::ElementPtr _node, const std::string& _file, MyGUI::Version _version)
{
MyGUI::xml::ElementEnumerator node = _node->getElementEnumerator();
while (node.next("Command"))
{
HotKeyCommand command;
MyGUI::xml::ElementEnumerator nodeCommand = node->getElementEnumerator();
while (nodeCommand.next())
{
if (nodeCommand->getName() == "Name")
{
command.setCommand(nodeCommand->getContent());
}
/*else if (nodeCommand->getName() == "Pressed")
{
command.setPressed(MyGUI::utility::parseValue<bool>(nodeCommand->getContent()));
}*/
else if (nodeCommand->getName() == "KeyCode")
{
MapKeys::const_iterator item = mKeyNames.find(nodeCommand->getContent());
if (item != mKeyNames.end())
{
command.setKey((*item).second);
}
else
{
// log
}
}
else if (nodeCommand->getName() == "Modifier")
{
command.setShift(nodeCommand->getContent().find("Shift") != std::string::npos);
command.setControl(nodeCommand->getContent().find("Control") != std::string::npos);
}
}
addCommand(command);
}
}
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;
}
}
}
}