Rewrite GUIs with ModularUI (#1381)

* Base work for ModularUI compat

* Remove useless interface

* Add almost all the widgets

* Invert method

* Refactor NEI stack placement positions

* NEI handlers on ModularUI

* Add some more docs

* AdvDebugStructureWriter

* Fix NEI progressbar not working

* PrimitiveBlastFurnace

* clean

* derp

* clean

* spotlessApply

* Boilers

* Buffers

* clean

* N by N slots containers

* Fix boilers not having bucket interaction
Put opening UI to individual MetaTEs

* Maintenance Hatch

* clean

* spotlessApply

* Add dependency

* IndustrialApiary

* Adapt to ModularUI change

* Base work for covers & fix crash with MP

* Fix crash with server

* Rewrite base work for covers

* Send initial cover data on cover GUI open
so that the time of showing incorrect data will be eliminated

* Covers part 1

* Rename package: ModularUI -> modularui

* Rename class: GT_UIInfo -> GT_UIInfos

* Fix build

* Covers part2

* Fix missing client check with tile UI & fix title overlap

* CoverTabLine

* Move cover window creators to inner class

* Fix crash with null base TE

* Close GUI when tile is broken

* Color cover window with tile colorization

* Change signature of addUIWidgets

* FluidFilter cover, FluidDisplaySlotWidget, BasicTank, BasicGenerator, Output Hatch, MicrowaveEnergyTransmitter, Teleporter, DigitalChest, DigitalTank

* Add title tab

* Move package: modularui -> modularui/widget

* Programmed circuit + IConfigurationCircuitSupport

* clean

* VolumetricFlask

* Remove integrated circuit overlay from recipe input slots

* Input Hatch & Quadruple Input Hatch

* Multiblock

* Deprecate old cover GUI

* BasicMachines

* Finish BasicMachine & NEI

* Expand DTPF NEI to 9 slots

* Fix ME input bus on MP

* Move AESlotWidget to public class

* Move GT_Recipe_Map constructors with mNEIUnificateOutput to setter method

* Move SteamTexture.Variant to outer enum

* Switch to remote repository

* oops

* Update MUI

* Update MUI

* Minor refactor for change amount buttons

* Display items and fluids that exceed usual count

* blah

* use +=, why didn't I do this

* Update MUI

* Move ModularUI to Base (#1510)

* Move ModularUI to Base
* Move most of the ModularUI functionality to `BaseTileEntity` (and `CoverableTileEntity`)
* `CommonMetaTileEntity` delegates ato the MetaTileEntity
* Added several interfaces (with defaults) to indicate if a tile/metatile override/implement certain behaviors.
* Moved `IConfigurationCircuitSupport` interface such that it will work with BaseTileEntity or a MetaTileEntity

* Address reviews

Co-authored-by: miozune <miozune@gmail.com>

* Update MUI

* Minor changes to NEI

* Return :facepalm:

* IGetTabIconSet override

* Some more changes to NEI

* Merge texture getter interfaces to new class GUITextureSet

* Remove BBF structure picture as it's auto-buildable now

* Make unified title tab style of texture angular

* Expose some boiler texture getters for addon

* Fix crash with cover GUI on pipe

* Lower the number of recipe per page for DTPF & update MUI

* Update MUI

* Fix crash with middle-clicking slot on circuit selection GUI

* Fix circuit selection window not syncing item from base machine

* Merge GT_NEI_AssLineHandler into GT_NEI_DefaultHandler

* Update MUI

* Add in TecTech multi message

* Allow changing the way of binding player inventory

* Update MUI

* Update MUI

* Update MUI

* Update MUI

* Update MUI

* Make MUI non-transitive to allow addons to use their own version

* Force enable mixin

* Format fluid amount tooltip

* Add GUITextureSet.STEAM

* Add guard against null ModularWindow creation

* Add constructors for Muffler Hatch with inventory

* Fix output slot on digital chest and tank allowing insertion

* Don't log null ModularWindow

* Add default implementation for IHasWorldObjectAndCoords#openGUI

* Make openGTTileEntityUI accept MultiTE & cleanup

Co-authored-by: Jason Mitchell <mitchej@gmail.com>

12 files changed, 1727 insertions, 0 deletions

diff --git a/src/main/java/gregtech/common/gui/modularui/UIHelper.java b/src/main/java/gregtech/common/gui/modularui/UIHelper.java
new file mode 100644
index 0000000000..f500514258
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/modularui/UIHelper.java
@@ -0,0 +1,222 @@
+package gregtech.common.gui.modularui;
+
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import gregtech.api.enums.SteamVariant;
+import gregtech.api.gui.modularui.SteamTexture;
+import gregtech.api.util.GT_Recipe;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+
+public class UIHelper {
+
+    /**
+     * Iterates over candidates for slot placement.
+     */
+    public static void forEachSlots(
+            ForEachSlot forEachItemInputSlot,
+            ForEachSlot forEachItemOutputSlot,
+            ForEachSlot forEachSpecialSlot,
+            ForEachSlot forEachFluidInputSlot,
+            ForEachSlot forEachFluidOutputSlot,
+            IDrawable itemSlotBackground,
+            IDrawable fluidSlotBackground,
+            @Nullable GT_Recipe.GT_Recipe_Map recipeMap,
+            int itemInputCount,
+            int itemOutputCount,
+            int fluidInputCount,
+            int fluidOutputCount,
+            SteamVariant steamVariant,
+            Pos2d offset) {
+        List<Pos2d> itemInputPositions = recipeMap != null
+                ? recipeMap.getItemInputPositions(itemInputCount)
+                : UIHelper.getItemInputPositions(itemInputCount);
+        itemInputPositions = itemInputPositions.stream().map(p -> p.add(offset)).collect(Collectors.toList());
+        for (int i = 0; i < itemInputPositions.size(); i++) {
+            forEachItemInputSlot.accept(
+                    i,
+                    getBackgroundsForSlot(itemSlotBackground, recipeMap, false, false, i, false, steamVariant),
+                    itemInputPositions.get(i));
+        }
+
+        List<Pos2d> itemOutputPositions = recipeMap != null
+                ? recipeMap.getItemOutputPositions(itemOutputCount)
+                : UIHelper.getItemOutputPositions(itemOutputCount);
+        itemOutputPositions =
+                itemOutputPositions.stream().map(p -> p.add(offset)).collect(Collectors.toList());
+        for (int i = 0; i < itemOutputPositions.size(); i++) {
+            forEachItemOutputSlot.accept(
+                    i,
+                    getBackgroundsForSlot(itemSlotBackground, recipeMap, false, true, i, false, steamVariant),
+                    itemOutputPositions.get(i));
+        }
+
+        forEachSpecialSlot.accept(
+                0,
+                getBackgroundsForSlot(itemSlotBackground, recipeMap, false, false, 0, true, steamVariant),
+                (recipeMap != null ? recipeMap.getSpecialItemPosition() : UIHelper.getSpecialItemPosition())
+                        .add(offset));
+
+        List<Pos2d> fluidInputPositions = recipeMap != null
+                ? recipeMap.getFluidInputPositions(fluidInputCount)
+                : UIHelper.getFluidInputPositions(fluidInputCount);
+        fluidInputPositions =
+                fluidInputPositions.stream().map(p -> p.add(offset)).collect(Collectors.toList());
+        for (int i = 0; i < fluidInputPositions.size(); i++) {
+            forEachFluidInputSlot.accept(
+                    i,
+                    getBackgroundsForSlot(fluidSlotBackground, recipeMap, true, false, i, false, steamVariant),
+                    fluidInputPositions.get(i));
+        }
+
+        List<Pos2d> fluidOutputPositions = recipeMap != null
+                ? recipeMap.getFluidOutputPositions(fluidOutputCount)
+                : UIHelper.getFluidOutputPositions(fluidOutputCount);
+        fluidOutputPositions =
+                fluidOutputPositions.stream().map(p -> p.add(offset)).collect(Collectors.toList());
+        for (int i = 0; i < fluidOutputPositions.size(); i++) {
+            forEachFluidOutputSlot.accept(
+                    i,
+                    getBackgroundsForSlot(fluidSlotBackground, recipeMap, true, true, i, false, steamVariant),
+                    fluidOutputPositions.get(i));
+        }
+    }
+
+    /**
+     * @return Display positions for GUI, including border (18x18 size)
+     */
+    public static List<Pos2d> getItemInputPositions(int itemInputCount) {
+        switch (itemInputCount) {
+            case 0:
+                return Collections.emptyList();
+            case 1:
+                return getItemGridPositions(itemInputCount, 52, 24, 1, 1);
+            case 2:
+                return getItemGridPositions(itemInputCount, 34, 24, 2, 1);
+            case 3:
+                return getItemGridPositions(itemInputCount, 16, 24, 3, 1);
+            case 4:
+            case 5:
+                return getItemGridPositions(itemInputCount, 16, 24, 3, 2);
+            case 6:
+                return getItemGridPositions(itemInputCount, 16, 15, 3, 2);
+            default:
+                return getItemGridPositions(itemInputCount, 16, 6, 3, 3);
+        }
+    }
+
+    /**
+     * @return Display positions for GUI, including border (18x18 size)
+     */
+    public static List<Pos2d> getItemOutputPositions(int itemOutputCount) {
+        switch (itemOutputCount) {
+            case 0:
+                return Collections.emptyList();
+            case 1:
+                return getItemGridPositions(itemOutputCount, 106, 24, 1, 1);
+            case 2:
+                return getItemGridPositions(itemOutputCount, 106, 24, 2, 1);
+            case 3:
+                return getItemGridPositions(itemOutputCount, 106, 24, 3, 1);
+            case 4:
+                return getItemGridPositions(itemOutputCount, 106, 15, 2, 2);
+            case 5:
+            case 6:
+                return getItemGridPositions(itemOutputCount, 106, 15, 3, 2);
+            default:
+                return getItemGridPositions(itemOutputCount, 106, 6, 3, 3);
+        }
+    }
+
+    /**
+     * @return Display position for GUI, including border (18x18 size)
+     */
+    public static Pos2d getSpecialItemPosition() {
+        return new Pos2d(124, 62);
+    }
+
+    /**
+     * @return Display positions for GUI, including border (18x18 size)
+     */
+    public static List<Pos2d> getFluidInputPositions(int fluidInputCount) {
+        List<Pos2d> results = new ArrayList<>();
+        int x = 52;
+        for (int i = 0; i < fluidInputCount; i++) {
+            results.add(new Pos2d(x, 62));
+            x -= 18;
+        }
+        return results;
+    }
+
+    /**
+     * @return Display positions for GUI, including border (18x18 size)
+     */
+    public static List<Pos2d> getFluidOutputPositions(int fluidOutputCount) {
+        List<Pos2d> results = new ArrayList<>();
+        int x = 106;
+        for (int i = 0; i < fluidOutputCount; i++) {
+            results.add(new Pos2d(x, 62));
+            x += 18;
+        }
+        return results;
+    }
+
+    public static List<Pos2d> getItemGridPositions(
+            int itemCount, int xOrigin, int yOrigin, int xDirMaxCount, int yDirMaxCount) {
+        // 18 pixels to get to a new grid for placing an item tile since they are 16x16 and have 1 pixel buffers
+        // around them.
+        int distanceGrid = 18;
+        int xMax = xOrigin + xDirMaxCount * distanceGrid;
+
+        List<Pos2d> results = new ArrayList<>();
+        // Temp variables to keep track of current coordinates to place item at.
+        int xCoord = xOrigin;
+        int yCoord = yOrigin;
+
+        for (int i = 0; i < itemCount; i++) {
+            results.add(new Pos2d(xCoord, yCoord));
+            xCoord += distanceGrid;
+            if (xCoord == xMax) {
+                xCoord = xOrigin;
+                yCoord += distanceGrid;
+            }
+        }
+
+        return results;
+    }
+
+    private static IDrawable[] getBackgroundsForSlot(
+            IDrawable base,
+            GT_Recipe.GT_Recipe_Map recipeMap,
+            boolean isFluid,
+            boolean isOutput,
+            int index,
+            boolean isSpecial,
+            SteamVariant steamVariant) {
+        if (recipeMap != null) {
+            IDrawable overlay;
+            if (steamVariant != SteamVariant.NONE) {
+                SteamTexture steamTexture = recipeMap.getOverlayForSlotSteam(isFluid, isOutput, index, isSpecial);
+                if (steamTexture != null) {
+                    overlay = steamTexture.get(steamVariant);
+                } else {
+                    overlay = null;
+                }
+            } else {
+                overlay = recipeMap.getOverlayForSlot(isFluid, isOutput, index, isSpecial);
+            }
+            if (overlay != null) {
+                return new IDrawable[] {base, overlay};
+            }
+        }
+        return new IDrawable[] {base};
+    }
+
+    @FunctionalInterface
+    public interface ForEachSlot {
+        void accept(int index, IDrawable[] backgrounds, Pos2d pos);
+    }
+}
diff --git a/src/main/java/gregtech/common/gui/modularui/uifactory/SelectItemUIFactory.java b/src/main/java/gregtech/common/gui/modularui/uifactory/SelectItemUIFactory.java
new file mode 100644
index 0000000000..c3da5cb1b4
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/modularui/uifactory/SelectItemUIFactory.java
@@ -0,0 +1,221 @@
+package gregtech.common.gui.modularui.uifactory;
+
+import com.gtnewhorizons.modularui.api.ModularUITextures;
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.drawable.ItemDrawable;
+import com.gtnewhorizons.modularui.api.drawable.Text;
+import com.gtnewhorizons.modularui.api.forge.ItemStackHandler;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import gregtech.api.enums.Dyes;
+import gregtech.api.gui.GT_GUIColorOverride;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.util.GT_Util;
+import gregtech.api.util.GT_Utility;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
+
+/**
+ * Creates UI for selecting item from given list.
+ * This is client-only UI to allow using client-preferred settings.
+ */
+public class SelectItemUIFactory {
+
+    private final String header;
+    private final ItemStack headerItem;
+    public static final int UNSELECTED = -1;
+    private static final int cols = 9;
+    private final Consumer<ItemStack> selectedCallback;
+    // passed in stack
+    private final List<ItemStack> stacks;
+    private final boolean noDeselect;
+    private int selected;
+    private boolean anotherWindow = false;
+    private AtomicBoolean dialogOpened;
+    private int guiTint = GT_Util.getRGBInt(Dyes.MACHINE_METAL.getRGBA());
+    private final ItemStackHandler currentDisplayItemHandler = new ItemStackHandler();
+    private Supplier<ItemStack> currentGetter;
+
+    private final GT_GUIColorOverride colorOverride = new GT_GUIColorOverride("SelectItemUIFactory");
+
+    private int getTextColorOrDefault(String textType, int defaultColor) {
+        return colorOverride.getTextColorOrDefault(textType, defaultColor);
+    }
+
+    private final Supplier<Integer> COLOR_TITLE = () -> getTextColorOrDefault("title", 0x222222);
+    private final Supplier<Integer> COLOR_TEXT_GRAY = () -> getTextColorOrDefault("text_gray", 0x555555);
+
+    public SelectItemUIFactory(
+            String header, ItemStack headerItem, Consumer<ItemStack> selectedCallback, List<ItemStack> stacks) {
+        this(header, headerItem, selectedCallback, stacks, UNSELECTED);
+    }
+
+    public SelectItemUIFactory(
+            String header,
+            ItemStack headerItem,
+            Consumer<ItemStack> selectedCallback,
+            List<ItemStack> stacks,
+            int selected) {
+        this(header, headerItem, selectedCallback, stacks, selected, false);
+    }
+
+    /**
+     * Constructor for a dialog to select an item from given list. Given callback may be called zero or more times depending on user action.
+     * @param header           Header text
+     * @param headerItem       ItemStack to use as Dialog icon
+     * @param selectedCallback callback upon selected
+     * @param stacks           list to choose from
+     * @param selected         preselected item. Use {@link #UNSELECTED} for unselected. Invalid selected will be clamped to 0 or highest index
+     * @param noDeselect	   true if player cannot deselect, false otherwise. If this is set to true, selectedCallback is guaranteed to be called with a nonnull stack
+     */
+    public SelectItemUIFactory(
+            String header,
+            ItemStack headerItem,
+            Consumer<ItemStack> selectedCallback,
+            List<ItemStack> stacks,
+            int selected,
+            boolean noDeselect) {
+        this.header = header;
+        this.headerItem = headerItem;
+        this.selectedCallback = selectedCallback;
+        this.stacks = stacks;
+        this.noDeselect = noDeselect;
+        this.selected = noDeselect ? Math.max(0, selected) : selected;
+        this.currentDisplayItemHandler.setStackInSlot(0, getCandidate(selected));
+    }
+
+    /**
+     * @param anotherWindow If UI is shown on top of another window
+     * @param dialogOpened Flag to store whether this UI is opened and hence it should block duplicated creation of this UI
+     */
+    public SelectItemUIFactory setAnotherWindow(boolean anotherWindow, AtomicBoolean dialogOpened) {
+        this.anotherWindow = anotherWindow;
+        this.dialogOpened = dialogOpened;
+        return this;
+    }
+
+    public SelectItemUIFactory setGuiTint(int guiTint) {
+        this.guiTint = guiTint;
+        return this;
+    }
+
+    /**
+     * @param currentGetter Getter for "current" item displayed that may change from external reasons
+     */
+    public SelectItemUIFactory setCurrentGetter(Supplier<ItemStack> currentGetter) {
+        this.currentGetter = currentGetter;
+        return this;
+    }
+
+    public ModularWindow createWindow(UIBuildContext buildContext) {
+        ModularWindow.Builder builder =
+                ModularWindow.builder(getGUIWidth(), 53 + 18 * ((stacks.size() - 1) / cols + 1));
+        builder.setBackground(ModularUITextures.VANILLA_BACKGROUND);
+        builder.setGuiTint(guiTint);
+
+        if (headerItem != null) {
+            builder.widget(new ItemDrawable(headerItem).asWidget().setPos(5, 5).setSize(16, 16));
+        }
+        builder.widget(new TextWidget(header).setDefaultColor(COLOR_TITLE.get()).setPos(25, 9));
+
+        builder.widget(
+                        new SlotWidget(BaseSlot.phantom(currentDisplayItemHandler, 0)) {
+                            @Override
+                            public void draw(float partialTicks) {
+                                if (currentGetter != null) {
+                                    ItemStack current = currentGetter.get();
+                                    currentDisplayItemHandler.setStackInSlot(0, current);
+                                    selected = GT_Utility.findMatchingStackInList(stacks, current);
+                                }
+                                super.draw(partialTicks);
+                            }
+                        }.disableInteraction()
+                                .setBackground(GT_UITextures.SLOT_DARK_GRAY)
+                                .setPos(
+                                        9
+                                                + getFontRenderer()
+                                                        .getStringWidth(StatCollector.translateToLocal(
+                                                                "GT5U.gui.select.current")),
+                                        24))
+                .widget(new TextWidget(StatCollector.translateToLocal("GT5U.gui.select.current"))
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(8, 25 + (18 - getFontRenderer().FONT_HEIGHT) / 2));
+
+        for (int i = 0; i < stacks.size(); i++) {
+            final int index = i;
+            builder.widget(
+                    new SlotWidget(new BaseSlot(new ItemStackHandler(new ItemStack[] {stacks.get(index)}), 0, true)) {
+                        @Override
+                        public ClickResult onClick(int buttonId, boolean doubleClick) {
+                            if (buttonId == 0) {
+                                setSelected(index);
+                            } else if (buttonId == 1) {
+                                setSelected(UNSELECTED);
+                            } else {
+                                return ClickResult.ACCEPT;
+                            }
+                            selectedCallback.accept(getCandidate(getSelected()));
+                            return ClickResult.SUCCESS;
+                        }
+
+                        @Override
+                        public IDrawable[] getBackground() {
+                            return new IDrawable[] {
+                                index == selected ? GT_UITextures.SLOT_DARK_GRAY : ModularUITextures.ITEM_SLOT
+                            };
+                        }
+                    }.disableInteraction().setPos(7 + 18 * (index % cols), 43 + 18 * (index / cols)));
+        }
+
+        if (anotherWindow) {
+            dialogOpened.set(true);
+            builder.widget(
+                    new ButtonWidget() {
+                        @Override
+                        public void onDestroy() {
+                            dialogOpened.set(false);
+                        }
+                    }.setOnClick((clickData, widget) -> widget.getWindow().tryClose())
+                            .setBackground(ModularUITextures.VANILLA_BACKGROUND, new Text("x"))
+                            .setPos(getGUIWidth() - 15, 3)
+                            .setSize(12, 12));
+        }
+
+        return builder.build();
+    }
+
+    public int getSelected() {
+        return selected;
+    }
+
+    public void setSelected(int selected) {
+        if (selected == this.selected) return;
+        int newSelected = GT_Utility.clamp(selected, UNSELECTED, stacks.size() - 1);
+        if (noDeselect && newSelected == UNSELECTED) return;
+
+        this.selected = newSelected;
+        currentDisplayItemHandler.setStackInSlot(0, getCandidate(this.selected));
+    }
+
+    private ItemStack getCandidate(int listIndex) {
+        return listIndex < 0 || listIndex >= stacks.size() ? null : stacks.get(listIndex);
+    }
+
+    private FontRenderer getFontRenderer() {
+        return Minecraft.getMinecraft().fontRenderer;
+    }
+
+    private int getGUIWidth() {
+        return 176;
+    }
+}
diff --git a/src/main/java/gregtech/common/gui/modularui/widget/AESlotWidget.java b/src/main/java/gregtech/common/gui/modularui/widget/AESlotWidget.java
new file mode 100644
index 0000000000..f3620d3234
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/modularui/widget/AESlotWidget.java
@@ -0,0 +1,40 @@
+package gregtech.common.gui.modularui.widget;
+
+import appeng.client.render.AppEngRenderItem;
+import appeng.core.AELog;
+import appeng.util.Platform;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.internal.wrapper.ModularGui;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.inventory.Slot;
+
+public class AESlotWidget extends SlotWidget {
+
+    public AESlotWidget(BaseSlot slot) {
+        super(slot);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    protected void drawSlot(Slot slotIn) {
+        final AppEngRenderItem aeRenderItem = new AppEngRenderItem();
+        final RenderItem pIR = this.setItemRender(aeRenderItem);
+        try {
+            aeRenderItem.setAeStack(Platform.getAEStackInSlot(slotIn));
+            super.drawSlot(slotIn, false);
+        } catch (final Exception err) {
+            AELog.warn("[AppEng] AE prevented crash while drawing slot: " + err);
+        }
+        this.setItemRender(pIR);
+    }
+
+    @SideOnly(Side.CLIENT)
+    private RenderItem setItemRender(final RenderItem item) {
+        final RenderItem ri = ModularGui.getItemRenderer();
+        ModularGui.setItemRenderer(item);
+        return ri;
+    }
+}
diff --git a/src/main/java/gregtech/common/gui/modularui/widget/CoverCycleButtonWidget.java b/src/main/java/gregtech/common/gui/modularui/widget/CoverCycleButtonWidget.java
new file mode 100644
index 0000000000..599ed28a5f
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/modularui/widget/CoverCycleButtonWidget.java
@@ -0,0 +1,89 @@
+package gregtech.common.gui.modularui.widget;
+
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.gui.modularui.GT_UITextures;
+import org.lwjgl.opengl.GL11;
+
+/**
+ * Fires click action on mouse release, not on press.
+ * Draws different backgrounds depending on whether the mouse is being pressed or the widget is hovered.
+ */
+public class CoverCycleButtonWidget extends CycleButtonWidget {
+
+    private static final UITexture BUTTON_NORMAL_NOT_PRESSED =
+            GT_UITextures.BUTTON_COVER_NORMAL.getSubArea(0, 0, 1, 0.5f);
+    private static final UITexture BUTTON_NORMAL_PRESSED = GT_UITextures.BUTTON_COVER_NORMAL.getSubArea(0, 0.5f, 1, 1);
+    private static final UITexture BUTTON_HOVERED_NOT_PRESSED =
+            GT_UITextures.BUTTON_COVER_NORMAL_HOVERED.getSubArea(0, 0, 1, 0.5f);
+    private static final UITexture BUTTON_HOVERED_PRESSED =
+            GT_UITextures.BUTTON_COVER_NORMAL_HOVERED.getSubArea(0, 0.5f, 1, 1);
+
+    private boolean clickPressed;
+
+    private static final int TOOLTIP_DELAY = 5;
+
+    public CoverCycleButtonWidget() {
+        setSize(16, 16);
+        setTooltipShowUpDelay(TOOLTIP_DELAY);
+    }
+
+    @Override
+    public ClickResult onClick(int buttonId, boolean doubleClick) {
+        updateState();
+        if (!canClick()) return ClickResult.REJECT;
+        clickPressed = true;
+        return ClickResult.SUCCESS;
+    }
+
+    @Override
+    public boolean onClickReleased(int buttonId) {
+        clickPressed = false;
+        updateState();
+        if (!isHovering() || !canClick()) return false;
+        return onClickImpl(buttonId);
+    }
+
+    protected boolean onClickImpl(int buttonId) {
+        super.onClick(buttonId, false);
+        return true;
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    protected boolean canClick() {
+        return true;
+    }
+
+    @SideOnly(Side.CLIENT)
+    protected void updateState() {}
+
+    public boolean isClickPressed() {
+        return clickPressed;
+    }
+
+    @Override
+    public void drawBackground(float partialTicks) {
+        GL11.glColor4f(1, 1, 1, 1);
+        super.drawBackground(partialTicks);
+    }
+
+    @Override
+    public IDrawable[] getBackground() {
+        if (isHovering()) {
+            if (clickPressed) {
+                return new IDrawable[] {BUTTON_HOVERED_PRESSED};
+            } else {
+                return new IDrawable[] {BUTTON_HOVERED_NOT_PRESSED};
+            }
+        } else {
+            if (clickPressed) {
+                return new IDrawable[] {BUTTON_NORMAL_PRESSED};
+            } else {
+                return new IDrawable[] {BUTTON_NORMAL_NOT_PRESSED};
+            }
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/gui/modularui/widget/CoverDataControllerWidget.java b/src/main/java/gregtech/common/gui/modularui/widget/CoverDataControllerWidget.java
new file mode 100644
index 0000000000..d28117054a
--- /dev/null
+++ b/src/main/java/gregtech/common/gui/modularui/widget/CoverDataControllerWidget.java
@@ -0,0 +1,138 @@
+package gregtech.common.gui.modularui.widget;
+
+import com.gtnewhorizons.modularui.api.widget.Widget;
+import com.gtnewhorizons.modularui.common.internal.network.NetworkUtils;
+import gregtech.api.gui.modularui.IDataFollowerWidget;
+import gregtech.api.util.GT_CoverBehaviorBase;
+import gregtech.api.util.ISerializableObject;
+import java.io.IOException;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import net.minecraft.network.PacketBuffer;
+
+public class CoverDataControllerWidget<T extends ISerializableObject> extends DataControllerWidget<T> {
+
+    protected final GT_CoverBehaviorBase<T> coverBehavior;
+
+    /**
+     * @param dataGetter () -> cover data this widget handles
+     * @param dataSetter data to set -> if setting cover data is successful
+     * @param coverBehavior cover this widget handles data update
+     */
+    public CoverDataControllerWidget(
+            Supplier<T> dataGetter, Function<T, Boolean> dataSetter, GT_CoverBehaviorBase<T> coverBehavior) {
+        super(dataGetter, dataSetter);
+        this.coverBehavior = coverBehavior;
+    }
+
+    @Override
+    public <U, W extends Widget & IDataFollowerWidget<T, U>> CoverDataControllerWidget<T> addFollower(
+            W widget, Function<T, U> dataToStateGetter, BiFunction<T, U, T> dataUpdater, Consumer<W> applyForWidget) {
+        super.addFollower(widget, dataToStateGetter, dataUpdater, applyForWidget);
+        return this;
+    }
+
+    @Override
+    protected void writeToPacket(PacketBuffer buffer, T data) {
+        try {
+            NetworkUtils.writeNBTBase(buffer, data.saveDataToNBT());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    protected T readFromPacket(PacketBuffer buffer) throws IOException {
+        return coverBehavior.createDataObject(NetworkUtils.readNBTBase(buffer));
+    }
+
+    /**
+     * Uses int index to determine toggle button behaviors.
+     */
+    public static class CoverDataIndexedControllerWidget_ToggleButtons<T extends ISerializableObject>
+            extends CoverDataControllerWidget<T> {
+
+        private final BiFunction<Integer, T, Boolean> dataToStateGetter;
+        private final BiFunction<Integer, T, T> dataUpdater;
+
+        /**
+         * @param coverDataGetter () -> cover data this widget handles
+         * @param coverDataSetter data to set -> if setting cover data is successful
+         * @param coverBehavior cover this widget handles data update
+         * @param dataToStateGetter (index of button, given cover data) -> button state
+         * @param dataUpdater (index of button, current cover data) -> new cover data
+         */
+        public CoverDataIndexedControllerWidget_ToggleButtons(
+                Supplier<T> coverDataGetter,
+                Function<T, Boolean> coverDataSetter,
+                GT_CoverBehaviorBase<T> coverBehavior,
+                BiFunction<Integer, T, Boolean> dataToStateGetter,
+                BiFunction<Integer, T, T> dataUpdater) {
+            super(coverDataGetter, coverDataSetter, coverBehavior);
+            this.dataToStateGetter = dataToStateGetter;
+            this.dataUpdater = dataUpdater;
+        }
+
+        /**
+         * @param index index of widget to add
+         * @param widget widget to add
+         * @param applyForWidget methods to call for widget to add
+         */
+        public <W extends CoverDataFollower_ToggleButtonWidget<T>>
+                CoverDataIndexedControllerWidget_ToggleButtons<T> addToggleButton(
+                        int index, W widget, Consumer<CoverDataFollower_ToggleButtonWidget<T>> applyForWidget) {
+            addFollower(
+                    widget,
+                    data -> dataToStateGetter.apply(index, data),
+                    (data, state) -> dataUpdater.apply(index, data),
+                    applyForWidget);
+            return this;
+        }
+    }
+
+    /**
+     * Uses int index to determine cycle button behaviors.
+     */
+    public static class CoverDataIndexedControllerWidget_CycleButtons<T extends ISerializableObject>
+            extends CoverDataControllerWidget<T> {
+
+        private final BiFunction<Integer, T, Integer> dataToStateGetter;
+        private final BiFunction<Integer, T, T> dataUpdater;
+
+        /**
+         * @param coverDataGetter () -> cover data this widget handles
+         * @param coverDataSetter data to set -> if setting cover data is successful
+         * @param coverBehavior cover this widget handles data update
+         * @param dataToStateGetter (index of button, given cover data) -> button state
+         * @param dataUpdater (index of button, current cover data) -> new cover data
+         */
+        public CoverDataIndexedControllerWidget_CycleButtons(
+                Supplier<T> coverDataGetter,
+                Function<T, Boolean> coverDataSetter,
+                GT_CoverBehaviorBase<T> coverBehavior,
+                BiFunction<Integer, T, Integer> dataToStateGetter,
+                BiFunction<Integer, T, T> dataUpdater) {
+            super(coverDataGetter, coverDataSetter, coverBehavior);
+            this.dataToStateGetter = dataToStateGetter;
+            this.dataUpdater = dataUpdater;
+        }
+
+        /**
+         * @param index index of widget to add
+         * @param widget widget to add
+         * @param applyForWi