public override void Draw()
{
var tabs = Groups[queueGroup].Tabs.Where(t => t.Queue.BuildableItems().Any());
if (!tabs.Any())
{
return;
}
var rb = RenderBounds;
leftButtonRect = new Rectangle(rb.X, rb.Y, ArrowWidth, rb.Height);
rightButtonRect = new Rectangle(rb.Right - ArrowWidth, rb.Y, ArrowWidth, rb.Height);
var leftDisabled = listOffset >= 0;
var leftHover = Ui.MouseOverWidget == this && leftButtonRect.Contains(Viewport.LastMousePos);
var rightDisabled = listOffset <= Bounds.Width - rightButtonRect.Width - leftButtonRect.Width - contentWidth;
var rightHover = Ui.MouseOverWidget == this && rightButtonRect.Contains(Viewport.LastMousePos);
WidgetUtils.DrawPanel(Background, rb);
ButtonWidget.DrawBackground(Button, leftButtonRect, leftDisabled, leftPressed, leftHover, false);
ButtonWidget.DrawBackground(Button, rightButtonRect, rightDisabled, rightPressed, rightHover, false);
var leftArrowImageName = WidgetUtils.GetStatefulImageName(DecorationScrollLeft, leftDisabled, leftPressed, leftHover);
var leftArrowImage = ChromeProvider.GetImage(Decorations, leftArrowImageName) ?? ChromeProvider.GetImage(Decorations, DecorationScrollLeft);
WidgetUtils.DrawRGBA(leftArrowImage,
new float2(leftButtonRect.Left + 2, leftButtonRect.Top + 2));
var rightArrowImageName = WidgetUtils.GetStatefulImageName(DecorationScrollRight, rightDisabled, rightPressed, rightHover);
var rightArrowImage = ChromeProvider.GetImage(Decorations, rightArrowImageName) ?? ChromeProvider.GetImage(Decorations, DecorationScrollRight);
WidgetUtils.DrawRGBA(rightArrowImage,
new float2(rightButtonRect.Left + 2, rightButtonRect.Top + 2));
// Draw tab buttons
Game.Renderer.EnableScissor(new Rectangle(leftButtonRect.Right, rb.Y + 1, rightButtonRect.Left - leftButtonRect.Right - 1, rb.Height));
var origin = new int2(leftButtonRect.Right - 1 + (int)listOffset, leftButtonRect.Y);
var font = Game.Renderer.Fonts["TinyBold"];
contentWidth = 0;
foreach (var tab in tabs)
{
var rect = new Rectangle(origin.X + contentWidth, origin.Y, TabWidth, rb.Height);
var hover = !leftHover && !rightHover && Ui.MouseOverWidget == this && rect.Contains(Viewport.LastMousePos);
var highlighted = tab.Queue == CurrentQueue;
ButtonWidget.DrawBackground(Button, rect, false, false, hover, highlighted);
contentWidth += TabWidth - 1;
var textSize = font.Measure(tab.Name);
var position = new int2(rect.X + (rect.Width - textSize.X) / 2, rect.Y + (rect.Height - textSize.Y) / 2);
font.DrawTextWithContrast(tab.Name, position, tab.Queue.AllQueued().Any(i => i.Done) ? Color.Gold : Color.White, Color.Black, 1);
}
Game.Renderer.DisableScissor();
}
public static void DrawBackground(string baseName, Rectangle rect, bool disabled, bool pressed, bool hover, bool highlighted)
{
if (string.IsNullOrEmpty(baseName))
{
return;
}
var variantName = highlighted ? baseName + "-highlighted" : baseName;
var imageName = WidgetUtils.GetStatefulImageName(variantName, disabled, pressed, hover);
WidgetUtils.DrawPanel(imageName, rect);
}
public override void Draw()
{
var disabled = IsDisabled();
var font = Game.Renderer.Fonts[Font];
var color = GetColor();
var colordisabled = GetColorDisabled();
var bgDark = GetContrastColorDark();
var bgLight = GetContrastColorLight();
var rect = RenderBounds;
var text = GetText();
var textSize = font.Measure(text);
var check = new Rectangle(rect.Location, new Size(Bounds.Height, Bounds.Height));
var baseName = IsHighlighted() ? "checkbox-highlighted" : "checkbox";
var state = WidgetUtils.GetStatefulImageName(baseName, disabled, Depressed && HasPressedState, Ui.MouseOverWidget == this);
WidgetUtils.DrawPanel(state, check);
var topOffset = font.TopOffset;
var position = new float2(rect.Left + rect.Height * 1.5f, RenderOrigin.Y + (Bounds.Height - textSize.Y - topOffset) / 2);
if (Contrast)
{
font.DrawTextWithContrast(text, position,
disabled ? colordisabled : color, bgDark, bgLight, 2);
}
else
{
font.DrawText(text, position,
disabled ? colordisabled : color);
}
if (IsChecked() || (Depressed && HasPressedState && !disabled))
{
var checkType = GetCheckType();
if (HasPressedState && (Depressed || disabled))
{
checkType += "-disabled";
}
var offset = new float2(rect.Left + CheckOffset, rect.Top + CheckOffset);
WidgetUtils.DrawSprite(ChromeProvider.GetImage("checkbox-bits", checkType), offset);
}
}
public override void Draw()
{
var apparentText = Key.DisplayString();
var font = Game.Renderer.Fonts[Font];
var pos = RenderOrigin;
var textSize = font.Measure(apparentText);
var disabled = IsDisabled();
var valid = IsValid();
var state = WidgetUtils.GetStatefulImageName("textfield", disabled, false, Ui.MouseOverWidget == this, HasKeyboardFocus);
WidgetUtils.DrawPanel(state, RenderBounds);
// Blink the current entry to indicate focus
if (HasKeyboardFocus && !showEntry)
{
return;
}
// Inset text by the margin and center vertically
var textPos = pos + new int2(LeftMargin, (Bounds.Height - textSize.Y) / 2 - VisualHeight);
// Scissor when the text overflows
var isTextOverflowing = textSize.X > Bounds.Width - LeftMargin - RightMargin;
if (isTextOverflowing)
{
Game.Renderer.EnableScissor(new Rectangle(pos.X + LeftMargin, pos.Y,
Bounds.Width - LeftMargin - RightMargin, Bounds.Bottom));
}
var color = disabled ? TextColorDisabled : !valid ? TextColorInvalid : TextColor;
font.DrawText(apparentText, textPos, color);
if (isTextOverflowing)
{
Game.Renderer.DisableScissor();
}
}
public override void Draw()
{
base.Draw();
var stateOffset = Depressed ? new int2(VisualHeight, VisualHeight) : new int2(0, 0);
var rb = RenderBounds;
var isDisabled = IsDisabled();
var isHover = Ui.MouseOverWidget == this || Children.Any(c => c == Ui.MouseOverWidget);
var markerImageName = WidgetUtils.GetStatefulImageName(DecorationMarker, isDisabled, Depressed, isHover);
var arrowImage = ChromeProvider.GetImage(Decorations, markerImageName) ?? ChromeProvider.GetImage(Decorations, DecorationMarker);
WidgetUtils.DrawRGBA(arrowImage, stateOffset + new float2(rb.Right - (int)((rb.Height + arrowImage.Size.X) / 2), rb.Top + (int)((rb.Height - arrowImage.Size.Y) / 2)));
var separatorImageName = WidgetUtils.GetStatefulImageName(SeparatorImage, isDisabled, Depressed, isHover);
var separatorImage = ChromeProvider.GetImage(Separators, separatorImageName) ?? ChromeProvider.GetImage(Separators, SeparatorImage);
if (separatorImage != null)
{
WidgetUtils.DrawRGBA(separatorImage, stateOffset + new float2(-3, 0) + new float2(rb.Right - rb.Height + 4, rb.Top + (int)((rb.Height - separatorImage.Size.Y) / 2)));
}
}
public override void DrawOuter()
{
if (!IsVisible())
{
return;
}
UpdateSmoothScrolling();
var rb = RenderBounds;
var scrollbarHeight = rb.Height - 2 * ScrollbarWidth;
// Scroll thumb is only visible if the content does not fit within the panel bounds
var thumbHeight = 0;
var thumbOrigin = rb.Y + ScrollbarWidth;
if (ContentHeight > rb.Height)
{
thumbHeight = Math.Max(MinimumThumbSize, scrollbarHeight * rb.Height / ContentHeight);
thumbOrigin += (int)((scrollbarHeight - thumbHeight) * currentListOffset / (rb.Height - ContentHeight));
}
switch (ScrollBar)
{
case ScrollBar.Left:
backgroundRect = new Rectangle(rb.X + ScrollbarWidth, rb.Y, rb.Width + 1, rb.Height);
upButtonRect = new Rectangle(rb.X, rb.Y, ScrollbarWidth, ScrollbarWidth);
downButtonRect = new Rectangle(rb.X, rb.Bottom - ScrollbarWidth, ScrollbarWidth, ScrollbarWidth);
scrollbarRect = new Rectangle(rb.X, rb.Y + ScrollbarWidth - 1, ScrollbarWidth, scrollbarHeight + 2);
thumbRect = new Rectangle(rb.X, thumbOrigin, ScrollbarWidth, thumbHeight);
break;
case ScrollBar.Right:
backgroundRect = new Rectangle(rb.X, rb.Y, rb.Width - ScrollbarWidth + 1, rb.Height);
upButtonRect = new Rectangle(rb.Right - ScrollbarWidth, rb.Y, ScrollbarWidth, ScrollbarWidth);
downButtonRect = new Rectangle(rb.Right - ScrollbarWidth, rb.Bottom - ScrollbarWidth, ScrollbarWidth, ScrollbarWidth);
scrollbarRect = new Rectangle(rb.Right - ScrollbarWidth, rb.Y + ScrollbarWidth - 1, ScrollbarWidth, scrollbarHeight + 2);
thumbRect = new Rectangle(rb.Right - ScrollbarWidth, thumbOrigin, ScrollbarWidth, thumbHeight);
break;
case ScrollBar.Hidden:
backgroundRect = new Rectangle(rb.X, rb.Y, rb.Width + 1, rb.Height);
break;
default:
throw new ArgumentOutOfRangeException();
}
WidgetUtils.DrawPanel(Background, backgroundRect);
if (ScrollBar != ScrollBar.Hidden)
{
var upHover = Ui.MouseOverWidget == this && upButtonRect.Contains(Viewport.LastMousePos);
upDisabled = thumbHeight == 0 || currentListOffset >= 0;
var downHover = Ui.MouseOverWidget == this && downButtonRect.Contains(Viewport.LastMousePos);
downDisabled = thumbHeight == 0 || currentListOffset <= Bounds.Height - ContentHeight;
var thumbHover = Ui.MouseOverWidget == this && thumbRect.Contains(Viewport.LastMousePos);
WidgetUtils.DrawPanel(ScrollBarBackground, scrollbarRect);
ButtonWidget.DrawBackground(Button, upButtonRect, upDisabled, upPressed, upHover, false);
ButtonWidget.DrawBackground(Button, downButtonRect, downDisabled, downPressed, downHover, false);
if (thumbHeight > 0)
{
ButtonWidget.DrawBackground(Button, thumbRect, false, HasMouseFocus && thumbHover, thumbHover, false);
}
var upOffset = !upPressed || upDisabled ? 4 : 4 + ButtonDepth;
var downOffset = !downPressed || downDisabled ? 4 : 4 + ButtonDepth;
var upArrowImageName = WidgetUtils.GetStatefulImageName(DecorationScrollUp, upDisabled, upPressed, upHover);
var upArrowImage = ChromeProvider.GetImage(Decorations, upArrowImageName) ?? ChromeProvider.GetImage(Decorations, DecorationScrollUp);
WidgetUtils.DrawRGBA(upArrowImage,
new float2(upButtonRect.Left + upOffset, upButtonRect.Top + upOffset));
var downArrowImageName = WidgetUtils.GetStatefulImageName(DecorationScrollDown, downDisabled, downPressed, downHover);
var downArrowImage = ChromeProvider.GetImage(Decorations, downArrowImageName) ?? ChromeProvider.GetImage(Decorations, DecorationScrollDown);
WidgetUtils.DrawRGBA(downArrowImage,
new float2(downButtonRect.Left + downOffset, downButtonRect.Top + downOffset));
}
var drawBounds = backgroundRect.InflateBy(-BorderWidth, -BorderWidth, -BorderWidth, -BorderWidth);
Game.Renderer.EnableScissor(drawBounds);
// ChildOrigin enumerates the widget tree, so only evaluate it once
var co = ChildOrigin;
drawBounds.X -= co.X;
drawBounds.Y -= co.Y;
foreach (var child in Children)
{
if (child.Bounds.IntersectsWith(drawBounds))
{
child.DrawOuter();
}
}
Game.Renderer.DisableScissor();
}
public override void Draw()
{
var apparentText = GetApparentText();
var font = Game.Renderer.Fonts[Font];
var pos = RenderOrigin;
var textSize = font.Measure(apparentText);
var cursorPosition = font.Measure(apparentText.Substring(0, CursorPosition));
var disabled = IsDisabled();
var hover = Ui.MouseOverWidget == this || Children.Any(c => c == Ui.MouseOverWidget);
var state = WidgetUtils.GetStatefulImageName("textfield", disabled, false, hover, HasKeyboardFocus);
WidgetUtils.DrawPanel(state,
new Rectangle(pos.X, pos.Y, Bounds.Width, Bounds.Height));
// Inset text by the margin and center vertically
var verticalMargin = (Bounds.Height - textSize.Y) / 2 - VisualHeight;
var textPos = pos + new int2(LeftMargin, verticalMargin);
// Right align when editing and scissor when the text overflows
var isTextOverflowing = textSize.X > Bounds.Width - LeftMargin - RightMargin;
if (isTextOverflowing)
{
if (HasKeyboardFocus)
{
textPos += new int2(Bounds.Width - LeftMargin - RightMargin - textSize.X, 0);
}
Game.Renderer.EnableScissor(new Rectangle(pos.X + LeftMargin, pos.Y,
Bounds.Width - LeftMargin - RightMargin, Bounds.Bottom));
}
// Draw the highlight around the selected area
if (selectionStartIndex != -1)
{
var visualSelectionStartIndex = selectionStartIndex < selectionEndIndex ? selectionStartIndex : selectionEndIndex;
var visualSelectionEndIndex = selectionStartIndex < selectionEndIndex ? selectionEndIndex : selectionStartIndex;
var highlightStartX = font.Measure(apparentText.Substring(0, visualSelectionStartIndex)).X;
var highlightEndX = font.Measure(apparentText.Substring(0, visualSelectionEndIndex)).X;
WidgetUtils.FillRectWithColor(
new Rectangle(textPos.X + highlightStartX, textPos.Y, highlightEndX - highlightStartX, Bounds.Height - (verticalMargin * 2)), TextColorHighlight);
}
var color =
disabled ? TextColorDisabled
: IsValid() ? TextColor
: TextColorInvalid;
font.DrawText(apparentText, textPos, color);
if (showCursor && HasKeyboardFocus)
{
font.DrawText("|", new float2(textPos.X + cursorPosition.X - 2, textPos.Y), TextColor);
}
if (isTextOverflowing)
{
Game.Renderer.DisableScissor();
}
}
public static void BindButtonIcon(ButtonWidget button)
{
var icon = button.Get <ImageWidget>("ICON");
var hasActiveImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-active") != null;
var hasActiveDisabledImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-active-disabled") != null;
var hasActivePressedImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-active-pressed") != null;
var hasActiveHoverImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-active-hover") != null;
var hasImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName) != null;
var hasDisabledImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-disabled") != null;
var hasPressedImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-pressed") != null;
var hasHoverImage = ChromeProvider.GetImage(icon.ImageCollection, icon.ImageName + "-hover") != null;
icon.GetImageName = () =>
{
var isActive = button.IsHighlighted();
var isDisabled = button.IsDisabled();
var isPressed = button.Depressed;
var isHovered = Ui.MouseOverWidget == button;
var baseName = button.IsHighlighted() ? icon.ImageName + "-active" : icon.ImageName;
var stateName = WidgetUtils.GetStatefulImageName(baseName, isDisabled, isPressed, isHovered);
if (isActive)
{
if (isDisabled)
{
return(hasActiveDisabledImage ? stateName : hasActiveImage?baseName : icon.ImageName);
}
else if (isPressed)
{
return(hasActivePressedImage ? stateName : hasActiveImage?baseName : icon.ImageName);
}
else if (isHovered)
{
return(hasActiveHoverImage ? stateName : hasActiveImage?baseName : icon.ImageName);
}
else
{
return(hasActiveImage ? baseName : icon.ImageName);
}
}
else
{
if (isDisabled)
{
return(hasDisabledImage ? stateName : baseName);
}
else if (isPressed)
{
return(hasPressedImage ? stateName : baseName);
}
else if (isHovered)
{
return(hasHoverImage ? stateName : baseName);
}
else
{
return(baseName);
}
}
};
}
