static TUIObjectInstance extractTUIObjectInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
TUIObjectInstance tuiObjectInstance;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
tuiObjectInstance.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
DOMNode * tuiTypeNameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename"));
if (tuiTypeNameAttribute) {
tuiObjectInstance.setTypeName(XMLString::transcode(tuiTypeNameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
XMLCh * textContent = XMLString::replicate(node->getTextContent());
XMLString::trim(textContent);
tuiObjectInstance.setDescription(XMLString::transcode(textContent));
XMLString::release(&textContent);
}
node = domTreeWalker->nextNode();
}
return tuiObjectInstance;
}
void
Importer::addVertexToScene
(xercesc::DOMNode* vertexNode, Scene* scene)
{
DOMNamedNodeMap* attributes = vertexNode->getAttributes();
DOMNode* indexNode = attributes->getNamedItem(XMLString::transcode("index"));
DOMNode* typeNode = attributes->getNamedItem(XMLString::transcode("type"));
int vertex_index = atoi(XMLString::transcode(indexNode->getNodeValue()));
string vertex_type = XMLString::transcode(typeNode->getNodeValue());
XMLCh* x_ch = XMLString::transcode("x");
XMLCh* y_ch = XMLString::transcode("y");
XMLCh* z_ch = XMLString::transcode("z");
float x = getValueFromTag(vertexNode, x_ch);
float y = getValueFromTag(vertexNode, y_ch);
float z = getValueFromTag(vertexNode, z_ch);
// Instanciar la posición del nodo.
Ogre::Vector3 position(x, y, z);
// Instanciar el nodo.
std::cout << vertex_type << std::endl;
Node n(vertex_index, vertex_type, position);
// Añadir el nodo a la estructura de grafo.
scene->getGraph()->addVertex(new GraphVertex(n));
XMLString::release(&x_ch);
XMLString::release(&y_ch);
XMLString::release(&z_ch);
}
void AcsAlarmTestCase::verifyUserTimestampElement(DOMDocument * doc)
{
// Verify the user-timestamp element
DOMNodeList * userTimestampNodes = doc->getElementsByTagName(USER_TIMESTAMP_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no user-properties element found",
(NULL != userTimestampNodes && userTimestampNodes->getLength() == 1));
// verify that there are 2 attributes
DOMNamedNodeMap * attributesMap = userTimestampNodes->item(0)->getAttributes();
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element does not contain 2 attributes",
(NULL!= attributesMap && attributesMap->getLength() == 2));
// check for seconds attribute
DOMNode * secondsValueNode = attributesMap->getNamedItem(SECONDS_TAG_NAME);
const XMLCh * secondsValue = secondsValueNode->getNodeValue();
char *secondsCharValue = XMLString::transcode(secondsValue);
int secondsIntValue = atoi(secondsCharValue);
XMLString::release(&secondsCharValue);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element, 'seconds' attribute value is not correct",
(NULL!= secondsValue && secondsIntValue == SECONDS_VALUE));
// check for microseconds attribute
DOMNode * microsecondsValueNode = attributesMap->getNamedItem(MICROSECONDS_TAG_NAME);
const XMLCh * microsecondsValue = microsecondsValueNode->getNodeValue();
char *microsecondsCharValue = XMLString::transcode(microsecondsValue);
int microsecondsIntValue = atoi(microsecondsCharValue);
XMLString::release(µsecondsCharValue);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element, 'microseconds' attribute value is not correct",
(NULL!= microsecondsValue && microsecondsIntValue == MICROSECONDS_VALUE));
}
void AcsAlarmTestCase::verifyFaultStateElement(DOMDocument * doc, bool propertiesAndTimestampPopulated)
{
// Verify that the fault-state element exists
DOMNodeList * faultStateNodes = doc->getElementsByTagName(FAULT_STATE_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no fault-state element found",
(NULL != faultStateNodes && faultStateNodes->getLength() == 1));
// verify that there are the expected attributes (family, member, code) on the fault-state element
DOMNode * faultStateItem = faultStateNodes->item(0);
if(NULL != faultStateItem)
{
// verify that there are 3 attributes in total
DOMNamedNodeMap * attributesMap = faultStateItem->getAttributes();
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 3 attributes",
(NULL!= attributesMap && attributesMap->getLength() == 3));
// check that the fault-state element has a "family" attribute
DOMNode * familyNode = attributesMap->getNamedItem(FAMILY_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'family' attribute",
(NULL!= familyNode));
// verify that the value of family attribute is correct
const XMLCh * familyNodeValue = familyNode->getNodeValue();
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'family' is not correct",
(NULL != familyNodeValue && XMLString::equals(familyNodeValue, FAMILY_VALUE_XMLCH)));
// check that the fault-state element has a "member" attribute
DOMNode * memberNode = attributesMap->getNamedItem(MEMBER_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'member' attribute",
(NULL!= memberNode));
// verify that the value of member attribute is correct
const XMLCh * memberNodeValue = memberNode->getNodeValue();
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'member' is not correct",
(NULL != memberNodeValue && XMLString::equals(memberNodeValue, MEMBER_VALUE_XMLCH)));
// check that the fault-state element has a "code" attribute
DOMNode * codeNode = attributesMap->getNamedItem(CODE_TAG_NAME);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'code' attribute",
(NULL!= codeNode));
// verify that the value of code attribute is correct
const XMLCh * codeNodeValue = codeNode->getNodeValue();
char *codeNodeCharValue = XMLString::transcode(codeNodeValue);
int codeNodeValueInt = atoi(codeNodeCharValue);
XMLString::release(&codeNodeCharValue);
CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'code' is not correct",
(NULL != codeNodeValue && codeNodeValueInt == CODE_VALUE));
}
verifyDescriptorElement(doc);
if(propertiesAndTimestampPopulated)
{
verifyUserPropertiesElement(doc);
verifyUserTimestampElement(doc);
}
}
static MSPInstance extractMSPInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
MSPInstance mspInstance;
map<string, ParameterGroup> parameterGroupMap;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
mspInstance.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
DOMNode * typeNameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename"));
if (typeNameAttribute) {
//TFDEBUG(XMLString::transcode(typeNameAttribute->getNodeValue()));
mspInstance.setTypeName(XMLString::transcode(typeNameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
ParameterGroup pg = extractParameterGroup(domDocument, d);
pg.setName(name);
parameterGroupMap[name] = pg;
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
XMLCh * textContent = XMLString::replicate(node->getTextContent());
XMLString::trim(textContent);
mspInstance.setDescription(XMLString::transcode(textContent));
XMLString::release(&textContent);
}
node = domTreeWalker->nextNode();
}
ParameterGroup parameterGroup;
parameterGroup.setName("root");
parameterGroup.setParameterGroupMap(parameterGroupMap);
mspInstance.setParameterGroup(parameterGroup);
return mspInstance;
}
static ParameterGroup extractParameterGroup(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
map<string, string> parameterMap;
map<string, ParameterGroup> parameterGroupMap;
DOMNode * node = domTreeWalker->nextNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Parameter") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
string value;
DOMNode * valueAttribute = nodeMap->getNamedItem(XMLString::transcode("value"));
if (valueAttribute) {
value = XMLString::transcode(valueAttribute->getNodeValue());
}
parameterMap[name] = value;
//TFINFO("Parameter: " << name << " -> " << value);
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
ParameterGroup pg = extractParameterGroup(domDocument, d);
pg.setName(name);
parameterGroupMap[name] = pg;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
ParameterGroup parameterGroup;
parameterGroup.setParameterMap(parameterMap);
parameterGroup.setParameterGroupMap(parameterGroupMap);
return parameterGroup;
}
const char* SYSTEM::CConfigItem::GetProperties(const char * propName)
{
if(!propName)
{
return NULL;
}
if(((DOMElement*)itemElement)->hasAttributes()) //判断当前节点是否存在属性
{
DOMNamedNodeMap *pAttributes = ((DOMElement*)itemElement)->getAttributes();
XMLCh *t = XMLString::transcode(propName);
DOMAttr *pAttributeNode = (DOMAttr*)pAttributes->getNamedItem(t);
XMLString::release(&t);
if( m_curValue != NULL )
XMLString::release(&m_curValue);
if(!pAttributeNode) //属性名称不存在
m_curValue = NULL;
else
m_curValue = XMLString::transcode(pAttributeNode->getValue());
return m_curValue;
}
else
{
return NULL;
}
}
void SYSTEM::CConfigItem::SetProperties(const char * propName, const char * value)
{
if(!propName||!value)
{
return;
}
if(((DOMElement*)itemElement)->hasAttributes())
{
DOMNamedNodeMap *pAttributes = ((DOMElement*)itemElement)->getAttributes();
XMLCh *t = XMLString::transcode(propName);
DOMAttr *pAttributeNode = (DOMAttr*)pAttributes->getNamedItem(t);
XMLString::release(&t);
if(!pAttributeNode)
{
return; //属性名错误，抛出异常
}
t = XMLString::transcode(value);
pAttributeNode->setValue(t);
XMLString::release(&t);
}
else
{
return;
}
}
/**
* extract's the value of an attribute and returns it:
*
* <parentNode>
* <elementNode attribute="returnstring" />
* </parentNode>
*
* the first parentNode found in the document is used. thus, it is expected to be unique.
*
* @param parentNode
* @param elementNode
* @param attribute
* @return
*/
string InputHandler::getAttributeValue(const XMLCh* parentNode, const XMLCh* elementNode, const XMLCh* attribute)
{
crusde_debug("%s, line: %d, InputHandler::getAttributeValue(%s) ", __FILE__, __LINE__, XMLString::transcode(elementNode));
DOMElement *root = doc->getDocumentElement();
DOMNodeList *node_list = root->getElementsByTagName(parentNode);
/*if element does not exist, return emptry string*/
if(node_list->getLength() == 0)
return string();
DOMNode *child = node_list->item(0)->getFirstChild();
DOMNamedNodeMap *attributes = NULL;
while (child)
{
if( child->getNodeType() == DOMNode::ELEMENT_NODE)
{
attributes = child->getAttributes();
if( XMLString::compareIString(child->getNodeName(), elementNode) == 0 )
{
char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue());
string value(val);
XMLString::release(&val);
return value;
}
}
child = child->getNextSibling();
}
return string();
}
static TUIObjectType extractTUIObjectType(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
TUIObjectType tuiObjectType;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
tuiObjectType.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "PortTypeSequence") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
tuiObjectType.setPortMap(extractPortMap(domDocument, d));
d->release();
delete nodeFilter;
} else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) {
XMLCh * textContent = XMLString::replicate(node->getTextContent());
XMLString::trim(textContent);
tuiObjectType.setDescription(XMLString::transcode(textContent));
XMLString::release(&textContent);
}
node = domTreeWalker->nextNode();
}
return tuiObjectType;
}
static DeviceInstance extractDeviceInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
DeviceInstance deviceInstance;
map<string, ParameterGroup> parameterGroupMap;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
deviceInstance.setName(XMLString::transcode(nameAttribute->getNodeValue()));
}
DOMNode * typenameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename"));
if (typenameAttribute) {
deviceInstance.setDeviceTypeName(XMLString::transcode(typenameAttribute->getNodeValue()));
}
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
string name;
DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name"));
if (nameAttribute) {
name = XMLString::transcode(nameAttribute->getNodeValue());
}
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
ParameterGroup pg = extractParameterGroup(domDocument, d);
pg.setName(name);
parameterGroupMap[name] = pg;
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
ParameterGroup parameterGroup;
parameterGroup.setName("root");
parameterGroup.setParameterGroupMap(parameterGroupMap);
deviceInstance.setParameterGroup(parameterGroup);
return deviceInstance;
}
LibraryElement* ColladaObject::CreateLibraryElement(const DOMNode* node)
{
_ASSERTE(node != NULL);
if( IsElementNode( node ) == false ) { return NULL; }
DOMNamedNodeMap* attr = node->getAttributes();
if( attr == NULL ) { return NULL; }
const DOMNode* type = attr->getNamedItem( (const XMLCh*)L"type" );
if( type == NULL ) { return NULL; }
LibraryElement* library = NULL;
if( IsNodeValueEquals( type, L"ANIMATION" ) )
{
library = new AnimationLibrary();
}
else if( IsNodeValueEquals( type, L"CAMERA" ) )
{
library = new CameraLibrary();
}
else if( IsNodeValueEquals( type, L"CODE" ) )
{
library = new CodeLibrary();
}
else if( IsNodeValueEquals( type, L"CONTROLLER" ) )
{
library = new ControllerLibrary();
}
else if( IsNodeValueEquals( type, L"GEOMETRY" ) )
{
library = new GeometryLibrary();
}
else if( IsNodeValueEquals( type, L"IMAGE" ) )
{
library = new ImageLibrary();
}
else if( IsNodeValueEquals( type, L"LIGHT" ) )
{
library = new LightLibrary();
}
else if( IsNodeValueEquals( type, L"MATERIAL" ) )
{
library = new MaterialLibrary();
}
else if( IsNodeValueEquals( type, L"PROGRAM" ) )
{
library = new ProgramLibrary();
}
else if( IsNodeValueEquals( type, L"TEXTURE" ) )
{
library = new TextureLibrary();
}
else{ _ASSERTE(!"UnknownLibraryType"); }
return library;
}
void
OptionValueParser::parse_category(OptionCategory* category, DOMNode* node)
{
DOMNodeList* children = node->getChildNodes();
// Traverse the children
for (size_t i = 0; i < children->getLength(); ++i)
{
DOMNode* item = children->item(i);
if (item->getNodeType() != DOMNode::ELEMENT_NODE)
continue;
XMLUnicodeString node_name =
item->getNodeName();
DOMNamedNodeMap* attributes = item->getAttributes();
XMLUnicodeString name =
attributes->getNamedItem(XMLUnicodeString("name"))->getNodeValue();
if (node_name.str() == std::string("OptionCategory"))
{
// Parsing a category node
parse_category(category->category(name.str().c_str()), item);
}
else
{
// Parsing an option node
Option* option = category->option(name.str().c_str());
if (option && (node_name.str() == std::string("BooleanOption")))
{
parse_boolean_option((BooleanOption*) option, item);
}
else if (option && (node_name.str() == std::string("StringOption")))
{
parse_string_option((StringOption*) option, item);
}
else if (option && (node_name.str() == std::string("IntegerOption")))
{
parse_integer_option((IntegerOption*) option, item);
}
else if (option && (node_name.str() == std::string("EnumOption")))
{
parse_enum_option((EnumOption*) option, item);
}
/*
else
throw UnknownOptionKind(name.str());
*/
}
}
}
set<StringTable::countryCode>
XMLIndata::parseCountryList(const DOMNode* cntrListTopNode){
set<StringTable::countryCode> countryList;
mc2dbg << "Parsing country list" << endl;
const XMLCh* name = cntrListTopNode->getNodeName();
if ( ! WFXMLStr::equals(name, "country_list") ){
mc2log << error << "Strange country list element name: " << name
<< endl;
MC2_ASSERT(false);
}
const DOMNodeList* countryNodes = cntrListTopNode->getChildNodes();
for (XMLSize_t i=0; i<countryNodes->getLength(); i++){
DOMNode* countryNode = countryNodes->item(i);
DOMNode::NodeType nodeType =
static_cast<DOMNode::NodeType>(countryNode->getNodeType());
const XMLCh* name = countryNode->getNodeName();
if ( nodeType == DOMNode::ELEMENT_NODE ){
if ( WFXMLStr::equals(name,"country") ){
DOMNamedNodeMap* attributes = countryNode->getAttributes();
DOMNode* attribute =
attributes->getNamedItem( X( "id_string" ) );
MC2_ASSERT( attribute != NULL );
MC2String gmsName =
XMLString::transcode( attribute->getNodeValue() );
StringTable::countryCode countryCode =
MapGenUtil::getCountryCodeFromGmsName( gmsName );
mc2dbg << " Country: " << gmsName << " "
<< countryCode << endl;
if ( countryCode == StringTable::NBR_COUNTRY_CODES ){
mc2log << error << "Strange GMS name: "
<< gmsName << endl;
MC2_ASSERT(false);
}
countryList.insert(countryCode);
}
else {
mc2log << error << "Strange element name: " << name << endl;
MC2_ASSERT(false);
}
}
else if ( nodeType == DOMNode::COMMENT_NODE ){
// Don't bother with comments.
}
else {
mc2log << error << "Strange node type: " << nodeType << endl;
MC2_ASSERT(false);
}
}
return countryList;
} // parseCountryList
static PortAddress extractPortAddress(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
PortAddress portAddress;
DOMNode * node = domTreeWalker->getCurrentNode();
DOMNamedNodeMap * nodeMap = node->getAttributes();
// entityType = DEV | TUI | MSP
DOMNode * entityTypeAttribute = nodeMap->getNamedItem(XMLString::transcode("entityType"));
if (entityTypeAttribute) {
if (XMLString::compareString(XMLString::transcode(entityTypeAttribute->getNodeValue()), "DEV") == 0) {
//TFINFO("DEV");
portAddress.setOwnerType(PortAddress::DEVICE);
} else if (XMLString::compareString(XMLString::transcode(entityTypeAttribute->getNodeValue()), "TUI") == 0) {
//TFINFO("TUI");
portAddress.setOwnerType(PortAddress::TUIOBJECT);
} else if (XMLString::compareString(XMLString::transcode(entityTypeAttribute->getNodeValue()), "MSP") == 0) {
//TFINFO("MSP");
portAddress.setOwnerType(PortAddress::MSP);
} else {
// TODO throw Exception
TFERROR("");
}
} else {
TFERROR("No entityType found")
}
DOMNode * entityNameAttribute = nodeMap->getNamedItem(XMLString::transcode("entityName"));
if (entityNameAttribute) {
portAddress.setName(XMLString::transcode(entityNameAttribute->getNodeValue()));
} else {
TFERROR("No entityName found")
}
DOMNode * portNameAttribute = nodeMap->getNamedItem(XMLString::transcode("portName"));
if (portNameAttribute) {
portAddress.setPortName(XMLString::transcode(portNameAttribute->getNodeValue()));
} else {
TFERROR("No portName found")
}
return portAddress;
}
/**
* Retrieve the value of an attribute
* @param node the DOMNode we are extracting an attribute from
* @param name the name of the attribute we want
* @return the value of the attribute or NULL if no such attribute is found
*/
char* getAttribute(DOMNode* node, const char* name) {
if (node == NULL)
return NULL;
DOMNamedNodeMap* map = node->getAttributes();
if (map == NULL)
return NULL;
DOMNode* attribute = map->getNamedItem(XMLString::transcode(name));
if (attribute == NULL)
return NULL;
return XMLString::transcode(attribute->getNodeValue());
}
string InputHandler::getAttributeValueByName(const XMLCh* elementNode, const XMLCh* attribute, const XMLCh* name)
{
crusde_debug("%s, line: %d, InputHandler::getAttributeValueByName(%s) name = %s ", __FILE__, __LINE__, XMLString::transcode(elementNode),
XMLString::transcode(name));
assert(doc);
DOMElement *root = doc->getDocumentElement();
DOMNode *child = root->getFirstChild();
DOMNamedNodeMap *attributes = NULL;
while (child)
{
if(child != NULL)
if( child->getNodeType() == DOMNode::ELEMENT_NODE )
{
if(child->hasAttributes())
{
attributes = child->getAttributes();
if( XMLString::compareIString( child->getNodeName(), elementNode) == 0 &&
XMLString::compareIString( attributes->getNamedItem(ATTR_name.xmlStr())->getNodeValue(), name) == 0 )
{
char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue());
string value(val);
XMLString::release(&val);
return value;
}
}
}
child = child->getNextSibling();
}
return string();
}
static long getRequiredLongOrThrow( DOMNode* node, const char* attribName )
throw ( XMLServerErrorMsg ) {
DOMNamedNodeMap* attribs = node->getAttributes();
DOMNode* attrib_to_find = attribs->getNamedItem( X( attribName ) );
if ( attrib_to_find == NULL ) {
MC2String nodeName =
XMLUtility::transcodefrom(node->getNodeName());
MC2String msg = MC2String("Node \"") + nodeName
+ "\" requires attribute \"" + attribName + '"';
mc2log << warn << __FUNCTION__ << " " << msg << endl;
throw XMLServerErrorMsg( "-1", msg );
} else {
// Try to get the value.
return getLongOrThrow( attrib_to_find, node );
}
}
bool ConfigurationFileHandler::getSubAlgorithm(std::string algorithm, std::string subalgorithm, std::string* result){
#ifdef BRICS_XERCES_ENABLE
if (errorsOccured) {
return false;
}
DOMNode* current = NULL;
DOMNode* attributeNode = NULL;
XMLCh* algorithmName = XMLString::transcode(algorithm.c_str());
XMLCh* subAlgorithmName = XMLString::transcode(subalgorithm.c_str());
XMLCh* implementationString = XMLString::transcode("implementation");
bool subAlgorithmFound = false;
DOMDocument* doc = parser->getDocument();
DOMNodeList* root = doc->getElementsByTagName(algorithmName);
if (root->getLength() > 1) {
LOG(WARNING) << "More than one " << algorithm << " found, taking the first one";
} else if(root->getLength() < 1) {
LOG(WARNING) << "No algorithm called " << algorithm << " found.";
return false; //TODO release resouces
}
current = root->item(0);
//search in children notes
for (current = current->getFirstChild()->getNextSibling(); current!=NULL; current = current->getNextSibling()) {
string nodeName = XMLString::transcode(current->getNodeName());
if (nodeName.compare(subalgorithm) == 0) {
DOMNamedNodeMap* attributesList = current->getAttributes();
attributeNode = attributesList->getNamedItem(implementationString);
if (attributeNode != 0) {
*result = XMLString::transcode(attributeNode->getNodeValue());
subAlgorithmFound = true;
break; //take only first found
}
}
}
XMLString::release(&algorithmName);
XMLString::release(&subAlgorithmName);
XMLString::release(&implementationString);
return subAlgorithmFound;
#else
return false;
#endif
}
static ServerStartupConfig extractServerStartupConfig(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
ServerStartupConfig serverStartupConfig;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Network") == 0) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
DOMNode * portAttribute = nodeMap->getNamedItem(XMLString::transcode("port"));
if (portAttribute) {
serverStartupConfig.setPortNr(XMLString::parseInt(portAttribute->getNodeValue()));
}
}
node = domTreeWalker->nextNode();
}
return serverStartupConfig;
}
static void removeBaseAttr(DOMDocument * domDocument) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * domTreeWalker = domDocument->createTreeWalker(domDocument, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
DOMNamedNodeMap * nodeMap = node->getAttributes();
if (nodeMap != 0) {
DOMNode * attr = nodeMap->getNamedItem(XMLString::transcode("xml:base"));
if (attr) {
DOMNode * node = nodeMap->removeNamedItem(XMLString::transcode("xml:base"));
TFINFO("[Server Config] filtered attribute: " << XMLString::transcode(node->getNodeName()) << "=" << XMLString::transcode(node->getNodeValue()));
node->release();
}
}
node = domTreeWalker->nextNode();
}
delete nodeFilter;
}
bool ConfigurationFileHandler::getAttribute(std::string algorithm, std::string attribute, int* result) {
#ifdef BRICS_XERCES_ENABLE
if (errorsOccured) {
return false;
}
DOMNode* current = NULL;
DOMNode* attributeNode = NULL;
XMLCh* algorithmName = XMLString::transcode(algorithm.c_str());
XMLCh* attributeName = XMLString::transcode(attribute.c_str());
string tmpResult;
bool attributeFound = false;
DOMDocument* doc = parser->getDocument();
DOMNodeList* root = doc->getElementsByTagName(algorithmName);
if (root->getLength() > 1) {
LOG(WARNING) << "More than one " << algorithm << " found, taking the first one";
} else if(root->getLength() < 1) {
LOG(WARNING) << "No algorithm called " << algorithm << " found.";
return false; //TODO release resouces
}
current = root->item(0);
DOMNamedNodeMap* attributesList = current->getAttributes();
attributeNode = attributesList->getNamedItem(attributeName);
if (attributeNode != 0) {
tmpResult = XMLString::transcode(attributeNode->getNodeValue());
*result = atoi(tmpResult.c_str());
attributeFound = true;
}
XMLString::release(&algorithmName);
XMLString::release(&attributeName);
return attributeFound;
#else
return false;
#endif
}
bool XmlWorldReader::Read(const std::string &file) {
// ワールドを初期化
try {
initialize();
if (initFlag) {
initializeWorld();
}
} catch (...) {
return false;
}
// TODO: ファイルの有無を確認
// XMLファイルをパース
const XMLCh gLS[] = {chLatin_L, chLatin_S, chNull};
DOMImplementationLS *impl = DOMImplementationRegistry::getDOMImplementation(gLS);
DOMLSParser *parser = impl->createLSParser(
DOMImplementationLS::MODE_SYNCHRONOUS, NULL
);
DOMDocument *doc = parser->parseURI(file.c_str());
if (doc == nullptr) {
return false;
}
// rootノードを取得
DOMElement *worldElement = doc->getDocumentElement();
if (worldElement == nullptr) {
parser->release();
return false;
}
{
YPT::XmlString temp("world");
bool res = XMLString::equals(worldElement->getNodeName(), temp);
if (!res) {
parser->release();
return false;
}
}
// ロード用クラス作成
YPT::XmlWorldPartReader partReader(doc);
// XPathコンテキスト作成
DOMXPathNSResolver *resolver = doc->createNSResolver(worldElement);
if (resolver == nullptr) {
parser->release();
return false;
}
YPT::XmlString str, str2;
DOMXPathResult *result;
// --------------------------------------------------
// ワールド全体の設定
// --------------------------------------------------
// ワールド名
str = worldElement->getAttribute(YPT::XmlString("name"));
if (str != "") {
name = str;
}
// 重力ベクトル
result = doc->evaluate(
YPT::XmlString("./gravity"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
if (result->getSnapshotLength() >= 1) {
str = result->getNodeValue()->getTextContent();
b2Vec2 temp;
if (!YPT::ConvertStrToVec2(str.ToChar(), &temp)) {
world.SetGravity(temp);
}
}
result->release();
}
// --------------------------------------------------
// shapes
// --------------------------------------------------
result = doc->evaluate(
YPT::XmlString("./shape"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
const XMLSize_t len = result->getSnapshotLength();
for (XMLSize_t i = 0; i < len; ++i) {
result->snapshotItem(i);
DOMNode *node = result->getNodeValue();
if (node == nullptr) {
continue;
}
DOMNamedNodeMap *nodeMap = node->getAttributes();
if (nodeMap == nullptr) {
continue;
}
DOMNode *typeNode = nodeMap->getNamedItem(YPT::XmlString("type"));
if (typeNode == nullptr) {
continue;
}
str = typeNode->getNodeValue();
b2Shape::Type type;
int index;
if (str == "circle") {
type = b2Shape::e_circle;
b2CircleShape temp;
if (partReader.ReadCircleShape(node, &temp)) {
circleShapes.push_back(temp);
index = circleShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else if (str == "edge") {
type = b2Shape::e_edge;
b2EdgeShape temp;
if (partReader.ReadEdgeShape(node, &temp)) {
edgeShapes.push_back(temp);
index = edgeShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else if (str == "polygon") {
type = b2Shape::e_polygon;
b2PolygonShape temp;
if (partReader.ReadPolygonShape(node, &temp)) {
polygonShapes.push_back(temp);
index = polygonShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else if (str == "chain") {
type = b2Shape::e_chain;
b2ChainShape temp;
if (partReader.ReadChainShape(node, &temp)) {
chainShapes.push_back(temp);
index = chainShapes.size()-1;
} else {
// 読み込み失敗
continue;
}
} else {
// 未対応
continue;
}
// nameプロパティがあれば保存
DOMNode *name = nodeMap->getNamedItem(YPT::XmlString("name"));
if (name != nullptr) {
str = name->getNodeValue();
shapes.insert(ShapesMap::value_type(
std::string(str),
std::make_pair(type, index)
));
}
}
result->release();
}
// --------------------------------------------------
// fixtures
// --------------------------------------------------
result = doc->evaluate(
YPT::XmlString("./fixture"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
const XMLSize_t len = result->getSnapshotLength();
for (XMLSize_t i = 0; i < len; ++i) {
result->snapshotItem(i);
DOMNode *node = result->getNodeValue();
if (node == nullptr) {
continue;
}
DOMXPathResult *result2 = doc->evaluate(
YPT::XmlString("./shape"), node, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result2 == nullptr) {
continue;
}
DOMNode *shapeNode = result2->getNodeValue();
if (shapeNode == nullptr) {
continue;
}
str = shapeNode->getTextContent();
result2->release();
ShapesMap::iterator found = shapes.find(std::string(str));
if (found == shapes.end()) {
continue;
}
// fixture読み込み
b2FixtureDef fixtureDef;
b2Shape *shape = NULL;
int index = found->second.second;
switch (found->second.first) {
case b2Shape::e_circle:
shape = &circleShapes[index];
break;
case b2Shape::e_edge:
shape = &edgeShapes[index];
break;
case b2Shape::e_polygon:
shape = &polygonShapes[index];
break;
case b2Shape::e_chain:
shape = &chainShapes[index];
break;
default:
// 未対応
break;
}
if (shape == NULL) {
continue;
}
if (partReader.ReadFixture(node, shape, &fixtureDef)) {
// 読み込み成功
// nameプロパティがあれば保存する
DOMNamedNodeMap *nodeMap = node->getAttributes();
if (nodeMap == nullptr) {
continue;
}
DOMNode *nameNode = nodeMap->getNamedItem(YPT::XmlString("name"));
if (nameNode == nullptr) {
continue;
}
str = nameNode->getNodeValue();
fixtures.insert(FixturesMap::value_type(
std::string(str), fixtureDef
));
}
}
result->release();
}
// --------------------------------------------------
// bodies
// --------------------------------------------------
result = doc->evaluate(
YPT::XmlString("./body"), worldElement, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result != nullptr) {
const XMLSize_t len = result->getSnapshotLength();
for (XMLSize_t i = 0; i < len; ++i) {
result->snapshotItem(i);
DOMNode *node = result->getNodeValue();
if (node == nullptr) {
continue;
}
DOMXPathResult *result2 = doc->evaluate(
YPT::XmlString("./fixtures/fixture"), node, resolver,
DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
NULL
);
if (result2 == nullptr) {
continue;
}
std::vector< b2FixtureDef *> fixtureDefs;
const XMLSize_t fixturesLen = result2->getSnapshotLength();
for (XMLSize_t j = 0; j < fixturesLen; ++j) {
result2->snapshotItem(j);
DOMNode *fixtureNode = result2->getNodeValue();
if (fixtureNode == nullptr) {
continue;
}
str = fixtureNode->getTextContent();
FixturesMap::iterator found = fixtures.find(
std::string(str)
);
if (found != fixtures.end()) {
fixtureDefs.push_back(&found->second);
}
}
result2->release();
b2Body *body = partReader.ReadBody(world, node, fixtureDefs);
if (body != nullptr) {
// 読み込み成功
// nameプロパティがあれば保存する
DOMNamedNodeMap *nodeMap = node->getAttributes();
if (nodeMap == nullptr) {
continue;
}
DOMNode *nameNode = nodeMap->getNamedItem(YPT::XmlString("name"));
if (nameNode == nullptr) {
continue;
}
str = nameNode->getNodeValue();
bodies.insert(BodiesMap::value_type(
std::string(str), body
));
}
}
result->release();
}
// --------------------------------------------------
// 読み込み完了
// --------------------------------------------------
resolver->release();
parser->release();
return true;
}
void VART::XmlAction::LoadAnimation(const Source& jointSource)
// Called by LoadFromFile after parsing to actually build the action from file.
{
static VART::LinearInterpolator linearInterpolator; // common interpolator for all joint movers
static VART::SineInterpolator sineInterpolator; // common interpolator for all joint movers
istringstream stream; // helper for converting strings to numbers
char* charAux; // helper for converting XMLStrings to C strings
unsigned int i, j, k; // loop counters (aaargh!)
float dur, speed; // duration and speed of the action
bool cycle; // cyclic status of the action
string dofIdentifier, jName, itplName;
XMLCh* xmlStr; // helper for converting C strings to XMLStrings
DOMNodeList* actionList;
DOMNamedNodeMap* attrAc; // attributes for the action
VART::JointMover* jointMPtr;
// Get list of actions (but there should be only one!)
xmlStr = XMLString::transcode("action");
actionList = documentPtr->getElementsByTagName(xmlStr);
XMLString::release(&xmlStr);
attrAc = documentPtr->getDocumentElement()->getAttributes();
// Read speed value
xmlStr = XMLString::transcode("speed");
charAux = XMLString::transcode(attrAc->getNamedItem(xmlStr)->getNodeValue());
stream.clear();
stream.str(charAux);
stream >> speed;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
// Read cyclic value
xmlStr = XMLString::transcode("cycle");
charAux = XMLString::transcode(attrAc->getNamedItem(xmlStr)->getNodeValue());
cycle = (strcmp(charAux, "true") == 0);
XMLString::release(&xmlStr);
XMLString::release(&charAux);
// Set action attributes
Set(speed, 1, cycle); //Priority default is 1.
// For each action (but there should be only one!):
for (i = 0; i<actionList->getLength(); i++)
{
DOMNodeList* jointsL = actionList->item(i)->getChildNodes();
// For each joint movement:
for (j = 0; j<jointsL->getLength(); j++)
{
bool isJointMovement;
charAux = XMLString::transcode(jointsL->item(j)->getNodeName());
isJointMovement = (strcmp(charAux, "joint_movement") == 0);
XMLString::release(&charAux);
if (isJointMovement)
{
Joint* jointPtr;
DOMNamedNodeMap* attrLt = jointsL->item(j)->getAttributes();
// Read joint mover's duration value
xmlStr = XMLString::transcode("duration");
charAux = XMLString::transcode(attrLt->getNamedItem(xmlStr)->getNodeValue());
stream.clear();
stream.str(charAux);
stream >> dur;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
// Read joint mover's target joint name
xmlStr = XMLString::transcode("joint_name");
charAux = XMLString::transcode(attrLt->getNamedItem(xmlStr)->getNodeValue());
jName = charAux;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
jointPtr = jointSource.GetJointByName(jName);
if (jointPtr)
{
DOMNodeList* dofsL = jointsL->item(j)->getChildNodes();
// It is now almost safe to create a joint mover :)
// Add an ease-in, ease-out interpolator as default. Change it when the
// interpolator gets known.
jointMPtr = AddJointMover(jointPtr, dur, sineInterpolator);
// For each element of a joint movement (may be interpolator or dof movement):
for(k = 0; k<dofsL->getLength(); k++)
{
bool isInterpolation;
charAux = XMLString::transcode(dofsL->item(k)->getNodeName());
isInterpolation = (strcmp(charAux, "interpolation") == 0);
XMLString::release(&charAux);
if (isInterpolation)
{
DOMNamedNodeMap* attrInterpLt = dofsL->item(k)->getAttributes();
// Read interpolation type
xmlStr = XMLString::transcode("type");
charAux = XMLString::transcode(attrInterpLt->getNamedItem(xmlStr)->getNodeValue());
itplName = charAux;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
// Change interpolator if it is different from default (ease-in/ease-out) value
if (itplName != "ease-in_ease-out")
{
if (itplName == "linear")
jointMPtr->SetInterpolator(linearInterpolator);
else if (itplName == "range_sine")
{
Interpolator* interpolatorPtr = new RangeSineInterpolator;
jointMPtr->SetInterpolator(*interpolatorPtr);
}
else
cerr << "Error: Unknown interpolator: '" << itplName
<< "'. Using: 'ease-in_ease-out'." << endl;
}
}
else // item is not "interpolation"
{
charAux = XMLString::transcode(dofsL->item(k)->getNodeName());
if(strcmp(charAux, "dof_movement") == 0)
ParseDofMovement(jointMPtr, dofsL->item(k));
XMLString::release(&charAux);
}
}
}
else // the target joint was not found
{
cerr << "Error: Joint mover targeting at '" << jName
<< "': No such scene node!" << endl;
}
}
}
}
}
void VART::XmlAction::ParseDofMovement(JointMover* jointMPtr, DOMNode* dofMovItemPtr)
// Called by LoadAnimation to create a dof mover from a XML entry.
// FixMe: Memory allocated for the interpolators is never released.
{
DOMNodeList* dofMovElements;
DOMNamedNodeMap* attrPt;
XMLCh* xmlStr; // helper for converting C strings to XMLStrings
float inTime;
float fTime;
float fPos;
float noiseAmplitude;
float noiseWaveLenght;
float overshoot;
float offset;
float peakTime;
char* charAux;
char* cstr_nodeName; // a node name (as a C string)
istringstream stream;
VART::Joint::DofID dofID;
unsigned int count;
bool foundPositionalError = false; // any positional error elements found inside the dof mover?
bool foundNoise = false; // any noise elements found inside the dof mover?
attrPt = dofMovItemPtr->getAttributes();
xmlStr = XMLString::transcode("initialTime");
charAux = XMLString::transcode(attrPt->getNamedItem(xmlStr)->getNodeValue());
stream.str(charAux);
stream >> inTime;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
xmlStr = XMLString::transcode("finalTime");
charAux = XMLString::transcode(attrPt->getNamedItem(xmlStr)->getNodeValue());
stream.clear();
stream.str(charAux);
stream >> fTime;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
xmlStr = XMLString::transcode("finalPosition");
charAux = XMLString::transcode(attrPt->getNamedItem(xmlStr)->getNodeValue());
stream.clear();
stream.str(charAux);
stream >> fPos;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
// Read value for dofID
xmlStr = XMLString::transcode("dofID");
charAux = XMLString::transcode(attrPt->getNamedItem(xmlStr)->getNodeValue());
if ((strcmp(charAux, "FLEX") == 0) || (strcmp(charAux, "FLEXION") == 0))
dofID = VART::Joint::FLEXION;
else
{
if ((strcmp(charAux, "ADDUCT") == 0) || (strcmp(charAux, "ADDUCTION") == 0))
dofID = VART::Joint::ADDUCTION;
else
if (strcmp(charAux, "TWIST") == 0)
dofID = VART::Joint::TWIST;
else
{
cerr << "XmlAction::ParseDofMovement: Unknown DOF ID" << endl;
exit (1);
}
}
XMLString::release(&xmlStr);
XMLString::release(&charAux);
dofMovElements = dofMovItemPtr->getChildNodes();
// for each child node of the dof mover (may be "noise" or "error"):
for (count = 0; count < dofMovElements->getLength(); ++count)
{
cstr_nodeName = XMLString::transcode(dofMovElements->item(count)->getNodeName());
if (strcmp(cstr_nodeName, "noise") == 0)
{
attrPt = dofMovElements->item(count)->getAttributes();
xmlStr = XMLString::transcode("amplitude");
charAux = XMLString::transcode(attrPt->getNamedItem(xmlStr)->getNodeValue());
stream.clear();
stream.str(charAux);
stream >> noiseAmplitude;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
xmlStr = XMLString::transcode("length");
charAux = XMLString::transcode(attrPt->getNamedItem(xmlStr)->getNodeValue());
stream.clear();
stream.str(charAux);
stream >> noiseWaveLenght;
XMLString::release(&xmlStr);
XMLString::release(&charAux);
foundNoise = true;
}
else if (strcmp(cstr_nodeName, "error") == 0)
void FDPLoader::loadFDPItem(DOMNode* pFDPItem)
{
DOMNamedNodeMap* attrList = pFDPItem->getAttributes();
FDPItem* pItem = 0;
// get the name (id)
DOMNode* attr = attrList->getNamedItem(XercesString("name"));
if(attr)
{
char* name = XMLString::transcode(attr->getNodeValue());
// create a new item (will be deleted in dtor of FDP class)
pItem = new FDPItem(name);
XMLString::release(&name);
}
else
return;
// get the control vertex index
attr = attrList->getNamedItem(XercesString("index"));
if(attr)
{
char* index = XMLString::transcode(attr->getNodeValue());
pItem->setControlPoint((unsigned short)atoi(index));
XMLString::release(&index);
}
// get the affecting mesh name
attr = attrList->getNamedItem(XercesString("affects"));
if(attr)
{
char* affects = XMLString::transcode(attr->getNodeValue());
pItem->setAffects(affects);
XMLString::release(&affects);
}
DOMNodeIterator* iterator = m_pDoc->createNodeIterator(pFDPItem,
DOMNodeFilter::SHOW_ELEMENT | DOMNodeFilter::SHOW_ATTRIBUTE, NULL, true);
// use the tree walker to print out the text nodes.
for ( DOMNode* current = iterator->nextNode(); current != 0; current = iterator->nextNode() )
{
if(XercesString(current->getNodeName()) == "indices")
{
DOMNodeList* children = current->getChildNodes();
// we should have only one child, text node, just a safety net here
if ( (children->getLength() == 1) && (children->item(0)->getNodeType() == DOMNode::TEXT_NODE) )//(XercesString(children->item(0)->getNodeName()) == "#text") )
{
char* pStr = XMLString::transcode(children->item(0)->getNodeValue());
std::string str(pStr);
processIndices(str, pItem);
XMLString::release(&pStr);
}
}
else if (XercesString(current->getNodeName()) == "influence") // can have multiple of those
{
// sample: <influence weight="0.25" fap="3" type="RaisedCosInfluenceWaveY" />
DOMNamedNodeMap* influenceAttr = current->getAttributes();
// get the weight
float w = toFloat(influenceAttr->getNamedItem(XercesString("weight"))->getNodeValue());
unsigned short fap = (unsigned short)toFloat(influenceAttr->getNamedItem(XercesString("fap"))->getNodeValue());
char* type = XMLString::transcode(influenceAttr->getNamedItem(XercesString("type"))->getNodeValue());
IInfluenceCalculator* pInfluence = InfluenceCalculatorMaker::newInfluenceCalculator(type, w, fap);
if(pInfluence)
pItem->addInfluenceCalculator(pInfluence);
}
}
m_pFDP->insertItem(pItem);
}
void FDPLoader::loadEntity(DOMNode* pSource)
{
DOMNamedNodeMap* attrList = pSource->getAttributes();
std::string alias, category;
DOMNode* attr = attrList->getNamedItem(XercesString("alias"));
if(attr)
{
char* aliasPtr = XMLString::transcode(attr->getNodeValue());
alias.assign(aliasPtr);
XMLString::release(&aliasPtr);
}
attr = attrList->getNamedItem(XercesString("category"));
if(attr)
{
char* catPtr = XMLString::transcode(attr->getNodeValue());
category.assign(catPtr);
XMLString::release(&catPtr);
}
DOMNodeIterator* iterator = m_pDoc->createNodeIterator(pSource,
DOMNodeFilter::SHOW_ELEMENT | DOMNodeFilter::SHOW_ATTRIBUTE, NULL, true);
// use the tree walker to print out the text nodes.
for ( DOMNode* current = iterator->nextNode(); current != 0; current = iterator->nextNode() )
{
if(XercesString(current->getNodeName()) == "mesh")
{
XEngine::MeshInfo info;
attrList = current->getAttributes();
attr = attrList->getNamedItem(XercesString("file"));
if(attr)
info.file = XMLString::transcode(attr->getNodeValue());
attr = attrList->getNamedItem(XercesString("format"));
if(attr)
info.format = XMLString::transcode(attr->getNodeValue());
attr = attrList->getNamedItem(XercesString("path"));
if(attr)
info.path = XMLString::transcode(attr->getNodeValue());
else
info.path.assign("");
info.keyframe_alias = alias;
info.keyframe_category = category;
if(alias == "Rest")
m_faceEntityMeshInfo.push_back(info);
// push the Rest state into the morph target dictionary as well
m_morphTargetsMeshInfos[alias].push_back(info);
}
else if(XercesString(current->getNodeName()) == "bind")
{
XEngine::MeshInfo info;
std::string submesh, item;
attrList = current->getAttributes();
attr = attrList->getNamedItem(XercesString("submesh"));
if(attr)
submesh = XMLString::transcode(attr->getNodeValue());
attr = attrList->getNamedItem(XercesString("item"));
if(attr)
item = XMLString::transcode(attr->getNodeValue());
if(item == "LeftEye" || item == "RightEye") // eye pivots
{
Vector3 eye(0, 0, 0);
//std::string x, y, z;
attr = attrList->getNamedItem(XercesString("pivotX"));
if(attr)
eye.x = toFloat(attr->getNodeValue());
attr = attrList->getNamedItem(XercesString("pivotY"));
if(attr)
eye.y = toFloat(attr->getNodeValue());
attr = attrList->getNamedItem(XercesString("pivotZ"));
if(attr)
eye.z = toFloat(attr->getNodeValue());
if(item == "LeftEye")
m_pFDP->setLeftEyePivot(eye);
else
m_pFDP->setRightEyePivot(eye);
}
m_bindings.insert(std::make_pair(submesh, item));
}
}
}
bool FDPLoader::parseHeader(DOMNode* pHeader)
{
DOMNodeIterator* iterator = m_pDoc->createNodeIterator(pHeader,
DOMNodeFilter::SHOW_ELEMENT | DOMNodeFilter::SHOW_ATTRIBUTE, NULL, true);
// use the tree walker to print out the text nodes.
for ( DOMNode* current = iterator->nextNode(); current != 0; current = iterator->nextNode() )
{
// there are "file", "model", "fapu", "translation" and "rotation" elements in this chunk
if (XercesString(current->getNodeName()) == "file")
{
// sample: <file version="0.2" />
DOMNamedNodeMap* attr = current->getAttributes();
if(!attr) // sth wrong
return false;
DOMNode* versionAttr = attr->getNamedItem(XercesString("version"));
if(XercesString(m_version.c_str()) != versionAttr->getNodeValue())
// versions not matching, flee!!
return false;
}
else if(XercesString(current->getNodeName()) == "fapu")
{
// sample: <fapu ES0="69.9977" IRISD0="16.0424" ENS0="51.8036" MNS0="30.1538" MW0="50.6392" />
DOMNamedNodeMap* attrList = current->getAttributes();
if(!attrList) // sth wrong
return false;
/////////////// ES0
DOMNode* attr = attrList->getNamedItem(XercesString("ES0"));
if(attr)
m_pFDP->setES0(toFloat(attr->getNodeValue()));
/////////////// IRISD0
attr = attrList->getNamedItem(XercesString("IRISD0"));
if(attr)
m_pFDP->setIRISD0(toFloat(attr->getNodeValue()));
/////////////// ENS0
attr = attrList->getNamedItem(XercesString("ENS0"));
if(attr)
m_pFDP->setENS0(toFloat(attr->getNodeValue()));
/////////////// MNS0
attr = attrList->getNamedItem(XercesString("MNS0"));
if(attr)
m_pFDP->setMNS0(toFloat(attr->getNodeValue()));
/////////////// MW0
attr = attrList->getNamedItem(XercesString("MW0"));
if(attr)
m_pFDP->setMW0(toFloat(attr->getNodeValue()));
// debug << "fapu item" << std::endl;
}
else if(XercesString(current->getNodeName()) == "translation")
{
// sample: <translation x="0" y="-1" z="-659" />
DOMNamedNodeMap* attrList = current->getAttributes();
if(!attrList) // sth wrong
return false;
float x = 0, y = 0, z = 0;
/////////////// x translation
DOMNode* attr = attrList->getNamedItem(XercesString("x"));
if(attr)
x = toFloat(attr->getNodeValue());
/////////////// y translation
attr = attrList->getNamedItem(XercesString("y"));
if(attr)
y = toFloat(attr->getNodeValue());
/////////////// z translation
attr = attrList->getNamedItem(XercesString("z"));
if(attr)
z = toFloat(attr->getNodeValue());
m_pFDP->setGlobalTranslation(x, y, z);
// debug << "translation item " << x << " " << y << " " << z << std::endl;
}
else if(XercesString(current->getNodeName()) == "rotation")
{
// sample: <rotation axis_x="-0.998192" axis_y="0.0596591" axis_z="0.00728935" axis_angle="0.444541" />
DOMNamedNodeMap* attrList = current->getAttributes();
if(!attrList) // sth wrong
return false;
float x = 0, y = 0, z = 0, a = 0;
/////////////// x rotation
DOMNode* attr = attrList->getNamedItem(XercesString("axis_x"));
if(attr)
x = toFloat(attr->getNodeValue());
/////////////// y rotation
attr = attrList->getNamedItem(XercesString("axis_y"));
if(attr)
y = toFloat(attr->getNodeValue());
/////////////// z rotation
attr = attrList->getNamedItem(XercesString("axis_z"));
if(attr)
z = toFloat(attr->getNodeValue());
/////////////// z rotation
attr = attrList->getNamedItem(XercesString("axis_angle"));
if(attr)
a = toFloat(attr->getNodeValue());
m_pFDP->setGlobalRotation(x, y, z, a);
}
}
return true;
}
bool
XMLIndata::parseContent(const DOMNode* content,
multimap<MC2String, ItemIdentifier*>& contents )
{
if ( XMLString::equals( content->getNodeName(), "content" ) ) {
// Get attributes
DOMNamedNodeMap* attributes = content->getAttributes();
// Note that map_ident attribute is #REQUIRED.
DOMNode* attribute =
attributes->getNamedItem( X( "map_ident" ) );
MC2_ASSERT( attribute != NULL );
char* tmpStr = XMLUtility::transcodefromucs(
attribute->getNodeValue() );
MC2String mapIdent( tmpStr );
delete [] tmpStr;
// Get children
DOMNode* child = content->getFirstChild();
while ( child != NULL ) {
switch ( child->getNodeType() ) {
case DOMNode::ELEMENT_NODE :
// See if the element is a known type
if ( XMLString::equals( child->getNodeName(),
"item_ident" ) )
{
// Parse item ident
ItemIdentifier* itemIdent = new ItemIdentifier();
parseItemIdent( child, *itemIdent );
contents.insert( make_pair( mapIdent, itemIdent ) );
} else if ( XMLString::equals( child->getNodeName(),
"whole_map" ) )
{
// Content is all of the specified map.
contents.insert( make_pair( mapIdent,
(ItemIdentifier*) NULL ) );
} else {
mc2log << warn
<< "XMLIndata::parseContent:"
<< " odd Element in content element: "
<< child->getNodeName() << endl;
}
break;
case DOMNode::COMMENT_NODE :
// Ignore comments
break;
default:
mc2log << warn
<< "XMLIndata::parseContent odd "
<< "node type in content element: "
<< child->getNodeName()
<< " type " << child->getNodeType() << endl;
break;
}
child = child->getNextSibling();
}
return true;
} else {
// Not a content node.
mc2log << warn
<< "XMLIndata::parseContent:"
<< " not a content node."
<< content->getNodeName() << endl;
return false;
}
}
bool
XMLIndata::parseName( const DOMNode* name,
NameCollection& names )
{
if ( XMLString::equals( name->getNodeName(), "name" ) ) {
// Get attributes
DOMNamedNodeMap* attributes = name->getAttributes();
LangTypes::language_t lang;
ItemTypes::name_t nameType;
// Note that language attribute is #REQUIRED.
DOMNode* attribute =
attributes->getNamedItem( X( "language" ) );
MC2_ASSERT( attribute != NULL );
MC2String langStr =
XMLUtility::transcodefromucs(attribute->getNodeValue() );
// Replace any occurance of '_' with space.
for (MC2String::iterator strIt = langStr.begin();
strIt != langStr.end(); ++strIt){
if ( *strIt == '_' ){
*strIt = ' ';
}
}
lang = LangTypes::getStringAsLanguage( langStr.c_str(), true );
if ( lang == LangTypes::invalidLanguage ){
mc2log << error << "Could not interpret language code of string"
<< endl;
MC2_ASSERT(false);
}
// Note that type attribute is always present.
attribute =
attributes->getNamedItem( X( "type" ) );
MC2_ASSERT( attribute != NULL );
const char* tmpStr = XMLUtility::transcodefromucs(
attribute->getNodeValue() );
nameType = ItemTypes::getStringAsNameType( tmpStr );
delete [] tmpStr;
// Get the name.
tmpStr = XMLUtility::getChildTextValue( name );
// Add name
Name* tmpName = new Name( tmpStr, lang, nameType );
names.addName( tmpName );
mc2dbg << "Added name: " << (*tmpName) << endl;
mc2dbg8 << "All names: " << names << endl;
delete tmpStr;
return true;
} else {
// Not a name node.
mc2log << warn
<< "XMLIndata::parseName:"
<< " not a name node."
<< name->getNodeName() << endl;
return false;
}
}
