Progress::Progress(void) { Logger::DiagnosticOut() << "Loading progress record\n"; //Load XML TiXmlDocument doc = TiXmlDocument("Progress.xml"); doc.LoadFile(); TiXmlElement* root = doc.FirstChildElement("Progress"); if(root) { TiXmlElement* record = root->FirstChildElement("Record"); int record_number = 0; while(record) { std::string filename = ""; bool completed = false; bool error = false; error |= (record->QueryValueAttribute("Filename", &filename) != TIXML_SUCCESS); error |= (record->QueryValueAttribute("Completed", &completed) != TIXML_SUCCESS); if(error) Logger::DiagnosticOut() << "Error parsing record number: " << record_number << ". Possible data: Filename:" << filename << ", completed: " << completed << "\n"; else { ProgressRecord pr; pr.completed = completed; progress_[filename] = pr; } record = record->NextSiblingElement("Record"); record_number++; } } }
// Component transform void CEntityBuilder::buildTransform (TiXmlElement *pNode, Entity* e, Resources *pResource){ TiXmlElement *pChar = pNode->FirstChildElement("position"); if ( pChar) { int x(0), y(0); if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "x", &x) && TIXML_SUCCESS == pChar->QueryValueAttribute( "y", &y) ) { e->addComponent(new Transform((float) x, (float) y)); return; } } LOG2ERR<<"Bad xml description for [Tranform] component\n"; throw "Bad xml description for [Tranform] component"; }
void CEntityBuilder::buildComponentResourcesImage( TiXmlElement *pNode, Entity *e, Resources *pResource ){ TiXmlElement *pChar = pNode->FirstChildElement("image"); if ( pChar) { std::string alias; if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "alias", &alias)){ BVisual *image = pResource->makeImage( alias); addCommonAttributes(pNode, pResource, image); // std::string gui; // if ( TIXML_SUCCESS == pNode->QueryValueAttribute( "gui", &gui)) { // if (gui == "true") { // image->setGUI(true); // } else { // image->setGUI(false); // } // } // std::string center; // if ( TIXML_SUCCESS == pNode->QueryValueAttribute( "center", ¢er)) { // if (center == "false") { // image->setCenter(0, 0); // } // } // int zOrder; // if ( TIXML_SUCCESS == pNode->QueryValueAttribute( "z-order", &zOrder)) { // image->setZOrder(zOrder); // } e->addComponent( image); return; } } LOG2ERR<<"Bad kind for [Resources/Image] component\n"; throw "Bad kind for [Resources/Image] component"; }
void ObjectLibrary::loadDatabase(string filename) { TiXmlDocument doc(filename); if (!doc.LoadFile()) { Error::addMessage(Error::FILE_NOT_FOUND, LIBGENS_LIBRARY_ERROR_FILE + filename); return; } TiXmlHandle hDoc(&doc); TiXmlElement* pElem; TiXmlHandle hRoot(0); pElem=hDoc.FirstChildElement().Element(); if (!pElem) { Error::addMessage(Error::EXCEPTION, LIBGENS_LIBRARY_ERROR_FILE_ROOT); return; } pElem=pElem->FirstChildElement(); for(pElem; pElem; pElem=pElem->NextSiblingElement()) { string entry_name=""; string category_name=""; string folder_name=""; entry_name = pElem->ValueStr(); pElem->QueryValueAttribute(LIBGENS_LIBRARY_NAME_ATTRIBUTE, &category_name); pElem->QueryValueAttribute(LIBGENS_LIBRARY_FOLDER_ATTRIBUTE, &folder_name); if ((entry_name==LIBGENS_LIBRARY_ENTRY) && category_name.size() && folder_name.size()) { loadCategory(category_name, folder_name); } } }
/* -------------------------------------------------------------------------------------------------- - get a text from file -------------------------------------------------------------------------------------------------- */ std::map<long, std::string> MapInfoXmlReader::LoadTextFile(const std::string &Filename) { std::map<long, std::string> res; TiXmlDocument doc(Filename); if (!doc.LoadFile()) return res; TiXmlHandle hDoc(&doc); TiXmlElement* pElem; // block: text attributes { pElem=hDoc.FirstChildElement().Element(); // should always have a valid root but handle gracefully if it does if (!pElem) return res; // for each text pElem=pElem->FirstChildElement("quotes"); pElem=pElem->FirstChildElement(); for(;pElem; pElem=pElem->NextSiblingElement()) { long ctid = -1; pElem->QueryValueAttribute("id", &ctid); if(pElem->FirstChild()) res[ctid] = pElem->FirstChild()->Value(); } } return res; }
// configure the design matrix from an xml element bool RtDesignMatrix::configure(TiXmlElement *designEle, const RtConfig &config) { string name; TiXmlElement *optionElmt; bool ret = true; // iterate over options for (TiXmlNode *option = 0; (option = designEle->IterateChildren("option", option));) { if (option->Type() != TiXmlNode::ELEMENT) continue; optionElmt = (TiXmlElement*) option; if (TIXML_SUCCESS != optionElmt->QueryValueAttribute("name", &name)) { continue; } // build the map between atrribute names and values map<string, string> attr = RtConfig::getAttributeMap(*optionElmt); // figure out which option we have and process it if (!processOption(name, optionElmt->GetText(), attr)) { ret = false; } } return ret; }
EditorLevelDatabase::EditorLevelDatabase(string filename) { TiXmlDocument doc(filename); if (!doc.LoadFile()) { LibGens::Error::addMessage(LibGens::Error::FILE_NOT_FOUND, (string)SONICGLVL_DATABASE_ERROR_FILE + filename); return; } TiXmlHandle hDoc(&doc); TiXmlElement* pElem; TiXmlHandle hRoot(0); pElem=hDoc.FirstChildElement().Element(); if (!pElem) { LibGens::Error::addMessage(LibGens::Error::EXCEPTION, SONICGLVL_DATABASE_ERROR_FILE_ROOT); return; } pElem=pElem->FirstChildElement(); for(pElem; pElem; pElem=pElem->NextSiblingElement()) { string entry_name=""; string level_name=""; string geometry_name=""; string layout_merge_name=""; string slot_name=""; string game_name=""; entry_name = pElem->ValueStr(); pElem->QueryValueAttribute(SONICGLVL_DATABASE_NAME_ATTRIBUTE, &level_name); pElem->QueryValueAttribute(SONICGLVL_DATABASE_GEOMETRY_ATTRIBUTE, &geometry_name); pElem->QueryValueAttribute(SONICGLVL_DATABASE_MERGE_ATTRIBUTE, &layout_merge_name); pElem->QueryValueAttribute(SONICGLVL_DATABASE_SLOT_ATTRIBUTE, &slot_name); pElem->QueryValueAttribute(SONICGLVL_DATABASE_GAME_ATTRIBUTE, &game_name); if (!game_name.size()) { game_name = LIBGENS_LEVEL_GAME_STRING_GENERATIONS; } if ((entry_name==SONICGLVL_DATABASE_ENTRY) && level_name.size() && geometry_name.size()) { EditorLevelEntry *entry=new EditorLevelEntry(level_name, geometry_name, layout_merge_name, slot_name, game_name); entries.push_back(entry); } } }
void CEntityBuilder::buildComponentResourcesText( TiXmlElement *pNode, Entity *e, Resources *pResource){ std::string text, police; int r(0), g(0), b(0), a(0); TiXmlElement *pFontAttr = pNode->FirstChildElement( "text"); if ( pFontAttr){ // Warning : only text is accepted here! no formatted text like <b>hello</b> text = pFontAttr->GetText(); } pFontAttr = pNode->FirstChildElement( "police"); if( pFontAttr){ pFontAttr->QueryValueAttribute( "name", &police); } pFontAttr = pNode->FirstChildElement( "color"); if ( pFontAttr){ pFontAttr->QueryValueAttribute( "r", &r); pFontAttr->QueryValueAttribute( "g", &g); pFontAttr->QueryValueAttribute( "b", &b); pFontAttr->QueryValueAttribute( "a", &a); } if ( !text.empty() && !police.empty()){ BVisual *textVis = NULL; // Color is defined if ( pFontAttr) { textVis = pResource->makeText( text, police, CPColor(r, g, b, a)); } else { textVis = pResource->makeText( text, police); } addCommonAttributes(pNode, pResource, textVis); // int zOrder; // if ( TIXML_SUCCESS == pNode->QueryValueAttribute( "z-order", &zOrder)) { // textVis->setZOrder(zOrder); // } e->addComponent(textVis); } }
// Component Scriptable void CEntityBuilder::buildScriptable( TiXmlElement *pNode, Entity *e, Resources*){ TiXmlElement *pChar = pNode->FirstChildElement("script"); std::string script; if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "name", &script)){ e->addComponent( new Scriptable( script)); return; } LOG2ERR<<"Bad xml description for [Scriptable] component\n"; throw "Bad xml description for [Scriptable] component"; }
void CEntityBuilder::buildComponentResourcesAudio( TiXmlElement *pNode, Entity *e, Resources *pResource ){ TiXmlElement *pChar = pNode->FirstChildElement("audio"); if ( pChar) { std::string alias; if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "alias", &alias)){ bool looping = false; std::string loop; if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "loop", &loop)) { if (loop == "true") { looping = true; } } Audio *audio = pResource->makeAudio( alias, looping); e->addComponent( audio); return; } } LOG2ERR<<"Bad kind for [Resources/Audio] component\n"; throw "Bad kind for [Resources/Audio] component"; }
void CEntityBuilder::BuildEntity( TiXmlElement *pParent, EntityManager &em, Resources *pResources){ // Create entity (new id) Entity *ent = em.createEntity(); if ( !ent){ LOG2ERR<<"Could not create entity\n"; throw "Could not create entity"; } TiXmlElement* pChilds = pParent->FirstChildElement( "tags"); if ( pChilds ){ // Add tags for(pChilds=pChilds->FirstChildElement( "tag" ); pChilds; pChilds = pChilds->NextSiblingElement() ){ std::string name; if ( TIXML_SUCCESS == pChilds->QueryValueAttribute( "name", &name)) { std::string unique; bool isUnique(false); if ( TIXML_SUCCESS == pChilds->QueryValueAttribute( "unique", &unique) ){ isUnique = ( unique=="true"); } em.tagEntity( ent, name, isUnique); } } } // Add components pChilds = pParent->FirstChildElement( "components"); if ( pChilds ){ for( pChilds=pChilds->FirstChildElement( "component" ); pChilds; pChilds = pChilds->NextSiblingElement() ){ std::string type; if ( TIXML_SUCCESS == pChilds->QueryValueAttribute( "type", &type)){ //LOG2 <<name<<"\n"; buildComponents(pChilds, type, ent, pResources); } else { LOG2ERR<<"Attribute [type] not found\n"; } } } }
// Component Animated void CEntityBuilder::buildAnimated(TiXmlElement *pNode, Entity *e, Resources*){ TiXmlElement *pChar = pNode->FirstChildElement("image"); if ( pChar ){ std::string name; if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "name", &name)){ e->addComponent( new Animated( name)); return; } } LOG2ERR<<"Bad xml description for [Animated] component\n"; throw "Bad xml description for [Animated] component"; }
// Component Character void CEntityBuilder::buildCharacter ( TiXmlElement *pNode, Entity *e, Resources*){ if ( pNode ){ // Check nickname to identify entity std::string nickname ("XXX"); pNode->QueryValueAttribute( "nickname", &nickname); // Parse stats TiXmlElement *pChar = pNode->FirstChildElement("stats"); if ( pChar ){ Character *character = new Character( nickname); for(; pChar; pChar= pChar->NextSiblingElement()){ std::string name; long value(0); if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "name", &name) && TIXML_SUCCESS == pChar->QueryValueAttribute( "value", &value)){ buildStats( character, name, CVariant( value)); } } e->addComponent( character); } } }
// Component Mobile void CEntityBuilder::buildMobile(TiXmlElement *pNode, Entity *e, Resources*){ // Build Mobile with arguments TiXmlElement *pChar = pNode->FirstChildElement("position"); if ( pChar ){ float x(0.f), y(0.f); if ( TIXML_SUCCESS == pChar->QueryValueAttribute( "x", &x) && TIXML_SUCCESS == pChar->QueryValueAttribute( "y", &y) ) { e->addComponent( new Mobile(x, y)); return; } } // Else, build Mobile without argument e->addComponent( new Mobile); }
string GetElementAttributeByTagName(TiXmlElement* root,const string& name, const string& attribute) { if (root == NULL) return string(""); string strValue(""); TiXmlElement* toFind = GetElementByTagName(root,name); if (toFind != NULL) { toFind->QueryValueAttribute(attribute,&strValue); } return strValue; }
void PlayerAI::LoadBindings() { TiXmlDocument doc("Controls.xml"); bool xml_error = false; if(doc.LoadFile()) { TiXmlElement* root = doc.FirstChildElement("Controls"); if(root) { TiXmlElement* player = root->FirstChildElement("PlayerBindings"); while(player) { int player_id = 0; if(player->QueryIntAttribute("id", &player_id) == TIXML_SUCCESS) { TiXmlElement* ic = player->FirstChildElement("InputConfig"); while(ic) { std::string action_string; if(ic->QueryValueAttribute("Action", &action_string) != TIXML_SUCCESS) { Logger::ErrorOut() << "Error reading action attribute, continuing\n"; continue; } std::string binding_type_string; if(ic->QueryValueAttribute("BindingType", &binding_type_string) != TIXML_SUCCESS) { Logger::ErrorOut() << "Error reading binding attribute, continuing\n"; continue; } Action::Enum action = Action::FromStr(action_string); BindingType::Enum binding_type = BindingType::FromStr(binding_type_string); TiXmlElement* binding = ic->FirstChildElement("Binding"); if(binding) { switch(binding_type) { case BindingType::KeyboardBinding: { int key = 0; if(binding->QueryValueAttribute("Key", &key) == TIXML_SUCCESS) { bindings[player_id].push_back(InputConfig(binding_type, Binding((SDLKey)key), action)); } else { Logger::ErrorOut() << "Missing Key attribute, continuing\n"; continue; } } break; case BindingType::JoystickButtonBinding: { int joystick_index = 0; int joystick_button_index = 0; if(binding->QueryValueAttribute("JoystickIndex", &joystick_index) == TIXML_SUCCESS && binding->QueryValueAttribute("JoystickButton", &joystick_button_index) == TIXML_SUCCESS) { bindings[player_id].push_back(InputConfig(binding_type, Binding(JoystickButton::Create(joystick_index, joystick_button_index)), action)); } else { Logger::ErrorOut() << "Missing JoystickIndex or JoystickButton atttribute, continuing\n"; } } break; case BindingType::JoystickAxisBinding: { int joystick_index = 0; int joystick_axis_index = 0; if(binding->QueryValueAttribute("JoystickIndex", &joystick_index) == TIXML_SUCCESS && binding->QueryValueAttribute("JoystickAxis", &joystick_axis_index) == TIXML_SUCCESS) { bindings[player_id].push_back(InputConfig(binding_type, Binding(JoystickAxis::Create(joystick_index, joystick_axis_index)), action)); } else { Logger::ErrorOut() << "Missing JoystickIndex or JoystickAxis atttribute, continuing\n"; } } break; case BindingType::MouseAxisBinding: { std::string axis; if(binding->QueryValueAttribute("MouseAxis", &axis) == TIXML_SUCCESS) { MouseAxis::Enum mouse_axis = MouseAxis::FromStr(axis); if(mouse_axis != MouseAxis::InvalidFirst && mouse_axis != MouseAxis::InvalidLast) { bindings[player_id].push_back(InputConfig(binding_type, Binding(mouse_axis), action)); } else { Logger::ErrorOut() << "MouseAxis attribute incorrect: " << axis << "\n"; } } else { Logger::ErrorOut() << "Missing MouseAxis attribute\n"; } } break; case BindingType::MouseButtonBinding: { std::string button; if(binding->QueryValueAttribute("MouseButton", &button) == TIXML_SUCCESS) { MouseButton::Enum mouse_button = MouseButton::FromStr(button); if(mouse_button != MouseButton::InvalidFirst && mouse_button != MouseButton::InvalidLast) { bindings[player_id].push_back(InputConfig(binding_type, Binding(mouse_button), action)); } else { Logger::ErrorOut() << "Missing MouseAxis attribute\n"; } } else { Logger::ErrorOut() << "Missing MouseButton attribute\n"; } } break; } } else { xml_error = true; Logger::ErrorOut() << "Missing Binding element\n"; } ic = ic->NextSiblingElement("InputConfig"); } } else xml_error = true; player = player->NextSiblingElement("PlayerBindings"); } } else xml_error = true; } else xml_error = true; if(xml_error) { ResetToDefault(); } }
int main() { // // We start with the 'demoStart' todo list. Process it. And // should hopefully end up with the todo list as illustrated. // const char* demoStart = "<?xml version=\"1.0\" standalone='no' >\n" "<!-- Our to do list data -->" "<ToDo>\n" "<!-- Do I need a secure PDA? -->\n" "<Item priority=\"1\" distance='close'> Go to the <bold>Toy store!</bold></Item>" "<Item priority=\"2\" distance='none'> Do bills </Item>" "<Item priority=\"2\" distance='far & back'> Look for Evil Dinosaurs! </Item>" "</ToDo>"; { #ifdef TIXML_USE_STL // What the todo list should look like after processing. // In stream (no formatting) representation. const char* demoEnd = "<?xml version=\"1.0\" standalone=\"no\" ?>" "<!-- Our to do list data -->" "<ToDo>" "<!-- Do I need a secure PDA? -->" "<Item priority=\"2\" distance=\"close\">Go to the" "<bold>Toy store!" "</bold>" "</Item>" "<Item priority=\"1\" distance=\"far\">Talk to:" "<Meeting where=\"School\">" "<Attendee name=\"Marple\" position=\"teacher\" />" "<Attendee name=\"Voel\" position=\"counselor\" />" "</Meeting>" "<Meeting where=\"Lunch\" />" "</Item>" "<Item priority=\"2\" distance=\"here\">Do bills" "</Item>" "</ToDo>"; #endif // The example parses from the character string (above): #if defined( WIN32 ) && defined( TUNE ) _CrtMemCheckpoint( &startMemState ); #endif { // Write to a file and read it back, to check file I/O. TiXmlDocument doc( "demotest.xml" ); doc.Parse( demoStart ); if ( doc.Error() ) { printf( "Error in %s: %s\n", doc.Value(), doc.ErrorDesc() ); exit( 1 ); } doc.SaveFile(); } TiXmlDocument doc( "demotest.xml" ); bool loadOkay = doc.LoadFile(); if ( !loadOkay ) { printf( "Could not load test file 'demotest.xml'. Error='%s'. Exiting.\n", doc.ErrorDesc() ); exit( 1 ); } printf( "** Demo doc read from disk: ** \n\n" ); printf( "** Printing via doc.Print **\n" ); doc.Print( stdout ); { printf( "** Printing via TiXmlPrinter **\n" ); TiXmlPrinter printer; doc.Accept( &printer ); fprintf( stdout, "%s", printer.CStr() ); } #ifdef TIXML_USE_STL { printf( "** Printing via operator<< **\n" ); std::cout << doc; } #endif TiXmlNode* node = 0; TiXmlElement* todoElement = 0; TiXmlElement* itemElement = 0; // -------------------------------------------------------- // An example of changing existing attributes, and removing // an element from the document. // -------------------------------------------------------- // Get the "ToDo" element. // It is a child of the document, and can be selected by name. node = doc.FirstChild( "ToDo" ); assert( node ); todoElement = node->ToElement(); assert( todoElement ); // Going to the toy store is now our second priority... // So set the "priority" attribute of the first item in the list. node = todoElement->FirstChildElement(); // This skips the "PDA" comment. assert( node ); itemElement = node->ToElement(); assert( itemElement ); itemElement->SetAttribute( "priority", 2 ); // Change the distance to "doing bills" from // "none" to "here". It's the next sibling element. itemElement = itemElement->NextSiblingElement(); assert( itemElement ); itemElement->SetAttribute( "distance", "here" ); // Remove the "Look for Evil Dinosaurs!" item. // It is 1 more sibling away. We ask the parent to remove // a particular child. itemElement = itemElement->NextSiblingElement(); todoElement->RemoveChild( itemElement ); itemElement = 0; // -------------------------------------------------------- // What follows is an example of created elements and text // nodes and adding them to the document. // -------------------------------------------------------- // Add some meetings. TiXmlElement item( "Item" ); item.SetAttribute( "priority", "1" ); item.SetAttribute( "distance", "far" ); TiXmlText text( "Talk to:" ); TiXmlElement meeting1( "Meeting" ); meeting1.SetAttribute( "where", "School" ); TiXmlElement meeting2( "Meeting" ); meeting2.SetAttribute( "where", "Lunch" ); TiXmlElement attendee1( "Attendee" ); attendee1.SetAttribute( "name", "Marple" ); attendee1.SetAttribute( "position", "teacher" ); TiXmlElement attendee2( "Attendee" ); attendee2.SetAttribute( "name", "Voel" ); attendee2.SetAttribute( "position", "counselor" ); // Assemble the nodes we've created: meeting1.InsertEndChild( attendee1 ); meeting1.InsertEndChild( attendee2 ); item.InsertEndChild( text ); item.InsertEndChild( meeting1 ); item.InsertEndChild( meeting2 ); // And add the node to the existing list after the first child. node = todoElement->FirstChild( "Item" ); assert( node ); itemElement = node->ToElement(); assert( itemElement ); todoElement->InsertAfterChild( itemElement, item ); printf( "\n** Demo doc processed: ** \n\n" ); doc.Print( stdout ); #ifdef TIXML_USE_STL printf( "** Demo doc processed to stream: ** \n\n" ); cout << doc << endl << endl; #endif // -------------------------------------------------------- // Different tests...do we have what we expect? // -------------------------------------------------------- int count = 0; TiXmlElement* element; ////////////////////////////////////////////////////// #ifdef TIXML_USE_STL cout << "** Basic structure. **\n"; ostringstream outputStream( ostringstream::out ); outputStream << doc; XmlTest( "Output stream correct.", string( demoEnd ).c_str(), outputStream.str().c_str(), true ); #endif node = doc.RootElement(); assert( node ); XmlTest( "Root element exists.", true, ( node != 0 && node->ToElement() ) ); XmlTest ( "Root element value is 'ToDo'.", "ToDo", node->Value()); node = node->FirstChild(); XmlTest( "First child exists & is a comment.", true, ( node != 0 && node->ToComment() ) ); node = node->NextSibling(); XmlTest( "Sibling element exists & is an element.", true, ( node != 0 && node->ToElement() ) ); XmlTest ( "Value is 'Item'.", "Item", node->Value() ); node = node->FirstChild(); XmlTest ( "First child exists.", true, ( node != 0 && node->ToText() ) ); XmlTest ( "Value is 'Go to the'.", "Go to the", node->Value() ); ////////////////////////////////////////////////////// printf ("\n** Iterators. **\n"); // Walk all the top level nodes of the document. count = 0; for( node = doc.FirstChild(); node; node = node->NextSibling() ) { count++; } XmlTest( "Top level nodes, using First / Next.", 3, count ); count = 0; for( node = doc.LastChild(); node; node = node->PreviousSibling() ) { count++; } XmlTest( "Top level nodes, using Last / Previous.", 3, count ); // Walk all the top level nodes of the document, // using a different syntax. count = 0; for( node = doc.IterateChildren( 0 ); node; node = doc.IterateChildren( node ) ) { count++; } XmlTest( "Top level nodes, using IterateChildren.", 3, count ); // Walk all the elements in a node. count = 0; for( element = todoElement->FirstChildElement(); element; element = element->NextSiblingElement() ) { count++; } XmlTest( "Children of the 'ToDo' element, using First / Next.", 3, count ); // Walk all the elements in a node by value. count = 0; for( node = todoElement->FirstChild( "Item" ); node; node = node->NextSibling( "Item" ) ) { count++; } XmlTest( "'Item' children of the 'ToDo' element, using First/Next.", 3, count ); count = 0; for( node = todoElement->LastChild( "Item" ); node; node = node->PreviousSibling( "Item" ) ) { count++; } XmlTest( "'Item' children of the 'ToDo' element, using Last/Previous.", 3, count ); #ifdef TIXML_USE_STL { cout << "\n** Parsing. **\n"; istringstream parse0( "<Element0 attribute0='foo0' attribute1= noquotes attribute2 = '>' />" ); TiXmlElement element0( "default" ); parse0 >> element0; XmlTest ( "Element parsed, value is 'Element0'.", "Element0", element0.Value() ); XmlTest ( "Reads attribute 'attribute0=\"foo0\"'.", "foo0", element0.Attribute( "attribute0" )); XmlTest ( "Reads incorrectly formatted 'attribute1=noquotes'.", "noquotes", element0.Attribute( "attribute1" ) ); XmlTest ( "Read attribute with entity value '>'.", ">", element0.Attribute( "attribute2" ) ); } #endif { const char* error = "<?xml version=\"1.0\" standalone=\"no\" ?>\n" "<passages count=\"006\" formatversion=\"20020620\">\n" " <wrong error>\n" "</passages>"; TiXmlDocument docTest; docTest.Parse( error ); XmlTest( "Error row", docTest.ErrorRow(), 3 ); XmlTest( "Error column", docTest.ErrorCol(), 17 ); //printf( "error=%d id='%s' row %d col%d\n", (int) doc.Error(), doc.ErrorDesc(), doc.ErrorRow()+1, doc.ErrorCol() + 1 ); } #ifdef TIXML_USE_STL { ////////////////////////////////////////////////////// cout << "\n** Streaming. **\n"; // Round trip check: stream in, then stream back out to verify. The stream // out has already been checked, above. We use the output istringstream inputStringStream( outputStream.str() ); TiXmlDocument document0; inputStringStream >> document0; ostringstream outputStream0( ostringstream::out ); outputStream0 << document0; XmlTest( "Stream round trip correct.", string( demoEnd ).c_str(), outputStream0.str().c_str(), true ); std::string str; str << document0; XmlTest( "String printing correct.", string( demoEnd ).c_str(), str.c_str(), true ); } #endif } { const char* str = "<doc attr0='1' attr1='2.0' attr2='foo' />"; TiXmlDocument doc; doc.Parse( str ); TiXmlElement* ele = doc.FirstChildElement(); int iVal, result; double dVal; result = ele->QueryDoubleAttribute( "attr0", &dVal ); XmlTest( "Query attribute: int as double", result, TIXML_SUCCESS ); XmlTest( "Query attribute: int as double", (int)dVal, 1 ); result = ele->QueryDoubleAttribute( "attr1", &dVal ); XmlTest( "Query attribute: double as double", (int)dVal, 2 ); result = ele->QueryIntAttribute( "attr1", &iVal ); XmlTest( "Query attribute: double as int", result, TIXML_SUCCESS ); XmlTest( "Query attribute: double as int", iVal, 2 ); result = ele->QueryIntAttribute( "attr2", &iVal ); XmlTest( "Query attribute: not a number", result, TIXML_WRONG_TYPE ); result = ele->QueryIntAttribute( "bar", &iVal ); XmlTest( "Query attribute: does not exist", result, TIXML_NO_ATTRIBUTE ); } { const char* str = "<doc/>"; TiXmlDocument doc; doc.Parse( str ); TiXmlElement* ele = doc.FirstChildElement(); int iVal; double dVal; ele->SetAttribute( "str", "strValue" ); ele->SetAttribute( "int", 1 ); ele->SetDoubleAttribute( "double", -1.0 ); const char* cStr = ele->Attribute( "str" ); ele->QueryIntAttribute( "int", &iVal ); ele->QueryDoubleAttribute( "double", &dVal ); XmlTest( "Attribute round trip. c-string.", "strValue", cStr ); XmlTest( "Attribute round trip. int.", 1, iVal ); XmlTest( "Attribute round trip. double.", -1, (int)dVal ); } { const char* str = "\t<?xml version=\"1.0\" standalone=\"no\" ?>\t<room doors='2'>\n" "</room>"; TiXmlDocument doc; doc.SetTabSize( 8 ); doc.Parse( str ); TiXmlHandle docHandle( &doc ); TiXmlHandle roomHandle = docHandle.FirstChildElement( "room" ); assert( docHandle.Node() ); assert( roomHandle.Element() ); TiXmlElement* room = roomHandle.Element(); assert( room ); TiXmlAttribute* doors = room->FirstAttribute(); assert( doors ); XmlTest( "Location tracking: Tab 8: room row", room->Row(), 1 ); XmlTest( "Location tracking: Tab 8: room col", room->Column(), 49 ); XmlTest( "Location tracking: Tab 8: doors row", doors->Row(), 1 ); XmlTest( "Location tracking: Tab 8: doors col", doors->Column(), 55 ); } { const char* str = "\t<?xml version=\"1.0\" standalone=\"no\" ?>\t<room doors='2'>\n" " <!-- Silly example -->\n" " <door wall='north'>A great door!</door>\n" "\t<door wall='east'/>" "</room>"; TiXmlDocument doc; doc.Parse( str ); TiXmlHandle docHandle( &doc ); TiXmlHandle roomHandle = docHandle.FirstChildElement( "room" ); TiXmlHandle commentHandle = docHandle.FirstChildElement( "room" ).FirstChild(); TiXmlHandle textHandle = docHandle.FirstChildElement( "room" ).ChildElement( "door", 0 ).FirstChild(); TiXmlHandle door0Handle = docHandle.FirstChildElement( "room" ).ChildElement( 0 ); TiXmlHandle door1Handle = docHandle.FirstChildElement( "room" ).ChildElement( 1 ); assert( docHandle.Node() ); assert( roomHandle.Element() ); assert( commentHandle.Node() ); assert( textHandle.Text() ); assert( door0Handle.Element() ); assert( door1Handle.Element() ); TiXmlDeclaration* declaration = doc.FirstChild()->ToDeclaration(); assert( declaration ); TiXmlElement* room = roomHandle.Element(); assert( room ); TiXmlAttribute* doors = room->FirstAttribute(); assert( doors ); TiXmlText* text = textHandle.Text(); TiXmlComment* comment = commentHandle.Node()->ToComment(); assert( comment ); TiXmlElement* door0 = door0Handle.Element(); TiXmlElement* door1 = door1Handle.Element(); XmlTest( "Location tracking: Declaration row", declaration->Row(), 1 ); XmlTest( "Location tracking: Declaration col", declaration->Column(), 5 ); XmlTest( "Location tracking: room row", room->Row(), 1 ); XmlTest( "Location tracking: room col", room->Column(), 45 ); XmlTest( "Location tracking: doors row", doors->Row(), 1 ); XmlTest( "Location tracking: doors col", doors->Column(), 51 ); XmlTest( "Location tracking: Comment row", comment->Row(), 2 ); XmlTest( "Location tracking: Comment col", comment->Column(), 3 ); XmlTest( "Location tracking: text row", text->Row(), 3 ); XmlTest( "Location tracking: text col", text->Column(), 24 ); XmlTest( "Location tracking: door0 row", door0->Row(), 3 ); XmlTest( "Location tracking: door0 col", door0->Column(), 5 ); XmlTest( "Location tracking: door1 row", door1->Row(), 4 ); XmlTest( "Location tracking: door1 col", door1->Column(), 5 ); } // -------------------------------------------------------- // UTF-8 testing. It is important to test: // 1. Making sure name, value, and text read correctly // 2. Row, Col functionality // 3. Correct output // -------------------------------------------------------- printf ("\n** UTF-8 **\n"); { TiXmlDocument doc( "utf8test.xml" ); doc.LoadFile(); if ( doc.Error() && doc.ErrorId() == TiXmlBase::TIXML_ERROR_OPENING_FILE ) { printf( "WARNING: File 'utf8test.xml' not found.\n" "(Are you running the test from the wrong directory?)\n" "Could not test UTF-8 functionality.\n" ); } else { TiXmlHandle docH( &doc ); // Get the attribute "value" from the "Russian" element and check it. TiXmlElement* element = docH.FirstChildElement( "document" ).FirstChildElement( "Russian" ).Element(); const unsigned char correctValue[] = { 0xd1U, 0x86U, 0xd0U, 0xb5U, 0xd0U, 0xbdU, 0xd0U, 0xbdU, 0xd0U, 0xbeU, 0xd1U, 0x81U, 0xd1U, 0x82U, 0xd1U, 0x8cU, 0 }; XmlTest( "UTF-8: Russian value.", (const char*)correctValue, element->Attribute( "value" ), true ); XmlTest( "UTF-8: Russian value row.", 4, element->Row() ); XmlTest( "UTF-8: Russian value column.", 5, element->Column() ); const unsigned char russianElementName[] = { 0xd0U, 0xa0U, 0xd1U, 0x83U, 0xd1U, 0x81U, 0xd1U, 0x81U, 0xd0U, 0xbaU, 0xd0U, 0xb8U, 0xd0U, 0xb9U, 0 }; const char russianText[] = "<\xD0\xB8\xD0\xBC\xD0\xB5\xD0\xB5\xD1\x82>"; TiXmlText* text = docH.FirstChildElement( "document" ).FirstChildElement( (const char*) russianElementName ).Child( 0 ).Text(); XmlTest( "UTF-8: Browsing russian element name.", russianText, text->Value(), true ); XmlTest( "UTF-8: Russian element name row.", 7, text->Row() ); XmlTest( "UTF-8: Russian element name column.", 47, text->Column() ); TiXmlDeclaration* dec = docH.Child( 0 ).Node()->ToDeclaration(); XmlTest( "UTF-8: Declaration column.", 1, dec->Column() ); XmlTest( "UTF-8: Document column.", 1, doc.Column() ); // Now try for a round trip. doc.SaveFile( "utf8testout.xml" ); // Check the round trip. char savedBuf[256]; char verifyBuf[256]; int okay = 1; FILE* saved = fopen( "data/utf8testout.xml", "r" ); FILE* verify = fopen( "data/utf8testverify.xml", "r" ); //bool firstLineBOM=true; if ( saved && verify ) { while ( fgets( verifyBuf, 256, verify ) ) { fgets( savedBuf, 256, saved ); NullLineEndings( verifyBuf ); NullLineEndings( savedBuf ); if ( /*!firstLineBOM && */ strcmp( verifyBuf, savedBuf ) ) { printf( "verify:%s<\n", verifyBuf ); printf( "saved :%s<\n", savedBuf ); okay = 0; break; } //firstLineBOM = false; } } if ( saved ) fclose( saved ); if ( verify ) fclose( verify ); XmlTest( "UTF-8: Verified multi-language round trip.", 1, okay ); // On most Western machines, this is an element that contains // the word "resume" with the correct accents, in a latin encoding. // It will be something else completely on non-wester machines, // which is why TinyXml is switching to UTF-8. const char latin[] = "<element>r\x82sum\x82</element>"; TiXmlDocument latinDoc; latinDoc.Parse( latin, 0, TIXML_ENCODING_LEGACY ); text = latinDoc.FirstChildElement()->FirstChild()->ToText(); XmlTest( "Legacy encoding: Verify text element.", "r\x82sum\x82", text->Value() ); } } ////////////////////// // Copy and assignment ////////////////////// printf ("\n** Copy and Assignment **\n"); { TiXmlElement element( "foo" ); element.Parse( "<element name='value' />", 0, TIXML_ENCODING_UNKNOWN ); TiXmlElement elementCopy( element ); TiXmlElement elementAssign( "foo" ); elementAssign.Parse( "<incorrect foo='bar'/>", 0, TIXML_ENCODING_UNKNOWN ); elementAssign = element; XmlTest( "Copy/Assign: element copy #1.", "element", elementCopy.Value() ); XmlTest( "Copy/Assign: element copy #2.", "value", elementCopy.Attribute( "name" ) ); XmlTest( "Copy/Assign: element assign #1.", "element", elementAssign.Value() ); XmlTest( "Copy/Assign: element assign #2.", "value", elementAssign.Attribute( "name" ) ); XmlTest( "Copy/Assign: element assign #3.", true, ( 0 == elementAssign.Attribute( "foo" )) ); TiXmlComment comment; comment.Parse( "<!--comment-->", 0, TIXML_ENCODING_UNKNOWN ); TiXmlComment commentCopy( comment ); TiXmlComment commentAssign; commentAssign = commentCopy; XmlTest( "Copy/Assign: comment copy.", "comment", commentCopy.Value() ); XmlTest( "Copy/Assign: comment assign.", "comment", commentAssign.Value() ); TiXmlUnknown unknown; unknown.Parse( "<[unknown]>", 0, TIXML_ENCODING_UNKNOWN ); TiXmlUnknown unknownCopy( unknown ); TiXmlUnknown unknownAssign; unknownAssign.Parse( "incorrect", 0, TIXML_ENCODING_UNKNOWN ); unknownAssign = unknownCopy; XmlTest( "Copy/Assign: unknown copy.", "[unknown]", unknownCopy.Value() ); XmlTest( "Copy/Assign: unknown assign.", "[unknown]", unknownAssign.Value() ); TiXmlText text( "TextNode" ); TiXmlText textCopy( text ); TiXmlText textAssign( "incorrect" ); textAssign = text; XmlTest( "Copy/Assign: text copy.", "TextNode", textCopy.Value() ); XmlTest( "Copy/Assign: text assign.", "TextNode", textAssign.Value() ); TiXmlDeclaration dec; dec.Parse( "<?xml version='1.0' encoding='UTF-8'?>", 0, TIXML_ENCODING_UNKNOWN ); TiXmlDeclaration decCopy( dec ); TiXmlDeclaration decAssign; decAssign = dec; XmlTest( "Copy/Assign: declaration copy.", "UTF-8", decCopy.Encoding() ); XmlTest( "Copy/Assign: text assign.", "UTF-8", decAssign.Encoding() ); TiXmlDocument doc; elementCopy.InsertEndChild( textCopy ); doc.InsertEndChild( decAssign ); doc.InsertEndChild( elementCopy ); doc.InsertEndChild( unknownAssign ); TiXmlDocument docCopy( doc ); TiXmlDocument docAssign; docAssign = docCopy; #ifdef TIXML_USE_STL std::string original, copy, assign; original << doc; copy << docCopy; assign << docAssign; XmlTest( "Copy/Assign: document copy.", original.c_str(), copy.c_str(), true ); XmlTest( "Copy/Assign: document assign.", original.c_str(), assign.c_str(), true ); #endif } ////////////////////////////////////////////////////// #ifdef TIXML_USE_STL printf ("\n** Parsing, no Condense Whitespace **\n"); TiXmlBase::SetCondenseWhiteSpace( false ); { istringstream parse1( "<start>This is \ntext</start>" ); TiXmlElement text1( "text" ); parse1 >> text1; XmlTest ( "Condense white space OFF.", "This is \ntext", text1.FirstChild()->Value(), true ); } TiXmlBase::SetCondenseWhiteSpace( true ); #endif ////////////////////////////////////////////////////// // GetText(); { const char* str = "<foo>This is text</foo>"; TiXmlDocument doc; doc.Parse( str ); const TiXmlElement* element = doc.RootElement(); XmlTest( "GetText() normal use.", "This is text", element->GetText() ); str = "<foo><b>This is text</b></foo>"; doc.Clear(); doc.Parse( str ); element = doc.RootElement(); XmlTest( "GetText() contained element.", element->GetText() == 0, true ); str = "<foo>This is <b>text</b></foo>"; doc.Clear(); TiXmlBase::SetCondenseWhiteSpace( false ); doc.Parse( str ); TiXmlBase::SetCondenseWhiteSpace( true ); element = doc.RootElement(); XmlTest( "GetText() partial.", "This is ", element->GetText() ); } ////////////////////////////////////////////////////// // CDATA { const char* str = "<xmlElement>" "<![CDATA[" "I am > the rules!\n" "...since I make symbolic puns" "]]>" "</xmlElement>"; TiXmlDocument doc; doc.Parse( str ); doc.Print(); XmlTest( "CDATA parse.", doc.FirstChildElement()->FirstChild()->Value(), "I am > the rules!\n...since I make symbolic puns", true ); #ifdef TIXML_USE_STL //cout << doc << '\n'; doc.Clear(); istringstream parse0( str ); parse0 >> doc; //cout << doc << '\n'; XmlTest( "CDATA stream.", doc.FirstChildElement()->FirstChild()->Value(), "I am > the rules!\n...since I make symbolic puns", true ); #endif TiXmlDocument doc1 = doc; //doc.Print(); XmlTest( "CDATA copy.", doc1.FirstChildElement()->FirstChild()->Value(), "I am > the rules!\n...since I make symbolic puns", true ); } { // [ 1482728 ] Wrong wide char parsing char buf[256]; buf[255] = 0; for( int i=0; i<255; ++i ) { buf[i] = (char)((i>=32) ? i : 32); } TIXML_STRING str( "<xmlElement><![CDATA[" ); str += buf; str += "]]></xmlElement>"; TiXmlDocument doc; doc.Parse( str.c_str() ); TiXmlPrinter printer; printer.SetStreamPrinting(); doc.Accept( &printer ); XmlTest( "CDATA with all bytes #1.", str.c_str(), printer.CStr(), true ); #ifdef TIXML_USE_STL doc.Clear(); istringstream iss( printer.Str() ); iss >> doc; std::string out; out << doc; XmlTest( "CDATA with all bytes #2.", out.c_str(), printer.CStr(), true ); #endif } { // [ 1480107 ] Bug-fix for STL-streaming of CDATA that contains tags // CDATA streaming had a couple of bugs, that this tests for. const char* str = "<xmlElement>" "<![CDATA[" "<b>I am > the rules!</b>\n" "...since I make symbolic puns" "]]>" "</xmlElement>"; TiXmlDocument doc; doc.Parse( str ); doc.Print(); XmlTest( "CDATA parse. [ 1480107 ]", doc.FirstChildElement()->FirstChild()->Value(), "<b>I am > the rules!</b>\n...since I make symbolic puns", true ); #ifdef TIXML_USE_STL doc.Clear(); istringstream parse0( str ); parse0 >> doc; XmlTest( "CDATA stream. [ 1480107 ]", doc.FirstChildElement()->FirstChild()->Value(), "<b>I am > the rules!</b>\n...since I make symbolic puns", true ); #endif TiXmlDocument doc1 = doc; //doc.Print(); XmlTest( "CDATA copy. [ 1480107 ]", doc1.FirstChildElement()->FirstChild()->Value(), "<b>I am > the rules!</b>\n...since I make symbolic puns", true ); } ////////////////////////////////////////////////////// // Visit() ////////////////////////////////////////////////////// printf( "\n** Fuzzing... **\n" ); const int FUZZ_ITERATION = 300; // The only goal is not to crash on bad input. int len = (int) strlen( demoStart ); for( int i=0; i<FUZZ_ITERATION; ++i ) { char* demoCopy = new char[ len+1 ]; strcpy( demoCopy, demoStart ); demoCopy[ i%len ] = (char)((i+1)*3); demoCopy[ (i*7)%len ] = '>'; demoCopy[ (i*11)%len ] = '<'; TiXmlDocument xml; xml.Parse( demoCopy ); delete [] demoCopy; } printf( "** Fuzzing Complete. **\n" ); ////////////////////////////////////////////////////// printf ("\n** Bug regression tests **\n"); // InsertBeforeChild and InsertAfterChild causes crash. { TiXmlElement parent( "Parent" ); TiXmlElement childText0( "childText0" ); TiXmlElement childText1( "childText1" ); TiXmlNode* childNode0 = parent.InsertEndChild( childText0 ); TiXmlNode* childNode1 = parent.InsertBeforeChild( childNode0, childText1 ); XmlTest( "Test InsertBeforeChild on empty node.", ( childNode1 == parent.FirstChild() ), true ); } { // InsertBeforeChild and InsertAfterChild causes crash. TiXmlElement parent( "Parent" ); TiXmlElement childText0( "childText0" ); TiXmlElement childText1( "childText1" ); TiXmlNode* childNode0 = parent.InsertEndChild( childText0 ); TiXmlNode* childNode1 = parent.InsertAfterChild( childNode0, childText1 ); XmlTest( "Test InsertAfterChild on empty node. ", ( childNode1 == parent.LastChild() ), true ); } // Reports of missing constructors, irregular string problems. { // Missing constructor implementation. No test -- just compiles. TiXmlText text( "Missing" ); #ifdef TIXML_USE_STL // Missing implementation: TiXmlDocument doc; string name = "missing"; doc.LoadFile( name ); TiXmlText textSTL( name ); #else // verifying some basic string functions: TiXmlString a; TiXmlString b( "Hello" ); TiXmlString c( "ooga" ); c = " World!"; a = b; a += c; a = a; XmlTest( "Basic TiXmlString test. ", "Hello World!", a.c_str() ); #endif } // Long filenames crashing STL version { TiXmlDocument doc( "midsummerNightsDreamWithAVeryLongFilenameToConfuseTheStringHandlingRoutines.xml" ); bool loadOkay = doc.LoadFile(); loadOkay = true; // get rid of compiler warning. // Won't pass on non-dev systems. Just a "no crash" check. //XmlTest( "Long filename. ", true, loadOkay ); } { // Entities not being written correctly. // From Lynn Allen const char* passages = "<?xml version=\"1.0\" standalone=\"no\" ?>" "<passages count=\"006\" formatversion=\"20020620\">" "<psg context=\"Line 5 has "quotation marks" and 'apostrophe marks'." " It also has <, >, and &, as well as a fake copyright ©.\"> </psg>" "</passages>"; TiXmlDocument doc( "passages.xml" ); doc.Parse( passages ); TiXmlElement* psg = doc.RootElement()->FirstChildElement(); const char* context = psg->Attribute( "context" ); const char* expected = "Line 5 has \"quotation marks\" and 'apostrophe marks'. It also has <, >, and &, as well as a fake copyright \xC2\xA9."; XmlTest( "Entity transformation: read. ", expected, context, true ); FILE* textfile = fopen( "textfile.txt", "w" ); if ( textfile ) { psg->Print( textfile, 0 ); fclose( textfile ); } textfile = fopen( "textfile.txt", "r" ); assert( textfile ); if ( textfile ) { char buf[ 1024 ]; fgets( buf, 1024, textfile ); XmlTest( "Entity transformation: write. ", "<psg context=\'Line 5 has "quotation marks" and 'apostrophe marks'." " It also has <, >, and &, as well as a fake copyright \xC2\xA9.' />", buf, true ); } fclose( textfile ); } { FILE* textfile = fopen( "test5.xml", "w" ); if ( textfile ) { fputs("<?xml version='1.0'?><a.elem xmi.version='2.0'/>", textfile); fclose(textfile); TiXmlDocument doc; doc.LoadFile( "test5.xml" ); XmlTest( "dot in element attributes and names", doc.Error(), 0); } } { FILE* textfile = fopen( "test6.xml", "w" ); if ( textfile ) { fputs("<element><Name>1.1 Start easy ignore fin thickness
</Name></element>", textfile ); fclose(textfile); TiXmlDocument doc; bool result = doc.LoadFile( "test6.xml" ); XmlTest( "Entity with one digit.", result, true ); TiXmlText* text = doc.FirstChildElement()->FirstChildElement()->FirstChild()->ToText(); XmlTest( "Entity with one digit.", text->Value(), "1.1 Start easy ignore fin thickness\n" ); } } { // DOCTYPE not preserved (950171) // const char* doctype = "<?xml version=\"1.0\" ?>" "<!DOCTYPE PLAY SYSTEM 'play.dtd'>" "<!ELEMENT title (#PCDATA)>" "<!ELEMENT books (title,authors)>" "<element />"; TiXmlDocument doc; doc.Parse( doctype ); doc.SaveFile( "test7.xml" ); doc.Clear(); doc.LoadFile( "test7.xml" ); TiXmlHandle docH( &doc ); TiXmlUnknown* unknown = docH.Child( 1 ).Unknown(); XmlTest( "Correct value of unknown.", "!DOCTYPE PLAY SYSTEM 'play.dtd'", unknown->Value() ); #ifdef TIXML_USE_STL TiXmlNode* node = docH.Child( 2 ).Node(); std::string str; str << (*node); XmlTest( "Correct streaming of unknown.", "<!ELEMENT title (#PCDATA)>", str.c_str() ); #endif } { // [ 791411 ] Formatting bug // Comments do not stream out correctly. const char* doctype = "<!-- Somewhat<evil> -->"; TiXmlDocument doc; doc.Parse( doctype ); TiXmlHandle docH( &doc ); TiXmlComment* comment = docH.Child( 0 ).Node()->ToComment(); XmlTest( "Comment formatting.", " Somewhat<evil> ", comment->Value() ); #ifdef TIXML_USE_STL std::string str; str << (*comment); XmlTest( "Comment streaming.", "<!-- Somewhat<evil> -->", str.c_str() ); #endif } { // [ 870502 ] White space issues TiXmlDocument doc; TiXmlText* text; TiXmlHandle docH( &doc ); const char* doctype0 = "<element> This has leading and trailing space </element>"; const char* doctype1 = "<element>This has internal space</element>"; const char* doctype2 = "<element> This has leading, trailing, and internal space </element>"; TiXmlBase::SetCondenseWhiteSpace( false ); doc.Clear(); doc.Parse( doctype0 ); text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); XmlTest( "White space kept.", " This has leading and trailing space ", text->Value() ); doc.Clear(); doc.Parse( doctype1 ); text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); XmlTest( "White space kept.", "This has internal space", text->Value() ); doc.Clear(); doc.Parse( doctype2 ); text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); XmlTest( "White space kept.", " This has leading, trailing, and internal space ", text->Value() ); TiXmlBase::SetCondenseWhiteSpace( true ); doc.Clear(); doc.Parse( doctype0 ); text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); XmlTest( "White space condensed.", "This has leading and trailing space", text->Value() ); doc.Clear(); doc.Parse( doctype1 ); text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); XmlTest( "White space condensed.", "This has internal space", text->Value() ); doc.Clear(); doc.Parse( doctype2 ); text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); XmlTest( "White space condensed.", "This has leading, trailing, and internal space", text->Value() ); } { // Double attributes const char* doctype = "<element attr='red' attr='blue' />"; TiXmlDocument doc; doc.Parse( doctype ); XmlTest( "Parsing repeated attributes.", true, doc.Error() ); // is an error to tinyxml (didn't use to be, but caused issues) //XmlTest( "Parsing repeated attributes.", "blue", doc.FirstChildElement( "element" )->Attribute( "attr" ) ); } { // Embedded null in stream. const char* doctype = "<element att\0r='red' attr='blue' />"; TiXmlDocument doc; doc.Parse( doctype ); XmlTest( "Embedded null throws error.", true, doc.Error() ); #ifdef TIXML_USE_STL istringstream strm( doctype ); doc.Clear(); doc.ClearError(); strm >> doc; XmlTest( "Embedded null throws error.", true, doc.Error() ); #endif } { // Legacy mode test. (This test may only pass on a western system) const char* str = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>" "<ä>" "CöntäntßäöüÄÖÜ" "</ä>"; TiXmlDocument doc; doc.Parse( str ); TiXmlHandle docHandle( &doc ); TiXmlHandle aHandle = docHandle.FirstChildElement( "ä" ); TiXmlHandle tHandle = aHandle.Child( 0 ); assert( aHandle.Element() ); assert( tHandle.Text() ); XmlTest( "ISO-8859-1 Parsing.", "CöntäntßäöüÄÖÜ", tHandle.Text()->Value() ); } { // Empty documents should return TIXML_ERROR_PARSING_EMPTY, bug 1070717 const char* str = " "; TiXmlDocument doc; doc.Parse( str ); XmlTest( "Empty document error TIXML_ERROR_DOCUMENT_EMPTY", TiXmlBase::TIXML_ERROR_DOCUMENT_EMPTY, doc.ErrorId() ); } #ifndef TIXML_USE_STL { // String equality. [ 1006409 ] string operator==/!= no worky in all cases TiXmlString temp; XmlTest( "Empty tinyxml string compare equal", ( temp == "" ), true ); TiXmlString foo; TiXmlString bar( "" ); XmlTest( "Empty tinyxml string compare equal", ( foo == bar ), true ); } #endif { // Bug [ 1195696 ] from marlonism TiXmlBase::SetCondenseWhiteSpace(false); TiXmlDocument xml; xml.Parse("<text><break/>This hangs</text>"); XmlTest( "Test safe error return.", xml.Error(), false ); } { // Bug [ 1243992 ] - another infinite loop TiXmlDocument doc; doc.SetCondenseWhiteSpace(false); doc.Parse("<p><pb></pb>test</p>"); } { // Low entities TiXmlDocument xml; xml.Parse( "<test></test>" ); const char result[] = { 0x0e, 0 }; XmlTest( "Low entities.", xml.FirstChildElement()->GetText(), result ); xml.Print(); } { // Bug [ 1451649 ] Attribute values with trailing quotes not handled correctly TiXmlDocument xml; xml.Parse( "<foo attribute=bar\" />" ); XmlTest( "Throw error with bad end quotes.", xml.Error(), true ); } #ifdef TIXML_USE_STL { // Bug [ 1449463 ] Consider generic query TiXmlDocument xml; xml.Parse( "<foo bar='3' barStr='a string'/>" ); TiXmlElement* ele = xml.FirstChildElement(); double d; int i; float f; bool b; std::string str; XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &d ), TIXML_SUCCESS ); XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &i ), TIXML_SUCCESS ); XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &f ), TIXML_SUCCESS ); XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &b ), TIXML_WRONG_TYPE ); XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "nobar", &b ), TIXML_NO_ATTRIBUTE ); XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "barStr", &str ), TIXML_SUCCESS ); XmlTest( "QueryValueAttribute", (d==3.0), true ); XmlTest( "QueryValueAttribute", (i==3), true ); XmlTest( "QueryValueAttribute", (f==3.0f), true ); XmlTest( "QueryValueAttribute", (str==std::string( "a string" )), true ); } #endif #ifdef TIXML_USE_STL { // [ 1505267 ] redundant malloc in TiXmlElement::Attribute TiXmlDocument xml; xml.Parse( "<foo bar='3' />" ); TiXmlElement* ele = xml.FirstChildElement(); double d; int i; std::string bar = "bar"; const std::string* atrrib = ele->Attribute( bar ); ele->Attribute( bar, &d ); ele->Attribute( bar, &i ); XmlTest( "Attribute", atrrib->empty(), false ); XmlTest( "Attribute", (d==3.0), true ); XmlTest( "Attribute", (i==3), true ); } #endif { // [ 1356059 ] Allow TiXMLDocument to only be at the top level TiXmlDocument xml, xml2; xml.InsertEndChild( xml2 ); XmlTest( "Document only at top level.", xml.Error(), true ); XmlTest( "Document only at top level.", xml.ErrorId(), TiXmlBase::TIXML_ERROR_DOCUMENT_TOP_ONLY ); } { // [ 1663758 ] Failure to report error on bad XML TiXmlDocument xml; xml.Parse("<x>"); XmlTest("Missing end tag at end of input", xml.Error(), true); xml.Parse("<x> "); XmlTest("Missing end tag with trailing whitespace", xml.Error(), true); } { // [ 1635701 ] fail to parse files with a tag separated into two lines // I'm not sure this is a bug. Marked 'pending' for feedback. TiXmlDocument xml; xml.Parse( "<title><p>text</p\n><title>" ); //xml.Print(); //XmlTest( "Tag split by newline", xml.Error(), false ); } #ifdef TIXML_USE_STL { // [ 1475201 ] TinyXML parses entities in comments TiXmlDocument xml; istringstream parse1( "<!-- declarations for <head> & <body> -->" "<!-- far & away -->" ); parse1 >> xml; TiXmlNode* e0 = xml.FirstChild(); TiXmlNode* e1 = e0->NextSibling(); TiXmlComment* c0 = e0->ToComment(); TiXmlComment* c1 = e1->ToComment(); XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true ); XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true ); } #endif { // [ 1475201 ] TinyXML parses entities in comments TiXmlDocument xml; xml.Parse("<!-- declarations for <head> & <body> -->" "<!-- far & away -->" ); TiXmlNode* e0 = xml.FirstChild(); TiXmlNode* e1 = e0->NextSibling(); TiXmlComment* c0 = e0->ToComment(); TiXmlComment* c1 = e1->ToComment(); XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true ); XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true ); } { TiXmlDocument xml; xml.Parse( "<Parent>" "<child1 att=''/>" "<!-- With this comment, child2 will not be parsed! -->" "<child2 att=''/>" "</Parent>" ); int count = 0; TiXmlNode* ele = 0; while ( (ele = xml.FirstChildElement( "Parent" )->IterateChildren( ele ) ) != 0 ) { ++count; } XmlTest( "Comments iterate correctly.", 3, count ); } { // trying to repro ]1874301]. If it doesn't go into an infinite loop, all is well. unsigned char buf[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?><feed><![CDATA[Test XMLblablablalblbl"; buf[60] = 239; buf[61] = 0; TiXmlDocument doc; doc.Parse( (const char*)buf); } { // bug 1827248 Error while parsing a little bit malformed file // Actually not malformed - should work. TiXmlDocument xml; xml.Parse( "<attributelist> </attributelist >" ); XmlTest( "Handle end tag whitespace", false, xml.Error() ); } { // This one must not result in an infinite loop TiXmlDocument xml; xml.Parse( "<infinite>loop" ); XmlTest( "Infinite loop test.", true, true ); } { // 1709904 - can not repro the crash { TiXmlDocument xml; xml.Parse( "<tag>/</tag>" ); XmlTest( "Odd XML parsing.", xml.FirstChild()->Value(), "tag" ); } /* Could not repro. { TiXmlDocument xml; xml.LoadFile( "EQUI_Inventory.xml" ); //XmlTest( "Odd XML parsing.", xml.FirstChildElement()->Value(), "XML" ); TiXmlPrinter printer; xml.Accept( &printer ); fprintf( stdout, "%s", printer.CStr() ); }*/ } /* 1417717 experiment { TiXmlDocument xml; xml.Parse("<text>Dan & Tracie</text>"); xml.Print(stdout); } { TiXmlDocument xml; xml.Parse("<text>Dan &foo; Tracie</text>"); xml.Print(stdout); } */ #if defined( WIN32 ) && defined( TUNE ) _CrtMemCheckpoint( &endMemState ); //_CrtMemDumpStatistics( &endMemState ); _CrtMemState diffMemState; _CrtMemDifference( &diffMemState, &startMemState, &endMemState ); _CrtMemDumpStatistics( &diffMemState ); #endif printf ("\nPass %d, Fail %d\n", gPass, gFail); return gFail; }
bool XmlODESettings::GetSettings(ODESimulator& sim) { string globals="globals"; TiXmlElement* c = e->FirstChildElement(globals); if(c) { printf("Parsing globals...\n"); //parse globals: gravity, etc Vector3 gravity; if(c->QueryValueAttribute("gravity",&gravity)==TIXML_SUCCESS) sim.SetGravity(gravity); double worldERP,worldCFM; if(c->QueryValueAttribute("ERP",&worldERP)==TIXML_SUCCESS) sim.SetERP(worldERP); if(c->QueryValueAttribute("CFM",&worldCFM)==TIXML_SUCCESS) sim.SetCFM(worldCFM); int maxContacts; if(c->QueryValueAttribute("maxContacts",&maxContacts)==TIXML_SUCCESS) sim.GetSettings().maxContacts = maxContacts; int rigidObjectCollisions,robotSelfCollisions,robotRobotCollisions; if(c->QueryValueAttribute("rigidObjectCollisions",&rigidObjectCollisions)==TIXML_SUCCESS) sim.GetSettings().rigidObjectCollisions = rigidObjectCollisions; if(c->QueryValueAttribute("robotSelfCollisions",&robotSelfCollisions)==TIXML_SUCCESS) sim.GetSettings().robotSelfCollisions = robotSelfCollisions; if(c->QueryValueAttribute("robotRobotCollisions",&robotRobotCollisions)==TIXML_SUCCESS) sim.GetSettings().robotRobotCollisions = robotRobotCollisions; } else c=e->FirstChildElement(); while(c!=NULL) { const char* name=c->Value(); printf("Parsing element %s\n",name); if(0 == strcmp(name,"env")) { int index; if(c->QueryValueAttribute("index",&index)==TIXML_SUCCESS) { Assert(index < (int)sim.numEnvs()); TiXmlElement* eg=c->FirstChildElement("geometry"); if(eg) { XmlODEGeometry g(eg); if(!g.Get(*sim.envMesh(index))) { fprintf(stderr,"Error reading environment geometry from XML\n"); return false; } } } else { fprintf(stderr,"Error reading environment index from XML file\n"); return false; } } else if(0 == strcmp(name,"object")) { int index; if(c->QueryValueAttribute("index",&index)==TIXML_SUCCESS) { Assert(index < (int)sim.numObjects()); TiXmlElement* eg=c->FirstChildElement("geometry"); if(eg) { XmlODEGeometry g(eg); if(!g.Get(*sim.object(index)->triMesh())) { fprintf(stderr,"Error reading object geometry from XML\n"); return false; } } } else { fprintf(stderr,"Error reading object index from XML file\n"); return false; } } else if(0 == strcmp(name,"robot")) { int index,bodyIndex=-1; if(c->QueryValueAttribute("index",&index)==TIXML_SUCCESS) { Assert(index < (int)sim.numRobots()); if(c->QueryValueAttribute("body",&bodyIndex)==TIXML_SUCCESS) { } else bodyIndex=-1; ODERobot* robot=sim.robot(index); TiXmlElement* eg=c->FirstChildElement("geometry"); if(eg) { XmlODEGeometry g(eg); if(bodyIndex < 0) { for(size_t i=0;i<robot->robot.links.size();i++) { if(robot->triMesh(i)) g.Get(*robot->triMesh(i)); } } else { Assert(bodyIndex < (int)robot->robot.links.size()); if(robot->triMesh(bodyIndex)) g.Get(*robot->triMesh(bodyIndex)); } } } else { fprintf(stderr,"Error reading robot index from XML file\n"); return false; } } c=c->NextSiblingElement(); } return true; }
bool XmlSimulationSettings::GetSettings(WorldSimulation& sim) { string globals="globals"; TiXmlElement* c = e->FirstChildElement(globals); if(c) { printf("Parsing timestep...\n"); //parse timestep double timestep; if(c->QueryValueAttribute("timestep",×tep)==TIXML_SUCCESS) sim.simStep = timestep; } printf("Parsing ODE...\n"); XmlODESettings ode(e); if(!ode.GetSettings(sim.odesim)) { return false; } printf("Parsing robot controllers / sensors\n"); c = e->FirstChildElement("robot"); while(c != NULL) { int index; if(c->QueryValueAttribute("index",&index)!=TIXML_SUCCESS) { fprintf(stderr,"Unable to read index of robot element\n"); continue; } Assert(index < (int)sim.robotControllers.size()); ControlledRobotSimulator& robotSim=sim.controlSimulators[index]; TiXmlElement* ec=c->FirstChildElement("controller"); if(ec) { RobotControllerFactory::RegisterDefault(*robotSim.robot); SmartPointer<RobotController> controller=RobotControllerFactory::Load(ec,*robotSim.robot); if(controller) sim.SetController(index,controller); else { fprintf(stderr,"Unable to load controller from xml file\n"); return false; } Real temp; if(ec->QueryValueAttribute("rate",&temp)==TIXML_SUCCESS){ if(!(temp > 0)) { fprintf(stderr,"Invalid rate %g\n",temp); continue; } sim.controlSimulators[index].controlTimeStep = 1.0/temp; } if(ec->QueryValueAttribute("timeStep",&temp)==TIXML_SUCCESS){ if(!(temp > 0)) { fprintf(stderr,"Invalid timestep %g\n",temp); continue; } sim.controlSimulators[index].controlTimeStep = temp; } } TiXmlElement*es=c->FirstChildElement("sensors"); if(es) { if(!sim.controlSimulators[index].sensors.LoadSettings(es)) { fprintf(stderr,"Unable to load sensors from xml file\n"); return false; } } /* TiXmlElement* es=c->FirstChildElement("sensors"); if(es) { printf("Parsing sensors...\n"); TiXmlElement* pos=es->FirstChildElement("position"); int ival; Real fval; if(pos) { if(pos->QueryValueAttribute("enabled",&ival)==TIXML_SUCCESS) { if(bodyIndex >= 0) fprintf(stderr,"Warning: cannot enable individual joint encoders yet\n"); robotSim.sensors.hasJointPosition=(ival!=0); } if(pos->QueryValueAttribute("variance",&fval)==TIXML_SUCCESS) { if(robotSim.sensors.qvariance.n==0) robotSim.sensors.qvariance.resize(robotSim.robot->q.n,Zero); if(bodyIndex >= 0) robotSim.sensors.qvariance(bodyIndex)=fval; else robotSim.sensors.qvariance.set(fval); } if(pos->QueryValueAttribute("resolution",&fval)==TIXML_SUCCESS) { if(robotSim.sensors.qresolution.n==0) robotSim.sensors.qresolution.resize(robotSim.robot->q.n,Zero); if(bodyIndex >= 0) robotSim.sensors.qresolution(bodyIndex)=fval; else robotSim.sensors.qresolution.set(fval); } } TiXmlElement* vel=c->FirstChildElement("velocity"); if(vel) { if(vel->QueryValueAttribute("enabled",&ival)==TIXML_SUCCESS) { if(bodyIndex >= 0) fprintf(stderr,"Warning: cannot enable individual joint encoders yet\n"); robotSim.sensors.hasJointVelocity=(ival!=0); } if(vel->QueryValueAttribute("variance",&fval)==TIXML_SUCCESS) { if(robotSim.sensors.dqvariance.n==0) robotSim.sensors.dqvariance.resize(robotSim.robot->q.n,Zero); if(bodyIndex >= 0) robotSim.sensors.dqvariance(bodyIndex)=fval; else robotSim.sensors.dqvariance.set(fval); } if(vel->QueryValueAttribute("resolution",&fval)==TIXML_SUCCESS) { if(robotSim.sensors.dqresolution.n==0) robotSim.sensors.dqresolution.resize(robotSim.robot->q.n,Zero); if(bodyIndex >= 0) robotSim.sensors.dqresolution(bodyIndex)=fval; else robotSim.sensors.dqresolution.set(fval); } } //TODO: other sensors? } */ /* TiXmlElement* ec=c->FirstChildElement("controller"); if(ec) { printf("Parsing controller...\n"); TiXmlAttribute* setting = ec->FirstAttribute(); while(setting) { bool res=robotSim.controller->SetSetting(setting->Name(),setting->Value()); if(!res) { printf("Setting %s not valid for current controller, or failed parsing\n",setting->Name()); } setting = setting->Next(); } } */ c = c->NextSiblingElement("robot"); } printf("Parsing state\n"); c = e->FirstChildElement("state"); if(c) { const char* data=c->Attribute("data"); if(!data) { fprintf(stderr,"No 'data' attribute in state\n"); return false; } string decoded=FromBase64(data); if(!sim.ReadState(decoded)) { fprintf(stderr,"Unable to read state from data\n"); return false; } } return true; }
SkillManager::SkillManager(void) { error_ = false; /* Populate upgrade paths, costs etc*/ TiXmlDocument doc("Skills.xml"); doc.LoadFile(); if(doc.Error()) { Logger::ErrorOut() << "Unable to load skills.xml\n"; Logger::ErrorOut() << "Error: " << doc.ErrorDesc() << "\n"; } TiXmlElement* root = doc.FirstChildElement("Skills"); if(root) { TiXmlElement* skill = root->FirstChildElement("Skill"); while(skill) { std::vector<SkillLevel> upgrades; std::string name; std::string alignment; unsigned int init_cost = 0; error_ |= (skill->QueryValueAttribute("name", &name) != TIXML_SUCCESS); error_ |= (skill->QueryValueAttribute("alignment", &alignment) != TIXML_SUCCESS); TiXmlElement* initialcost = skill->FirstChildElement("InitialCost"); if(initialcost) { std::string init_cost_str = initialcost->GetText(); init_cost = boost::lexical_cast<unsigned int, std::string>(init_cost_str); } else { Logger::ErrorOut() << "No initial cost for skill " << name << "\n"; error_ = true; } //TODO upgrades TiXmlElement* upgrade = skill->FirstChildElement("Upgrade"); while(upgrade) { std::string upgrade_name; upgrade->QueryValueAttribute("name", &upgrade_name); SkillLevel sl(upgrade_name); int ltv_rank = 1; TiXmlElement* level = upgrade->FirstChildElement("Level"); while(level) { int rank = 0; int cost = 0; error_ |= (level->QueryIntAttribute("rank", &rank) != TIXML_SUCCESS); error_ |= (level->QueryIntAttribute("cost", &cost) != TIXML_SUCCESS); error_ |= (rank != ltv_rank + 1); ltv_rank = rank; sl.AddRank(cost); level = level->NextSiblingElement("Level"); } upgrades.push_back(sl); upgrade = upgrade->NextSiblingElement("Upgrade"); } if(error_) break; else { Skill* sk = new Skill(); sk->SetCost(init_cost); sk->SetName(name); for(std::vector<SkillLevel>::iterator it = upgrades.begin(); it != upgrades.end(); ++it) { sk->AddUpgrade(*it); } if(alignment == "good") sk->SetAlignment(SkillAlignment::Good); else if(alignment == "evil") sk->SetAlignment(SkillAlignment::Evil); else if(alignment == "neutral") sk->SetAlignment(SkillAlignment::Neutral); else { Logger::ErrorOut() << "Skill alignment can only be 'good', 'evil' or 'neutral'\n"; error_ = true; break; } if(cheat_) sk->SetUnlocked(true); skills_.push_back(sk); } skill = skill->NextSiblingElement("Skill"); } } else { Logger::ErrorOut() << "Malformed skills.xml, no root element 'Skills'\n"; error_ = true; } }
bool Progression::LoadSavefile() { description_.save_exists = false; bool error = false; TiXmlDocument doc(savefile_); doc.LoadFile(); if(!doc.Error()) { description_.save_exists = true; TiXmlElement* root = doc.FirstChildElement("Progress"); if(root) { TiXmlElement* points = root->FirstChildElement("Points"); if(points) { int good = 0; int evil = 0; if(points->QueryValueAttribute("Good", &good) == TIXML_SUCCESS && points->QueryValueAttribute("Evil", &evil) == TIXML_SUCCESS) { good_points_ = good; evil_points_ = evil; } else error = true; } else error = true; TiXmlElement* levels = root->FirstChildElement("Levels"); if(levels) { TiXmlElement* level = levels->FirstChildElement("Level"); while(level) { std::string id; int beaten = 0; if(level->QueryValueAttribute("id", &id) == TIXML_SUCCESS && level->QueryIntAttribute("Beaten", &beaten) == TIXML_SUCCESS) { for(std::vector<ProgressLevel*>::iterator it = levels_.begin(); it != levels_.end(); ++it) { if((*it)->GetFilename() == id) { (*it)->SetLocked(false); (*it)->SetBeaten(beaten ? 1 : 0); } } } else { error = true; break; } level = level->NextSiblingElement("Level"); } } else error = true; TiXmlElement* skills = root->FirstChildElement("Skills"); if(skills) { TiXmlElement* skill = skills->FirstChildElement("Skill"); while(skill) { std::string id; int purchased = 0; if(skill->QueryValueAttribute("id", &id) == TIXML_SUCCESS && skill->QueryIntAttribute("Purchased", &purchased) == TIXML_SUCCESS) { std::vector<Skill*> sm_skills = skill_manager_.GetAllSkills(); for(std::vector<Skill*>::iterator it = sm_skills.begin(); it != sm_skills.end(); ++it) { if((*it)->GetName() == id) { (*it)->SetUnlocked(true); (*it)->SetPurchased(purchased ? 1 : 0); TiXmlElement* rank = skill->FirstChildElement("Rank"); while(rank) { std::string rid; int level = 0; if(rank->QueryValueAttribute("id", &rid) == TIXML_SUCCESS && rank->QueryIntAttribute("Level", &level) == TIXML_SUCCESS) { SkillLevel* sl = (*it)->GetSkillLevel(rid); if(sl) { sl->SetLevel(level); } else Logger::DiagnosticOut() << "Malformed skill in campaign savefile\n"; } else Logger::DiagnosticOut() << "Malformed skill in campaign savefile\n"; rank = rank->NextSiblingElement("Rank"); } } } } else { error = true; break; } skill = skill->NextSiblingElement("Skill"); } } else error = true; } } if(error) Logger::ErrorOut() << "Malformed savefile\n"; return error; }
bool Progression::LoadCampaign(TiXmlDocument* _doc) { bool error_found = false; TiXmlElement* root = _doc->FirstChildElement("Campaign"); if(root) { root->QueryValueAttribute("name", &description_.name); root->QueryValueAttribute("desc", &description_.description); root->QueryValueAttribute("icon", &description_.icon_filename); TiXmlElement* level = root->FirstChildElement("Level"); while(level) { std::string levelname; std::string filename; bool locked = false; error_found |= level->QueryValueAttribute("name", &levelname) != TIXML_SUCCESS; error_found |= level->QueryValueAttribute("file", &filename) != TIXML_SUCCESS; error_found |= level->QueryValueAttribute("locked", &locked) != TIXML_SUCCESS; if(error_found) break; else { ProgressLevel* pl = new ProgressLevel(levelname, filename); if(cheat_) pl->SetLocked(false); else pl->SetLocked(locked); LoadUnlockables(level->FirstChildElement("Unlockable"), pl); levels_.push_back(pl); } level = level->NextSiblingElement("Level"); } TiXmlElement* skill = root->FirstChildElement("StartingSkill"); while(skill) { bool purchased = false; std::string skillname; skill->QueryValueAttribute("name", &skillname); skill->QueryValueAttribute("purchased", &purchased); if(skill_manager_.SkillExists(skillname)) { skill_manager_.Unlock(skillname); if(purchased) skill_manager_.Purchase(skillname); } else { Logger::DiagnosticOut() << "Skill " << skillname << " does not exist in skills.xml\n"; } skill = skill->NextSiblingElement("StartingSkill"); } } else { Logger::ErrorOut() << "Unable to find root Campaign node\n"; error_found = true; } return !error_found; }
bool Progression::LoadUnlockables(TiXmlElement* _first, ProgressLevel* _progress_level) { description_.unlockable_count = 0; bool error_found = false; TiXmlElement* unlockable = _first; while(unlockable) { bool require_good = false; bool require_evil = false; bool require_flawless = false; std::vector<std::string> skill_unlocks; std::vector<std::string> level_unlocks; TiXmlElement* condition = unlockable->FirstChildElement("Condition"); while(condition) { std::string alignment; if(condition->QueryValueAttribute("alignment", &alignment) == TIXML_SUCCESS) { if(alignment == "Evil") { require_evil = true; } else if(alignment == "Good") { require_good = true; } } condition->QueryValueAttribute("flawless", &require_flawless); condition = condition->NextSiblingElement("Condition"); } TiXmlElement* level_unlock = unlockable->FirstChildElement("LevelUnlock"); while(level_unlock) { std::string name; if(level_unlock->QueryValueAttribute("name", &name) != TIXML_SUCCESS) { error_found = true; Logger::ErrorOut() << "LevelUnlock requires a name attribute\n"; } else level_unlocks.push_back(name); level_unlock = level_unlock->NextSiblingElement("LevelUnlock"); } TiXmlElement* skill_unlock = unlockable->FirstChildElement("SkillUnlock"); while(skill_unlock) { std::string name; if(skill_unlock->QueryValueAttribute("name", &name) != TIXML_SUCCESS) { error_found = true; Logger::ErrorOut() << "SkillUnlock requires a name attribute\n"; } else skill_unlocks.push_back(name); skill_unlock = skill_unlock ->NextSiblingElement("SkillUnlock"); } _progress_level->AddUnlock(require_good, require_evil, require_flawless, level_unlocks, skill_unlocks); description_.unlockable_count++; unlockable = unlockable->NextSiblingElement("Unlockable"); } return false; }
bool VirtualTrajClient::SetupVirtual(const char* xmlFile) { virtualTimer.Reset(); Vector q(6,0.0); qmin.resize(6); qmax.resize(6); vmax.resize(6); amax.resize(6); dmax.resize(6); if(!xmlFile) { fill(qmin.begin(),qmin.end(),-45.0); fill(qmax.begin(),qmax.end(),45.0); fill(vmax.begin(),vmax.end(),20.0); fill(amax.begin(),amax.end(),50.0); fill(dmax.begin(),dmax.end(),50.0); maxSegments = 3000; maxRate = 250.0; //same as Staubli CS8 } else { TiXmlDocument doc; if(!doc.LoadFile(xmlFile)) { fprintf(stderr,"Error reading XML file %s\n",xmlFile); return false; } if(0!=strcmp(doc.RootElement()->Value(),"val3specs")) { fprintf(stderr,"Wrong type of root element %s\n",doc.RootElement()->Value()); return false; } TiXmlElement* e; e=doc.RootElement()->FirstChildElement("rate"); if(e && e->QueryValueAttribute("value",&maxRate) != TIXML_SUCCESS) { fprintf(stderr,"Could not read value attribute of rate\n"); maxRate = 250.0; } e=doc.RootElement()->FirstChildElement("queue"); if(e && e->QueryValueAttribute("size",&maxSegments) != TIXML_SUCCESS) { fprintf(stderr,"Could not read size attribute of queue\n"); maxSegments = 3000; } e=doc.RootElement()->FirstChildElement("joints"); if(e) { int n; if(e->QueryValueAttribute("num",&n) == TIXML_SUCCESS) { q.resize(n); qmin.resize(n); qmax.resize(n); vmax.resize(n); amax.resize(n); dmax.resize(n); } if(e->Attribute("value")) { stringstream ss(e->Attribute("value")); for(size_t i=0;i<q.size();i++) ss >> q[i]; } if(e->Attribute("min")) { stringstream ss(e->Attribute("min")); for(size_t i=0;i<q.size();i++) ss >> qmin[i]; } if(e->Attribute("max")) { stringstream ss(e->Attribute("max")); for(size_t i=0;i<q.size();i++) ss >> qmax[i]; }
bool XmlODESettings::GetSettings(ODESimulator& sim) { string globals="globals"; TiXmlElement* c = e->FirstChildElement(globals); if(c) { printf("Parsing globals...\n"); //parse globals: gravity, etc Vector3 gravity; if(c->QueryValueAttribute("gravity",&gravity)==TIXML_SUCCESS) sim.SetGravity(gravity); double worldERP,worldCFM; if(c->QueryValueAttribute("ERP",&worldERP)==TIXML_SUCCESS) sim.SetERP(worldERP); if(c->QueryValueAttribute("CFM",&worldCFM)==TIXML_SUCCESS) sim.SetCFM(worldCFM); int maxContacts; if(c->QueryValueAttribute("maxContacts",&maxContacts)==TIXML_SUCCESS) sim.GetSettings().maxContacts = maxContacts; int boundaryLayer,rigidObjectCollisions,robotSelfCollisions,robotRobotCollisions; if(c->QueryValueAttribute("boundaryLayer",&boundaryLayer)==TIXML_SUCCESS) { printf("XML simulator: warning, boundary layer settings don't have an effect\n"); sim.GetSettings().boundaryLayerCollisions = boundaryLayer; } if(c->QueryValueAttribute("rigidObjectCollisions",&rigidObjectCollisions)==TIXML_SUCCESS) sim.GetSettings().rigidObjectCollisions = rigidObjectCollisions; if(c->QueryValueAttribute("robotSelfCollisions",&robotSelfCollisions)==TIXML_SUCCESS) sim.GetSettings().robotSelfCollisions = robotSelfCollisions; if(c->QueryValueAttribute("robotRobotCollisions",&robotRobotCollisions)==TIXML_SUCCESS) sim.GetSettings().robotRobotCollisions = robotRobotCollisions; } else c=e->FirstChildElement(); while(c!=NULL) { const char* name=c->Value(); printf("Parsing element %s\n",name); if(0 == strcmp(name,"terrain")) { int index; if(c->QueryValueAttribute("index",&index)==TIXML_SUCCESS) { Assert(index < (int)sim.numEnvs()); TiXmlElement* eg=c->FirstChildElement("geometry"); if(eg) { XmlODEGeometry g(eg); if(!g.Get(*sim.envGeom(index))) { fprintf(stderr,"Error reading terrain geometry from XML\n"); return false; } } } else { fprintf(stderr,"Error reading terrain index from XML file\n"); return false; } } else if(0 == strcmp(name,"object")) { int index; if(c->QueryValueAttribute("index",&index)==TIXML_SUCCESS) { Assert(index < (int)sim.numObjects()); TiXmlElement* eg=c->FirstChildElement("geometry"); if(eg) { XmlODEGeometry g(eg); if(!g.Get(*sim.object(index)->triMesh())) { fprintf(stderr,"Error reading object geometry from XML\n"); return false; } } TiXmlElement *ev=c->FirstChildElement("velocity"); if(ev) { Vector3 v,w; if(ev->QueryValueAttribute("linear",&v) != TIXML_SUCCESS) v.setZero(); if(ev->QueryValueAttribute("angular",&w) != TIXML_SUCCESS) w.setZero(); cout<<"Setting velocity "<<w<<", "<<v<<endl; sim.object(index)->SetVelocity(w,v); } } else { fprintf(stderr,"Error reading object index from XML file\n"); return false; } } else if(0 == strcmp(name,"robot")) { int index,bodyIndex=-1; if(c->QueryValueAttribute("index",&index)==TIXML_SUCCESS) { Assert(index < (int)sim.numRobots()); if(c->QueryValueAttribute("body",&bodyIndex)==TIXML_SUCCESS) { } else bodyIndex=-1; ODERobot* robot=sim.robot(index); TiXmlElement* eg=c->FirstChildElement("geometry"); if(eg) { XmlODEGeometry g(eg); if(bodyIndex < 0) { for(size_t i=0;i<robot->robot.links.size();i++) { if(robot->triMesh(i)) g.Get(*robot->triMesh(i)); } } else { Assert(bodyIndex < (int)robot->robot.links.size()); if(robot->triMesh(bodyIndex)) g.Get(*robot->triMesh(bodyIndex)); } } } else { fprintf(stderr,"Error reading robot index from XML file\n"); return false; } } c=c->NextSiblingElement(); } return true; }
int CDBServiceConfig::LoadServiceTypes(TiXmlElement* pType, SServiceType& sServiceType) { SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s Start!\n",__FUNCTION__); char szName[256] = {0}; int nRet = pType->QueryValueAttribute("name", &szName); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,No Type Name\n",__FUNCTION__); return -1; } sServiceType.sTypeName = szName; boost::to_lower(sServiceType.sTypeName); // char szClass[16] = {0}; nRet = pType->QueryValueAttribute("class", &szClass); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,No Type Class\n",__FUNCTION__); return -1; } if(strncmp(szClass,"int",3)==0) { sServiceType.eType = DBP_DT_INT; } else if(strncmp(szClass,"string",6) == 0) { sServiceType.eType = DBP_DT_STRING; int nStrLen = 0; nRet = pType->QueryValueAttribute("length", (int *)&nStrLen); if(nRet == TIXML_SUCCESS) { sServiceType.nStrLen = nStrLen; } } else if(strncmp(szClass,"array",5) == 0) { sServiceType.eType = DBP_DT_ARRAY; char szItemType[256] = {0}; nRet = pType->QueryValueAttribute("itemtype", &szItemType); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,Get Array Element Error,Name=[%s]\n",__FUNCTION__,szName); return -1; } sServiceType.sElementName = szItemType; } else if(strncmp(szClass,"tlv",3) == 0) { char szArrayField[32] = {0}; nRet = pType->QueryValueAttribute("arrayfield", &szArrayField); if((nRet == TIXML_SUCCESS)&&(strncmp(szArrayField,"true",4) == 0)) { sServiceType.eType = DBP_DT_TLV_ARRAY; TiXmlElement * pTlvType = NULL; int nTypeCode = 0; nRet = pType->QueryValueAttribute("code", (int *)&nTypeCode); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s, Name=[%s] TLV-Array no code\n",__FUNCTION__,szName); return -1; } sServiceType.nTypeCode = nTypeCode; if((pTlvType=pType->FirstChildElement("field"))==NULL) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s, Name=[%s] TLV-Array Child No Type_Type\n",__FUNCTION__,szName); return -1; } else { char szItemType[256] = {0}; nRet = pTlvType->QueryValueAttribute("type", &szItemType); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,Get TLV-Array Element Error,Name=[%s]\n",__FUNCTION__,szName); return -1; } sServiceType.sElementName = szItemType; } } else { sServiceType.eType = DBP_DT_TLV; TiXmlElement * pTlvType = NULL; if((pTlvType=pType->FirstChildElement("field"))==NULL) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,TLV Child No Type_Type\n",__FUNCTION__); return -1; } else { SServiceType tlvElementType; if(LoadTlvServiceTypes(pTlvType,tlvElementType)<0) { return -1; } sServiceType.vecSubType.push_back(tlvElementType); } while((pTlvType=pTlvType->NextSiblingElement("field"))!=NULL) { SServiceType tlvElementType; if(LoadTlvServiceTypes(pTlvType,tlvElementType)<0) { return -1; } sServiceType.vecSubType.push_back(tlvElementType); } } } else if(strncmp(szClass,"struct",6) == 0) { sServiceType.eType = DBP_DT_STRUCT; TiXmlElement * pStructType = NULL; if((pStructType=pType->FirstChildElement("field"))==NULL) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,Struct Child No Type_Type\n",__FUNCTION__); return -1; } else { SServiceType structElementType; if(LoadStructServiceTypes(pStructType,structElementType)<0) { return -1; } sServiceType.vecSubType.push_back(structElementType); } while((pStructType=pStructType->NextSiblingElement("field"))!=NULL) { SServiceType structElementType; if(LoadStructServiceTypes(pStructType,structElementType)<0) { return -1; } sServiceType.vecSubType.push_back(structElementType); } } int nTypeCode = 0; nRet = pType->QueryValueAttribute("code", (int *)&nTypeCode); if(nRet == TIXML_SUCCESS) { sServiceType.nTypeCode = nTypeCode; } else { sServiceType.nTypeCode = 0; } SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s,code=[%d],name=[%s]\n", __FUNCTION__,sServiceType.nTypeCode,sServiceType.sTypeName.c_str()); return 0; }
int CDBServiceConfig::LoadSQLs(TiXmlElement* pSQL,SMsgAttri& sMsgAtrri) { SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s\n",__FUNCTION__); char szIsFullScan[16] = {0}; int nRet = pSQL->QueryValueAttribute("isfullscan", &szIsFullScan); if(nRet == TIXML_SUCCESS) { if(strncmp(szIsFullScan,"true",4) == 0) { sMsgAtrri.bIsFullScan = true; } else { sMsgAtrri.bIsFullScan = false; } } TiXmlElement *pMulPart = NULL; vector<SPartSql> parts; pMulPart = pSQL->FirstChildElement("mulpart"); while(pMulPart != NULL) { SPartSql ss; string strSql; if(pMulPart->GetText()==NULL) { /* cdata */ const char* pCDataSQL = pMulPart->FirstChild()->Value(); if(pCDataSQL) { strSql = pCDataSQL; } } else { strSql = pMulPart->GetText(); } ss.strSql = strSql; ss.dwConditon = OP_NOTHING; char szConditon[128] = {0}; char szVariable[128] = {0}; if (pMulPart->QueryValueAttribute("test", &szConditon)==TIXML_SUCCESS) { if (strcmp(szConditon,"null")==0) { ss.dwConditon=OP_NULL; } else if (strcmp(szConditon,"notnull")==0) { ss.dwConditon=OP_NOTNULL; } } if (pMulPart->QueryValueAttribute("variable", &szVariable)==TIXML_SUCCESS) { ss.strVariable=szVariable; boost::to_lower(ss.strVariable); } parts.push_back(ss); pMulPart=pMulPart->NextSiblingElement("mulpart"); } sMsgAtrri.exePartSQLs.push_back(parts); TiXmlElement *pPrefix = NULL; if(( pPrefix = pSQL->FirstChildElement("prefix")) == NULL) { /* simple sql */ string strTmp; if(pSQL->GetText()==NULL) { /* cdata */ const char* pCDataSQL = pSQL->FirstChild()->Value(); if(pCDataSQL) { strTmp = pCDataSQL; } } else { strTmp = pSQL->GetText(); } SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s,ORISQL=[%s]\n",__FUNCTION__,strTmp.c_str()); ProcessXMLCDATA(strTmp); MakeSQLToLower(strTmp); sMsgAtrri.exeSQLs.push_back(strTmp); char szParaCounts[16] = {0}; int paraCounts = -1; if (pSQL->QueryValueAttribute("paracounts", &szParaCounts)==TIXML_SUCCESS) { paraCounts = atoi(szParaCounts); } sMsgAtrri.paraCounts.push_back(paraCounts); SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s,SQL=[%s] ParaCounts=[%d]\n",__FUNCTION__,strTmp.c_str(), paraCounts); if(boost::istarts_with(strTmp,"update") || boost::istarts_with(strTmp,"delete") || boost::istarts_with(strTmp,"insert")) { sMsgAtrri.eOperType = DBO_WRITE; } } else { /* compose sql */ SComposeSQL composeSQL; composeSQL.sPrefix = pPrefix->GetText(); TiXmlElement *pSuffix = NULL; if( (pSuffix = pSQL->FirstChildElement("suffix")) != NULL) { composeSQL.sSuffix = pSuffix->GetText(); } TiXmlElement *pDetail = NULL; if( (pDetail = pSQL->FirstChildElement("detail")) != NULL) { string strDetail = pDetail->GetText(); MakeSQLToLower(strDetail); composeSQL.vecDetail.push_back(strDetail); while((pDetail=pDetail->NextSiblingElement("detail"))!=NULL) { strDetail = pDetail->GetText(); MakeSQLToLower(strDetail); composeSQL.vecDetail.push_back(strDetail); } } sMsgAtrri.exeComposeSQLs.push_back(composeSQL); if(boost::istarts_with(composeSQL.sPrefix,"update") || boost::istarts_with(composeSQL.sPrefix,"delete")) { sMsgAtrri.eOperType = DBO_WRITE; } } return 0; }
int CDBServiceConfig::LoadXmlByFileName(const string& sFileName) { SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s,FileName=[%s]\n",__FUNCTION__,sFileName.c_str()); TiXmlDocument m_xmlDoc; TiXmlElement *pService; if(!m_xmlDoc.LoadFile(sFileName.c_str())) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,Load File Error,FileName=[%s]\n",__FUNCTION__,sFileName.c_str()); return -1; } if((pService=m_xmlDoc.RootElement())==NULL) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,No RootElement,FileName=[%s]\n",__FUNCTION__,sFileName.c_str()); return -1; } SServiceDesc serviceDesc; char szName[64] = {0}; int nRet = pService->QueryValueAttribute("name", &szName); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,No Service Name,FileName=[%s]\n",__FUNCTION__,sFileName.c_str()); return -1; } serviceDesc.sServiceName = szName; boost::to_lower(serviceDesc.sServiceName); serviceDesc.bReadOnly = false; char szReadOnly[64]={0}; nRet = pService->QueryValueAttribute("queryonly", &szReadOnly); if(nRet == TIXML_SUCCESS) { if (strncmp(szReadOnly,"true",4)==0) { serviceDesc.bReadOnly = true; } } int nServiceId = 0; nRet = pService->QueryIntAttribute("id", (int *)&nServiceId); if(nRet != TIXML_SUCCESS) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,Get ServiceId Error\n",__FUNCTION__); return -1; } serviceDesc.nServiceId = nServiceId; /* get types */ TiXmlElement * pConfigType = NULL; if((pConfigType=pService->FirstChildElement("type"))==NULL) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,No Type,FileName=[%s]\n",__FUNCTION__,sFileName.c_str()); return -1; } else { SServiceType serviceType; if(LoadServiceTypes(pConfigType,serviceType)<0) { return -1; } serviceDesc.mapServiceType.insert(make_pair(serviceType.sTypeName,serviceType)); } while((pConfigType=pConfigType->NextSiblingElement("type"))!=NULL) { SServiceType serviceType; if(LoadServiceTypes(pConfigType,serviceType)<0) { return -1; } serviceDesc.mapServiceType.insert(make_pair(serviceType.sTypeName,serviceType)); } PostProcessServiceTypes(serviceDesc.mapServiceType); //get message attribute TiXmlElement * pMsgAttri = NULL; if((pMsgAttri=pService->FirstChildElement("message"))==NULL) { SC_XLOG(XLOG_ERROR, "CDBServiceConfig::%s,No Message,FileName=[%s]\n",__FUNCTION__,sFileName.c_str()); return -1; } else { SMsgAttri sMsgAttri; if(LoadServiceMessage(pMsgAttri,sMsgAttri)<0) { return -1; } SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s,OperType=[%d]\n",__FUNCTION__,sMsgAttri.eOperType); serviceDesc.mapMsgAttri.insert(make_pair(sMsgAttri.nMsgId,sMsgAttri)); } while((pMsgAttri=pMsgAttri->NextSiblingElement("message"))!=NULL) { SMsgAttri sMsgAttri; if(LoadServiceMessage(pMsgAttri,sMsgAttri)<0) { return -1; } SC_XLOG(XLOG_DEBUG, "CDBServiceConfig::%s,OperType=[%d]\n",__FUNCTION__,sMsgAttri.eOperType); serviceDesc.mapMsgAttri.insert(make_pair(sMsgAttri.nMsgId,sMsgAttri)); } PostProcessMsgAttri(serviceDesc.mapMsgAttri,serviceDesc.mapServiceType); mapServiceConfig.insert(make_pair(serviceDesc.nServiceId,serviceDesc)); return 0; }
void CButtonTranslator::MapJoystickActions(int windowID, TiXmlNode *pJoystick) { string joyname = "_xbmc_"; // default global map name vector<string> joynames; map<int, string> buttonMap; map<int, string> axisMap; map<int, string> hatMap; TiXmlElement *pJoy = pJoystick->ToElement(); if (pJoy && pJoy->Attribute("name")) joyname = pJoy->Attribute("name"); else CLog::Log(LOGNOTICE, "No Joystick name specified, loading default map"); joynames.push_back(joyname); // parse map TiXmlElement *pButton = pJoystick->FirstChildElement(); int id = 0; //char* szId; const char* szType; const char *szAction; while (pButton) { szType = pButton->Value(); szAction = pButton->GetText(); if (szAction == NULL) szAction = ""; if (szType) { if ((pButton->QueryIntAttribute("id", &id) == TIXML_SUCCESS) && id>=0 && id<=256) { if (strcmpi(szType, "button")==0) { buttonMap[id] = string(szAction); } else if (strcmpi(szType, "axis")==0) { int limit = 0; if (pButton->QueryIntAttribute("limit", &limit) == TIXML_SUCCESS) { if (limit==-1) axisMap[-id] = string(szAction); else if (limit==1) axisMap[id] = string(szAction); else if (limit==0) axisMap[id|0xFFFF0000] = string(szAction); else { axisMap[id] = string(szAction); axisMap[-id] = string(szAction); CLog::Log(LOGERROR, "Error in joystick map, invalid limit specified %d for axis %d", limit, id); } } else { axisMap[id] = string(szAction); axisMap[-id] = string(szAction); } } else if (strcmpi(szType, "hat")==0) { string position; if (pButton->QueryValueAttribute("position", &position) == TIXML_SUCCESS) { uint32_t hatID = id|0xFFF00000; if (position.compare("up") == 0) hatMap[(JACTIVE_HAT_UP<<16)|hatID] = string(szAction); else if (position.compare("down") == 0) hatMap[(JACTIVE_HAT_DOWN<<16)|hatID] = string(szAction); else if (position.compare("right") == 0) hatMap[(JACTIVE_HAT_RIGHT<<16)|hatID] = string(szAction); else if (position.compare("left") == 0) hatMap[(JACTIVE_HAT_LEFT<<16)|hatID] = string(szAction); else CLog::Log(LOGERROR, "Error in joystick map, invalid position specified %s for axis %d", position.c_str(), id); } } else CLog::Log(LOGERROR, "Error reading joystick map element, unknown button type: %s", szType); } else if (strcmpi(szType, "altname")==0) joynames.push_back(string(szAction)); else CLog::Log(LOGERROR, "Error reading joystick map element, Invalid id: %d", id); } else CLog::Log(LOGERROR, "Error reading joystick map element, skipping"); pButton = pButton->NextSiblingElement(); } vector<string>::iterator it = joynames.begin(); while (it!=joynames.end()) { m_joystickButtonMap[*it][windowID] = buttonMap; m_joystickAxisMap[*it][windowID] = axisMap; m_joystickHatMap[*it][windowID] = hatMap; // CLog::Log(LOGDEBUG, "Found Joystick map for window %d using %s", windowID, it->c_str()); it++; } }
AnimationPtr AnimationLoader::load(const std::string& filename) { bfs::path animPath(filename); std::string animationFilename = animPath.string(); TiXmlDocument doc; AnimationPtr animation; try { RawData* data = m_vfs->open(animationFilename); if (data) { if (data->getDataLength() != 0) { doc.Parse(data->readString(data->getDataLength()).c_str()); if (doc.Error()) { return animation; } // done with data delete resource delete data; data = 0; } } } catch (NotFound& e) { FL_ERR(_log, e.what()); // TODO - should we abort here // or rethrow the exception // or just keep going return animation; } // if we get here then everything loaded properly // so we can just parse out the contents TiXmlElement* root = doc.RootElement(); if (root) { animation.reset(new Animation()); int animDelay = 0; root->QueryValueAttribute("delay", &animDelay); int animXoffset = 0; int animYoffset = 0; int action = -1; root->QueryValueAttribute("x_offset", &animXoffset); root->QueryValueAttribute("y_offset", &animYoffset); root->QueryValueAttribute("action", &action); for (TiXmlElement* frameElement = root->FirstChildElement("frame"); frameElement; frameElement = frameElement->NextSiblingElement("frame")) { if (animation) { animation->setActionFrame(action); const std::string* sourceId = frameElement->Attribute(std::string("source")); if (sourceId) { bfs::path framePath(filename); if (HasParentPath(framePath)) { framePath = GetParentPath(framePath) / *sourceId; } else { framePath = bfs::path(*sourceId); } ImagePtr imagePtr; if(!m_imageManager->exists(framePath.string())) { imagePtr = m_imageManager->create(framePath.string()); } else { imagePtr = m_imageManager->getPtr(framePath.string()); } if (imagePtr) { int frameXoffset = 0; int frameYoffset = 0; int success = root->QueryValueAttribute("x_offset", &frameXoffset); if (success == TIXML_SUCCESS) { imagePtr->setXShift(frameXoffset); } else { imagePtr->setXShift(animXoffset); } success = root->QueryValueAttribute("y_offset", &frameYoffset); if (success == TIXML_SUCCESS) { imagePtr->setYShift(frameYoffset); } else { imagePtr->setYShift(animYoffset); } int frameDelay = 0; success = root->QueryValueAttribute("delay", &frameDelay); if (success == TIXML_SUCCESS) { animation->addFrame(imagePtr, frameDelay); } else { animation->addFrame(imagePtr, animDelay); } } } } } } return animation; }