public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
//<a2-pager :source = "Parent.pager" />
var pager = new TagBuilder("a2-pager", null, IsInGrid);
if (Style != PagerStyle.Default)
{
pager.AddCssClass(Style.ToString().ToLowerInvariant());
}
pager.AddCssClass(CssClass);
MergeAttributes(pager, context, MergeAttrMode.Margin);
onRender?.Invoke(pager);
var source = GetBinding(nameof(Source));
if (source == null)
{
throw new XamlException("Pager has no Source binding");
}
pager.MergeAttribute(":source", source.GetPath(context));
MergeBindingAttributeString(pager, context, "empty-text", nameof(EmptyText), EmptyText);
MergeBindingAttributeString(pager, context, "template-text", nameof(TemplateText), TemplateText);
pager.Render(context, TagRenderMode.Normal);
}
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);
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tr = new TagBuilder("tr");
onRender?.Invoke(tr);
MergeAttributes(tr, context);
if (Style != RowStyle.Default)
{
tr.AddCssClass("row-" + Style.ToString().ToKebabCase());
}
if (Align != null)
{
tr.AddCssClass("text-" + Align.ToString().ToLowerInvariant());
}
tr.RenderStart(context);
foreach (var c in Cells)
{
c.RenderElement(context);
}
tr.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var cont = new TagBuilder("tree-view", null, IsInGrid);
MergeAttributes(cont, context);
if (Height != null)
{
cont.MergeStyle("height", Height.Value);
}
if (Style != TreeViewStyle.Normal)
{
cont.AddCssClass($"tree-view-{Style.ToString().ToKebabCase()}");
}
if (Indent != null && Indent.Value == false)
{
cont.AddCssClass("no-indent");
}
var isBind = GetBinding(nameof(ItemsSource));
if (isBind != null)
{
cont.MergeAttribute(":items", isBind.GetPath(context));
cont.MergeAttribute(":expand", "$expand"); // in BaseController
if (Children.Count != 1)
{
throw new XamlException("Only one TreeViewItem element is allowed for dynamic TreeView");
}
var ch = Children[0];
cont.MergeAttribute(":options", GetOptions(context, ch));
}
if (AutoSelect != AutoSelectMode.None)
{
cont.MergeAttribute("auto-select", AutoSelect.ToString().ToKebabCase());
}
if (ExpandFirstItem)
{
cont.MergeAttribute(":expand-first-item", "true");
}
var dblClickBind = GetBindingCommand(nameof(DoubleClick));
if (dblClickBind != null)
{
// Function!
cont.MergeAttribute(":doubleclick", "() => " + dblClickBind.GetCommand(context));
}
cont.RenderStart(context);
cont.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var panel = new TagBuilder("a2-panel", null, IsInGrid);
MergeBindingAttributeBool(panel, context, ":initial-collapsed", nameof(Collapsed), Collapsed);
MergeBindingAttributeBool(panel, context, ":collapsible", nameof(Collapsible), Collapsible);
if (!String.IsNullOrEmpty(TestId) && context.IsDebugConfiguration)
{
panel.MergeAttribute("test-id", TestId);
}
panel.AddCssClassBool(Compact, "compact");
if (!HasHeader)
{
panel.MergeAttribute(":no-header", "true");
}
var sb = GetBinding(nameof(Style));
if (sb != null)
{
panel.MergeAttribute(":panel-style", sb.GetPathFormat(context));
}
else if (Style != PaneStyle.Default)
{
panel.MergeAttribute("panel-style", Style.ToString().ToLowerInvariant());
}
MergeAttributes(panel, context, MergeAttrMode.Visibility);
if (Background != BackgroundStyle.Default)
{
panel.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
if (Height != null)
{
panel.MergeStyle("height", Height.Value);
}
if (DropShadow != ShadowStyle.None)
{
panel.AddCssClass("drop-shadow");
panel.AddCssClass(DropShadow.ToString().ToLowerInvariant());
}
panel.RenderStart(context);
RenderHeader(context);
var content = new TagBuilder("div", "panel-content");
MergeAttributes(content, context, MergeAttrMode.Margin | MergeAttrMode.Wrap | MergeAttrMode.Tip);
content.RenderStart(context);
RenderChildren(context);
content.RenderEnd(context);
panel.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tr = new TagBuilder("tr");
onRender?.Invoke(tr);
MergeAttributes(tr, 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");
}
var class2 = tr.GetAttribute(":class");
if (!String.IsNullOrEmpty(class2))
{
tr.MergeAttribute(":class", $"row.rowCssClass({markBind.GetPathFormat(context)})", replaceExisting: true);
}
else
{
tr.MergeAttribute(":class", markBind.GetPathFormat(context));
}
}
else if (Mark != MarkStyle.Default)
{
tr.AddCssClass(Mark.ToString().ToKebabCase());
}
if (Style != RowStyle.Default)
{
tr.AddCssClass("row-" + Style.ToString().ToKebabCase());
}
if (Align != null)
{
tr.AddCssClass("text-" + Align.ToString().ToLowerInvariant());
}
tr.RenderStart(context);
foreach (var c in Cells)
{
c.RenderElement(context);
}
tr.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var tag = new TagBuilder("div", "a2-alert", IsInGrid);
tag.MergeAttribute("role", "alert");
MergeAttributes(tag, context);
var bindStyle = GetBinding(nameof(Style));
if (bindStyle != null)
{
tag.MergeAttribute(":class", bindStyle.GetPath(context));
}
else if (Style != AlertStyle.Default)
{
tag.AddCssClass(Style.ToString().ToLowerInvariant());
}
if (DropShadow != ShadowStyle.None)
{
tag.AddCssClass("drop-shadow");
tag.AddCssClass(DropShadow.ToString().ToLowerInvariant());
}
tag.RenderStart(context);
RenderIcon(context, Icon);
if (Content is UIElementBase)
{
(Content as UIElementBase).RenderElement(context, null);
}
else
{
var span = new TagBuilder("span");
var cbind = GetBinding(nameof(Content));
if (cbind != null)
{
span.MergeAttribute("v-text", cbind.GetPathFormat(context));
}
else if (Content != null)
{
span.SetInnerText(Content.ToString());
}
span.Render(context);
}
tag.RenderEnd(context);
}
public 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 (MinWidth != null)
{
panel.MergeStyleUnit("min-width", MinWidth.Value);
}
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.AddCssClassBool(Compact, "compact");
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);
}
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;
}
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);
}
}
internal override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (CheckDisabledModel(context))
{
return;
}
var combo = new TagBuilder("select", null, IsInGrid);
onRender?.Invoke(combo);
combo.MergeAttribute("is", "combobox");
combo.MergeAttribute("v-cloak", String.Empty);
combo.MergeAttribute("display", DisplayProperty);
if (Style != ComboBoxStyle.Default)
{
combo.AddCssClass($"combo-{Style.ToString().ToLowerInvariant()}");
}
MergeAttributes(combo, context);
MergeAlign(combo, context, Align);
MergeBoolAttribute(combo, context, nameof(ShowValue), ShowValue);
if (Size != ControlSize.Default)
{
combo.AddCssClass($"cb-{Size.ToString().ToLowerInvariant()}");
}
MergeDisabled(combo, context);
var isBind = GetBinding(nameof(ItemsSource));
if (isBind != null)
{
combo.MergeAttribute(":items-source", isBind.GetPath(context));
if (_children != null)
{
if (Children.Count != 1)
{
throw new XamlException("The ComboBox with the specified ItemsSource must have only one ComboBoxItem element");
}
var elem = Children[0];
var contBind = elem.GetBinding("Content");
if (contBind == null)
{
throw new XamlException("ComboBoxItem. Content binging must be specified");
}
combo.MergeAttribute(":name-prop", $"'{contBind.Path}'"); /*without context!*/
var valBind = elem.GetBinding("Value");
if (valBind == null)
{
throw new XamlException("ComboBoxItem. Value binging must be specified");
}
combo.MergeAttribute(":value-prop", $"'{valBind.Path}'"); /*without context!*/
}
}
MergeValue(combo, context);
combo.RenderStart(context);
if (_children != null && isBind == null)
{
foreach (var ch in Children)
{
ch.RenderElement(context);
}
}
RenderPopover(context);
RenderHint(context);
RenderLink(context);
combo.RenderEnd(context);
}
void RenderButton(RenderContext context, Boolean hasDropDown, Boolean bDropUp, Action <TagBuilder> onRender)
{
var parentCB = IsParentCommandBar;
var parentTB = IsParentToolBar;
Boolean hasCommand = GetBindingCommand(nameof(Command)) != null;
Boolean insideBar = IsParentToolBar || IsParentCommandBar;
var button = new TagBuilder("button", "btn", IsInGrid);
onRender?.Invoke(button);
if (!Block && !insideBar)
{
button.AddCssClass("a2-inline");
}
if (Parent is Toolbar && Style == ButtonStyle.Default)
{
button.AddCssClass("btn-tb");
}
else if (IsParentCommandBar)
{
button.AddCssClass("btn-cb");
}
AddSize(button);
if (IconAlign == IconAlign.Top)
{
button.AddCssClass("icon-top");
}
//if (!insideBar)
if (Style != ButtonStyle.Default)
{
button.AddCssClass($"btn-{Style.ToString().ToLowerInvariant()}");
}
button.AddCssClassBool(Rounded, "btn-rounded");
if (hasDropDown && !hasCommand)
{
button.MergeAttribute("toggle", String.Empty);
}
MergeAttributes(button, context, MergeAttrMode.NoTabIndex); // dinamic
if (TabIndex != 0)
{
button.MergeAttribute("tabindex", TabIndex.ToString());
}
if (!HasContent && (Icon != Icon.NoIcon))
{
button.AddCssClass("btn-icon");
}
MergeDisabled(button, context, nativeControl: true);
button.MergeAttribute("v-settabindex", String.Empty);
button.RenderStart(context);
RenderIcon(context, Icon);
RenderContent(context);
if (hasDropDown)
{
if (!hasCommand)
{
RenderCaret(context, bDropUp);
}
}
button.RenderEnd(context);
if (hasDropDown && hasCommand)
{
var open = new TagBuilder("button", "btn btn-caret")
.MergeAttribute("toggle", String.Empty);
if (Style != ButtonStyle.Default)
{
open.AddCssClass($"btn-{Style.ToString().ToLowerInvariant()}");
}
MergeVisibilityAttribures(open, context); // Visible only
AddSize(open);
open.RenderStart(context);
RenderCaret(context, bDropUp);
open.RenderEnd(context);
}
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var dataGrid = new TagBuilder("data-grid", null, IsInGrid);
onRender?.Invoke(dataGrid);
MergeBindingAttributeBool(dataGrid, context, ":compact", nameof(Compact), Compact);
MergeAttributes(dataGrid, context, MergeAttrMode.Margin | MergeAttrMode.Visibility);
dataGrid.MergeAttribute("key", Guid.NewGuid().ToString()); // disable vue reusing
if (Height != null)
{
dataGrid.MergeStyle("height", Height.Value);
}
if (FixedHeader)
{
dataGrid.MergeAttribute(":fixed-header", "true");
}
if (HeadersVisibility == HeadersVisibility.None)
{
dataGrid.MergeAttribute(":hide-header", "true");
}
if (Style != DataGridStyle.Default)
{
dataGrid.AddCssClass($"data-grid-{Style.ToString().ToKebabCase()}");
}
if (Background != BackgroundStyle.Default)
{
dataGrid.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
if (RowDetails != null)
{
dataGrid.MergeAttribute(":row-details", "true");
dataGrid.MergeAttribute("row-details-activate", RowDetails.Activate.ToString().ToLowerInvariant());
var vBind = RowDetails.GetBinding("Visible");
if (vBind != null)
{
dataGrid.MergeAttribute("row-details-visible", vBind.Path /*!without context!*/);
}
}
var isb = GetBinding(nameof(ItemsSource));
if (isb != null)
{
dataGrid.MergeAttribute(":items-source", isb.GetPath(context));
}
MergeBoolAttributeIfExists(dataGrid, context, nameof(Hover), Hover);
MergeBoolAttributeIfExists(dataGrid, context, nameof(Striped), Striped);
MergeBoolAttribute(dataGrid, context, nameof(Border), Border);
MergeBoolAttribute(dataGrid, context, nameof(Sort), Sort);
dataGrid.MergeAttribute(":route-query", "$query"); // always!
if (!String.IsNullOrEmpty(EmptyPanelDelegate))
{
dataGrid.MergeAttribute(":empty-panel-callback", $"$delegate('{EmptyPanelDelegate}')");
}
var dblClickBind = GetBindingCommand(nameof(DoubleClick));
if (dblClickBind != null)
{
// Function!
dataGrid.MergeAttribute(":doubleclick", "() => " + dblClickBind.GetCommand(context));
}
if (MarkerStyle != RowMarkerStyle.None)
{
dataGrid.MergeAttribute("mark-style", MarkerStyle.ToString().ToKebabCase());
}
var mbind = GetBinding(nameof(Mark));
if (mbind != null)
{
dataGrid.MergeAttribute("mark", mbind.Path); // without context!!!
}
else if (Mark != MarkStyle.Default)
{
throw new XamlException("The Mark property must be a binding");
}
var rbbind = GetBinding(nameof(RowBold));
if (rbbind != null)
{
dataGrid.MergeAttribute("row-bold", rbbind.GetPath(context));
}
else if (RowBold != null)
{
throw new XamlException("The RowBold property must be a binding");
}
// TODO: binding for GridLines ???
if (GridLines != GridLinesVisibility.None)
{
dataGrid.MergeAttribute("grid", GridLines.ToString());
}
var groupByBind = GetBinding(nameof(GroupBy));
if (groupByBind != null)
{
dataGrid.MergeAttribute(":group-by", groupByBind.GetPath(context));
}
else if (_groupBy != null)
{
dataGrid.MergeAttribute(":group-by", _groupBy.GetJsValue(context));
}
if (AutoSelect != AutoSelectMode.None)
{
dataGrid.MergeAttribute("auto-select", AutoSelect.ToString().ToKebabCase());
}
dataGrid.RenderStart(context);
Int32 colIndex = 0;
foreach (var col in Columns)
{
col.RenderColumn(context, colIndex);
colIndex++;
}
RenderRowDetails(context);
RenderEmptyPanel(context);
RenderFooter(context);
dataGrid.RenderEnd(context);
}
void RenderButton(RenderContext context, Boolean hasDropDown, Boolean bDropUp, Action <TagBuilder> onRender)
{
Boolean hasCommand = GetBindingCommand(nameof(Command)) != null;
Boolean insideBar = Parent is Toolbar || Parent is CommandBar;
var button = new TagBuilder("button", "btn", IsInGrid);
onRender?.Invoke(button);
if (!Block && !insideBar)
{
button.AddCssClass("a2-inline");
}
if (Parent is Toolbar && Style == ButtonStyle.Default)
{
button.AddCssClass("btn-tb");
}
else if (Parent is CommandBar)
{
button.AddCssClass("btn-cb");
}
switch (Size)
{
case ControlSize.Large:
button.AddCssClass("lg");
break;
case ControlSize.Small:
button.AddCssClass("sm");
break;
case ControlSize.Mini:
button.AddCssClass("xs");
break;
}
if (IconAlign == IconAlign.Top)
{
button.AddCssClass("icon-top");
}
//if (!insideBar)
if (Style != ButtonStyle.Default)
{
button.AddCssClass($"btn-{Style.ToString().ToLowerInvariant()}");
}
if (hasDropDown && !hasCommand)
{
button.MergeAttribute("toggle", String.Empty);
}
MergeAttributes(button, context, MergeAttrMode.NoTabIndex); // dinamic
if (TabIndex != 0)
{
button.MergeAttribute("tabindex", TabIndex.ToString());
}
if (!HasContent && (Icon != Icon.NoIcon))
{
button.AddCssClass("btn-icon");
}
MergeDisabled(button, context, nativeControl: true);
button.MergeAttribute("v-settabindex", String.Empty);
button.RenderStart(context);
RenderIcon(context, Icon);
RenderContent(context);
if (hasDropDown)
{
if (!hasCommand)
{
RenderCaret(context, bDropUp);
}
}
button.RenderEnd(context);
if (hasDropDown && hasCommand)
{
var open = new TagBuilder("button", "btn btn-caret")
.MergeAttribute("toggle", String.Empty)
.RenderStart(context);
RenderCaret(context, bDropUp);
open.RenderEnd(context);
}
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (SkipRender(context))
{
return;
}
var ul = new TagBuilder("a2-list", null, IsInGrid);
onRender?.Invoke(ul);
var isBind = GetBinding(nameof(ItemsSource));
ul.AddCssClassBool(Striped, "striped");
ul.AddCssClassBool(Border, "border");
ul.AddCssClassBool(Flush, "flush");
ul.AddCssClassBool(Compact, "compact");
ul.MergeAttribute("group-by", GroupBy);
if (BorderStyle != BorderStyle.None)
{
ul.AddCssClass($"border-{BorderStyle.ToString().ToKebabCase()}");
}
if (MarkerStyle != RowMarkerStyle.None)
{
ul.MergeAttribute("mark-style", MarkerStyle.ToString().ToKebabCase());
}
if (Select != null)
{
ul.MergeAttribute(":selectable", Select.Value.ToString().ToLowerInvariant());
}
ul.AddCssClass(Style.ToString().ToKebabCase());
//ul.MergeAttribute(":command", "()=> $navigate()");
if (Background != BackgroundStyle.Default)
{
ul.AddCssClass("background-" + Background.ToString().ToKebabCase());
}
var mbind = GetBinding(nameof(Mark));
if (mbind != null)
{
ul.MergeAttribute("mark", mbind.Path /*without scope, property name*/);
}
else if (Mark != null)
{
throw new XamlException("The Mark property must be a binding");
}
if (isBind != null)
{
ul.MergeAttribute(":items-source", isBind.GetPath(context));
ul.MergeAttribute("v-lazy", isBind.GetPath(context));
}
MergeAttributes(ul, context);
if (Height != null)
{
ul.MergeStyle("height", Height.Value);
}
if (MaxHeight != null)
{
ul.MergeStyle("max-height", MaxHeight.Value);
}
if (AutoSelect != AutoSelectMode.None)
{
ul.MergeAttribute("auto-select", AutoSelect.ToString().ToKebabCase());
}
ul.RenderStart(context);
RenderBody(context, isBind != null);
RenderEmptyPanel(context);
ul.RenderEnd(context);
}
public override void RenderElement(RenderContext context, Action <TagBuilder> onRender = null)
{
if (CheckDisabledModel(context))
{
return;
}
var input = new TagBuilder("a2-selector", null, IsInGrid);
onRender?.Invoke(input);
if (!String.IsNullOrEmpty(Delegate))
{
input.MergeAttribute(":fetch", $"$delegate('{Delegate}')");
}
if (!String.IsNullOrEmpty(SetDelegate))
{
input.MergeAttribute(":hitfunc", $"$delegate('{SetDelegate}')");
}
input.MergeAttribute("display", DisplayProperty);
if (PanelPlacement != DropDownPlacement.BottomLeft)
{
input.MergeAttribute("placement", PanelPlacement.ToString().ToKebabCase());
}
if (Style != SelectorStyle.Default)
{
input.MergeAttribute("mode", Style.ToString().ToKebabCase());
}
if (Size != ControlSize.Default)
{
input.AddCssClass($"sel-{Size.ToString().ToLowerInvariant()}");
}
if (ListSize != null)
{
if (!ListSize.Width.IsEmpty)
{
input.MergeAttribute("list-width", ListSize.Width.ToString());
}
if (!ListSize.Height.IsEmpty)
{
input.MergeAttribute("list-height", ListSize.Height.ToString());
}
}
if (ShowCaret.HasValue && ShowCaret.Value)
{
input.MergeAttribute(":caret", "true");
}
if (ShowClear)
{
input.MergeAttribute(":has-clear", "true");
}
var isBind = GetBinding(nameof(ItemsSource));
if (isBind != null)
{
input.MergeAttribute(":items-source", isBind.GetPath(context));
}
MergeAttributes(input, context);
MergeDisabled(input, context);
MergeAlign(input, context, Align);
MergeBindingAttributeString(input, context, "placeholder", nameof(Placeholder), Placeholder);
MergeValue(input, context);
MergeCustomValueItemProp(input, context, nameof(TextValue), "text");
MergeCreateNew(input, context);
input.RenderStart(context);
RenderAddOns(context);
//RenderNewPane(context);
RenderPaneTemplate(context);
input.RenderEnd(context);
}
