void CGUIIncludes::ResolveConstants(TiXmlElement *node)
{
if (!node)
return;
TiXmlNode *child = node->FirstChild();
if (child && child->Type() == TiXmlNode::TINYXML_TEXT && m_constantNodes.count(node->ValueStr()))
{
child->SetValue(ResolveConstant(child->ValueStr()));
}
else
{
TiXmlAttribute *attribute = node->FirstAttribute();
while (attribute)
{
if (m_constantAttributes.count(attribute->Name()))
attribute->SetValue(ResolveConstant(attribute->ValueStr()));
attribute = attribute->Next();
}
}
}
void CGUIIncludes::ResolveIncludesForNode(TiXmlElement *node, std::map<INFO::InfoPtr, bool>* xmlIncludeConditions /* = NULL */)
{
// we have a node, find any <include file="fileName">tagName</include> tags and replace
// recursively with their real includes
if (!node) return;
// First add the defaults if this is for a control
std::string type;
if (node->ValueStr() == "control")
{
type = XMLUtils::GetAttribute(node, "type");
std::map<std::string, TiXmlElement>::const_iterator it = m_defaults.find(type);
if (it != m_defaults.end())
{
// we don't insert <left> et. al. if <posx> or <posy> is specified
bool hasPosX(node->FirstChild("posx") != NULL);
bool hasPosY(node->FirstChild("posy") != NULL);
const TiXmlElement &element = (*it).second;
const TiXmlElement *tag = element.FirstChildElement();
while (tag)
{
std::string value = tag->ValueStr();
bool skip(false);
if (hasPosX && (value == "left" || value == "right" || value == "centerleft" || value == "centerright"))
skip = true;
if (hasPosY && (value == "top" || value == "bottom" || value == "centertop" || value == "centerbottom"))
skip = true;
// we insert at the end of block
if (!skip)
node->InsertEndChild(*tag);
tag = tag->NextSiblingElement();
}
}
}
TiXmlElement *include = node->FirstChildElement("include");
while (include)
{
// have an include tag - grab it's tag name and replace it with the real tag contents
const char *file = include->Attribute("file");
if (file)
{ // we need to load this include from the alternative file
LoadIncludes(g_SkinInfo->GetSkinPath(file));
}
const char *condition = include->Attribute("condition");
if (condition)
{ // check this condition
INFO::InfoPtr conditionID = g_infoManager.Register(condition);
bool value = conditionID->Get();
if (xmlIncludeConditions)
(*xmlIncludeConditions)[conditionID] = value;
if (!value)
{
include = include->NextSiblingElement("include");
continue;
}
}
Params params;
std::string tagName;
// determine which form of include call we have
const char *name = include->Attribute("content");
if (name)
{
// 1. <include name="MyControl" />
// 2. <include name="MyControl">
// <param name="posx" value="225" />
// <param name="posy">150</param>
// ...
// </include>
tagName = name;
GetParameters(include, "value", params);
}
else
{
const TiXmlNode *child = include->FirstChild();
if (child && child->Type() == TiXmlNode::TINYXML_TEXT)
{
// 3. <include>MyControl</include> // old-style includes for backward compatibility
tagName = child->ValueStr();
}
}
std::map<std::string, std::pair<TiXmlElement, Params>>::const_iterator it = m_includes.find(tagName);
if (it != m_includes.end())
{ // found the tag(s) to include - let's replace it
const TiXmlElement *includeBody = &it->second.first;
const Params& defaultParams = it->second.second;
const TiXmlElement *tag = includeBody->FirstChildElement();
// combine passed include parameters with their default values into a single list (no overwrites)
params.insert(defaultParams.begin(), defaultParams.end());
while (tag)
{
// we insert before the <include> element to keep the correct
// order (we render in the order given in the xml file)
TiXmlElement *insertedTag = static_cast<TiXmlElement*>(node->InsertBeforeChild(include, *tag));
// after insertion we resolve parameters even if parameter list is empty (to remove param references)
ResolveParametersForNode(insertedTag, params);
tag = tag->NextSiblingElement();
}
// remove the include element itself
node->RemoveChild(include);
include = node->FirstChildElement("include");
}
else
{ // invalid include
CLog::Log(LOGWARNING, "Skin has invalid include: %s", tagName.c_str());
include = include->NextSiblingElement("include");
}
}
// run through this element's attributes, resolving any constants
TiXmlAttribute *attribute = node->FirstAttribute();
while (attribute)
{ // check the attribute against our set
if (m_constantAttributes.count(attribute->Name()))
attribute->SetValue(ResolveConstant(attribute->ValueStr()));
if (m_expressionAttributes.count(attribute->Name()))
attribute->SetValue(ResolveExpressions(attribute->ValueStr()));
attribute = attribute->Next();
}
// also do the value
if (node->FirstChild() && node->FirstChild()->Type() == TiXmlNode::TINYXML_TEXT && m_constantNodes.count(node->ValueStr()))
node->FirstChild()->SetValue(ResolveConstant(node->FirstChild()->ValueStr()));
if (node->FirstChild() && node->FirstChild()->Type() == TiXmlNode::TINYXML_TEXT && m_expressionNodes.count(node->ValueStr()))
node->FirstChild()->SetValue(ResolveExpressions(node->FirstChild()->ValueStr()));
}
