private IStyleRule?GetStyleRule(IMarkupNode setterNode,
Type targetType)
{
var rule = _xmlRuleBuilder.GetRule(setterNode, targetType);
return(rule);
}
public Dictionary <String, String> GetNamespaceAssemblySearch(IMarkupNode node,
IDictionary <String, String> search)
{
var nsAsmSearch = new Dictionary <String, String>(search);
return(GetNamespaceAssemblySearchImpl(node, nsAsmSearch));
}
private async IAsyncEnumerable <KeyValuePair <String, IPropertyBinding> > GetBindings(
Type dataContextType,
IMarkupNode node,
Dictionary <String, String>
nameSpaceAssemblySearch)
{
foreach (var kvp in node.GetAllAttributes())
{
BindingType bindingType;
var valTrim = kvp.Value.Trim();
if (valTrim.Length < 3 ||
valTrim[0] != '{' || valTrim[valTrim.Length - 1] != '}')
{
continue;
}
var valExpression = valTrim.Substring(1, valTrim.Length - 2);
var expressionGroups = valExpression.Split(',');
var expressionTokens = expressionGroups[0].Split();
String propName;
switch (expressionTokens.Length)
{
case 2 when expressionTokens[0] == DATA_BINDING:
public Task <IVisualElement> GetVisualAsync(IMarkupNode node,
Type dataContextType,
IVisualLineage visualLineage,
ApplyVisualStyles applyStyles)
{
return(GetVisualAsync(node, dataContextType, VisualTypeResolver.DefaultNamespaceSeed,
visualLineage, applyStyles));
}
public IStyleRule?GetRule(IMarkupNode cssNode)
{
var selector = _selectorBuilder.GetSelector(cssNode);
var declarations = GetDeclarations(cssNode);
var res = new StyleValueRule(selector, declarations);
if (res.Declarations.Length == 0)
{
return(default);
private static Dictionary <String, String> GetNamespaceAssemblySearchImpl(IMarkupNode node,
Dictionary <String, String> nsAsmSearch)
{
foreach (var attribute in node.GetAllAttributes())
{
if (!attribute.Key.StartsWith("xmlns:"))
{
continue;
}
var tokens = attribute.Value.Split(';');
String?asmName = null;
String?ns = null;
for (var t = 0; t < tokens.Length; t++)
{
var subTokens = tokens[t].Split(_namespaceSplitters);
if (subTokens.Length != 2)
{
continue;
}
switch (subTokens[0])
{
case "clr-namespace":
ns = subTokens[1];
break;
case "assembly":
asmName = subTokens[1];
//if (!asmName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) &&
// !asmName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
//{
// asmName += ".dll";
//}
break;
}
}
if (ns == null)
{
continue;
}
if (asmName == null)
{
continue;
}
nsAsmSearch[ns] = asmName;
}
return(nsAsmSearch);
}
private static Object?BuildPropertyValue(IDependencyProperty property,
IMarkupNode parentNode)
{
if (typeof(IVisualTemplate).IsAssignableFrom(property.PropertyType))
{
if (parentNode.ChildrenCount != 1)
{
throw new NotImplementedException();
}
return(new DeferredVisualTemplate(parentNode[0]));
}
throw new NotImplementedException();
}
public IStyleSelector GetSelector(IMarkupNode cssNode)
{
GetSelectorParts(cssNode, out var selectors, out _);
switch (selectors.Count)
{
case 0:
throw new InvalidOperationException();
case 1:
return(selectors[0]);
default:
return(new AndStyleSelector(selectors));
}
}
private async Task <IDataTemplate> BuildDataTemplateAsync(IMarkupNode node,
Type?dataContextType,
Dictionary <String, String> nameSpaceAssemblySearch,
IVisualLineage visualLineage,
ApplyVisualStyles applyStyles)
{
if (node.ChildrenCount != 1)
{
var visuals = new List <IVisualElement>();
foreach (var childNode in node.Children)
{
var visual = await GetVisualAsync(childNode, dataContextType,
nameSpaceAssemblySearch, visualLineage, applyStyles).ConfigureAwait(false);
visuals.Add(visual);
}
return(new MultiDataTemplate(_visualBootstrapper, dataContextType, visuals));
}
var onlyChild = node.Children.First();
switch (onlyChild.Name)
{
case nameof(MultiDataTemplate):
var dataBindings = (await _bindingBuilder.GetBindingsDictionaryAsync(node,
dataContextType, nameSpaceAssemblySearch)).Values.OfType <IDataBinding>();
dataContextType = _bindingBuilder.InferDataContextTypeFromBindings(dataBindings,
dataContextType);
return(await BuildDataTemplateAsync(onlyChild, dataContextType,
nameSpaceAssemblySearch, visualLineage, applyStyles).ConfigureAwait(false));
case nameof(DataTemplate):
return(await BuildDataTemplateAsync(onlyChild, dataContextType,
nameSpaceAssemblySearch, visualLineage, applyStyles).ConfigureAwait(false));
default:
var visualContent = await GetVisualAsync(onlyChild, dataContextType,
nameSpaceAssemblySearch, visualLineage, applyStyles).ConfigureAwait(false);
visualLineage.AssertPopVisual(visualContent);
return(new DataTemplate(_visualBootstrapper, dataContextType, visualContent));
}
}
public IStyleRule?GetRule(IMarkupNode markupNode,
Type targetType)
{
if (markupNode.TryGetAttributeValue(nameof(DependencyPropertySelector.Property),
out var propertyName))
{
if (DependencyProperty.TryGetDependecyProperty(targetType, propertyName, out var depProp))
{
var selector = new DependencyPropertySelector(depProp);
var propVal = BuildPropertyValue(depProp, markupNode);
var objDeclaration = new ObjectDeclaration(propVal);
return(new DependencyPropertyValueRule(selector, objDeclaration));
}
}
throw new NotImplementedException();
}
public Type GetType(IMarkupNode node,
String?genericArgName,
Dictionary <String, String> nameSpaceAssemblySearch)
{
var name = node.Name;
if (_typeAliases.TryGetValue(name, out var aliasedType))
{
return(node.ChildrenCount == 0
? aliasedType.ChildlessType
: aliasedType.PanelType);
}
if (name == "input" && node.TryGetAttributeValue("type", out var inputType))
{
switch (inputType)
{
case "checkbox":
return(typeof(CheckBox));
}
}
var notGeneric = _typeInferrer.GetTypeFromClearName(name, nameSpaceAssemblySearch);
if (notGeneric != null)
{
return(notGeneric);
}
if (!String.IsNullOrEmpty(genericArgName) && node.ChildrenCount > 0)
{
var letsTry = name + "[" + genericArgName + "]";
var found = _typeInferrer.GetTypeFromClearName(letsTry, nameSpaceAssemblySearch, true);
if (found != null)
{
return(found);
}
}
throw new TypeLoadException(name);
}
private IEnumerable <IStyleRule> GetStyleRules(IMarkupNode child,
Type targetType)
{
switch (child.Name)
{
case nameof(IStyle.Setters):
foreach (var setterNode in child.Children)
{
foreach (var rule in GetStyleRules(setterNode, targetType))
{
yield return(rule);
}
}
break;
case "Setter":
var styleRule = GetStyleRule(child, targetType);
if (styleRule != null)
{
yield return(styleRule);
}
break;
case "Rules":
var css = child.InnerText;
if (css != null)
{
foreach (var cssRule in _cssRuleBuilder.GetRules(css))
{
yield return(cssRule);
}
}
break;
}
}
public async Task <Dictionary <String, IPropertyBinding> > GetBindingsDictionaryAsync(
IMarkupNode node,
Type?dataContextType,
Dictionary <String, String>
nameSpaceAssemblySearch)
{
Dictionary <String, IPropertyBinding> bindings;
if (dataContextType != null)
{
bindings = new Dictionary <String, IPropertyBinding>();
await foreach (var kvp in GetBindings(dataContextType, node, nameSpaceAssemblySearch))
{
bindings.Add(kvp.Key, kvp.Value);
}
}
else
{
bindings = _emptyBindings;
}
return(bindings);
}
public Type GetType(IMarkupNode node,
String?genericArgName)
{
return(GetType(node, genericArgName, DefaultNamespaceSeed));
}
private void GetSelectorParts(IMarkupNode cssNode,
out List <IStyleSelector> currentAndSelectors,
out List <Combinator> combinators)
{
currentAndSelectors = new List <IStyleSelector>();
combinators = new List <Combinator>();
var name = cssNode.Name;
if (name == "*")
{
currentAndSelectors.Add(AllStyleSelector.Instance);
return;
}
var tokens = name.Split();
for (var c = 0; c < tokens.Length; c++)
{
var currentToken = tokens[c];
if (currentToken.Length == 0)
{
continue;
}
switch (currentToken[0])
{
case '.':
{
var classSelector = GetClassStyleSelector(currentToken);
currentAndSelectors.Add(classSelector);
break;
}
case '>':
currentAndSelectors.Add(new CombinatorSelector(Combinator.Child));
break;
case '+':
currentAndSelectors.Add(new CombinatorSelector(Combinator.AdjacentSibling));
break;
case '~':
currentAndSelectors.Add(new CombinatorSelector(Combinator.AdjacentSibling));
break;
case '|':
if (currentToken[1] == '|')
{
currentAndSelectors.Add(new CombinatorSelector(Combinator.Column));
}
break;
case ' ':
currentAndSelectors.Add(new CombinatorSelector(Combinator.Descendant));
break;
default:
var colonIndex = currentToken.IndexOf(':');
if (colonIndex > 0)
{
var visualName = currentToken.Substring(0, colonIndex);
var typeSelector = GetVisualTypeSelector(visualName);
if (currentToken.Length > colonIndex + 1 &&
currentToken[colonIndex + 1] == ':')
{
// span::before
var appenderName = currentToken.Substring(colonIndex + 2);
var appendSelector = GetContentAppender(typeSelector, appenderName);
currentAndSelectors.Add(appendSelector);
break;
}
// PSEUDO
// input:checked
var stateType = GetStateType(currentToken, colonIndex);
var visualStateSelector = new VisualStateSelector(typeSelector, stateType);
currentAndSelectors.Add(visualStateSelector);
}
else
{
var visualTypeSelector = GetVisualTypeSelector(currentToken);
currentAndSelectors.Add(visualTypeSelector);
}
break;
}
}
}
private async Task <IContentVisual> BuildContentVisualAsync(IMarkupNode node,
Type?dataContextType,
Dictionary <String, String> nameSpaceAssemblySearch,
Type visualType,
IVisualLineage visualLineage,
ApplyVisualStyles applyStyles)
{
IVisualElement?contentVisual = null;
//-------------------------------
var contentContainer = _visualBootstrapper.Instantiate <IContentVisual>(visualType)
?? throw new InvalidOperationException();
//await applyStyles(contentContainer, node, visualLineage, this);
//-------------------------------
visualLineage.PushVisual(contentContainer);
switch (node.ChildrenCount)
{
case 1:
{
var currentNode = node[0];
var childObjRes = await InflateChildAsync(currentNode, contentContainer,
dataContextType, nameSpaceAssemblySearch, visualLineage, applyStyles)
.ConfigureAwait(false);
if (childObjRes.ChildType == ChildNodeType.ChildVisual &&
childObjRes.Child is IVisualElement childVisual)
{
contentVisual = childVisual;
}
else if (childObjRes.ChildType == ChildNodeType.PropertyValue &&
childObjRes.VisualProperty is { } prop)
{
//Object oContentContainer = contentContainer;
prop.SetPropertyValue(ref contentContainer, childObjRes.Child);
//prop.SetValue(contentContainer, childObjRes.Child, null);
}
break;
}
case 0:
{
if (!node.TryGetAttributeValue(nameof(IContentContainer.Content), out var textContent))
{
textContent = node.InnerText;
}
if (!String.IsNullOrEmpty(textContent))
{
// zb <button>TEXT</button> etc
contentVisual = new Label(_visualBootstrapper)
{
Text = textContent !
};
visualLineage.PushVisual(contentVisual);
}
break;
}
default:
throw new NotImplementedException();
}
contentContainer !.Content = contentVisual;
if (contentVisual != null)
{
visualLineage.AssertPopVisual(contentVisual);
}
return(contentContainer);
}
/// <summary>
/// Builds a visual from a markup node. Infers the data context type and instantiates
/// a generic visual if possible
/// </summary>
/// <param name="node">an xml/json etc node</param>
/// <param name="dataContextType">the data context type of the parent visual.</param>
/// <param name="nameSpaceAssemblySearch"></param>
/// <param name="visualLineage"></param>
/// <param name="applyStyles"></param>
/// <returns></returns>
private async Task <IVisualElement> GetVisualAsync(IMarkupNode node,
Type?dataContextType,
Dictionary <String, String> nameSpaceAssemblySearch,
IVisualLineage visualLineage,
ApplyVisualStyles applyStyles)
{
var bindings = await _bindingBuilder.GetBindingsDictionaryAsync(node,
dataContextType, nameSpaceAssemblySearch);
var dataBindings = bindings.Values.OfType <IDataBinding>()
.ToArray();
dataContextType = _bindingBuilder.InferDataContextTypeFromBindings(dataBindings,
dataContextType);
if (!node.TryGetAttributeValue("ContextType", out var currentGenericArgName))
{
currentGenericArgName = dataContextType?.Name;
}
else
{
dataContextType = _typeInferrer.GetTypeFromClearName(currentGenericArgName,
nameSpaceAssemblySearch, true);
}
var visualType = _visualTypeResolver.GetType(node, currentGenericArgName,
nameSpaceAssemblySearch);
IVisualElement visual;
if (typeof(IContentContainer).IsAssignableFrom(visualType))
{
// CONTENT VISUAL
visual = await BuildContentVisualAsync(node, dataContextType,
nameSpaceAssemblySearch, visualType, visualLineage, applyStyles)
.ConfigureAwait(false);
}
else if (visualType is { } validVisualType)
{
//-------------------------------
visual = _visualBootstrapper.Instantiate <IVisualElement>(validVisualType);
//await applyStyles(visual, node, visualLineage, this);
//-------------------------------
visualLineage.PushVisual(visual);
if (node.ChildrenCount > 0)
{
// PANEL
await InflateAndAddChildNodesAsync(node, visual, dataContextType,
nameSpaceAssemblySearch, visualLineage,
_appliedStyleBuilder.ApplyVisualStylesAsync).ConfigureAwait(false);
}
if (node.InnerText is { } innerText&&
innerText.Trim() is { } validInnerText&& validInnerText.Length > 0 &&
GetAttribute <ContentPropertyAttribute>(validVisualType) is { } cp&&
_typeInferrer.FindPublicProperty(validVisualType, cp.Name) is { } contentProp&&
contentProp.PropertyType == typeof(String))
{
// zb <Label>hello world</Label>
contentProp.SetValue(visual, validInnerText, null);
}
}
public DeferredVisualTemplate(IMarkupNode markup)
{
MarkupNode = markup;
}
