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