public View Render(AdaptiveTypedElement element)
{
if (!this.Config.SupportsInteractivity)
{
AdaptiveInput adaptiveInput = element as AdaptiveInput;
AdaptiveInput adaptiveInput1 = adaptiveInput;
if (adaptiveInput != null)
{
AdaptiveTextBlock nonInteractiveValue = AdaptiveTypedElementConverter.CreateElement <AdaptiveTextBlock>(null);
nonInteractiveValue.Text = adaptiveInput1.GetNonInteractiveValue() ?? "*[Input]*";
nonInteractiveValue.Color = AdaptiveTextColor.Accent;
nonInteractiveValue.Wrap = true;
this.Warnings.Add(new AdaptiveWarning(-1, string.Format("Rendering non-interactive input element '{0}'", element.Type)));
return(this.Render(nonInteractiveValue));
}
}
Func <AdaptiveTypedElement, AdaptiveRenderContext, View> func = this.ElementRenderers.Get(element.GetType());
if (func != null)
{
return(func(element, this));
}
this.Warnings.Add(new AdaptiveWarning(-1, string.Format("No renderer for element '{0}'", element.Type)));
return(null);
}
/// <summary>
/// Helper to deal with casting
/// </summary>
public FrameworkElement Render(AdaptiveTypedElement element)
{
var renderer = ElementRenderers.Get(element.GetType());
if (renderer != null)
{
return(renderer.Invoke(element, this));
}
else
{
Warnings.Add(new AdaptiveWarning(-1, $"No renderer for element type '{element.Type}'"));
return(null);
}
}
/// <summary>
/// Helper to deal with casting
/// </summary>
public FrameworkElement Render(AdaptiveTypedElement element)
{
// Inputs should render read-only if interactivity is false
if (!Config.SupportsInteractivity && element is AdaptiveInput input)
{
var tb = AdaptiveTypedElementConverter.CreateElement <AdaptiveTextBlock>();
tb.Text = input.GetNonInteractiveValue() ?? "*[Input]*";
tb.Color = AdaptiveTextColor.Accent;
tb.Wrap = true;
Warnings.Add(new AdaptiveWarning(-1, $"Rendering non-interactive input element '{element.Type}'"));
return(Render(tb));
}
var renderer = ElementRenderers.Get(element.GetType());
if (renderer != null)
{
// Increment card depth before rendering the inner card
if (element is AdaptiveCard)
{
CardDepth += 1;
}
var rendered = renderer.Invoke(element, this);
if (!String.IsNullOrEmpty(element.Id))
{
rendered.Name = element.Id;
}
// Decrement card depth after inner card is rendered
if (element is AdaptiveCard)
{
CardDepth -= 1;
}
return(rendered);
}
Warnings.Add(new AdaptiveWarning(-1, $"No renderer for element '{element.Type}'"));
return(null);
}
/// <summary>
/// Helper to deal with casting
/// </summary>
public FrameworkElement Render(AdaptiveTypedElement element)
{
// Inputs should render read-only if interactivity is false
if (!Config.SupportsInteractivity && element is AdaptiveInput input)
{
var tb = AdaptiveTypedElementConverter.CreateElement <AdaptiveTextBlock>();
tb.Text = input.GetNonInteractiveValue() ?? "*[Input]*";
tb.Color = AdaptiveTextColor.Accent;
tb.Wrap = true;
Warnings.Add(new AdaptiveWarning(-1, $"Rendering non-interactive input element '{element.Type}'"));
return(Render(tb));
}
var renderer = ElementRenderers.Get(element.GetType());
if (renderer != null)
{
return(renderer.Invoke(element, this));
}
Warnings.Add(new AdaptiveWarning(-1, $"No renderer for element '{element.Type}'"));
return(null);
}
public HtmlTag Render(AdaptiveTypedElement element)
{
// If non-inertactive, inputs should just render text
if (!Config.SupportsInteractivity && element is AdaptiveInput input)
{
var tb = new AdaptiveTextBlock();
tb.Text = input.GetNonInteractiveValue();
Warnings.Add(new AdaptiveWarning(-1, $"Rendering non-interactive input element '{element.Type}'"));
return(Render(tb));
}
var renderer = ElementRenderers.Get(element.GetType());
if (renderer != null)
{
return(renderer.Invoke(element, this));
}
else
{
Warnings.Add(new AdaptiveWarning(-1, $"No renderer for element '{element.Type}'"));
return(null);
}
}
public static void ApplyPadding(Grid uiElement, AdaptiveTypedElement element, AdaptiveContainerStyle parentStyle, AdaptiveRenderContext context)
{
bool canApplyPadding = false;
// AdaptiveColumn inherits from AdaptiveContainer so only one check is required for both
if (element is AdaptiveContainer container)
{
canApplyPadding = ((container.BackgroundImage != null) || ((container.Style != AdaptiveContainerStyle.None) && (container.Style != parentStyle)));
}
else if (element is AdaptiveColumnSet columnSet)
{
canApplyPadding = ((columnSet.Style != AdaptiveContainerStyle.None) && (columnSet.Style != parentStyle));
}
if (canApplyPadding)
{
int padding = context.Config.Spacing.Padding;
Thickness paddingThickness = new Thickness {
Left = padding, Right = padding
};
uiElement.Margin = paddingThickness;
}
}
/// <summary>
/// Helper to deal with casting
/// </summary>
public FrameworkElement Render(AdaptiveTypedElement element)
{
FrameworkElement frameworkElementOut = null;
var oldAncestorHasFallback = AncestorHasFallback;
var elementHasFallback = element != null && element.Fallback != null && (element.Fallback.Type != AdaptiveFallbackElement.AdaptiveFallbackType.None);
AncestorHasFallback = AncestorHasFallback || elementHasFallback;
try
{
if (AncestorHasFallback && !element.MeetsRequirements(FeatureRegistration))
{
throw new AdaptiveFallbackException("Element requirements aren't met");
}
// Inputs should render read-only if interactivity is false
if (!Config.SupportsInteractivity && element is AdaptiveInput input)
{
var tb = AdaptiveTypedElementConverter.CreateElement <AdaptiveTextBlock>();
tb.Text = input.GetNonInteractiveValue() ?? "*[Input]*";
tb.Color = AdaptiveTextColor.Accent;
tb.Wrap = true;
Warnings.Add(new AdaptiveWarning(-1, $"Rendering non-interactive input element '{element.Type}'"));
frameworkElementOut = Render(tb);
}
if (frameworkElementOut == null)
{
var renderer = ElementRenderers.Get(element.GetType());
if (renderer != null)
{
var rendered = renderer.Invoke(element, this);
if (!String.IsNullOrEmpty(element.Id))
{
rendered.Name = element.Id;
}
frameworkElementOut = rendered;
}
}
}
catch (AdaptiveFallbackException)
{
if (!elementHasFallback)
{
throw;
}
}
if (frameworkElementOut == null)
{
// Since no renderer exists for this element, add warning and render fallback (if available)
if (element.Fallback != null && element.Fallback.Type != AdaptiveFallbackElement.AdaptiveFallbackType.None)
{
if (element.Fallback.Type == AdaptiveFallbackElement.AdaptiveFallbackType.Drop)
{
Warnings.Add(new AdaptiveWarning(-1, $"Dropping element '{element.Type}' for fallback"));
}
else if (element.Fallback.Type == AdaptiveFallbackElement.AdaptiveFallbackType.Content && element.Fallback.Content != null)
{
// Render fallback content
Warnings.Add(new AdaptiveWarning(-1, $"Performing fallback for '{element.Type}' (fallback element type '{element.Fallback.Content.Type}')"));
RenderingFallback = true;
frameworkElementOut = Render(element.Fallback.Content);
RenderingFallback = false;
}
}
else if (AncestorHasFallback && !RenderingFallback)
{
throw new AdaptiveFallbackException();
}
else
{
Warnings.Add(new AdaptiveWarning(-1, $"No renderer for element '{element.Type}'"));
}
}
AncestorHasFallback = oldAncestorHasFallback;
return(frameworkElementOut);
}
public HtmlTag Render(AdaptiveTypedElement element)
{
HtmlTag htmlTagOut = null;
var oldAncestorHasFallback = AncestorHasFallback;
var elementHasFallback = element != null && element.Fallback != null && (element.Fallback.Type != AdaptiveFallbackElement.AdaptiveFallbackType.None);
AncestorHasFallback = AncestorHasFallback || elementHasFallback;
try
{
if (AncestorHasFallback && !element.MeetsRequirements(FeatureRegistration))
{
throw new AdaptiveFallbackException("Element requirements aren't met");
}
// If non-interactive, inputs should just render text
if (!Config.SupportsInteractivity && element is AdaptiveInput input)
{
var tb = new AdaptiveTextBlock();
tb.Text = input.GetNonInteractiveValue();
Warnings.Add(new AdaptiveWarning(-1, $"Rendering non-interactive input element '{element.Type}'"));
htmlTagOut = Render(tb);
}
if (htmlTagOut == null)
{
var renderer = ElementRenderers.Get(element.GetType());
if (renderer != null)
{
htmlTagOut = renderer.Invoke(element, this);
}
}
}
catch (AdaptiveFallbackException)
{
if (!elementHasFallback)
{
throw;
}
}
if (htmlTagOut == null)
{
// Since no renderer exists for this element, add warning and render fallback (if available)
if (element.Fallback != null && element.Fallback.Type != AdaptiveFallbackElement.AdaptiveFallbackType.None)
{
if (element.Fallback.Type == AdaptiveFallbackElement.AdaptiveFallbackType.Drop)
{
Warnings.Add(new AdaptiveWarning(-1, $"Dropping element for fallback '{element.Type}'"));
}
else if (element.Fallback.Type == AdaptiveFallbackElement.AdaptiveFallbackType.Content && element.Fallback.Content != null)
{
// Render fallback content
htmlTagOut = Render(element.Fallback.Content);
}
}
else if (AncestorHasFallback)
{
throw new AdaptiveFallbackException();
}
else
{
Warnings.Add(new AdaptiveWarning(-1, $"No renderer for element '{element.Type}'"));
}
}
AncestorHasFallback = oldAncestorHasFallback;
return(htmlTagOut);
}
private void TestGetElementById <T>(AdaptiveTypedElement parent, string id) where T : AdaptiveTypedElement
{
var element = parent.GetElementById <T>(id);
Assert.IsNotNull(element);
}
public Func <AdaptiveTypedElement, TContext, TUIElement> Get(Dictionary <string, object> elementDefinitions, AdaptiveTypedElement element)
{
var type = element.GetType();
if (_dictionary.ContainsKey(type))
{
return(_dictionary[type]);
}
// For Actions we can render the base AdaptiveAction type
if (typeof(AdaptiveAction).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
{
return(_dictionary[typeof(AdaptiveAction)]);
}
throw new ArgumentOutOfRangeException(nameof(type), $"Unable to locate renderer for {type}");
}
