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); }