From 04fe933f4c24817100f3101f088accf55a621f8a Mon Sep 17 00:00:00 2001 From: isxander Date: Thu, 11 Apr 2024 18:43:06 +0100 Subject: Extremely fragile and broken multiversion build with stonecutter --- .../yacl3/gui/controllers/ActionController.java | 120 ++++++ .../yacl3/gui/controllers/BooleanController.java | 164 ++++++++ .../yacl3/gui/controllers/ColorController.java | 220 ++++++++++ .../yacl3/gui/controllers/ControllerWidget.java | 148 +++++++ .../yacl3/gui/controllers/LabelController.java | 193 +++++++++ .../yacl3/gui/controllers/ListEntryWidget.java | 128 ++++++ .../yacl3/gui/controllers/TickBoxController.java | 119 ++++++ .../cycling/CyclingControllerElement.java | 60 +++ .../controllers/cycling/CyclingListController.java | 86 ++++ .../gui/controllers/cycling/EnumController.java | 48 +++ .../controllers/cycling/ICyclingController.java | 38 ++ .../dropdown/AbstractDropdownController.java | 87 ++++ .../AbstractDropdownControllerElement.java | 248 +++++++++++ .../dropdown/DropdownStringController.java | 34 ++ .../dropdown/DropdownStringControllerElement.java | 31 ++ .../dropdown/EnumDropdownController.java | 92 ++++ .../dropdown/EnumDropdownControllerElement.java | 25 ++ .../gui/controllers/dropdown/ItemController.java | 68 +++ .../dropdown/ItemControllerElement.java | 87 ++++ .../yacl3/gui/controllers/package-info.java | 12 + .../controllers/slider/DoubleSliderController.java | 119 ++++++ .../controllers/slider/FloatSliderController.java | 119 ++++++ .../gui/controllers/slider/ISliderController.java | 54 +++ .../slider/IntegerSliderController.java | 116 +++++ .../controllers/slider/LongSliderController.java | 116 +++++ .../slider/SliderControllerElement.java | 157 +++++++ .../yacl3/gui/controllers/slider/package-info.java | 10 + .../gui/controllers/string/IStringController.java | 44 ++ .../gui/controllers/string/StringController.java | 37 ++ .../string/StringControllerElement.java | 466 +++++++++++++++++++++ .../string/number/DoubleFieldController.java | 111 +++++ .../string/number/FloatFieldController.java | 111 +++++ .../string/number/IntegerFieldController.java | 111 +++++ .../string/number/LongFieldController.java | 111 +++++ .../string/number/NumberFieldController.java | 80 ++++ .../controllers/string/number/package-info.java | 10 + 36 files changed, 3780 insertions(+) create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/DropdownStringController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/DropdownStringControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/EnumDropdownController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/EnumDropdownControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/ItemController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/ItemControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/package-info.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/DoubleSliderController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/FloatSliderController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/ISliderController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/IntegerSliderController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/LongSliderController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/SliderControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/slider/package-info.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/IStringController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/StringController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/StringControllerElement.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/number/DoubleFieldController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/number/FloatFieldController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/number/IntegerFieldController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/number/LongFieldController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/number/NumberFieldController.java create mode 100644 src/main/java/dev/isxander/yacl3/gui/controllers/string/number/package-info.java (limited to 'src/main/java/dev/isxander/yacl3/gui/controllers') diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java new file mode 100644 index 0000000..77938f6 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/ActionController.java @@ -0,0 +1,120 @@ +package dev.isxander.yacl3.gui.controllers; + +import com.mojang.blaze3d.platform.InputConstants; +import dev.isxander.yacl3.api.ButtonOption; +import dev.isxander.yacl3.api.Controller; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import net.minecraft.network.chat.Component; + +import java.util.function.BiConsumer; + +/** + * Simple controller that simply runs the button action on press + * and renders a {@link} Text on the right. + */ +public class ActionController implements Controller> { + public static final Component DEFAULT_TEXT = Component.translatable("yacl.control.action.execute"); + + private final ButtonOption option; + private final Component text; + + /** + * Constructs an action controller + * with the default formatter of {@link ActionController#DEFAULT_TEXT} + * + * @param option bound option + */ + public ActionController(ButtonOption option) { + this(option, DEFAULT_TEXT); + } + + /** + * Constructs an action controller + * + * @param option bound option + * @param text text to display + */ + public ActionController(ButtonOption option, Component text) { + this.option = option; + this.text = text; + + } + + /** + * {@inheritDoc} + */ + @Override + public ButtonOption option() { + return option; + } + + /** + * {@inheritDoc} + */ + @Override + public Component formatValue() { + return text; + } + + /** + * {@inheritDoc} + */ + @Override + public AbstractWidget provideWidget(YACLScreen screen, Dimension widgetDimension) { + return new ActionControllerElement(this, screen, widgetDimension); + } + + public static class ActionControllerElement extends ControllerWidget { + private final String buttonString; + + public ActionControllerElement(ActionController control, YACLScreen screen, Dimension dim) { + super(control, screen, dim); + buttonString = control.formatValue().getString().toLowerCase(); + } + + public void executeAction() { + playDownSound(); + control.option().action().accept(screen, control.option()); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (isMouseOver(mouseX, mouseY) && isAvailable()) { + executeAction(); + return true; + } + return false; + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (!focused) { + return false; + } + + if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_SPACE || keyCode == InputConstants.KEY_NUMPADENTER) { + executeAction(); + return true; + } + + return false; + } + + @Override + protected int getHoveredControlWidth() { + return getUnhoveredControlWidth(); + } + + @Override + public boolean canReset() { + return false; + } + + @Override + public boolean matchesSearch(String query) { + return super.matchesSearch(query) || buttonString.contains(query); + } + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java new file mode 100644 index 0000000..cbd6ba5 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/BooleanController.java @@ -0,0 +1,164 @@ +package dev.isxander.yacl3.gui.controllers; + +import com.mojang.blaze3d.platform.InputConstants; +import dev.isxander.yacl3.api.Controller; +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.api.controller.ValueFormatter; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import net.minecraft.ChatFormatting; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.network.chat.CommonComponents; +import net.minecraft.network.chat.Component; +import org.jetbrains.annotations.ApiStatus; + +import java.util.function.Function; + +/** + * This controller renders a simple formatted {@link Component} + */ +public class BooleanController implements Controller { + + public static final Function ON_OFF_FORMATTER = (state) -> + state + ? CommonComponents.OPTION_ON + : CommonComponents.OPTION_OFF; + + public static final Function TRUE_FALSE_FORMATTER = (state) -> + state + ? Component.translatable("yacl.control.boolean.true") + : Component.translatable("yacl.control.boolean.false"); + + public static final Function YES_NO_FORMATTER = (state) -> + state + ? CommonComponents.GUI_YES + : CommonComponents.GUI_NO; + + private final Option option; + private final ValueFormatter valueFormatter; + private final boolean coloured; + + /** + * Constructs a tickbox controller + * with the default value formatter of {@link BooleanController#ON_OFF_FORMATTER} + * + * @param option bound option + */ + public BooleanController(Option option) { + this(option, ON_OFF_FORMATTER, false); + } + + /** + * Constructs a tickbox controller + * with the default value formatter of {@link BooleanController#ON_OFF_FORMATTER} + * + * @param option bound option + * @param coloured value format is green or red depending on the state + */ + public BooleanController(Option option, boolean coloured) { + this(option, ON_OFF_FORMATTER, coloured); + } + + /** + * Constructs a tickbox controller + * + * @param option bound option + * @param valueFormatter format value into any {@link Component} + * @param coloured value format is green or red depending on the state + */ + public BooleanController(Option option, Function valueFormatter, boolean coloured) { + this.option = option; + this.valueFormatter = valueFormatter::apply; + this.coloured = coloured; + } + + @ApiStatus.Internal + public static BooleanController createInternal(Option option, ValueFormatter formatter, boolean coloured) { + return new BooleanController(option, formatter::format, coloured); + } + + /** + * {@inheritDoc} + */ + @Override + public Option option() { + return option; + } + + /** + * {@inheritDoc} + */ + @Override + public Component formatValue() { + return valueFormatter.format(option().pendingValue()); + } + + /** + * Value format is green or red depending on the state + */ + public boolean coloured() { + return coloured; + } + + /** + * {@inheritDoc} + */ + @Override + public AbstractWidget provideWidget(YACLScreen screen, Dimension widgetDimension) { + return new BooleanControllerElement(this, screen, widgetDimension); + } + + public static class BooleanControllerElement extends ControllerWidget { + public BooleanControllerElement(BooleanController control, YACLScreen screen, Dimension dim) { + super(control, screen, dim); + } + + @Override + protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (!isMouseOver(mouseX, mouseY) || !isAvailable()) + return false; + + toggleSetting(); + return true; + } + + @Override + protected int getHoveredControlWidth() { + return getUnhoveredControlWidth(); + } + + public void toggleSetting() { + control.option().requestSet(!control.option().pendingValue()); + playDownSound(); + } + + @Override + protected Component getValueText() { + if (control.coloured()) { + return super.getValueText().copy().withStyle(control.option().pendingValue() ? ChatFormatting.GREEN : ChatFormatting.RED); + } + + return super.getValueText(); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (!isFocused()) { + return false; + } + + if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_SPACE || keyCode == InputConstants.KEY_NUMPADENTER) { + toggleSetting(); + return true; + } + + return false; + } + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java new file mode 100644 index 0000000..56e6d30 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/ColorController.java @@ -0,0 +1,220 @@ +package dev.isxander.yacl3.gui.controllers; + +import com.google.common.collect.ImmutableList; +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.api.utils.MutableDimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import dev.isxander.yacl3.gui.controllers.string.IStringController; +import dev.isxander.yacl3.gui.controllers.string.StringControllerElement; +import net.minecraft.ChatFormatting; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.MutableComponent; + +import java.awt.*; +import java.util.List; + +/** + * A color controller that uses a hex color field as input. + */ +public class ColorController implements IStringController { + private final Option option; + private final boolean allowAlpha; + + /** + * Constructs a color controller with {@link ColorController#allowAlpha()} defaulting to false + * + * @param option bound option + */ + public ColorController(Option option) { + this(option, false); + } + + /** + * Constructs a color controller + * + * @param option bound option + * @param allowAlpha allows the color input to accept alpha values + */ + public ColorController(Option option, boolean allowAlpha) { + this.option = option; + this.allowAlpha = allowAlpha; + } + + /** + * {@inheritDoc} + */ + @Override + public Option option() { + return option; + } + + public boolean allowAlpha() { + return allowAlpha; + } + + @Override + public String getString() { + return formatValue().getString(); + } + + @Override + public Component formatValue() { + MutableComponent text = Component.literal("#"); + text.append(Component.literal(toHex(option().pendingValue().getRed())).withStyle(ChatFormatting.RED)); + text.append(Component.literal(toHex(option().pendingValue().getGreen())).withStyle(ChatFormatting.GREEN)); + text.append(Component.literal(toHex(option().pendingValue().getBlue())).withStyle(ChatFormatting.BLUE)); + if (allowAlpha()) text.append(toHex(option().pendingValue().getAlpha())); + return text; + } + + private String toHex(int value) { + String hex = Integer.toString(value, 16).toUpperCase(); + if (hex.length() == 1) + hex = "0" + hex; + return hex; + } + + @Override + public void setFromString(String value) { + if (value.startsWith("#")) + value = value.substring(1); + + int red = Integer.parseInt(value.substring(0, 2), 16); + int green = Integer.parseInt(value.substring(2, 4), 16); + int blue = Integer.parseInt(value.substring(4, 6), 16); + + if (allowAlpha()) { + int alpha = Integer.parseInt(value.substring(6, 8), 16); + option().requestSet(new Color(red, green, blue, alpha)); + } else { + option().requestSet(new Color(red, green, blue)); + } + } + + @Override + public AbstractWidget provideWidget(YACLScreen screen, Dimension widgetDimension) { + return new ColorControllerElement(this, screen, widgetDimension); + } + + public static class ColorControllerElement extends StringControllerElement { + private final ColorController colorController; + + protected MutableDimension colorPreviewDim; + + private final List allowedChars; + + public ColorControllerElement(ColorController control, YACLScreen screen, Dimension dim) { + super(control, screen, dim, true); + this.colorController = control; + this.allowedChars = ImmutableList.of('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'); + } + + @Override + protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + if (isHovered()) { + colorPreviewDim.move(-inputFieldBounds.width() - 5, 0); + super.drawValueText(graphics, mouseX, mouseY, delta); + } + + graphics.fill(colorPreviewDim.x(), colorPreviewDim.y(), colorPreviewDim.xLimit(), colorPreviewDim.yLimit(), colorController.option().pendingValue().getRGB()); + drawOutline(graphics, colorPreviewDim.x(), colorPreviewDim.y(), colorPreviewDim.xLimit(), colorPreviewDim.yLimit(), 1, 0xFF000000); + } + + @Override + public void write(String string) { + if (string.startsWith("0x")) string = string.substring(2); + for (char chr : string.toCharArray()) { + if (!allowedChars.contains(Character.toLowerCase(chr))) { + return; + } + } + + if (caretPos == 0) + return; + + String trimmed = string.substring(0, Math.min(inputField.length() - caretPos, string.length())); + + if (modifyInput(builder -> builder.replace(caretPos, caretPos + trimmed.length(), trimmed))) { + caretPos += trimmed.length(); + setSelectionLength(); + updateControl(); + } + } + + @Override + protected void doBackspace() { + if (caretPos > 1) { + if (modifyInput(builder -> builder.setCharAt(caretPos - 1, '0'))) { + caretPos--; + updateControl(); + } + } + } + + @Override + protected void doDelete() { + if (caretPos >= 1) { + if (modifyInput(builder -> builder.setCharAt(caretPos, '0'))) { + updateControl(); + } + } + } + + @Override + protected boolean doCut() { + return false; + } + + @Override + protected boolean doCopy() { + return false; + } + + @Override + protected boolean doSelectAll() { + return false; + } + + protected void setSelectionLength() { + selectionLength = caretPos < inputField.length() && caretPos > 0 ? 1 : 0; + } + + @Override + protected int getDefaultCaretPos() { + return colorController.allowAlpha() ? 3 : 1; + } + + @Override + public void setDimension(Dimension dim) { + super.setDimension(dim); + + int previewSize = (dim.height() - getYPadding() * 2) / 2; + colorPreviewDim = Dimension.ofInt(dim.xLimit() - getXPadding() - previewSize, dim.centerY() - previewSize / 2, previewSize, previewSize); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + int prevSelectionLength = selectionLength; + selectionLength = 0; + if (super.keyPressed(keyCode, scanCode, modifiers)) { + caretPos = Math.max(1, caretPos); + setSelectionLength(); + return true; + } else selectionLength = prevSelectionLength; + return false; + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (super.mouseClicked(mouseX, mouseY, button)) { + caretPos = Math.max(1, caretPos); + setSelectionLength(); + return true; + } + return false; + } + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java b/src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java new file mode 100644 index 0000000..19fe2f6 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/ControllerWidget.java @@ -0,0 +1,148 @@ +package dev.isxander.yacl3.gui.controllers; + +import dev.isxander.yacl3.api.Controller; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import dev.isxander.yacl3.gui.utils.GuiUtils; +import net.minecraft.ChatFormatting; +import net.minecraft.client.gui.ComponentPath; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.gui.components.MultiLineLabel; +import net.minecraft.client.gui.narration.NarratedElementType; +import net.minecraft.client.gui.narration.NarrationElementOutput; +import net.minecraft.client.gui.navigation.FocusNavigationEvent; +import net.minecraft.network.chat.Component; +import org.jetbrains.annotations.Nullable; + +public abstract class ControllerWidget> extends AbstractWidget { + protected final T control; + protected MultiLineLabel wrappedTooltip; + protected final YACLScreen screen; + + protected boolean focused = false; + protected boolean hovered = false; + + protected final Component modifiedOptionName; + protected final String optionNameString; + + public ControllerWidget(T control, YACLScreen screen, Dimension dim) { + super(dim); + this.control = control; + this.screen = screen; + control.option().addListener((opt, pending) -> updateTooltip()); + updateTooltip(); + this.modifiedOptionName = control.option().name().copy().withStyle(ChatFormatting.ITALIC); + this.optionNameString = control.option().name().getString().toLowerCase(); + } + + @Override + public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + hovered = isMouseOver(mouseX, mouseY); + + Component name = control.option().changed() ? modifiedOptionName : control.option().name(); + Component shortenedName = Component.literal(GuiUtils.shortenString(name.getString(), textRenderer, getDimension().width() - getControlWidth() - getXPadding() - 7, "...")).setStyle(name.getStyle()); + + drawButtonRect(graphics, getDimension().x(), getDimension().y(), getDimension().xLimit(), getDimension().yLimit(), hovered || focused, isAvailable()); + graphics.drawString(textRenderer, shortenedName, getDimension().x() + getXPadding(), getTextY(), getValueColor(), true); + + + drawValueText(graphics, mouseX, mouseY, delta); + if (isHovered()) { + drawHoveredControl(graphics, mouseX, mouseY, delta); + } + } + + protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + + } + + protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + Component valueText = getValueText(); + graphics.drawString(textRenderer, valueText, getDimension().xLimit() - textRenderer.width(valueText) - getXPadding(), getTextY(), getValueColor(), true); + } + + private void updateTooltip() { + this.wrappedTooltip = MultiLineLabel.create(textRenderer, control.option().tooltip(), screen.width / 3 * 2 - 10); + } + + protected int getControlWidth() { + return isHovered() ? getHoveredControlWidth() : getUnhoveredControlWidth(); + } + + public boolean isHovered() { + return isAvailable() && (hovered || focused); + } + + protected abstract int getHoveredControlWidth(); + + protected int getUnhoveredControlWidth() { + return textRenderer.width(getValueText()); + } + + protected int getXPadding() { + return 5; + } + + protected int getYPadding() { + return 2; + } + + protected Component getValueText() { + return control.formatValue(); + } + + protected boolean isAvailable() { + return control.option().available(); + } + + protected int getValueColor() { + return isAvailable() ? -1 : inactiveColor; + } + + @Override + public boolean canReset() { + return true; + } + + protected int getTextY() { + return (int)(getDimension().y() + getDimension().height() / 2f - textRenderer.lineHeight / 2f); + } + + @Nullable + @Override + public ComponentPath nextFocusPath(FocusNavigationEvent focusNavigationEvent) { + return !this.isFocused() ? ComponentPath.leaf(this) : null; + } + + @Override + public boolean isFocused() { + return focused; + } + + @Override + public void setFocused(boolean focused) { + this.focused = focused; + } + + @Override + public void unfocus() { + this.focused = false; + } + + @Override + public boolean matchesSearch(String query) { + return optionNameString.contains(query.toLowerCase()); + } + + @Override + public NarrationPriority narrationPriority() { + return focused ? NarrationPriority.FOCUSED : isHovered() ? NarrationPriority.HOVERED : NarrationPriority.NONE; + } + + @Override + public void updateNarration(NarrationElementOutput builder) { + builder.add(NarratedElementType.TITLE, control.option().name()); + builder.add(NarratedElementType.HINT, control.option().tooltip()); + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java new file mode 100644 index 0000000..fee6c19 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/LabelController.java @@ -0,0 +1,193 @@ +package dev.isxander.yacl3.gui.controllers; + +import dev.isxander.yacl3.api.Controller; +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import net.minecraft.client.gui.ComponentPath; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.gui.components.MultiLineLabel; +import net.minecraft.client.gui.narration.NarratedElementType; +import net.minecraft.client.gui.narration.NarrationElementOutput; +import net.minecraft.client.gui.navigation.FocusNavigationEvent; +import net.minecraft.client.gui.screens.Screen; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.HoverEvent; +import net.minecraft.network.chat.Style; +import net.minecraft.util.FormattedCharSequence; +import net.minecraft.world.item.ItemStack; +import org.jetbrains.annotations.Nullable; + +import java.util.List; + +/** + * Simply renders some text as a label. + */ +public class LabelController implements Controller { + private final Option option; + /** + * Constructs a label controller + * + * @param option bound option + */ + public LabelController(Option option) { + this.option = option; + } + + /** + * {@inheritDoc} + */ + @Override + public Option option() { + return option; + } + + @Override + public Component formatValue() { + return option().pendingValue(); + } + + @Override + public AbstractWidget provideWidget(YACLScreen screen, Dimension widgetDimension) { + return new LabelControllerElement(screen, widgetDimension); + } + + public class LabelControllerElement extends AbstractWidget { + private List wrappedText; + protected MultiLineLabel wrappedTooltip; + protected boolean focused; + + protected final YACLScreen screen; + + public LabelControllerElement(YACLScreen screen, Dimension dim) { + super(dim); + this.screen = screen; + option().addListener((opt, pending) -> updateTooltip()); + updateTooltip(); + updateText(); + } + + @Override + public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + updateText(); + + int y = getDimension().y(); + for (FormattedCharSequence text : wrappedText) { + graphics.drawString(textRenderer, text, getDimension().x() + getXPadding(), y + getYPadding(), option().available() ? -1 : 0xFFA0A0A0, true); + y += textRenderer.lineHeight; + } + + if (isFocused()) { + graphics.fill(getDimension().x() - 1, getDimension().y() - 1, getDimension().xLimit() + 1, getDimension().y(), -1); + graphics.fill(getDimension().x() - 1, getDimension().y() - 1, getDimension().x(), getDimension().yLimit() + 1, -1); + graphics.fill(getDimension().x() - 1, getDimension().yLimit(), getDimension().xLimit() + 1, getDimension().yLimit() + 1, -1); + graphics.fill(getDimension().xLimit(), getDimension().y() - 1, getDimension().xLimit() + 1, getDimension().yLimit() + 1, -1); + } + + graphics.pose().pushPose(); + graphics.pose().translate(0, 0, 100); + if (isMouseOver(mouseX, mouseY)) { + YACLScreen.renderMultilineTooltip(graphics, textRenderer, wrappedTooltip, getDimension().centerX(), getDimension().y() - 5, getDimension().yLimit() + 5, screen.width, screen.height); + + Style style = getStyle(mouseX, mouseY); + if (style != null && style.getHoverEvent() != null) { + HoverEvent hoverEvent = style.getHoverEvent(); + HoverEvent.ItemStackInfo itemStackContent = hoverEvent.getValue(HoverEvent.Action.SHOW_ITEM); + if (itemStackContent != null) { + ItemStack stack = itemStackContent.getItemStack(); + graphics.renderTooltip(textRenderer, Screen.getTooltipFromItem(client, stack), stack.getTooltipImage(), mouseX, mouseY); + } else { + HoverEvent.EntityTooltipInfo entityContent = hoverEvent.getValue(HoverEvent.Action.SHOW_ENTITY); + if (entityContent != null) { + if (this.client.options.advancedItemTooltips) { + graphics.renderComponentTooltip(textRenderer, entityContent.getTooltipLines(), mouseX, mouseY); + } + } else { + Component text = hoverEvent.getValue(HoverEvent.Action.SHOW_TEXT); + if (text != null) { + MultiLineLabel multilineText = MultiLineLabel.create(textRenderer, text, getDimension().width()); + YACLScreen.renderMultilineTooltip(graphics, textRenderer, multilineText, getDimension().centerX(), getDimension().y(), getDimension().yLimit(), screen.width, screen.height); + } + } + } + } + } + graphics.pose().popPose(); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (!isMouseOver(mouseX, mouseY)) + return false; + + Style style = getStyle((int) mouseX, (int) mouseY); + return screen.handleComponentClicked(style); + } + + protected Style getStyle(int mouseX, int mouseY) { + if (!getDimension().isPointInside(mouseX, mouseY)) + return null; + + int x = mouseX - getDimension().x(); + int y = mouseY - getDimension().y() - getYPadding(); + int line = y / textRenderer.lineHeight; + + if (x < 0 || x > getDimension().xLimit()) return null; + if (y < 0 || y > getDimension().yLimit()) return null; + if (line < 0 || line >= wrappedText.size()) return null; + + return textRenderer.getSplitter().componentStyleAtWidth(wrappedText.get(line), x); + } + + private int getXPadding() { + return 4; + } + + private int getYPadding() { + return 3; + } + + private void updateText() { + wrappedText = textRenderer.split(formatValue(), getDimension().width() - getXPadding() * 2); + setDimension(getDimension().withHeight(wrappedText.size() * textRenderer.lineHeight + getYPadding() * 2)); + } + + private void updateTooltip() { + this.wrappedTooltip = MultiLineLabel.create(textRenderer, option().tooltip(), screen.width / 3 * 2 - 10); + } + + @Override + public boolean matchesSearch(String query) { + return formatValue().getString().toLowerCase().contains(query.toLowerCase()); + } + + @Nullable + @Override + public ComponentPath nextFocusPath(FocusNavigationEvent focusNavigationEvent) { + if (!option().available()) + return null; + return !this.isFocused() ? ComponentPath.leaf(this) : null; + } + + @Override + public boolean isFocused() { + return focused; + } + + @Override + public void setFocused(boolean focused) { + this.focused = focused; + } + + @Override + public void updateNarration(NarrationElementOutput builder) { + builder.add(NarratedElementType.TITLE, formatValue()); + } + + @Override + public NarrationPriority narrationPriority() { + return NarrationPriority.FOCUSED; + } + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java b/src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java new file mode 100644 index 0000000..7e71cc7 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/ListEntryWidget.java @@ -0,0 +1,128 @@ +package dev.isxander.yacl3.gui.controllers; + +import com.google.common.collect.ImmutableList; +import dev.isxander.yacl3.api.ListOption; +import dev.isxander.yacl3.api.ListOptionEntry; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.TooltipButtonWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.gui.components.events.ContainerEventHandler; +import net.minecraft.client.gui.components.events.GuiEventListener; +import net.minecraft.client.gui.narration.NarrationElementOutput; +import net.minecraft.network.chat.Component; +import org.jetbrains.annotations.Nullable; + +import java.util.List; + +public class ListEntryWidget extends AbstractWidget implements ContainerEventHandler { + private final TooltipButtonWidget removeButton, moveUpButton, moveDownButton; + private final AbstractWidget entryWidget; + + private final ListOption listOption; + private final ListOptionEntry listOptionEntry; + + private final String optionNameString; + + private GuiEventListener focused; + private boolean dragging; + + public ListEntryWidget(YACLScreen screen, ListOptionEntry listOptionEntry, AbstractWidget entryWidget) { + super(entryWidget.getDimension().withHeight(Math.max(entryWidget.getDimension().height(), 20) - ((listOptionEntry.parentGroup().indexOf(listOptionEntry) == listOptionEntry.parentGroup().options().size() - 1) ? 0 : 2))); // -2 to remove the padding + this.listOptionEntry = listOptionEntry; + this.listOption = listOptionEntry.parentGroup(); + this.optionNameString = listOptionEntry.name().getString().toLowerCase(); + this.entryWidget = entryWidget; + + Dimension dim = entryWidget.getDimension(); + entryWidget.setDimension(dim.clone().move(20 * 2, 0).expand(-20 * 3, 0)); + + removeButton = new TooltipButtonWidget(screen, dim.xLimit() - 20, dim.y(), 20, 20, Component.literal("\u274c"), Component.translatable("yacl.list.remove"), btn -> { + listOption.removeEntry(listOptionEntry); + updateButtonStates(); + }); + + moveUpButton = new TooltipButtonWidget(screen, dim.x(), dim.y(), 20, 20, Component.literal("\u2191"), Component.translatable("yacl.list.move_up"), btn -> { + int index = listOption.indexOf(listOptionEntry) - 1; + if (index >= 0) { + listOption.removeEntry(listOptionEntry); + listOption.insertEntry(index, listOptionEntry); + updateButtonStates(); + } + }); + + moveDownButton = new TooltipButtonWidget(screen, dim.x() + 20, dim.y(), 20, 20, Component.literal("\u2193"), Component.translatable("yacl.list.move_down"), btn -> { + int index = listOption.indexOf(listOptionEntry) + 1; + if (index < listOption.options().size()) { + listOption.removeEntry(listOptionEntry); + listOption.insertEntry(index, listOptionEntry); + updateButtonStates(); + } + }); + + updateButtonStates(); + } + + @Override + public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + updateButtonStates(); // update every render in case option becomes available/unavailable + + removeButton.setY(getDimension().y()); + moveUpButton.setY(getDimension().y()); + moveDownButton.setY(getDimension().y()); + entryWidget.setDimension(entryWidget.getDimension().withY(getDimension().y())); + + removeButton.render(graphics, mouseX, mouseY, delta); + moveUpButton.render(graphics, mouseX, mouseY, delta); + moveDownButton.render(graphics, mouseX, mouseY, delta); + entryWidget.render(graphics, mouseX, mouseY, delta); + } + + protected void updateButtonStates() { + removeButton.active = listOption.available() && listOption.numberOfEntries() > listOption.minimumNumberOfEntries(); + moveUpButton.active = listOption.indexOf(listOptionEntry) > 0 && listOption.available(); + moveDownButton.active = listOption.indexOf(listOptionEntry) < listOption.options().size() - 1 && listOption.available(); + } + + @Override + public void unfocus() { + entryWidget.unfocus(); + } + + @Override + public void updateNarration(NarrationElementOutput builder) { + entryWidget.updateNarration(builder); + } + + @Override + public boolean matchesSearch(String query) { + return optionNameString.contains(query.toLowerCase()); + } + + @Override + public List children() { + return ImmutableList.of(moveUpButton, moveDownButton, entryWidget, removeButton); + } + + @Override + public boolean isDragging() { + return dragging; + } + + @Override + public void setDragging(boolean dragging) { + this.dragging = dragging; + } + + @Nullable + @Override + public GuiEventListener getFocused() { + return focused; + } + + @Override + public void setFocused(@Nullable GuiEventListener focused) { + this.focused = focused; + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java new file mode 100644 index 0000000..de19c14 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/TickBoxController.java @@ -0,0 +1,119 @@ +package dev.isxander.yacl3.gui.controllers; + +import com.mojang.blaze3d.platform.InputConstants; +import dev.isxander.yacl3.api.Controller; +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.network.chat.Component; + +/** + * This controller renders a tickbox + */ +public class TickBoxController implements Controller { + private final Option option; + + /** + * Constructs a tickbox controller + * + * @param option bound option + */ + public TickBoxController(Option option) { + this.option = option; + } + + /** + * {@inheritDoc} + */ + @Override + public Option option() { + return option; + } + + /** + * {@inheritDoc} + */ + @Override + public Component formatValue() { + return Component.empty(); + } + + /** + * {@inheritDoc} + */ + @Override + public AbstractWidget provideWidget(YACLScreen screen, Dimension widgetDimension) { + return new TickBoxControllerElement(this, screen, widgetDimension); + } + + public static class TickBoxControllerElement extends ControllerWidget { + public TickBoxControllerElement(TickBoxController control, YACLScreen screen, Dimension dim) { + super(control, screen, dim); + } + + @Override + protected void drawHoveredControl(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + int outlineSize = 10; + int outlineX1 = getDimension().xLimit() - getXPadding() - outlineSize; + int outlineY1 = getDimension().centerY() - outlineSize / 2; + int outlineX2 = getDimension().xLimit() - getXPadding(); + int outlineY2 = getDimension().centerY() + outlineSize / 2; + + int color = getValueColor(); + int shadowColor = multiplyColor(color, 0.25f); + + drawOutline(graphics, outlineX1 + 1, outlineY1 + 1, outlineX2 + 1, outlineY2 + 1, 1, shadowColor); + drawOutline(graphics, outlineX1, outlineY1, outlineX2, outlineY2, 1, color); + if (control.option().pendingValue()) { + graphics.fill(outlineX1 + 3, outlineY1 + 3, outlineX2 - 1, outlineY2 - 1, shadowColor); + graphics.fill(outlineX1 + 2, outlineY1 + 2, outlineX2 - 2, outlineY2 - 2, color); + } + } + + @Override + protected void drawValueText(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + if (!isHovered()) + drawHoveredControl(graphics, mouseX, mouseY, delta); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (!isMouseOver(mouseX, mouseY) || !isAvailable()) + return false; + + toggleSetting(); + return true; + } + + @Override + protected int getHoveredControlWidth() { + return 10; + } + + @Override + protected int getUnhoveredControlWidth() { + return 10; + } + + public void toggleSetting() { + control.option().requestSet(!control.option().pendingValue()); + playDownSound(); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (!focused) { + return false; + } + + if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_SPACE || keyCode == InputConstants.KEY_NUMPADENTER) { + toggleSetting(); + return true; + } + + return false; + } + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java new file mode 100644 index 0000000..3d85afe --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingControllerElement.java @@ -0,0 +1,60 @@ +package dev.isxander.yacl3.gui.controllers.cycling; + +import com.mojang.blaze3d.platform.InputConstants; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.YACLScreen; +import dev.isxander.yacl3.gui.controllers.ControllerWidget; +import net.minecraft.client.gui.screens.Screen; + +public class CyclingControllerElement extends ControllerWidget> { + + public CyclingControllerElement(ICyclingController control, YACLScreen screen, Dimension dim) { + super(control, screen, dim); + } + + public void cycleValue(int increment) { + int targetIdx = control.getPendingValue() + increment; + if (targetIdx >= control.getCycleLength()) { + targetIdx -= control.getCycleLength(); + } else if (targetIdx < 0) { + targetIdx += control.getCycleLength(); + } + control.setPendingValue(targetIdx); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (!isMouseOver(mouseX, mouseY) || (button != 0 && button != 1) || !isAvailable()) + return false; + + playDownSound(); + cycleValue(button == 1 || Screen.hasShiftDown() || Screen.hasControlDown() ? -1 : 1); + + return true; + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (!focused) + return false; + + switch (keyCode) { + case InputConstants.KEY_LEFT -> + cycleValue(-1); + case InputConstants.KEY_RIGHT -> + cycleValue(1); + case InputConstants.KEY_RETURN, InputConstants.KEY_SPACE, InputConstants.KEY_NUMPADENTER -> + cycleValue(Screen.hasControlDown() || Screen.hasShiftDown() ? -1 : 1); + default -> { + return false; + } + } + + return true; + } + + @Override + protected int getHoveredControlWidth() { + return getUnhoveredControlWidth(); + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java new file mode 100644 index 0000000..3fce3cf --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/CyclingListController.java @@ -0,0 +1,86 @@ +package dev.isxander.yacl3.gui.controllers.cycling; + +import com.google.common.collect.ImmutableList; +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.api.controller.ValueFormatter; +import net.minecraft.network.chat.Component; +import org.jetbrains.annotations.ApiStatus; + +import java.util.function.Function; + +/** + * A controller where once clicked, cycles through elements + * in the provided list. + */ +public class CyclingListController implements ICyclingController { + private final Option option; + private final ValueFormatter valueFormatter; + private final ImmutableList values; + + /** + * Constructs a {@link CyclingListController}, with a default + * value formatter of {@link Object#toString()}. + * @param option option of which to bind the controller to + * @param values the values to cycle through + */ + public CyclingListController(Option option, Iterable values) { + this(option, values, value -> Component.literal(value.toString())); + } + + /** + * Constructs a {@link CyclingListController} + * @param option option of which to bind the controller to + * @param values the values to cycle through + * @param valueFormatter function of how to convert each value to a string to display + */ + public CyclingListController(Option option, Iterable values, Function valueFormatter) { + this.option = option; + this.valueFormatter = valueFormatter::apply; + this.values = ImmutableList.copyOf(values); + } + + @ApiStatus.Internal + public static CyclingListController createInternal(Option option, Iterable values, ValueFormatter formatter) { + return new CyclingListController<>(option, values, formatter::format); + } + + /** + * {@inheritDoc} + */ + @Override + public Option option() { + return option; + } + + /** + * {@inheritDoc} + */ + @Override + public Component formatValue() { + return valueFormatter.format(option().pendingValue()); + } + + /** + * {@inheritDoc} + */ + @Override + public void setPendingValue(int ordinal) { + option().requestSet(values.get(ordinal)); + } + + /** + * {@inheritDoc} + */ + @Override + public int getPendingValue() { + return values.indexOf(option().pendingValue()); + } + + /** + * {@inheritDoc} + */ + @Override + public int getCycleLength() { + return values.size(); + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java new file mode 100644 index 0000000..5a6a912 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/EnumController.java @@ -0,0 +1,48 @@ +package dev.isxander.yacl3.gui.controllers.cycling; + +import dev.isxander.yacl3.api.NameableEnum; +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.api.controller.ValueFormatter; +import net.minecraft.network.chat.Component; +import net.minecraft.util.OptionEnum; + +import java.util.Arrays; +import java.util.function.Function; + +/** + * Simple controller type that displays the enum on the right. + *

+ * Cycles forward with left click, cycles backward with right click or when shift is held + * + * @param enum type + */ +public class EnumController> extends CyclingListController { + public static > Function getDefaultFormatter() { + return value -> { + if (value instanceof NameableEnum nameableEnum) + return nameableEnum.getDisplayName(); + if (value instanceof OptionEnum translatableOption) + return translatableOption.getCaption(); + return Component.literal(value.toString()); + }; + } + + public EnumController(Option option, Class enumClass) { + this(option, getDefaultFormatter(), enumClass.getEnumConstants()); + } + + /** + * Constructs a cycling enum controller. + * + * @param option bound option + * @param valueFormatter format the enum into any {@link Component} + * @param availableValues all enum constants that can be cycled through + */ + public EnumController(Option option, Function valueFormatter, T[] availableValues) { + super(option, Arrays.asList(availableValues), valueFormatter); + } + + public static > EnumController createInternal(Option option, ValueFormatter formatter, T[] values) { + return new EnumController<>(option, formatter::format, values); + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java new file mode 100644 index 0000000..cfddefa --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/cycling/ICyclingController.java @@ -0,0 +1,38 @@ +package dev.isxander.yacl3.gui.controllers.cycling; + +import dev.isxander.yacl3.api.Controller; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.AbstractWidget; +import dev.isxander.yacl3.gui.YACLScreen; + +/** + * This interface simply generifies setting and getting of + * the pending value, using an ordinal so elements can cycle through + * without knowing the content. + */ +public interface ICyclingController extends Controller { + /** + * Sets the pending value to whatever corresponds to the ordinal + * @param ordinal index of element to set + */ + void setPendingValue(int ordinal); + + /** + * Gets the pending ordinal that corresponds to the actual value + * @return ordinal + */ + int getPendingValue(); + + /** + * Allows the element when it should wrap-around back to zeroth ordinal + */ + int getCycleLength(); + + /** + * {@inheritDoc} + */ + @Override + default AbstractWidget provideWidget(YACLScreen screen, Dimension widgetDimension) { + return new CyclingControllerElement(this, screen, widgetDimension); + } +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownController.java b/src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownController.java new file mode 100644 index 0000000..b913d15 --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownController.java @@ -0,0 +1,87 @@ +package dev.isxander.yacl3.gui.controllers.dropdown; + +import dev.isxander.yacl3.api.Option; +import dev.isxander.yacl3.gui.controllers.string.IStringController; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public abstract class AbstractDropdownController implements IStringController { + protected final Option option; + private final List allowedValues; + public final boolean allowEmptyValue; + public final boolean allowAnyValue; + + /** + * Constructs a dropdown controller + * + * @param option bound option + * @param allowedValues possible values + */ + protected AbstractDropdownController(Option option, List allowedValues, boolean allowEmptyValue, boolean allowAnyValue) { + this.option = option; + this.allowedValues = allowedValues; + this.allowEmptyValue = allowEmptyValue; + this.allowAnyValue = allowAnyValue; + } + + protected AbstractDropdownController(Option option, List allowedValues) { + this(option, allowedValues, false, false); + } + + protected AbstractDropdownController(Option option) { + this(option, Collections.emptyList()); + } + + /** + * {@inheritDoc} + */ + @Override + public Option option() { + return option; + } + + public List getAllowedValues() { + return getAllowedValues(""); + } + public List getAllowedValues(String inputField) { + List values = new ArrayList<>(allowedValues); + if (allowEmptyValue && !values.contains("")) values.add(""); + if (allowAnyValue && !inputField.isBlank() && !allowedValues.contains(inputField)) { + values.add(inputField); + } + String currentValue = getString(); + if (allowAnyValue && !allowedValues.contains(currentValue)) { + values.add(currentValue); + } + return values; + } + + public boolean isValueValid(String value) { + if (value.isBlank()) return allowEmptyValue; + return allowAnyValue || getAllowedValues().contains(value); + } + + protected String getValidValue(String value) { + return getValidValue(value, 0); + } + protected String getValidValue(String value, int offset) { + if (offset == -1) return getString(); + + String valueLowerCase = value.toLowerCase(); + return getAllowedValues(value).stream() + .filter(val -> val.toLowerCase().contains(valueLowerCase)) + .sorted((s1, s2) -> { + String s1LowerCase = s1.toLowerCase(); + String s2LowerCase = s2.toLowerCase(); + if (s1LowerCase.startsWith(valueLowerCase) && !s2LowerCase.startsWith(valueLowerCase)) return -1; + if (!s1LowerCase.startsWith(valueLowerCase) && s2LowerCase.startsWith(valueLowerCase)) return 1; + return s1.compareTo(s2); + }) + .skip(offset) + .findFirst() + .orElseGet(this::getString); + } + +} diff --git a/src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownControllerElement.java b/src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownControllerElement.java new file mode 100644 index 0000000..49e0c0e --- /dev/null +++ b/src/main/java/dev/isxander/yacl3/gui/controllers/dropdown/AbstractDropdownControllerElement.java @@ -0,0 +1,248 @@ +package dev.isxander.yacl3.gui.controllers.dropdown; + +import com.mojang.blaze3d.platform.InputConstants; +import com.mojang.blaze3d.vertex.PoseStack; +import dev.isxander.yacl3.api.utils.Dimension; +import dev.isxander.yacl3.gui.YACLScreen; +import dev.isxander.yacl3.gui.controllers.string.StringControllerElement; +import dev.isxander.yacl3.gui.utils.GuiUtils; +import net.minecraft.ChatFormatting; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.gui.screens.Screen; +import net.minecraft.network.chat.Component; + +import java.awt.Color; +import java.util.List; +import java.util.function.Consumer; + +public abstract class AbstractDropdownControllerElement extends StringControllerElement { + public static final int MAX_SHOWN_NUMBER_OF_ITEMS = 7; + + private final AbstractDropdownController dropdownController; + protected boolean dropdownVisible = false; + // Stores the current selection position. The item at this position in the dropdown list will be chosen as the + // accepted value when the element is closed. + protected int selectedIndex = 0; + // Stores a cached list of matching values + protected List matchingValues = null; + + public AbstractDropdownControllerElement(AbstractDropdownController control, YACLScreen screen, Dimension dim) { + super(control, screen, dim, false); + this.dropdownController = control; + this.dropdownController.option.addListener((opt, val) -> this.matchingValues = this.computeMatchingValues()); + } + + public void showDropdown() { + dropdownVisible = true; + selectedIndex = 0; + } + + public void closeDropdown() { + dropdownVisible = false; + ensureValidValue(); + } + + public void ensureValidValue() { + inputField = dropdownController.getValidValue(inputField, selectedIndex); + this.matchingValues = this.computeMatchingValues(); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (super.mouseClicked(mouseX, mouseY, button)) { + if (!dropdownVisible) { + showDropdown(); + doSelectAll(); + } + return true; + } + return false; + } + + @Override + public void setFocused(boolean focused) { + if (focused) { + doSelectAll(); + super.setFocused(true); + } else unfocus(); + } + + @Override + public void unfocus() { + closeDropdown(); + super.unfocus(); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (!inputFieldFocused) + return false; + if (dropdownVisible) { + switch (keyCode) { + case InputConstants.KEY_DOWN -> { + selectNextEntry(); + return true; + } + case InputConstants.KEY_UP -> { + selectPreviousEntry(); + return true; + } + case InputConstants.KEY_TAB -> { + if (Screen.hasShiftDown()) { + selectPreviousEntry(); + } else { + selectNextEntry(); + } + return true; + } + } + } else { + if (keyCode == InputConstants.KEY_RETURN || keyCode == InputConstants.KEY_NUMPADENTER) { + showDropdown(); + return true; + } + } + return super.keyPressed(keyCode, scanCode, modifiers); + } + + @Override + public boolean charTyped(char chr, int modifiers) { + if (!dropdownVisible) { + showDropdown(); + } + return super.charTyped(chr, modifiers); + } + + @Override + protected int getValueColor() { + if (inputFieldFocused) { + if (!dropdownController.isValueValid(inputField)) { + return 0xFFF06080; + } + } + return super.getValueColor(); + } + + public void selectNextEntry() { + if (selectedIndex == getDropdownLength() - 1) { + selectedIndex = 0; + } else { + selectedIndex++; + } + } + + public void selectPreviousEntry() { + if (selectedIndex == 0) { + selectedIndex = getDropdownLength() - 1; + } else { + selectedIndex--; + } + } + + public int getDropdownLength() { + return matchingValues.size(); + } + + @Override + public boolean modifyInput(Consumer builder) { + boolean success = super.modifyInput(builder); + if (success) { + this.matchingValues = this.computeMatchingValues(); + } + return success; + } + + public abstract List computeMatchingValues(); + + public boolean matchingValue(String value) { + return value.toLowerCase().contains(inputField.toLowerCase()); + } + + @Override + public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) { + if (matchingValues == null) matchingValues = computeMatchingValues(); + + super.render(graphics, mouseX, mouseY, delta); + + if (inputFieldFocused && dropdownVisible) { + PoseStack matrices = graphics.pose(); + matrices.pushPose(); + matrices.translate(0, 0, 200); + renderDropdown(graphics); + matrices.popPose(); + } + } + + public void renderDropdown(GuiGraphics graphics) { + if (matchingValues.isEmpty()) return; + // Limit the visible options to allow scrolling through the suggestion list + int begin = Math.max(0, selectedIndex - MAX_SHOWN_NUMBER_OF_ITEMS / 2); + int end = begin + MAX_SHOWN_NUMBER_OF_ITEMS; + if (end >= matchingValues.size()) { + end = matchingValues.size(); + begin = Math.max(0, end - MAX_SHOWN_NUMBER_OF_ITEMS); + } + + renderDropd