public static FrameworkElement Render(AdaptiveContainer container, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
//uiContainer.Margin = new Thickness(context.Config.Spacing.Padding);
uiContainer.Style = context.GetStyle("Adaptive.Container");
uiContainer.SetBackgroundSource(container.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var outerStyle = context.ForegroundColors;
if (container.Style != null)
{
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(container.Style);
uiContainer.SetBackgroundColor(containerStyle.BackgroundColor, context);
context.ForegroundColors = containerStyle.ForegroundColors;
}
switch (container.VerticalContentAlignment)
{
case AdaptiveVerticalContentAlignment.Center:
uiContainer.VerticalAlignment = VerticalAlignment.Center;
break;
case AdaptiveVerticalContentAlignment.Bottom:
uiContainer.VerticalAlignment = VerticalAlignment.Bottom;
break;
case AdaptiveVerticalContentAlignment.Top:
default:
break;
}
AddContainerElements(uiContainer, container.Items, context);
if (container.SelectAction != null)
{
return(context.RenderSelectAction(container.SelectAction, uiContainer));
}
Grid uiOuterContainer = new Grid();
uiOuterContainer.Children.Add(uiContainer);
Border border = new Border();
border.Child = uiOuterContainer;
if (!container.IsVisible)
{
border.Visibility = Visibility.Collapsed;
}
// Revert context's value to that of outside the Container
context.ForegroundColors = outerStyle;
return(border);
}
public static FrameworkElement Render(AdaptiveColumn column, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Column");
uiContainer.SetBackgroundSource(column.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var parentRenderArgs = context.RenderArgs;
// This is the renderArgs that will be passed down to the children
var childRenderArgs = new AdaptiveRenderArgs(parentRenderArgs);
Border border = new Border();
border.Child = uiContainer;
bool inheritsStyleFromParent = !column.Style.HasValue;
bool columnHasPadding = false;
if (!inheritsStyleFromParent)
{
columnHasPadding = AdaptiveContainerRenderer.ApplyPadding(border, uiContainer, column, parentRenderArgs, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(column.Style);
border.Background = context.GetColorBrush(containerStyle.BackgroundColor);
childRenderArgs.ForegroundColors = containerStyle.ForegroundColors;
}
childRenderArgs.ParentStyle = (inheritsStyleFromParent) ? parentRenderArgs.ParentStyle : column.Style.Value;
// If the column has no padding or has padding and doesn't bleed, then the children can bleed
// to the side the column would have bled
if (columnHasPadding)
{
childRenderArgs.BleedDirection = BleedDirection.Both;
}
// If either this column or an ancestor had padding, then the children will have an ancestor with padding
childRenderArgs.HasParentWithPadding = (columnHasPadding || parentRenderArgs.HasParentWithPadding);
context.RenderArgs = childRenderArgs;
AdaptiveContainerRenderer.AddContainerElements(uiContainer, column.Items, context);
RendererUtil.ApplyVerticalContentAlignment(uiContainer, column);
RendererUtil.ApplyIsVisible(uiContainer, column);
uiContainer.MinHeight = column.PixelMinHeight;
// Revert context's value to that of outside the Column
context.RenderArgs = parentRenderArgs;
return(RendererUtil.ApplySelectAction(border, column, context));
}
public static FrameworkElement Render(AdaptiveColumn column, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Column");
uiContainer.SetBackgroundSource(column.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var parentRenderArgs = context.RenderArgs;
var elementRenderArgs = new AdaptiveRenderArgs(parentRenderArgs);
Border border = new Border();
border.Child = uiContainer;
bool inheritsStyleFromParent = !column.Style.HasValue;
bool columnHasPadding = false;
if (!inheritsStyleFromParent)
{
columnHasPadding = AdaptiveContainerRenderer.ApplyPadding(border, uiContainer, column, parentRenderArgs, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(column.Style);
border.Background = context.GetColorBrush(containerStyle.BackgroundColor);
elementRenderArgs.ForegroundColors = containerStyle.ForegroundColors;
}
elementRenderArgs.ParentStyle = (inheritsStyleFromParent) ? parentRenderArgs.ParentStyle : column.Style.Value;
if ((parentRenderArgs.ColumnRelativePosition == ColumnPositionEnum.Begin) ||
(parentRenderArgs.ColumnRelativePosition == ColumnPositionEnum.End))
{
elementRenderArgs.ColumnRelativePosition = ColumnPositionEnum.Intermediate;
}
elementRenderArgs.HasParentWithPadding = columnHasPadding;
context.RenderArgs = elementRenderArgs;
AdaptiveContainerRenderer.AddContainerElements(uiContainer, column.Items, context);
RendererUtil.ApplyVerticalContentAlignment(uiContainer, column);
RendererUtil.ApplyIsVisible(uiContainer, column);
uiContainer.MinHeight = column.PixelMinHeight;
// Revert context's value to that of outside the Column
context.RenderArgs = parentRenderArgs;
return(RendererUtil.ApplySelectAction(border, column, context));
}
public static FrameworkElement Render(AdaptiveContainer container, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Container");
uiContainer.SetBackgroundSource(container.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var parentRenderArgs = context.RenderArgs;
var elementRenderArgs = new AdaptiveRenderArgs(parentRenderArgs);
Grid uiOuterContainer = new Grid();
uiOuterContainer.Children.Add(uiContainer);
Border border = new Border();
border.Child = uiOuterContainer;
RendererUtil.ApplyVerticalContentAlignment(uiContainer, container);
RendererUtil.ApplyIsVisible(border, container);
uiContainer.MinHeight = container.PixelMinHeight;
bool inheritsStyleFromParent = !container.Style.HasValue;
bool hasPadding = false;
if (!inheritsStyleFromParent)
{
hasPadding = ApplyPadding(border, uiOuterContainer, container, parentRenderArgs, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(container.Style);
border.Background = context.GetColorBrush(containerStyle.BackgroundColor);
elementRenderArgs.ForegroundColors = containerStyle.ForegroundColors;
}
// Modify context outer parent style so padding necessity can be determined
elementRenderArgs.ParentStyle = (inheritsStyleFromParent) ? parentRenderArgs.ParentStyle : container.Style.Value;
elementRenderArgs.HasParentWithPadding = (hasPadding || parentRenderArgs.HasParentWithPadding);
context.RenderArgs = elementRenderArgs;
AddContainerElements(uiContainer, container.Items, context);
// Revert context's value to that of outside the Container
context.RenderArgs = parentRenderArgs;
return(RendererUtil.ApplySelectAction(border, container, context));
}
public static View Render(AdaptiveContainer container, AdaptiveRenderContext context)
{
ContainerStyleConfig defaultConfig = context.Config.ContainerStyles.Default;
Grid grid = new Grid()
{
Style = context.GetStyle("Adaptive.Container")
};
AdaptiveContainerRenderer.AddContainerElements(grid, container.Items, context);
if (container.SelectAction != null)
{
return(context.RenderSelectAction(container.SelectAction, grid));
}
Grid grid1 = new Grid()
{
BackgroundColor = context.GetColor(defaultConfig.BackgroundColor)
};
grid1.Children.Add(grid);
return(grid1);
}
public static FrameworkElement Render(AdaptiveContainer container, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Container");
uiContainer.SetBackgroundSource(container.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var parentRenderArgs = context.RenderArgs;
// This is the renderArgs that will be passed down to the children
var childRenderArgs = new AdaptiveRenderArgs(parentRenderArgs);
Grid uiOuterContainer = new Grid();
uiOuterContainer.Children.Add(uiContainer);
Border border = new Border();
border.Child = uiOuterContainer;
RendererUtil.ApplyVerticalContentAlignment(uiContainer, container);
uiContainer.MinHeight = container.PixelMinHeight;
bool inheritsStyleFromParent = !container.Style.HasValue;
bool hasPadding = false;
if (!inheritsStyleFromParent)
{
hasPadding = ApplyPadding(border, uiOuterContainer, container, parentRenderArgs, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(container.Style);
border.Background = context.GetColorBrush(containerStyle.BackgroundColor);
childRenderArgs.ForegroundColors = containerStyle.ForegroundColors;
}
switch (container.VerticalContentAlignment)
{
case AdaptiveVerticalContentAlignment.Center:
uiContainer.VerticalAlignment = VerticalAlignment.Center;
break;
case AdaptiveVerticalContentAlignment.Bottom:
uiContainer.VerticalAlignment = VerticalAlignment.Bottom;
break;
case AdaptiveVerticalContentAlignment.Top:
default:
break;
}
if (hasPadding)
{
childRenderArgs.BleedDirection = BleedDirection.BleedAll;
}
// Modify context outer parent style so padding necessity can be determined
childRenderArgs.ParentStyle = (inheritsStyleFromParent) ? parentRenderArgs.ParentStyle : container.Style.Value;
childRenderArgs.HasParentWithPadding = (hasPadding || parentRenderArgs.HasParentWithPadding);
context.RenderArgs = childRenderArgs;
AddContainerElements(uiContainer, container.Items, context);
// Revert context's value to that of outside the Container
context.RenderArgs = parentRenderArgs;
return(RendererUtil.ApplySelectAction(border, container, context));
}
public static FrameworkElement Render(AdaptiveColumn column, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Column");
uiContainer.SetBackgroundSource(column.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var parentRenderArgs = context.RenderArgs;
var elementRenderArgs = new AdaptiveRenderArgs(parentRenderArgs);
Border border = new Border();
border.Child = uiContainer;
bool inheritsStyleFromParent = !column.Style.HasValue;
bool columnHasPadding = false;
if (!inheritsStyleFromParent)
{
columnHasPadding = AdaptiveContainerRenderer.ApplyPadding(border, uiContainer, column, parentRenderArgs, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(column.Style);
border.Background = context.GetColorBrush(containerStyle.BackgroundColor);
elementRenderArgs.ForegroundColors = containerStyle.ForegroundColors;
}
elementRenderArgs.ParentStyle = (inheritsStyleFromParent) ? parentRenderArgs.ParentStyle : column.Style.Value;
if ((parentRenderArgs.ColumnRelativePosition == ColumnPositionEnum.Begin) ||
(parentRenderArgs.ColumnRelativePosition == ColumnPositionEnum.End))
{
elementRenderArgs.ColumnRelativePosition = ColumnPositionEnum.Intermediate;
}
elementRenderArgs.HasParentWithPadding = columnHasPadding;
context.RenderArgs = elementRenderArgs;
AdaptiveContainerRenderer.AddContainerElements(uiContainer, column.Items, context);
if (column.SelectAction != null)
{
return(context.RenderSelectAction(column.SelectAction, border));
}
switch (column.VerticalContentAlignment)
{
case AdaptiveVerticalContentAlignment.Center:
uiContainer.VerticalAlignment = VerticalAlignment.Center;
break;
case AdaptiveVerticalContentAlignment.Bottom:
uiContainer.VerticalAlignment = VerticalAlignment.Bottom;
break;
case AdaptiveVerticalContentAlignment.Top:
default:
break;
}
if (!column.IsVisible)
{
uiContainer.Visibility = Visibility.Collapsed;
}
// Revert context's value to that of outside the Column
context.RenderArgs = parentRenderArgs;
return(border);
}
public static FrameworkElement Render(AdaptiveContainer container, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Container");
uiContainer.SetBackgroundSource(container.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var parentRenderArgs = context.RenderArgs;
var elementRenderArgs = new AdaptiveRenderArgs(parentRenderArgs);
Grid uiOuterContainer = new Grid();
uiOuterContainer.Children.Add(uiContainer);
Border border = new Border();
border.Child = uiOuterContainer;
if (!container.IsVisible)
{
border.Visibility = Visibility.Collapsed;
}
bool inheritsStyleFromParent = (container.Style == AdaptiveContainerStyle.None);
bool hasPadding = false;
if (!inheritsStyleFromParent)
{
hasPadding = ApplyPadding(border, uiOuterContainer, container, parentRenderArgs, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(container.Style);
border.Background = context.GetColorBrush(containerStyle.BackgroundColor);
elementRenderArgs.ForegroundColors = containerStyle.ForegroundColors;
}
switch (container.VerticalContentAlignment)
{
case AdaptiveVerticalContentAlignment.Center:
uiContainer.VerticalAlignment = VerticalAlignment.Center;
break;
case AdaptiveVerticalContentAlignment.Bottom:
uiContainer.VerticalAlignment = VerticalAlignment.Bottom;
break;
case AdaptiveVerticalContentAlignment.Top:
default:
break;
}
// Modify context outer parent style so padding necessity can be determined
elementRenderArgs.ParentStyle = (inheritsStyleFromParent) ? parentRenderArgs.ParentStyle : container.Style;
elementRenderArgs.HasParentWithPadding = (hasPadding || parentRenderArgs.HasParentWithPadding);
context.RenderArgs = elementRenderArgs;
AddContainerElements(uiContainer, container.Items, context);
if (container.SelectAction != null)
{
return(context.RenderSelectAction(container.SelectAction, border));
}
// Revert context's value to that of outside the Container
context.RenderArgs = parentRenderArgs;
return(border);
}
public static FrameworkElement Render(AdaptiveColumn column, AdaptiveRenderContext context)
{
var uiContainer = new Grid();
uiContainer.Style = context.GetStyle("Adaptive.Column");
uiContainer.SetBackgroundSource(column.BackgroundImage, context);
// Keep track of ContainerStyle.ForegroundColors before Container is rendered
var outerStyle = context.ForegroundColors;
var parentContainerStyle = context.ParentStyle;
if (column.Style != null)
{
AdaptiveContainerRenderer.ApplyPadding(uiContainer, column, parentContainerStyle, context);
// Apply background color
ContainerStyleConfig containerStyle = context.Config.ContainerStyles.GetContainerStyleConfig(column.Style);
uiContainer.SetBackgroundColor(containerStyle.BackgroundColor, context);
context.ForegroundColors = containerStyle.ForegroundColors;
}
AdaptiveContainerStyle containerContainerStyle = column.Style ?? parentContainerStyle;
if (containerContainerStyle == AdaptiveContainerStyle.None)
{
containerContainerStyle = parentContainerStyle;
}
context.ParentStyle = containerContainerStyle;
AdaptiveContainerRenderer.AddContainerElements(uiContainer, column.Items, context);
if (column.SelectAction != null)
{
return(context.RenderSelectAction(column.SelectAction, uiContainer));
}
switch (column.VerticalContentAlignment)
{
case AdaptiveVerticalContentAlignment.Center:
uiContainer.VerticalAlignment = VerticalAlignment.Center;
break;
case AdaptiveVerticalContentAlignment.Bottom:
uiContainer.VerticalAlignment = VerticalAlignment.Bottom;
break;
case AdaptiveVerticalContentAlignment.Top:
default:
break;
}
if (!column.IsVisible)
{
uiContainer.Visibility = Visibility.Collapsed;
}
// Revert context's value to that of outside the Column
context.ForegroundColors = outerStyle;
context.ParentStyle = parentContainerStyle;
return(uiContainer);
}