void CGUIIncludes::ResolveParametersForNode(TiXmlElement *node, const Params& params)
{
if (!node)
return;
std::string newValue;
// run through this element's attributes, resolving any parameters
TiXmlAttribute *attribute = node->FirstAttribute();
while (attribute)
{
ResolveParamsResult result = ResolveParameters(attribute->ValueStr(), newValue, params);
if (result == SINGLE_UNDEFINED_PARAM_RESOLVED && strcmp(node->Value(), "param") == 0 &&
strcmp(attribute->Name(), "value") == 0 && node->Parent() && strcmp(node->Parent()->Value(), "include") == 0)
{
// special case: passing <param name="someName" value="$PARAM[undefinedParam]" /> to the nested include
// this usually happens when trying to forward a missing parameter from the enclosing include to the nested include
// problem: since 'undefinedParam' is not defined, it expands to <param name="someName" value="" /> and overrides any default value set with <param name="someName" default="someValue" /> in the nested include
// to prevent this, we'll completely remove this parameter from the nested include call so that the default value can be correctly picked up later
node->Parent()->RemoveChild(node);
return;
}
else if (result != NO_PARAMS_FOUND)
attribute->SetValue(newValue);
attribute = attribute->Next();
}
// run through this element's value and children, resolving any parameters
TiXmlNode *child = node->FirstChild();
if (child)
{
if (child->Type() == TiXmlNode::TINYXML_TEXT)
{
ResolveParamsResult result = ResolveParameters(child->ValueStr(), newValue, params);
if (result == SINGLE_UNDEFINED_PARAM_RESOLVED && strcmp(node->Value(), "param") == 0 &&
node->Parent() && strcmp(node->Parent()->Value(), "include") == 0)
{
// special case: passing <param name="someName">$PARAM[undefinedParam]</param> to the nested include
// we'll remove the offending param tag same as above
node->Parent()->RemoveChild(node);
}
else if (result != NO_PARAMS_FOUND)
child->SetValue(newValue);
}
else if (child->Type() == TiXmlNode::TINYXML_ELEMENT)
{
do
{
TiXmlElement *next = child->NextSiblingElement(); // save next as current child might be removed from the tree
ResolveParametersForNode(static_cast<TiXmlElement *>(child), params);
child = next;
}
while (child);
}
}
}
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()));
}
void CGUIIncludes::ResolveIncludes(TiXmlElement *node, std::map<INFO::InfoPtr, bool>* xmlIncludeConditions /* = NULL */)
{
if (!node)
return;
TiXmlElement *include = node->FirstChildElement("include");
while (include)
{
// file: load includes from specified XML file
const char *file = include->Attribute("file");
if (file)
Load(g_SkinInfo->GetSkinPath(file));
// condition: process include if condition evals to true
const char *condition = include->Attribute("condition");
if (condition)
{
INFO::InfoPtr conditionID = g_infoManager.Register(ResolveExpressions(condition));
bool value = conditionID->Get();
if (xmlIncludeConditions)
xmlIncludeConditions->insert(std::make_pair(conditionID, value));
if (!value)
{
include = include->NextSiblingElement("include");
continue;
}
}
Params params;
std::string tagName;
// normal or old-style include
const char *name = include->Attribute("content");
if (name)
{
// <include content="MyControl" />
// or
// <include content="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)
{
// <include>MyControl</include>
// old-style includes for backward compatibility
tagName = child->ValueStr();
}
}
// check, whether the include exists and therefore should be replaced by its definition
auto it = m_includes.find(tagName);
if (it != m_includes.end())
{
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");
}
}
}
