protected void AddFromAttribute <T>(XmlNode node, string attrName, string entryName, bool throwIfMissing, Dictionary <string, object> dict = null)
{
var attr = node.Attributes[attrName];
if (attr == null)
{
if (throwIfMissing)
{
throw KmlParseException.MissingRequiredAttribute(attrName, node);
}
else
{
return;
}
}
if (dict == null)
{
Properties.Add(entryName, ParseValue <T>(attr.Value));
}
else
{
dict.Add(entryName, ParseValue <T>(attr.Value));
}
}
public static KTextModule TryCreateFromModuleNode(XmlNode moduleNode)
{
if (moduleNode.Name != "text")
{
return(null);
}
var text = new KTextModule();
text.LoadBasicsFromNode(moduleNode);
text.Properties.Add("internal_type", "TextModule");
text.AddOptional(moduleNode, "font", "text_family", s => {
if (s.StartsWith("kfile://"))
{
return(s);
}
else
{
return("kfile://org.kustom.provider/fonts/" + s);
}
});
text.AddOptional(moduleNode, "align", "text_align");
text.AddOptional(moduleNode, "width", "text_width");
text.AddOptional(moduleNode, "height", "text_height");
text.AddOptional(moduleNode, "maxlines", "text_lines");
text.AddOptional(moduleNode, "size", "text_size");
text.AddOptional(moduleNode, "type", "text_size_type");
var textNode = moduleNode.SelectSingleNode("text");
if (textNode == null)
{
throw KmlParseException.MissingRequiredNode("text", moduleNode);
}
text.AddFromContent(textNode, "text_expression", text.Properties);
var textFiltersNode = moduleNode.SelectSingleNode("textfilters");
if (textFiltersNode != null)
{
var filterNodes = textFiltersNode.SelectNodes("filter");
foreach (XmlNode filterNode in filterNodes)
{
text.TextFilter.Add(filterNode.InnerText);
}
}
return(text);
}
public static List <KModule> SubmodulesNodeToKModuleList(XmlNode submodulesNode)
{
var list = new List <KModule>();
foreach (XmlNode node in submodulesNode.ChildNodes)
{
// ignore comment nodes
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
if (node.Name == "repeat")
{
var timesAttr = node.Attributes["times"];
if (timesAttr == null)
{
throw KmlParseException.MissingRequiredAttribute("times", node);
}
int repeatCount;
if (int.TryParse(timesAttr.Value, out repeatCount))
{
// add multiple times
for (int i = 0; i < repeatCount; i++)
{
list.AddRange(SubmodulesNodeToKModuleList(node));
}
}
else
{
throw KmlParseException.InvalidRepeatValue(timesAttr.Value);
}
}
else
{
// add normal node
list.Add(ModuleNodeToKModule(node));
}
var repeatAttr = node.Attributes["repeat"];
if (repeatAttr != null)
{
}
else
{
}
}
return(list);
}
/// <summary>
/// Read the value of <paramref name="attrName"/> of <paramref name="node"/>,
/// parse it to the given type using <see cref="ParseValue{T}(string)"/>,
/// then add the value to <see cref="Properties"></see>.<br/>
/// After that, search <paramref name="node"/> for a formula or global node with attr = <paramref name="attrName"/>.
/// If found, add formulas to <see cref="InternalFormulas"/> and globals to <see cref="InternalGlobals"/>,
/// then set <see cref="InternalToggles"/>[<paramref name="entryName"/>] to 0 for normal value, 10 for formula and 100 for global.<br/>
/// Throws when <paramref name="attrName"/> value cannot be parsed or when the attribute is not found and <paramref name="throwIfMissing"/> is true.
/// </summary>
/// <typeparam name="T">The type to convert the attribute value to.</typeparam>
/// <param name="node">The node to read attribute value and subnodes from.</param>
/// <param name="attrName">The attribute name.</param>
/// <param name="entryName">The key to add to dictionaries.</param>
/// <exception cref="KmlParseException"></exception>
protected void AddAttrValueFormulaGlobal <T>(XmlNode node, string attrName, string entryName, bool throwIfMissing, Func <T, T> transform = null)
{
var attr = node.Attributes[attrName];
var globalNode = node.SelectSingleNode($"global[@attr='{attrName}']");
var formulaNode = node.SelectSingleNode($"formula[@attr='{attrName}']");
if (attr == null)
{
if (throwIfMissing)
{
throw KmlParseException.MissingRequiredAttribute(attrName, node);
}
else
{
return;
}
}
if (attr != null)
{
if (transform == null)
{
Properties.Add(entryName, ParseValue <T>(attr.Value));
}
else
{
Properties.Add(entryName, transform((T)ParseValue <T>(attr.Value)));
}
}
if (globalNode != null && formulaNode != null)
{
throw KmlParseException.CannotSetToFormulaAndGlobal(attrName, node);
}
if (globalNode != null)
{
InternalToggles.Add(entryName, 100);
AddFromAttribute(globalNode, "global", entryName, true, InternalGlobals);
}
if (formulaNode != null)
{
InternalToggles.Add(entryName, 10);
AddFromContent(formulaNode, entryName, InternalFormulas);
}
}
public static KModule ModuleNodeToKModule(XmlNode moduleNode)
{
KModule module = null;
module = KShapeModule.TryCreateFromModuleNode(moduleNode);
if (module == null)
{
module = KTextModule.TryCreateFromModuleNode(moduleNode);
}
if (module == null)
{
throw KmlParseException.UnknownModuleName(moduleNode.Name);
}
return(module);
}
protected object ParseValue <T>(string value)
{
var type = typeof(T);
try
{
// short-circuit here for strings
if (type == typeof(string))
{
return(value);
}
if (type == typeof(double))
{
return(double.Parse(value));
}
if (type == typeof(int))
{
return(int.Parse(value));
}
if (type == typeof(float))
{
return(float.Parse(value));
}
else
{
return(value);
}
}
catch (Exception ex)
{
throw KmlParseException.CouldNotParseValueAsType(value, type);
}
}
public static KTouchEvent CreateFromEventNode(XmlNode eventNode)
{
if (eventNode.Name != "event")
{
throw KmlParseException.ExpectedDifferentNode("event", eventNode);
}
var ev = new KTouchEvent();
var typeAttr = eventNode.Attributes["type"];
if (typeAttr == null)
{
throw KmlParseException.MissingRequiredAttribute("type", eventNode);
}
ev.Type = typeAttr.Value;
var actionAttr = eventNode.Attributes["action"];
if (actionAttr == null)
{
throw KmlParseException.MissingRequiredAttribute("action", eventNode);
}
ev.Action = actionAttr.Value;
var globalAttr = eventNode.Attributes["global"];
if (globalAttr != null)
{
ev.Switch = globalAttr.Value;
}
ev.SwitchText = eventNode.InnerText.Trim();
return(ev);
}
public static KAnimationKeyframe CreateFromNode(XmlNode node)
{
if (node.Name != "keyframe")
{
throw KmlParseException.ExpectedDifferentNode("keyframe", node);
}
var keyframe = new KAnimationKeyframe();
var propertyAttr = node.Attributes["property"];
if (propertyAttr == null)
{
throw KmlParseException.MissingRequiredAttribute("property", node);
}
else
{
keyframe.Property = propertyAttr.Value;
}
double dbl;
var positionAttr = node.Attributes["position"];
if (positionAttr == null)
{
throw KmlParseException.MissingRequiredAttribute("position", node);
}
else
{
if (double.TryParse(positionAttr.Value, out dbl))
{
keyframe.Position = dbl;
}
else
{
throw KmlParseException.CouldNotParseValueAsType(positionAttr.Value, typeof(double));
}
}
var valueAttr = node.Attributes["value"];
if (valueAttr == null)
{
throw KmlParseException.MissingRequiredAttribute("value", node);
}
else
{
if (double.TryParse(valueAttr.Value, out dbl))
{
keyframe.Value = dbl;
}
else
{
throw KmlParseException.CouldNotParseValueAsType(valueAttr.Value, typeof(double));
}
}
// ease is the only non-required attribute here
var easeAttr = node.Attributes["ease"];
if (easeAttr != null)
{
keyframe.Ease = easeAttr.Value;
}
return(keyframe);
}
