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