Add text field support to AbstractConfigPanel, closes #32

Mumfrey
1 parent 7940c007
Showing 2 changed files with 372 additions and 31 deletions
src/client/java/com/mumfrey/liteloader/modconfig/AbstractConfigPanel.java
src/main/resources/assets/liteloader/lang/en_us.lang
@@ -6,16 +6,22 @@
 package com.mumfrey.liteloader.modconfig;
  
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.regex.Pattern;
  
 import org.lwjgl.input.Keyboard;
  
 import com.mumfrey.liteloader.client.mixin.IGuiButton;
  
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiLabel;
 import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.resources.I18n;
  
 /**
  * A general-purpose base class for mod config panels which implements a lot of
@@ -42,74 +48,360 @@ public abstract class AbstractConfigPanel implements ConfigPanel
     }
  
     /**
-     * Struct which keeps a control together with its callback object
-     * 
-     * @param <T> control type
+     * A handle to an option text field, used to get and retrieve text and set
+     * the max length. It is possible to obtain the native text field as well,
+     * however caution should be used when doing so to avoid breaking the
+     * contract of the text field wrapper used in the config panel itself.
+     */
+    public interface ConfigTextField
+    {
+        /**
+         * Get the inner text field
+         */
+        public abstract GuiTextField getNativeTextField();
+        
+        /**
+         * Get the text field's text
+         */
+        public abstract String getText();
+        
+        /**
+         * Set the text field's text
+         * 
+         * @param text text to set
+         * @return fluent interface
+         */
+        public abstract ConfigTextField setText(String text);
+        
+        /**
+         * Set a validation regex for this text box.
+         * 
+         * @param regex Validation regex to use for this text field
+         * @param force If set to <tt>false</tt>, invalid values will only cause
+         *      the text field to display an error when invalid text is present.
+         *      If set to <tt>true</tt>, invalid values will be forcibly
+         *      prohibited from being entered.
+         * @return fluent interfaces
+         */
+        public abstract ConfigTextField setRegex(String regex, boolean force);
+        
+        /**
+         * If the validation regex is not set, always returns true. Otherwise
+         * returns true if the current text value matches the validation regex.
+         * 
+         * @return validation state of the current text value
+         */
+        public abstract boolean isValid();
+        
+        /**
+         * Set the max allowed string length, defaults to 32
+         * 
+         * @param maxLength max string length to use
+         * @return fluent interface
+         */
+        public abstract ConfigTextField setMaxLength(int maxLength);
+    }
+    
+    /**
+     * Base for config option handle structs
+     */
+    static abstract class ConfigOption
+    {
+        void onTick()
+        {
+        }
+        
+        abstract void draw(Minecraft minecraft, int mouseX, int mouseY, float partialTicks);
+        
+        void mouseReleased(Minecraft minecraft, int mouseX, int mouseY)
+        {
+        }
+        
+        boolean mousePressed(Minecraft minecraft, int mouseX, int mouseY)
+        {
+            return false;
+        }
+        
+        boolean keyPressed(Minecraft minecraft, char keyChar, int keyCode)
+        {
+            return false;
+        }
+    }
+    
+    /**
+     * Struct for labels
      */
-    class ConfigOption<T extends GuiButton>
+    static class ConfigOptionLabel extends ConfigOption
     {
-        final GuiLabel label;
-        final T control;
-        final ConfigOptionListener<T> listener;
+        private final GuiLabel label;
  
-        ConfigOption(GuiLabel label)
+        ConfigOptionLabel(GuiLabel label)
         {
             this.label = label;
-            this.control = null;
-            this.listener = null;
         }
  
-        ConfigOption(T control, ConfigOptionListener<T> listener)
+        @Override
+        void draw(Minecraft minecraft, int mouseX, int mouseY, float partialTicks)
+        {
+            this.label.drawLabel(minecraft, mouseX, mouseY);
+        }
+    }
+    
+    /**
+     * Struct which keeps a control together with its callback object
+     * 
+     * @param <T> control type
+     */
+    static class ConfigOptionButton<T extends GuiButton> extends ConfigOption
+    {
+        private final T control;
+        private final ConfigOptionListener<T> listener;
+        
+        ConfigOptionButton(T control, ConfigOptionListener<T> listener)
         {
-            this.label = null;
             this.control = control;
             this.listener = listener;
         }
  
+        @Override
         void draw(Minecraft minecraft, int mouseX, int mouseY, float partialTicks)
         {
-            if (this.label != null)
+            this.control.drawButton(minecraft, mouseX, mouseY, partialTicks);
+        }
+
+        @Override
+        boolean mousePressed(Minecraft minecraft, int mouseX, int mouseY)
+        {
+            if (this.control.mousePressed(minecraft, mouseX, mouseY))
             {
-                this.label.drawLabel(minecraft, mouseX, mouseY);
+                this.control.playPressSound(minecraft.getSoundHandler());
+                if (this.listener != null)
+                {
+                    this.listener.actionPerformed(this.control);
+                }
+                return true;
             }
  
-            if (this.control != null)
+            return false;
+        }
+
+        @Override
+        void mouseReleased(Minecraft minecraft, int mouseX, int mouseY)
+        {
+            this.control.mouseReleased(mouseX, mouseY);
+        }
+    }
+    
+    /**
+     * Struct for text fields
+     */
+    class ConfigOptionTextField extends ConfigOption implements ConfigTextField
+    {
+        /**
+         * List for accessing via tab order
+         */
+        private final List<GuiConfigTextField> tabOrder;
+        
+        /**
+         * Tab index
+         */
+        private final int tabIndex;
+        
+        /**
+         * Inner text field
+         */
+        private final GuiConfigTextField textField;
+        
+        ConfigOptionTextField(List<GuiConfigTextField> tabOrder, GuiConfigTextField textField)
+        {
+            this.tabOrder = tabOrder;
+            this.tabIndex = tabOrder.indexOf(textField);
+            this.textField = textField;
+            
+            if (this.tabIndex == 0)
             {
-                this.control.drawButton(minecraft, mouseX, mouseY, partialTicks);
+                textField.setFocused(true);
             }
         }
  
+        @Override
+        void onTick()
+        {
+            this.textField.updateCursorCounter();
+        }
+        
+        @Override
+        void draw(Minecraft minecraft, int mouseX, int mouseY, float partialTicks)
+        {
+            this.textField.drawTextBox(mouseX, mouseY);
+        }
+        
+        @Override
         boolean mousePressed(Minecraft minecraft, int mouseX, int mouseY)
         {
-            if (this.control != null && this.control.mousePressed(minecraft, mouseX, mouseY))
+            if (this.textField.mouseClicked(mouseX, mouseY, 0))
             {
-                this.control.playPressSound(minecraft.getSoundHandler());
-                if (this.listener != null)
+                // Unfocus all other text fields
+                for (GuiTextField textField : this.tabOrder)
                 {
-                    this.listener.actionPerformed(this.control);
+                    if (textField != this.textField)
+                    {
+                        textField.setFocused(false);
+                    }
                 }
-                return true;
             }
  
             return false;
         }
+        
+        @Override
+        boolean keyPressed(Minecraft minecraft, char keyChar, int keyCode)
+        {
+            if (!this.textField.isFocused())
+            {
+                return false;
+            }
+            
+            if (keyCode == Keyboard.KEY_TAB)
+            {
+                this.textField.setFocused(false);
+                int tabOrderSize = this.tabOrder.size();
+                this.tabOrder.get((this.tabIndex + (GuiScreen.isShiftKeyDown() ? -1 : 1) + tabOrderSize) % tabOrderSize).setFocused(true);
+                return true;
+            }
+            
+            return this.textField.textboxKeyTyped(keyChar, keyCode);
+        }
+        
+        @Override
+        public GuiTextField getNativeTextField()
+        {
+            return this.textField;
+        }
+
+        @Override
+        public String getText()
+        {
+            return this.textField.getText();
+        }
+
+        @Override
+        public ConfigTextField setText(String text)
+        {
+            this.textField.setText(text);
+            return this;
+        }
+
+        @Override
+        public ConfigTextField setMaxLength(int maxLength)
+        {
+            this.textField.setMaxStringLength(maxLength);
+            return this;
+        }
  
-        void mouseReleased(Minecraft mc, int mouseX, int mouseY)
+        @Override
+        public ConfigTextField setRegex(String regex, boolean force)
         {
-            if (this.control != null)
+            this.textField.setRegex(Pattern.compile(regex), force);;
+            return this;
+        }
+
+        @Override
+        public boolean isValid()
+        {
+            return this.textField.isValid();
+        }
+    }
+    
+    /**
+     * Custom text field which supports "soft" validation by regex (draws red
+     * border and error message when invalid)
+     */
+    class GuiConfigTextField extends GuiTextField
+    {
+        private final FontRenderer fontRenderer;
+        private final int width, height;
+        private Pattern regex;
+        private boolean valid, drawing;
+        
+        GuiConfigTextField(int id, FontRenderer fontRenderer, int x, int y, int width, int height)
+        {
+            super(id, fontRenderer, x, y, width, height);
+            this.fontRenderer = fontRenderer;
+            this.width = width;
+            this.height = height;
+            this.setRegex(null, false);
+        }
+
+        void setRegex(Pattern regex, boolean restrict)
+        {
+            if (restrict && regex != null)
+            {
+                this.setValidator((text) -> regex.matcher(text).matches());
+                this.regex = null;
+            }
+            else
             {
-                this.control.mouseReleased(mouseX, mouseY);
+                this.setValidator((text) -> {
+                    this.validate(text);
+                    return true;
+                });
+                this.regex = regex;
+                this.validate(this.getText());
             }
         }
+
+        private boolean validate(String text)
+        {
+            this.valid = (this.regex == null || this.regex.matcher(text).matches());
+            return true;
+        }
+        
+        boolean isValid()
+        {
+            return this.valid;
+        }
+        
+        @Override
+        public boolean getEnableBackgroundDrawing()
+        {
+            boolean bg = super.getEnableBackgroundDrawing();
+            if (bg && this.drawing && !this.isValid())
+            {
+                drawRect(this.x - 1, this.y - 1, this.x + this.width + 1, this.y + this.height + 1, 0xFFFF5555);
+                drawRect(this.x, this.y, this.x + this.width, this.y + this.height, 0xFF000000);
+                return false;
+            }
+            
+            return bg;
+        }
+        
+        public void drawTextBox(int mouseX, int mouseY)
+        {
+            this.drawing = true;
+            super.drawTextBox();
+            if (!this.isValid())
+            {
+                drawRect(this.x + this.width - 10, this.y, this.x + this.width, this.y + this.height, 0x66000000);
+                this.fontRenderer.drawString("\247l!", this.x + this.width - 6, this.y + (this.height / 2) - 4, 0xFFFF5555);
+                if (mouseX >= this.x && mouseX < this.x + this.width && mouseY >= this.y && mouseY < this.y + this.height)
+                {
+                    AbstractConfigPanel.this.drawHoveringText(I18n.format("gui.invalidvalue"), mouseX, mouseY);
+                }
+            }
+            this.drawing = false;
+        }
     }
  
     protected final Minecraft mc;
  
-    private final List<ConfigOption<?>> options = new ArrayList<ConfigOption<?>>();
+    private final List<ConfigOption> options = new ArrayList<ConfigOption>();
+    
+    private final List<GuiConfigTextField> textFields = new ArrayList<GuiConfigTextField>();
  
     private int contentHeight = 0;
  
-    private ConfigOption<?> selected;
+    private ConfigOption selected;
  
     public AbstractConfigPanel()
     {
@@ -170,7 +462,7 @@ public abstract class AbstractConfigPanel implements ConfigPanel
             label.addLine(line);
         }
         this.contentHeight = Math.max(y + height, this.contentHeight);
-        this.options.add(new ConfigOption<GuiButton>(label));
+        this.options.add(new ConfigOptionLabel(label));
     }
  
     /**
@@ -185,12 +477,33 @@ public abstract class AbstractConfigPanel implements ConfigPanel
         if (control != null)
         {
             this.contentHeight = Math.max(control.y + ((IGuiButton)control).getButtonHeight(), this.contentHeight);
-            this.options.add(new ConfigOption<T>(control, listener));
+            this.options.add(new ConfigOptionButton<T>(control, listener));
         }
  
         return control;
     }
  
+    /**
+     * Add a text field to the panel, returns a handle through which the created
+     * text field can be accessed
+     * 
+     * @param id control id
+     * @param x text field x position
+     * @param y text field y position
+     * @param width text field width
+     * @param height text field height
+     * @return text field handle
+     */
+    protected ConfigTextField addTextField(int id, int x, int y, int width, int height)
+    {
+        GuiConfigTextField textField = new GuiConfigTextField(id, this.mc.fontRenderer, x + 2, y, width, height);
+        this.textFields.add(textField);
+        
+        ConfigOptionTextField configOption = new ConfigOptionTextField(this.textFields, textField);
+        this.options.add(configOption);
+        return configOption;
+    }
+    
     @Override
     public void onPanelResize(ConfigPanelHost host)
     {
@@ -199,12 +512,16 @@ public abstract class AbstractConfigPanel implements ConfigPanel
     @Override
     public void onTick(ConfigPanelHost host)
     {
+        for (ConfigOption configOption : this.options)
+        {
+            configOption.onTick();
+        }
     }
  
     @Override
     public void drawPanel(ConfigPanelHost host, int mouseX, int mouseY, float partialTicks)
     {
-        for (ConfigOption<?> configOption : this.options)
+        for (ConfigOption configOption : this.options)
         {
             configOption.draw(this.mc, mouseX, mouseY, partialTicks);
         }
@@ -219,7 +536,7 @@ public abstract class AbstractConfigPanel implements ConfigPanel
             return;
         }
  
-        for (ConfigOption<?> configOption : this.options)
+        for (ConfigOption configOption : this.options)
         {
             if (configOption.mousePressed(this.mc, mouseX, mouseY))
             {
@@ -251,5 +568,27 @@ public abstract class AbstractConfigPanel implements ConfigPanel
             host.close();
             return;
         }
+        
+        for (ConfigOption configOption : this.options)
+        {
+            if (configOption.keyPressed(this.mc, keyChar, keyCode))
+            {
+                break;
+            }
+        }
+    }
+    
+    protected final void drawHoveringText(String text, int x, int y)
+    {
+        this.drawHoveringText(Arrays.asList(text), x, y);
+    }
+
+    protected final void drawHoveringText(List<String> textLines, int x, int y)
+    {
+        if (this.mc.currentScreen != null)
+        {
+            this.mc.currentScreen.drawHoveringText(textLines, x, y);
+            RenderHelper.disableStandardItemLighting();
+        }
     }
 }    
@@ -91,4 +91,6 @@ gui.error.copytoclipboard=Copy error to clipboard
 gui.error.tooltip=%d mod startup error(s) detected (%d critical)
  
 gui.notifications.updateavailable=LiteLoader Update Available!
-gui.notifications.newsnapshotavailable=!!New Snapshot Available:%nBuild #%s (%s)
 \ No newline at end of file
+gui.notifications.newsnapshotavailable=!!New Snapshot Available:%nBuild #%s (%s)
+
+gui.invalidvalue=§cInvalid value!
 \ No newline at end of file