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>

7 files changed, 596 insertions, 69 deletions

diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java
index dc5c976eac..3dc9fd7b63 100644
--- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java
+++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_CuringOven.java
@@ -1,21 +1,21 @@
 package gregtech.common.tileentities.machines.basic;
 
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
 import gregtech.api.enums.ItemList;
 import gregtech.api.enums.Textures;
-import gregtech.api.gui.GT_Container_1by1;
-import gregtech.api.gui.GT_GUIContainer_1by1;
 import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.items.GT_MetaGenerated_Tool;
 import gregtech.api.metatileentity.MetaTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine;
 import gregtech.api.render.TextureFactory;
-import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.fluids.FluidStack;
 
-public class GT_MetaTileEntity_CuringOven extends GT_MetaTileEntity_BasicMachine {
+public class GT_MetaTileEntity_CuringOven extends GT_MetaTileEntity_BasicMachine implements IAddUIWidgets {
 
     public GT_MetaTileEntity_CuringOven(int aID, String aName, String aNameRegional, int aTier) {
         super(
@@ -76,16 +76,6 @@ public class GT_MetaTileEntity_CuringOven extends GT_MetaTileEntity_BasicMachine
     }
 
     @Override
-    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_Container_1by1(aPlayerInventory, aBaseMetaTileEntity);
-    }
-
-    @Override
-    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_GUIContainer_1by1(aPlayerInventory, aBaseMetaTileEntity, getLocalName());
-    }
-
-    @Override
     public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
         if (aBaseMetaTileEntity.isServerSide()) {
             for (ItemStack tStack : mInventory)
@@ -120,4 +110,14 @@ public class GT_MetaTileEntity_CuringOven extends GT_MetaTileEntity_BasicMachine
                 }
         }
     }
+
+    @Override
+    public boolean useModularUI() {
+        return true;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        getBaseMetaTileEntity().add1by1Slot(builder);
+    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java
index 81e7ece86f..ff46aada64 100644
--- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java
+++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java
@@ -605,4 +605,16 @@ public class GT_MetaTileEntity_Disassembler extends GT_MetaTileEntity_BasicMachi
                 && aStack.getTagCompound() != null
                 && aStack.getTagCompound().getCompoundTag("GT.CraftingComponents") != null;
     }
+
+    @Override
+    public GT_Recipe.GT_Recipe_Map getRecipeList() {
+        return GT_Recipe.GT_Recipe_Map.sDisassemblerRecipes;
+    }
+
+    // GUI stuff
+
+    @Override
+    public boolean hasNEITransferRect() {
+        return false;
+    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_IndustrialApiary.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_IndustrialApiary.java
index b1e6b1cc2f..557b01fbb0 100644
--- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_IndustrialApiary.java
+++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_IndustrialApiary.java
@@ -3,9 +3,28 @@ package gregtech.common.tileentities.machines.basic;
 import static gregtech.api.enums.GT_Values.AuthorKuba;
 import static gregtech.api.enums.GT_Values.V;
 import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.metatileentity.BaseTileEntity.STALLED_STUTTERING_TOOLTIP;
+import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY;
 import static gregtech.api.util.GT_Utility.moveMultipleItemStacks;
 
 import com.google.common.collect.ImmutableSet;
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.forge.IItemHandlerModifiable;
+import com.gtnewhorizons.modularui.api.math.Pos2d;
+import com.gtnewhorizons.modularui.api.screen.ModularUIContext;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.builder.UIInfo;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.internal.wrapper.ModularUIContainer;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.ProgressBar;
+import com.gtnewhorizons.modularui.common.widget.SlotGroup;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
 import com.mojang.authlib.GameProfile;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
@@ -19,7 +38,11 @@ import forestry.apiculture.genetics.Bee;
 import forestry.apiculture.genetics.alleles.AlleleEffectThrottled;
 import forestry.core.errors.EnumErrorCode;
 import forestry.plugins.PluginApiculture;
+import gregtech.GT_Mod;
+import gregtech.api.gui.modularui.GT_UIInfos;
+import gregtech.api.gui.modularui.GT_UITextures;
 import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine;
@@ -28,27 +51,28 @@ import gregtech.api.util.GT_ApiaryModifier;
 import gregtech.api.util.GT_ApiaryUpgrade;
 import gregtech.api.util.GT_Utility;
 import gregtech.common.GT_Client;
-import gregtech.common.gui.GT_Container_IndustrialApiary;
-import gregtech.common.gui.GT_GUIContainer_IndustrialApiary;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.util.*;
+import java.util.stream.Collectors;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
 import net.minecraft.util.Vec3;
 import net.minecraft.world.World;
 import net.minecraft.world.biome.BiomeGenBase;
 
 public class GT_MetaTileEntity_IndustrialApiary extends GT_MetaTileEntity_BasicMachine
-        implements IBeeHousing, IBeeHousingInventory, IErrorLogic, IBeeModifier, IBeeListener {
+        implements IBeeHousing, IBeeHousingInventory, IErrorLogic, IBeeModifier, IBeeListener, IAddUIWidgets {
 
     public static final int beeCycleLength = 550;
     public static final int baseEUtUsage = 37;
@@ -149,13 +173,29 @@ public class GT_MetaTileEntity_IndustrialApiary extends GT_MetaTileEntity_BasicM
     }
 
     @Override
-    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_Container_IndustrialApiary(aPlayerInventory, aBaseMetaTileEntity);
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) return true;
+        if (!GT_Mod.gregtechproxy.mForceFreeFace) {
+            openGUI(aBaseMetaTileEntity, aPlayer);
+            return true;
+        }
+        for (byte i = 0; i < 6; i++) {
+            if (aBaseMetaTileEntity.getAirAtSide(i)) {
+                openGUI(aBaseMetaTileEntity, aPlayer);
+                return true;
+            }
+        }
+        GT_Utility.sendChatToPlayer(aPlayer, "No free Side!");
+        return true;
     }
 
-    @Override
-    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_GUIContainer_IndustrialApiary(aPlayerInventory, aBaseMetaTileEntity);
+    private void openGUI(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        IndustrialApiaryUI.open(
+                aPlayer,
+                aBaseMetaTileEntity.getWorld(),
+                aBaseMetaTileEntity.getXCoord(),
+                aBaseMetaTileEntity.getYCoord(),
+                aBaseMetaTileEntity.getZCoord());
     }
 
     @Override
@@ -1036,4 +1076,305 @@ public class GT_MetaTileEntity_IndustrialApiary extends GT_MetaTileEntity_BasicM
         @Override
         public void writeToNBT(NBTTagCompound nbtTagCompound) {}
     };
+
+    private static final String POWER_SOURCE_POWER = "GT5U.machines.powersource.power",
+            CANCEL_PROCESS_TOOLTIP = "GT5U.machines.industrialapiary.cancel.tooltip",
+            SPEED_TOOLTIP = "GT5U.machines.industrialapiary.speed.tooltip",
+            SPEED_LOCKED_TOOLTIP = "GT5U.machines.industrialapiary.speedlocked.tooltip",
+            INFO_TOOLTIP = "GT5U.machines.industrialapiary.info.tooltip",
+            INFO_WITH_BEE_TOOLTIP = "GT5U.machines.industrialapiary.infoextended.tooltip",
+            UPGRADE_TOOLTIP = "GT5U.machines.industrialapiary.upgradeslot.tooltip";
+
+    @Override
+    public boolean useModularUI() {
+        return true;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(new SlotWidget(new ApiarySlot(inventoryHandler, queen))
+                        .setBackground(getGUITextureSet().getItemSlot(), GT_UITextures.OVERLAY_SLOT_BEE_QUEEN)
+                        .setPos(36, 21))
+                .widget(new SlotWidget(new ApiarySlot(inventoryHandler, drone))
+                        .setBackground(getGUITextureSet().getItemSlot(), GT_UITextures.OVERLAY_SLOT_BEE_DRONE)
+                        .setPos(36, 41))
+                .widget(SlotGroup.ofItemHandler(inventoryHandler, 2)
+                        .startFromSlot(7)
+                        .endAtSlot(10)
+                        .slotCreator(i -> new ApiarySlot(inventoryHandler, i))
+                        .applyForWidget(widget -> widget.setGTTooltip(() -> mTooltipCache.getData(UPGRADE_TOOLTIP))
+                                .setTooltipShowUpDelay(TOOLTIP_DELAY))
+                        .build()
+                        .setPos(61, 23));
+
+        super.addUIWidgets(builder, buildContext);
+
+        builder.widget(new ProgressBar()
+                        .setProgress(() -> (float) getProgresstime() / Math.max(maxProgresstime(), 1))
+                        .setTexture(GT_UITextures.PROGRESSBAR_ARROW, 20)
+                        .setPos(70, 3)
+                        .setSize(20, 18))
+                .widget(new ButtonWidget()
+                        .setOnClick((clickData, widget) -> cancelProcess())
+                        .setBackground(GT_UITextures.BUTTON_STANDARD, GT_UITextures.OVERLAY_BUTTON_CROSS)
+                        .setGTTooltip(() -> mTooltipCache.getData(CANCEL_PROCESS_TOOLTIP))
+                        .setTooltipShowUpDelay(TOOLTIP_DELAY)
+                        .setPos(7, 26)
+                        .setSize(18, 18))
+                .widget(new DrawableWidget()
+                        .setDrawable(GT_UITextures.PICTURE_INFORMATION)
+                        .setGTTooltip(() -> {
+                            String energyreq = GT_Utility.formatNumbers(
+                                    (int) ((float) GT_MetaTileEntity_IndustrialApiary.baseEUtUsage
+                                                    * getEnergyModifier()
+                                                    * getAcceleration())
+                                            + getAdditionalEnergyUsage());
+                            String Temp = StatCollector.translateToLocal(
+                                    getTemperature().getName());
+                            String Hum =
+                                    StatCollector.translateToLocal(getHumidity().getName());
+                            if (getUsedQueen() != null
+                                    && BeeManager.beeRoot.isMember(getUsedQueen(), EnumBeeType.QUEEN.ordinal())) {
+                                IBee bee = BeeManager.beeRoot.getMember(getUsedQueen());
+                                if (bee.isAnalyzed()) {
+                                    IBeeGenome genome = bee.getGenome();
+                                    IBeeModifier mod = BeeManager.beeRoot
+                                            .getBeekeepingMode(getWorld())
+                                            .getBeeModifier();
+                                    float tmod = getTerritoryModifier(null, 1f) * mod.getTerritoryModifier(null, 1f);
+                                    int[] t = Arrays.stream(genome.getTerritory())
+                                            .map(i -> (int) ((float) i * tmod))
+                                            .toArray();
+                                    return mTooltipCache.getUncachedTooltipData(
+                                            INFO_WITH_BEE_TOOLTIP,
+                                            energyreq,
+                                            Temp,
+                                            Hum,
+                                            genome.getSpeed(),
+                                            getProductionModifier(null, 1f) * mod.getProductionModifier(null, 1f),
+                                            Math.round(getFloweringModifier(null, 1f)
+                                                    * genome.getFlowering()
+                                                    * mod.getFloweringModifier(null, 1f)),
+                                            Math.round(getLifespanModifier(null, null, 1f)
+                                                    * genome.getLifespan()
+                                                    * mod.getLifespanModifier(null, null, 1f)),
+                                            t[0],
+                                            t[1],
+                                            t[2]);
+                                }
+                            }
+                            return mTooltipCache.getUncachedTooltipData(INFO_TOOLTIP, energyreq, Temp, Hum);
+                        })
+                        .attachSyncer(
+                                new FakeSyncWidget.ItemStackSyncer(() -> usedQueen, val -> usedQueen = val),
+                                builder,
+                                (widget, val) -> widget.notifyTooltipChange())
+                        .setPos(163, 5)
+                        .setSize(7, 18))
+                .widget(new ButtonWidget()
+                        .setOnClick((clickData, widget) -> {
+                            if (clickData.mouseButton == 0) {
+                                if (mLockedSpeed) return;
+                                if (!clickData.shift) {
+                                    mSpeed++;
+                                    if (mSpeed > getMaxSpeed()) mSpeed = 0;
+                                } else {
+                                    mSpeed--;
+                                    if (mSpeed < 0) mSpeed = getMaxSpeed();
+                                }
+                            } else if (clickData.mouseButton == 1) {
+                                mLockedSpeed = !mLockedSpeed;
+                                if (mLockedSpeed) mSpeed = getMaxSpeed();
+                            }
+                        })
+                        .setGTTooltip(() -> mTooltipCache.getUncachedTooltipData(
+                                mLockedSpeed ? SPEED_LOCKED_TOOLTIP : SPEED_TOOLTIP,
+                                getAcceleration(),
+                                GT_Utility.formatNumbers(getAdditionalEnergyUsage())))
+                        .attachSyncer(
+                                new FakeSyncWidget.IntegerSyncer(() -> mSpeed, val -> mSpeed = val),
+                                builder,
+                                (widget, val) -> widget.notifyTooltipChange())
+                        .attachSyncer(
+                                new FakeSyncWidget.BooleanSyncer(() -> mLockedSpeed, val -> mLockedSpeed = val),
+                                builder,
+                                (widget, val) -> widget.notifyTooltipChange())
+                        .setTooltipShowUpDelay(TOOLTIP_DELAY)
+                        .setBackground(GT_UITextures.PICTURE_SQUARE_LIGHT_GRAY)
+                        .setPos(25, 62)
+                        .setSize(18, 18))
+                .widget(new TextWidget("x")
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(30, 63))
+                .widget(TextWidget.dynamicString(() -> String.valueOf(1 << mSpeed))
+                        // mSpeed is already synced
+                        .setSynced(false)
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(26, 72));
+    }
+
+    @Override
+    protected SlotWidget createItemInputSlot(int index, IDrawable[] backgrounds, Pos2d pos) {
+        // we have custom input slots
+        return null;
+    }
+
+    @Override
+    protected CycleButtonWidget createItemAutoOutputButton() {
+        return (CycleButtonWidget) super.createItemAutoOutputButton().setPos(7, 62);
+    }
+
+    @Override
+    protected CycleButtonWidget createFluidAutoOutputButton() {
+        return null;
+    }
+
+    @Override
+    protected SlotWidget createChargerSlot(int x, int y, String tooltipKey, Object[] tooltipArgs) {
+        return (SlotWidget)
+                super.createChargerSlot(x, y, tooltipKey, tooltipArgs).setPos(79, 62);
+    }
+
+    @Override
+    protected DrawableWidget createErrorStatusArea(ModularWindow.Builder builder, IDrawable picture) {
+        return (DrawableWidget) super.createErrorStatusArea(builder, picture)
+                .setPos(100, 62)
+                .attachSyncer(
+                        new FakeSyncWidget.ListSyncer<>(
+                                () -> Arrays.asList(mErrorStates.toArray(new IErrorState[0])),
+                                val -> {
+                                    mErrorStates.clear();
+                                    mErrorStates.addAll(new HashSet<>(val));
+                                },
+                                (buffer, val) -> buffer.writeShort(val.getID()),
+                                buffer -> ForestryAPI.errorStateRegistry.getErrorState(buffer.readShort())),
+                        builder,
+                        (widget, val) -> widget.notifyTooltipChange());
+    }
+
+    @Override
+    protected List<String> getErrorDescriptions() {
+        if (!mErrorStates.isEmpty()) {
+            return mErrorStates.stream()
+                    .map(state ->
+                            EnumChatFormatting.RED + StatCollector.translateToLocal("for." + state.getDescription()))
+                    .collect(Collectors.toList());
+        } else if (mStuttering) {
+            return mTooltipCache.getData(STALLED_STUTTERING_TOOLTIP, StatCollector.translateToLocal(POWER_SOURCE_POWER))
+                    .text;
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    @Override
+    protected List<String> getErrorDescriptionsShift() {
+        // Don't show shift tooltip of "Progress was lost"
+        // as this machine does not lose progress
+        return getErrorDescriptions();
+    }
+
+    private int getAcceleration() {
+        return 1 << mSpeed;
+    }
+
+    private int getAdditionalEnergyUsage() {
+        int accelerated = getAcceleration();
+        int energyusage = 0;
+        if (accelerated == 2) energyusage = 32;
+        else if (accelerated > 2) energyusage = 32 * accelerated << (mSpeed - 2);
+        return energyusage;
+    }
+
+    private class ApiarySlot extends BaseSlot {
+
+        public ApiarySlot(IItemHandlerModifiable inventory, int index) {
+            super(inventory, index);
+        }
+
+        @Override
+        public boolean isItemValidPhantom(ItemStack stack) {
+            return super.isItemValidPhantom(stack) && getBaseMetaTileEntity().isItemValidForSlot(getSlotIndex(), stack);
+        }
+
+        @Override
+        public void onSlotChanged() {
+            super.onSlotChanged();
+            onInventoryUpdate(getSlotIndex());
+        }
+    }
+
+    private static final UIInfo<?, ?> IndustrialApiaryUI =
+            GT_UIInfos.GTTileEntityUIFactory.apply(GT_ModularUIContainer_IndustrialApiary::new);
+
+    private static class GT_ModularUIContainer_IndustrialApiary extends ModularUIContainer {
+
+        public GT_ModularUIContainer_IndustrialApiary(ModularUIContext context, ModularWindow mainWindow) {
+            super(context, mainWindow);
+        }
+
+        private final int playerInventorySlot = 36;
+
+        @Override
+        public ItemStack slotClick(int aSlotNumber, int aMouseclick, int aShifthold, EntityPlayer aPlayer) {
+            if (!(aSlotNumber >= playerInventorySlot + 2 && aSlotNumber < playerInventorySlot + 2 + 4))
+                return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            if (aShifthold == 5) return null;
+            if (aShifthold != 0) return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            if (aMouseclick > 1) return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            ItemStack s = aPlayer.inventory.getItemStack();
+            if (s == null) return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            Slot slot = getSlot(aSlotNumber);
+            ItemStack slotStack = slot.getStack();
+            if (slotStack != null && !GT_Utility.areStacksEqual(slotStack, s)) return null; // super would replace item
+            if (slotStack == null && !slot.isItemValid(s))
+                return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            if (!GT_ApiaryUpgrade.isUpgrade(s)) return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            int max = GT_ApiaryUpgrade.getUpgrade(s).getMaxNumber();
+            if (slotStack != null) max = Math.max(0, max - slotStack.stackSize);
+            max = Math.min(max, s.stackSize);
+            if (max == 0) return null;
+            if (aMouseclick == 1) max = 1;
+            if (max == s.stackSize) return super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            ItemStack newStack = s.splitStack(s.stackSize - max);
+            ItemStack result = super.slotClick(aSlotNumber, aMouseclick, aShifthold, aPlayer);
+            aPlayer.inventory.setItemStack(newStack);
+            return result;
+        }
+
+        @Override
+        public ItemStack transferStackInSlot(EntityPlayer aPlayer, int aSlotIndex) {
+            Slot s = getSlot(aSlotIndex);
+            if (s == null) return super.transferStackInSlot(aPlayer, aSlotIndex);
+            if (aSlotIndex >= playerInventorySlot) return super.transferStackInSlot(aPlayer, aSlotIndex);
+            ItemStack aStack = s.getStack();
+            if (aStack == null) return super.transferStackInSlot(aPlayer, aSlotIndex);
+            if (!GT_ApiaryUpgrade.isUpgrade(aStack)) return super.transferStackInSlot(aPlayer, aSlotIndex);
+            for (int i = playerInventorySlot + 2; i < playerInventorySlot + 2 + 4; i++) {
+                Slot iSlot = getSlot(i);
+                ItemStack iStack = iSlot.getStack();
+                if (iStack == null) {
+                    if (!iSlot.isItemValid(aStack)) continue;
+                } else {
+                    if (!GT_Utility.areStacksEqual(aStack, iStack)) continue;
+                }
+                int max = GT_ApiaryUpgrade.getUpgrade(aStack).getMaxNumber();
+                if (iStack == null) {
+                    max = Math.min(max, aStack.stackSize);
+                    ItemStack newstack = aStack.splitStack(max);
+                    iSlot.putStack(newstack);
+                } else {
+                    max = Math.max(0, max - iStack.stackSize);
+                    max = Math.min(max, aStack.stackSize);
+                    iStack.stackSize += max;
+                    aStack.stackSize -= max;
+                    iSlot.onSlotChanged();
+                }
+                if (aStack.stackSize == 0) s.putStack(null);
+                else s.onSlotChanged();
+                break;
+            }
+            return null;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java
index 8616b98fae..14a213b156 100644
--- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java
+++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java
@@ -7,11 +7,23 @@ import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE_GLOW;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TELEPORTER_GLOW;
 
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DrawableWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.Materials;
+import gregtech.api.gui.modularui.GT_UIInfos;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.gui.modularui.GUITextureSet;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.modularui.IAddGregtechLogo;
+import gregtech.api.interfaces.modularui.IAddUIWidgets;
 import gregtech.api.interfaces.tileentity.IEnergyConnected;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.BaseMetaTileEntity;
@@ -19,10 +31,8 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank;
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_Config;
 import gregtech.api.util.GT_Utility;
-import gregtech.common.gui.GT_Container_MicrowaveEnergyTransmitter;
-import gregtech.common.gui.GT_GUIContainer_MicrowaveEnergyTransmitter;
+import java.util.function.Consumer;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumChatFormatting;
@@ -30,7 +40,8 @@ import net.minecraft.world.World;
 import net.minecraftforge.common.DimensionManager;
 import net.minecraftforge.fluids.FluidStack;
 
-public class GT_MetaTileEntity_MicrowaveEnergyTransmitter extends GT_MetaTileEntity_BasicTank {
+public class GT_MetaTileEntity_MicrowaveEnergyTransmitter extends GT_MetaTileEntity_BasicTank
+        implements IAddGregtechLogo, IAddUIWidgets {
 
     private static boolean sInterDimensionalTeleportAllowed = true;
     private static int mMaxLoss = 50;
@@ -71,21 +82,11 @@ public class GT_MetaTileEntity_MicrowaveEnergyTransmitter extends GT_MetaTileEnt
     public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
         if (aBaseMetaTileEntity.isClientSide()) return true;
         this.hasBlock = checkForBlock();
-        aBaseMetaTileEntity.openGUI(aPlayer);
+        GT_UIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer);
         return true;
     }
 
     @Override
-    public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_Container_MicrowaveEnergyTransmitter(aPlayerInventory, aBaseMetaTileEntity);
-    }
-
-    @Override
-    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_GUIContainer_MicrowaveEnergyTransmitter(aPlayerInventory, aBaseMetaTileEntity);
-    }
-
-    @Override
     public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
         return new GT_MetaTileEntity_MicrowaveEnergyTransmitter(
                 this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
@@ -415,4 +416,82 @@ public class GT_MetaTileEntity_MicrowaveEnergyTransmitter extends GT_MetaTileEnt
     public ITexture[][][] getTextureSet(ITexture[] aTextures) {
         return null;
     }
+
+    @Override
+    public boolean useModularUI() {
+        return true;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        builder.widget(new DrawableWidget()
+                        .setDrawable(GT_UITextures.PICTURE_SCREEN_BLACK)
+                        .setSize(90, 72)
+                        .setPos(43, 4))
+                .widget(TextWidget.dynamicString(() -> "X: " + GT_Utility.parseNumberToString(mTargetX))
+                        .setDefaultColor(COLOR_TEXT_WHITE.get())
+                        .setPos(46, 8))
+                .widget(TextWidget.dynamicString(() -> "Y: " + GT_Utility.parseNumberToString(mTargetY))
+                        .setDefaultColor(COLOR_TEXT_WHITE.get())
+                        .setPos(46, 16))
+                .widget(TextWidget.dynamicString(() -> "Z: " + GT_Utility.parseNumberToString(mTargetZ))
+                        .setDefaultColor(COLOR_TEXT_WHITE.get())
+                        .setPos(46, 24))
+                .widget(TextWidget.dynamicString(() -> "Dim: " + GT_Utility.parseNumberToString(mTargetD))
+                        .setDefaultColor(COLOR_TEXT_WHITE.get())
+                        .setPos(46, 32))
+                .widget(TextWidget.dynamicString(
+                                () -> "Dim Valid: " + (GT_Utility.isRealDimension(mTargetD) ? "Yes" : "No"))
+                        .setDefaultColor(COLOR_TEXT_WHITE.get())
+                        .setEnabled(widget -> hasDimensionalTeleportCapability())
+                        .setPos(46, 40))
+                .widget(new FakeSyncWidget.FluidStackSyncer(() -> mFluid, val -> mFluid = val));
+
+        addChangeNumberButtons(builder, GT_UITextures.OVERLAY_BUTTON_MINUS_LARGE, -512, -64, 7);
+        addChangeNumberButtons(builder, GT_UITextures.OVERLAY_BUTTON_MINUS_SMALL, -16, -1, 25);
+        addChangeNumberButtons(builder, GT_UITextures.OVERLAY_BUTTON_PLUS_SMALL, 16, 1, 133);
+        addChangeNumberButtons(builder, GT_UITextures.OVERLAY_BUTTON_PLUS_LARGE, 512, 64, 151);
+
+        addChangeNumberButton(
+                builder, GT_UITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> mTargetD += val, -16, -8, 7, 58);
+        addChangeNumberButton(
+                builder, GT_UITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> mTargetD += val, -4, -1, 25, 58);
+        addChangeNumberButton(builder, GT_UITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> mTargetD += val, 4, 1, 133, 58);
+        addChangeNumberButton(builder, GT_UITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> mTargetD += val, 16, 8, 151, 58);
+    }
+
+    private void addChangeNumberButtons(
+            ModularWindow.Builder builder, IDrawable overlay, int addNumberShift, int addNumber, int xPos) {
+        addChangeNumberButton(builder, overlay, val -> mTargetX += val, addNumberShift, addNumber, xPos, 4);
+        addChangeNumberButton(builder, overlay, val -> mTargetY += val, addNumberShift, addNumber, xPos, 22);
+        addChangeNumberButton(builder, overlay, val -> mTargetZ += val, addNumberShift, addNumber, xPos, 40);
+    }
+
+    private void addChangeNumberButton(
+            ModularWindow.Builder builder,
+            IDrawable overlay,
+            Consumer<Integer> setter,
+            int addNumberShift,
+            int addNumber,
+            int xPos,
+            int yPos) {
+        builder.widget(new ButtonWidget()
+