public PseudoVisualAssignment(IVisualElement toVisual, ContentAppendType appendType, IStyleRule rule, IVisualBootstrapper visualBootstrapper, IVisualLineage visualLineage, BuildAssignments assignmentsBuilder) { Visual = toVisual; _appendType = appendType; ILabel applyTo; switch (appendType) { case ContentAppendType.Before: if (!(toVisual.BeforeLabel is { } beforeLabel)) { applyTo = visualBootstrapper.Instantiate <Label>(); toVisual.BeforeLabel = applyTo; } else { applyTo = beforeLabel; } break;
public IAppliedStyle?BuildAppliedStyle(IStyleSheet style, IVisualElement visual, IVisualLineage visualLineage, IVisualBootstrapper visualBootstrapper) { var appliedStyle = new AppliedStyle(style); foreach (var rule in style.Rules) { var appliedRule = BuildAppliedRule(appliedStyle, rule, visual, visualLineage, visualBootstrapper); if (appliedRule == null) { continue; } appliedStyle.AddAppliedRule(appliedRule); } appliedStyle.EnsureInverseForFilteredSelectors(); TrySetVisualStyle(visual, appliedStyle); if (!appliedStyle.HasAppliedRules) { return(default);
public AndroidFontPaint GetRenderer(IFont font, IVisualLineage visualLineage) { var currentVisual = visualLineage.PeekVisual(); lock (_fontLock) { AndroidFontPaint painter; if (currentVisual != null) { if (!_visualFonts.TryGetValue(currentVisual, out var myFonts)) { myFonts = new Dictionary <IFont, AndroidFontPaint>(); _visualFonts[currentVisual] = myFonts; } if (!myFonts.TryGetValue(font, out painter)) { painter = new AndroidFontPaint(font, _displayMetrics, true); myFonts[font] = painter; } return(painter); } if (!_fonts.TryGetValue(font, out painter)) { painter = new AndroidFontPaint(font, _displayMetrics, false); _fonts[font] = painter; } return(painter); } }
public T GetStyleSetter <T>(StyleSetterType setterType, IVisualElement element, IVisualLineage visualLineage) { return(GetStyleSetter <T>(setterType, VisualStateType.None, element, visualLineage)); }
public Task <IVisualElement> GetVisualAsync(IMarkupNode node, Type dataContextType, IVisualLineage visualLineage, ApplyVisualStyles applyStyles) { return(GetVisualAsync(node, dataContextType, VisualTypeResolver.DefaultNamespaceSeed, visualLineage, applyStyles)); }
public RefreshRenderContext(IViewPerspective perspective, IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueCube> renderPositions, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(perspective, surrogateProvider, renderPositions, lastMeasurements, themeProvider, visualLineage, layoutQueue) { }
protected BaseMeasureContext(IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(lastMeasurements, themeProvider, surrogateProvider, visualLineage, layoutQueue) { _contextBounds = ValueSize.Empty; _lastMeasurements = lastMeasurements; }
public GLMeasureContext(IFontProvider fontProvider, IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(surrogateProvider, lastMeasurements, themeProvider, visualLineage, layoutQueue) { _fontProvider = fontProvider; }
protected BaseRenderContext(IViewPerspective perspective, IVisualSurrogateProvider surrogateProvider, IThemeProvider themeProvider, IVisualLineage visualLineage, Dictionary <IVisualElement, ValueCube> renderPositions, ILayoutQueue layoutQueue) : this(perspective, surrogateProvider, renderPositions, new Dictionary <IVisualElement, ValueSize>(), themeProvider, visualLineage, layoutQueue) { }
public GdiMeasureContext(IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(surrogateProvider, lastMeasurements, themeProvider, visualLineage, layoutQueue) { var bmp = new Bitmap(1, 1); Graphics = Graphics.FromImage(bmp); }
public async Task ApplyStylesToVisualAsync(IVisualElement visual, String?styleClassName, IVisualLineage visualLineage) { if (!String.IsNullOrEmpty(styleClassName)) { var classStyles = _styleProvider.GetStylesByClassNameAsync(styleClassName !); await foreach (var style in classStyles) { } } }
public GdiRenderContext(IViewPerspective perspective, Graphics nullGraphics, IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueSize> lastMeasures, Dictionary <IVisualElement, ValueCube> renderPositions, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(perspective, surrogateProvider, renderPositions, lastMeasures, themeProvider, visualLineage, layoutQueue) { _testPen = new Pen(Color.Yellow, 1); Graphics = nullGraphics; }
public GLRenderContext(IViewPerspective perspective, IGLContext openGlContext, IFontProvider fontProvider, IVisualSurrogateProvider surrogateProvider, IThemeProvider themeProvider, IVisualLineage visualLineage, Dictionary <IVisualElement, ValueCube> renderPositions, ILayoutQueue layoutQueue) : base(perspective, surrogateProvider, themeProvider, visualLineage, renderPositions, layoutQueue) { _openGlContext = openGlContext; _fontProvider = fontProvider; }
public AndroidMeasureKit(IWindowManager windowManager, AndroidFontProvider fontProvider, IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, DisplayMetrics displayMetrics, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(surrogateProvider, lastMeasurements, themeProvider, visualLineage, layoutQueue) { _windowManager = windowManager; _fontProvider = fontProvider; _contextBounds = GetCOntextBounds(displayMetrics); }
public AndroidRenderContext(IViewPerspective perspective, AndroidFontProvider fontProvider, IViewState viewState, IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueCube> renderPositions, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(perspective, surrogateProvider, renderPositions, lastMeasurements, themeProvider, visualLineage, layoutQueue) { _fontProvider = fontProvider; _paint = new Paint(); ViewState = viewState; }
protected ContextBase(Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, //IStyleContext styleContext, IVisualSurrogateProvider surrogateProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) { _measureLock = new Object(); _lastMeasurements = lastMeasurements; //_styleContext = styleContext; _surrogateProvider = surrogateProvider; _themeProvider = themeProvider; VisualLineage = visualLineage; LayoutQueue = layoutQueue; ViewState = NullViewState.Instance; }
private static Boolean IsVisualSelectable(IVisualElement visual, IStyleSelector selector, IVisualLineage visualLineage) { switch (selector) { case AndStyleSelector andy: foreach (var sel in andy.Selectors) { if (!IsVisualSelectable(visual, sel, visualLineage)) { return(false); } } return(true); case VisualTypeStyleSelector typeSelector: var res = typeSelector.VisualType.IsInstanceOfType(visual); return(res); case DependencyPropertySelector _: return(false); case ClassStyleSelector classSelector: var className = GetClassName(visual, visualLineage); return(className == classSelector.ClassName); case ContentAppenderSelector contentAppender: var res2 = IsVisualSelectable(visual, contentAppender.TypeSelector, visualLineage); if (res2) { } return(res2); case VisualStateSelector stateSelector: // the state selector isn't tied to a specific type and is combined // with a type selector (presumably...) return(IsVisualSelectable(visual, stateSelector.BaseSelector, visualLineage)); default: throw new NotImplementedException(); } }
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)); } }
private static String?GetClassName(IVisualElement visual, IVisualLineage visualLineage) { if (!String.IsNullOrEmpty(visual.Class)) { return(visual.Class); } foreach (var item in visualLineage) { if (!String.IsNullOrEmpty(item.Class)) { return(item.Class); } } return(default);
public T GetStyleSetter <T>(StyleSetterType setterType, VisualStateType type, IVisualElement element, IVisualLineage visualLineage) { if (TryGetStyleSetterImpl <T>(setterType, type, element, visualLineage, out var found)) { return(found); } if (type != VisualStateType.None && TryGetStyleSetterImpl(setterType, VisualStateType.None, element, visualLineage, out found)) { return(found); } return(_defaultStyle[setterType] is T good ? good : default !);
//public async Task ApplyStylesToVisualAsync(IVisualElement visual, // IAttributeDictionary attributeDictionary, // IVisualLineage visualLineage, // IViewInflater viewInflater) //{ // var applicableRules = ApplyStyleValuesToVisual(visual, attributeDictionary, visualLineage); // TrySetVisualStyle(visual, new StyleSheet(applicableRules)); // await Task.CompletedTask; //} public List <IStyleRule> ApplyStyleValuesToVisual(IVisualElement visual, IAttributeDictionary attributeDictionary, IVisualLineage visualLineage) { TrySetVisualClass(visual, attributeDictionary); var applicableRules = new List <IStyleRule>(); foreach (var rule in _rules) { if (TryApplyRuleToVisual(visual, rule, visualLineage)) { applicableRules.Add(rule); } } return(applicableRules); }
public IEnumerable <IStyleValueAssignment> BuildStyleValueAssignments(IVisualElement visual, IVisualLineage visualLineage, IStyleRule rule, IVisualBootstrapper visualBootstrapper) { if (rule.Selector.TryGetContentAppendType(out var contentAppend)) { yield return(new PseudoVisualAssignment(visual, contentAppend, rule, visualBootstrapper, visualLineage, BuildStyleValueAssignments)); } else { foreach (var assignment in BuildStyleValueAssignments(visual, visualLineage, rule.Selector, rule.Declarations)) { yield return(assignment); } } }
protected BaseRenderContext(IViewPerspective perspective, IVisualSurrogateProvider surrogateProvider, Dictionary <IVisualElement, ValueCube> renderPositions, Dictionary <IVisualElement, ValueSize> lastMeasurements, IThemeProvider themeProvider, IVisualLineage visualLineage, ILayoutQueue layoutQueue) : base(lastMeasurements, themeProvider, surrogateProvider, visualLineage, layoutQueue) { RenderPositions = renderPositions; LastRenderPositions = new Dictionary <IVisualElement, ValueCube>(); _renderLock = new Object(); Perspective = perspective; CurrentElementRect = ValueRenderRectangle.Empty; _locations = new Stack <ValueRenderRectangle>(); _locations.Push(CurrentElementRect); _boxModel = new BoxModelLayoutTree(); }
/// <summary> /// Returns the root visual and/or any child visuals that meet the /// requirements of the selector /// </summary> public static IEnumerable <IVisualElement> GetSelectableVisuals(IVisualElement rootVisual, IStyleSelector selector, IVisualLineage visualLineage) { switch (selector) { case AndStyleSelector andy: var selectables = GetSelectableVisualsImpl(rootVisual, andy, visualLineage, 0); foreach (var selectable in selectables) { yield return(selectable); } break; default: if (IsVisualSelectable(rootVisual, selector, visualLineage)) { yield return(rootVisual); } break; } }
/// <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); } }
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); }
private static IEnumerable <IVisualElement> GetSelectableVisualsImpl(IVisualElement rootVisual, AndStyleSelector selectors, IVisualLineage visualLineage, Int32 selectorIndex) { var currentVisual = rootVisual; for (var c = selectorIndex; c < selectors.Count; c++) { var currentSelector = selectors[c]; switch (currentSelector) { case CombinatorSelector combinator: switch (combinator.Combinator) { case Combinator.Invalid: case Combinator.None: throw new InvalidOperationException(); case Combinator.Descendant: break; case Combinator.Child: if (!(currentVisual is IVisualContainer container)) { yield break; } foreach (var childVisual in container.Children.GetAllChildren()) { visualLineage.PushVisual(childVisual); var selectableChildren = GetSelectableVisualsImpl(childVisual, selectors, visualLineage, c + 1); foreach (var selectable in selectableChildren) { yield return(selectable); } visualLineage.AssertPopVisual(childVisual); } break; case Combinator.GeneralSibling: break; case Combinator.AdjacentSibling: var nextSibling = visualLineage.GetNextSibling(); if (nextSibling != null) { visualLineage.PushVisual(nextSibling); var selectableSiblings = GetSelectableVisualsImpl(nextSibling, selectors, visualLineage, c + 1); foreach (var selectable in selectableSiblings) { yield return(selectable); } visualLineage.AssertPopVisual(nextSibling); } break; case Combinator.Column: break; default: throw new ArgumentOutOfRangeException(); } break; case VisualStateSelector stateSelector: if (IsVisualSelectable(currentVisual, stateSelector.BaseSelector, visualLineage)) { } goto default; default: if (!IsVisualSelectable(currentVisual, currentSelector, visualLineage)) { yield break; } if (c == selectors.Count - 1) { yield return(currentVisual); } break; } } }
public T GetStyleSetter <T>(StyleSetterType setterType, VisualStateType type, IVisualElement element, IVisualLineage visualLineage) { return(ThrowException <T>()); }
public async Task ApplyStylesToVisualAsync(IVisualElement visual, IAttributeDictionary attributeDictionary, IVisualLineage visualLineage, IViewInflater viewInflater) { await _appliedStyleBuilder.ApplyVisualStylesAsync(visual, attributeDictionary, visualLineage, viewInflater); return; var omgStyle = await _styleProvider.GetStyleForVisualAsync(visual, attributeDictionary); if (omgStyle != null) { } if (attributeDictionary.TryGetAttributeValue("class", out var className)) { await ApplyStylesToVisualAsync(visual, className, visualLineage); return; } if (attributeDictionary.TryGetAttributeValue("Style", out var styleName)) { var style = await _styleProvider.GetStyleByNameAsync(styleName); if (style == null) { return; } //var applyingRules = new StyledVisualWorker(style, _propertyProvider, _visualBootstrapper); //applyingRules.TrySetVisualStyle(visual, style); //if (applyingRules.TryGetVisualTemplate(out var visualTemplate) && // visualTemplate is DeferredVisualTemplate deferred) if (TryGetVisualTemplate(style, out var visualTemplate) && visualTemplate is DeferredVisualTemplate deferred) { //var contentVisual = await viewInflater.GetVisualAsync(deferred.MarkupNode, // visual.GetType(), visualLineage, applyingRules.ApplyStylesToVisualAsync); var contentVisual = await viewInflater.GetVisualAsync(deferred.MarkupNode, visual.GetType(), visualLineage, _appliedStyleBuilder.ApplyVisualStylesAsync); visual.Template = new VisualTemplate { Content = contentVisual }; //control template's data context should be the control being templated....? if (contentVisual is IBindableElement bindable) { bindable.DataContext = visual; } visualLineage.AssertPopVisual(contentVisual); _appliedStyleBuilder.BuildAppliedStyle(style, visual, visualLineage); } else { await _appliedStyleBuilder.ApplyVisualStylesAsync(visual, attributeDictionary, visualLineage); //applyingRules.ApplyStyleValuesToVisual(visual, attributeDictionary, visualLineage); } } }