public static string GetClassForButtonSize(ButtonSize buttonSize)
{
if (buttonSize == ButtonSize.Large) return "btn-large";
if (buttonSize == ButtonSize.Small) return "btn-small";
if (buttonSize == ButtonSize.Mini) return "btn-mini";
return string.Empty;
}
internal static MvcHtmlString ButtonInternal(this HtmlHelper helper, string tagName, string text,
IDictionary <string, object> htmlAttributes,
ButtonStyles style = ButtonStyles.Default,
ButtonSize size = ButtonSize.Default,
bool block = false,
bool disabled = false,
Nullable <Glyphicons> icon = null,
bool inverted = false)
{
string className = "btn button ";
if (style != ButtonStyles.Default)
{
className += style.ToClassName("btn-");
}
if (size != ButtonSize.Default)
{
className += size.ToClassName("button-");
}
if (block)
{
className += " btn-block";
}
if (disabled)
{
htmlAttributes = htmlAttributes ?? new Dictionary <string, object>();
var key = "disabled";
className += " " + key;
if (htmlAttributes.ContainsKey(key))
{
htmlAttributes[key] = key;
}
else
{
htmlAttributes.Add(key, key);
}
}
var innerText = new StringBuilder();
innerText.Append("<span>").Append(text);
if (icon.HasValue)
{
innerText.Append(icon.Value.Render(null, inverted));
}
innerText.Append("</span>");
var buttonBuilder = new TagBuilder(tagName)
{
InnerHtml = innerText.ToString()
};
buttonBuilder.MergeAttributes(htmlAttributes);
buttonBuilder.AddCssClass(className);
return(MvcHtmlString.Create(buttonBuilder.ToString(TagRenderMode.Normal)));
}
public LenticularPropertiesCapsule(string name, string text, System.Drawing.Image image, string hint, RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base(name, text, image, hint, parent, buttonSize)
{
Values[Resources.LenticularSweepAngle] = new RibbonCommandValue(sweepAngle * 180 / Math.PI);
Values[Resources.LenticularInterlaceCount] = new RibbonCommandValue(interlaceCount);
Values[Resources.LenticularInterlaceWidth] = new RibbonCommandValue(interlaceWidth);
}
public override string GetButtonSizeCssClass(ButtonSize buttonSize)
{
if (Version == BootstrapVersion.Version2)
{
switch (buttonSize)
{
case ButtonSize.Default: return("btn");
case ButtonSize.Large: return("btn btn-large");
case ButtonSize.Small: return("btn btn-small");
case ButtonSize.ExtraSmall: return("btn btn-mini");
default:
throw new ArgumentOutOfRangeException("buttonSize");
}
}
switch (buttonSize)
{
case ButtonSize.Default: return("btn");
case ButtonSize.Large: return("btn btn-lg");
case ButtonSize.Small: return("btn btn-sm");
case ButtonSize.ExtraSmall: return("btn btn-xs");
default:
throw new ArgumentOutOfRangeException("buttonSize");
}
}
/// <summary>
/// Bootstraps the button
/// </summary>
/// <param name="htmlHelper">The HTML helper</param>
/// <param name="id">The id.</param>
/// <param name="text">The text.</param>
/// <param name="buttonType">Type of the button</param>
/// <param name="buttonSize">Size of the button</param>
/// <param name="disabled">if set to <c>true</c> [disabled].</param>
/// <param name="icon">The icon.</param>
/// <param name="inverted">if set to <c>true</c> [icon is inverted]</param>
/// <param name="isSubmit">if set to <c>true</c> [is submit]</param>
/// <returns>An MvcHtmlString</returns>
public static MvcHtmlString BootstrapButton(
this HtmlHelper htmlHelper,
string id,
string text,
ButtonType buttonType = ButtonType.@default,
ButtonSize buttonSize = ButtonSize.@default,
bool disabled = false,
Icon icon = Icon.@default,
bool inverted = false,
bool isSubmit = false)
{
var tag = new TagBuilder("button");
if (isSubmit)
{
tag.Attributes.Add("type", "submit");
}
return(ButtonBuilder(
htmlHelper,
id,
text,
string.Empty,
tag,
buttonType,
buttonSize,
disabled,
icon,
inverted));
}
public static MvcHtmlString BackButton(this HtmlHelper htmlHelper,
string icon = ButtonIcon.Null,
ButtonOption option = ButtonOption.Default,
ButtonSize size = ButtonSize.Small)
{
var a = new TagBuilder("a");
a.MergeAttribute("href", "#");
a.MergeAttribute("data-pjax", "");
a.AddCssClass("btn");
a.AddCssClass(option.Text());
a.AddCssClass(size.Text());
a.MergeAttribute("onclick", "history.go(-1)");
if (icon != ButtonIcon.Null)
{
var i = new TagBuilder("i");
i.MergeAttribute("class", string.Format("{0}", icon));
a.InnerHtml += i;
a.InnerHtml += " ";
}
a.InnerHtml += "返回";
return(MvcHtmlString.Create(a.ToString(TagRenderMode.Normal)));
}
public static MvcHtmlString Submit(this HtmlHelper htmlHelper,
string title,
object htmlAttributes,
string icon = ButtonIcon.Save,
ButtonOption option = ButtonOption.Primary,
ButtonSize size = ButtonSize.Small)
{
var button = new TagBuilder("button");
button.AddCssClass("btn");
button.AddCssClass(option.Text());
button.AddCssClass(size.Text());
button.MergeAttribute("type", "submit");
var attributes = ((IDictionary <string, object>)HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
button.MergeAttributes(attributes);
if (icon != ButtonIcon.Null)
{
var i = new TagBuilder("i");
i.MergeAttribute("class", string.Format("{0}", icon));
button.InnerHtml += i;
button.InnerHtml += " ";
}
button.InnerHtml += title;
return(MvcHtmlString.Create(button.ToString(TagRenderMode.Normal)));
}
/// <summary>
/// Changes the button to use the given size.
/// </summary>
/// <example>
/// @n.Submit("Submit").WithSize(ButtonSize.Large)
/// </example>
/// <param name="attrs">The Html Attributes from a navigation button</param>
/// <param name="size">The size of button</param>
/// <returns>The Html Attribute object so other methods can be chained off of it</returns>
public static ButtonHtmlAttributes WithSize(this ButtonHtmlAttributes attrs, ButtonSize size)
{
if (size != ButtonSize.Default)
{
attrs.AddClass(string.Format("btn-{0}", size.Humanize()));
}
return(attrs);
}
public static MvcHtmlString BootStrapSubmitButton(
this HtmlHelper html,
string text,
ButtonStyle type,
ButtonSize size)
{
return html.BootStrapSubmitButton(text, type, size, new { });
}
/// <summary>
/// Changes the button to use the given size.
/// </summary>
/// <example>
/// @n.Submit("Submit").WithSize(ButtonSize.Large)
/// </example>
/// <param name="attrs">The Html Attributes from a navigation button</param>
/// <param name="size">The size of button</param>
/// <returns>The Html Attribute object so other methods can be chained off of it</returns>
public static ButtonHtmlAttributes WithSize(this ButtonHtmlAttributes attrs, ButtonSize size)
{
if (size != ButtonSize.Default && size != ButtonSize.NoneSpecified)
{
attrs.AddClass($"btn-{size.Humanize()}");
}
return(attrs);
}
/// <summary>
/// Creates an input button tag with the given style and size.
/// </summary>
/// <param name="text">Inner text of the tag.</param>
/// <param name="buttonStyle">The button style type.</param>
/// <param name="buttonSize">The button size.</param>
/// <param name="isDisabled">
/// Make buttons look unclickable by fading them back 50%. True to
/// disable, False to enable.
/// </param>
public MvcHtmlString InputButton(string text, ButtonStyle buttonStyle, ButtonSize buttonSize, bool isDisabled)
{
var tag = CreateBaseButton("input", buttonStyle, buttonSize, isDisabled);
tag.MergeAttribute("type", "button");
tag.SetInnerText(text);
return(tag.ToMvcHtmlString());
}
protected override void Render(TagHelperContext context, TagHelperOutput output)
{
output.AddCssClass("btn");
if (!Size.Equals(ButtonSize.Normal))
{
output.AddCssClass(ButtonSize.Parse(Size));
}
}
public static MvcHtmlString BootStrapActionLink(
this HtmlHelper htmlHelper,
string linkText,
string actionName,
ButtonStyle type,
ButtonSize size)
{
return htmlHelper.BootStrapActionLink(linkText, actionName, type, size, new RouteValueDictionary());
}
/// <summary>
/// Bootstraps the button.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="id">The id.</param>
/// <param name="text">The text.</param>
/// <param name="buttonType">Type of the button.</param>
/// <param name="buttonSize">Size of the button.</param>
/// <param name="disabled">if set to <c>true</c> [disabled].</param>
/// <param name="icon">The icon.</param>
/// <param name="inverted">if set to <c>true</c> [icon is inverted].</param>
/// <param name="isSubmit">if set to <c>true</c> [is submit].</param>
/// <returns>
/// An MvcHtmlString
/// </returns>
public static MvcHtmlString BootstrapButton(this HtmlHelper htmlHelper, string id, string text, ButtonType buttonType = ButtonType.@default, ButtonSize buttonSize = ButtonSize.@default, bool disabled = false, Icon icon = Icon.@default, bool inverted = false, bool isSubmit = false)
{
var tag = new TagBuilder("button");
if (isSubmit)
{
tag.Attributes.Add("type", "submit");
}
return ButtonBuilder(htmlHelper, id, text, string.Empty, tag, buttonType, buttonSize, disabled, icon, inverted);
}
private Size GetMaximumSize(ButtonSize size)
{
switch (size)
{
case ButtonSize.Small: return(Orientation == Orientation.Horizontal ? new Size(48, 48 * 3) : new Size(48 * 3, 48));
case ButtonSize.Large: return(Orientation == Orientation.Horizontal ? new Size(80, 80 * 3) : new Size(80 * 3, 80));
}
return(Orientation == Orientation.Vertical ? new Size(64, 64 * 3) : new Size(64 * 3, 64));
}
private Size GetMinimumSize(ButtonSize size)
{
switch (size)
{
case ButtonSize.Small: return(new Size(48, 48));
case ButtonSize.Large: return(new Size(80, 80));
}
return(new Size(64, 64));
}
public void CollapseToMediumTest()
{
RadioButton target = new RadioButton(); // TODO: Initialize to an appropriate value
ButtonSize expected = new ButtonSize(); // TODO: Initialize to an appropriate value
ButtonSize actual;
target.CollapseToMedium = expected;
actual = target.CollapseToMedium;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public static MvcHtmlString Button(this HtmlHelper htmlHelper, string text,
IDictionary <string, object> htmlAttributes,
ButtonStyles style = ButtonStyles.Default,
ButtonSize size = ButtonSize.Default,
bool block = false,
bool disabled = false,
Nullable <Glyphicons> icon = null,
bool inverted = false)
{
return(ButtonInternal(htmlHelper, "button", text, htmlAttributes, style, size, block, disabled, icon, inverted));
}
public static MvcHtmlString LinkButton(this HtmlHelper htmlHelper,
string text,
string action,
ButtonStyles style = ButtonStyles.Default,
ButtonSize size = ButtonSize.Default,
bool block = false,
bool disabled = false,
Nullable <Glyphicons> icon = null,
bool inverted = false)
{
return(LinkButton(htmlHelper, text, action, null, null, null, style, size, block, disabled, icon, inverted));
}
public static MvcHtmlString BootStrapActionLink(
this HtmlHelper htmlHelper,
string linkText,
string actionName,
ButtonStyle type,
ButtonSize size,
object routeValues)
{
var actionClass = "btn " + type.GetAttribute<XmlEnumAttribute>().Name + " "
+ size.GetAttribute<XmlEnumAttribute>().Name;
return htmlHelper.ActionLink(linkText, actionName, routeValues, new { @class = actionClass });
}
/// <summary>
/// Bootstraps the link button
/// </summary>
/// <param name="htmlHelper">The Html helper.</param>
/// <param name="id">The id.</param>
/// <param name="text">The text.</param>
/// <param name="navigateTo">The navigate to.</param>
/// <param name="buttonType">Type of the button.</param>
/// <param name="buttonSize">Size of the button.</param>
/// <param name="icon">The icon</param>
/// <param name="inverted">if set to <c>true</c> [icon is inverted].</param>
/// <returns>An MvcHtmlstring</returns>
public static MvcHtmlString BootstrapLinkButton(
this HtmlHelper htmlHelper,
string id,
string text,
string navigateTo,
ButtonType buttonType = ButtonType.@default,
ButtonSize buttonSize = ButtonSize.@default,
Icon icon = Icon.@default,
bool inverted = false)
{
return(ButtonBuilder(
htmlHelper, id, text, navigateTo, new TagBuilder("a"), buttonType, buttonSize, false, icon, inverted));
}
public override string ButtonSize(ButtonSize buttonSize)
{
switch (buttonSize)
{
case Blazorise.ButtonSize.Small:
return("is-small");
case Blazorise.ButtonSize.Large:
return("is-large");
default:
return(null);
}
}
private static Tag AddCss(this Tag tag, ButtonSize size)
{
switch (size)
{
case ButtonSize.Small: tag.Css("btn-small"); break;
case ButtonSize.Large: tag.Css("btn-large"); break;
case ButtonSize.Medium:
case ButtonSize.Default:
default: break;
}
return(tag);
}
internal static ElementClassSet Class(ButtonSize size)
{
switch (size)
{
case ButtonSize.ShrinkWrap:
return(ActionComponentCssElementCreator.ShrinkWrapButtonStyleClass);
case ButtonSize.Large:
return(ActionComponentCssElementCreator.LargeButtonStyleClass);
default:
return(ActionComponentCssElementCreator.NormalButtonStyleClass);
}
}
public virtual string ButtonSize(ButtonSize buttonSize)
{
switch (buttonSize)
{
case Blazorise.ButtonSize.Small:
return("btn-sm");
case Blazorise.ButtonSize.Large:
return("btn-lg");
default:
return(null);
}
}
public override string DropdownToggleSize(ButtonSize buttonSize)
{
switch (buttonSize)
{
case Blazorise.ButtonSize.Small:
return("btn-sm");
case Blazorise.ButtonSize.Large:
return("btn-lg");
default:
return(null);
}
}
public virtual string DropdownToggleSize(ButtonSize buttonSize)
{
switch (buttonSize)
{
case Blazorise.ButtonSize.Small:
return("is-small");
case Blazorise.ButtonSize.Large:
return("is-large");
default:
return(null);
}
}
public static Tuple <int, int> Dimensions(this ButtonSize buttonSize)
{
switch (buttonSize)
{
case ButtonSize.Large:
return(Tuple.Create(180, 46));
case ButtonSize.Medium:
return(Tuple.Create(168, 44));
case ButtonSize.Small:
default:
return(Tuple.Create(160, 43));
}
}
public static string ToButtonGroupCssClass(this ButtonSize size)
{
switch (size)
{
case ButtonSize.Large:
return("btn-group-lg");
case ButtonSize.Small:
return("btn-group-sm");
case ButtonSize.ExtraSmall:
return("btn-group-xs");
}
return(string.Empty);
}
public OutlineButton(ButtonType type, ButtonSize size, params BodyElement[] content) : base(content)
{
this.Class("btn");
this.Class("btn-outline-" + type.AsKebab());
switch (size)
{
case ButtonSize.Small:
this.Class("btn-sm");
break;
case ButtonSize.Large:
this.Class("btn-lg");
break;
}
}
public override string GetButtonSizeCssClass(ButtonSize buttonSize)
{
switch (buttonSize)
{
case ButtonSize.Default: return("button");
case ButtonSize.Large: return("large button");
case ButtonSize.Small: return("small button");
case ButtonSize.ExtraSmall: return("tiny button");
default:
throw new ArgumentOutOfRangeException("buttonSize");
}
}
public static string GetClassForButtonSize(ButtonSize buttonSize)
{
if (buttonSize == ButtonSize.Large)
{
return("btn-lg");
}
if (buttonSize == ButtonSize.Small)
{
return("btn-sm");
}
if (buttonSize == ButtonSize.Mini)
{
return("btn-xs");
}
return(string.Empty);
}
public static System.Drawing.Size GetButtonSize(ButtonSize size = ButtonSize.Standard)
{
int w = 0, h = 0;
switch (size)
{
case ButtonSize.Standard:
{
w = 124;
h = 32;
}
break;
}
return(new System.Drawing.Size(w, h));;
}
/// <summary>
/// Builds a button
/// </summary>
/// <param name="htmlHelper">The HTML helper</param>
/// <param name="id">The id.</param>
/// <param name="text">The text.</param>
/// <param name="navigateTo">The navigate to.</param>
/// <param name="tag">The tag.</param>
/// <param name="buttonType">The button type</param>
/// <param name="buttonSize">The button size</param>
/// <param name="disabled">if set to <c>true</c> [disabled]</param>
/// <param name="icon">The icon.</param>
/// <param name="inverted">if set to <c>true</c> [icon is inverted]</param>
/// <returns>An MvcHtmlString</returns>
private static MvcHtmlString ButtonBuilder(
HtmlHelper htmlHelper,
string id,
string text,
string navigateTo,
TagBuilder tag,
ButtonType buttonType,
ButtonSize buttonSize,
bool disabled,
Icon icon,
bool inverted)
{
var typeCss = GetCssClass(buttonType);
var sizeCss = GetCssClass(buttonSize);
var iconHtml = htmlHelper.BootstrapIcon(icon, inverted);
if (!string.IsNullOrEmpty(typeCss))
{
tag.AddCssClass(typeCss);
}
if (!string.IsNullOrEmpty(sizeCss))
{
tag.AddCssClass(sizeCss);
}
tag.AddCssClass("btn");
if (!string.IsNullOrEmpty(id))
{
tag.Attributes.Add("id", id);
}
if (!string.IsNullOrEmpty(navigateTo))
{
tag.Attributes.Add("href", navigateTo);
}
if (disabled)
{
tag.Attributes.Add("disabled", "disabled");
tag.AddCssClass("disabled");
}
tag.InnerHtml = iconHtml + text;
return(tag.ToMvcHtmlString());
}
/// <summary>
/// Gets the CSS class
/// </summary>
/// <param name="buttonSize">size of the button</param>
/// <returns>The css class of the button size</returns>
private static string GetCssClass(ButtonSize buttonSize)
{
switch (buttonSize)
{
case ButtonSize.@default:
return(String.Empty);
case ButtonSize.large:
return("btn-large");
case ButtonSize.small:
return("btn-small");
default:
return(String.Empty);
}
}
public static string ToCssClass(this ButtonSize type)
{
switch (type)
{
case ButtonSize.Large:
return("btn-large");
case ButtonSize.Small:
return("btn-small");
case ButtonSize.Mini:
return("btn-mini");
default:
return(string.Empty);
}
}
public static string ToButtonCssClass(this ButtonSize size)
{
switch (size)
{
case ButtonSize.Large:
return("btn-lg");
case ButtonSize.Small:
return("btn-sm");
#if BOOTSTRAP3
case ButtonSize.ExtraSmall:
return("btn-xs");
#endif
}
return(string.Empty);
}
public string GoogleCheckoutButtonImage(ButtonSize size = ButtonSize.Small, ButtonStyle style = ButtonStyle.White)
{
var queryString = HttpUtility.ParseQueryString(string.Empty);
queryString.Add("merchant_id", _configuration.MerchantId);
var dimensions = size.Dimensions();
queryString.Add("w", dimensions.Item1.ToString());
queryString.Add("h", dimensions.Item2.ToString());
queryString.Add("style", style.ToString().ToLower());
queryString.Add("variant", "text");
// TODO: Introduce different locales
queryString.Add("loc", "en_GB");
return _configuration.ButtonSrc + '?' + queryString;
}
public static string GetName(ButtonSize type)
{
string result = String.Empty;
switch (type)
{
case ButtonSize.Small:
result = "small";
break;
case ButtonSize.Medium:
result = "medium";
break;
case ButtonSize.Large:
result = "large";
break;
}
return result;
}
public static MvcHtmlString BootStrapSubmitButton(
this HtmlHelper html,
string text,
ButtonStyle type,
ButtonSize size,
object routeValues)
{
var buttonClass = "btn " + type.GetAttribute<XmlEnumAttribute>().Name + " "
+ size.GetAttribute<XmlEnumAttribute>().Name;
var builder = new TagBuilder("input");
builder.Attributes.Add("type", "submit");
builder.Attributes.Add("class", buttonClass);
builder.Attributes.Add("value", text);
builder.MergeAttributes(new RouteValueDictionary(routeValues));
return MvcHtmlString.Create(builder.ToString(TagRenderMode.SelfClosing));
}
public void CollapseToSmallTest()
{
CheckBox target = new CheckBox(); // TODO: Initialize to an appropriate value
ButtonSize expected = new ButtonSize(); // TODO: Initialize to an appropriate value
ButtonSize actual;
target.CollapseToSmall = expected;
actual = target.CollapseToSmall;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public static MvcHtmlString Button(this HtmlHelper html, string text, ButtonType? type, ButtonSize? size, ButtonTag? tag)
{
return Button(html, text, type, size, tag, false, false);
}
public LenticularPlanarCommandCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("LenticularPlanar", Resources.LenticularPlanarCommandText, null, Resources.LenticularPlanarCommandHint, parent, buttonSize)
{
}
public ButtonDropDown SetSize(ButtonSize size)
{
this.Component.Button.Size = size;
return this;
}
/// <summary>
/// Creates a button action control style.
/// </summary>
/// <param name="text">Do not pass null.</param>
/// <param name="buttonSize"></param>
/// <param name="icon">The icon.</param>
public ButtonActionControlStyle( string text, ButtonSize buttonSize = ButtonSize.Normal, ActionControlIcon icon = null )
{
this.buttonSize = buttonSize;
this.icon = icon;
this.text = text;
}
public TessellateLoftButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("Loft", Resources.TessellateLoftCommandText, Resources.TessellateLoft, Resources.TessellateLoftCommandHint, parent, buttonSize)
{
Values[Resources.TessellateLoftStepSize] = new RibbonCommandValue(Settings.Default.TessellateLoftStepSize);
}
public GearButtonCapsule(string name, RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base(name, Resources.CreateGearCommandText, Resources.Gear, Resources.CreateGearCommandHint, parent, buttonSize)
{
}
public TabPropertiesButtonCapsule(string name, string text, System.Drawing.Image image, string hint, RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base(name, text, image, hint, parent, buttonSize)
{
Booleans[Resources.FlipTabsText] = new RibbonCommandBoolean(areTabsFlipped);
Booleans[Resources.StartSlotText] = new RibbonCommandBoolean(isTabStartSlot);
Values[Resources.EdgeOffsetFieldText] = new RibbonCommandValue(edgeOffset);
}
public ButtonGroupContent BeginButtonGroup(ButtonSize size)
{
return ButtonGroup().Size(size).BeginContent();
}
public ThreadButtonCapsule(string name, RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base(name, Resources.ThreadToolCommandText, Resources.Threads32, Resources.ThreadToolCommandHint, parent, buttonSize)
{
}
public TessellateButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("Tessellate", Resources.TessellateCommandText, Resources.Tessellate, Resources.TessellateCommandHint, parent, buttonSize)
{
Values[Resources.TesselateSurfaceDeviationText] = new RibbonCommandValue(Settings.Default.TessellateLinearDeviation);
Values[Resources.TesselateAngleDeviationText] = new RibbonCommandValue(Settings.Default.TessellateAngularDeviation);
}
public TessellateFoldCornerButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("FoldCorner", Resources.TessellateFoldCornerCommandText, null, Resources.TessellateFoldCornerCommandHint, parent, buttonSize)
{
}
public static MvcHtmlString Button(this HtmlHelper html, string text, ButtonType type, ButtonSize size)
{
return Button(html, text, type, size, ButtonTag.Default);
}
public MobiusButtonCapsule(string name, RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("MobiusGearRing", "Mobius", null, "Mobius", parent, buttonSize)
{
}
public MakeTabsButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("MakeTabs", Resources.MakeTabsText, null, Resources.MakeTabsHint, parent, buttonSize)
{
}
public OffsetEdgesButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("OffsetEdges", Resources.OffsetEdgesText, null, Resources.OffsetEdgesHint, parent, buttonSize)
{
}
public IWriter2<ButtonGroup, ButtonGroupContent> ButtonGroup(ButtonSize size)
{
return Context.CreateWriter<ButtonGroup, ButtonGroupContent>().Size(size);
}
public EdgeTabButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("EdgeTab", Resources.EdgeTabText, null, Resources.EdgeTabHint, parent, buttonSize)
{
}
public RibbonButtonCapsule(string name, string text, System.Drawing.Image image, string hint, RibbonCollectionCapsule parent, ButtonSize size)
: base(name, text, image, hint, parent)
{
this.size = size;
}
public CreatePoincareDiskButtonCapsule(RibbonCollectionCapsule parent, ButtonSize buttonSize)
: base("PoincareDisk", Resources.CreatePoincareDiskCommandText, null, Resources.CreatePoincareDiskCommandHint, parent, buttonSize)
{
}
