/// <summary>
/// All xml roads lead through here
/// </summary>
private async Task <IVisualElement> InflateXmlImpl(String xml,
IDictionary <String, String> searchSeed)
{
var sw = Stopwatch.StartNew();
var node = GetRootNode(xml);
var nsAsmSearch = _visualTypeResolver.GetNamespaceAssemblySearch(node, searchSeed);
var lineage = new VisualLineage();
var res = await GetVisualAsync(node, null, nsAsmSearch, lineage,
_appliedStyleBuilder.ApplyVisualStylesAsync).ConfigureAwait(false);
Debug.WriteLine("Inflated visual in " + sw.ElapsedMilliseconds + " ms");
lineage.AssertPopVisual(res);
if (lineage.Count > 0)
{
throw new InvalidOperationException();
}
return(res);
}
public virtual ValueSize MeasureElement <TRenderSize>(IVisualElement element,
TRenderSize availableSpace)
where TRenderSize : IRenderSize
{
if (!element.IsRequiresMeasure)
{
lock (_measureLock)
{
if (_lastMeasurements.TryGetValue(element, out var val))
{
LayoutQueue.RemoveVisualFromMeasureQueue(element);
return(val);
}
}
}
// measure anyways if we know nothing of it...?
//return ValueSize.Empty;
VisualLineage.PushVisual(element);
//_styleContext.PushVisual(element);
var layoutElement = GetElementForLayout(element);
////////////////////////
var res = MeasureElementImpl(layoutElement, availableSpace);
////////////////////////
LayoutQueue.RemoveVisualFromMeasureQueue(element);
element.AcceptChanges(ChangeType.Measure);
return(res);
}
private void Init(IWindowManager windowManager,
IThemeProvider themeProvider,
IViewPerspective viewPerspective,
DisplayMetrics displayMetrics,
AndroidFontProvider fontProvider,
IViewState viewState,
IUiProvider uiProvider,
ref AndroidMeasureKit measureContext,
ref AndroidRenderContext renderContext,
ref RefreshRenderContext refreshRenderContext)
{
var imageProvider = new AndroidImageProvider(displayMetrics);
var visualLineage = new VisualLineage();
var lastMeasures = new Dictionary <IVisualElement, ValueSize>();
var layoutQueue = new LayoutQueue();
measureContext = new AndroidMeasureKit(windowManager, fontProvider,
this, lastMeasures, themeProvider, displayMetrics, visualLineage, layoutQueue);
var visualPositions = new Dictionary <IVisualElement, ValueCube>();
renderContext = new AndroidRenderContext(viewPerspective,
fontProvider, viewState, this, visualPositions,
lastMeasures, themeProvider, visualLineage, layoutQueue);
refreshRenderContext = new RefreshRenderContext(viewPerspective, this,
visualPositions, lastMeasures, themeProvider, visualLineage, layoutQueue);
Container.ResolveTo <IImageProvider>(imageProvider);
Container.ResolveTo(uiProvider);
Container.ResolveTo(themeProvider);
}
private void Init(IWindowProvider <IVisualHost> windowProvider,
IThemeProvider themeProvider,
IViewPerspective viewPerspective,
Dictionary <IVisualElement, ValueCube> renderPositions,
ref GdiImageProvider?imageProvider,
ref GdiMeasureContext measureContext,
ref GdiRenderContext renderContext)
{
imageProvider = new GdiImageProvider();
var lastMeasure = new Dictionary <IVisualElement, ValueSize>();
var visualLineage = new VisualLineage();
measureContext = new GdiMeasureContext(this, lastMeasure,
themeProvider, visualLineage, VisualBootstrapper.LayoutQueue);
renderContext = new GdiRenderContext(viewPerspective,
MeasureContext.Graphics, this, lastMeasure,
renderPositions, themeProvider, visualLineage, VisualBootstrapper.LayoutQueue);
Container.ResolveTo <IImageProvider>(imageProvider);
Container.ResolveTo <IUiProvider>(new GdiUiProvider(windowProvider));
Container.ResolveTo(themeProvider);
windowProvider.WindowShown += OnWindowShown;
RegisterSurrogate <HtmlPanel>(GetHtmlPanelSurrogate);
}
//public StaticGdiRenderKit(IViewPerspective viewPerspective,
// IMultiSerializer xmlSerializer)
//: this(viewPerspective, xmlSerializer)
//{}
public StaticGdiRenderKit(IViewPerspective viewPerspective,
IMultiSerializer xmlSerializer)
: base(new GdiImageProvider(), xmlSerializer,
NullSvgBuilder.Instance, null)
{
var defaultSurrogates = new BaseSurrogateProvider();
var lastMeasure = new Dictionary <IVisualElement, ValueSize>();
var visualLineage = new VisualLineage();
var layoutQueue = new LayoutQueue();
MeasureContext = new GdiMeasureContext(defaultSurrogates, lastMeasure,
BaselineThemeProvider.Instance, visualLineage, layoutQueue);
RenderContext = new GdiRenderContext(viewPerspective,
MeasureContext.Graphics, defaultSurrogates, lastMeasure,
new Dictionary <IVisualElement, ValueCube>(),
BaselineThemeProvider.Instance, visualLineage, layoutQueue);
}
public OpenGLRenderKit(IFontProvider fontProvider,
IGLContext glContext,
IThemeProvider themeProvider,
IImageProvider imageProvider)
: base(imageProvider, Serializer,
new SvgPathBuilder(imageProvider, Serializer), null)
//: base(themeProvider, Serializer.AttributeParser,
// Serializer.TypeInferrer, Serializer.TypeManipulator,
// new Dictionary<IVisualElement, ValueCube>(), imageProvider,
// Serializer.AssemblyList, Serializer)
{
var lastMeasurements = new Dictionary <IVisualElement, ValueSize>();
var lastRender = new Dictionary <IVisualElement, ValueCube>();
var visualLineage = new VisualLineage();
var layoutQueue = new LayoutQueue();
MeasureContext = new GLMeasureContext(fontProvider, this,
lastMeasurements, themeProvider, visualLineage, layoutQueue);
RenderContext = new GLRenderContext(new BasePerspective(),
glContext, fontProvider, this, themeProvider,
visualLineage, lastRender, layoutQueue);
}
private ValueSize MeasureElementImpl <TRenderSize>(IVisualElement element,
TRenderSize availableSpace)
where TRenderSize : IRenderSize
{
if (element.Visibility == Visibility.Collapsed)
{
return(ValueSize.Empty);
}
var margin = element.Margin.GetValue(availableSpace);
var border = element.Border;
var borderThickness = border.GetThickness(availableSpace);
ValueSize desiredSize;
Double extraWidth;
Double extraHeight;
if (margin.IsEmpty && border.IsEmpty)
{
desiredSize = element.Measure(availableSpace, this);
extraWidth = 0;
extraHeight = 0;
}
else
{
extraWidth = margin.Width + borderThickness.Width;
extraHeight = margin.Height + borderThickness.Height;
desiredSize = element.Measure(
new ValueRenderSize(availableSpace.Width - extraWidth,
availableSpace.Height - extraHeight), this);
}
var h = desiredSize.Height;
switch (element.Height?.Units ?? LengthUnits.Invalid)
{
case LengthUnits.Invalid:
case LengthUnits.Percent:
h = desiredSize.Height + extraHeight;
break;
case LengthUnits.Px:
h = element.Height !.Value.GetQuantity(availableSpace.Height) + extraHeight;
break;
}
var w = desiredSize.Width;
switch (element.Width?.Units ?? LengthUnits.Invalid)
{
case LengthUnits.Invalid:
case LengthUnits.Percent:
w = desiredSize.Width + margin.Width + borderThickness.Width;
break;
case LengthUnits.Px:
w = element.Width !.Value.GetQuantity(availableSpace.Width) + extraWidth;
break;
}
desiredSize = new ValueSize(w, h);
var useHeight = desiredSize.Height;
var useWidth = desiredSize.Width;
if (element.BeforeLabel is { } beforeLabel)
{
VisualLineage.PushVisual(beforeLabel);
var beforeLabelMeasured = MeasureElementImpl(beforeLabel, availableSpace);
useHeight = Math.Max(useHeight, beforeLabelMeasured.Height);
useWidth += beforeLabelMeasured.Width;
}
if (element.AfterLabel is { } afterLabel)
{
VisualLineage.PushVisual(afterLabel);
var afterLabelMeasured = MeasureElementImpl(afterLabel, availableSpace);
useHeight = Math.Max(useHeight, afterLabelMeasured.Height);
useWidth += afterLabelMeasured.Width;
}
desiredSize = new ValueSize(useWidth, useHeight);
SetLastMeasured(element, desiredSize);
VisualLineage.PopVisual();
return(desiredSize);
}
