Refactor DebugHandlerWidget (#900)

src/main/java/codechicken/nei/recipe/debug/DebugHandlerWidget.java

@@ -0,0 +1,618 @@
+package codechicken.nei.recipe.debug;
+
+import java.awt.Point;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.stream.Collectors;
+
+import net.minecraft.client.gui.inventory.GuiContainer;
+
+import org.apache.commons.io.IOUtils;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.opengl.GL11;
+
+import codechicken.lib.gui.GuiDraw;
+import codechicken.lib.vec.Rectangle4i;
+import codechicken.nei.ClientHandler;
+import codechicken.nei.NEIClientConfig;
+import codechicken.nei.NEIClientUtils;
+import codechicken.nei.Widget;
+import codechicken.nei.drawable.DrawableBuilder;
+import codechicken.nei.drawable.DrawableResource;
+import codechicken.nei.recipe.GuiRecipe;
+import codechicken.nei.recipe.GuiRecipeButton;
+import codechicken.nei.recipe.GuiRecipeTab;
+import codechicken.nei.recipe.HandlerInfo;
+import codechicken.nei.recipe.IRecipeHandler;
+import codechicken.nei.recipe.NEIRecipeWidget;
+import codechicken.nei.recipe.TemplateRecipeHandler;
+import codechicken.nei.recipe.TemplateRecipeHandler.RecipeTransferRect;
+import codechicken.nei.scroll.ScrollContainer;
+
+public class DebugHandlerWidget extends Widget {
+
+    private static class HandlerInfoRecord {
+
+        public String handlerKey;
+        public int yShift;
+        public int width;
+        public int height;
+        public boolean multiWidgets;
+        public int order;
+        public boolean useCustomScroll;
+        public boolean showFavorites;
+        public boolean showOverlay;
+
+        private String csvLine;
+
+        public HandlerInfoRecord(String handlerKey, HandlerInfo info) {
+            this.handlerKey = handlerKey;
+            this.yShift = info.getYShift();
+            this.width = info.getWidth();
+            this.height = info.getHeight();
+            this.multiWidgets = info.isMultipleWidgetsAllowed();
+            this.order = NEIClientConfig.handlerOrdering.getOrDefault(handlerKey, 0);
+            this.useCustomScroll = info.getUseCustomScroll();
+            this.showFavorites = info.getShowFavoritesButton();
+            this.showOverlay = info.getShowOverlayButton();
+            this.csvLine = toCsvLine();
+        }
+
+        public void applyTo(HandlerInfo info) {
+            info.setYShift(this.yShift);
+            info.setHandlerDimensions(this.width, this.height);
+            info.setMultipleWidgetsAllowed(this.multiWidgets);
+            info.setUseCustomScroll(this.useCustomScroll);
+            info.setShowFavoritesButton(this.showFavorites);
+            info.setShowOverlayButton(this.showOverlay);
+            NEIClientConfig.handlerOrdering.put(this.handlerKey, this.order);
+        }
+
+        public String toCsvLine() {
+            return String.join(
+                    ",",
+                    handlerKey,
+                    String.valueOf(yShift),
+                    String.valueOf(height),
+                    String.valueOf(width),
+                    String.valueOf(multiWidgets ? 1 : 0),
+                    String.valueOf(order),
+                    String.valueOf(useCustomScroll ? 1 : 0),
+                    String.valueOf(showFavorites ? 1 : 0),
+                    String.valueOf(showOverlay ? 1 : 0));
+        }
+
+        public boolean isUnmodified() {
+            return this.csvLine.equals(this.toCsvLine());
+        }
+    }
+
+    private static final int WINDOW_WIDTH = 176;
+    private static final int LINE_HEIGHT = 16;
+    private static final int INLINE_PADDING = 6;
+    private static final int LABEL_WIDTH = 50;
+
+    private static final String TOOLTIP_PREFIX = "debug.RecipeHandler.";
+    private static final String HEADER = "HandlerId,YShift,Height,Width,MultiWidgets,Order,UseCustomScroll,ShowFavorites,ShowOverlay";
+    private final int[] COLORS = new int[] { 0x2200FF00, 0x22FF0000, 0x220000FF, 0x2200FFFF, 0x22FF00FF, 0x22FFFF00 };
+
+    public static DebugHandlerWidget instance = new DebugHandlerWidget();
+
+    private ScrollContainer container = new ScrollContainer();
+    private final Map<String, IUpdatableWidget> values = new LinkedHashMap<>();
+    private Map<String, HandlerInfoRecord> patches = new HashMap<>();
+
+    private IRecipeHandler handler;
+    private HandlerInfo handlerInfo;
+    private HandlerInfoRecord record;
+
+    private Point dragPoint = null;
+    private boolean showWidget = false;
+
+    private final DrawableResource BG_TEXTURE = new DrawableBuilder(
+            "nei:textures/gui/recipebg.png",
+            0,
+            0,
+            176 + TRANSPARENCY_BORDER * 2,
+            166 + TRANSPARENCY_BORDER * 2).build();
+    private static final int BORDER_PADDING = 6;
+    private static final int TRANSPARENCY_BORDER = 4;
+
+    public DebugHandlerWidget() {
+        this.w = WINDOW_WIDTH;
+        this.x = 10;
+        this.y = 50;
+        this.z = 4;
+
+        this.container.x = this.x + INLINE_PADDING;
+        this.container.y = this.y + 5 + LINE_HEIGHT;
+        this.container.w = this.w - INLINE_PADDING * 2;
+
+        int y = 0;
+        y = addInfoWidget("Name", y);
+        y = addInfoWidget("Id", y);
+        y = addInfoWidget("Key", y);
+        y = addInfoWidget("HHack", y);
+        y = addInfoWidget("ModName", y);
+        y = addInfoWidget("ModId", y);
+        y = addInfoWidget("Override", y);
+
+        y = addTextFieldWidget("Order", 0, (field, oldText) -> {
+
+            if (field.getInteger() != record.order) {
+                record.order = field.getInteger();
+                saveHandlerInfoPatch();
+            }
+
+        }, y);
+
+        y = addTextFieldWidget("yShift", 0, (field, oldText) -> {
+
+            if (field.getInteger() != handlerInfo.getYShift()) {
+                handlerInfo.setYShift(field.getInteger());
+                record.yShift = field.getInteger();
+                saveHandlerInfoPatch();
+            }
+
+        }, y);
+
+        y = addCheckboxWidget("MultiWidgets", button -> {
+            handlerInfo.setMultipleWidgetsAllowed(button.value);
+            record.multiWidgets = button.value;
+            saveHandlerInfoPatch();
+        }, y);
+
+        final LabelWidget readonly = new LabelWidget(0xffffff, true);
+
+        readonly.y = y;
+        readonly.w = 57;
+        readonly.x = this.w - INLINE_PADDING * 2 - readonly.w;
+        this.values.put("height_readonly", readonly);
+
+        y = addTextFieldWidget("Height", HandlerInfo.DEFAULT_HEIGHT, (field, oldText) -> {
+
+            if (field.getInteger() != handlerInfo.getHeight()) {
+                handlerInfo.setHandlerDimensions(handlerInfo.getWidth(), field.getInteger());
+                record.height = field.getInteger();
+                saveHandlerInfoPatch();
+            }
+
+        }, y);
+
+        y = addTextFieldWidget("Width", HandlerInfo.DEFAULT_WIDTH, (field, oldText) -> {
+
+            if (field.getInteger() != handlerInfo.getWidth()) {
+                handlerInfo.setHandlerDimensions(field.getInteger(), handlerInfo.getHeight());
+                record.width = field.getInteger();
+                saveHandlerInfoPatch();
+            }
+
+        }, y);
+
+        y = addCheckboxWidget("UseCustomScroll", button -> {
+            handlerInfo.setUseCustomScroll(button.value);
+            record.useCustomScroll = button.value;
+            saveHandlerInfoPatch();
+        }, y);
+
+        y = addCheckboxWidget("ShowFavorites", button -> {
+            handlerInfo.setShowFavoritesButton(button.value);
+            record.showFavorites = button.value;
+            saveHandlerInfoPatch();
+        }, y);
+
+        y = addCheckboxWidget("ShowOverlay", button -> {
+            handlerInfo.setShowOverlayButton(button.value);
+            record.showOverlay = button.value;
+            saveHandlerInfoPatch();
+        }, y);
+
+        this.h = 10 + LINE_HEIGHT + y;
+        this.container.h = this.h - INLINE_PADDING * 2 - LINE_HEIGHT;
+    }
+
+    private int addInfoWidget(String key, int y) {
+        final LabelWidget label = new LabelWidget(0x888888, false);
+        final LabelWidget value = new LabelWidget(0xffffff, true);
+
+        label.y = value.y = y;
+        label.w = LABEL_WIDTH;
+        value.x = LABEL_WIDTH + 5;
+        value.w = this.w - INLINE_PADDING * 2 - value.x;
+
+        label.updateValue(NEIClientUtils.translate(TOOLTIP_PREFIX + key));
+
+        this.container.addWidget(label);
+        this.container.addWidget(value);
+        this.values.put(key.toLowerCase(), value);
+
+        return y + value.h + 1;
+    }
+
+    private int addTextFieldWidget(String key, int defaultValue, BiConsumer<IntegerField, String> onChange, int y) {
+        final LabelWidget label = new LabelWidget(0x888888, false);
+        final IntegerField value = new IntegerField(key, onChange, defaultValue);
+
+        label.y = value.y = y;
+        value.w = 60;
+        value.x = this.w - INLINE_PADDING * 2 - value.w;
+        label.w = value.x;
+
+        label.updateValue(NEIClientUtils.translate(TOOLTIP_PREFIX + key));
+
+        this.container.addWidget(label);
+        this.container.addWidget(value);
+
+        this.values.put(key.toLowerCase(), value);
+
+        return y + value.h + 1;
+    }
+
+    private int addCheckboxWidget(String key, Consumer<CheckboxWidget> onChange, int y) {
+        final LabelWidget label = new LabelWidget(0x888888, false);
+        final CheckboxWidget value = new CheckboxWidget(onChange);
+
+        label.y = value.y = y;
+        value.w = 58;
+        value.x = this.w - INLINE_PADDING * 2 - value.w - 1;
+        label.w = value.x;
+
+        label.updateValue(NEIClientUtils.translate(TOOLTIP_PREFIX + key));
+
+        this.container.addWidget(label);
+        this.container.addWidget(value);
+        this.values.put(key.toLowerCase(), value);
+
+        return y + value.h + 1;
+    }
+
+    @Override
+    public void draw(int mx, int my) {
+
+        if (this.handler != null) {
+            GL11.glColor4f(1F, 1F, 1F, 1F);
+            GL11.glScaled(1, 1, 2f);
+            GL11.glDisable(GL11.GL_DEPTH_TEST);
+            BG_TEXTURE.draw(
+                    this.x - TRANSPARENCY_BORDER,
+                    this.y - TRANSPARENCY_BORDER,
+                    this.w + TRANSPARENCY_BORDER * 2,
+                    this.h + TRANSPARENCY_BORDER * 2,
+                    BORDER_PADDING + TRANSPARENCY_BORDER,
+                    BORDER_PADDING + TRANSPARENCY_BORDER,
+                    BORDER_PADDING + TRANSPARENCY_BORDER,
+                    BORDER_PADDING + TRANSPARENCY_BORDER);
+            GuiDraw.drawRect(
+                    this.x + INLINE_PADDING,
+                    this.y + BORDER_PADDING,
+                    this.w - INLINE_PADDING * 2,
+                    12,
+                    0x30000000);
+            GuiDraw.drawStringC(
+                    NEIClientUtils.translate("debug.RecipeHandler.title"),
+                    this.x + this.w / 2,
+                    this.y + BORDER_PADDING + 2,
+                    0xffffff);
+
+            this.container.draw(mx, my);
+
+            GL11.glScaled(1, 1, 1 / 2f);
+        }
+    }
+
+    @Override
+    public void update() {
+        final GuiContainer gui = NEIClientUtils.getGuiContainer();
+
+        if (this.showWidget && gui instanceof GuiRecipe recipe) {
+
+            if (this.handler != recipe.getHandler()) {
+                this.handler = recipe.getHandler();
+                this.handlerInfo = GuiRecipeTab.getHandlerInfo(handler);
+                this.record = this.patches.computeIfAbsent(
+                        getHandlerID(handler),
+                        handlerKey -> new HandlerInfoRecord(handlerKey, handlerInfo));
+
+                final boolean isHeightHackApplied = NEIClientConfig.heightHackHandlerRegex.stream()
+                        .map(pattern -> pattern.matcher(this.handler.getHandlerId())).anyMatch(Matcher::matches);
+
+                this.values.get("name").updateValue(this.handler.getRecipeName());
+                this.values.get("id").updateValue(this.handler.getOverlayIdentifier());
+                this.values.get("key").updateValue(this.handler.getHandlerId());
+                this.values.get("hhack").updateValue(
+                        isHeightHackApplied ? NEIClientUtils.translate("debug.RecipeHandler.yes")
+                                : NEIClientUtils.translate("debug.RecipeHandler.no"));
+                this.values.get("modname").updateValue(this.handlerInfo.getModName());
+                this.values.get("modid").updateValue(this.handlerInfo.getModId());
+
+                this.values.get("order").updateValue(String.valueOf(this.record.order));
+                this.values.get("yshift").updateValue(String.valueOf(this.record.yShift));
+                this.values.get("height").updateValue(String.valueOf(this.record.height));
+                this.values.get("height_readonly").updateValue(String.valueOf(this.record.height));
+                this.values.get("width").updateValue(String.valueOf(this.record.width));
+
+                this.values.get("multiwidgets").updateValue(String.valueOf(this.record.multiWidgets));
+                this.values.get("usecustomscroll").updateValue(String.valueOf(this.record.useCustomScroll));
+
+                this.values.get("showfavorites").updateValue(String.valueOf(this.record.showFavorites));
+                this.values.get("showoverlay").updateValue(String.valueOf(this.record.showOverlay));
+
+                this.values.get("override").updateValue(
+                        this.record.isUnmodified() ? NEIClientUtils.translate("debug.RecipeHandler.no")
+                                : NEIClientUtils.translate("debug.RecipeHandler.yes"));
+
+                this.container.removeIf(
+                        widget -> this.values.get("height") == widget || this.values.get("height_readonly") == widget);
+                if (handler.getRecipeHeight(0) > 0) {
+                    this.container.addWidget((Widget) this.values.get("height_readonly"));
+                } else {
+                    this.container.addWidget((Widget) this.values.get("height"));
+                }
+
+            }
+
+        } else {
+            this.handler = null;
+            this.record = null;
+            this.handlerInfo = null;
+            this.showWidget = false;
+        }
+
+        this.container.update();
+    }
+
+    @Override
+    public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
+        return this.handler != null ? this.container.handleTooltip(mx, my, tooltip) : tooltip;
+    }
+
+    @Override
+    public Map<String, String> handleHotkeys(int mousex, int mousey, Map<String, String> hotkeys) {
+        return this.handler != null ? this.container.handleHotkeys(mousex, mousey, hotkeys) : hotkeys;
+    }
+
+    @Override
+    public boolean handleKeyPress(int keyID, char keyChar) {
+
+        if (NEIClientConfig.getBooleanSetting("inventory.guirecipe.handlerInfo") && keyID == Keyboard.KEY_D
+                && NEIClientUtils.shiftKey()) {
+            this.showWidget = !this.showWidget;
+            return true;
+        } else if (this.handler != null) {
+
+            if (this.container.handleKeyPress(keyID, keyChar)) {
+                return true;
+            }
+
+            this.container.lastKeyTyped(keyID, keyChar);
+
+            return this.container.isFocused();
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onGuiClick(int mx, int my) {
+        if (this.handler != null) {
+            this.container.onGuiClick(mx, my);
+        }
+    }
+
+    @Override
+    public boolean handleClick(int mx, int my, int button) {
+
+        if (this.handler != null) {
+
+            if (new Rectangle4i(this.x + INLINE_PADDING, this.y + BORDER_PADDING, this.w - INLINE_PADDING * 2, 12)
+                    .contains(mx, my)) {
+                this.dragPoint = new Point(mx, my);
+            }
+
+            this.container.handleClick(mx, my, button);
+        }
+
+        return this.handler != null;
+    }
+
+    @Override
+    public boolean contains(int px, int py) {
+        return this.handler != null && super.contains(px, py);
+    }
+
+    @Override
+    public void mouseUp(int mx, int my, int button) {
+        this.dragPoint = null;
+
+        if (this.handler != null) {
+            this.container.mouseUp(mx, my, button);
+        }
+    }
+
+    @Override
+    public boolean onMouseWheel(int scrolled, int mousex, int mousey) {
+
+        if (this.handler != null && contains(mousex, mousey)) {
+            this.container.onMouseWheel(scrolled, mousex, mousey);
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean handleClickExt(int mx, int my, int button) {
+        return this.handler != null && this.container.handleClickExt(mx, my, button);
+    }
+
+    @Override
+    public void mouseDragged(int mx, int my, int button, long heldTime) {
+        if (this.dragPoint != null) {
+            this.x -= this.dragPoint.x - mx;
+            this.y -= this.dragPoint.y - my;
+
+            this.container.y = this.y + INLINE_PADDING + LINE_HEIGHT;
+            this.container.x = this.x + INLINE_PADDING;
+
+            this.dragPoint.move(mx, my);
+        }
+    }
+
+    public void drawGuiPlaceholder(NEIRecipeWidget widget) {
+        if (!this.showWidget) return;
+
+        NEIClientUtils.gl2DRenderContext(() -> {
+
+            // background
+            GuiDraw.drawRect(
+                    widget.x,
+                    widget.y,
+                    widget.w,
+                    widget.h,
+                    COLORS[widget.getRecipeHandlerRef().recipeIndex % COLORS.length]);
+
+            // center cross
+            GuiDraw.drawRect(widget.x + widget.w / 2 - 1, widget.y, 1, widget.h, 0x88ffffff);
+            GuiDraw.drawRect(widget.x, widget.y + widget.h / 2 - 1, widget.w, 1, 0x88ffffff);
+
+            // blue-line-top (grid-top)
+            GuiDraw.drawRect(widget.x + 14, widget.y + 5, widget.w - 38, 1, 0xff0000aa);
+
+            // blue-line-bottom {grid-bottom}
+            GuiDraw.drawRect(widget.x + 14, widget.y + widget.h - 7, widget.w - 38, 1, 0xff0000aa);
+
+            // blue-left (grid start)
+            GuiDraw.drawRect(widget.x + 24, widget.y + (widget.h - 16) / 2, 1, 16, 0xffaa00aa);
+
+            // purple (before favorite)
+            GuiDraw.drawRect(
+                    widget.x + Math.min(168, widget.w) - 27,
+                    widget.y + widget.h - 6 - GuiRecipeButton.BUTTON_HEIGHT * 2 - 4,
+                    GuiRecipeButton.BUTTON_WIDTH,
+                    1,
+                    0xffaa00aa);
+
+            // green ()
+            GuiDraw.drawRect(
+                    widget.x + Math.min(168, widget.w) - 35,
+                    widget.y + widget.h - 6 - GuiRecipeButton.BUTTON_HEIGHT - 3,
+                    20,
+                    1,
+                    0xff00aa00);
+
+            // purple space before bottom grid
+            GuiDraw.drawRect(
+                    widget.x + 14,
+                    widget.y + widget.h - 7 - GuiRecipeButton.BUTTON_WIDTH / 2,
+                    38,
+                    1,
+                    0xffaa00aa);
+
+            if (widget.getRecipeHandlerRef().handler instanceof TemplateRecipeHandler handler) {
+                int yShift = widget.getHandlerInfo().getYShift();
+
+                for (RecipeTransferRect rect : handler.transferRects) {
+                    GuiDraw.drawRect(
+                            widget.x + rect.getRect().x,
+                            widget.y + yShift + rect.getRect().y,
+                            rect.getRect().width,
+                            rect.getRect().height,
+                            0x40ff0000);
+                }
+            }
+
+        });
+    }
+
+    public void loadHandlerInfoPatch() {
+
+        ClientHandler.loadSettingsFile("handlers.patch", lines -> {
+
+            for (String line : lines.collect(Collectors.toCollection(HashSet::new))) {
+                if (HEADER.equals(line)) continue;
+                final String[] parts = Arrays.copyOf((line + ",null,null,null,null,null,null,null,null").split(","), 9);
+                final String handler = parts[0];
+
+                if (GuiRecipeTab.handlerMap.containsKey(handler)) {
+                    final HandlerInfo info = GuiRecipeTab.handlerMap.get(handler);
+                    final HandlerInfoRecord record = patches
+                            .computeIfAbsent(handler, handlerKey -> new HandlerInfoRecord(handler, info));
+
+                    record.yShift = intOrDefault(parts[1], info.getYShift());
+                    record.height = intOrDefault(parts[2], info.getHeight());
+                    record.width = intOrDefault(parts[3], info.getWidth());
+                    record.multiWidgets = intOrDefault(parts[4], info.isMultipleWidgetsAllowed() ? 1 : 0) == 1;
+                    record.order = intOrDefault(parts[5], NEIClientConfig.handlerOrdering.getOrDefault(handler, 0));
+                    record.useCustomScroll = intOrDefault(parts[6], info.getUseCustomScroll() ? 1 : 0) == 1;
+                    record.showFavorites = intOrDefault(parts[7], info.getShowFavoritesButton() ? 1 : 0) == 1;
+                    record.showOverlay = intOrDefault(parts[8], info.getShowOverlayButton() ? 1 : 0) == 1;
+
+                    record.applyTo(info);
+                }
+
+            }
+
+        });
+
+    }
+
+    private void saveHandlerInfoPatch() {
+        final List<String> lines = new ArrayList<>();
+        lines.add(HEADER);
+
+        for (HandlerInfoRecord record : patches.values()) {
+            if (!record.csvLine.equals(record.toCsvLine())) {
+                lines.add(record.toCsvLine());
+            }
+        }
+
+        final File path = new File(NEIClientConfig.configDir, "handlers.patch");
+
+        try (FileOutputStream output = new FileOutputStream(path)) {
+            IOUtils.writeLines(lines, "\n", output, StandardCharsets.UTF_8);
+        } catch (IOException e) {}
+
+        if (this.record != null) {
+            this.values.get("override").updateValue(
+                    this.record.isUnmodified() ? NEIClientUtils.translate("debug.RecipeHandler.no")
+                            : NEIClientUtils.translate("debug.RecipeHandler.yes"));
+        }
+
+        if (NEIClientUtils.getGuiContainer() instanceof GuiRecipe<?>recipe) {
+            recipe.forceRefreshPage();
+        }
+    }
+
+    private int intOrDefault(String str, int defaultValue) {
+        if (str == null || str.isEmpty()) return defaultValue;
+        try {
+            return Integer.parseInt(str);
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    private String getHandlerID(IRecipeHandler handler) {
+
+        if (GuiRecipeTab.handlerMap.containsKey(handler.getHandlerId())) {
+            return handler.getHandlerId();
+        } else if (handler instanceof TemplateRecipeHandler) {
+            return handler.getOverlayIdentifier();
+        }
+
+        return handler.getHandlerId();
+    }
+
+}