void RenderDescription(RenderContext context)
{
var descBind = GetBinding(nameof(Description));
if (descBind == null && Description == null)
{
return;
}
var span = new TagBuilder("span", "description");
if (descBind != null)
{
span.MergeAttribute("v-text", descBind.GetPathFormat(context));
}
span.RenderStart(context);
if (Description is UIElementBase descUi)
{
descUi.RenderElement(context);
}
else if (Description != null)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Description.ToString()));
}
span.RenderEnd(context);
}
void RenderFooter(RenderContext context)
{
if (!HasFooter)
{
return;
}
var f = new TagBuilder("div", "card-footer");
f.RenderStart(context);
var fb = GetBinding(nameof(Footer));
if (fb != null)
{
var s = new TagBuilder("span");
s.MergeAttribute(":text", fb.GetPathFormat(context));
s.Render(context);
}
else if (Footer is UIElementBase fUiElem)
{
fUiElem.RenderElement(context);
}
else if (Footer is String fStr)
{
context.Writer.Write(context.LocalizeCheckApostrophe(fStr));
}
f.RenderEnd(context);
}
protected virtual void RenderHelp(RenderContext context)
{
if (!HasHelp)
{
return;
}
//<a class="btn-help"><i class="ico ico-help"></i>Справка</a>
var ha = new TagBuilder("a", "btn-help");
// TODO: Help path
var hbind = GetBinding(nameof(HelpUrl));
if (hbind != null)
{
String hpath = hbind.GetPathFormat(context);
ha.MergeAttribute("@click.prevent", $"$showHelp({hpath})");
ha.MergeAttribute(":href", $"$helpHref({hpath})");
}
else if (!String.IsNullOrEmpty(HelpUrl))
{
ha.MergeAttribute("@click.prevent", $"$showHelp('{HelpUrl}')");
ha.MergeAttribute(":href", $"$helpHref('{HelpUrl}')");
}
ha.RenderStart(context);
new TagBuilder("i", "ico ico-help")
.Render(context);
context.Writer.Write(context.Localize("@[Help]"));
ha.RenderEnd(context);
new TagBuilder("div", "aligner").Render(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
GenerateSheet(context);
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.AddCssClassBoolNo(Border, "border");
sheet.AddCssClassBool(Compact, "compact");
sheet.AddCssClassBool(FitWidth, "fit-width");
if (Width != null)
{
sheet.MergeStyle("width", Width.Value);
}
sheet.RenderStart(context);
RenderColumns(context);
RenderBody(context);
RenderColumnsShadow(context);
RenderHeader(context);
RenderFooter(context);
sheet.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var isBind = GetBinding(nameof(ItemsSource));
if (isBind == null)
{
return;
}
var div = new TagBuilder("template", null, IsInGrid);
onRender?.Invoke(div);
MergeAttributes(div, context);
div.MergeAttribute("v-for", $"(elem, elemIndex) in {isBind.GetPath(context)}");
div.RenderStart(context);
if (Content != null)
{
using (new ScopeContext(context, "elem"))
{
Content.RenderElement(context, (tag) =>
{
onRender?.Invoke(tag);
tag.MergeAttribute(":key", "elemIndex");
});
}
}
div.RenderEnd(context);
}
void RenderPaneTemplate(RenderContext context)
{
if (ItemsPanel == null)
{
return;
}
if (!(ItemsPanel is DataGrid))
{
throw new XamlException("Only DataGrid panel is supported");
}
var dg = ItemsPanel as DataGrid;
var tml = new TagBuilder("template");
tml.MergeAttribute("slot", "pane");
tml.MergeAttribute("slot-scope", "root");
tml.RenderStart(context);
using (var ctx = new ScopeContext(context, "itm"))
{
ItemsPanel.RenderElement(context, (tag) =>
{
tag.MergeAttribute(":is-item-active", "root.isItemActive");
tag.MergeAttribute(":hit-item", "root.hit");
tag.MergeAttribute(":items-source", "root.items");
if (ListSize != null && !ListSize.Height.IsEmpty && dg.FixedHeader)
{
// for fixed headers only
tag.MergeStyle("height", ListSize.Height.ToString());
tag.MergeStyle("max-height", ListSize.Height.ToString());
}
});
}
tml.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
if (StickyHeaders)
{
var outTag = new TagBuilder("div", "a2-sticky-container", IsInGrid);
MergeAttributes(outTag, context, MergeAttrMode.Visibility);
if (Height != null)
{
outTag.MergeStyle("height", Height.Value);
}
outTag.RenderStart(context);
RenderTable(context, "a2-table sticky", false, false, null);
outTag.RenderEnd(context);
var sb = new TagBuilder("div", "a2-sticky-bottom");
if (Width != null)
{
sb.MergeStyle("width", Width.Value);
}
sb.Render(context);
}
else
{
RenderTable(context, "a2-table", IsInGrid, true, onRender);
}
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var input = new TagBuilder("static", null, IsInGrid);
onRender?.Invoke(input);
MergeAttributes(input, context);
MergeValue(input, context); // item, prop for validator
MergeAlign(input, context, Align);
var valBind = GetBinding(nameof(Value));
if (valBind != null)
{
input.MergeAttribute(":text", valBind.GetPathFormat(context)); // formatted
if (valBind.NegativeRed)
{
input.MergeAttribute(":class", $"$getNegativeRedClass({valBind.GetPath(context)})");
}
}
input.RenderStart(context);
RenderAddOns(context);
input.RenderEnd(context);
}
public 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);
if (Border != ToolbarBorderStyle.None)
{
tb.AddCssClass("tb-border-" + Border.ToString().ToKebabCase());
}
tb.RenderStart(context);
RenderChildren(context);
tb.RenderEnd(context);
}
protected virtual void RenderHelp(RenderContext context)
{
if (!HasHelp)
{
return;
}
var ha = new TagBuilder("a", "btn-help");
ha.MergeAttribute("rel", "help");
ha.MergeAttribute("title", context.Localize("@[Help]"));
var hbind = GetBinding(nameof(HelpUrl));
if (hbind != null)
{
String hpath = hbind.GetPathFormat(context);
ha.MergeAttribute("@click.stop.prevent", $"$showHelp({hpath})");
ha.MergeAttribute(":href", $"$helpHref({hpath})");
}
else if (!String.IsNullOrEmpty(HelpUrl))
{
ha.MergeAttribute("@click.stop.prevent", $"$showHelp('{HelpUrl}')");
ha.MergeAttribute(":href", $"$helpHref('{HelpUrl}')");
}
ha.RenderStart(context);
new TagBuilder("i", "ico ico-help")
.Render(context);
//context.Writer.Write(context.Localize("@[Help]"));
ha.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var grid = new TagBuilder("div", "grid", IsInGrid);
onRender?.Invoke(grid);
MergeAttributes(grid, context);
if (Height != null)
{
grid.MergeStyle("height", Height.Value);
}
if (_rows != null)
{
grid.MergeStyle("grid-template-rows", _rows.ToAttribute());
}
if (_columns != null)
{
grid.MergeStyle("grid-template-columns", _columns.ToAttribute());
}
grid.RenderStart(context);
RenderChildren(context);
grid.RenderEnd(context);
}
public 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()}");
}
if (MinWidth != null)
{
list.MergeStyleUnit("min-width", MinWidth.Value);
}
list.RenderStart(context);
RenderChildren(context);
list.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var po = new TagBuilder("popover", "a2-inline", IsInGrid);
MergeAttributes(po, context, MergeAttrMode.All);
po.AddCssClass("po-" + Placement.ToString().ToKebabCase());
if (Background != PopoverBackgroundStyle.Default)
{
po.AddCssClass("po-" + Background.ToString().ToKebabCase());
}
if (Icon != Icon.NoIcon)
{
po.MergeAttribute("icon", Icon.ToString().ToKebabCase());
}
MergeBindingAttributeString(po, context, "content", nameof(Text), Text);
var urlBind = GetBinding(nameof(Url));
if (urlBind != null)
{
po.MergeAttribute(":url", urlBind.GetPathFormat(context));
}
else if (!String.IsNullOrEmpty(Url))
{
po.MergeAttribute("url", Url);
}
if (Width != null)
{
po.MergeAttribute("width", Width.Value);
}
if (Top != null)
{
po.MergeAttribute("top", Top.Value);
}
po.RenderStart(context);
var cntBind = GetBinding(nameof(Content));
if (cntBind != null)
{
var cont = new TagBuilder("span");
cont.MergeAttribute("v-text", cntBind.GetPathFormat(context));
cont.Render(context);
}
else if (Content is UIElementBase)
{
(Content as UIElementBase).RenderElement(context);
}
else if (Content != null)
{
context.Writer.Write(context.Localize(Content.ToString()));
}
po.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var option = new TagBuilder("option");
MergeAttributes(option, context, MergeAttrMode.Visibility);
if (Value != null)
{
if (Value is IJavaScriptSource)
{
var jsValue = (Value as IJavaScriptSource).GetJsValue(context);
option.MergeAttribute(":value", jsValue);
}
else
{
option.MergeAttribute("value", Value.ToString());
}
}
else
{
option.MergeAttribute(":value", "null"); // JS null value
}
option.RenderStart(context);
if (Content != null)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Content));
}
option.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var table = new TagBuilder("table", "prop-grid", IsInGrid);
onRender?.Invoke(table);
table.AddCssClassBool(Compact, "compact");
SetStyle(table);
table.AddCssClassBool(Striped, "striped");
table.AddCssClassBool(NoWrapName, "no-wrap-name");
if (!String.IsNullOrEmpty(TestId) && context.IsDebugConfiguration)
{
table.MergeAttribute("test-id", TestId);
}
MergeAttributes(table, context);
if (GridLines != GridLinesVisibility.None)
{
table.AddCssClass($"grid-{GridLines.ToString().ToLowerInvariant()}");
}
table.RenderStart(context);
RenderColumns(context);
RenderBody(context);
table.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (CheckDisabledModel(context))
{
return;
}
var tagName = Multiline ? "a2-textarea" : "textbox";
var input = new TagBuilder(tagName, null, IsInGrid);
onRender?.Invoke(input);
MergeAttributes(input, context);
MergeDisabled(input, context);
if (Multiline)
{
MergeAttributeInt32(input, context, "rows", nameof(Rows), Rows);
}
if (Password)
{
input.MergeAttribute(":password", "true");
}
if (AutoSize)
{
input.MergeAttribute(":auto-size", "true");
}
if (UpdateTrigger != UpdateTrigger.Default)
{
input.MergeAttribute("update-trigger", UpdateTrigger.ToString().ToLowerInvariant());
}
MergeAlign(input, context, Align);
MergeBindingAttributeString(input, context, "placeholder", nameof(Placeholder), Placeholder);
MergeValue(input, context);
input.RenderStart(context);
RenderAddOns(context);
input.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var span = new TagBuilder("span", null, IsInGrid);
onRender?.Invoke(span);
MergeAttributes(span, context);
var cbind = GetBinding(nameof(Content));
if (cbind != null)
{
span.MergeAttribute("v-html", $"$sanitize({cbind.GetPathFormat(context)})");
}
span.RenderStart(context);
if (Content != null && Content is String)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Content.ToString()));
}
span.RenderEnd(context);
}
void RenderHeader(RenderContext context)
{
if (!HasHeader)
{
return;
}
var header = new TagBuilder("div", "panel-header-slot");
header.MergeAttribute("slot", "header");
header.RenderStart(context);
RenderIcon(context, Icon);
var hBind = GetBinding(nameof(Header));
if (hBind != null)
{
var span = new TagBuilder("span");
span.MergeAttribute("v-text", hBind.GetPathFormat(context));
span.Render(context);
}
else if (Header is UIElementBase)
{
(Header as UIElementBase).RenderElement(context);
}
else if (Header != null)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Header.ToString()));
}
RenderHint(context);
header.RenderEnd(context);
}
void RenderBody(RenderContext context)
{
var tbody = new TagBuilder("tbody").RenderStart(context);
var isBind = GetBinding(nameof(ItemsSource));
if (isBind != null)
{
if (Children.Count != 1)
{
throw new XamlException("For a table with an items source, only one child element is allowed");
}
String path = isBind.GetPath(context); // before scope!
using (new ScopeContext(context, "prop"))
{
Children[0].RenderElement(context, (tag) =>
{
tag.MergeAttribute("v-for", $"(prop, propIndex) in {path}");
tag.MergeAttribute(":key", "propIndex");
});
}
}
else
{
Children.Render(context);
}
tbody.RenderEnd(context);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var section = new TagBuilder("a2-sheet-section-tree");
var isBind = GetBinding(nameof(ItemsSource));
if (isBind != null)
{
String path = isBind.GetPath(context);
var(Path, Prop) = SplitToPathProp(path);
section.MergeAttribute(":items-source", Path);
section.MergeAttribute("prop-name", Prop);
}
section.RenderStart(context);
var tml = new TagBuilder("template");
tml.MergeAttribute("slot-scope", "row");
tml.RenderStart(context);
using (var scope = new ScopeContext(context, "row.item"))
{
foreach (var r in Children)
{
r.RenderElement(context, (tr) => tr.MergeAttribute(":class", "row.rowCssClass()"));
}
}
tml.RenderEnd(context);
section.RenderEnd(context);
}
void RenderColumnsShadow(RenderContext context)
{
// for export to excel column widths
if (_columns == null)
{
return;
}
var cs = new TagBuilder("template");
cs.MergeAttribute("slot", "col-shadow");
cs.RenderStart(context);
var tb = new TagBuilder("tbody", "col-shadow");
tb.RenderStart(context);
var tr = new TagBuilder("tr");
tr.RenderStart(context);
foreach (var c in _columns)
{
c.RenderShadow(context);
}
tr.RenderEnd(context);
tb.RenderEnd(context);
cs.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var panel = new TagBuilder("div", "a2-tab-bar", IsInGrid);
onRender?.Invoke(panel);
MergeAttributes(panel, context);
if (DropShadow != ShadowStyle.None)
{
panel.AddCssClass("drop-shadow");
panel.AddCssClass(DropShadow.ToString().ToLowerInvariant());
}
if (Style != TabBarStyle.Default)
{
panel.AddCssClass($"tab-bar-{Style.ToString().ToKebabCase()}");
}
panel.RenderStart(context);
RenderButtons(context);
if (HasDescription)
{
RenderDesription(context);
}
panel.RenderEnd(context);
}
internal 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);
MergeAttributes(wrap, context, MergeAttrMode.Visibility);
wrap.RenderStart(context);
RenderHyperlink(context, false, null, true);
DropDown.RenderElement(context);
wrap.RenderEnd(context);
}
else
{
RenderHyperlink(context, IsInGrid, onRender, false);
}
}
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");
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 RenderHeader(RenderContext context)
{
if (!HasHeader)
{
return;
}
var h = new TagBuilder("div", "card-header");
h.RenderStart(context);
var hb = GetBinding(nameof(Header));
if (hb != null)
{
var s = new TagBuilder("span");
s.MergeAttribute(":text", hb.GetPathFormat(context));
s.Render(context);
}
else if (Header is UIElementBase hUiElem)
{
hUiElem.RenderElement(context);
}
else if (Header is String hStr)
{
context.Writer.Write(context.LocalizeCheckApostrophe(hStr));
}
RenderHint(context);
h.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var label = new TagBuilder("div", "a2-label", IsInGrid);
onRender?.Invoke(label);
var contBind = GetBinding(nameof(Content));
if (contBind != null)
{
label.MergeAttribute("v-text", contBind.GetPathFormat(context));
}
MergeAttributes(label, context);
if (Align != TextAlign.Left)
{
label.AddCssClass("text-" + Align.ToString().ToLowerInvariant());
}
label.AddCssClassBool(Required, "required");
AddSize(label);
label.RenderStart(context);
if (Content != null)
{
context.Writer.Write(context.LocalizeCheckApostrophe(Content.ToString()));
}
label.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.Localize(Title));
}
span.Render(context);
}
var close = new TagBuilder("button", "btnclose");
close.MergeAttribute("@click.prevent", "$modalClose(false)");
close.SetInnerText("✕");
close.Render(context);
header.RenderEnd(context);
}
internal override void RenderChildren(RenderContext context, Action <TagBuilder> onRenderStatic = null)
{
foreach (var ch in Children)
{
ch.IsInGrid = true;
if (ch is GridGroup gg)
{
var grpTemplate = new TagBuilder("template");
gg.MergeAttributes(grpTemplate, context, MergeAttrMode.Visibility);
grpTemplate.RenderStart(context);
foreach (var gc in gg.Children)
{
gc.IsInGrid = true;
using (context.GridContext(GetRow(gc), GetCol(gc), GetRowSpan(gc), GetColSpan(gc), GetVAlign(gc)))
{
gc.RenderElement(context);
}
}
grpTemplate.RenderEnd(context);
}
else
{
using (context.GridContext(GetRow(ch), GetCol(ch), GetRowSpan(ch), GetColSpan(ch), GetVAlign(ch)))
{
ch.RenderElement(context);
}
}
}
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var mi = new TagBuilder("button", "dropdown-item");
if (HasIcon)
{
MergeAttributes(mi, context, MergeAttrMode.NoContent);
MergeDisabled(mi, context, nativeControl: true);
mi.MergeAttribute("v-disable", String.Empty);
mi.RenderStart(context);
RenderIcon(context, Icon);
var span = new TagBuilder("span");
MergeAttributesBase(span, context, MergeAttrMode.Content); // skip command!
span.RenderStart(context);
RenderContent(context);
span.RenderEnd(context);
mi.RenderEnd(context);
}
else
{
MergeAttributes(mi, context, MergeAttrMode.All);
MergeDisabled(mi, context, nativeControl: true);
mi.MergeAttribute("v-disable", String.Empty);
mi.RenderStart(context);
RenderContent(context);
mi.RenderEnd(context);
}
}
internal void RenderMe(RenderContext context, String valuePath)
{
if (SkipRender(context))
{
return;
}
var btn = new TagBuilder("a", "a2-tab-button");
var activeValueArg = $"'{ActiveValue}'";
var avBind = GetBinding(nameof(ActiveValue));
if (avBind != null)
{
activeValueArg = avBind.GetPathFormat(context);
}
MergeAttributes(btn, context);
if (valuePath != null)
{
btn.MergeAttribute(":class", $"{{'active': {activeValueArg} == {valuePath}}}");
btn.MergeAttribute("@click.prevent", $"{valuePath}={activeValueArg}");
}
btn.RenderStart(context);
RenderContent(context);
RenderDescription(context);
btn.RenderEnd(context);
}
