TiXmlNode* WriteXmlNode(const std::string& tag, const std::string& data, bool cdata)
{
TiXmlNode* node = new TiXmlElement(tag);
TiXmlText* text = new TiXmlText(data);
text->SetCDATA(cdata);
node->LinkEndChild(text);
return node;
}
void CXml::ModifyElemValueCDATA(const char *pszElemValue)
{
if (NULL == pszElemValue)
{
return;
}
if (NULL == m_pXmlNode)
{
return;
}
TiXmlText *pXmlText = m_pXmlNode->FirstChild()->ToText();
//判断指针是否为空
CHECK_POINTER_VOID(pXmlText);
pXmlText->SetCDATA(true); // 添加CDATA属性
pXmlText->SetValue(pszElemValue);
}
/**************************************************************************
* name : SetElemValueCDATA
* description: 设定当前元素值 <![CDATA[ElemValue]]>
* input : pszElemValue 待设定的元素值
* output : NA
* return : true - 成功，false - 失败
* remark : NA
**************************************************************************/
bool CXml::SetElemValueCDATA(const char* pszElemValue)
{
CHECK_POINTER(pszElemValue, false);
CHECK_POINTER(m_pXmlElem, false);
TiXmlText *pXmlText = NULL;
try
{
pXmlText = new TiXmlText(pszElemValue);
CHECK_POINTER(pXmlText, false);//lint !e774
pXmlText->SetCDATA(true); // 设置该文本为CDATA,无需解析
}
catch (...)
{
pXmlText = NULL;
return false;//lint !e438
}
CHECK_POINTER(pXmlText, false);//lint !e774
(void)(m_pXmlElem->LinkEndChild(pXmlText));
return true;//lint !e429
}
TiXmlElement* CqDisplayServerImage::serialiseToXML()
{
TiXmlElement* imageXML = new TiXmlElement("Image");
TiXmlElement* typeXML = new TiXmlElement("Type");
TiXmlText* typeText = new TiXmlText("managed");
typeXML->LinkEndChild(typeText);
imageXML->LinkEndChild(typeXML);
TiXmlElement* nameXML = new TiXmlElement("Name");
TiXmlText* nameText = new TiXmlText(name());
nameXML->LinkEndChild(nameText);
imageXML->LinkEndChild(nameXML);
if(filename().empty())
{
TiXmlElement* dataXML = new TiXmlElement("Bitmap");
std::stringstream base64Data;
size_t dataLen = m_displayData->width() * m_displayData->height() * numChannels() * sizeof(TqUchar);
std::copy( base64_text(BOOST_MAKE_PFTO_WRAPPER(m_displayData->rawData())),
base64_text(BOOST_MAKE_PFTO_WRAPPER(m_displayData->rawData() + dataLen)),
std::ostream_iterator<char>(base64Data));
TiXmlText* dataTextXML = new TiXmlText(base64Data.str());
dataTextXML->SetCDATA(true);
dataXML->LinkEndChild(dataTextXML);
imageXML->LinkEndChild(dataXML);
}
else
{
TiXmlElement* filenameXML = new TiXmlElement("Filename");
TiXmlText* filenameText = new TiXmlText(filename());
filenameXML->LinkEndChild(filenameText);
imageXML->LinkEndChild(filenameXML);
}
return(imageXML);
}
TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )
{
TiXmlNode* returnNode = 0;
p = SkipWhiteSpace( p, encoding );
if( !p || !*p || *p != '<' )
{
return 0;
}
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p )
{
return 0;
}
// What is this thing?
// - Elements start with a letter or underscore, but xml is reserved.
// - Comments: <!--
// - Decleration: <?xml
// - Everthing else is unknown to tinyxml.
//
const char* xmlHeader = { "<?xml" };
const char* commentHeader = { "<!--" };
const char* dtdHeader = { "<!" };
const char* cdataHeader = { "<![CDATA[" };
if ( StringEqual( p, xmlHeader, true, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Declaration\n" );
#endif
returnNode = new TiXmlDeclaration();
}
else if ( StringEqual( p, commentHeader, false, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Comment\n" );
#endif
returnNode = new TiXmlComment();
}
else if ( StringEqual( p, cdataHeader, false, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing CDATA\n" );
#endif
TiXmlText* text = new TiXmlText( "" );
text->SetCDATA( true );
returnNode = text;
}
else if ( StringEqual( p, dtdHeader, false, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Unknown(1)\n" );
#endif
returnNode = new TiXmlUnknown();
}
else if ( IsAlpha( *(p+1), encoding )
|| *(p+1) == '_' )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Element\n" );
#endif
returnNode = new TiXmlElement( "" );
}
else
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Unknown(2)\n" );
#endif
returnNode = new TiXmlUnknown();
}
if ( returnNode )
{
// Set the parent, so it can report errors
returnNode->parent = this;
}
return returnNode;
}
bool ETHEntityProperties::WriteToXMLFile(TiXmlElement *pHeadRoot) const
{
TiXmlElement *pRoot = new TiXmlElement(GS_L("Entity"));
pHeadRoot->LinkEndChild(pRoot);
TiXmlElement *pElement;
if (emissiveColor != ETH_DEFAULT_EMISSIVE_COLOR)
ETHEntityProperties::SetColorPropertyToXmlElement(pRoot, GS_L("EmissiveColor"), emissiveColor);
if (spriteCut != ETH_DEFAULT_SPRITE_CUT)
ETHEntityProperties::SetVector2iPropertyToXmlElement(pRoot, GS_L("SpriteCut"), spriteCut);
if (scale != ETH_DEFAULT_SCALE)
ETHEntityProperties::SetVector2PropertyToXmlElement(pRoot, GS_L("Scale"), scale);
if (pivotAdjust != ETH_DEFAULT_PIVOT_ADJUST)
ETHEntityProperties::SetVector2PropertyToXmlElement(pRoot, GS_L("PivotAdjust"), pivotAdjust);
if (spriteFile != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Sprite"));
pElement->LinkEndChild(new TiXmlText(spriteFile));
pRoot->LinkEndChild(pElement);
}
if (normalFile != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Normal"));
pElement->LinkEndChild(new TiXmlText(normalFile));
pRoot->LinkEndChild(pElement);
}
if (glossFile != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Gloss"));
pElement->LinkEndChild(new TiXmlText(glossFile));
pRoot->LinkEndChild(pElement);
}
if (!particleSystems.empty())
{
TiXmlElement *pParticles = new TiXmlElement(GS_L("Particles"));
pRoot->LinkEndChild(pParticles);
for (unsigned int t=0; t<particleSystems.size(); t++)
{
if (particleSystems[t]->nParticles > 0)
particleSystems[t]->WriteToXMLFile(pParticles);
}
}
if (light)
{
light->WriteToXMLFile(pRoot);
}
if (collision)
{
TiXmlElement *pCollisionRoot = collision->WriteToXMLFile(pRoot);
if (pCollisionRoot)
{
// Write polygon data
if (polygon)
{
pElement = new TiXmlElement(GS_L("Polygon"));
TiXmlText* text = new TiXmlText(polygon->GetENMLDeclaration());
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
else if (shape == BS_POLYGON) // if the polygon data is empty, write sample data into it
{
pElement = new TiXmlElement(GS_L("Polygon"));
TiXmlText* text = new TiXmlText(POLYGON_ENML_SAMPLE);
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
// Write compound shape data
if (compoundShape)
{
pElement = new TiXmlElement(GS_L("Compound"));
TiXmlText* text = new TiXmlText(compoundShape->GetENMLDeclaration());
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
else if (shape == BS_COMPOUND) // it the compound data is empty, write sample data into it
{
pElement = new TiXmlElement(GS_L("Compound"));
TiXmlText* text = new TiXmlText(COMPOUND_SHAPE_ENML_SAMPLE);
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
// Write joint data
if (enmlJointDefinitions != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Joints"));
pElement->LinkEndChild(new TiXmlText(enmlJointDefinitions));
pCollisionRoot->LinkEndChild(pElement);
}
}
}
pRoot->SetAttribute(GS_L("shape"), shape);
if (shape != BS_NONE)
{
pRoot->SetAttribute(GS_L("sensor"), sensor);
pRoot->SetAttribute(GS_L("bullet"), bullet);
pRoot->SetAttribute(GS_L("fixedRotation"), fixedRotation);
pRoot->SetDoubleAttribute(GS_L("friction"), friction);
pRoot->SetDoubleAttribute(GS_L("density"), density);
pRoot->SetDoubleAttribute(GS_L("restitution"), restitution);
pRoot->SetDoubleAttribute(GS_L("gravityScale"), gravityScale);
}
pRoot->SetAttribute(GS_L("applyLight"), applyLight);
if (applyLight)
{
pRoot->SetDoubleAttribute(GS_L("specularPower"), specularPower);
pRoot->SetDoubleAttribute(GS_L("specularBrightness"), specularBrightness);
}
pRoot->SetAttribute(GS_L("castShadow"), castShadow);
if (castShadow)
{
pRoot->SetDoubleAttribute(GS_L("shadowScale"), shadowScale);
pRoot->SetDoubleAttribute(GS_L("shadowLengthScale"), shadowLengthScale);
pRoot->SetDoubleAttribute(GS_L("shadowOpacity"), shadowOpacity);
}
pRoot->SetAttribute(GS_L("type"), type);
if (type == ET_LAYERABLE)
pRoot->SetDoubleAttribute(GS_L("layerDepth"), layerDepth);
if (soundVolume != ETH_DEFAULT_SOUND_VOLUME)
pRoot->SetDoubleAttribute(GS_L("soundVolume"), soundVolume);
if (parallaxIntensity != ETH_DEFAULT_PARALLAX_INTENS)
pRoot->SetDoubleAttribute(GS_L("parallaxIntensity"), parallaxIntensity);
if (hideFromSceneEditor != ETH_FALSE)
pRoot->SetAttribute(GS_L("hideFromSceneEditor"), hideFromSceneEditor);
pRoot->SetAttribute(GS_L("static"), staticEntity);
pRoot->SetAttribute(GS_L("blendMode"), blendMode);
WriteDataToFile(pRoot);
return true;
}
TiXmlNode* TiXmlNode::Identify( const TIXML_CHAR* p, TiXmlEncoding encoding )
{
TiXmlNode* returnNode = 0;
p = SkipWhiteSpace( p, encoding );
if( !p || !*p || *p != _TIXML_L('<') )
{
return 0;
}
TiXmlDocument* doc = GetDocument();
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p )
{
return 0;
}
// What is this thing?
// - Elements start with a letter or underscore, but xml is reserved.
// - Comments: <!--
// - Decleration: <?xml
// - Everthing else is unknown to tinyxml.
//
const TIXML_CHAR* xmlHeader = { _TIXML_L("<?xml") };
const TIXML_CHAR* commentHeader = { _TIXML_L("<!--") };
const TIXML_CHAR* dtdHeader = { _TIXML_L("<!") };
const TIXML_CHAR* cdataHeader = { _TIXML_L("<
