Merge pull request #300 from moller21/cover_guis

Cover guis

13 files changed, 1514 insertions, 36 deletions

diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Arm.java b/src/main/java/gregtech/common/covers/GT_Cover_Arm.java
index 70d0340d1f..77558e001d 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_Arm.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_Arm.java
@@ -1,58 +1,162 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiFakeItemButton;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconButton;
+import gregtech.api.gui.widgets.GT_GuiIntegerTextBox;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IMachineProgress;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.fluids.Fluid;
 
 public class GT_Cover_Arm
         extends GT_CoverBehavior {
     public final int mTickRate;
+    //msb converted, 2nd : direction (1=export)
+    //right 14 bits: internalSlot, next 14 bits adjSlot, 0 = all, slot = -1
+    protected final static int EXPORT_MASK = 0x40000000;
+    protected final static int SLOT_ID_MASK = 0x3FFF;
+    protected final static int SLOT_ID_MIN = 0;
+    protected final static int CONVERTED_BIT = 0x80000000;
 
     public GT_Cover_Arm(int aTickRate) {
         this.mTickRate = aTickRate;
     }
 
     public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) {
-        if ((aCoverVariable == 0) || (((aTileEntity instanceof IMachineProgress)) && (!((IMachineProgress) aTileEntity).isAllowedToWork()))) {
+        if ((((aTileEntity instanceof IMachineProgress)) && (!((IMachineProgress) aTileEntity).isAllowedToWork()))) {
             return aCoverVariable;
         }
-        TileEntity tTileEntity = aTileEntity.getTileEntityAtSide(aSide);
-        //aTileEntity.decreaseStoredEnergyUnits(1L, true);
+
+        //Convert from ver. 5.09.33.50, check if 3 last bits are equal
+        if ((aCoverVariable >>> 29) == 0) {
+            aCoverVariable = CONVERTED_BIT | (((aCoverVariable+1) & SLOT_ID_MASK) << 14) | EXPORT_MASK;
+        } else if ((aCoverVariable >>> 29) == 7) {
+            aCoverVariable = CONVERTED_BIT | Math.min(Math.abs(aCoverVariable-1), SLOT_ID_MASK);
+        }
+
+        boolean usePower = false;
         if (aTileEntity.getUniversalEnergyCapacity() >= 128L) {
             if (aTileEntity.isUniversalEnergyStored(256L)) {
-                aTileEntity.decreaseStoredEnergyUnits(4 * GT_Utility.moveOneItemStackIntoSlot(aCoverVariable > 0 ? aTileEntity : tTileEntity, aCoverVariable > 0 ? tTileEntity : aTileEntity, aCoverVariable > 0 ? aSide : GT_Utility.getOppositeSide(aSide), Math.abs(aCoverVariable) - 1, null, false, (byte) 64, (byte) 1, (byte) 64, (byte) 1), true);
+                usePower = true;
+            } else {
+                return aCoverVariable;
             }
+        }
+
+        TileEntity toTile, fromTile;
+        int toSlot, fromSlot;
+
+        if ((aCoverVariable & EXPORT_MASK) > 0) {
+            fromTile = (TileEntity) aTileEntity;
+            toTile = aTileEntity.getTileEntityAtSide(aSide);
+            fromSlot = aCoverVariable & SLOT_ID_MASK;
+            toSlot = (aCoverVariable>>14) & SLOT_ID_MASK;
         } else {
-            GT_Utility.moveOneItemStackIntoSlot(aCoverVariable > 0 ? aTileEntity : tTileEntity, aCoverVariable > 0 ? tTileEntity : aTileEntity, aCoverVariable > 0 ? aSide : GT_Utility.getOppositeSide(aSide), Math.abs(aCoverVariable) - 1, null, false, (byte) 64, (byte) 1, (byte) 64, (byte) 1);
+            fromTile = aTileEntity.getTileEntityAtSide(aSide);
+            toTile = (TileEntity) aTileEntity;
+            fromSlot = (aCoverVariable>>14) & SLOT_ID_MASK;
+            toSlot = aCoverVariable & SLOT_ID_MASK;
         }
+
+        byte movedItems = 0;
+        if(fromSlot > 0 && toSlot > 0) {
+            if (fromTile instanceof IInventory && toTile instanceof IInventory)
+                movedItems = GT_Utility.moveFromSlotToSlot((IInventory) fromTile, (IInventory) toTile, fromSlot-1, toSlot-1, null, false, (byte)64, (byte)1, (byte)64, (byte)1);
+        } else if (toSlot > 0) {
+            byte side;
+            if ((aCoverVariable & EXPORT_MASK) > 0)
+                side = aSide;
+            else
+                side = GT_Utility.getOppositeSide(aSide);
+            movedItems = GT_Utility.moveOneItemStackIntoSlot(fromTile, toTile, side, toSlot-1, null, false, (byte)64, (byte)1, (byte)64, (byte)1);
+        } else if (fromSlot > 0) {
+            byte toSide;
+            if ((aCoverVariable & EXPORT_MASK) > 0)
+                toSide = aSide;
+            else
+                toSide = GT_Utility.getOppositeSide(aSide);
+            if (fromTile instanceof IInventory)
+                movedItems = GT_Utility.moveFromSlotToSide((IInventory) fromTile, toTile, fromSlot-1, toSide, null, false, (byte)64, (byte)1, (byte)64, (byte)1);
+        } else {
+            byte fromSide, toSide;
+            if ((aCoverVariable & EXPORT_MASK) > 0) {
+                fromSide = aSide;
+                toSide = GT_Utility.getOppositeSide(aSide);
+            } else {
+                fromSide = GT_Utility.getOppositeSide(aSide);
+                toSide = aSide;
+            }
+            movedItems = GT_Utility.moveOneItemStack(fromTile, toTile, fromSide, toSide, null, false, (byte)64, (byte)1, (byte)64, (byte)1);
+        }
+
+        if (usePower)
+            aTileEntity.decreaseStoredEnergyUnits(4*movedItems, true);
+
         return aCoverVariable;
     }
 
     public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        int step = 0;
         if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) {
-            aCoverVariable += aPlayer.isSneaking() ? 256 : 16;
+            step += aPlayer.isSneaking() ? 256 : 16;
         } else {
-            aCoverVariable += aPlayer.isSneaking() ? 256 : 16;
+            step -= aPlayer.isSneaking() ? 256 : 16;
         }
-        GT_Utility.sendChatToPlayer(aPlayer, (aCoverVariable > 0 ? trans("001","Puts out into adjacent Slot #") : trans("002","Grabs in for own Slot #")) + (Math.abs(aCoverVariable) - 1));
+        aCoverVariable = getNewVar(aCoverVariable, step);
+        sendMessageToPlayer(aPlayer, aCoverVariable);
         return aCoverVariable;
     }
 
     public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) {
-            aCoverVariable++;
-        } else {
-            aCoverVariable--;
-        }
-        GT_Utility.sendChatToPlayer(aPlayer, (aCoverVariable > 0 ? trans("001","Puts out into adjacent Slot #") : trans("002","Grabs in for own Slot #")) + (Math.abs(aCoverVariable) - 1));
+        int step = (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) ? 1 : -1;
+        aCoverVariable = getNewVar(aCoverVariable, step);
+        sendMessageToPlayer(aPlayer, aCoverVariable);
         aTileEntity.setCoverDataAtSide(aSide, aCoverVariable);
         return true;
     }
 
+    private void sendMessageToPlayer(EntityPlayer aPlayer, int var) {
+        if ((var & EXPORT_MASK) != 0)
+            GT_Utility.sendChatToPlayer(aPlayer, trans("001","Puts out into adjacent Slot #") + (((var >> 14) & SLOT_ID_MASK) - 1));
+        else
+            GT_Utility.sendChatToPlayer(aPlayer, trans("002","Grabs in for own Slot #") + ((var & SLOT_ID_MASK) - 1));
+    }
+
+    private int getNewVar(int var, int step) {
+        int intSlot = (var & SLOT_ID_MASK);
+        int adjSlot = (var >> 14) & SLOT_ID_MASK;
+        if ((var & EXPORT_MASK) == 0) {
+            int x = (intSlot + step);
+            if (x > SLOT_ID_MASK )
+                return createVar(0, SLOT_ID_MASK, 0);
+            else if (x < 1)
+                return createVar(-step - intSlot + 1, 0, EXPORT_MASK);
+            else
+                return createVar(0, x, 0);
+        } else {
+            int x = (adjSlot - step);
+            if (x > SLOT_ID_MASK)
+                return createVar(SLOT_ID_MASK, 0, EXPORT_MASK);
+            else if (x < 1)
+                return createVar(0, +step - adjSlot + 1, 0);
+            else
+                return createVar(x, 0, EXPORT_MASK);
+        }
+    }
+
+    private int createVar(int adjSlot, int intSlot, int export){
+        return  CONVERTED_BIT | export | ((adjSlot & SLOT_ID_MASK) << 14) | (intSlot & SLOT_ID_MASK);
+    }
+
     public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return true;
     }
@@ -92,4 +196,239 @@ public class GT_Cover_Arm
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return this.mTickRate;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GT_Cover_Arm.GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private GT_GuiIntegerTextBox intSlot, adjSlot;
+        private GT_GuiFakeItemButton intSlotIcon, adjSlotIcon;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        private final String ANY_TEXT = trans("ANY", "Any");
+
+        private boolean export;
+        private int internalSlotID, adjacentSlotID;
+
+        private final int maxIntSlot, maxAdjSlot;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            export = (coverVariable & EXPORT_MASK) > 0;
+            internalSlotID = (coverVariable & SLOT_ID_MASK);
+            adjacentSlotID = (coverVariable >> 14) & SLOT_ID_MASK;
+
+            new GT_GuiIconButton(this, 0, startX + spaceX * 0, startY + spaceY * 0, GT_GuiIcon.EXPORT).setTooltipText(trans("006", "Export"));
+            new GT_GuiIconButton(this, 1, startX + spaceX * 1, startY + spaceY * 0, GT_GuiIcon.IMPORT).setTooltipText(trans("007", "Import"));
+
+            intSlot = new GT_GuiIntegerTextBox(this, 2, startX + spaceX * 0, startY + spaceY * 1 + 2, spaceX * 2+5, 12);
+            setBoxText(intSlot, internalSlotID-1);
+            intSlot.setMaxStringLength(6);
+
+            adjSlot = new GT_GuiIntegerTextBox(this, 3, startX + spaceX * 0, startY + spaceY * 2 + 2, spaceX * 2+5, 12);
+            setBoxText(adjSlot, adjacentSlotID-1);
+            adjSlot.setMaxStringLength(6);
+
+            //intSlotIcon = new GT_GuiFakeItemButton(this, startX + spaceX * 8-4, startY + spaceY * 1, GT_GuiIcon.SLOT_GRAY);
+            //adjSlotIcon = new GT_GuiFakeItemButton(this, startX + spaceX * 8-4, startY + spaceY * 2, GT_GuiIcon.SLOT_GRAY);
+
+            if (super.tile instanceof TileEntity && !super.tile.isDead()) {
+                maxIntSlot = tile.getSizeInventory()-1;
+
+                TileEntity adj = super.tile.getTileEntityAtSide(side);
+                if (adj instanceof IInventory)
+                    maxAdjSlot = ((IInventory) adj).getSizeInventory()-1;
+                else
+                    maxAdjSlot = -1;
+            } else {
+                maxIntSlot = -1;
+                maxAdjSlot = -1;
+            }
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            if (export)
+                this.getFontRenderer().drawString(trans("006", "Export"),  startX + spaceX*3, 4+startY+spaceY*0, 0xFF555555);
+            else
+                this.getFontRenderer().drawString(trans("007", "Import"),  startX + spaceX*3, 4+startY+spaceY*0, 0xFF555555);
+
+            this.getFontRenderer().drawString(trans("254", "Internal slot#"),     startX + spaceX*3, 4+startY+spaceY*1, 0xFF555555);
+            this.getFontRenderer().drawString(trans("255", "Adjacent slot#"),  startX + spaceX*3, 4+startY+spaceY*2, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            intSlot.setFocused(true);
+            updateButtons();
+
+            //updateInventorySlots();
+        }
+
+        @Override
+        public void buttonClicked(GuiButton btn) {
+            if (buttonClickable(btn.id)) {
+                export = btn.id == 0;
+                coverVariable = getNewCoverVariable();
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons() {
+            GuiButton b;
+            for (Object o : buttonList) {
+                b = (GuiButton) o;
+                b.enabled = buttonClickable(b.id);
+            }
+        }
+
+        @Override
+        public void onMouseWheel(int x, int y, int delta) {
+            for (GT_GuiIntegerTextBox box : textBoxes) {
+                if (box.isFocused()) {
+                    int step = Math.max(1, Math.abs(delta / 120));
+                    step = (isShiftKeyDown() ? 50 : isCtrlKeyDown() ? 5 : 1) * (delta > 0 ? step : -step);
+                    int maxSlot = box.id == 3 ? maxAdjSlot : maxIntSlot;
+                    int val = parseTextBox(box, maxSlot);
+                    if (val < 0)
+                        val = -1;
+                    val = val + step;
+
+                    if (maxSlot < val)
+                        if (maxSlot < 0)
+                            val =  -1;
+                        else
+                            val = maxSlot;
+                    else if (val < SLOT_ID_MIN)
+                        val =  -1;
+
+                    setBoxText(box, val);
+                    return;
+                }
+            }
+        }
+
+        @Override
+        public void applyTextBox(GT_GuiIntegerTextBox box) {
+            int val = -1;
+
+            if (box.id == 2) {
+                val = parseTextBox(box, maxIntSlot);
+                internalSlotID = val+1;
+            }
+            else if (box.id == 3) {
+                val = parseTextBox(box, maxAdjSlot);
+                adjacentSlotID = val+1;
+            }
+
+            setBoxText(box, val);
+            coverVariable = getNewCoverVariable();
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            //updateInventorySlots();
+        }
+
+        @Override
+        public void resetTextBox(GT_GuiIntegerTextBox box) {
+            int val = 0;
+            if (box.id == 2)
+                val = internalSlotID-1;
+            else if (box.id == 3)
+                val = adjacentSlotID-1;
+            setBoxText(box, val);
+        }
+
+        private void setBoxText(GT_GuiIntegerTextBox box, int val) {
+            box.setText( val < 0 ? ANY_TEXT : String.valueOf(val));
+        }
+
+        private int parseTextBox(GT_GuiIntegerTextBox box, int maxSlot) {
+            String text = box.getText();
+            if (text == null)
+                return -1;
+            text = text.trim();
+            if (text.startsWith(ANY_TEXT))
+                text = text.substring(ANY_TEXT.length());
+
+            if (text.isEmpty())
+                return -1;
+
+            int val;
+            try {
+                val = Integer.parseInt(text);
+            } catch (NumberFormatException e) {
+                return -1;
+            }
+
+            if (maxSlot < val)
+                if (maxSlot < 0)
+                    return -1;
+                else
+                    return maxSlot;
+            else if (val < SLOT_ID_MIN)
+                return SLOT_ID_MIN;
+            return val;
+        }
+
+        private int getNewCoverVariable() {
+            return (export ? EXPORT_MASK : 0) | ((adjacentSlotID & SLOT_ID_MASK) << 14) | (internalSlotID & SLOT_ID_MASK) | CONVERTED_BIT;
+        }
+
+        private boolean buttonClickable(int id) {
+            if (id == 0)
+                return !export;
+            return export;
+        }
+
+//        getStackInSlot wasn't available client side..
+//        private void updateInventorySlots() {
+//            updateInventorySlot(intSlotIcon, internalSlotID, true);
+//            updateInventorySlot(adjSlotIcon, adjacentSlotID, false);
+//        }
+//
+//        private void updateInventorySlot(GT_GuiFakeItemButton button, int slotID, boolean internal) {
+//            if (slotID == SLOT_ID_ANY) {
+//                button.setItem(null);
+//                return;
+//            }
+//
+//            if (super.tile instanceof TileEntity && !super.tile.isDead()) {
+//                TileEntity tile;
+//                if (internal)
+//                    tile = (TileEntity) super.tile;
+//                else
+//                    tile = super.tile.getTileEntityAtSide(side);
+//
+//                if (tile instanceof IInventory && ((IInventory) tile).getSizeInventory() >= slotID) {
+//                    ItemStack item = ((IInventory) tile).getStackInSlot(slotID);
+//                    button.setItem(item);
+//                    return;
+//                }
+//            }
+//            button.setItem(null);
+//        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java b/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java
index 96a2d4a2b8..9624b68464 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java
@@ -1,9 +1,15 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IMachineProgress;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.fluids.Fluid;
 
@@ -70,4 +76,78 @@ public class GT_Cover_ControlsWork
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 1;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GT_Cover_ControlsWork.GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            GuiButton b;
+            b = new GT_GuiIconButton(this, 0, startX + spaceX * 0, startY + spaceY * 0, GT_GuiIcon.REDSTONE_ON);
+            b = new GT_GuiIconButton(this, 1, startX + spaceX * 0, startY + spaceY * 1, GT_GuiIcon.REDSTONE_OFF);
+            b = new GT_GuiIconButton(this, 2, startX + spaceX * 0, startY + spaceY * 2, GT_GuiIcon.CROSS);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.fontRendererObj.drawString(trans("243", "Enable with Redstone"), 3+startX + spaceX*1, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString(trans("244", "Disable with Redstone"),3+startX + spaceX*1, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString(trans("245", "Disable machine"),              3+startX + spaceX*1, 4+startY+spaceY*2, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn) {
+            if (getClickable(btn.id)) {
+                coverVariable = getNewCoverVariable(btn.id);
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons() {
+            GuiButton b;
+            for (Object o : buttonList) {
+                b = (GuiButton) o;
+                b.enabled = getClickable(b.id);
+            }
+        }
+
+        private int getNewCoverVariable(int id) {
+            return id;
+        }
+
+        private boolean getClickable(int id) {
+            return id != coverVariable;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java b/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java
index d781f10915..303f358a34 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java
@@ -1,9 +1,15 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IMachineProgress;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.fluids.Fluid;
@@ -112,4 +118,124 @@ public class GT_Cover_Conveyor extends GT_CoverBehavior {
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return this.mTickRate;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GT_Cover_Conveyor.GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            GT_GuiIconButton b;
+            b = new GT_GuiIconButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.EXPORT).setTooltipText(trans("006","Export"));
+            b = new GT_GuiIconButton(this, 1, startX + spaceX*1, startY+spaceY*0, GT_GuiIcon.IMPORT).setTooltipText(trans("007","Import"));
+            b = new GT_GuiIconButton(this, 2, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.CHECKMARK).setTooltipText(trans("224","Ignore"));
+            b = new GT_GuiIconButton(this, 3, startX + spaceX*1, startY+spaceY*1, GT_GuiIcon.REDSTONE_ON).setTooltipText(trans("225","Conditional"));
+            b = new GT_GuiIconButton(this, 4, startX + spaceX*2, startY+spaceY*1, GT_GuiIcon.REDSTONE_OFF).setTooltipText(trans("226","Invert Condition"));
+            b = new GT_GuiIconButton(this, 5, startX + spaceX*0, startY+spaceY*2, GT_GuiIcon.ALLOW_INPUT).setTooltipText(trans("227","Allow Input"));
+            b = new GT_GuiIconButton(this, 6, startX + spaceX*1, startY+spaceY*2, GT_GuiIcon.BLOCK_INPUT).setTooltipText(trans("228","Block Input"));
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.fontRendererObj.drawString(trans("229","Import/Export" ),  startX + spaceX*3, 3+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString(trans("230","Conditional"),     startX + spaceX*3, 3+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString(trans("231", "Enable Input"),   startX + spaceX*3, 3+startY+spaceY*2, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            if (getClickable(btn.id)){
+                coverVariable = getNewCoverVariable(btn.id);
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            GuiButton b;
+            for (Object o : buttonList) {
+                b = (GuiButton) o;
+                b.enabled = getClickable(b.id);
+            }
+        }
+
+        private int getNewCoverVariable(int id) {
+            switch (id) {
+                case 0:
+                    return coverVariable & ~0x1;
+                case 1:
+                    return coverVariable | 0x1;
+                case 2:
+                    if (coverVariable > 5)
+                        return 0x6 | (coverVariable & ~0xE);
+                    return (coverVariable & ~0xE);
+                case 3:
+                    if (coverVariable > 5)
+                        return 0x8 | (coverVariable & ~0xE);
+                    return 0x2 | (coverVariable & ~0xE);
+                case 4:
+                    if (coverVariable > 5)
+                        return 0xA | (coverVariable & ~0xE);
+                    return (0x4 | (coverVariable & ~0xE));
+                case 5:
+                    if (coverVariable <= 5)
+                        return coverVariable + 6;
+                    break;
+                case 6:
+                    if (coverVariable > 5)
+                        return coverVariable - 6;
+            }
+            return coverVariable;
+        }
+
+        private boolean getClickable(int id) {
+            if (coverVariable < 0 | 11 < coverVariable)
+                return false;
+
+            switch (id) {
+                case 0: case 1:
+                    return (0x1 & coverVariable) != id;
+                case 2:
+                    return (coverVariable % 6) >= 2;
+                case 3:
+                    return (coverVariable % 6) < 2 | 4 <= (coverVariable % 6);
+                case 4:
+                    return (coverVariable % 6) < 4;
+                case 5:
+                    return coverVariable < 6;
+                case 6:
+                    return coverVariable >= 6;
+            }
+            return false;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java b/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java
index 963b519f34..f2a37dd3cc 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java
@@ -1,9 +1,16 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconButton;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IMachineProgress;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.fluids.Fluid;
 
@@ -31,10 +38,10 @@ public class GT_Cover_DoesWork
         aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 4;
         if(aCoverVariable <0){aCoverVariable = 3;}
         switch(aCoverVariable) {
-            case 0: GT_Utility.sendChatToPlayer(aPlayer, trans("018", "Normal")); break;
-            case 1: GT_Utility.sendChatToPlayer(aPlayer, trans("019", "Inverted")); break;
-            case 2: GT_Utility.sendChatToPlayer(aPlayer, trans("020", "Ready to work")); break;
-            case 3: GT_Utility.sendChatToPlayer(aPlayer, trans("021", "Not ready to work")); break;
+            case 0: GT_Utility.sendChatToPlayer(aPlayer, trans("018", "Normal")); break; // Progress scaled
+            case 1: GT_Utility.sendChatToPlayer(aPlayer, trans("019", "Inverted")); break; // ^ inverted
+            case 2: GT_Utility.sendChatToPlayer(aPlayer, trans("020", "Ready to work")); break; // Not Running
+            case 3: GT_Utility.sendChatToPlayer(aPlayer, trans("021", "Not ready to work")); break; // Running
         }
         return aCoverVariable;
     }
@@ -70,4 +77,112 @@ public class GT_Cover_DoesWork
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 5;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GT_Cover_DoesWork.GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            GuiButton b;
+            b = new GT_GuiIconButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.PROGRESS);
+            b = new GT_GuiIconButton(this, 1, startX + spaceX*1, startY+spaceY*0, GT_GuiIcon.CHECKMARK);
+            b = new GT_GuiIconCheckButton(this, 2, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            String s1, s2;
+            if ((coverVariable & 0x2) > 0)
+                s1 = trans("242", "Machine idle");
+            else
+                s1 = trans("241", "Recipe progress");
+            if ((coverVariable & 0x1) > 0)
+                s2 = trans("INVERTED","Inverted");
+            else
+                s2 = trans("NORMAL","Normal");
+            this.fontRendererObj.drawString(s1,  startX + spaceX*3, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString(s2,  startX + spaceX*3, 4+startY+spaceY*1, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            if (getClickable(btn.id)){
+                boolean state = false;
+                if (btn.id == 2)
+                    state = ((GT_GuiIconCheckButton) btn).isChecked();
+
+                coverVariable = getNewCoverVariable(btn.id, state);
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            GuiButton b;
+            for (Object o : buttonList) {
+                b = (GuiButton) o;
+                if(b.id == 2){
+                    ((GT_GuiIconCheckButton) b).setChecked((coverVariable & 0x1) > 0);
+                } else {
+                    b.enabled = getClickable(b.id);
+                }
+            }
+        }
+
+        private int getNewCoverVariable(int id, boolean buttonState) {
+            switch (id) {
+                case 0:
+                    return coverVariable & ~0x2;
+                case 1:
+                    return coverVariable | 0x2;
+                case 2:
+                    if (buttonState)
+                        return coverVariable & ~0x1;
+                    return coverVariable | 0x1;
+            }
+            return coverVariable;
+        }
+
+        private boolean getClickable(int id) {
+            switch (id) {
+                case 0:
+                    return (coverVariable & 0x2) > 0;
+                case 1:
+                    return (coverVariable & 0x2) == 0;
+                case 2:
+                    return true;
+            }
+            return false;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java
index 13aafe90df..d12034d3a7 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java
@@ -1,14 +1,20 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.items.GT_MetaBase_Item;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicBatteryBuffer;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Utility;
 import ic2.api.item.IElectricItem;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
@@ -141,4 +147,109 @@ public class GT_Cover_EUMeter
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 20;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            GuiButton b;
+            b = new GT_GuiIconCheckButton(this, 0, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("256", "Universal Storage"));
+            b = new GT_GuiIconCheckButton(this, 1, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("257", "Electricity Storage"));
+            b = new GT_GuiIconCheckButton(this, 2, startX + spaceX*0, startY+spaceY*2, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("258", "Steam Storage"));
+            b = new GT_GuiIconCheckButton(this, 3, startX + spaceX*4, startY+spaceY*1, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("259", "Average Electric Input"));
+            b = new GT_GuiIconCheckButton(this, 4, startX + spaceX*4, startY+spaceY*2, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("260", "Average Electric Output"));
+            b = new GT_GuiIconCheckButton(this, 5, startX + spaceX*4, startY+spaceY*0, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("261", "Electricity Storage(Including Batteries)"));
+            b = new GT_GuiIconCheckButton(this, 6, startX + spaceX*0, startY+spaceY*3+4, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            String s2;
+            if ((coverVariable & 0x1) > 0)
+                s2 = trans("INVERTED","Inverted");
+            else
+                s2 = trans("NORMAL","Normal");
+            this.fontRendererObj.drawString(s2,  startX + spaceX*1, 8+startY+spaceY*3, 0xFF555555);
+
+            this.fontRendererObj.drawString("Universal",
+                    startX + spaceX*1, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString("Int. EU",
+                    startX + spaceX*1, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString("Steam",
+                    startX + spaceX*1, 4+startY+spaceY*2, 0xFF555555);
+            this.fontRendererObj.drawString("Avg. Input",
+                    startX + spaceX*5, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString("Avg. Output",
+                    startX + spaceX*5, 4+startY+spaceY*2, 0xFF555555);
+            this.fontRendererObj.drawString("EU stored",
+                    startX + spaceX*5, 4+startY+spaceY*0, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            if (btn.id == 6 || !isEnabled(btn.id)){
+                coverVariable = getNewCoverVariable(btn.id, ((GT_GuiIconCheckButton) btn).isChecked());
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            for (Object o : buttonList)
+                ((GT_GuiIconCheckButton) o).setChecked(isEnabled(((GT_GuiIconCheckButton) o).id));
+        }
+
+        private int getNewCoverVariable(int id, boolean checked) {
+            if (id == 6) {
+                if (checked)
+                    return coverVariable & ~0x1;
+                else
+                    return coverVariable | 0x1;
+            }
+            return (coverVariable & 0x1) | (id << 1) ;
+        }
+
+        private boolean isEnabled(int id) {
+            if (id == 6)
+                return (coverVariable & 0x1) > 0;
+            return (coverVariable >> 1) == id;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java b/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java
index 0a213bb844..bc966d3f54 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java
@@ -184,8 +184,8 @@ public class GT_Cover_Fluidfilter extends GT_CoverBehavior {
             this.coverVariable = aCoverVariable;
 
             GT_GuiIconButton b;
-            b = new GT_GuiIconButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.EXPORT).setTooltipText(trans("232","Filter Input"));
-            b = new GT_GuiIconButton(this, 1, startX + spaceX*1, startY+spaceY*0, GT_GuiIcon.IMPORT).setTooltipText(trans("233","Filter Output"));
+            b = new GT_GuiIconButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.IMPORT).setTooltipText(trans("232","Filter Input"));
+            b = new GT_GuiIconButton(this, 1, startX + spaceX*1, startY+spaceY*0, GT_GuiIcon.EXPORT).setTooltipText(trans("233","Filter Output"));
             b = new GT_GuiIconButton(this, 2, startX + spaceX*0, startY+spaceY*2, GT_GuiIcon.BLOCK_INPUT).setTooltipText(trans("234", "Block Output"));
             b = new GT_GuiIconButton(this, 3, startX + spaceX*1, startY+spaceY*2, GT_GuiIcon.ALLOW_INPUT).setTooltipText(trans("235", "Allow Output"));
             b = new GT_GuiIconButton(this, 4, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.WHITELIST).setTooltipText(trans("236","Whitelist Fluid"));
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java
index 40706721c9..ed3d6fc3f9 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java
@@ -1,21 +1,45 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiFakeItemButton;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
+import gregtech.api.gui.widgets.GT_GuiIntegerTextBox;
 import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.fluids.Fluid;
 
 public class GT_Cover_ItemMeter
         extends GT_CoverBehavior {
+
+    // format:
+    private static final int SLOT_MASK = 0x3FFFFFF; // 0 = all, 1 = 0 ...
+    private static final int CONVERTED_BIT = 0x80000000;
+    private static final int INVERT_BIT = 0x40000000;
+
     public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) {
+        //Convert from ver. 5.09.33.50
+        if ((CONVERTED_BIT & aCoverVariable) == 0)
+            if (aCoverVariable == 0)
+                aCoverVariable = CONVERTED_BIT;
+            else if (aCoverVariable == 1)
+                aCoverVariable = CONVERTED_BIT | INVERT_BIT;
+            else if (aCoverVariable > 1)
+                aCoverVariable = CONVERTED_BIT | Math.min((aCoverVariable - 2), SLOT_MASK);
+
         int[] tSlots;
-        if (aCoverVariable < 2) {
+        if ((aCoverVariable & SLOT_MASK) > 0)
+            tSlots = new int[]{(aCoverVariable & SLOT_MASK) - 1};
+        else
             tSlots = aTileEntity.getAccessibleSlotsFromSide(aSide);
-        } else {
-            tSlots = new int[]{aCoverVariable - 2};
-        }
+
         int tMax = 0;
         int tUsed = 0;
         for (int i : tSlots) {
@@ -26,23 +50,39 @@ public class GT_Cover_ItemMeter
                     tUsed += (tStack.stackSize<<6)/tStack.getMaxStackSize();
             }
         }
+
+        boolean inverted = (aCoverVariable & INVERT_BIT) == INVERT_BIT;
         if(tUsed==0)//nothing
-            aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable == 1 ? 15 : 0));
+            aTileEntity.setOutputRedstoneSignal(aSide, (byte)(inverted ? 15 : 0));
         else if(tUsed >= tMax)//full
-            aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable == 1 ? 0 : 15));
+            aTileEntity.setOutputRedstoneSignal(aSide, (byte)(inverted ? 0 : 15));
         else//1-14 range
-            aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable == 1 ? 14-((14*tUsed)/tMax) : 1+((14*tUsed)/tMax)) );
+            aTileEntity.setOutputRedstoneSignal(aSide, (byte)(inverted ? 14-((14*tUsed)/tMax) : 1+((14*tUsed)/tMax)) );
         return aCoverVariable;
     }
 
     public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % (2 + aTileEntity.getSizeInventory());
-        switch(aCoverVariable) {
-            case 0: GT_Utility.sendChatToPlayer(aPlayer, trans("051", "Normal")); break;
-            case 1: GT_Utility.sendChatToPlayer(aPlayer, trans("052", "Inverted")); break;
-            default: GT_Utility.sendChatToPlayer(aPlayer, trans("053", "Slot: ") + (aCoverVariable - 2)); break;
+        if (aPlayer.isSneaking()) {
+            if ((aCoverVariable & INVERT_BIT) == INVERT_BIT) {
+                aCoverVariable = aCoverVariable & ~INVERT_BIT;
+                GT_Utility.sendChatToPlayer(aPlayer, trans("NORMAL","Normal"));
+            }
+            else {
+                aCoverVariable = aCoverVariable | INVERT_BIT;
+                GT_Utility.sendChatToPlayer(aPlayer, trans("INVERTED","Inverted"));
+            }
+            return aCoverVariable;
         }
-        return aCoverVariable;
+
+        int slot = (aCoverVariable & SLOT_MASK) + 1;
+        if (slot > aTileEntity.getSizeInventory() || slot > SLOT_MASK)
+            slot = 0;
+
+        if (slot == 0)
+            GT_Utility.sendChatToPlayer(aPlayer, trans("053", "Slot: ") + trans("ALL", "All"));
+        else
+            GT_Utility.sendChatToPlayer(aPlayer, trans("053", "Slot: ") + (slot - 1));
+        return CONVERTED_BIT | (aCoverVariable & INVERT_BIT) | slot;
     }
 
     public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
@@ -76,4 +116,186 @@ public class GT_Cover_ItemMeter
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 5;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private final GT_GuiIconCheckButton button;
+        private final GT_GuiIntegerTextBox intSlot;
+        private final GT_GuiFakeItemButton intSlotIcon;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        private final int maxSlot;
+
+        private final String ALL = trans("ALL", "All");
+        private final String INVERTED = trans("INVERTED","Inverted");
+        private final String NORMAL = trans("NORMAL","Normal");
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            button = new GT_GuiIconCheckButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF);
+
+            intSlot = new GT_GuiIntegerTextBox(this, 1, startX + spaceX * 0, startY + spaceY * 1 + 2, spaceX * 2+5, 12);
+            intSlot.setMaxStringLength(6);
+
+            //only shows if opened gui of block sadly, should've used container.
+            intSlotIcon = new GT_GuiFakeItemButton(this, startX + spaceX * 8-4, startY + spaceY * 1, GT_GuiIcon.SLOT_GRAY);
+
+            if (tile instanceof TileEntity && !super.tile.isDead())
+                maxSlot = Math.min(tile.getSizeInventory() - 1, SLOT_MASK-1);
+            else
+                maxSlot = -1;
+
+            if (maxSlot == -1)
+                intSlot.setEnabled(false);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            if ((coverVariable & 0x1) > 0)
+                this.getFontRenderer().drawString(INVERTED,  startX + spaceX*3, 4+startY+spaceY*0, 0xFF555555);
+            else
+                this.getFontRenderer().drawString(NORMAL,  startX + spaceX*3, 4+startY+spaceY*0, 0xFF555555);
+
+            this.getFontRenderer().drawString(trans("254", "Internal slot#"),     startX + spaceX*3, 4+startY+spaceY*1, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            update();
+            if (intSlot.isEnabled())
+                intSlot.setFocused(true);
+        }
+
+        @Override
+        public void buttonClicked(GuiButton btn) {
+            if (isInverted())
+                coverVariable = (coverVariable & ~INVERT_BIT);
+            else
+                coverVariable = (coverVariable | INVERT_BIT);
+
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            update();
+        }
+
+        private void update() {
+            resetTextBox(intSlot);
+            button.setChecked(isInverted());
+
+            int slot = getSlot();
+            if (slot < 0) {
+                intSlotIcon.setItem(null);
+                return;
+            }
+            if (tile instanceof TileEntity && !super.tile.isDead()) {
+                if (tile.getSizeInventory() >= slot) {
+                    ItemStack item = tile.getStackInSlot(slot);
+                    intSlotIcon.setItem(item);
+                    return;
+                }
+            }
+            intSlotIcon.setItem(null);
+        }
+
+        @Override
+        public void onMouseWheel(int x, int y, int delta) {
+            for (GT_GuiIntegerTextBox box : textBoxes) {
+                if (box.isFocused()) {
+                    int step = Math.max(1, Math.abs(delta / 120));
+                    step = (isShiftKeyDown() ? 50 : isCtrlKeyDown() ? 5 : 1) * (delta > 0 ? step : -step);
+                    int val = parseTextBox(box);
+
+                    if (val < 0)
+                        val = -1;
+
+                    val = val + step;
+
+                    if (val < 0)
+                        val = -1;
+                    else if (val > maxSlot )
+                        val = maxSlot;
+
+                    box.setText(val < 0 ? ALL : String.valueOf(val));
+                    return;
+                }
+            }
+        }
+
+        @Override
+        public void applyTextBox(GT_GuiIntegerTextBox box) {
+            int val = parseTextBox(box);
+
+            if (val >= 0)
+                coverVariable = val + 1;
+
+            coverVariable = coverVariable | CONVERTED_BIT | (coverVariable & INVERT_BIT);
+
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            update();
+        }
+
+        @Override
+        public void resetTextBox(GT_GuiIntegerTextBox box) {
+            box.setText(getSlot() < 0 ? ALL : String.valueOf(getSlot()));
+        }
+
+        private int parseTextBox(GT_GuiIntegerTextBox box) {
+            String text = box.getText();
+            if (text == null)
+                return -1;
+            text = text.trim();
+            if (text.startsWith(ALL))
+                text = text.substring(ALL.length());
+
+            if (text.isEmpty())
+                return -1;
+
+            int val;
+            try {
+                val = Integer.parseInt(text);
+            } catch (NumberFormatException e) {
+                return -1;
+            }
+
+            if (val < 0)
+                return -1;
+            else if (maxSlot < val)
+                return maxSlot;
+            return val;
+        }
+
+        private boolean isInverted() {
+            return ((coverVariable & INVERT_BIT) == 0);
+        }
+
+        private int getSlot() {
+            if ((coverVariable & SLOT_MASK) == 0)
+                return -1;
+            return (coverVariable & SLOT_MASK) - 1;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java
index 5a0bb2e7d2..9ca2f77d62 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java
@@ -1,8 +1,14 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.Fluid;
@@ -42,9 +48,9 @@ public class GT_Cover_LiquidMeter
 
     public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
         if (aCoverVariable == 0) {
-            GT_Utility.sendChatToPlayer(aPlayer, trans("054", "Inverted"));
-        } else {
             GT_Utility.sendChatToPlayer(aPlayer, trans("055", "Normal"));
+        } else {
+            GT_Utility.sendChatToPlayer(aPlayer, trans("054", "Inverted"));
         }
         return aCoverVariable == 0 ? 1 : 0;
     }
@@ -80,4 +86,82 @@ public class GT_Cover_LiquidMeter
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 5;
     }
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+            new GT_GuiIconCheckButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            String s2;
+            if (coverVariable == 0)
+                s2 = trans("INVERTED","Inverted");
+            else
+                s2 = trans("NORMAL","Normal");
+
+            this.fontRendererObj.drawString(s2,  startX + spaceX*1, 4+startY+spaceY*0, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            boolean state = false;
+            if (btn.id == 0)
+                state = ((GT_GuiIconCheckButton) btn).isChecked();
+
+            coverVariable = getNewCoverVariable(btn.id, state);
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            GuiButton b;
+            for (Object o : buttonList) {
+                b = (GuiButton) o;
+                if(b.id == 0)
+                    ((GT_GuiIconCheckButton) b).setChecked(coverVariable == 0);
+            }
+        }
+
+        private int getNewCoverVariable(int id, boolean buttonState) {
+            if (id == 0) {
+                if (buttonState)
+                    return coverVariable | 0x1;
+                else
+                    return coverVariable & ~0x1;
+            }
+            return coverVariable;
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java b/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java
index 3316b204dc..43160aa908 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java
@@ -1,12 +1,18 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.items.GT_MetaGenerated_Tool;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
@@ -139,5 +145,119 @@ public class GT_Cover_NeedMaintainance extends GT_CoverBehavior {
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 60;
     }
+    /**
+     * GUI Stuff
+     */
 
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final String[] tooltiptext = {
+                trans("056", "Emit if 1 Maintenance Needed"),
+                trans("058", "Emit if 2 Maintenance Needed"),
+                trans("060", "Emit if 3 Maintenance Needed"),
+                trans("062", "Emit if 4 Maintenance Needed"),
+                trans("064", "Emit if 5 Maintenance Needed"),
+                trans("066", "Emit if rotor needs maintenance low accuracy mod"),
+                trans("068", "Emit if rotor needs maintenance high accuracy mod"),
+        };
+
+        private final String[] buttontext = {
+                trans("247", "1 Issue"),
+                trans("248", "2 Issues"),
+                trans("249", "3 Issues"),
+                trans("250", "4 Issues"),
+                trans("251", "5 Issues"),
+                trans("252", "Rotor < 80%"),
+                trans("253", "Rotor < 100%"),
+
+                trans("INVERTED","Inverted"),
+                trans("NORMAL","Normal"),
+        };
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            GuiButton b;
+            b = new GT_GuiIconCheckButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[0]);
+            b = new GT_GuiIconCheckButton(this, 1, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[1]);
+            b = new GT_GuiIconCheckButton(this, 2, startX + spaceX*0, startY+spaceY*2, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[2]);
+            b = new GT_GuiIconCheckButton(this, 3, startX + spaceX*0, startY+spaceY*3, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[3]);
+            b = new GT_GuiIconCheckButton(this, 4, startX + spaceX*4 + 4, startY+spaceY*0, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[4]);
+            b = new GT_GuiIconCheckButton(this, 5, startX + spaceX*4 + 4, startY+spaceY*1, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[5]);
+            b = new GT_GuiIconCheckButton(this, 6, startX + spaceX*4 + 4, startY+spaceY*2, GT_GuiIcon.CHECKMARK, null).setTooltipText(tooltiptext[6]);
+            b = new GT_GuiIconCheckButton(this, 7, startX + spaceX*4 + 4, startY+spaceY*3, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF);
+        }
+
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+
+            this.fontRendererObj.drawString(buttontext[0],startX + spaceX*1, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString(buttontext[1],startX + spaceX*1, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString(buttontext[2],startX + spaceX*1, 4+startY+spaceY*2, 0xFF555555);
+            this.fontRendererObj.drawString(buttontext[3],startX + spaceX*1, 4+startY+spaceY*3, 0xFF555555);
+            this.fontRendererObj.drawString(buttontext[4],startX + spaceX*5 + 4, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString(buttontext[5],startX + spaceX*5 + 4, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString(buttontext[6],startX + spaceX*5 + 4, 4+startY+spaceY*2, 0xFF555555);
+            //                                          inverted        normal
+            String s2 = ((coverVariable & 0x1) > 0) ? buttontext[7] : buttontext[8];
+            this.fontRendererObj.drawString(s2,  startX + spaceX*5 + 4, 4+startY+spaceY*3, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            if (btn.id == 7 || !isEnabled(btn.id)){
+                coverVariable = getNewCoverVariable(btn.id, ((GT_GuiIconCheckButton) btn).isChecked());
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            for (Object o : buttonList)
+                ((GT_GuiIconCheckButton) o).setChecked(isEnabled(((GT_GuiIconCheckButton) o).id));
+        }
+
+        private int getNewCoverVariable(int id, boolean checked) {
+            if (id == 7) {
+                if (checked)
+                    return coverVariable & ~0x1;
+                else
+                    return coverVariable | 0x1;
+            }
+            return (coverVariable & 0x1) | (id << 1) ;
+        }
+
+        private boolean isEnabled(int id) {
+            if (id == 7)
+                return (coverVariable & 0x1) > 0;
+            return (coverVariable >>> 1) == id;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_PlayerDetector.java b/src/main/java/gregtech/common/covers/GT_Cover_PlayerDetector.java
index 9e6c764170..57f52ab42d 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_PlayerDetector.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_PlayerDetector.java
@@ -1,9 +1,15 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraftforge.fluids.Fluid;
@@ -94,5 +100,79 @@ public class GT_Cover_PlayerDetector extends GT_CoverBehavior {
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 20;
     }
+    /**
+     * GUI Stuff
+     */
 
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            new GT_GuiIconCheckButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("068", "Emit if any Player is close"));
+            new GT_GuiIconCheckButton(this, 1, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("069", "Emit if other Player is close"));
+            new GT_GuiIconCheckButton(this, 2, startX + spaceX*0, startY+spaceY*2, GT_GuiIcon.CHECKMARK, null)
+                    .setTooltipText(trans("070", "Emit if you are close"));
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.fontRendererObj.drawString("Any player",
+                    startX + spaceX*1, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString("Other players",
+                    startX + spaceX*1, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString("Only owner",
+                    startX + spaceX*1, 4+startY+spaceY*2, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            if (!isEnabled(btn.id)){
+                coverVariable = getNewCoverVariable(btn.id, ((GT_GuiIconCheckButton) btn).isChecked());
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            for (Object o : buttonList)
+                ((GT_GuiIconCheckButton) o).setChecked(isEnabled(((GT_GuiIconCheckButton) o).id));
+        }
+
+        private int getNewCoverVariable(int id, boolean checked) {
+            return id;
+        }
+
+        private boolean isEnabled(int id) {
+            return coverVariable == id;
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Pump.java b/src/main/java/gregtech/common/covers/GT_Cover_Pump.java
index 364229f6f8..a6f7d653b9 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_Pump.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_Pump.java
@@ -2,13 +2,13 @@ package gregtech.common.covers;
 
 import gregtech.api.enums.GT_Values;
 import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
 import gregtech.api.gui.widgets.GT_GuiIconButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IMachineProgress;
 import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
-import gregtech.api.gui.widgets.GT_GuiIcon;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.common.util.ForgeDirection;
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java b/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java
index a359d20aa9..1407311b88 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java
@@ -1,7 +1,12 @@
 package gregtech.common.covers;
 
 import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIntegerTextBox;
+import gregtech.api.interfaces.IGuiScreen;
 import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
 import net.minecraft.entity.player.EntityPlayer;
@@ -78,4 +83,118 @@ public abstract class GT_Cover_RedstoneWirelessBase
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 1;
     }
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private GT_GuiIntegerTextBox fBox;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            fBox = new GT_GuiIntegerTextBoxWithMinus(this, 2,startX + spaceX*0,startY+spaceY*0 + 2, spaceX*4-3,12);
+            fBox.setText(String.valueOf(coverVariable));
+            fBox.setMaxStringLength(12);
+
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.getFontRenderer().drawString(trans("246","Frequency" ),  startX + spaceX*4, 4+startY+spaceY*0, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            fBox.setFocused(true);
+        }
+
+        @Override
+        public void onMouseWheel(int x, int y, int delta) {
+            for (GT_GuiIntegerTextBox box : textBoxes){
+                if (box.isFocused()) {
+                    int step = Math.max(1, Math.abs(delta / 120));
+                    step = (isShiftKeyDown() ? 1000 : isCtrlKeyDown() ? 50 : 1) * (delta > 0 ? step : -step);
+                    long i;
+                    try {
+                        i = Long.parseLong(box.getText());
+                    } catch (NumberFormatException e) {
+                        return;
+                    }
+                    i = i + step;
+                    if (i > Integer.MAX_VALUE)
+                        i = Integer.MAX_VALUE;
+                    else if (i < Integer.MIN_VALUE)
+                        i = Integer.MIN_VALUE;
+
+                    box.setText(String.valueOf(i));
+                    return;
+                }
+            }
+        }
+
+        @Override
+        public void applyTextBox(GT_GuiIntegerTextBox box) {
+            long i;
+            String s = box.getText().trim();
+            try {
+                i = Long.parseLong(s);
+            } catch (NumberFormatException e) {
+                resetTextBox(box);
+                return;
+            }
+
+            if (i > Integer.MAX_VALUE)
+                i = Integer.MAX_VALUE;
+            else if (i < Integer.MIN_VALUE)
+                i = Integer.MIN_VALUE;
+
+
+            coverVariable = (int) i;
+            fBox.setText(String.valueOf(coverVariable));
+            GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+        }
+
+        @Override
+        public void resetTextBox(GT_GuiIntegerTextBox box) {
+            box.setText(String.valueOf(coverVariable));
+        }
+
+        private class GT_GuiIntegerTextBoxWithMinus extends GT_GuiIntegerTextBox {
+
+            public GT_GuiIntegerTextBoxWithMinus(IGuiScreen gui, int id, int x, int y, int width, int height) {
+                super(gui, id, x, y, width, height);
+            }
+
+            @Override
+            public boolean validChar(char c, int key) {
+                if (getCursorPosition() == 0 && key == 12) // minus first allowed.
+                    return true;
+                return super.validChar(c, key);
+            }
+        }
+    }
 }
diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Shutter.java b/src/main/java/gregtech/common/covers/GT_Cover_Shutter.java
index b43cbe0122..b1c0c5c3af 100644
--- a/src/main/java/gregtech/common/covers/GT_Cover_Shutter.java
+++ b/src/main/java/gregtech/common/covers/GT_Cover_Shutter.java
@@ -1,9 +1,15 @@
 package gregtech.common.covers;
 
+import gregtech.api.enums.GT_Values;
+import gregtech.api.gui.GT_GUICover;
+import gregtech.api.gui.widgets.GT_GuiIcon;
+import gregtech.api.gui.widgets.GT_GuiIconCheckButton;
 import gregtech.api.interfaces.tileentity.ICoverable;
 import gregtech.api.interfaces.tileentity.IMachineProgress;
+import gregtech.api.net.GT_Packet_TileEntityCover;
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.fluids.Fluid;
 
@@ -64,4 +70,80 @@ public class GT_Cover_Shutter
     public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
         return 0;
     }
+
+    /**
+     * GUI Stuff
+     */
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity)  {
+        return new GUI(aSide, aCoverID, coverData, aTileEntity);
+    }
+
+    private class GUI extends GT_GUICover {
+        private final byte side;
+        private final int coverID;
+        private int coverVariable;
+
+        private final static int startX = 10;
+        private final static int startY = 25;
+        private final static int spaceX = 18;
+        private final static int spaceY = 18;
+
+        public GUI(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
+            super(aTileEntity, 176, 107, GT_Utility.intToStack(aCoverID));
+            this.side = aSide;
+            this.coverID = aCoverID;
+            this.coverVariable = aCoverVariable;
+
+            new GT_GuiIconCheckButton(this, 0, startX + spaceX*0, startY+spaceY*0, GT_GuiIcon.CHECKMARK, null);
+            new GT_GuiIconCheckButton(this, 1, startX + spaceX*0, startY+spaceY*1, GT_GuiIcon.CHECKMARK, null);
+            new GT_GuiIconCheckButton(this, 2, startX + spaceX*0, startY+spaceY*2, GT_GuiIcon.CHECKMARK, null);
+            new GT_GuiIconCheckButton(this, 3, startX + spaceX*0, startY+spaceY*3, GT_GuiIcon.CHECKMARK, null);
+        }
+
+        @Override
+        public void drawExtras(int mouseX, int mouseY, float parTicks) {
+            super.drawExtras(mouseX, mouseY, parTicks);
+            this.fontRendererObj.drawString(trans("082", "Open if work enabled"),
+                    3+startX + spaceX*1, 4+startY+spaceY*0, 0xFF555555);
+            this.fontRendererObj.drawString(trans("083", "Open if work disabled"),
+                    3+startX + spaceX*1, 4+startY+spaceY*1, 0xFF555555);
+            this.fontRendererObj.drawString(trans("084", "Only Output allowed"),
+                    3+startX + spaceX*1, 4+startY+spaceY*2, 0xFF555555);
+            this.fontRendererObj.drawString(trans("085", "Only Input allowed"),
+                    3+startX + spaceX*1, 4+startY+spaceY*3, 0xFF555555);
+        }
+
+        @Override
+        protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) {
+            updateButtons();
+        }
+
+        public void buttonClicked(GuiButton btn){
+            if (!isEnabled(btn.id)){
+                coverVariable = getNewCoverVariable(btn.id, ((GT_GuiIconCheckButton) btn).isChecked());
+                GT_Values.NW.sendToServer(new GT_Packet_TileEntityCover(side, coverID, coverVariable, tile));
+            }
+            updateButtons();
+        }
+
+        private void updateButtons(){
+            for (Object o : buttonList)
+                ((GT_GuiIconCheckButton) o).setChecked(isEnabled(((GT_GuiIconCheckButton) o).id));
+        }
+
+        private int getNewCoverVariable(int id, boolean checked) {
+            return id;
+        }
+
+        private boolean isEnabled(int id) {
+            return coverVariable == id;
+        }
+    }
 }