internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var list = new TagBuilder("ul", "flex-list", IsInGrid);
MergeAttributes(list, context);
if (AlignItems != AlignItems.Default)
{
list.AddCssClass("align-" + AlignItems.ToString().ToLowerInvariant());
}
list.AddCssClass(Orientation.ToString().ToLowerInvariant());
if (BorderStyle != BorderStyle.None)
{
list.AddCssClass($"border-{BorderStyle.ToString().ToKebabCase()}");
}
list.RenderStart(context);
RenderChildren(context);
list.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var menu = new TagBuilder("div", "dropdown-menu menu");
menu.MergeAttribute("role", "menu");
MergeAttributes(menu, context);
if (Direction != DropDownDirection.Default)
{
menu.AddCssClass(Direction.ToString().ToKebabCase());
}
if (Background != BackgroundStyle.Default)
{
menu.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
menu.RenderStart(context);
RenderChildren(context);
menu.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tb = new TagBuilder("div", "toolbar", IsInGrid);
onRender?.Invoke(tb);
if (Style != ToolbarStyle.Default)
{
tb.AddCssClass(Style.ToString().ToKebabCase());
}
if (AlignItems != AlignItems.Default)
{
tb.AddCssClass("align-" + AlignItems.ToString().ToLowerInvariant());
}
MergeAttributes(tb, context);
tb.RenderStart(context);
RenderChildren(context);
tb.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var panel = new TagBuilder("div", "a2-state-card", IsInGrid);
onRender?.Invoke(panel);
MergeAttributes(panel, context);
if (DropShadow != ShadowStyle.None)
{
panel.AddCssClass("drop-shadow");
panel.AddCssClass(DropShadow.ToString().ToLowerInvariant());
}
if (Style != CardStyle.Default)
{
panel.AddCssClass("a2-state-card-styled");
panel.AddCssClass("a2-state-card-" + Style.ToString().ToLowerInvariant());
}
panel.RenderStart(context);
if (HasHeader)
{
RenderHeader(context);
}
if (HasText)
{
RenderText(context);
}
if (HasFooter)
{
RenderFooter(context);
}
RenderIcon(context, Icon, "a2-card-icon");
RenderContent(context);
panel.RenderEnd(context);
}
void RenderHeader(RenderContext context)
{
var header = new TagBuilder("div", "modal-header");
header.MergeAttribute("v-drag-window", String.Empty);
header.RenderStart(context);
var hdr = GetBinding(nameof(Title));
if ((hdr != null) || (Title != null))
{
var span = new TagBuilder("span");
if (hdr != null)
{
span.MergeAttribute("v-text", hdr.GetPathFormat(context));
}
else if (Title != null)
{
span.SetInnerText(context.LocalizeCheckApostrophe(Title));
}
span.Render(context);
}
if (TitleInfo != null)
{
var span = new TagBuilder("span", "modal-title-info");
span.RenderStart(context);
TitleInfo.RenderElement(context, null);
span.RenderEnd(context);
}
var close = new TagBuilder("button", "btnclose");
close.MergeAttribute("@click.prevent", "$modalClose(false)");
close.SetInnerText("✕");
close.Render(context);
RenderHelp(context);
header.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var panel = new TagBuilder("div", "full-height-panel", IsInGrid);
panel.MergeAttribute("key", Guid.NewGuid().ToString()); // disable vue reusing
MergeAttributes(panel, context);
if (MinWidth != null)
{
panel.MergeStyleUnit("min-width", MinWidth.Value);
}
if (AlignItems != AlignItems.Default)
{
panel.AddCssClass("align-" + AlignItems.ToString().ToLowerInvariant());
}
panel.MergeStyle("grid-template-rows", GetRows());
panel.RenderStart(context);
RenderChildren(context);
panel.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tag = new TagBuilder("div", "a2-popup");
tag.MergeAttribute("ondblclick", "event.stopPropagation()");
tag.MergeAttribute("id", context.RootId);
MergeAttributes(tag, context, MergeAttrMode.Margin);
if (Width != null)
{
tag.MergeStyle("width", Width.ToString());
}
if (MinWidth != null)
{
tag.MergeStyle("min-width", MinWidth.ToString());
}
tag.RenderStart(context);
RenderChildren(context);
tag.RenderEnd(context);
}
void RenderTitle(RenderContext context)
{
var titleBind = GetBinding(nameof(Title));
if (titleBind != null || Title != null)
{
var title = new TagBuilder("legend");
title.RenderStart(context);
var span = new TagBuilder("span");
if (titleBind != null)
{
span.MergeAttribute("v-text", titleBind.GetPathFormat(context));
}
span.RenderStart(context);
if (Title != null)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Title));
}
span.RenderEnd(context);
RenderHint(context);
title.RenderEnd(context);
}
}
void RenderHeader(RenderContext context)
{
var hBind = GetBinding(nameof(Header));
if (hBind != null || Header != null)
{
var ht = new TagBuilder("template");
ht.MergeAttribute("slot", "title");
ht.RenderStart(context);
var tag = new TagBuilder("div", "pane-header");
if (hBind != null)
{
tag.MergeAttribute("v-text", hBind.GetPath(context));
}
tag.RenderStart(context);
if (Header != null)
{
RenderContent(context, Header);
}
tag.RenderEnd(context);
ht.RenderEnd(context);
}
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (CheckDisabledModel(context))
{
return;
}
var input = new TagBuilder("a2-date-picker", null, IsInGrid);
onRender?.Invoke(input);
MergeAttributes(input, context);
MergeDisabled(input, context);
MergeAlign(input, context, Align);
SetSize(input, nameof(DatePicker));
if (Placement != DropDownPlacement.BottomLeft)
{
input.AddCssClass("drop-" + Placement.ToString().ToKebabCase());
}
MergeValue(input, context);
input.MergeAttribute("view", View.ToString().ToLowerInvariant());
input.RenderStart(context);
RenderAddOns(context);
input.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var page = new TagBuilder("div", "page partial");
page.MergeAttribute("id", context.RootId);
MergeAttributes(page, context, MergeAttrMode.Margin);
if (Background != BackgroundStyle.Default)
{
page.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
page.AddCssClass(CssClass);
page.RenderStart(context);
RenderChildren(context);
RenderContextMenus();
RenderAccelCommands(context);
page.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var sheet = new TagBuilder("a2-sheet", null, IsInGrid);
onRender?.Invoke(sheet);
MergeAttributes(sheet, context);
if (GridLines != GridLinesVisibility.None)
{
sheet.AddCssClass($"grid-{GridLines.ToString().ToLowerInvariant()}");
}
sheet.AddCssClassBool(Hover, "hover");
sheet.AddCssClassBool(Striped, "striped");
sheet.RenderStart(context);
RenderColumns(context);
RenderHeader(context);
RenderBody(context);
RenderFooter(context);
sheet.RenderEnd(context);
}
void RenderDesription(RenderContext context)
{
new Separator().RenderElement(context);
var dBind = GetBinding(nameof(Description));
var wrap = new TagBuilder(null, "a2-tab-description");
wrap.RenderStart(context);
if (dBind != null)
{
var span = new TagBuilder("span");
span.MergeAttribute("v-text", dBind.GetPathFormat(context));
span.Render(context);
}
else if (Description is UIElementBase uiDescr)
{
uiDescr.RenderElement(context);
}
else if (Description != null)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Description.ToString()));
}
wrap.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var div = new TagBuilder("div", "stack-panel", IsInGrid);
onRender?.Invoke(div);
MergeAttributes(div, context);
div.AddCssClass(Orientation.ToString().ToLowerInvariant());
if (AlignItems != AlignItems.Default)
{
div.AddCssClass("align-" + AlignItems.ToString().ToLowerInvariant());
}
if (JustifyItems != JustifyItems.Default)
{
div.AddCssClass("justify-" + JustifyItems.ToString().ToKebabCase());
}
div.RenderStart(context);
RenderChildren(context);
div.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var code = new TagBuilder(Multiline ? "pre" : "code", null, IsInGrid);
onRender?.Invoke(code);
if (Multiline)
{
code.AddCssClass("pre-scrollable");
}
if (Height != null)
{
code.MergeStyle("max-height", Height.Value);
}
code.AddCssClass("a2-code");
MergeAttributes(code, context);
code.RenderStart(context);
RenderContent(context);
code.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
var expr = GetBinding(nameof(Expression));
if (expr == null)
{
new XamlException("Binding 'Expression' must be a Bind");
}
for (var i = 0; i < Cases.Count; i++)
{
var itm = Cases[i];
var t = new TagBuilder("template");
var ifKey = (i == 0) ? "v-if " : "v-else-if";
if (itm is Else)
{
ifKey = "v-else";
}
t.MergeAttribute("v-if", $"({expr.GetPathFormat(context)}) === '{itm.Value}'");
t.RenderStart(context);
itm.RenderElement(context);
t.RenderEnd(context);
}
}
internal void RenderMe(RenderContext context, String valuePath)
{
if (SkipRender(context))
{
return;
}
var btn = new TagBuilder("a", "a2-tab-button");
var activeValueArg = GetActiveValueArg(context);
MergeAttributes(btn, context);
if (valuePath != null)
{
btn.MergeAttribute(":class", $"{{'active': {activeValueArg} == {valuePath}}}");
btn.MergeAttribute("@click.stop.prevent", $"$closeAllPopups(); {valuePath}={activeValueArg}");
}
btn.RenderStart(context);
RenderContent(context);
RenderDescription(context);
btn.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var sect = new TagBuilder("a2-sheet-section");
MergeAttributes(sect, context);
sect.RenderStart(context);
var tml = new TagBuilder("template");
var isBind = GetBinding(nameof(ItemsSource));
if (isBind != null)
{
tml.MergeAttribute("v-for", $"(item, itemIndex) of {isBind.GetPath(context)}");
tml.RenderStart(context);
using (var scope = new ScopeContext(context, "item", isBind.Path))
{
foreach (var r in Children)
{
r.RenderElement(context);
}
}
tml.RenderEnd(context);
}
else
{
tml.RenderStart(context);
foreach (var r in Children)
{
r.RenderElement(context);
}
tml.RenderEnd(context);
}
sect.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tag = new TagBuilder("a2-taskpad", null, IsInGrid);
onRender?.Invoke(tag);
MergeAttributes(tag, context);
MergeBindingAttributeString(tag, context, "title", nameof(Title), Title);
tag.AddCssClassBool(Overflow, "overflow");
tag.MergeStyle("grid-column", Position == TaskpadPosition.Left ? "1" : "2");
if (Background != BackgroundStyle.Default)
{
tag.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
tag.AddCssClassBoolNo(Collapsible, "collapsible");
tag.MergeAttribute("position", Position.ToString().ToLowerInvariant());
var colBind = GetBinding(nameof(Collapsed));
if (colBind != null)
{
tag.MergeAttribute(":initial-collapsed", colBind.GetPath(context));
}
else
{
tag.MergeAttribute(":initial-collapsed", Collapsed.ToString().ToLowerInvariant());
}
tag.RenderStart(context);
RenderChildren(context);
tag.RenderEnd(context);
}
void RenderBody(RenderContext context, Boolean dyna)
{
if (Content.Count == 0)
{
return;
}
var tml = new TagBuilder("template");
if (dyna)
{
tml.MergeAttribute("slot", "items");
tml.MergeAttribute("slot-scope", "listItem");
tml.RenderStart(context);
using (new ScopeContext(context, "listItem.item"))
{
foreach (var c in Content)
{
c.RenderElement(context);
}
}
tml.RenderEnd(context);
}
else
{
tml.RenderStart(context);
foreach (var c in Content)
{
var li = new TagBuilder("li", "a2-list-item");
li.MergeAttribute("tabindex", "1");
//li.MergeAttribute("@click.prevent", "$exec('test')");
li.RenderStart(context);
c.RenderElement(context);
li.RenderEnd(context);
}
tml.RenderEnd(context);
}
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var div = new TagBuilder("a2-include");
MergeAttributes(div, context);
var src = GetBinding(nameof(Source));
if (src != null)
{
div.MergeAttribute(":source", src.GetPathFormat(context));
}
else if (Source != null)
{
div.MergeAttribute("source", Source);
}
else
{
throw new XamlException("Partial. Source must be specified");
}
var arg = GetBinding(nameof(Argument));
if (arg != null)
{
div.MergeAttribute(":arg", arg.GetPathFormat(context));
}
else if (Argument != null)
{
div.MergeAttribute("arg", Argument.ToString());
}
div.AddCssClassBool(FullHeight, "full-height");
div.RenderStart(context);
div.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (String.IsNullOrEmpty(Id))
{
throw new XamlException("Id is required for Inline Dialog");
}
var dlg = new TagBuilder("a2-inline-dialog");
onRender?.Invoke(dlg);
dlg.AddCssClassBoolNo(UserSelect, "user-select");
dlg.MergeAttribute("dialog-id", Id);
if (NoClose)
{
dlg.MergeAttribute(":no-close", "true");
}
MergeBindingAttributeString(dlg, context, "dialog-title", nameof(Title), Title);
if (Width != null)
{
dlg.MergeAttribute("width", Width.Value);
}
dlg.RenderStart(context);
var m = new TagBuilder("div", "modal");
m.RenderStart(context);
RenderHeader(context);
var mc = new TagBuilder("div", "modal-content");
mc.RenderStart(context);
RenderChildren(context);
mc.RenderEnd(context);
RenderFooter(context);
m.RenderEnd(context);
dlg.RenderEnd(context);
}
void RenderBody(RenderContext context, Boolean dyna)
{
if (Content.Count == 0)
{
return;
}
var tml = new TagBuilder("template");
if (dyna)
{
tml.MergeAttribute("slot", "items");
tml.MergeAttribute("slot-scope", "listItem");
tml.RenderStart(context);
using (new ScopeContext(context, "listItem.item", null))
{
foreach (var c in Content)
{
c.RenderElement(context);
}
}
tml.RenderEnd(context);
}
else
{
tml.RenderStart(context);
foreach (var c in Content)
{
var li = new TagBuilder("li", "a2-list-item");
c.MergeBindingAttributeBool(li, context, "v-if", "If", c.If);
li.MergeAttribute("tabindex", "1");
li.RenderStart(context);
c.RenderElement(context);
li.RenderEnd(context);
}
tml.RenderEnd(context);
}
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tag = new TagBuilder("a2-period-picker", null, IsInGrid);
onRender?.Invoke(tag);
if (Style != PeriodPickerStyle.Default)
{
tag.AddCssClass($"pp-{Style.ToString().ToLowerInvariant()}");
}
if (Size != ControlSize.Default)
{
tag.AddCssClass($"pp-{Size.ToString().ToLowerInvariant()}");
}
if (ShowAllData != null)
{
tag.MergeAttribute(":show-all", ShowAllData.ToString().ToLowerInvariant());
}
if (Display != DisplayMode.Date)
{
tag.MergeAttribute("display", Display.ToString().ToLowerInvariant());
}
MergeAttributes(tag, context);
MergeDisabled(tag, context);
MergeAlign(tag, context, Align);
MergeValue(tag, context);
if (Placement != DatePickerDropDownPlacement.BottomLeft)
{
tag.AddCssClass("drop-" + Placement.ToString().ToKebabCase());
}
tag.RenderStart(context);
RenderAddOns(context);
tag.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var isBind = GetBinding(nameof(ItemsSource));
if (isBind == null)
{
throw new XamlException("ItemsSource must be specified for Lazy component");
}
var tag = new TagBuilder("div", null, IsInGrid);
onRender?.Invoke(tag);
MergeAttributes(tag, context);
tag.MergeAttribute("v-lazy", isBind.GetPath(context));
tag.RenderStart(context);
RenderContent(context, Content);
tag.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tag = new TagBuilder("span", null, IsInGrid);
MergeAttributes(tag, context);
tag.AddCssClassBool(Block, "block");
if (Align != TextAlign.Left)
{
tag.AddCssClass("text-" + Align.ToString().ToLowerInvariant());
}
if (Size != TextSize.Normal)
{
tag.AddCssClass("text-" + Size.ToString().ToLowerInvariant());
}
else
{
tag.AddCssClassBool(Small, "text-small");
tag.AddCssClassBool(Big, "text-big");
}
tag.AddCssClassBool(Gray, "text-gray");
if (Color != TextColor.Default)
{
tag.AddCssClass("text-color-" + Color.ToString().ToKebabCase());
}
else
{
tag.AddCssClassBool(Gray, "text-gray");
}
tag.RenderStart(context);
Inlines.Render(context);
tag.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tag = new TagBuilder("a2-taskpad", null, IsInGrid);
onRender?.Invoke(tag);
MergeAttributes(tag, context);
MergeBindingAttributeString(tag, context, "title", nameof(Title), Title);
tag.AddCssClassBool(Overflow, "overflow");
if (Background != BackgroundStyle.Default)
{
tag.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
tag.AddCssClassBoolNo(Collapsible, "collapsible");
tag.RenderStart(context);
RenderChildren(context);
tag.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var block = new TagBuilder("div", "empty-panel");
onRender?.Invoke(block);
MergeAttributes(block, context);
block.RenderStart(context);
RenderIcon(context, Icon);
var cont = new TagBuilder("div", "empty-panel-content");
cont.RenderStart(context);
RenderContent(context);
cont.RenderEnd(context);
block.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var row = new TagBuilder("tr");
onRender?.Invoke(row);
MergeAttributes(row, context);
var markBind = GetBinding(nameof(Mark));
if (markBind != null)
{
if (GetBinding(nameof(Bold)) != null)
{
throw new XamlException("The Bold and Mark bindings cannot be used at the same time");
}
row.MergeAttribute(":class", markBind.GetPathFormat(context));
}
if (Align != TextAlign.Left)
{
row.AddCssClass("text-" + Align.ToString().ToLowerInvariant());
}
if (VAlign != VerticalAlign.Default)
{
row.AddCssClass($"valign-{VAlign.ToString().ToLowerInvariant()}");
}
row.RenderStart(context);
RenderCells(context);
row.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
Boolean bHasDropDown = DropDown != null;
if (bHasDropDown)
{
DropDownDirection?dir = (DropDown as DropDownMenu)?.Direction;
Boolean bDropUp = (dir == DropDownDirection.UpLeft) || (dir == DropDownDirection.UpRight);
var wrap = new TagBuilder("div", "dropdown hlink-dd-wrapper", IsInGrid)
.AddCssClass(bDropUp ? "dir-up" : "dir-down")
.MergeAttribute("v-dropdown", String.Empty);
onRender?.Invoke(wrap);
if (!Block)
{
wrap.AddCssClass("a2-inline");
}
if (Style != HyperlinkStyle.Default)
{
wrap.AddCssClass(Style.ToString().ToLowerInvariant());
}
MergeAttributes(wrap, context, MergeAttrMode.Visibility);
wrap.RenderStart(context);
var hasAddOn = wrap.HasClass("add-on");
RenderHyperlink(context, false, null, inside: true, addOn: hasAddOn);
DropDown.RenderElement(context);
wrap.RenderEnd(context);
}
else
{
RenderHyperlink(context, IsInGrid, onRender, false);
}
}
