static CodeFormatter()
{
CssClasses.Add(TokenCategory.Text, new TokenCategoryClassProvider("cr-text", new KeyValuePair <TokenLanguage, string>(TokenLanguage.Html, "cr-text-html")));
CssClasses.Add(TokenCategory.Keyword, new TokenCategoryClassProvider("cr-keyword", new KeyValuePair <TokenLanguage, string>(TokenLanguage.Html, "cr-keyword-html"), new KeyValuePair <TokenLanguage, string>(TokenLanguage.Css, "cr-keyword-css")));
CssClasses.Add(TokenCategory.Operator, new TokenCategoryClassProvider("cr-operator"));
CssClasses.Add(TokenCategory.PreprocessorKeyword, new TokenCategoryClassProvider("cr-preproc", new KeyValuePair <TokenLanguage, string>(TokenLanguage.Html, "cr-preproc-html")));
CssClasses.Add(TokenCategory.String, new TokenCategoryClassProvider("cr-string", new KeyValuePair <TokenLanguage, string>(TokenLanguage.Html, "cr-string-html"), new KeyValuePair <TokenLanguage, string>(TokenLanguage.Css, "cr-string-css")));
CssClasses.Add(TokenCategory.Number, new TokenCategoryClassProvider("cr-number"));
CssClasses.Add(TokenCategory.Identifier, new TokenCategoryClassProvider("cr-identifier"));
CssClasses.Add(TokenCategory.HtmlServerSideScript, new TokenCategoryClassProvider("cr-htmlserverscript"));
CssClasses.Add(TokenCategory.HtmlString, new TokenCategoryClassProvider("cr-htmlstring"));
CssClasses.Add(TokenCategory.Unknown, new TokenCategoryClassProvider("cr-unknown"));
CssClasses.Add(TokenCategory.Comment, new TokenCategoryClassProvider("cr-comment"));
CssClasses.Add(TokenCategory.XmlComment, new TokenCategoryClassProvider("cr-xmlcomment"));
CssClasses.Add(TokenCategory.CssComment, new TokenCategoryClassProvider("cr-csscomment"));
CssClasses.Add(TokenCategory.CssKeyword, new TokenCategoryClassProvider("cr-csskeyword"));
CssClasses.Add(TokenCategory.CssPropertyName, new TokenCategoryClassProvider("cr-csspropertyname"));
CssClasses.Add(TokenCategory.CssPropertyValue, new TokenCategoryClassProvider("cr-csspropertyvalue"));
CssClasses.Add(TokenCategory.CssSelector, new TokenCategoryClassProvider("cr-cssselector"));
CssClasses.Add(TokenCategory.CssStringValue, new TokenCategoryClassProvider("cr-cssstringvalue"));
CssClasses.Add(TokenCategory.HtmlElementName, new TokenCategoryClassProvider("cr-htmlelementname"));
CssClasses.Add(TokenCategory.HtmlEntity, new TokenCategoryClassProvider("cr-htmlentity"));
CssClasses.Add(TokenCategory.HtmlOperator, new TokenCategoryClassProvider("cr-htmloperator"));
CssClasses.Add(TokenCategory.HtmlComment, new TokenCategoryClassProvider("cr-htmlcomment"));
CssClasses.Add(TokenCategory.HtmlAttributeName, new TokenCategoryClassProvider("cr-htmlattributename"));
CssClasses.Add(TokenCategory.HtmlAttributeValue, new TokenCategoryClassProvider("cr-htmlattributevalue"));
CssClasses.Add(TokenCategory.HtmlTagDelimiter, new TokenCategoryClassProvider("cr-htmltagdelimiter"));
}
protected override void OnStart(System.IO.TextWriter writer)
{
// Add the outer group
_buttonGroup = GetHelper().ButtonGroup().Component;
if (Dropup)
{
_buttonGroup.AddCss(Css.Dropup);
}
_buttonGroup.Start(writer);
// Add the action button if split and copy over button CSS classes
// Also move the icon to the button (if one is present)
// But only create the split if we actually have some text to put in it
if (Split && !string.IsNullOrWhiteSpace(TextContent))
{
Button button = GetHelper().Button(TextContent).Component;
MoveIcons(button);
TextContent = null;
foreach (string cssClass in CssClasses)
{
button.CssClasses.Add(cssClass);
}
button.MergeAttributes(Attributes.Dictionary);
Attributes.Dictionary.Clear();
button.StartAndFinish(writer);
}
// Create the dropdown button, copy over CSS, add the text and caret, then render
Button dropdown = GetHelper().Button(buttonType: ButtonType.Button).Component;
MoveIcons(dropdown);
dropdown.AddCss(Css.Btn, Css.BtnDefault, Css.DropdownToggle);
dropdown.MergeAttribute("data-toggle", "dropdown");
foreach (string cssClass in CssClasses)
{
dropdown.CssClasses.Add(cssClass);
}
dropdown.MergeAttributes(Attributes.Dictionary);
Attributes.Dictionary.Clear();
CssClasses.Clear();
if (!string.IsNullOrWhiteSpace(TextContent))
{
dropdown.AddChild(GetHelper().Content(TextContent + " "));
}
else
{
Element element = GetHelper().Element("span").AddCss(Css.SrOnly).Component;
element.AddChild(GetHelper().Content("Toggle Dropdown"));
dropdown.AddChild(element);
}
dropdown.AddChild(GetHelper().Caret());
TextContent = null;
dropdown.StartAndFinish(writer);
// Add CSS and attributes after we've copied all the user-specified stuff to the buttons
MergeAttribute("role", "menu");
AddCss(Css.DropdownMenu);
base.OnStart(writer);
}
protected override void OnStart(TextWriter writer)
{
// Change to a div if no link was provided, otherwise wrap in a div
string href = GetAttribute("href");
if (string.IsNullOrWhiteSpace(href))
{
TagName = "div";
}
else
{
// Copy media CSS classes to the wrapping div
_wrapper = GetHelper().Div().Component;
foreach (string mediaClass in CssClasses.Where(x => x.StartsWith("media-")).ToList())
{
_wrapper.AddCss(mediaClass);
CssClasses.Remove(mediaClass);
}
_wrapper.Start(writer);
}
base.OnStart(writer);
_image = GetHelper().Image(Src, Alt).AddCss(Css.MediaObject).Component;
_image.Start(writer);
}
//public MenuExpression<MODEL, ITEMS> For(Func<MODEL, IList<ITEMS>> expression)
//{
// _nodes = expression(_model);
// return this;
//}
public override string ToString()
{
CssClasses.Add("entity-link-list");
return(@"<div{0}><ul class=""sf-menu sf-vertical"">{1}</ul></div>".ToFormat(GetHtmlAttributesString(),
renderListItems(_items)));
}
public void AddCss(params string[] cssClasses)
{
foreach (string cssClass in cssClasses)
{
CssClasses.Add(cssClass);
}
}
/// <inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Insert(1, StackDirection.ToString().ToLower());
CssClasses.Insert(0, "ui");
CssClasses.Add("segments");
}
///<inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Insert(0, "ui");
this.AddInvertedClass(1).AddUnselectableClass(1).AddSizeClass(1).AddColorClass(1);
CssClasses.Add("text");
}
public virtual IEnumerator <IGridRow <T> > GetEnumerator()
{
if (CurrentRows == null)
{
IQueryable <T> items = Grid.Source;
foreach (IGridProcessor <T> processor in Grid.Processors.Where(proc => proc.ProcessorType == GridProcessorType.Pre))
{
items = processor.Process(items);
}
foreach (IGridProcessor <T> processor in Grid.Processors.Where(proc => proc.ProcessorType == GridProcessorType.Post))
{
items = processor.Process(items);
}
CurrentRows = items
.ToList()
.Select(model => new GridRow <T>(model)
{
CssClasses = CssClasses?.Invoke(model)
});
}
return(CurrentRows.GetEnumerator());
}
public void RemoveCss(params string[] cssClasses)
{
foreach (string cssClass in cssClasses)
{
CssClasses.Remove(cssClass);
}
}
/// <summary>
/// Creates an alert
/// </summary>
/// <param name="type">Type of alert</param>
/// <param name="message">Alert message</param>
/// <param name="title">Title/Heading of the alert</param>
/// <param name="icon">Icon to be rendered with title/heading</param>
private void CreateAlert(EMessage type, string message, string title, IHtmlComponent icon)
{
CssClasses.Add(type.GetStringValue());
HtmlComponent bc = new HtmlComponent(EHtmlTag.B)
{
InnerHtml = title ?? string.Empty
};
if (icon != null)
{
bc.PrependTags.Add(icon);
}
if (WebExtrasSettings.CssFramework != ECssFramework.JQueryUI)
{
CssClasses.Add("alert");
Button closeBtn = new Button(EButton.Regular, "×", string.Empty);
closeBtn.CssClasses.Add("close");
closeBtn.Attributes["data-dismiss"] = "alert";
PrependTags.Add(closeBtn);
PrependTags.Add(bc);
InnerHtml = (!string.IsNullOrWhiteSpace(title) || icon != null)
? WebExtrasSettings.HTMLSpace + message
: message;
}
else
{
HtmlComponent div = new HtmlComponent(EHtmlTag.Div);
switch (type)
{
case EMessage.Error:
div.CssClasses.Add("ui-state-error");
break;
case EMessage.Information:
case EMessage.Warning:
div.CssClasses.Add("ui-state-highlight");
break;
case EMessage.Success:
div.CssClasses.Add("ui-state-success");
break;
}
div.CssClasses.Add("ui-corner-all");
div.PrependTags.Add(bc);
div.InnerHtml = (!string.IsNullOrWhiteSpace(title) || icon != null)
? WebExtrasSettings.HTMLSpace + message
: message;
PrependTags.Add(div);
}
Type = type;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="icon">Icon to be displayed as the hypelink</param>
/// <param name="url">Link URL</param>
/// <param name="htmlAttributes">[Optional Extra HTML attributes</param>
public BootstrapIconlink(EFontAwesomeIcon icon, string url, object htmlAttributes = null) :
base(string.Empty, url, htmlAttributes)
{
CssClasses.Add("icon-only-link");
m_icon = BootstrapUtil.CreateIcon(icon);
PrependTags.Add(m_icon);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="icon">Icon to be displayed as the hypelink</param>
/// <param name="url">Link URL</param>
/// <param name="htmlAttributes">[Optional Extra HTML attributes</param>
public BootstrapIconlink(EBootstrapIcon icon, string url, object htmlAttributes = null) :
base(string.Empty, url, htmlAttributes)
{
CssClasses.Add("icon-only-link");
IHtmlComponent iconElement = BootstrapUtil.CreateIcon(icon);
PrependTags.Add(iconElement);
}
///<inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Insert(0, Icon.ToCssClass());
this.AddDisabledClass(0).AddCircularClass(0).AddFittedClass(0).AddSizeClass(0).AddInvertedClass(0).AddColorClass(0);
CssClasses.Add("icon");
}
/// <summary>
/// Converts current HTML component to a HTML encoded string
/// </summary>
/// <returns></returns>
public virtual string ToHtml()
{
PreRender();
if (Tag == EHtmlTag.Empty)
{
return(string.Empty);
}
if (Attributes.ContainsKey("class"))
{
CssClasses.Add(Attributes["class"]);
}
if (CssClasses.Count > 0)
{
Attributes["class"] = string.Join(" ", CssClasses.Distinct());
}
string innerHtml = string.Empty;
if (Tag != EHtmlTag.Img)
{
innerHtml =
string.Join("", PrependTags.Select(f => f.ToHtml())) +
InnerHtml +
string.Join("", AppendTags.Select(f => f.ToHtml()));
}
List <string> parts = new List <string> {
"<" + Tag.ToString().ToLowerInvariant()
};
string attribs = " " + string.Join(" ",
Attributes.OrderBy(f => f.Key).Select(f => string.Format("{0}=\"{1}\"", f.Key, f.Value)));
parts.Add(attribs);
if (Tag == EHtmlTag.Img || Tag == EHtmlTag.Input)
{
parts.Add("/>");
}
else
{
parts.Add(">");
if (!string.IsNullOrWhiteSpace(innerHtml))
{
parts.Add(innerHtml);
}
parts.Add("</" + Tag.ToString().ToLowerInvariant() + ">");
}
string result = string.Join(string.Empty, parts);
return(result);
}
/// <inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
if (IsPlaceholder)
{
CssClasses.Insert(1, PlaceholderClass);
}
CssClasses.Insert(0, "ui");
CssClasses.Add("segment");
}
private void addCssClasses(StringBuilder builder, IDictionary <string, string> attributes)
{
if (CssClasses.Count > 0)
{
CssClasses.Each(name => builder.AppendFormat("{0}", name));
attributes.Add("class", string.Join(" ", CssClasses.ToArray()));
builder.Length = 0;
}
}
protected override void OnStart(TextWriter writer)
{
// Add the text content as a child
if (!string.IsNullOrEmpty(TextContent))
{
this.AddChild(new Content <THelper>(Helper, TextContent));
}
base.OnStart(writer);
// Pretty print
if (_prettyPrint && !(writer is SuppressOutputWriter))
{
writer.WriteLine();
int tagIndent = (int)Helper.GetItem(TagIndentKey, 0);
writer.Write(new String(' ', tagIndent++));
Helper.AddItem(TagIndentKey, tagIndent);
Helper.AddItem(LastToWriteKey, this);
}
else
{
_prettyPrint = false;
}
// Merge CSS classes
if (CssClasses.Count > 0)
{
Attributes.Merge("class",
(Attributes.Dictionary.ContainsKey("class") ? Attributes.GetValue("class") + " " : string.Empty)
+ string.Join(" ", CssClasses.Reverse())); // TODO: Remove the reverse call
}
// Generate the inline CSS style
if (InlineStyles.Dictionary.Count > 0)
{
Attributes.Merge("style", string.Join(" ", InlineStyles.Dictionary.Select(x => x.Key + ": " + x.Value + ";")));
}
// Append the start tag
StringBuilder startTag = new StringBuilder("<" + _tagName);
foreach (KeyValuePair <string, string> attribute in Attributes.Dictionary.Reverse()) // TODO: Remove the reverse call
{
if (string.Equals(attribute.Key, "id", StringComparison.Ordinal) && string.IsNullOrEmpty(attribute.Value))
{
continue;
}
string encoded = HttpUtility.HtmlAttributeEncode(attribute.Value);
startTag.Append(" " + attribute.Key + "=\"" + encoded + "\"");
}
startTag.Append(">");
writer.Write(startTag.ToString());
_startTagOutput = true;
}
///<inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Insert(0, "ui");
this.AddDisabledClass(1)
.AddAlignmentClass(1)
.AddContentAlignmentClass(1)
.AddAttachClass(1)
.AddDividingClass(1)
.AddUnselectableClass(1)
.AddInvertedClass(1)
.AddColorClass(1);
CssClasses.Add("header");
}
public void ToggleCss(string cssClass, bool add, params string[] removeIfAdding)
{
if (add)
{
foreach (string remove in removeIfAdding)
{
CssClasses.Remove(remove);
}
CssClasses.Add(cssClass);
}
else
{
CssClasses.Remove(cssClass);
}
}
internal TThis ToggleCss(string cssClass, bool add, params string[] removeIfAdding)
{
if (add)
{
foreach (string remove in removeIfAdding)
{
CssClasses.Remove(remove);
}
CssClasses.Add(cssClass);
}
else
{
CssClasses.Remove(cssClass);
}
return(this.GetThis());
}
public SelectBuilder <TModel, TProperty> Select2(string placeholder = null, bool allowClear = false)
{
CssClasses.Add("select2");
if (!string.IsNullOrEmpty(placeholder))
{
HtmlAttributes.Add("data-placeholder", placeholder);
}
if (allowClear)
{
HtmlAttributes.Add("data-allowClear", "true");
}
return(this);
}
protected override void OnStart(TextWriter writer)
{
// Adjust the link style if we're in a navbar
if (GetComponent <Navbar>() != null)
{
CssClasses.Add(Css.NavbarLink);
}
// Adjust the link style if we're in an alert
if (GetComponent <Alert>() != null)
{
CssClasses.Add(Css.AlertLink);
}
base.OnStart(writer);
}
protected virtual void RenderContents(BocListRenderingContext renderingContext)
{
ArgumentUtility.CheckNotNull("renderingContext", renderingContext);
// Menu Block
if (renderingContext.Control.HasMenuBlock)
{
renderingContext.Writer.AddAttribute(HtmlTextWriterAttribute.Class, CssClasses.MenuBlock);
if (!renderingContext.Control.MenuBlockWidth.IsEmpty)
{
renderingContext.Writer.AddStyleAttribute(HtmlTextWriterStyle.Width, renderingContext.Control.MenuBlockWidth.ToString());
}
renderingContext.Writer.RenderBeginTag(HtmlTextWriterTag.Div);
if (!renderingContext.Control.MenuBlockOffset.IsEmpty)
{
renderingContext.Writer.AddStyleAttribute(HtmlTextWriterStyle.MarginLeft, renderingContext.Control.MenuBlockOffset.ToString());
}
renderingContext.Writer.RenderBeginTag(HtmlTextWriterTag.Div);
MenuBlockRenderer.Render(renderingContext);
renderingContext.Writer.RenderEndTag();
renderingContext.Writer.RenderEndTag();
}
// Table Block
renderingContext.Writer.AddAttribute(
HtmlTextWriterAttribute.Class, CssClasses.GetTableBlock(renderingContext.Control.HasMenuBlock, renderingContext.Control.HasNavigator));
if (renderingContext.Control.HasMenuBlock && !renderingContext.Control.MenuBlockWidth.IsEmpty)
{
renderingContext.Writer.AddStyleAttribute("right", renderingContext.Control.MenuBlockWidth.ToString());
}
renderingContext.Writer.RenderBeginTag(HtmlTextWriterTag.Div);
TableBlockRenderer.Render(renderingContext);
if (renderingContext.Control.HasNavigator)
{
NavigationBlockRenderer.Render(renderingContext);
}
renderingContext.Writer.RenderEndTag();
}
/// <summary>
/// Renders a table cell for <see cref="BocColumnRenderingContext.ColumnDefinition"/> containing the appropriate data from the
/// <see cref="IBusinessObject"/> contained in <paramref name="dataRowRenderEventArgs"/>
/// </summary>
/// <param name="renderingContext">The <see cref="BocColumnRenderingContext{TBocColumnDefinition}"/>.</param>
/// <param name="rowIndex">The zero-based index of the row on the page to be displayed.</param>
/// <param name="showIcon">Specifies if an object-specific icon will be rendered in the table cell.</param>
/// <param name="dataRowRenderEventArgs">Specifies row-specific arguments used in rendering the table cell.</param>
/// <remarks>
/// This is a template method. Deriving classes must implement <see cref="RenderCellContents"/> to provide the contents of
/// the table cell (<td>) element.
/// </remarks>
public virtual void RenderDataCell(
BocColumnRenderingContext <TBocColumnDefinition> renderingContext,
int rowIndex,
bool showIcon,
BocListDataRowRenderEventArgs dataRowRenderEventArgs)
{
ArgumentUtility.CheckNotNull("renderingContext", renderingContext);
ArgumentUtility.CheckNotNull("dataRowRenderEventArgs", dataRowRenderEventArgs);
string cssClassTableCell = CssClasses.GetDataCell(dataRowRenderEventArgs.IsOddRow);
if (!string.IsNullOrEmpty(renderingContext.ColumnDefinition.CssClass))
{
cssClassTableCell += " " + renderingContext.ColumnDefinition.CssClass;
}
renderingContext.Writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClassTableCell);
renderingContext.Writer.RenderBeginTag(HtmlTextWriterTag.Td);
RenderCellContents(renderingContext, dataRowRenderEventArgs, rowIndex, showIcon);
renderingContext.Writer.RenderEndTag();
}
///<inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Insert(0, "ui");
if (IsPlaceholder)
{
CssClasses.Insert(1, PlaceholderClass);
}
this.AddContentSpacingClass(1).
AddLoadingIndicatorClass(1).
AddDisabledClass(1).
AddContentAlignmentClass(1).
AddCompactClass(1).
AddAttachClass(1).
AddCircularClass(1).
AddISegmentStyleClass(1).
AddInvertedClass(1).
AddColorClass(1);
CssClasses.Add("segment");
}
protected Dictionary <string, object> GetAttributesDictionary()
{
object attrClass;
if (HtmlAttributes.TryGetValue("class", out attrClass))
{
string strClass = (string)attrClass;
var classes = strClass.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (classes.Length > 0)
{
CssClasses.AddRange(classes);
}
HtmlAttributes.Remove("class");
}
var result = new Dictionary <string, object>(HtmlAttributes);
result["class"] = GetCssClassString();
return(result);
}
// This prepares the outer form group if we need one
// Needs to be in a separate method so that derived classes can create the form group before outputting any wrappers of their own
protected void Prepare(TextWriter writer)
{
// Only prepare once
if (_prepared)
{
return;
}
_prepared = true;
// Make sure we're in a form group
IFormGroup formGroup = GetComponent <IFormGroup>();
if (formGroup == null && EnsureFormGroup)
{
_formGroup = new FormGroup <THelper>(Helper);
formGroup = _formGroup;
}
// Move any validation classes to the form group, but only if it's implicit for this control and doesn't already have any
if (CssClasses.Any(x => x.StartsWith("has-")) && _formGroup != null && formGroup != null && !formGroup.CssClasses.Any(x => x.StartsWith("has-")))
{
foreach (string formValidation in CssClasses.Where(x => x.StartsWith("has-")))
{
formGroup.CssClasses.Add(formValidation);
}
CssClasses.RemoveWhere(x => x.StartsWith("has-"));
}
// Move any grid column classes to the form group, but only if it's implicit for this control and doesn't already have any
if (CssClasses.Any(x => x.StartsWith("col-")) && _formGroup != null && formGroup != null && !formGroup.CssClasses.Any(x => x.StartsWith("col-")))
{
foreach (string col in CssClasses.Where(x => x.StartsWith("col-")))
{
formGroup.CssClasses.Add(col);
}
CssClasses.RemoveWhere(x => x.StartsWith("col-"));
}
// Add the label to the form group or write it
if (_label != null)
{
// Set the label's for attribute to the input name
string name = Attributes.GetValue("name");
if (!string.IsNullOrWhiteSpace(name))
{
_label.MergeAttribute("for", name);
}
// Add or write the label
if (_formGroup != null)
{
_formGroup.ControlLabel = _label;
}
else
{
_label.StartAndFinish(writer);
}
}
// Start the new form group if we created one
if (_formGroup != null)
{
_formGroup.Start(writer);
}
_prepared = true;
}
protected override void OnStart(TextWriter writer)
{
// Set column classes if we're horizontal
if (AutoColumns)
{
ComponentBuilder <BootstrapConfig, FormGroup> builder = GetBuilder(this);
Form form = GetComponent <Form>();
if ((form != null && form.Horizontal && (!Horizontal.HasValue || Horizontal.Value)) || (Horizontal.HasValue && Horizontal.Value))
{
int labelWidth = form == null ? Config.DefaultFormLabelWidth : form.DefaultLabelWidth;
// Set label column class
if (_label != null && !_label.CssClasses.Any(x => x.StartsWith("col-")))
{
_label.SetColumnClass(Config, "col-md-", labelWidth);
}
// Add column classes to this (these will get moved to a wrapper later in this method)
if (!CssClasses.Any(x => x.StartsWith("col-")))
{
builder.SetMd(Config.GridColumns - labelWidth);
// Also need to add an offset if no label
if (_label == null)
{
builder.SetMdOffset(labelWidth);
}
}
}
else if (form != null && form.Horizontal)
{
// If the form is horizontal but we requested not to be, create a full-width column wrapper
builder.SetMd(Config.GridColumns);
_columnWrapperBeforeLabel = true;
}
}
// Move any grid column classes to a container class
if (CssClasses.Any(x => x.StartsWith("col-")))
{
_columnWrapper = GetHelper().Element("div").AddCss(CssClasses.Where(x => x.StartsWith("col-")).ToArray()).Component;
}
CssClasses.RemoveWhere(x => x.StartsWith("col-"));
base.OnStart(writer);
// Write the column wrapper first if needed
if (_columnWrapperBeforeLabel && _columnWrapper != null)
{
_columnWrapper.Start(writer);
}
// Write the label
if (_label != null)
{
_label.StartAndFinish(writer);
}
// Write the column wrapper
if (!_columnWrapperBeforeLabel && _columnWrapper != null)
{
_columnWrapper.Start(writer);
}
// Add the feedback icon as a final child of either this or the wrapper
if (Icon != Icon.None)
{
Component icon = GetHelper().Icon(Icon).AddCss(Css.FormControlFeedback).Component;
if (_columnWrapper == null)
{
AddChildAtEnd(icon);
}
else
{
_columnWrapper.AddChildAtEnd(icon);
}
}
else if (IconFontAwesome != IconFontAwesome.None)
{
Component icon = GetHelper().Icon(IconFontAwesome).AddCss(Css.FormControlFeedback).Component;
if (_columnWrapper == null)
{
AddChildAtEnd(icon);
}
else
{
_columnWrapper.AddChildAtEnd(icon);
}
}
}
/// <inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Insert(0, "ui");
CssClasses.Add("header");
}
/// <inheritdoc/>
protected internal override void ConstractClasses()
{
base.ConstractClasses();
CssClasses.Add(Icon.ToCssClass());
CssClasses.Add("icon");
}
