void KeyerConfigure::SetPorts( TiXmlElement *e ) { for ( TiXmlElement * c = e->FirstChildElement(); c; c = c->NextSiblingElement() ) { if ( checkElementName( c, "Port" ) ) { // attribs name, type, port std::string n; std::string t; if ( GetStringAttribute( c, "name", n ) == TIXML_SUCCESS && GetStringAttribute( c, "type", t ) == TIXML_SUCCESS ) { // should all this live inside PortConfig? PortConfig::PortType pt; if ( t == "Windows" ) { pt = PortConfig::eptWindows; } else if ( t == "MinosControl" ) { pt = PortConfig::eptMinosControl; } else { // error... continue; } PortConfig p( n, pt ); portmap[ n ] = p; } } } }
void KeyerConfigure::SetEnable( TiXmlElement *e ) { //attribs Keyer, Port - refer to names of KeyerConfig, PortConfig std::string k; std::string p; if ( GetStringAttribute( e, "keyer", k ) == TIXML_SUCCESS && GetStringAttribute( e, "port", p ) == TIXML_SUCCESS ) createKeyer( keyermap[ k ], portmap[ p ] ); }
void Nena::Utility::MayaReader::ImportSkinCluster(XMLNode *clusterNode) { ::UINT32 result = 0; ::std::string clusterName; GetNameAttribute(clusterNode, clusterName, result); ::UINT32 skinCount; GetCountAttribute(clusterNode, skinCount, result); Data::SkinCluster *clusterData = new Data::SkinCluster(); Root->GetHandles()->push_back(clusterData); clusterData->m_type = Data::IItem::kSkinCluster; clusterData->m_name = clusterName; XMLNode *skinNode = clusterNode->first_node("Skin"); while (skinNode) { Data::SkinCluster::Skin *skin = new Data::SkinCluster::Skin; clusterData->Geometries.push_back(skin); Root->GetHandles()->push_back(skin); ::UINT32 skinIndex; GetIndexAttribute(skinNode, skinIndex, result); ::std::string skinName; GetNameAttribute(skinNode, skinName, result); ::UINT32 componentCount; GetCountAttribute(skinNode, componentCount, result); skin->m_name = skinName; skin->m_type = Data::IItem::kSkin; skin->ComponentCount = componentCount; skin->Components = new Data::SkinCluster::Skin::Component[componentCount]; XMLNode *componentNode = skinNode->first_node("Component"); while (componentNode) { ::UINT32 componentIndex; GetIndexAttribute(componentNode, componentIndex, result); ::UINT32 influenceCount; GetCountAttribute(componentNode, influenceCount, result); skin->Components[componentIndex].InfluenceCount = influenceCount; skin->Components[componentIndex].Influences = new Data::SkinCluster::Skin::Component::Influence[influenceCount]; XMLNode *influenceNode = componentNode->first_node("Influence"); while (influenceNode) { ::UINT32 influenceIndex; GetIndexAttribute(influenceNode, influenceIndex, result); ::FLOAT influenceWeight; GetFloatAttribute(influenceNode, "Weight", influenceWeight, result); ::std::string fullPath; GetStringAttribute(influenceNode, "Full-Path", fullPath, result); ::std::string partialPath; GetStringAttribute(influenceNode, "Partial-Path", partialPath, result); skin->Components[componentIndex].Influences[influenceIndex].Weight = influenceWeight; skin->Components[componentIndex].Influences[influenceIndex].FullPath = fullPath; skin->Components[componentIndex].Influences[influenceIndex].PartialPath = partialPath; influenceNode = influenceNode->next_sibling("Influence"); } componentNode = componentNode->next_sibling("Component"); } skinNode = skinNode->next_sibling("Skin"); } }
void KeyerConfigure::SetMorseCode( TiXmlElement *e ) { /* int codeinc; void procCodeParam(const std::string &pname, const std::string &pvalue ) { MORSELETTER[ codeinc ] = toupper( pname[ 0 ] ); for ( int i = 0; i < 8 && pvalue[ i ] && pvalue[ i ] != ' '; i++ ) { if ( pvalue[ i ] == '.' ) MORSECODE[ codeinc ][ i ] = 0x40; if ( pvalue[ i ] == '-' ) MORSECODE[ codeinc ][ i ] = 0x80; } codeinc++; } void defineCode( const ParamTable &code ) { memset( MORSELETTER, 0, MORSESIZE ); memset( MORSECODE, 0, MORSESIZE * 8 ); codeinc = 0; code.forEachParam( 0, 0, procCodeParam ); } */ for ( TiXmlElement * c = e->FirstChildElement(); c; c = c->NextSiblingElement() ) { if ( checkElementName( c, "Key" ) ) { std::string character; std::string code; if ( GetStringAttribute( c, "character", character ) == TIXML_SUCCESS && GetStringAttribute( c, "code", code ) == TIXML_SUCCESS ) { std::string proccode; for ( int i = 0; i < 8 && code[ i ] && code[ i ] != ' '; i++ ) { if ( code[ i ] == '.' ) proccode += '\x40'; if ( code[ i ] == '-' ) proccode += '\x80'; } MORSECODE[ character[ 0 ] ] = proccode; } } } }
void Nena::Utility::MayaReader::ImportPolygons(XMLNode *shapeNode, Data::Shape *shapeData) { ::UINT32 result = 0; ::UINT32 bntnIndex = 0; ::UINT32 polygonsCount = 0; XMLNode *polygonsNode = shapeNode->first_node("Polygons"); GetCountAttribute(polygonsNode, polygonsCount, result); shapeData->Polygons.resize(polygonsCount); XMLNode *polygonNode = polygonsNode->first_node("Polygon"); while (polygonNode) { ::UINT32 vertexCount = 0; ::UINT32 polygonIndex; GetCountAttribute(polygonNode, vertexCount, result); GetIndexAttribute(polygonNode, polygonIndex, result); shapeData->Polygons[polygonIndex] = new Data::Shape::Polygon; shapeData->Polygons[polygonIndex]->Vertices = new Data::Shape::Polygon::Vertex[vertexCount]; shapeData->Polygons[polygonIndex]->VertexCount = vertexCount; XMLNode *vertexNode = polygonNode->first_node("Vertex"); while (vertexNode) { ::UINT32 vertexIndex, pointIndex, normalIndex, texcoordsCount; GetIndexAttribute(vertexNode, vertexIndex, result); GetUIntAttribute(vertexNode, "Point-Index", pointIndex, result); GetUIntAttribute(vertexNode, "Normal-Index", normalIndex, result); GetCountAttribute(vertexNode, texcoordsCount, result); shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].PointIndex = pointIndex; shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].NormalIndex = normalIndex; shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].BinormalIndex = bntnIndex; shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].TangentIndex = bntnIndex; shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].TexcoordCount = texcoordsCount; shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].Texcoords = new Data::Shape::Polygon::Vertex::Tex[texcoordsCount]; ::UINT32 texIndex = 0; XMLNode *texNode = vertexNode->first_node("Tex"); while (texNode) { ::std::string uvSetName; ::UINT32 uvIndex; GetStringAttribute(texNode, "UV-Set", uvSetName, result); GetUIntAttribute(texNode, "UV-Index", uvIndex, result); shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].Texcoords[texIndex].UVIndex = uvIndex; shapeData->Polygons[polygonIndex]->Vertices[vertexIndex].Texcoords[texIndex].UVSet = uvSetName; texNode = texNode->next_sibling("Tex"); } vertexNode = vertexNode->next_sibling("Vertex"); bntnIndex++; } polygonNode = polygonNode->next_sibling("Polygon"); } }
static int GetStringAttribute( TiXmlElement *e, const std::string &name, std::string &s, const std::string &def ) { int ret = GetStringAttribute( e, name, s ); if ( ret == TIXML_NO_ATTRIBUTE ) { s = def; } return ret; }
///===================================================== /// ///===================================================== bool GetBoolAttribute(const XMLNode& node, const std::string& attributeName, bool defaultValue /*= false*/){ std::string attr = GetStringAttribute(node, attributeName, defaultValue == true ? "1" : "0"); if (attr == "1" || attr == "true") return true; if (attr == "0" || attr == "false") return false; return defaultValue; }
///===================================================== /// ///===================================================== TeleportBehavior::TeleportBehavior(const std::string& name, const XMLNode& behaviorNode) : BaseAIBehavior(name, BehaviorType::Attack, behaviorNode), m_healthThreshold(0.0f), m_chance(0.0f), m_phrase("casts Teleport"), m_numUses(-1){ m_healthThreshold = GetFloatAttribute(behaviorNode, "healthThreshold", m_healthThreshold); m_chance = GetFloatAttribute(behaviorNode, "chance", m_chance); m_phrase = GetStringAttribute(behaviorNode, "phrase", m_phrase); m_numUses = GetIntAttribute(behaviorNode, "numUses", m_numUses); }
int GetIntAttribute(const wxXmlNode& node, const wxString& name, const wxString& def) { wxString value = GetStringAttribute(node, name, def); long l; if (!value.ToLong(&l, 0)) { THROW("Attribute \"%s\" in element <%s> is not an integer.", name.c_str(), node.GetName().c_str()); } return l; }
void Nena::Utility::MayaReader::ImportCurves( XMLNode *transformNode, Data::Transform *transformData ) { ::UINT32 type = 0; ::UINT32 result = 0; ::UINT32 keyCount = 0; ::std::string curveName; XMLNode *curveNode, *keyNode; curveNode = transformNode->first_node("Curve"); if (curveNode) transformData->Curves = new ::std::vector<Data::Transform::Curve *>(); while (curveNode) { GetCountAttribute(curveNode, keyCount, result); GetUIntAttribute(curveNode, "Type", type, result); GetStringAttribute(curveNode, "Name", curveName, result); Data::Transform::Curve *curveData = new Data::Transform::Curve(); transformData->Curves->push_back(curveData); //Root->GetHandles()->push_back(curveData); curveData->m_name = curveName; curveData->m_type = Data::IItem::kAnimationCurve; curveData->Type = type; curveData->KeyCount = keyCount; curveData->Keys = new Data::Transform::Curve::Key[keyCount]; keyNode = curveNode->first_node("Key"); while (keyNode) { ::UINT32 keyIndex; GetIndexAttribute(keyNode, keyIndex, result); GetFloatAttribute(keyNode, "Time", curveData->Keys[keyIndex].Time, result); GetFloatAttribute(keyNode, "Value", curveData->Keys[keyIndex].Value, result); GetFloatAttribute(keyNode, "InX", curveData->Keys[keyIndex].In.x, result); GetFloatAttribute(keyNode, "InY", curveData->Keys[keyIndex].In.y, result); GetFloatAttribute(keyNode, "OutX", curveData->Keys[keyIndex].Out.x, result); GetFloatAttribute(keyNode, "OutY", curveData->Keys[keyIndex].Out.y, result); GetUIntAttribute(keyNode, "InType", curveData->Keys[keyIndex].InTangent, result); GetUIntAttribute(keyNode, "OutType", curveData->Keys[keyIndex].OutTangent, result); keyNode = keyNode->next_sibling("Key"); } curveNode = curveNode->next_sibling("Curve"); } }
void KeyerConfigure::SetKeyers( TiXmlElement *e ) { /* void procKeyerParam( void *self, const std::string &pname, int pvalue ) { lineMonitor * lm = ( lineMonitor * ) self; lm->procParam( pname, pvalue ); } */ for ( TiXmlElement * c = e->FirstChildElement(); c; c = c->NextSiblingElement() ) { if ( checkElementName( c, "Keyer" ) ) { // attribs name PipTone EnablePip StartDelay AutoRepeat PipStartDelay PlayPTTDelay std::string name; int PipTone; int PipLength; bool EnablePip; int StartDelay; int AutoRepeatDelay; bool EnableAutoRepeat; int PipStartDelay; int PlayPTTDelay; int voxHangTime; int pipVolume; int ClipRecord; if ( GetStringAttribute( c, "name", name ) == TIXML_SUCCESS ) { GetIntAttribute( c, "pipTone", PipTone, 1000 ); GetIntAttribute( c, "pipLength", PipLength, 250 ); GetBoolAttribute( c, "enablePip", EnablePip, false ); GetIntAttribute( c, "pipStartDelay", PipStartDelay, 0 ); GetIntAttribute( c, "pipVolume", pipVolume, 80 ); GetIntAttribute( c, "startDelay", StartDelay, 0 ); GetIntAttribute( c, "autoRepeat", AutoRepeatDelay, 6 ); GetBoolAttribute( c, "enableAutoRepeat", EnableAutoRepeat, false ); GetIntAttribute( c, "playPTTDelay", PlayPTTDelay, 0 ); GetIntAttribute( c, "voxHangTime", voxHangTime, 0 ); GetIntAttribute( c, "clipRecord", ClipRecord, 0 ); KeyerConfig k( name, PipTone, pipVolume, PipLength, EnablePip, StartDelay, AutoRepeatDelay, EnableAutoRepeat, PipStartDelay, PlayPTTDelay, voxHangTime, ClipRecord ); keyermap[ name ] = k; } } } }
static int GetBoolAttribute( TiXmlElement *e, const std::string &name, bool &b ) { std::string val; int ret = GetStringAttribute( e, name, val ); if ( ret == TIXML_SUCCESS ) { if ( val[ 0 ] == 't' || val[ 0 ] == 'T' || val[ 0 ] == 'y' || val[ 0 ] == 'Y' || val[ 0 ] == '1' ) { b = true; } else { b = false; } } return ret; }
bool GetBoolAttribute(const wxXmlNode& node, const wxString& name, const wxString& def) { wxString value = GetStringAttribute(node, name, def); if (value == wxT("true")) { return true; } else if (value == wxT("false")) { return false; } else { THROW("Attribute \"%s\" in element <%s> is not a boolean.", name.c_str(), node.GetName().c_str()); } }
///===================================================== /// ///===================================================== Item::Item(const XMLNode& itemNode, OpenGLRenderer* renderer) : Entity(itemNode, renderer), m_type(Undefined), m_equippedSlot(Unequippable), m_damageReductionPercent(0.0f), m_numUses(1), m_healing(0), m_damage(0, 0){ m_name = GetStringAttribute(itemNode, "name"); std::string itemType = GetStringAttribute(itemNode, "type"); m_damageReductionPercent = GetFloatAttribute(itemNode, "damageReductionPercent", m_damageReductionPercent); m_numUses = GetIntAttribute(itemNode, "numUses", m_numUses); m_healing = GetIntAttribute(itemNode, "healing", m_healing); m_damage = IntVec2(GetIntAttribute(itemNode, "minDamage", m_damage.x), GetIntAttribute(itemNode, "maxDamage", m_damage.y)); RGBAchars defaultColor = RGBAchars::WHITE; char defaultGlyph = ':'; if (itemType == "Weapon"){ m_type = ItemType::Weapon; } else if (itemType == "Armor"){ m_type = ItemType::Armor; } else if (itemType == "Consumable"){ m_type = ItemType::Consumable; } else{ //unknown item assert(false); } if (m_type != ItemType::Undefined){ defaultColor = ITEM_COLOR_TABLE[m_type]; defaultGlyph = ITEM_SYMBOL_TABLE[m_type]; } std::string itemEquipSlot = GetStringAttribute(itemNode, "equip"); if (itemEquipSlot == "Weapon"){ m_equippedSlot = EquipmentSlot::WeaponSlot; } else if (itemEquipSlot == "Chest"){ m_equippedSlot = EquipmentSlot::Chest; } else if (itemEquipSlot == "Head"){ m_equippedSlot = EquipmentSlot::Head; } else if (itemEquipSlot == "Ring"){ m_equippedSlot = EquipmentSlot::Ring; } else if (itemEquipSlot == "Hands"){ m_equippedSlot = EquipmentSlot::Hands; } else if (itemEquipSlot == "Feet"){ m_equippedSlot = EquipmentSlot::Feet; } else if (itemEquipSlot == "Legs"){ m_equippedSlot = EquipmentSlot::Legs; } m_glyph = GetCharAttribute(itemNode, "glyph", defaultGlyph); m_color = GetColorAttribute(itemNode, "color", defaultColor); m_textRenderer.SetInputString(std::string(1, m_glyph)); m_textRenderer.SetInputStringColor(m_color); }
void Nena::Utility::MayaReader::GetSpaceAttribute(XMLNode *node, ::std::string &space, ::UINT32 &result) { GetStringAttribute(node, "Space", space, result); }
void Nena::Utility::MayaReader::GetNameAttribute(XMLNode *node, ::std::string &name, ::UINT32 &result) { GetStringAttribute(node, "Name", name, result); }
/// 载入系统邮件参数 void MailList::LoadSysMailList(TiXmlElement* pElem,tagMailParam* ptgMailParam) { for (TiXmlElement* pChildElem=pElem->FirstChildElement(); pChildElem!=NULL; pChildElem=pChildElem->NextSiblingElement()) { if (!stricmp(pChildElem->Value(),"BaseParam")) { //主题 ptgMailParam->strSubject = GetStringAttribute(pChildElem, "subject"); ptgMailParam->strText = GetStringAttribute(pChildElem, "text"); ptgMailParam->strExText = GetStringAttribute(pChildElem, "extext"); ptgMailParam->strWriter = GetStringAttribute(pChildElem, "writer"); } else if(!stricmp(pChildElem->Value(), "Receiver")) { //邮件内容 string strReceiver = GetStringAttribute(pChildElem, "name"); if (strReceiver.size()>0) { ptgMailParam->strReceiverList.push_back(strReceiver); } } // else if(!stricmp(pChildElem->Value(), "Good")) // { // //物品 // tagSGoods* ptgSGoods = new tagSGoods; // ptgSGoods->lIndex = GetDwordAttribute(pChildElem, "id"); // ptgSGoods->lNum = GetDwordAttribute(pChildElem, "num"); // ptgMailParam->lSGoods.push_back(ptgSGoods); // } else if (!stricmp(pChildElem->Value(), "Gold")) { ptgMailParam->lGold = GetDwordAttribute(pChildElem, "value"); } else if (!stricmp(pChildElem->Value(), "Time")) { tagTimer* ptgTimer = new tagTimer; struct tm* timeinfo = new tm; LoadSysMailTimeConfig(pChildElem, timeinfo); ptgTimer->lIntev = GetDwordAttribute(pChildElem, "intev"); ptgTimer->lCount = GetDwordAttribute(pChildElem, "count"); ptgTimer->lTimer = (long)mktime(timeinfo); ptgMailParam->ltgTimer.push_back(ptgTimer); SAFE_DELETE(timeinfo); } else if (!stricmp(pChildElem->Value(), "Condition")) { tagMailCondition* pMailCondition = new tagMailCondition; pMailCondition->strName = GetStringAttribute(pChildElem, "name"); pMailCondition->lValue = GetDwordAttribute(pChildElem, "value"); pMailCondition->strOperator = GetStringAttribute(pChildElem, "cmpfun"); ptgMailParam->lMailCondition.push_back(pMailCondition); } else if (!stricmp(pChildElem->Value(), "Event")) { tagMailEvent* ptgMailEvent = new tagMailEvent; ptgMailEvent->strEventName= GetStringAttribute(pChildElem, "name"); LoadSysMailEventTime(pChildElem, ptgMailEvent); ptgMailParam->ltgMailEvent.push_back(ptgMailEvent); } } }