public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (prop.Type == typeof(Vector2))
{
return(new Provider2(ParseVector(node, 2)));
}
if (prop.Type == typeof(Vector3))
{
return(new Provider3(ParseVector(node, 3)));
}
if (prop.Type == typeof(Vector4))
{
return(new Provider4(ParseVector(node, 4)));
}
return(null);
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (prop.Type != typeof(ElementKey))
{
return(null);
}
return(ResolveInternal(context, element, node));
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (!typeof(ofElement).IsAssignableFrom(prop.Type))
{
return(null);
}
return(((IYamlComponentBuilder)context.Builder).BuildElement(context, node));
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (!CollectionPropProvider.IsCollection(prop.Type, out _, out var itemType))
{
return(null);
}
IEnumerable <YamlNode> items;
switch (node)
{
case YamlSequenceNode n:
items = n;
break;
case YamlScalarNode n when string.IsNullOrEmpty(n.Value):
items = Enumerable.Empty <YamlNode>();
break;
default:
items = new[] { node };
break;
}
return(new CollectionPropProvider(prop.Type, items.Select(n => ((IYamlComponentBuilder)context.Builder).PropResolver.Resolve(context, element, itemType, n))));
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (prop.Type != typeof(FontUsage))
{
return(null);
}
switch (node)
{
case YamlScalarNode scalar:
var parts = scalar.Value.Split(',');
switch (parts.Length)
{
case 1:
return(new Provider(FontUsage.Default.With(family: parts[0])));
case 2:
return(new Provider(FontUsage.Default.With(family: parts[0], size: node.ToSingle(parts[1]))));
default: throw new YamlComponentException("Must be a scalar that indicates the font family name and an optional font size.", node);
}
case YamlMappingNode mapping:
var usage = FontUsage.Default;
foreach (var(keyNode, valueNode) in mapping)
{
var key = keyNode.ToScalar().Value;
switch (key)
{
case "family":
usage = usage.With(family: valueNode.ToScalar().Value);
break;
case "weight":
usage = usage.With(weight: valueNode.ToScalar().Value);
break;
case "italics":
usage = usage.With(italics: valueNode.ToBoolean());
break;
case "size":
usage = usage.With(size: valueNode.ToSingle());
break;
case "fixed":
usage = usage.With(fixedWidth: valueNode.ToBoolean());
break;
default:
throw new YamlComponentException($"Invalid font property '{key}'.", keyNode);
}
}
return(new Provider(usage));
default:
throw new YamlComponentException("Must be a scalar or sequence.", node);
}
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node) => _resolvers.Select(r => r.Resolve(context, element, prop, node)).FirstOrDefault(p => p != null);
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node) => prop.GetAttributes() .OfType <IPropResolver>() .Select(r => r.Resolve(context, element, prop, node)) .FirstOrDefault(p => p != null);
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (prop.Type == typeof(Color4))
{
return(new Provider(ParseColor(node)));
}
if (prop.Type == typeof(SRGBColour))
{
return(new SrgbProvider(ParseColor(node)));
}
if (prop.Type == typeof(ColourInfo))
{
switch (node)
{
case YamlScalarNode scalar:
return(new MultiProvider(ParseColor(scalar)));
case YamlSequenceNode sequence when sequence.Children.Count == 1:
return(new MultiProvider(ParseColor(sequence[0])));
case YamlSequenceNode sequence when sequence.Children.Count == 4:
return(new MultiProvider(new ColourInfo
{
TopLeft = ParseColor(sequence[0]),
TopRight = ParseColor(sequence[1]),
BottomRight = ParseColor(sequence[2]),
BottomLeft = ParseColor(sequence[3])
}));
case YamlMappingNode mapping when mapping.Children.Count == 1:
foreach (var(keyNode, valueNode) in mapping)
{
var value = valueNode.ToSequence().Children;
switch (keyNode.ToScalar().Value)
{
case "vertical":
if (value.Count != 2)
{
throw new YamlComponentException("Must be a sequence containing two colors representing the top and bottom of gradient.", valueNode);
}
return(new MultiProvider(ColourInfo.GradientVertical(ParseColor(value[0]), ParseColor(value[1]))));
case "horizontal":
if (value.Count != 2)
{
throw new YamlComponentException("Must be a sequence containing two colors representing the left and right of gradient.", valueNode);
}
return(new MultiProvider(ColourInfo.GradientHorizontal(ParseColor(value[0]), ParseColor(value[1]))));
default:
throw new YamlComponentException("Must specify either vertical or horizontal gradient.", keyNode);
}
}
break;
default:
throw new YamlComponentException("Must be a sequence containing 4 components or a mapping that specifies a gradient.", node);
}
}
return(null);
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (prop.Type != typeof(MarginPadding))
{
return(null);
}
switch (node)
{
case YamlScalarNode scalar:
return(new Provider(new MarginPadding(scalar.ToSingle())));
case YamlSequenceNode sequence when sequence.Children.Count == 1:
return(new Provider(new MarginPadding(sequence[0].ToSingle())));
case YamlSequenceNode sequence when sequence.Children.Count == 4:
return(new Provider(new MarginPadding
{
Top = sequence[0].ToSingle(),
Right = sequence[1].ToSingle(),
Bottom = sequence[2].ToSingle(),
Left = sequence[3].ToSingle()
}));
case YamlMappingNode mapping:
var value = new MarginPadding();
foreach (var(keyNode, valueNode) in mapping)
{
var key = keyNode.ToScalar().Value;
switch (key)
{
case "top":
value.Top = valueNode.ToSingle();
break;
case "right":
value.Right = valueNode.ToSingle();
break;
case "bottom":
value.Bottom = valueNode.ToSingle();
break;
case "left":
value.Left = valueNode.ToSingle();
break;
default:
throw new YamlComponentException($"Invalid margin/padding property '{key}'.", keyNode);
}
}
return(new Provider(value));
default:
throw new YamlComponentException("Must be a sequence containing 4 components or a mapping that specifies top-left-bottom-right margin/padding respectively.", node);
}
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (prop.Type != typeof(LocalisedString))
{
return(null);
}
return(new Provider(node.ToScalar().Value));
}
// resolving a style delegate parameter
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (!IsStyleDelegate(prop.Type))
{
return(null);
}
var provider = new Provider(prop.Type);
foreach (var(key, value) in node.ToMapping())
{
try
{
// find member by name
var memberName = key.ToScalar().Value;
var member = provider.FindMember(memberName);
// resolve member using prop provider
var memberProvider = member == null ? null : ((IYamlComponentBuilder)context.Builder).PropResolver.Resolve(context, null, member, value);
if (memberProvider == null)
{
throw new YamlComponentException($"Cannot resolve property or field '{memberName}' in element {provider.DrawableType}.", key);
}
provider.Properties[member] = memberProvider;
}
catch (Exception e)
{
context.OnException(e);
}
}
return(provider);
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (!prop.Type.IsPrimitive && prop.Type != typeof(string))
{
return(null);
}
var value = node.ToScalar().Value;
try
{
return(new Provider(Convert.ChangeType(value, prop.Type, CultureInfo.InvariantCulture)));
}
catch (Exception e)
{
throw new YamlComponentException($"Cannot convert '{value}' to type {prop.Type}.", node, e);
}
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
var underlying = Nullable.GetUnderlyingType(prop.Type);
if (underlying == null)
{
return(null);
}
// rerun prop resolution using unwrapped nullable type
return(new Provider(prop.Type, ((IYamlComponentBuilder)context.Builder).PropResolver.Resolve(context, element, underlying, node)));
}
public IPropProvider Resolve(ComponentBuilderContext context, ElementBuilder element, PropTypeInfo prop, YamlNode node)
{
if (!prop.Type.IsEnum)
{
return(null);
}
var value = node.ToScalar().Value;
if (Enum.TryParse(prop.Type, value, IgnoreEnumCase, out var parsed))
{
return(new Provider(parsed, prop.Type));
}
throw new YamlComponentException($"Cannot convert '{value}' to enum {prop.Type}.", node);
}
