Refactor the way fluid slots work.

CHANGELOG.md

@@ -10,7 +10,7 @@
 - Made the Crafting Preview window bigger (raoulvdberge)
 - Fixed crash log when opening Pattern Grid GUI (raoulvdberge)
 - Updated Russian translation (kellixon)
-- Overhauled and Updated German translation (Cydhra)
+- Overhauled and updated German translation (Cydhra)
 
 ### 1.6
 NOTE: Worlds that used Refined Storage 1.5.x are fully compatible with Refined Storage 1.6.x and are getting converted upon loading the world. It is however not possible to revert back to Refined Storage 1.5.x when a world has already been converted to Refined Storage 1.6.x.

src/main/java/com/raoulvdberge/refinedstorage/api/autocrafting/ICraftingPatternContainer.java

@@ -29,7 +29,7 @@ public interface ICraftingPatternContainer {
     /**
      * @return the fluid inventory that this container is connected to, or null if no fluid inventory is present
      *
-     * TODO: remove default.
+     * TODO: Remove default.
      */
     @Nullable
     default IFluidHandler getConnectedFluidInventory() {

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeConstructor.java

@@ -5,11 +5,11 @@ import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.TileConstructor;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -55,13 +55,14 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
     private static final String NBT_TYPE = "Type";
     private static final String NBT_DROP = "Drop";
     private static final String NBT_COVERS = "Covers";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
     private static final int BASE_SPEED = 20;
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(1, new ListenerNetworkNode(this));
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
     private int type = IType.ITEMS;
@@ -105,8 +106,8 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
                         dropItem();
                     }
                 }
-            } else if (type == IType.FLUIDS && !fluidFilters.getStackInSlot(0).isEmpty()) {
+            } else if (type == IType.FLUIDS && fluidFilters.getFluid(0) != null) {
-                FluidStack stack = fluidFilters.getFluidStackInSlot(0);
+                FluidStack stack = fluidFilters.getFluid(0);
 
                 if (stack != null && stack.getFluid().canBePlacedInWorld()) {
                     BlockPos front = pos.offset(getDirection());
@@ -300,7 +301,8 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
         tag.setBoolean(NBT_DROP, drop);
 
         StackUtils.writeItems(itemFilters, 0, tag);
-        StackUtils.writeItems(fluidFilters, 2, tag);
+
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
 
         return tag;
     }
@@ -326,7 +328,10 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
         }
 
         StackUtils.readItems(itemFilters, 0, tag);
-        StackUtils.readItems(fluidFilters, 2, tag);
+
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
     }
 
     public boolean isDrop() {
@@ -369,13 +374,13 @@ public class NetworkNodeConstructor extends NetworkNode implements IComparable,
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeCrafter.java

@@ -7,9 +7,9 @@ import com.raoulvdberge.refinedstorage.api.autocrafting.ICraftingPatternProvider
 import com.raoulvdberge.refinedstorage.api.network.INetwork;
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import com.raoulvdberge.refinedstorage.util.WorldUtils;
@@ -37,7 +37,7 @@ public class NetworkNodeCrafter extends NetworkNode implements ICraftingPatternC
     private static final String NBT_DISPLAY_NAME = "DisplayName";
     private static final String NBT_UUID = "CrafterUuid";
 
-    private ItemHandlerBase patterns = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this), s -> isValidPatternInSlot(world, s)) {
+    private ItemHandlerBase patterns = new ItemHandlerBase(9, new ListenerNetworkNode(this), s -> isValidPatternInSlot(world, s)) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -63,7 +63,7 @@ public class NetworkNodeCrafter extends NetworkNode implements ICraftingPatternC
 
     private List<ICraftingPattern> actualPatterns = new ArrayList<>();
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED);
 
     // Used to prevent infinite recursion on getRootContainer() when there's e.g. two crafters facing each other.
     private boolean visited = false;

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDestructor.java

@@ -5,10 +5,10 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.TileDestructor;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -60,13 +60,14 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
     private static final String NBT_TYPE = "Type";
     private static final String NBT_PICKUP = "Pickup";
     private static final String NBT_COVERS = "Covers";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
     private static final int BASE_SPEED = 20;
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_SILK_TOUCH, ItemUpgrade.TYPE_FORTUNE_1, ItemUpgrade.TYPE_FORTUNE_2, ItemUpgrade.TYPE_FORTUNE_3);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_SILK_TOUCH, ItemUpgrade.TYPE_FORTUNE_1, ItemUpgrade.TYPE_FORTUNE_2, ItemUpgrade.TYPE_FORTUNE_3);
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
     private int mode = IFilterable.BLACKLIST;
@@ -251,7 +252,8 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
         tag.setBoolean(NBT_PICKUP, pickupItem);
 
         StackUtils.writeItems(itemFilters, 0, tag);
-        StackUtils.writeItems(fluidFilters, 2, tag);
+
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
 
         return tag;
     }
@@ -277,9 +279,12 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
         }
 
         StackUtils.readItems(itemFilters, 0, tag);
-        StackUtils.readItems(fluidFilters, 2, tag);
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
+
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
     }
 
     public IItemHandler getUpgrades() {
@@ -313,13 +318,13 @@ public class NetworkNodeDestructor extends NetworkNode implements IComparable, I
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeDetector.java

@@ -6,9 +6,9 @@ import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask;
 import com.raoulvdberge.refinedstorage.api.network.INetwork;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.tile.TileDetector;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
@@ -36,9 +36,10 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
     private static final String NBT_MODE = "Mode";
     private static final String NBT_AMOUNT = "Amount";
     private static final String NBT_TYPE = "Type";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(1, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(1, new ListenerNetworkNode(this));
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
     private int type = IType.ITEMS;
@@ -101,7 +102,7 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
                     powered = mode == MODE_AUTOCRAFTING ? !network.getCraftingManager().getTasks().isEmpty() : isPowered(network.getItemStorageCache().getList().getStacks().stream().map(ItemStack::getCount).mapToInt(Number::intValue).sum());
                 }
             } else if (type == IType.FLUIDS) {
-                FluidStack slot = fluidFilters.getFluidStackInSlot(0);
+                FluidStack slot = fluidFilters.getFluid(0);
 
                 if (slot != null) {
                     FluidStack stack = network.getFluidStorageCache().getList().get(slot, compare);
@@ -197,7 +198,8 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
         tag.setInteger(NBT_TYPE, type);
 
         StackUtils.writeItems(itemFilters, 0, tag);
-        StackUtils.writeItems(fluidFilters, 1, tag);
+
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
 
         return tag;
     }
@@ -223,7 +225,10 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
         }
 
         StackUtils.readItems(itemFilters, 0, tag);
-        StackUtils.readItems(fluidFilters, 1, tag);
+
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
     }
 
     public IItemHandler getInventory() {
@@ -248,12 +253,12 @@ public class NetworkNodeDetector extends NetworkNode implements IComparable, ITy
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java

@@ -4,10 +4,10 @@ import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.TileExporter;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -35,11 +35,12 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
     private static final String NBT_COMPARE = "Compare";
     private static final String NBT_TYPE = "Type";
     private static final String NBT_COVERS = "Covers";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_CRAFTING, ItemUpgrade.TYPE_STACK);
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
     private int type = IType.ITEMS;
@@ -187,7 +188,8 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
         tag.setInteger(NBT_TYPE, type);
 
         StackUtils.writeItems(itemFilters, 0, tag);
-        StackUtils.writeItems(fluidFilters, 2, tag);
+
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
 
         return tag;
     }
@@ -216,7 +218,10 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
         }
 
         StackUtils.readItems(itemFilters, 0, tag);
-        StackUtils.readItems(fluidFilters, 2, tag);
+
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
     }
 
     public IItemHandler getUpgrades() {
@@ -241,13 +246,13 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExternalStorage.java

@@ -15,9 +15,9 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.tile.TileExternalStorage;
 import com.raoulvdberge.refinedstorage.tile.config.*;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
@@ -45,9 +45,10 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
     private static final String NBT_MODE = "Mode";
     private static final String NBT_TYPE = "Type";
     private static final String NBT_COVERS = "Covers";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
 
     private int priority = 0;
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
@@ -135,7 +136,8 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
         super.writeConfiguration(tag);
 
         StackUtils.writeItems(itemFilters, 0, tag);
-        StackUtils.writeItems(fluidFilters, 1, tag);
+
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
 
         tag.setInteger(NBT_PRIORITY, priority);
         tag.setInteger(NBT_COMPARE, compare);
@@ -152,7 +154,10 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
         super.readConfiguration(tag);
 
         StackUtils.readItems(itemFilters, 0, tag);
-        StackUtils.readItems(fluidFilters, 1, tag);
+
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
 
         if (tag.hasKey(NBT_PRIORITY)) {
             priority = tag.getInteger(NBT_PRIORITY);
@@ -172,7 +177,7 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
 
         accessType = AccessTypeUtils.readAccessType(tag);
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
     }
 
     @Override
@@ -341,13 +346,13 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 
     public List<IStorageExternal<ItemStack>> getItemStorages() {

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeFluidInterface.java

@@ -6,7 +6,11 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.externalstorage.StorageExternalFluid;
-import com.raoulvdberge.refinedstorage.inventory.*;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidHandlerFluidInterface;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.TileFluidInterface;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
@@ -26,10 +30,11 @@ import org.apache.commons.lang3.tuple.Pair;
 public class NetworkNodeFluidInterface extends NetworkNode {
     public static final String ID = "fluid_interface";
 
-    public static final int TANK_CAPACITY = 16000;
+    public static final int TANK_CAPACITY = 16_000;
 
     private static final String NBT_TANK_IN = "TankIn";
     private static final String NBT_TANK_OUT = "TankOut";
+    private static final String NBT_OUT = "Out";
 
     private FluidTank tankIn = new FluidTank(TANK_CAPACITY) {
         @Override
@@ -47,10 +52,10 @@ public class NetworkNodeFluidInterface extends NetworkNode {
 
     private FluidHandlerFluidInterface tank = new FluidHandlerFluidInterface(tankIn, tankOut);
 
-    private ItemHandlerBase in = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase in = new ItemHandlerBase(1, new ListenerNetworkNode(this));
-    private ItemHandlerFluid out = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory out = new FluidInventory(1, TANK_CAPACITY, new ListenerNetworkNode(this));
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
 
     public NetworkNodeFluidInterface(World world, BlockPos pos) {
         super(world, pos);
@@ -66,21 +71,21 @@ public class NetworkNodeFluidInterface extends NetworkNode {
     public void update() {
         super.update();
 
-        ItemStack container = in.getStackInSlot(0);
-
-        if (!container.isEmpty()) {
-            Pair<ItemStack, FluidStack> result = StackUtils.getFluid(container, true);
-
-            if (result.getValue() != null && tankIn.fillInternal(result.getValue(), false) == result.getValue().amount) {
-                result = StackUtils.getFluid(container, false);
-
-                tankIn.fillInternal(result.getValue(), true);
-
-                in.setStackInSlot(0, result.getLeft());
-            }
-        }
-
         if (network != null && canUpdate()) {
+            ItemStack container = in.getStackInSlot(0);
+
+            if (!container.isEmpty()) {
+                Pair<ItemStack, FluidStack> result = StackUtils.getFluid(container, true);
+
+                if (result.getValue() != null && tankIn.fillInternal(result.getValue(), false) == result.getValue().amount) {
+                    result = StackUtils.getFluid(container, false);
+
+                    tankIn.fillInternal(result.getValue(), true);
+
+                    in.setStackInSlot(0, result.getLeft());
+                }
+            }
+
             if (ticks % upgrades.getSpeed() == 0) {
                 FluidStack drained = tankIn.drainInternal(Fluid.BUCKET_VOLUME * upgrades.getItemInteractCount(), true);
 
@@ -94,8 +99,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
                 }
             }
 
-            FluidStack wanted = out.getFluidStackInSlot(0);
+            FluidStack wanted = out.getFluid(0);
-            int wantedAmount = out.getStackInSlot(0).getCount();
             FluidStack got = tankOut.getFluid();
 
             if (wanted == null) {
@@ -109,7 +113,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
 
                 onTankOutChanged();
             } else {
-                int delta = got == null ? wantedAmount : (wantedAmount - got.amount);
+                int delta = got == null ? wanted.amount : (wanted.amount - got.amount);
 
                 if (delta > 0) {
                     final boolean actingAsStorage = isActingAsStorage();
@@ -215,7 +219,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
     public NBTTagCompound writeConfiguration(NBTTagCompound tag) {
         super.writeConfiguration(tag);
 
-        StackUtils.writeItems(out, 2, tag, StackUtils::serializeStackToNbt);
+        tag.setTag(NBT_OUT, out.writeToNbt());
 
         return tag;
     }
@@ -224,7 +228,9 @@ public class NetworkNodeFluidInterface extends NetworkNode {
     public void readConfiguration(NBTTagCompound tag) {
         super.readConfiguration(tag);
 
-        StackUtils.readItems(out, 2, tag, StackUtils::deserializeStackFromNbt);
+        if (tag.hasKey(NBT_OUT)) {
+            out.readFromNbt(tag.getCompoundTag(NBT_OUT));
+        }
     }
 
     public ItemHandlerUpgrade getUpgrades() {
@@ -235,7 +241,7 @@ public class NetworkNodeFluidInterface extends NetworkNode {
         return in;
     }
 
-    public ItemHandlerFluid getOut() {
+    public FluidInventory getOut() {
         return out;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeGrid.java

@@ -22,7 +22,11 @@ import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridFluid;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridItem;
 import com.raoulvdberge.refinedstorage.block.BlockGrid;
-import com.raoulvdberge.refinedstorage.inventory.*;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
+import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemPattern;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataManager;
@@ -39,6 +43,7 @@ import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.NonNullList;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.items.IItemHandler;
@@ -59,12 +64,13 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
     public static final String NBT_SORTING_DIRECTION = "SortingDirection";
     public static final String NBT_SORTING_TYPE = "SortingType";
     public static final String NBT_SEARCH_BOX_MODE = "SearchBoxMode";
-    public static final String NBT_OREDICT_PATTERN = "OredictPattern";
+    private static final String NBT_OREDICT_PATTERN = "OredictPattern";
     public static final String NBT_TAB_SELECTED = "TabSelected";
     public static final String NBT_TAB_PAGE = "TabPage";
     public static final String NBT_SIZE = "Size";
-    public static final String NBT_PROCESSING_PATTERN = "ProcessingPattern";
+    private static final String NBT_PROCESSING_PATTERN = "ProcessingPattern";
-    public static final String NBT_PROCESSING_TYPE = "ProcessingType";
+    private static final String NBT_PROCESSING_TYPE = "ProcessingType";
+    private static final String NBT_PROCESSING_MATRIX_FLUIDS = "ProcessingMatrixFluids";
 
     private Container craftingContainer = new Container() {
         @Override
@@ -80,10 +86,10 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
     private IRecipe currentRecipe;
     private InventoryCrafting matrix = new InventoryCrafting(craftingContainer, 3, 3);
     private InventoryCraftResult result = new InventoryCraftResult();
-    private ItemHandlerBase matrixProcessing = new ItemHandlerBase(9 * 2, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase processingMatrix = new ItemHandlerBase(9 * 2, new ListenerNetworkNode(this));
-    private ItemHandlerFluid matrixProcessingFluids = new ItemHandlerFluid(9 * 2, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory processingMatrixFluids = new FluidInventory(9 * 2, Fluid.BUCKET_VOLUME, new ListenerNetworkNode(this));
 
-    private ItemHandlerBase patterns = new ItemHandlerBase(2, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.PATTERN)) {
+    private ItemHandlerBase patterns = new ItemHandlerBase(2, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.PATTERN)) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -94,11 +100,11 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
 
                 if (isPatternProcessing && isProcessingPattern()) {
                     for (int i = 0; i < 9; ++i) {
-                        matrixProcessing.setStackInSlot(i, StackUtils.nullToEmpty(ItemPattern.getInputSlot(pattern, i)));
+                        processingMatrix.setStackInSlot(i, StackUtils.nullToEmpty(ItemPattern.getInputSlot(pattern, i)));
                     }
 
                     for (int i = 0; i < 9; ++i) {
-                        matrixProcessing.setStackInSlot(9 + i, StackUtils.nullToEmpty(ItemPattern.getOutputSlot(pattern, i)));
+                        processingMatrix.setStackInSlot(9 + i, StackUtils.nullToEmpty(ItemPattern.getOutputSlot(pattern, i)));
                     }
                 } else if (!isPatternProcessing && !isProcessingPattern()) {
                     for (int i = 0; i < 9; ++i) {
@@ -130,7 +136,7 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
     };
     private List<IFilter> filters = new ArrayList<>();
     private List<IGridTab> tabs = new ArrayList<>();
-    private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ListenerNetworkNode(this));
 
     private GridType type;
 
@@ -292,11 +298,11 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
     }
 
     public ItemHandlerBase getProcessingMatrix() {
-        return matrixProcessing;
+        return processingMatrix;
     }
 
-    public ItemHandlerFluid getMatrixProcessingFluids() {
+    public FluidInventory getProcessingMatrixFluids() {
-        return matrixProcessingFluids;
+        return processingMatrixFluids;
     }
 
     @Override
@@ -405,12 +411,12 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
     }
 
     public void clearMatrix() {
-        for (int i = 0; i < matrixProcessing.getSlots(); ++i) {
+        for (int i = 0; i < processingMatrix.getSlots(); ++i) {
-            matrixProcessing.setStackInSlot(i, ItemStack.EMPTY);
+            processingMatrix.setStackInSlot(i, ItemStack.EMPTY);
         }
 
-        for (int i = 0; i < matrixProcessingFluids.getSlots(); ++i) {
+        for (int i = 0; i < processingMatrixFluids.getSlots(); ++i) {
-            matrixProcessingFluids.setStackInSlot(i, ItemStack.EMPTY);
+            processingMatrixFluids.setFluid(i, null);
         }
 
         for (int i = 0; i < matrix.getSizeInventory(); ++i) {
@@ -524,25 +530,20 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
 
             if (processingPattern) {
                 for (int i = 0; i < 18; ++i) {
-                    if (!matrixProcessing.getStackInSlot(i).isEmpty()) {
+                    if (!processingMatrix.getStackInSlot(i).isEmpty()) {
                         if (i >= 9) {
-                            ItemPattern.setOutputSlot(pattern, i - 9, matrixProcessing.getStackInSlot(i));
+                            ItemPattern.setOutputSlot(pattern, i - 9, processingMatrix.getStackInSlot(i));
                         } else {
-                            ItemPattern.setInputSlot(pattern, i, matrixProcessing.getStackInSlot(i));
+                            ItemPattern.setInputSlot(pattern, i, processingMatrix.getStackInSlot(i));
                         }
                     }
 
-                    if (!matrixProcessingFluids.getStackInSlot(i).isEmpty()) {
+                    FluidStack fluid = processingMatrixFluids.getFluid(i);
+                    if (fluid != null) {
                         if (i >= 9) {
-                            FluidStack fluid = StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(matrixProcessingFluids.getStackInSlot(i), 1), true).getValue();
+                            ItemPattern.setFluidOutputSlot(pattern, i - 9, fluid);
-                            if (fluid != null) {
-                                ItemPattern.setFluidOutputSlot(pattern, i - 9, StackUtils.copy(fluid, matrixProcessingFluids.getStackInSlot(i).getCount()));
-                            }
                         } else {
-                            FluidStack fluid = StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(matrixProcessingFluids.getStackInSlot(i), 1), true).getValue();
+                            ItemPattern.setFluidInputSlot(pattern, i, fluid);
-                            if (fluid != null) {
-                                ItemPattern.setFluidInputSlot(pattern, i, StackUtils.copy(fluid, matrixProcessingFluids.getStackInSlot(i).getCount()));
-                            }
                         }
                     }
                 }
@@ -574,21 +575,21 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
             int outputsFilled = 0;
 
             for (int i = 0; i < 9; ++i) {
-                if (!matrixProcessing.getStackInSlot(i).isEmpty()) {
+                if (!processingMatrix.getStackInSlot(i).isEmpty()) {
                     inputsFilled++;
                 }
 
-                if (!matrixProcessingFluids.getStackInSlot(i).isEmpty()) {
+                if (processingMatrixFluids.getFluid(i) != null) {
                     inputsFilled++;
                 }
             }
 
             for (int i = 9; i < 18; ++i) {
-                if (!matrixProcessing.getStackInSlot(i).isEmpty()) {
+                if (!processingMatrix.getStackInSlot(i).isEmpty()) {
                     outputsFilled++;
                 }
 
-                if (!matrixProcessingFluids.getStackInSlot(i).isEmpty()) {
+                if (processingMatrixFluids.getFluid(i) != null) {
                     outputsFilled++;
                 }
             }
@@ -689,13 +690,13 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.FLUIDS ? matrixProcessingFluids : matrixProcessing;
+        return processingMatrix;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return processingMatrixFluids;
     }
 
     @Override
@@ -710,8 +711,11 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
         StackUtils.readItems(matrix, 0, tag);
         StackUtils.readItems(patterns, 1, tag);
         StackUtils.readItems(filter, 2, tag);
-        StackUtils.readItems(matrixProcessing, 3, tag);
+        StackUtils.readItems(processingMatrix, 3, tag);
-        StackUtils.readItems(matrixProcessingFluids, 4, tag, StackUtils::deserializeStackFromNbt);
+
+        if (tag.hasKey(NBT_PROCESSING_MATRIX_FLUIDS)) {
+            processingMatrixFluids.readFromNbt(tag.getCompoundTag(NBT_PROCESSING_MATRIX_FLUIDS));
+        }
 
         if (tag.hasKey(NBT_TAB_SELECTED)) {
             tabSelected = tag.getInteger(NBT_TAB_SELECTED);
@@ -734,9 +738,9 @@ public class NetworkNodeGrid extends NetworkNode implements IGridNetworkAware, I
         StackUtils.writeItems(matrix, 0, tag);
         StackUtils.writeItems(patterns, 1, tag);
         StackUtils.writeItems(filter, 2, tag);
-        StackUtils.writeItems(matrixProcessing, 3, tag);
+        StackUtils.writeItems(processingMatrix, 3, tag);
-        StackUtils.writeItems(matrixProcessingFluids, 4, tag, StackUtils::serializeStackToNbt);
 
+        tag.setTag(NBT_PROCESSING_MATRIX_FLUIDS, processingMatrixFluids.writeToNbt());
         tag.setInteger(NBT_TAB_SELECTED, tabSelected);
         tag.setInteger(NBT_TAB_PAGE, tabPage);
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java

@@ -5,10 +5,10 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
 import com.raoulvdberge.refinedstorage.tile.TileImporter;
@@ -39,11 +39,12 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
     private static final String NBT_MODE = "Mode";
     private static final String NBT_TYPE = "Type";
     private static final String NBT_COVERS = "Covers";
+    private static final String NBT_FLUID_FILTERS = "FLuidFilters";
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK);
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
     private int mode = IFilterable.BLACKLIST;
@@ -187,7 +188,8 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
         tag.setInteger(NBT_TYPE, type);
 
         StackUtils.writeItems(itemFilters, 0, tag);
-        StackUtils.writeItems(fluidFilters, 2, tag);
+
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
 
         return tag;
     }
@@ -209,9 +211,12 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
         }
 
         StackUtils.readItems(itemFilters, 0, tag);
-        StackUtils.readItems(fluidFilters, 2, tag);
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
+
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
     }
 
     public IItemHandler getUpgrades() {
@@ -241,13 +246,13 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeInterface.java

@@ -6,10 +6,10 @@ import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.externalstorage.StorageExternalItem;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerProxy;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerProxy;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
@@ -27,14 +27,14 @@ public class NetworkNodeInterface extends NetworkNode implements IComparable {
 
     private static final String NBT_COMPARE = "Compare";
 
-    private ItemHandlerBase importItems = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase importItems = new ItemHandlerBase(9, new ListenerNetworkNode(this));
 
-    private ItemHandlerBase exportFilterItems = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase exportFilterItems = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerBase exportItems = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase exportItems = new ItemHandlerBase(9, new ListenerNetworkNode(this));
 
     private IItemHandler items = new ItemHandlerProxy(importItems, exportItems);
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK, ItemUpgrade.TYPE_CRAFTING);
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeNetworkTransmitter.java

@@ -2,10 +2,10 @@ package com.raoulvdberge.refinedstorage.apiimpl.network.node;
 
 import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.RSItems;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
-import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemNetworkCard;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
@@ -22,7 +22,7 @@ import javax.annotation.Nullable;
 public class NetworkNodeNetworkTransmitter extends NetworkNode {
     public static final String ID = "network_transmitter";
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(1, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_INTERDIMENSIONAL) {
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(1, new ListenerNetworkNode(this), ItemUpgrade.TYPE_INTERDIMENSIONAL) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -33,7 +33,7 @@ public class NetworkNodeNetworkTransmitter extends NetworkNode {
         }
     };
 
-    private ItemHandlerBase networkCard = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.NETWORK_CARD)) {
+    private ItemHandlerBase networkCard = new ItemHandlerBase(1, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.NETWORK_CARD)) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeSecurityManager.java

@@ -7,9 +7,9 @@ import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCard;
 import com.raoulvdberge.refinedstorage.api.network.security.ISecurityCardContainer;
 import com.raoulvdberge.refinedstorage.api.network.security.Permission;
 import com.raoulvdberge.refinedstorage.apiimpl.network.security.SecurityCard;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
-import com.raoulvdberge.refinedstorage.inventory.ItemValidatorBasic;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemSecurityCard;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import net.minecraft.item.ItemStack;
@@ -28,7 +28,7 @@ public class NetworkNodeSecurityManager extends NetworkNode implements ISecurity
 
     private List<ISecurityCard> actualCards = new ArrayList<>();
 
-    private ItemHandlerBase cards = new ItemHandlerBase(9 * 2, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD)) {
+    private ItemHandlerBase cards = new ItemHandlerBase(9 * 2, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD)) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -42,7 +42,7 @@ public class NetworkNodeSecurityManager extends NetworkNode implements ISecurity
             }
         }
     };
-    private ItemHandlerBase editCard = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD));
+    private ItemHandlerBase editCard = new ItemHandlerBase(1, new ListenerNetworkNode(this), new ItemValidatorBasic(RSItems.SECURITY_CARD));
 
     public NetworkNodeSecurityManager(World world, BlockPos pos) {
         super(world, pos);

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeStorageMonitor.java

@@ -4,12 +4,9 @@ import com.raoulvdberge.refinedstorage.api.network.security.Permission;
 import com.raoulvdberge.refinedstorage.api.util.Action;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
-import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
-import com.raoulvdberge.refinedstorage.tile.config.IType;
 import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import com.raoulvdberge.refinedstorage.util.WorldUtils;
@@ -21,31 +18,19 @@ import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.items.IItemHandler;
 import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.HashMap;
 import java.util.Map;
 
-public class NetworkNodeStorageMonitor extends NetworkNode implements IComparable, IType {
+public class NetworkNodeStorageMonitor extends NetworkNode implements IComparable {
     public static final int DEPOSIT_ALL_MAX_DELAY = 500;
 
     public static final String ID = "storage_monitor";
 
     private static final String NBT_COMPARE = "Compare";
-    private static final String NBT_TYPE = "Type";
 
-    private ItemHandlerBase itemFilter = new ItemHandlerBase(1, new ItemHandlerListenerNetworkNode(this)) {
+    private ItemHandlerBase itemFilter = new ItemHandlerBase(1, new ListenerNetworkNode(this)) {
-        @Override
-        public void onContentsChanged(int slot) {
-            super.onContentsChanged(slot);
-
-            WorldUtils.updateBlock(world, pos);
-        }
-    };
-
-    private ItemHandlerFluid fluidFilter = new ItemHandlerFluid(1, new ItemHandlerListenerNetworkNode(this)) {
         @Override
         public void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -57,7 +42,6 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
     private Map<String, Pair<ItemStack, Long>> deposits = new HashMap<>();
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
-    private int type = IType.ITEMS;
 
     private int oldAmount = -1;
 
@@ -81,7 +65,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
     }
 
     public boolean depositAll(EntityPlayer player) {
-        if (type != IType.ITEMS || network == null) {
+        if (network == null) {
             return false;
         }
 
@@ -112,7 +96,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
     }
 
     public boolean deposit(EntityPlayer player, ItemStack toInsert) {
-        if (type != IType.ITEMS || network == null) {
+        if (network == null) {
             return false;
         }
 
@@ -132,7 +116,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
     }
 
     public void extract(EntityPlayer player, EnumFacing side) {
-        if (type != IType.ITEMS || network == null || getDirection() != side) {
+        if (network == null || getDirection() != side) {
             return;
         }
 
@@ -179,39 +163,13 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
         markDirty();
     }
 
-    @Override
-    public int getType() {
-        return world.isRemote ? TileStorageMonitor.TYPE.getValue() : type;
-    }
-
-    @Override
-    public void setType(int type) {
-        this.type = type;
-
-        WorldUtils.updateBlock(world, pos);
-
-        markDirty();
-    }
-
-    @Override
-    public IItemHandler getFilterInventory() {
-        return getType() == IType.ITEMS ? itemFilter : fluidFilter;
-    }
-
-    @Override
-    public boolean isServer() {
-        return !world.isRemote;
-    }
-
     @Override
     public NBTTagCompound writeConfiguration(NBTTagCompound tag) {
         super.writeConfiguration(tag);
 
         tag.setInteger(NBT_COMPARE, compare);
-        tag.setInteger(NBT_TYPE, type);
 
         StackUtils.writeItems(itemFilter, 0, tag);
-        StackUtils.writeItems(fluidFilter, 1, tag);
 
         return tag;
     }
@@ -224,20 +182,7 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
             compare = tag.getInteger(NBT_COMPARE);
         }
 
-        if (tag.hasKey(NBT_TYPE)) {
-            type = tag.getInteger(NBT_TYPE);
-        }
-
         StackUtils.readItems(itemFilter, 0, tag);
-        StackUtils.readItems(fluidFilter, 1, tag);
-    }
-
-    public ItemHandlerBase getItemFilter() {
-        return itemFilter;
-    }
-
-    public ItemHandlerFluid getFluidFilter() {
-        return fluidFilter;
     }
 
     public int getAmount() {
@@ -245,33 +190,19 @@ public class NetworkNodeStorageMonitor extends NetworkNode implements IComparabl
             return 0;
         }
 
-        switch (type) {
+        ItemStack toCheck = itemFilter.getStackInSlot(0);
-            case ITEMS: {
-                ItemStack toCheck = itemFilter.getStackInSlot(0);
 
-                if (toCheck.isEmpty()) {
+        if (toCheck.isEmpty()) {
-                    return 0;
+            return 0;
-                }
-
-                ItemStack stored = network.getItemStorageCache().getList().get(toCheck, compare);
-
-                return stored != null ? stored.getCount() : 0;
-            }
-            case FLUIDS: {
-                FluidStack toCheck = fluidFilter.getFluidStackInSlot(0);
-
-                if (toCheck == null) {
-                    return 0;
-                }
-
-                FluidStack stored = network.getFluidStorageCache().getList().get(toCheck, compare);
-
-                return stored != null ? stored.amount : 0;
-            }
-            default: {
-                return 0;
-            }
         }
+
+        ItemStack stored = network.getItemStorageCache().getList().get(toCheck, compare);
+
+        return stored != null ? stored.getCount() : 0;
+    }
+
+    public ItemHandlerBase getItemFilters() {
+        return itemFilter;
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeWirelessTransmitter.java

@@ -2,9 +2,9 @@ package com.raoulvdberge.refinedstorage.apiimpl.network.node;
 
 import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.api.network.IWirelessTransmitter;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import net.minecraft.nbt.NBTTagCompound;
@@ -18,7 +18,7 @@ import javax.annotation.Nullable;
 public class NetworkNodeWirelessTransmitter extends NetworkNode implements IWirelessTransmitter {
     public static final String ID = "wireless_transmitter";
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_RANGE);
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_RANGE);
 
     public NetworkNodeWirelessTransmitter(World world, BlockPos pos) {
         super(world, pos);

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/diskdrive/NetworkNodeDiskDrive.java

@@ -15,9 +15,9 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
 import com.raoulvdberge.refinedstorage.tile.config.*;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
@@ -45,13 +45,14 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
     private static final String NBT_COMPARE = "Compare";
     private static final String NBT_MODE = "Mode";
     private static final String NBT_TYPE = "Type";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
     private static final int DISK_STATE_UPDATE_THROTTLE = 30;
 
     private int ticksSinceBlockUpdateRequested;
     private boolean blockUpdateRequested;
 
-    private ItemHandlerBase disks = new ItemHandlerBase(8, new ItemHandlerListenerNetworkNode(this), VALIDATOR_STORAGE_DISK) {
+    private ItemHandlerBase disks = new ItemHandlerBase(8, new ListenerNetworkNode(this), VALIDATOR_STORAGE_DISK) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -77,8 +78,8 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
         }
     };
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
 
     private IStorageDisk[] itemDisks = new IStorageDisk[8];
     private IStorageDisk[] fluidDisks = new IStorageDisk[8];
@@ -199,8 +200,8 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
         super.writeConfiguration(tag);
 
         StackUtils.writeItems(itemFilters, 1, tag);
-        StackUtils.writeItems(fluidFilters, 2, tag);
 
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
         tag.setInteger(NBT_PRIORITY, priority);
         tag.setInteger(NBT_COMPARE, compare);
         tag.setInteger(NBT_MODE, mode);
@@ -216,7 +217,10 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
         super.readConfiguration(tag);
 
         StackUtils.readItems(itemFilters, 1, tag);
-        StackUtils.readItems(fluidFilters, 2, tag);
+
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
 
         if (tag.hasKey(NBT_PRIORITY)) {
             priority = tag.getInteger(NBT_PRIORITY);
@@ -236,7 +240,7 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
 
         accessType = AccessTypeUtils.readAccessType(tag);
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
     }
 
     @Override
@@ -359,20 +363,12 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
-    }
-
-    @Override
-    public boolean isServer() {
-        return !world.isRemote;
-    }
-
-    ItemHandlerBase getItemFilters() {
         return itemFilters;
     }
 
-    ItemHandlerFluid getFluidFilters() {
+    @Override
+    public FluidInventory getFluidFilters() {
         return fluidFilters;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/diskmanipulator/NetworkNodeDiskManipulator.java

@@ -10,7 +10,11 @@ import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
-import com.raoulvdberge.refinedstorage.inventory.*;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerProxy;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -42,6 +46,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
     private static final String NBT_MODE = "Mode";
     private static final String NBT_TYPE = "Type";
     private static final String NBT_IO_MODE = "IOMode";
+    private static final String NBT_FLUID_FILTERS = "FluidFilters";
 
     private int compare = IComparer.COMPARE_NBT | IComparer.COMPARE_DAMAGE;
     private int mode = IFilterable.BLACKLIST;
@@ -51,7 +56,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
     private IStorageDisk<ItemStack>[] itemDisks = new IStorageDisk[6];
     private IStorageDisk<FluidStack>[] fluidDisks = new IStorageDisk[6];
 
-    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ItemHandlerListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK) {
+    private ItemHandlerUpgrade upgrades = new ItemHandlerUpgrade(4, new ListenerNetworkNode(this), ItemUpgrade.TYPE_SPEED, ItemUpgrade.TYPE_STACK) {
         @Override
         public int getItemInteractCount() {
             int count = super.getItemInteractCount();
@@ -64,7 +69,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
         }
     };
 
-    private ItemHandlerBase inputDisks = new ItemHandlerBase(3, new ItemHandlerListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
+    private ItemHandlerBase inputDisks = new ItemHandlerBase(3, new ListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -85,7 +90,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
         }
     };
 
-    private ItemHandlerBase outputDisks = new ItemHandlerBase(3, new ItemHandlerListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
+    private ItemHandlerBase outputDisks = new ItemHandlerBase(3, new ListenerNetworkNode(this), NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);
@@ -112,8 +117,8 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
         super(world, pos);
     }
 
-    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase itemFilters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
-    private ItemHandlerFluid fluidFilters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory fluidFilters = new FluidInventory(9, new ListenerNetworkNode(this));
 
     @Override
     public int getEnergyUsage() {
@@ -343,7 +348,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
                 FluidStack filterStack = null;
 
                 while (fluidFilters.getSlots() > i && filterStack == null) {
-                    filterStack = fluidFilters.getFluidStackInSlot(i++);
+                    filterStack = fluidFilters.getFluid(i++);
                 }
 
                 if (filterStack != null) {
@@ -402,13 +407,13 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
     }
 
     @Override
-    public IItemHandler getFilterInventory() {
+    public IItemHandler getItemFilters() {
-        return getType() == IType.ITEMS ? itemFilters : fluidFilters;
+        return itemFilters;
     }
 
     @Override
-    public boolean isServer() {
+    public FluidInventory getFluidFilters() {
-        return !world.isRemote;
+        return fluidFilters;
     }
 
     @Override
@@ -441,14 +446,6 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
         return disks;
     }
 
-    public ItemHandlerBase getItemFilters() {
-        return itemFilters;
-    }
-
-    public ItemHandlerFluid getFluidFilters() {
-        return fluidFilters;
-    }
-
     public IItemHandler getUpgrades() {
         return upgrades;
     }
@@ -499,8 +496,8 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
         super.writeConfiguration(tag);
 
         StackUtils.writeItems(itemFilters, 1, tag);
-        StackUtils.writeItems(fluidFilters, 2, tag);
 
+        tag.setTag(NBT_FLUID_FILTERS, fluidFilters.writeToNbt());
         tag.setInteger(NBT_COMPARE, compare);
         tag.setInteger(NBT_MODE, mode);
         tag.setInteger(NBT_TYPE, type);
@@ -514,7 +511,10 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
         super.readConfiguration(tag);
 
         StackUtils.readItems(itemFilters, 1, tag);
-        StackUtils.readItems(fluidFilters, 2, tag);
+
+        if (tag.hasKey(NBT_FLUID_FILTERS)) {
+            fluidFilters.readFromNbt(tag.getCompoundTag(NBT_FLUID_FILTERS));
+        }
 
         if (tag.hasKey(NBT_COMPARE)) {
             compare = tag.getInteger(NBT_COMPARE);
@@ -532,7 +532,7 @@ public class NetworkNodeDiskManipulator extends NetworkNode implements IComparab
             ioMode = tag.getInteger(NBT_IO_MODE);
         }
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters, fluidFilters);
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, itemFilters);
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/storage/NetworkNodeFluidStorage.java

@@ -16,8 +16,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheFluid;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
 import com.raoulvdberge.refinedstorage.block.BlockFluidStorage;
 import com.raoulvdberge.refinedstorage.block.enums.FluidStorageType;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.tile.TileFluidStorage;
 import com.raoulvdberge.refinedstorage.tile.config.IAccessType;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -25,7 +25,6 @@ import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
 import com.raoulvdberge.refinedstorage.tile.config.IPrioritizable;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import com.raoulvdberge.refinedstorage.util.AccessTypeUtils;
-import com.raoulvdberge.refinedstorage.util.StackUtils;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -42,9 +41,10 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
     private static final String NBT_PRIORITY = "Priority";
     private static final String NBT_COMPARE = "Compare";
     private static final String NBT_MODE = "Mode";
+    private static final String NBT_FILTERS = "Filters";
     public static final String NBT_ID = "Id";
 
-    private ItemHandlerFluid filters = new ItemHandlerFluid(9, new ItemHandlerListenerNetworkNode(this));
+    private FluidInventory filters = new FluidInventory(9, new ListenerNetworkNode(this));
 
     private FluidStorageType type;
 
@@ -142,8 +142,7 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
     public NBTTagCompound writeConfiguration(NBTTagCompound tag) {
         super.writeConfiguration(tag);
 
-        StackUtils.writeItems(filters, 0, tag);
+        tag.setTag(NBT_FILTERS, filters.writeToNbt());
-
         tag.setInteger(NBT_PRIORITY, priority);
         tag.setInteger(NBT_COMPARE, compare);
         tag.setInteger(NBT_MODE, mode);
@@ -157,7 +156,9 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
     public void readConfiguration(NBTTagCompound tag) {
         super.readConfiguration(tag);
 
-        StackUtils.readItems(filters, 0, tag);
+        if (tag.hasKey(NBT_FILTERS)) {
+            filters.readFromNbt(tag.getCompoundTag(NBT_FILTERS));
+        }
 
         if (tag.hasKey(NBT_PRIORITY)) {
             priority = tag.getInteger(NBT_PRIORITY);
@@ -173,7 +174,7 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
 
         accessType = AccessTypeUtils.readAccessType(tag);
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, null, filters);
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, null);
     }
 
     public FluidStorageType getType() {
@@ -211,7 +212,7 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
         markDirty();
     }
 
-    public ItemHandlerFluid getFilters() {
+    public FluidInventory getFilters() {
         return filters;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/storage/NetworkNodeStorage.java

@@ -16,8 +16,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheItem;
 import com.raoulvdberge.refinedstorage.apiimpl.util.OneSixMigrationHelper;
 import com.raoulvdberge.refinedstorage.block.BlockStorage;
 import com.raoulvdberge.refinedstorage.block.enums.ItemStorageType;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerNetworkNode;
 import com.raoulvdberge.refinedstorage.tile.TileStorage;
 import com.raoulvdberge.refinedstorage.tile.config.IAccessType;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
@@ -44,7 +44,7 @@ public class NetworkNodeStorage extends NetworkNode implements IGuiStorage, ISto
     private static final String NBT_MODE = "Mode";
     public static final String NBT_ID = "Id";
 
-    private ItemHandlerBase filters = new ItemHandlerBase(9, new ItemHandlerListenerNetworkNode(this));
+    private ItemHandlerBase filters = new ItemHandlerBase(9, new ListenerNetworkNode(this));
 
     private ItemStorageType type;
 
@@ -173,7 +173,7 @@ public class NetworkNodeStorage extends NetworkNode implements IGuiStorage, ISto
 
         accessType = AccessTypeUtils.readAccessType(tag);
 
-        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, filters, null);
+        OneSixMigrationHelper.migrateEmptyWhitelistToEmptyBlacklist(version, this, filters);
     }
 
     public ItemStorageType getType() {

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/util/OneSixMigrationHelper.java

@@ -205,10 +205,10 @@ public class OneSixMigrationHelper implements IOneSixMigrationHelper {
     public static void removalHook() {
     }
 
-    public static void migrateEmptyWhitelistToEmptyBlacklist(String version, IFilterable filterable, @Nullable IItemHandler itemFilterInv, @Nullable IItemHandler fluidFilterInv) {
+    public static void migrateEmptyWhitelistToEmptyBlacklist(String version, IFilterable filterable, @Nullable IItemHandler itemFilterInv) {
         // Only migrate if we come from a version where the RS version tag stuff in NetworkNode wasn't added yet.
         // Otherwise, we would constantly migrate empty whitelists to empty blacklists...
-        if (version == null && filterable.getMode() == IFilterable.WHITELIST && IFilterable.isEmpty(itemFilterInv) && IFilterable.isEmpty(fluidFilterInv)) {
+        if (version == null && filterable.getMode() == IFilterable.WHITELIST && IFilterable.isEmpty(itemFilterInv)) {
             filterable.setMode(IFilter.MODE_BLACKLIST);
         }
     }

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerBase.java

@@ -1,27 +1,30 @@
 package com.raoulvdberge.refinedstorage.container;
 
+import com.raoulvdberge.refinedstorage.RS;
+import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.container.slot.*;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
-import com.raoulvdberge.refinedstorage.gui.GuiBase;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
-import com.raoulvdberge.refinedstorage.gui.GuiFluidAmount;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyDisabled;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import com.raoulvdberge.refinedstorage.network.MessageSlotFilterFluidUpdate;
 import com.raoulvdberge.refinedstorage.tile.TileBase;
-import com.raoulvdberge.refinedstorage.tile.config.IType;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataWatcher;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
 import invtweaks.api.container.InventoryContainer;
-import net.minecraft.client.Minecraft;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.inventory.ClickType;
 import net.minecraft.inventory.Container;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
-import net.minecraftforge.fml.client.FMLClientHandler;
+import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fml.common.FMLCommonHandler;
-import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.items.ItemHandlerHelper;
 
-import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
 
 @InventoryContainer(showOptions = false)
 public abstract class ContainerBase extends Container {
@@ -31,11 +34,16 @@ public abstract class ContainerBase extends Container {
     private TileDataWatcher listener;
     private EntityPlayer player;
 
+    private List<SlotFilterFluid> fluidSlots = new ArrayList<>();
+    private List<FluidStack> fluids = new ArrayList<>();
+
     public ContainerBase(@Nullable TileBase tile, EntityPlayer player) {
         this.tile = tile;
+
         if (tile != null && player instanceof EntityPlayerMP) {
             listener = new TileDataWatcher((EntityPlayerMP) player, tile.getDataManager());
         }
+
         this.player = player;
     }
 
@@ -56,7 +64,7 @@ public abstract class ContainerBase extends Container {
             int y = yInventory + 4 + (3 * 18);
 
             if (isHeldItemDisabled() && i == player.inventory.currentItem) {
-                addSlotToContainer(new SlotDisabled(player.inventory, id, x, y));
+                addSlotToContainer(new SlotLegacyDisabled(player.inventory, id, x, y));
             } else {
                 addSlotToContainer(new Slot(player.inventory, id, x, y));
             }
@@ -77,8 +85,7 @@ public abstract class ContainerBase extends Container {
     public ItemStack slotClick(int id, int dragType, ClickType clickType, EntityPlayer player) {
         Slot slot = id >= 0 ? getSlot(id) : null;
 
-        // Prevent swapping disabled held item with the number keys
+        // Prevent swapping disabled held item with the number keys (dragType is the slot we're swapping with)
-        // (dragType is the slot we're swapping with)
         if (isHeldItemDisabled() && clickType == ClickType.SWAP && dragType == player.inventory.currentItem) {
             return ItemStack.EMPTY;
         }
@@ -88,20 +95,11 @@ public abstract class ContainerBase extends Container {
                 if (clickType == ClickType.QUICK_MOVE) {
                     slot.putStack(ItemStack.EMPTY);
                 } else if (!player.inventory.getItemStack().isEmpty()) {
-                    slot.putStack(ItemHandlerHelper.copyStackWithSize(player.inventory.getItemStack(), ((SlotFilter) slot).getInitialAmount(player.inventory.getItemStack())));
+                    slot.putStack(player.inventory.getItemStack().copy());
                 } else if (slot.getHasStack()) {
-                    if (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getType().getType() == IType.FLUIDS) {
+                    slot.getStack().setCount(((SlotFilter) slot).getModifiedAmount(dragType));
-                        if (FMLCommonHandler.instance().getSide() == Side.CLIENT) {
-                            Minecraft.getMinecraft().addScheduledTask(() -> {
-                                // Prevent JEI crash - this needs to run on the main thread and not on the packet handler thread
-                                FMLClientHandler.instance().showGuiScreen(new GuiFluidAmount((GuiBase) Minecraft.getMinecraft().currentScreen, player, slot.slotNumber, ((SlotFilterItemOrFluid) slot).getActualStack(), ((SlotFilterItemOrFluid) slot).getMaxFluidAmount()));
-                            });
-                        }
-                    } else {
-                        slot.getStack().setCount(((SlotFilter) slot).getModifiedAmount(dragType));
 
-                        detectAndSendChanges();
+                    detectAndSendChanges();
-                    }
                 }
             } else if (player.inventory.getItemStack().isEmpty()) {
                 slot.putStack(ItemStack.EMPTY);
@@ -110,7 +108,21 @@ public abstract class ContainerBase extends Container {
             }
 
             return player.inventory.getItemStack();
-        } else if (slot instanceof SlotFilterLegacy) {
+        } else if (slot instanceof SlotFilterFluid) {
+            if (((SlotFilterFluid) slot).isSizeAllowed()) {
+                if (clickType == ClickType.QUICK_MOVE) {
+                    ((SlotFilterFluid) slot).onContainerClicked(ItemStack.EMPTY);
+                } else if (!player.inventory.getItemStack().isEmpty()) {
+                    ((SlotFilterFluid) slot).onContainerClicked(player.inventory.getItemStack());
+                }
+            } else if (player.inventory.getItemStack().isEmpty()) {
+                ((SlotFilterFluid) slot).onContainerClicked(ItemStack.EMPTY);
+            } else {
+                ((SlotFilterFluid) slot).onContainerClicked(player.inventory.getItemStack());
+            }
+
+            return player.inventory.getItemStack();
+        } else if (slot instanceof SlotLegacyFilter) {
             if (player.inventory.getItemStack().isEmpty()) {
                 slot.putStack(ItemStack.EMPTY);
             } else if (slot.isItemValid(player.inventory.getItemStack())) {
@@ -118,7 +130,7 @@ public abstract class ContainerBase extends Container {
             }
 
             return player.inventory.getItemStack();
-        } else if (slot instanceof SlotDisabled) {
+        } else if (slot instanceof SlotLegacyDisabled) {
             return ItemStack.EMPTY;
         }
 
@@ -130,9 +142,9 @@ public abstract class ContainerBase extends Container {
         return ItemStack.EMPTY;
     }
 
-    protected ItemStack mergeItemStackToFilters(ItemStack stack, int begin, int end) {
+    protected ItemStack transferToFilters(ItemStack stack, int begin, int end) {
         for (int i = begin; i < end; ++i) {
-            if (API.instance().getComparer().isEqualNoQuantity(getStackFromSlot(getSlot(i)), stack)) {
+            if (API.instance().getComparer().isEqualNoQuantity(getSlot(i).getStack(), stack)) {
                 return ItemStack.EMPTY;
             }
         }
@@ -140,7 +152,7 @@ public abstract class ContainerBase extends Container {
         for (int i = begin; i < end; ++i) {
             Slot slot = getSlot(i);
 
-            if (getStackFromSlot(slot).isEmpty() && slot.isItemValid(stack)) {
+            if (slot.getStack().isEmpty() && slot.isItemValid(stack)) {
                 slot.putStack(ItemHandlerHelper.copyStackWithSize(stack, 1));
                 slot.onSlotChanged();
 
@@ -151,19 +163,30 @@ public abstract class ContainerBase extends Container {
         return ItemStack.EMPTY;
     }
 
-    @Nonnull
+    protected ItemStack transferToFluidFilters(ItemStack stack) {
-    private ItemStack getStackFromSlot(Slot slot) {
+        FluidStack fluidInContainer = StackUtils.getFluid(stack, true).getValue();
-        ItemStack stackInSlot = slot.getStack();
 
-        if (stackInSlot.isEmpty()) {
+        if (fluidInContainer == null) {
-            if (slot instanceof SlotFilterFluid) {
+            return ItemStack.EMPTY;
-                stackInSlot = ((SlotFilterFluid) slot).getActualStack();
+        }
-            } else if (slot instanceof SlotFilterItemOrFluid) {
+
-                stackInSlot = ((SlotFilterItemOrFluid) slot).getActualStack();
+        for (SlotFilterFluid slot : fluidSlots) {
+            if (API.instance().getComparer().isEqual(fluidInContainer, slot.getFluidInventory().getFluid(slot.getSlotIndex()), IComparer.COMPARE_NBT)) {
+                return ItemStack.EMPTY;
             }
         }
 
-        return stackInSlot;
+        for (SlotFilterFluid slot : fluidSlots) {
+            FluidInventory inventory = slot.getFluidInventory();
+
+            if (inventory.getFluid(slot.getSlotIndex()) == null) {
+                slot.onContainerClicked(stack);
+
+                return ItemStack.EMPTY;
+            }
+        }
+
+        return ItemStack.EMPTY;
     }
 
     @Override
@@ -175,6 +198,16 @@ public abstract class ContainerBase extends Container {
         return false;
     }
 
+    @Override
+    protected Slot addSlotToContainer(Slot slot) {
+        if (slot instanceof SlotFilterFluid) {
+            fluids.add(null);
+            fluidSlots.add((SlotFilterFluid) slot);
+        }
+
+        return super.addSlotToContainer(slot);
+    }
+
     @Override
     public void detectAndSendChanges() {
         super.detectAndSendChanges();
@@ -182,6 +215,21 @@ public abstract class ContainerBase extends Container {
         if (listener != null) {
             listener.detectAndSendChanges();
         }
+
+        if (this.getPlayer() instanceof EntityPlayerMP) {
+            for (int i = 0; i < this.fluidSlots.size(); ++i) {
+                SlotFilterFluid slot = this.fluidSlots.get(i);
+
+                FluidStack cached = this.fluids.get(i);
+                FluidStack actual = slot.getFluidInventory().getFluid(slot.getSlotIndex());
+
+                if (!API.instance().getComparer().isEqual(cached, actual, IComparer.COMPARE_QUANTITY | IComparer.COMPARE_NBT)) {
+                    this.fluids.set(i, actual);
+
+                    RS.INSTANCE.network.sendTo(new MessageSlotFilterFluidUpdate(slot.slotNumber, actual), (EntityPlayerMP) this.getPlayer());
+                }
+            }
+        }
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerConstructor.java

@@ -1,21 +1,29 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeConstructor;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileConstructor;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerConstructor extends ContainerBase {
+    private NetworkNodeConstructor constructor;
+
     public ContainerConstructor(TileConstructor constructor, EntityPlayer player) {
         super(constructor, player);
 
+        this.constructor = constructor.getNode();
+
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(constructor.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
-        addSlotToContainer(new SlotFilterItemOrFluid(constructor.getNode(), 0, 80, 20));
+        addSlotToContainer(new SlotFilter(constructor.getNode().getItemFilters(), 0, 80, 20).setEnableHandler(() -> constructor.getNode().getType() == IType.ITEMS));
+        addSlotToContainer(new SlotFilterFluid(constructor.getNode().getFluidFilters(), 0, 80, 20, 0).setEnableHandler(() -> constructor.getNode().getType() == IType.FLUIDS));
 
         addPlayerInventory(8, 55);
     }
@@ -34,7 +42,11 @@ public class ContainerConstructor extends ContainerBase {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 4, false)) {
-                return mergeItemStackToFilters(stack, 4, 4 + 1);
+                if (constructor.getType() == IType.ITEMS) {
+                    return transferToFilters(stack, 4, 4 + 1);
+                } else {
+                    return transferToFluidFilters(stack);
+                }
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCrafterManager.java

@@ -8,7 +8,7 @@ import com.raoulvdberge.refinedstorage.gui.IResizableDisplay;
 import com.raoulvdberge.refinedstorage.gui.grid.filtering.GridFilterParser;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackItem;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
 import com.raoulvdberge.refinedstorage.item.ItemPattern;
 import com.raoulvdberge.refinedstorage.tile.TileCrafterManager;
 import net.minecraft.entity.player.EntityPlayer;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerCraftingSettings.java

@@ -1,45 +1,31 @@
 package com.raoulvdberge.refinedstorage.container;
 
+import com.raoulvdberge.refinedstorage.container.slot.SlotDisabled;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluidDisabled;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackFluid;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.GridStackItem;
 import com.raoulvdberge.refinedstorage.gui.grid.stack.IGridStack;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.ItemHandlerHelper;
 import net.minecraftforge.items.ItemStackHandler;
-import net.minecraftforge.items.SlotItemHandler;
-
-import javax.annotation.Nonnull;
 
 public class ContainerCraftingSettings extends ContainerBase {
     public ContainerCraftingSettings(EntityPlayer player, IGridStack stack) {
         super(null, player);
 
-        IItemHandler handler = null;
-
         if (stack instanceof GridStackFluid) {
-            handler = new ItemHandlerFluid(1, null);
+            FluidInventory inventory = new FluidInventory(1);
 
-            ((ItemHandlerFluid) handler).setFluidStack(0, ((GridStackFluid) stack).getStack());
+            inventory.setFluid(0, ((GridStackFluid) stack).getStack());
+
+            addSlotToContainer(new SlotFilterFluidDisabled(inventory, 0, 89, 48));
         } else if (stack instanceof GridStackItem) {
-            handler = new ItemStackHandler(1);
+            ItemStackHandler handler = new ItemStackHandler(1);
 
-            ((ItemStackHandler) handler).setStackInSlot(0, ItemHandlerHelper.copyStackWithSize(((GridStackItem) stack).getStack(), 1));
+            handler.setStackInSlot(0, ItemHandlerHelper.copyStackWithSize(((GridStackItem) stack).getStack(), 1));
+
+            addSlotToContainer(new SlotDisabled(handler, 0, 89, 48));
         }
-
-        addSlotToContainer(new SlotItemHandler(handler, 0, 89, 48) {
-            @Override
-            public boolean isItemValid(@Nonnull ItemStack stack) {
-                return false;
-            }
-
-            @Nonnull
-            @Override
-            public ItemStack getStack() {
-                return stack instanceof GridStackFluid ? ItemStack.EMPTY : super.getStack();
-            }
-        });
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDestructor.java

@@ -1,22 +1,33 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDestructor;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileDestructor;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerDestructor extends ContainerBase {
+    private NetworkNodeDestructor destructor;
+
     public ContainerDestructor(TileDestructor destructor, EntityPlayer player) {
         super(destructor, player);
 
+        this.destructor = destructor.getNode();
+
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(destructor.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterItemOrFluid(destructor.getNode(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilter(destructor.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> destructor.getNode().getType() == IType.ITEMS));
+        }
+
+        for (int i = 0; i < 9; ++i) {
+            addSlotToContainer(new SlotFilterFluid(destructor.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> destructor.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 55);
@@ -32,11 +43,15 @@ public class ContainerDestructor extends ContainerBase {
             stack = slot.getStack();
 
             if (index < 4) {
-                if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) {
+                if (!mergeItemStack(stack, 4 + 9 + 9, inventorySlots.size(), false)) {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 4, false)) {
-                return mergeItemStackToFilters(stack, 4, 4 + 9);
+                if (destructor.getType() == IType.ITEMS) {
+                    return transferToFilters(stack, 4, 4 + 9);
+                } else {
+                    return transferToFluidFilters(stack);
+                }
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDetector.java

@@ -1,16 +1,24 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDetector;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileDetector;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 
 public class ContainerDetector extends ContainerBase {
+    private NetworkNodeDetector detector;
+
     public ContainerDetector(TileDetector detector, EntityPlayer player) {
         super(detector, player);
 
-        addSlotToContainer(new SlotFilterItemOrFluid(detector.getNode(), 0, 107, 20));
+        this.detector = detector.getNode();
+
+        addSlotToContainer(new SlotFilter(detector.getNode().getItemFilters(), 0, 107, 20).setEnableHandler(() -> detector.getNode().getType() == IType.ITEMS));
+        addSlotToContainer(new SlotFilterFluid(detector.getNode().getFluidFilters(), 0, 107, 20).setEnableHandler(() -> detector.getNode().getType() == IType.FLUIDS));
 
         addPlayerInventory(8, 55);
     }
@@ -19,8 +27,14 @@ public class ContainerDetector extends ContainerBase {
     public ItemStack transferStackInSlot(EntityPlayer player, int index) {
         Slot slot = getSlot(index);
 
+        ItemStack stack = slot.getStack();
+
         if (slot.getHasStack() && index > 0) {
-            return mergeItemStackToFilters(slot.getStack(), 0, 1);
+            if (detector.getType() == IType.ITEMS) {
+                return transferToFilters(stack, 0, 1);
+            } else {
+                return transferToFluidFilters(stack);
+            }
         }
 
         return ItemStack.EMPTY;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskDrive.java

@@ -1,25 +1,36 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerDiskDrive extends ContainerBase {
-    public ContainerDiskDrive(TileDiskDrive drive, EntityPlayer player) {
+    private NetworkNodeDiskDrive diskDrive;
-        super(drive, player);
+
+    public ContainerDiskDrive(TileDiskDrive diskDrive, EntityPlayer player) {
+        super(diskDrive, player);
+
+        this.diskDrive = diskDrive.getNode();
 
         int x = 80;
         int y = 54;
 
         for (int i = 0; i < 8; ++i) {
-            addSlotToContainer(new SlotItemHandler(drive.getNode().getDisks(), i, x + ((i % 2) * 18), y + Math.floorDiv(i, 2) * 18));
+            addSlotToContainer(new SlotItemHandler(diskDrive.getNode().getDisks(), i, x + ((i % 2) * 18), y + Math.floorDiv(i, 2) * 18));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterItemOrFluid(drive.getNode(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilter(diskDrive.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskDrive.getNode().getType() == IType.ITEMS));
+        }
+
+        for (int i = 0; i < 9; ++i) {
+            addSlotToContainer(new SlotFilterFluid(diskDrive.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskDrive.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 141);
@@ -35,11 +46,15 @@ public class ContainerDiskDrive extends ContainerBase {
             stack = slot.getStack();
 
             if (index < 8) {
-                if (!mergeItemStack(stack, 8 + 9, inventorySlots.size(), false)) {
+                if (!mergeItemStack(stack, 8 + 9 + 9, inventorySlots.size(), false)) {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 8, false)) {
-                return mergeItemStackToFilters(stack, 8, 8 + 9);
+                if (diskDrive.getType() == IType.ITEMS) {
+                    return transferToFilters(stack, 8, 8 + 9);
+                } else {
+                    return transferToFluidFilters(stack);
+                }
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerDiskManipulator.java

@@ -1,30 +1,41 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskmanipulator.NetworkNodeDiskManipulator;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileDiskManipulator;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerDiskManipulator extends ContainerBase {
-    public ContainerDiskManipulator(TileDiskManipulator manipulator, EntityPlayer player) {
+    private NetworkNodeDiskManipulator diskManipulator;
-        super(manipulator, player);
+
+    public ContainerDiskManipulator(TileDiskManipulator diskManipulator, EntityPlayer player) {
+        super(diskManipulator, player);
+
+        this.diskManipulator = diskManipulator.getNode();
 
         for (int i = 0; i < 4; ++i) {
-            addSlotToContainer(new SlotItemHandler(manipulator.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
+            addSlotToContainer(new SlotItemHandler(diskManipulator.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
         for (int i = 0; i < 3; ++i) {
-            addSlotToContainer(new SlotItemHandler(manipulator.getNode().getInputDisks(), i, 44, 57 + (i * 18)));
+            addSlotToContainer(new SlotItemHandler(diskManipulator.getNode().getInputDisks(), i, 44, 57 + (i * 18)));
         }
 
         for (int i = 0; i < 3; ++i) {
-            addSlotToContainer(new SlotItemHandler(manipulator.getNode().getOutputDisks(), i, 116, 57 + (i * 18)));
+            addSlotToContainer(new SlotItemHandler(diskManipulator.getNode().getOutputDisks(), i, 116, 57 + (i * 18)));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterItemOrFluid(manipulator.getNode(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilter(diskManipulator.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskManipulator.getNode().getType() == IType.ITEMS));
+        }
+
+        for (int i = 0; i < 9; ++i) {
+            addSlotToContainer(new SlotFilterFluid(diskManipulator.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> diskManipulator.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 129);
@@ -39,12 +50,16 @@ public class ContainerDiskManipulator extends ContainerBase {
         if (slot.getHasStack()) {
             stack = slot.getStack();
 
-            if (index < 4 + 6) {
+            if (index < 4 + 3 + 3) {
-                if (!mergeItemStack(stack, 4 + 6 + 9, inventorySlots.size(), false)) {
+                if (!mergeItemStack(stack, 4 + 3 + 3 + 9 + 9, inventorySlots.size(), false)) {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 4 + 3, false)) {
-                return mergeItemStackToFilters(stack, 4 + 6, 4 + 6 + 9);
+                if (diskManipulator.getType() == IType.ITEMS) {
+                    return transferToFilters(stack, 4 + 3 + 3, 4 + 3 + 3 + 9);
+                } else {
+                    return transferToFluidFilters(stack);
+                }
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExporter.java

@@ -1,25 +1,33 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeExporter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileExporter;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerExporter extends ContainerBase {
+    private NetworkNodeExporter exporter;
+
     public ContainerExporter(TileExporter exporter, EntityPlayer player) {
         super(exporter, player);
 
-        this.inventorySlots.clear();
+        this.exporter = exporter.getNode();
-        this.inventoryItemStacks.clear();
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(exporter.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterItemOrFluid(exporter.getNode(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilter(exporter.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> exporter.getNode().getType() == IType.ITEMS));
+        }
+
+        for (int i = 0; i < 9; ++i) {
+            addSlotToContainer(new SlotFilterFluid(exporter.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> exporter.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 55);
@@ -35,11 +43,15 @@ public class ContainerExporter extends ContainerBase {
             stack = slot.getStack();
 
             if (index < 4) {
-                if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) {
+                if (!mergeItemStack(stack, 4 + 9 + 9, inventorySlots.size(), false)) {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 4, false)) {
-                return mergeItemStackToFilters(stack, 4, 4 + 9);
+                if (exporter.getType() == IType.ITEMS) {
+                    return transferToFilters(stack, 4, 4 + 9);
+                } else {
+                    return transferToFluidFilters(stack);
+                }
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerExternalStorage.java

@@ -1,17 +1,28 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeExternalStorage;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileExternalStorage;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 
 public class ContainerExternalStorage extends ContainerBase {
+    private NetworkNodeExternalStorage externalStorage;
+
     public ContainerExternalStorage(TileExternalStorage externalStorage, EntityPlayer player) {
         super(externalStorage, player);
 
+        this.externalStorage = externalStorage.getNode();
+
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterItemOrFluid(externalStorage.getNode(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilter(externalStorage.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> externalStorage.getNode().getType() == IType.ITEMS));
+        }
+
+        for (int i = 0; i < 9; ++i) {
+            addSlotToContainer(new SlotFilterFluid(externalStorage.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> externalStorage.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 141);
@@ -21,8 +32,12 @@ public class ContainerExternalStorage extends ContainerBase {
     public ItemStack transferStackInSlot(EntityPlayer player, int index) {
         Slot slot = getSlot(index);
 
-        if (slot.getHasStack() && index >= 8) {
+        if (slot.getHasStack() && index > 8) {
-            return mergeItemStackToFilters(slot.getStack(), 0, 9);
+            if (externalStorage.getType() == IType.ITEMS) {
+                return transferToFilters(slot.getStack(), 0, 9);
+            } else {
+                return transferToFluidFilters(slot.getStack());
+            }
         }
 
         return ItemStack.EMPTY;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFilter.java

@@ -1,8 +1,8 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilterIcon;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilterIcon;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilterItems;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilterItems;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
@@ -50,7 +50,7 @@ public class ContainerFilter extends ContainerBase {
             stack = slot.getStack();
 
             if (index > 27 - 1) {
-                return mergeItemStackToFilters(stack, 0, 27);
+                return transferToFilters(stack, 0, 27);
             }
 
             return ItemStack.EMPTY;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidAmount.java

@@ -1,32 +1,18 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluidDisabled;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.items.ItemHandlerHelper;
-import net.minecraftforge.items.SlotItemHandler;
-
-import javax.annotation.Nonnull;
 
 public class ContainerFluidAmount extends ContainerBase {
-    public ContainerFluidAmount(EntityPlayer player, ItemStack fluidContainer) {
+    public ContainerFluidAmount(EntityPlayer player, FluidStack stack) {
         super(null, player);
 
-        ItemHandlerFluid handler = new ItemHandlerFluid(1, null);
+        FluidInventory inventory = new FluidInventory(1);
 
-        handler.setStackInSlot(0, ItemHandlerHelper.copyStackWithSize(fluidContainer, 1));
+        inventory.setFluid(0, stack);
 
-        addSlotToContainer(new SlotItemHandler(handler, 0, 89, 48) {
+        addSlotToContainer(new SlotFilterFluidDisabled(inventory, 0, 89, 48, 0));
-            @Override
-            public boolean isItemValid(@Nonnull ItemStack stack) {
-                return false;
-            }
-
-            @Nonnull
-            @Override
-            public ItemStack getStack() {
-                return ItemStack.EMPTY;
-            }
-        });
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidInterface.java

@@ -1,14 +1,11 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidInterface;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
 import com.raoulvdberge.refinedstorage.tile.TileFluidInterface;
-import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
-import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerFluidInterface extends ContainerBase {
@@ -20,31 +17,7 @@ public class ContainerFluidInterface extends ContainerBase {
         }
 
         addSlotToContainer(new SlotItemHandler(fluidInterface.getNode().getIn(), 0, 44, 32));
-        addSlotToContainer(new SlotFilterItemOrFluid(new IType() {
+        addSlotToContainer(new SlotFilterFluid(fluidInterface.getNode().getOut(), 0, 116, 32, SlotFilter.FILTER_ALLOW_SIZE));
-            @Override
-            public int getType() {
-                return IType.FLUIDS;
-            }
-
-            @Override
-            public void setType(int type) {
-                // NO OP
-            }
-
-            @Override
-            public IItemHandler getFilterInventory() {
-                return fluidInterface.getNode().getOut();
-            }
-
-            @Override
-            public boolean isServer() {
-                return !fluidInterface.getNode().getWorld().isRemote;
-            }
-        }, 0, 116, 32, SlotFilter.FILTER_ALLOW_SIZE, (slot, amount) -> {
-            if (amount > 0 && amount <= NetworkNodeFluidInterface.TANK_CAPACITY) {
-                fluidInterface.getNode().getOut().getStackInSlot(0).setCount(amount);
-            }
-        }, NetworkNodeFluidInterface.TANK_CAPACITY));
 
         addPlayerInventory(8, 122);
     }
@@ -58,12 +31,12 @@ public class ContainerFluidInterface extends ContainerBase {
         if (slot.getHasStack()) {
             stack = slot.getStack();
 
-            if (index < 4 + 2) {
+            if (index < 4 + 1 + 1) {
-                if (!mergeItemStack(stack, 4 + 2, inventorySlots.size(), false)) {
+                if (!mergeItemStack(stack, 4 + 1 + 1, inventorySlots.size(), false)) {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 4 + 1, false)) {
-                return mergeItemStackToFilters(stack, 5, 6);
+                return transferToFluidFilters(stack);
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerFluidStorage.java

@@ -1,6 +1,6 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterFluid;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileFluidStorage;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
@@ -11,7 +11,7 @@ public class ContainerFluidStorage extends ContainerBase {
         super(fluidStorage, player);
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterFluid(!fluidStorage.getWorld().isRemote, fluidStorage.getNode().getFilters(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilterFluid(fluidStorage.getNode().getFilters(), i, 8 + (18 * i), 20));
         }
 
         addPlayerInventory(8, 141);
@@ -21,8 +21,8 @@ public class ContainerFluidStorage extends ContainerBase {
     public ItemStack transferStackInSlot(EntityPlayer player, int index) {
         Slot slot = getSlot(index);
 
-        if (slot.getHasStack() && index >= 8) {
+        if (slot.getHasStack() && index > 8) {
-            return mergeItemStackToFilters(slot.getStack(), 0, 9);
+            return transferToFluidFilters(slot.getStack());
         }
 
         return ItemStack.EMPTY;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerGrid.java

@@ -10,9 +10,16 @@ import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
 import com.raoulvdberge.refinedstorage.api.storage.IStorageCacheListener;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskFactory;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid;
-import com.raoulvdberge.refinedstorage.container.slot.*;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
+import com.raoulvdberge.refinedstorage.container.slot.grid.SlotGridCrafting;
+import com.raoulvdberge.refinedstorage.container.slot.grid.SlotGridCraftingResult;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyBase;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyDisabled;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
 import com.raoulvdberge.refinedstorage.gui.IResizableDisplay;
 import com.raoulvdberge.refinedstorage.tile.TileBase;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import com.raoulvdberge.refinedstorage.tile.grid.WirelessGrid;
 import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
 import com.raoulvdberge.refinedstorage.tile.grid.portable.PortableGrid;
@@ -21,7 +28,6 @@ import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.inventory.IContainerListener;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.items.SlotItemHandler;
 
 import javax.annotation.Nullable;
@@ -33,7 +39,7 @@ public class ContainerGrid extends ContainerBase {
     private IResizableDisplay display;
 
     private SlotGridCraftingResult craftingResultSlot;
-    private SlotDisabled patternResultSlot;
+    private SlotLegacyBase patternResultSlot;
 
     public ContainerGrid(IGrid grid, IResizableDisplay display, @Nullable TileBase gridTile, EntityPlayer player) {
         super(gridTile, player);
@@ -96,11 +102,8 @@ public class ContainerGrid extends ContainerBase {
             int y = headerAndSlots + 4;
 
             for (int i = 0; i < 9 * 2; ++i) {
-                addSlotToContainer(new SlotFilterItemOrFluid((NetworkNodeGrid) grid, i, x, y, SlotFilter.FILTER_ALLOW_SIZE, (slot, amount) -> {
+                addSlotToContainer(new SlotFilter(((NetworkNodeGrid) grid).getProcessingMatrix(), i, x, y, SlotFilter.FILTER_ALLOW_SIZE).setEnableHandler(() -> ((NetworkNodeGrid) grid).isProcessingPattern() && ((NetworkNodeGrid) grid).getType() == IType.ITEMS));
-                    if (amount > 0 && amount <= Fluid.BUCKET_VOLUME && slot < ((NetworkNodeGrid) grid).getMatrixProcessingFluids().getSlots()) {
+                addSlotToContainer(new SlotFilterFluid(((NetworkNodeGrid) grid).getProcessingMatrixFluids(), i, x, y, SlotFilter.FILTER_ALLOW_SIZE).setEnableHandler(() -> ((NetworkNodeGrid) grid).isProcessingPattern() && ((NetworkNodeGrid) grid).getType() == IType.FLUIDS));
-                        ((NetworkNodeGrid) grid).getMatrixProcessingFluids().getStackInSlot(slot).setCount(amount);
-                    }
-                }, Fluid.BUCKET_VOLUME, () -> ((NetworkNodeGrid) grid).isProcessingPattern()));
 
                 x += 18;
 
@@ -121,7 +124,7 @@ public class ContainerGrid extends ContainerBase {
             y = headerAndSlots + 4;
 
             for (int i = 0; i < 9; ++i) {
-                addSlotToContainer(new SlotFilterLegacy(grid.getCraftingMatrix(), i, x, y, () -> !((NetworkNodeGrid) grid).isProcessingPattern()));
+                addSlotToContainer(new SlotLegacyFilter(grid.getCraftingMatrix(), i, x, y).setEnableHandler(() -> !((NetworkNodeGrid) grid).isProcessingPattern()));
 
                 x += 18;
 
@@ -131,7 +134,7 @@ public class ContainerGrid extends ContainerBase {
                 }
             }
 
-            addSlotToContainer(patternResultSlot = new SlotDisabled(grid.getCraftingResult(), 0, 134, headerAndSlots + 22, () -> !((NetworkNodeGrid) grid).isProcessingPattern()));
+            addSlotToContainer(patternResultSlot = (new SlotLegacyDisabled(grid.getCraftingResult(), 0, 134, headerAndSlots + 22).setEnableHandler(() -> !((NetworkNodeGrid) grid).isProcessingPattern())));
         }
     }
 
@@ -223,7 +226,7 @@ public class ContainerGrid extends ContainerBase {
 
                     sendCraftingSlots();
                     detectAndSendChanges();
-                } else if (slot != patternResultSlot && !(slot instanceof SlotFilterLegacy)) {
+                } else if (slot != patternResultSlot && !(slot instanceof SlotLegacyFilter)) {
                     ItemStack stack = slot.getStack();
 
                     if (grid.getGridType() != GridType.FLUID && stack.getItem() == RSItems.FILTER) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerImporter.java

@@ -1,22 +1,33 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeImporter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.tile.TileImporter;
+import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 
 public class ContainerImporter extends ContainerBase {
+    private NetworkNodeImporter importer;
+
     public ContainerImporter(TileImporter importer, EntityPlayer player) {
         super(importer, player);
 
+        this.importer = importer.getNode();
+
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(importer.getNode().getUpgrades(), i, 187, 6 + (i * 18)));
         }
 
         for (int i = 0; i < 9; ++i) {
-            addSlotToContainer(new SlotFilterItemOrFluid(importer.getNode(), i, 8 + (18 * i), 20));
+            addSlotToContainer(new SlotFilter(importer.getNode().getItemFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> importer.getNode().getType() == IType.ITEMS));
+        }
+
+        for (int i = 0; i < 9; ++i) {
+            addSlotToContainer(new SlotFilterFluid(importer.getNode().getFluidFilters(), i, 8 + (18 * i), 20).setEnableHandler(() -> importer.getNode().getType() == IType.FLUIDS));
         }
 
         addPlayerInventory(8, 55);
@@ -32,11 +43,15 @@ public class ContainerImporter extends ContainerBase {
             stack = slot.getStack();
 
             if (index < 4) {
-                if (!mergeItemStack(stack, 4 + 9, inventorySlots.size(), false)) {
+                if (!mergeItemStack(stack, 4 + 9 + 9, inventorySlots.size(), false)) {
                     return ItemStack.EMPTY;
                 }
             } else if (!mergeItemStack(stack, 0, 4, false)) {
-                return mergeItemStackToFilters(stack, 4, 4 + 9);
+                if (importer.getType() == IType.ITEMS) {
+                    return transferToFilters(stack, 4, 4 + 9);
+                } else {
+                    return transferToFluidFilters(stack);
+                }
             }
 
             if (stack.getCount() == 0) {

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerInterface.java

@@ -1,7 +1,7 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
 import com.raoulvdberge.refinedstorage.container.slot.SlotOutput;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
 import com.raoulvdberge.refinedstorage.tile.TileInterface;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorage.java

@@ -1,6 +1,6 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
 import com.raoulvdberge.refinedstorage.tile.TileStorage;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
@@ -21,8 +21,8 @@ public class ContainerStorage extends ContainerBase {
     public ItemStack transferStackInSlot(EntityPlayer player, int index) {
         Slot slot = getSlot(index);
 
-        if (slot.getHasStack() && index >= 8) {
+        if (slot.getHasStack() && index > 8) {
-            return mergeItemStackToFilters(slot.getStack(), 0, 9);
+            return transferToFilters(slot.getStack(), 0, 9);
         }
 
         return ItemStack.EMPTY;

src/main/java/com/raoulvdberge/refinedstorage/container/ContainerStorageMonitor.java

@@ -1,6 +1,6 @@
 package com.raoulvdberge.refinedstorage.container;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
 import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Slot;
@@ -10,7 +10,7 @@ public class ContainerStorageMonitor extends ContainerBase {
     public ContainerStorageMonitor(TileStorageMonitor storageMonitor, EntityPlayer player) {
         super(storageMonitor, player);
 
-        addSlotToContainer(new SlotFilterItemOrFluid(storageMonitor.getNode(), 0, 80, 20));
+        addSlotToContainer(new SlotFilter(storageMonitor.getNode().getItemFilters(), 0, 80, 20));
 
         addPlayerInventory(8, 55);
     }
@@ -22,7 +22,7 @@ public class ContainerStorageMonitor extends ContainerBase {
         ItemStack stack = slot.getStack();
 
         if (index > 0 && slot.getHasStack()) {
-            return mergeItemStackToFilters(stack, 0, 1);
+            return transferToFilters(stack, 0, 1);
         }
 
         return stack;

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotBase.java

@@ -0,0 +1,25 @@
+package com.raoulvdberge.refinedstorage.container.slot;
+
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.SlotItemHandler;
+
+import java.util.function.Supplier;
+
+public class SlotBase extends SlotItemHandler {
+    private Supplier<Boolean> enableHandler = () -> true;
+
+    public SlotBase(IItemHandler itemHandler, int inventoryIndex, int x, int y) {
+        super(itemHandler, inventoryIndex, x, y);
+    }
+
+    public SlotBase setEnableHandler(Supplier<Boolean> enableHandler) {
+        this.enableHandler = enableHandler;
+
+        return this;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enableHandler.get();
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotCrafterManager.java

@@ -3,15 +3,14 @@ package com.raoulvdberge.refinedstorage.container.slot;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCrafterManager;
 import com.raoulvdberge.refinedstorage.gui.IResizableDisplay;
 import net.minecraftforge.items.IItemHandler;
-import net.minecraftforge.items.SlotItemHandler;
 
-public class SlotCrafterManager extends SlotItemHandler {
+public class SlotCrafterManager extends SlotBase {
     private boolean visible;
     private NetworkNodeCrafterManager crafterManager;
     private IResizableDisplay display;
 
-    public SlotCrafterManager(IItemHandler itemHandler, int index, int xPosition, int yPosition, boolean visible, IResizableDisplay display, NetworkNodeCrafterManager crafterManager) {
+    public SlotCrafterManager(IItemHandler itemHandler, int inventoryIndex, int x, int y, boolean visible, IResizableDisplay display, NetworkNodeCrafterManager crafterManager) {
-        super(itemHandler, index, xPosition, yPosition);
+        super(itemHandler, inventoryIndex, x, y);
 
         this.visible = visible;
         this.display = display;

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotDisabled.java

@@ -1,32 +1,17 @@
 package com.raoulvdberge.refinedstorage.container.slot;
 
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
+import net.minecraftforge.items.IItemHandler;
 
 import javax.annotation.Nonnull;
-import java.util.function.Supplier;
 
-public class SlotDisabled extends Slot {
+public class SlotDisabled extends SlotBase {
-    private Supplier<Boolean> enableHandler = () -> true;
+    public SlotDisabled(IItemHandler itemHandler, int inventoryIndex, int x, int y) {
-
+        super(itemHandler, inventoryIndex, x, y);
-    public SlotDisabled(IInventory inventory, int id, int x, int y) {
-        super(inventory, id, x, y);
-    }
-
-    public SlotDisabled(IInventory inventory, int id, int x, int y, Supplier<Boolean> enableHandler) {
-        this(inventory, id, x, y);
-
-        this.enableHandler = enableHandler;
     }
 
     @Override
     public boolean isItemValid(@Nonnull ItemStack stack) {
         return false;
     }
-
-    @Override
-    public boolean isEnabled() {
-        return enableHandler.get();
-    }
 }

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilterFluid.java

@@ -1,26 +0,0 @@
-package com.raoulvdberge.refinedstorage.container.slot;
-
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.items.IItemHandler;
-
-import javax.annotation.Nonnull;
-
-public class SlotFilterFluid extends SlotFilter {
-    private boolean server;
-
-    public SlotFilterFluid(boolean server, IItemHandler handler, int id, int x, int y) {
-        super(handler, id, x, y);
-
-        this.server = server;
-    }
-
-    @Override
-    @Nonnull
-    public ItemStack getStack() {
-        return server ? super.getStack() : ItemStack.EMPTY;
-    }
-
-    public ItemStack getActualStack() {
-        return super.getStack();
-    }
-}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilterItemOrFluid.java

@@ -1,89 +0,0 @@
-package com.raoulvdberge.refinedstorage.container.slot;
-
-import com.raoulvdberge.refinedstorage.tile.config.IType;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.Fluid;
-import net.minecraftforge.items.IItemHandler;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.function.Supplier;
-
-public class SlotFilterItemOrFluid extends SlotFilter {
-    public interface IFluidAmountChangeListener {
-        void onChangeRequested(int slot, int amount);
-    }
-
-    private IType type;
-
-    @Nullable
-    private IFluidAmountChangeListener listener;
-    private int maxFluidAmount;
-
-    private Supplier<Boolean> enableHandler = () -> true;
-
-    public SlotFilterItemOrFluid(IType type, int id, int x, int y, int flags, @Nullable IFluidAmountChangeListener listener, int maxFluidAmount) {
-        super(null, id, x, y, flags);
-
-        this.type = type;
-        this.listener = listener;
-        this.maxFluidAmount = maxFluidAmount;
-    }
-
-    public SlotFilterItemOrFluid(IType type, int id, int x, int y, int flags, @Nullable IFluidAmountChangeListener listener, int maxFluidAmount, Supplier<Boolean> enableHandler) {
-        this(type, id, x, y, flags, listener, maxFluidAmount);
-
-        this.enableHandler = enableHandler;
-    }
-
-    public SlotFilterItemOrFluid(IType type, int id, int x, int y) {
-        this(type, id, x, y, 0, null, 0);
-    }
-
-    @Override
-    public IItemHandler getItemHandler() {
-        return type.getFilterInventory();
-    }
-
-    @Override
-    public boolean isBlockAllowed() {
-        return super.isBlockAllowed() && type.getType() == IType.ITEMS;
-    }
-
-    @Override
-    @Nonnull
-    public ItemStack getStack() {
-        return (type.getType() == IType.ITEMS || type.isServer()) ? super.getStack() : ItemStack.EMPTY;
-    }
-
-    public ItemStack getActualStack() {
-        return super.getStack();
-    }
-
-    public IType getType() {
-        return type;
-    }
-
-    @Override
-    public int getInitialAmount(ItemStack stack) {
-        if (type.getType() == IType.FLUIDS && isSizeAllowed()) {
-            return Fluid.BUCKET_VOLUME;
-        }
-
-        return super.getInitialAmount(stack);
-    }
-
-    @Nullable
-    public IFluidAmountChangeListener getFluidAmountChangeListener() {
-        return listener;
-    }
-
-    public int getMaxFluidAmount() {
-        return maxFluidAmount;
-    }
-
-    @Override
-    public boolean isEnabled() {
-        return enableHandler.get();
-    }
-}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotFilterLegacy.java

@@ -1,48 +0,0 @@
-package com.raoulvdberge.refinedstorage.container.slot;
-
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-
-import javax.annotation.Nonnull;
-import java.util.function.Supplier;
-
-public class SlotFilterLegacy extends Slot {
-    private Supplier<Boolean> enableHandler = () -> true;
-
-    public SlotFilterLegacy(IInventory inventory, int id, int x, int y) {
-        super(inventory, id, x, y);
-    }
-
-    public SlotFilterLegacy(IInventory inventory, int id, int x, int y, Supplier<Boolean> enableHandler) {
-        this(inventory, id, x, y);
-
-        this.enableHandler = enableHandler;
-    }
-
-    @Override
-    public boolean canTakeStack(EntityPlayer player) {
-        return false;
-    }
-
-    @Override
-    public boolean isItemValid(ItemStack stack) {
-        return true;
-    }
-
-    @Override
-    public void putStack(@Nonnull ItemStack stack) {
-        if (!stack.isEmpty()) {
-            stack.setCount(1);
-        }
-
-        super.putStack(stack);
-    }
-
-    @Override
-    public boolean isEnabled() {
-        return enableHandler.get();
-    }
-}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotGridCrafting.java

@@ -1,10 +0,0 @@
-package com.raoulvdberge.refinedstorage.container.slot;
-
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.Slot;
-
-public class SlotGridCrafting extends Slot {
-    public SlotGridCrafting(IInventory inventory, int index, int x, int y) {
-        super(inventory, index, x, y);
-    }
-}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/SlotOutput.java

@@ -2,13 +2,12 @@ package com.raoulvdberge.refinedstorage.container.slot;
 
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;
-import net.minecraftforge.items.SlotItemHandler;
 
 import javax.annotation.Nonnull;
 
-public class SlotOutput extends SlotItemHandler {
+public class SlotOutput extends SlotBase {
-    public SlotOutput(IItemHandler inventory, int id, int x, int y) {
+    public SlotOutput(IItemHandler inventory, int inventoryIndex, int x, int y) {
-        super(inventory, id, x, y);
+        super(inventory, inventoryIndex, x, y);
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/container/slot/filter/SlotFilter.java

@@ -1,5 +1,6 @@
-package com.raoulvdberge.refinedstorage.container.slot;
+package com.raoulvdberge.refinedstorage.container.slot.filter;
 
+import com.raoulvdberge.refinedstorage.container.slot.SlotBase;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.*;
@@ -7,25 +8,24 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.common.IPlantable;
 import net.minecraftforge.items.IItemHandler;
-import net.minecraftforge.items.SlotItemHandler;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-public class SlotFilter extends SlotItemHandler {
+public class SlotFilter extends SlotBase {
     public static final int FILTER_ALLOW_SIZE = 1;
     public static final int FILTER_ALLOW_BLOCKS = 2;
 
     private int flags = 0;
 
-    public SlotFilter(IItemHandler handler, int id, int x, int y, int flags) {
+    public SlotFilter(IItemHandler handler, int inventoryIndex, int x, int y, int flags) {
-        super(handler, id, x, y);
+        super(handler, inventoryIndex, x, y);
 
         this.flags = flags;
     }
 
-    public SlotFilter(IItemHandler handler, int id, int x, int y) {
+    public SlotFilter(IItemHandler handler, int inventoryIndex, int x, int y) {
-        this(handler, id, x, y, 0);
+        this(handler, inventoryIndex, x, y, 0);
     }
 
     @Override
@@ -70,10 +70,6 @@ public class SlotFilter extends SlotItemHandler {
         return amount;
     }
 
-    public int getInitialAmount(ItemStack stack) {
-        return stack.getCount();
-    }
-
     @Nullable
     public static IBlockState getBlockState(IBlockAccess world, BlockPos pos, @Nullable ItemStack stack) {
         if (stack != null) {

src/main/java/com/raoulvdberge/refinedstorage/container/slot/filter/SlotFilterFluid.java

@@ -0,0 +1,53 @@
+package com.raoulvdberge.refinedstorage.container.slot.filter;
+
+import com.raoulvdberge.refinedstorage.container.slot.SlotBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.items.ItemStackHandler;
+
+import javax.annotation.Nonnull;
+
+public class SlotFilterFluid extends SlotBase {
+    public static final int FILTER_ALLOW_SIZE = 1;
+
+    private int flags;
+    private FluidInventory fluidInventory;
+
+    public SlotFilterFluid(FluidInventory inventory, int inventoryIndex, int x, int y, int flags) {
+        super(new ItemStackHandler(inventory.getSlots()), inventoryIndex, x, y);
+
+        this.flags = flags;
+        this.fluidInventory = inventory;
+    }
+
+    public SlotFilterFluid(FluidInventory inventory, int inventoryIndex, int x, int y) {
+        this(inventory, inventoryIndex, x, y, 0);
+    }
+
+    @Override
+    public boolean isItemValid(@Nonnull ItemStack stack) {
+        return false;
+    }
+
+    public void onContainerClicked(@Nonnull ItemStack stack) {
+        if (stack.isEmpty()) {
+            fluidInventory.setFluid(getSlotIndex(), null);
+        } else {
+            FluidStack fluid = StackUtils.getFluid(stack, true).getValue();
+
+            if (fluid != null) {
+                fluidInventory.setFluid(getSlotIndex(), fluid);
+            }
+        }
+    }
+
+    public boolean isSizeAllowed() {
+        return (flags & FILTER_ALLOW_SIZE) == FILTER_ALLOW_SIZE;
+    }
+
+    public FluidInventory getFluidInventory() {
+        return fluidInventory;
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/filter/SlotFilterFluidDisabled.java

@@ -0,0 +1,21 @@
+package com.raoulvdberge.refinedstorage.container.slot.filter;
+
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import net.minecraft.item.ItemStack;
+
+import javax.annotation.Nonnull;
+
+public class SlotFilterFluidDisabled extends SlotFilterFluid {
+    public SlotFilterFluidDisabled(FluidInventory inventory, int inventoryIndex, int x, int y, int flags) {
+        super(inventory, inventoryIndex, x, y, flags);
+    }
+
+    public SlotFilterFluidDisabled(FluidInventory inventory, int inventoryIndex, int x, int y) {
+        super(inventory, inventoryIndex, x, y);
+    }
+
+    @Override
+    public void onContainerClicked(@Nonnull ItemStack stack) {
+        // NO OP
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/grid/SlotGridCrafting.java

@@ -0,0 +1,10 @@
+package com.raoulvdberge.refinedstorage.container.slot.grid;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+
+public class SlotGridCrafting extends Slot {
+    public SlotGridCrafting(IInventory inventory, int inventoryIndex, int x, int y) {
+        super(inventory, inventoryIndex, x, y);
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/grid/SlotGridCraftingResult.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.container.slot;
+package com.raoulvdberge.refinedstorage.container.slot.grid;
 
 import com.raoulvdberge.refinedstorage.api.network.grid.IGrid;
 import com.raoulvdberge.refinedstorage.container.ContainerGrid;
@@ -12,8 +12,8 @@ public class SlotGridCraftingResult extends SlotCrafting {
     private ContainerGrid container;
     private IGrid grid;
 
-    public SlotGridCraftingResult(ContainerGrid container, EntityPlayer player, IGrid grid, int id, int x, int y) {
+    public SlotGridCraftingResult(ContainerGrid container, EntityPlayer player, IGrid grid, int inventoryIndex, int x, int y) {
-        super(player, grid.getCraftingMatrix(), grid.getCraftingResult(), id, x, y);
+        super(player, grid.getCraftingMatrix(), grid.getCraftingResult(), inventoryIndex, x, y);
 
         this.container = container;
         this.grid = grid;

src/main/java/com/raoulvdberge/refinedstorage/container/slot/legacy/SlotLegacyBase.java

@@ -0,0 +1,26 @@
+package com.raoulvdberge.refinedstorage.container.slot.legacy;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+
+import java.util.function.Supplier;
+
+public class SlotLegacyBase extends Slot {
+    private Supplier<Boolean> enableHandler = () -> true;
+
+    public SlotLegacyBase(IInventory inventory, int inventoryIndex, int x, int y) {
+        super(inventory, inventoryIndex, x, y);
+    }
+
+    public SlotLegacyBase setEnableHandler(Supplier<Boolean> enableHandler) {
+        this.enableHandler = enableHandler;
+
+        return this;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enableHandler.get();
+    }
+
+}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/legacy/SlotLegacyDisabled.java

@@ -0,0 +1,17 @@
+package com.raoulvdberge.refinedstorage.container.slot.legacy;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+import javax.annotation.Nonnull;
+
+public class SlotLegacyDisabled extends SlotLegacyBase {
+    public SlotLegacyDisabled(IInventory inventory, int inventoryIndex, int x, int y) {
+        super(inventory, inventoryIndex, x, y);
+    }
+
+    @Override
+    public boolean isItemValid(@Nonnull ItemStack stack) {
+        return false;
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/container/slot/legacy/SlotLegacyFilter.java

@@ -0,0 +1,33 @@
+package com.raoulvdberge.refinedstorage.container.slot.legacy;
+
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+import javax.annotation.Nonnull;
+
+public class SlotLegacyFilter extends SlotLegacyBase {
+    public SlotLegacyFilter(IInventory inventory, int inventoryIndex, int x, int y) {
+        super(inventory, inventoryIndex, x, y);
+    }
+
+    @Override
+    public boolean canTakeStack(EntityPlayer player) {
+        return false;
+    }
+
+    @Override
+    public boolean isItemValid(ItemStack stack) {
+        return true;
+    }
+
+    @Override
+    public void putStack(@Nonnull ItemStack stack) {
+        if (!stack.isEmpty()) {
+            stack.setCount(1);
+        }
+
+        super.putStack(stack);
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/gui/GuiBase.java

@@ -4,26 +4,27 @@ import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.api.render.IElementDrawer;
 import com.raoulvdberge.refinedstorage.api.render.IElementDrawers;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
 import com.raoulvdberge.refinedstorage.gui.control.Scrollbar;
 import com.raoulvdberge.refinedstorage.gui.control.SideButton;
 import com.raoulvdberge.refinedstorage.integration.jei.IntegrationJEI;
 import com.raoulvdberge.refinedstorage.integration.jei.RecipeTransferHandlerGrid;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
 import com.raoulvdberge.refinedstorage.util.RenderUtils;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.resources.I18n;
+import net.minecraft.inventory.ClickType;
 import net.minecraft.inventory.Container;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.client.FMLClientHandler;
 import net.minecraftforge.fml.client.config.GuiCheckBox;
 import net.minecraftforge.fml.client.config.GuiUtils;
-import net.minecraftforge.items.SlotItemHandler;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;
 import org.lwjgl.opengl.GL11;
@@ -87,6 +88,16 @@ public abstract class GuiBase extends GuiContainer {
 
     private void runRunnables() {
         Queue<Consumer> queue = RUNNABLES.get(getClass());
+
+        if (queue != null && !queue.isEmpty()) {
+            Consumer callback;
+            while ((callback = queue.poll()) != null) {
+                callback.accept(this);
+            }
+        }
+
+        queue = RUNNABLES.get(GuiContainer.class);
+
         if (queue != null && !queue.isEmpty()) {
             Consumer callback;
             while ((callback = queue.poll()) != null) {
@@ -184,23 +195,19 @@ public abstract class GuiBase extends GuiContainer {
         for (int i = 0; i < inventorySlots.inventorySlots.size(); ++i) {
             Slot slot = inventorySlots.inventorySlots.get(i);
 
-            if (slot instanceof SlotItemHandler && ((SlotItemHandler) slot).getItemHandler() instanceof ItemHandlerFluid) {
+            if (slot.isEnabled() && slot instanceof SlotFilterFluid) {
-                FluidStack stack = ((ItemHandlerFluid) ((SlotItemHandler) slot).getItemHandler()).getFluidStackInSlot(slot.getSlotIndex());
+                FluidStack stack = ((SlotFilterFluid) slot).getFluidInventory().getFluid(slot.getSlotIndex());
 
                 if (stack != null) {
                     FLUID_RENDERER.draw(mc, guiLeft + slot.xPos, guiTop + slot.yPos, stack);
 
-                    if (slot instanceof SlotFilterItemOrFluid) {
+                    if (((SlotFilterFluid) slot).isSizeAllowed()) {
-                        int count = ((SlotFilterItemOrFluid) slot).getActualStack().getCount();
+                        drawQuantity(guiLeft + slot.xPos, guiTop + slot.yPos, API.instance().getQuantityFormatter().formatInBucketForm(stack.amount));
 
-                        if (count != 1) {
+                        GL11.glDisable(GL11.GL_LIGHTING);
-                            drawQuantity(guiLeft + slot.xPos, guiTop + slot.yPos, API.instance().getQuantityFormatter().formatInBucketForm(count));
-
-                            GL11.glDisable(GL11.GL_LIGHTING);
-                        }
                     }
 
-                    if (inBounds(guiLeft + slot.xPos, guiTop + slot.yPos, 18, 18, mouseX, mouseY)) {
+                    if (inBounds(guiLeft + slot.xPos, guiTop + slot.yPos, 17, 17, mouseX, mouseY)) {
                         this.hoveringFluid = stack.getLocalizedName();
                     }
                 }
@@ -238,6 +245,27 @@ public abstract class GuiBase extends GuiContainer {
         }
     }
 
+    @Override
+    protected void handleMouseClick(Slot slot, int slotId, int mouseButton, ClickType type) {
+        if (slot instanceof SlotFilterFluid && slot.isEnabled() && ((SlotFilterFluid) slot).isSizeAllowed() && type != ClickType.QUICK_MOVE && Minecraft.getMinecraft().player.inventory.getItemStack().isEmpty()) {
+            FluidStack stack = ((SlotFilterFluid) slot).getFluidInventory().getFluid(slot.getSlotIndex());
+
+            if (stack != null) {
+                FMLClientHandler.instance().showGuiScreen(new GuiFluidAmount(
+                    (GuiBase) Minecraft.getMinecraft().currentScreen,
+                    Minecraft.getMinecraft().player,
+                    slot.slotNumber,
+                    stack,
+                    ((SlotFilterFluid) slot).getFluidInventory().getMaxAmount()
+                ));
+            } else {
+                super.handleMouseClick(slot, slotId, mouseButton, type);
+            }
+        } else {
+            super.handleMouseClick(slot, slotId, mouseButton, type);
+        }
+    }
+
     @Override
     public void handleMouseInput() throws IOException {
         super.handleMouseInput();
@@ -432,4 +460,8 @@ public abstract class GuiBase extends GuiContainer {
 
         queue.add(callback);
     }
+
+    public static void executeLater(Consumer<GuiContainer> callback) {
+        executeLater(GuiContainer.class, callback);
+    }
 }

src/main/java/com/raoulvdberge/refinedstorage/gui/GuiFluidAmount.java

@@ -3,26 +3,26 @@ package com.raoulvdberge.refinedstorage.gui;
 import com.google.common.primitives.Ints;
 import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.container.ContainerFluidAmount;
-import com.raoulvdberge.refinedstorage.network.MessageFluidAmount;
+import com.raoulvdberge.refinedstorage.network.MessageSlotFilterFluidSetAmount;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
 
 public class GuiFluidAmount extends GuiAmountSpecifying {
     private int containerSlot;
-    private ItemStack fluidContainer;
+    private FluidStack stack;
     private int maxAmount;
 
-    public GuiFluidAmount(GuiBase parent, EntityPlayer player, int containerSlot, ItemStack fluidContainer, int maxAmount) {
+    public GuiFluidAmount(GuiBase parent, EntityPlayer player, int containerSlot, FluidStack stack, int maxAmount) {
-        super(parent, new ContainerFluidAmount(player, fluidContainer), 172, 99);
+        super(parent, new ContainerFluidAmount(player, stack), 172, 99);
 
         this.containerSlot = containerSlot;
-        this.fluidContainer = fluidContainer;
+        this.stack = stack;
         this.maxAmount = maxAmount;
     }
 
     @Override
     protected int getDefaultAmount() {
-        return fluidContainer.getCount();
+        return stack.amount;
     }
 
     @Override
@@ -63,7 +63,7 @@ public class GuiFluidAmount extends GuiAmountSpecifying {
         Integer amount = Ints.tryParse(amountField.getText());
 
         if (amount != null) {
-            RS.INSTANCE.network.sendToServer(new MessageFluidAmount(containerSlot, amount));
+            RS.INSTANCE.network.sendToServer(new MessageSlotFilterFluidSetAmount(containerSlot, amount));
 
             close();
         }

src/main/java/com/raoulvdberge/refinedstorage/gui/GuiStorageMonitor.java

@@ -3,7 +3,6 @@ package com.raoulvdberge.refinedstorage.gui;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.container.ContainerStorageMonitor;
 import com.raoulvdberge.refinedstorage.gui.control.SideButtonCompare;
-import com.raoulvdberge.refinedstorage.gui.control.SideButtonType;
 import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
 
 public class GuiStorageMonitor extends GuiBase {
@@ -13,8 +12,6 @@ public class GuiStorageMonitor extends GuiBase {
 
     @Override
     public void init(int x, int y) {
-        addSideButton(new SideButtonType(this, TileStorageMonitor.TYPE));
-
         addSideButton(new SideButtonCompare(this, TileStorageMonitor.COMPARE, IComparer.COMPARE_DAMAGE));
         addSideButton(new SideButtonCompare(this, TileStorageMonitor.COMPARE, IComparer.COMPARE_NBT));
     }

src/main/java/com/raoulvdberge/refinedstorage/integration/craftingtweaks/IntegrationCraftingTweaks.java

@@ -4,7 +4,7 @@ import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.raoulvdberge.refinedstorage.api.network.grid.GridType;
 import com.raoulvdberge.refinedstorage.container.ContainerGrid;
-import com.raoulvdberge.refinedstorage.container.slot.SlotGridCrafting;
+import com.raoulvdberge.refinedstorage.container.slot.grid.SlotGridCrafting;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraftforge.fml.common.Loader;
 import net.minecraftforge.fml.common.event.FMLInterModComms;

src/main/java/com/raoulvdberge/refinedstorage/integration/jei/GhostIngredientHandler.java

@@ -1,22 +1,18 @@
 package com.raoulvdberge.refinedstorage.integration.jei;
 
 import com.raoulvdberge.refinedstorage.RS;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterFluid;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterLegacy;
 import com.raoulvdberge.refinedstorage.gui.GuiBase;
-import com.raoulvdberge.refinedstorage.network.MessageFilterSlot;
+import com.raoulvdberge.refinedstorage.network.MessageSlotFilterSet;
-import com.raoulvdberge.refinedstorage.tile.config.IType;
+import com.raoulvdberge.refinedstorage.network.MessageSlotFilterSetFluid;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import mezz.jei.api.gui.IGhostIngredientHandler;
-import net.minecraft.init.Items;
 import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
-import net.minecraftforge.fluids.capability.IFluidHandlerItem;
 
 import java.awt.*;
 import java.util.ArrayList;
@@ -35,11 +31,7 @@ public class GhostIngredientHandler implements IGhostIngredientHandler<GuiBase>
             Rectangle bounds = new Rectangle(gui.getGuiLeft() + slot.xPos, gui.getGuiTop() + slot.yPos, 17, 17);
 
             if (ingredient instanceof ItemStack) {
-                if (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getType().getType() == IType.FLUIDS) {
+                if (slot instanceof SlotLegacyFilter || slot instanceof SlotFilter) {
-                    continue;
-                }
-
-                if (slot instanceof SlotFilterLegacy || (slot instanceof SlotFilter && !(slot instanceof SlotFilterFluid))) {
                     targets.add(new Target<I>() {
                         @Override
                         public Rectangle getArea() {
@@ -50,12 +42,12 @@ public class GhostIngredientHandler implements IGhostIngredientHandler<GuiBase>
                         public void accept(I ingredient) {
                             slot.putStack((ItemStack) ingredient);
 
-                            RS.INSTANCE.network.sendToServer(new MessageFilterSlot(slot.slotNumber, (ItemStack) ingredient));
+                            RS.INSTANCE.network.sendToServer(new MessageSlotFilterSet(slot.slotNumber, (ItemStack) ingredient));
                         }
                     });
                 }
             } else if (ingredient instanceof FluidStack) {
-                if (slot instanceof SlotFilterFluid || (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getType().getType() == IType.FLUIDS)) {
+                if (slot instanceof SlotFilterFluid) {
                     targets.add(new Target<I>() {
                         @Override
                         public Rectangle getArea() {
@@ -64,18 +56,7 @@ public class GhostIngredientHandler implements IGhostIngredientHandler<GuiBase>
 
                         @Override
                         public void accept(I ingredient) {
-                            ItemStack filledContainer = new ItemStack(Items.BUCKET);
+                            RS.INSTANCE.network.sendToServer(new MessageSlotFilterSetFluid(slot.slotNumber, StackUtils.copy((FluidStack) ingredient, Fluid.BUCKET_VOLUME)));
-
-                            IFluidHandlerItem fluidHandler = filledContainer.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
-
-                            fluidHandler.fill(StackUtils.copy((FluidStack) ingredient, Fluid.BUCKET_VOLUME), true);
-
-                            filledContainer = fluidHandler.getContainer();
-                            filledContainer.setCount(((FluidStack) ingredient).amount);
-
-                            slot.putStack(filledContainer);
-
-                            RS.INSTANCE.network.sendToServer(new MessageFilterSlot(slot.slotNumber, filledContainer));
                         }
                     });
                 }

src/main/java/com/raoulvdberge/refinedstorage/integration/jei/RSJEIPlugin.java

@@ -22,7 +22,8 @@ public class RSJEIPlugin implements IModPlugin {
         registry.addRecipeRegistryPlugin(new RecipeRegistryPluginCover());
         registry.addRecipeRegistryPlugin(new RecipeRegistryPluginHollowCover());
 
-        // TODO: #1905 registry.addGhostIngredientHandler(GuiBase.class, new GhostIngredientHandler());
+        // TODO: #1905
+        // registry.addGhostIngredientHandler(GuiBase.class, new GhostIngredientHandler());
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/inventory/ItemHandlerFluid.java

@@ -1,45 +0,0 @@
-package com.raoulvdberge.refinedstorage.inventory;
-
-import com.raoulvdberge.refinedstorage.util.StackUtils;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.items.ItemHandlerHelper;
-
-import javax.annotation.Nullable;
-import java.util.function.Consumer;
-
-public class ItemHandlerFluid extends ItemHandlerBase {
-    private FluidStack[] fluids;
-
-    public ItemHandlerFluid(int size, @Nullable Consumer<Integer> listener) {
-        super(size, listener, s -> StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(s, 1), true).getValue() != null);
-
-        this.fluids = new FluidStack[size];
-    }
-
-    @Override
-    protected void onContentsChanged(int slot) {
-        super.onContentsChanged(slot);
-
-        ItemStack stack = getStackInSlot(slot);
-
-        if (stack.isEmpty()) {
-            setFluidStack(slot, null);
-        } else {
-            setFluidStack(slot, StackUtils.getFluid(ItemHandlerHelper.copyStackWithSize(stack, 1), true).getValue());
-        }
-    }
-
-    public void setFluidStack(int slot, @Nullable FluidStack stack) {
-        fluids[slot] = stack;
-    }
-
-    @Nullable
-    public FluidStack getFluidStackInSlot(int slot) {
-        return fluids[slot];
-    }
-
-    public FluidStack[] getFluids() {
-        return fluids;
-    }
-}

src/main/java/com/raoulvdberge/refinedstorage/inventory/fluid/FluidHandlerFluidInterface.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.fluid;
 
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.FluidTank;

src/main/java/com/raoulvdberge/refinedstorage/inventory/fluid/FluidInventory.java

@@ -0,0 +1,84 @@
+package com.raoulvdberge.refinedstorage.inventory.fluid;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.FluidStack;
+
+import javax.annotation.Nullable;
+import java.util.function.Consumer;
+
+public class FluidInventory {
+    private static final String NBT_SLOT = "Slot_%d";
+
+    private FluidStack[] fluids;
+    private int maxAmount;
+
+    @Nullable
+    private Consumer<Integer> listener;
+
+    public FluidInventory(int size, int maxAmount, @Nullable Consumer<Integer> listener) {
+        this.fluids = new FluidStack[size];
+        this.maxAmount = maxAmount;
+        this.listener = listener;
+    }
+
+    public FluidInventory(int size, @Nullable Consumer<Integer> listener) {
+        this(size, Integer.MAX_VALUE, listener);
+    }
+
+    public FluidInventory(int size) {
+        this(size, Integer.MAX_VALUE, null);
+    }
+
+    public int getSlots() {
+        return fluids.length;
+    }
+
+    public int getMaxAmount() {
+        return maxAmount;
+    }
+
+    public FluidStack[] getFluids() {
+        return fluids;
+    }
+
+    @Nullable
+    public FluidStack getFluid(int slot) {
+        return fluids[slot];
+    }
+
+    public void setFluid(int slot, @Nullable FluidStack stack) {
+        if (stack != null && stack.amount <= 0 && stack.amount > maxAmount) {
+            throw new IllegalArgumentException("Fluid size is invalid (given: " + stack.amount + ", max size: " + maxAmount + ")");
+        }
+
+        fluids[slot] = stack;
+
+        if (listener != null) {
+            listener.accept(slot);
+        }
+    }
+
+    public NBTTagCompound writeToNbt() {
+        NBTTagCompound tag = new NBTTagCompound();
+
+        for (int i = 0; i < getSlots(); ++i) {
+            FluidStack stack = getFluid(i);
+
+            if (stack != null) {
+                tag.setTag(String.format(NBT_SLOT, i), stack.writeToNBT(new NBTTagCompound()));
+            }
+        }
+
+        return tag;
+    }
+
+    public void readFromNbt(NBTTagCompound tag) {
+        for (int i = 0; i < getSlots(); ++i) {
+            String key = String.format(NBT_SLOT, i);
+
+            if (tag.hasKey(key)) {
+                fluids[i] = FluidStack.loadFluidStackFromNBT(tag.getCompoundTag(key));
+            }
+        }
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerBase.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item;
 
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.ItemStackHandler;

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerFilter.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item;
 
 import com.raoulvdberge.refinedstorage.RSItems;
 import com.raoulvdberge.refinedstorage.api.network.grid.IGridTab;
@@ -7,6 +7,7 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.grid.GridTab;
 import com.raoulvdberge.refinedstorage.apiimpl.util.Filter;
 import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
+import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
 import com.raoulvdberge.refinedstorage.item.ItemFilter;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fml.common.FMLCommonHandler;

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerFilterIcon.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item;
 
 import com.raoulvdberge.refinedstorage.item.ItemFilter;
 import net.minecraft.item.ItemStack;

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerFilterItems.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item;
 
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import net.minecraft.item.ItemStack;

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerProxy.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item;
 
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.IItemHandler;

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/ItemHandlerUpgrade.java

@@ -1,6 +1,7 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item;
 
 import com.raoulvdberge.refinedstorage.RSItems;
+import com.raoulvdberge.refinedstorage.inventory.item.validator.ItemValidatorBasic;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
 
 import javax.annotation.Nullable;

src/main/java/com/raoulvdberge/refinedstorage/inventory/item/validator/ItemValidatorBasic.java

@@ -1,4 +1,4 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.item.validator;
 
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;

src/main/java/com/raoulvdberge/refinedstorage/inventory/listener/ListenerNetworkNode.java

@@ -1,13 +1,13 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.listener;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
 
 import java.util.function.Consumer;
 
-public class ItemHandlerListenerNetworkNode implements Consumer<Integer> {
+public class ListenerNetworkNode implements Consumer<Integer> {
     private INetworkNode node;
 
-    public ItemHandlerListenerNetworkNode(INetworkNode node) {
+    public ListenerNetworkNode(INetworkNode node) {
         this.node = node;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/inventory/listener/ListenerTile.java

@@ -1,13 +1,13 @@
-package com.raoulvdberge.refinedstorage.inventory;
+package com.raoulvdberge.refinedstorage.inventory.listener;
 
 import net.minecraft.tileentity.TileEntity;
 
 import java.util.function.Consumer;
 
-public class ItemHandlerListenerTile implements Consumer<Integer> {
+public class ListenerTile implements Consumer<Integer> {
     private TileEntity tile;
 
-    public ItemHandlerListenerTile(TileEntity tile) {
+    public ListenerTile(TileEntity tile) {
         this.tile = tile;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/item/ItemFilter.java

@@ -5,7 +5,7 @@ import com.raoulvdberge.refinedstorage.RSGui;
 import com.raoulvdberge.refinedstorage.RSItems;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.api.util.IFilter;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilterItems;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilterItems;
 import com.raoulvdberge.refinedstorage.item.info.ItemInfo;
 import com.raoulvdberge.refinedstorage.render.IModelRegistration;
 import com.raoulvdberge.refinedstorage.util.RenderUtils;

src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridFluidDelta.java

@@ -13,6 +13,7 @@ import net.minecraftforge.fml.common.network.ByteBufUtils;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import org.apache.commons.lang3.tuple.Pair;
 
 public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageGridFluidDelta, IMessage> {
     private INetwork network;
@@ -32,13 +33,15 @@ public class MessageGridFluidDelta implements IMessage, IMessageHandler<MessageG
 
     @Override
     public void fromBytes(ByteBuf buf) {
-        gridStack = new GridStackFluid(buf.readInt(), StackUtils.readFluidStack(buf), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), false);
+        Pair<Integer, FluidStack> hashAndFluidStack = StackUtils.readFluidStackAndHash(buf);
+
+        gridStack = new GridStackFluid(hashAndFluidStack.getLeft(), hashAndFluidStack.getRight(), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), false);
         delta = buf.readInt();
     }
 
     @Override
     public void toBytes(ByteBuf buf) {
-        StackUtils.writeFluidStack(buf, stack);
+        StackUtils.writeFluidStackAndHash(buf, stack);
 
         IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
         buf.writeBoolean(entry != null);

src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridFluidUpdate.java

@@ -15,6 +15,7 @@ import net.minecraftforge.fml.common.network.ByteBufUtils;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -39,7 +40,9 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
         int items = buf.readInt();
 
         for (int i = 0; i < items; ++i) {
-            this.stacks.add(new GridStackFluid(buf.readInt(), StackUtils.readFluidStack(buf), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), buf.readBoolean()));
+            Pair<Integer, FluidStack> hashAndFluidStack = StackUtils.readFluidStackAndHash(buf);
+
+            this.stacks.add(new GridStackFluid(hashAndFluidStack.getLeft(), hashAndFluidStack.getRight(), buf.readBoolean() ? new StorageTrackerEntry(buf) : null, buf.readBoolean(), buf.readBoolean()));
         }
     }
 
@@ -56,7 +59,7 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
         buf.writeInt(size);
 
         for (FluidStack stack : network.getFluidStorageCache().getList().getStacks()) {
-            StackUtils.writeFluidStack(buf, stack);
+            StackUtils.writeFluidStackAndHash(buf, stack);
 
             IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
             buf.writeBoolean(entry != null);
@@ -71,7 +74,7 @@ public class MessageGridFluidUpdate implements IMessage, IMessageHandler<Message
 
         for (ICraftingPattern pattern : network.getCraftingManager().getPatterns()) {
             for (FluidStack stack : pattern.getFluidOutputs()) {
-                StackUtils.writeFluidStack(buf, stack);
+                StackUtils.writeFluidStackAndHash(buf, stack);
 
                 IStorageTracker.IStorageTrackerEntry entry = network.getFluidStorageTracker().get(stack);
                 buf.writeBoolean(entry != null);

src/main/java/com/raoulvdberge/refinedstorage/network/MessageGridProcessingTransfer.java

@@ -4,17 +4,14 @@ import com.raoulvdberge.refinedstorage.api.network.grid.GridType;
 import com.raoulvdberge.refinedstorage.api.network.grid.IGrid;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeGrid;
 import com.raoulvdberge.refinedstorage.container.ContainerGrid;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
 import com.raoulvdberge.refinedstorage.util.StackUtils;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
-import net.minecraftforge.fluids.capability.IFluidHandlerItem;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 
 import java.util.ArrayList;
@@ -60,8 +57,6 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
         this.fluidInputs = new ArrayList<>(size);
 
         for (int i = 0; i < size; i++) {
-            buf.readInt();
-
             this.fluidInputs.add(StackUtils.readFluidStack(buf));
         }
 
@@ -70,8 +65,6 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
         this.fluidOutputs = new ArrayList<>(size);
 
         for (int i = 0; i < size; i++) {
-            buf.readInt();
-
             this.fluidOutputs.add(StackUtils.readFluidStack(buf));
         }
     }
@@ -110,7 +103,7 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
 
             if (grid.getGridType() == GridType.PATTERN) {
                 ItemHandlerBase handler = ((NetworkNodeGrid) grid).getProcessingMatrix();
-                ItemHandlerFluid handlerFluid = ((NetworkNodeGrid) grid).getMatrixProcessingFluids();
+                FluidInventory handlerFluid = ((NetworkNodeGrid) grid).getProcessingMatrixFluids();
 
                 clearInputsAndOutputs(handler);
                 clearInputsAndOutputs(handlerFluid);
@@ -130,6 +123,12 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
         }
     }
 
+    private void clearInputsAndOutputs(FluidInventory handler) {
+        for (int i = 0; i < 9 * 2; ++i) {
+            handler.setFluid(i, null);
+        }
+    }
+
     private void setInputs(ItemHandlerBase handler, Collection<ItemStack> stacks) {
         setSlots(handler, stacks, 0, 9);
     }
@@ -150,30 +149,21 @@ public class MessageGridProcessingTransfer extends MessageHandlerPlayerToServer<
         }
     }
 
-    private void setFluidInputs(ItemHandlerBase handler, Collection<FluidStack> stacks) {
+    private void setFluidInputs(FluidInventory inventory, Collection<FluidStack> stacks) {
-        setFluidSlots(handler, stacks, 0, 9);
+        setFluidSlots(inventory, stacks, 0, 9);
     }
 
-    private void setFluidOutputs(ItemHandlerBase handler, Collection<FluidStack> stacks) {
+    private void setFluidOutputs(FluidInventory inventory, Collection<FluidStack> stacks) {
-        setFluidSlots(handler, stacks, 9, 18);
+        setFluidSlots(inventory, stacks, 9, 18);
     }
 
-    private void setFluidSlots(ItemHandlerBase handler, Collection<FluidStack> stacks, int begin, int end) {
+    private void setFluidSlots(FluidInventory inventory, Collection<FluidStack> stacks, int begin, int end) {
         for (FluidStack stack : stacks) {
-            if (!StackUtils.hasFluidBucket(stack) || stack.amount > Fluid.BUCKET_VOLUME) {
+            if (stack.amount > Fluid.BUCKET_VOLUME) {
                 continue;
             }
 
-            ItemStack filledContainer = new ItemStack(Items.BUCKET);
+            inventory.setFluid(begin, stack.copy());
-
-            IFluidHandlerItem fluidHandler = filledContainer.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
-
-            fluidHandler.fill(StackUtils.copy(stack, Fluid.BUCKET_VOLUME), true);
-
-            filledContainer = fluidHandler.getContainer();
-            filledContainer.setCount(stack.amount);
-
-            handler.setStackInSlot(begin, filledContainer);
 
             begin++;
 

src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterFluidSetAmount.java

@@ -0,0 +1,58 @@
+package com.raoulvdberge.refinedstorage.network;
+
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+
+public class MessageSlotFilterFluidSetAmount extends MessageHandlerPlayerToServer<MessageSlotFilterFluidSetAmount> implements IMessage {
+    private int containerSlot;
+    private int amount;
+
+    public MessageSlotFilterFluidSetAmount(int containerSlot, int amount) {
+        this.containerSlot = containerSlot;
+        this.amount = amount;
+    }
+
+    public MessageSlotFilterFluidSetAmount() {
+        // NO OP
+    }
+
+    @Override
+    protected void handle(MessageSlotFilterFluidSetAmount message, EntityPlayerMP player) {
+        Container container = player.openContainer;
+
+        if (container != null) {
+            if (message.containerSlot >= 0 && message.containerSlot < container.inventorySlots.size()) {
+                Slot slot = container.getSlot(message.containerSlot);
+
+                if (slot instanceof SlotFilterFluid) {
+                    FluidInventory inventory = ((SlotFilterFluid) slot).getFluidInventory();
+
+                    FluidStack stack = inventory.getFluid(slot.getSlotIndex());
+
+                    if (stack != null && message.amount > 0 && message.amount <= inventory.getMaxAmount()) {
+                        inventory.setFluid(slot.getSlotIndex(), StackUtils.copy(stack, message.amount));
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        containerSlot = buf.readInt();
+        amount = buf.readInt();
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(containerSlot);
+        buf.writeInt(amount);
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterFluidUpdate.java

@@ -0,0 +1,62 @@
+package com.raoulvdberge.refinedstorage.network;
+
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
+import com.raoulvdberge.refinedstorage.gui.GuiBase;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.inventory.Slot;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+
+public class MessageSlotFilterFluidUpdate implements IMessage, IMessageHandler<MessageSlotFilterFluidUpdate, IMessage> {
+    private int containerSlot;
+    private FluidStack stack;
+
+    public MessageSlotFilterFluidUpdate(int containerSlot, FluidStack stack) {
+        this.containerSlot = containerSlot;
+        this.stack = stack;
+    }
+
+    public MessageSlotFilterFluidUpdate() {
+        // NO OP
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        containerSlot = buf.readInt();
+
+        if (buf.readBoolean()) {
+            stack = StackUtils.readFluidStack(buf);
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(containerSlot);
+
+        if (stack == null) {
+            buf.writeBoolean(false);
+        } else {
+            buf.writeBoolean(true);
+
+            StackUtils.writeFluidStack(buf, stack);
+        }
+    }
+
+    @Override
+    public IMessage onMessage(MessageSlotFilterFluidUpdate message, MessageContext ctx) {
+        GuiBase.executeLater(gui -> {
+            if (message.containerSlot >= 0 && message.containerSlot < gui.inventorySlots.inventorySlots.size()) {
+                Slot slot = gui.inventorySlots.getSlot(message.containerSlot);
+
+                if (slot instanceof SlotFilterFluid) {
+                    ((SlotFilterFluid) slot).getFluidInventory().setFluid(slot.getSlotIndex(), message.stack);
+                }
+            }
+        });
+
+        return null;
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterSet.java

@@ -1,7 +1,7 @@
 package com.raoulvdberge.refinedstorage.network;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilter;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilter;
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterLegacy;
+import com.raoulvdberge.refinedstorage.container.slot.legacy.SlotLegacyFilter;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.inventory.Container;
@@ -10,28 +10,28 @@ import net.minecraft.item.ItemStack;
 import net.minecraftforge.fml.common.network.ByteBufUtils;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 
-public class MessageFilterSlot extends MessageHandlerPlayerToServer<MessageFilterSlot> implements IMessage {
+public class MessageSlotFilterSet extends MessageHandlerPlayerToServer<MessageSlotFilterSet> implements IMessage {
     private int containerSlot;
     private ItemStack stack;
 
-    public MessageFilterSlot(int containerSlot, ItemStack stack) {
+    public MessageSlotFilterSet(int containerSlot, ItemStack stack) {
         this.containerSlot = containerSlot;
         this.stack = stack;
     }
 
-    public MessageFilterSlot() {
+    public MessageSlotFilterSet() {
         // NO OP
     }
 
     @Override
-    protected void handle(MessageFilterSlot message, EntityPlayerMP player) {
+    protected void handle(MessageSlotFilterSet message, EntityPlayerMP player) {
         Container container = player.openContainer;
 
         if (container != null) {
             if (message.containerSlot >= 0 && message.containerSlot < container.inventorySlots.size()) {
                 Slot slot = container.getSlot(message.containerSlot);
 
-                if (slot instanceof SlotFilter || slot instanceof SlotFilterLegacy) {
+                if (slot instanceof SlotFilter || slot instanceof SlotLegacyFilter) {
                     slot.putStack(message.stack);
                 }
             }

src/main/java/com/raoulvdberge/refinedstorage/network/MessageSlotFilterSetFluid.java

@@ -1,35 +1,37 @@
 package com.raoulvdberge.refinedstorage.network;
 
-import com.raoulvdberge.refinedstorage.container.slot.SlotFilterItemOrFluid;
+import com.raoulvdberge.refinedstorage.container.slot.filter.SlotFilterFluid;
+import com.raoulvdberge.refinedstorage.util.StackUtils;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.inventory.Container;
 import net.minecraft.inventory.Slot;
+import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 
-public class MessageFluidAmount extends MessageHandlerPlayerToServer<MessageFluidAmount> implements IMessage {
+public class MessageSlotFilterSetFluid extends MessageHandlerPlayerToServer<MessageSlotFilterSetFluid> implements IMessage {
     private int containerSlot;
-    private int amount;
+    private FluidStack stack;
 
-    public MessageFluidAmount(int containerSlot, int amount) {
+    public MessageSlotFilterSetFluid(int containerSlot, FluidStack stack) {
         this.containerSlot = containerSlot;
-        this.amount = amount;
+        this.stack = stack;
     }
 
-    public MessageFluidAmount() {
+    public MessageSlotFilterSetFluid() {
         // NO OP
     }
 
     @Override
-    protected void handle(MessageFluidAmount message, EntityPlayerMP player) {
+    protected void handle(MessageSlotFilterSetFluid message, EntityPlayerMP player) {
         Container container = player.openContainer;
 
         if (container != null) {
             if (message.containerSlot >= 0 && message.containerSlot < container.inventorySlots.size()) {
                 Slot slot = container.getSlot(message.containerSlot);
 
-                if (slot instanceof SlotFilterItemOrFluid && ((SlotFilterItemOrFluid) slot).getFluidAmountChangeListener() != null) {
+                if (slot instanceof SlotFilterFluid) {
-                    ((SlotFilterItemOrFluid) slot).getFluidAmountChangeListener().onChangeRequested(slot.getSlotIndex(), message.amount);
+                    ((SlotFilterFluid) slot).getFluidInventory().setFluid(slot.getSlotIndex(), message.stack);
                 }
             }
         }
@@ -38,12 +40,12 @@ public class MessageFluidAmount extends MessageHandlerPlayerToServer<MessageFlui
     @Override
     public void fromBytes(ByteBuf buf) {
         containerSlot = buf.readInt();
-        amount = buf.readInt();
+        stack = StackUtils.readFluidStack(buf);
     }
 
     @Override
     public void toBytes(ByteBuf buf) {
         buf.writeInt(containerSlot);
-        buf.writeInt(amount);
+        StackUtils.writeFluidStack(buf, stack);
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java

@@ -95,12 +95,7 @@ public class ProxyCommon {
         API.instance().getCraftingTaskRegistry().add(CraftingTaskFactory.ID, new CraftingTaskFactory());
 
         API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementItemRender.ID, buf -> new CraftingMonitorElementItemRender(StackUtils.readItemStack(buf), buf.readInt(), buf.readInt()));
-        API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementFluidRender.ID, buf -> {
+        API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementFluidRender.ID, buf -> new CraftingMonitorElementFluidRender(StackUtils.readFluidStack(buf), buf.readInt(), buf.readInt()));
-            // Consume hash
-            buf.readInt();
-
-            return new CraftingMonitorElementFluidRender(StackUtils.readFluidStack(buf), buf.readInt(), buf.readInt());
-        });
         API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementText.ID, buf -> new CraftingMonitorElementText(ByteBufUtils.readUTF8String(buf), buf.readInt()));
         API.instance().getCraftingMonitorElementRegistry().add(CraftingMonitorElementColor.ID, buf -> {
             int color = buf.readInt();
@@ -188,8 +183,10 @@ public class ProxyCommon {
         RS.INSTANCE.network.registerMessage(MessageStorageDiskSizeRequest.class, MessageStorageDiskSizeRequest.class, id++, Side.SERVER);
         RS.INSTANCE.network.registerMessage(MessageStorageDiskSizeResponse.class, MessageStorageDiskSizeResponse.class, id++, Side.CLIENT);
         RS.INSTANCE.network.registerMessage(MessageConfigSync.class, MessageConfigSync.class, id++, Side.CLIENT);
-        RS.INSTANCE.network.registerMessage(MessageFluidAmount.class, MessageFluidAmount.class, id++, Side.SERVER);
+        RS.INSTANCE.network.registerMessage(MessageSlotFilterFluidSetAmount.class, MessageSlotFilterFluidSetAmount.class, id++, Side.SERVER);
-        RS.INSTANCE.network.registerMessage(MessageFilterSlot.class, MessageFilterSlot.class, id++, Side.SERVER);
+        RS.INSTANCE.network.registerMessage(MessageSlotFilterSet.class, MessageSlotFilterSet.class, id++, Side.SERVER);
+        RS.INSTANCE.network.registerMessage(MessageSlotFilterSetFluid.class, MessageSlotFilterSetFluid.class, id++, Side.SERVER);
+        RS.INSTANCE.network.registerMessage(MessageSlotFilterFluidUpdate.class, MessageSlotFilterFluidUpdate.class, id++, Side.CLIENT);
 
         NetworkRegistry.INSTANCE.registerGuiHandler(RS.INSTANCE, new GuiHandler());
 

src/main/java/com/raoulvdberge/refinedstorage/render/meshdefinition/ItemMeshDefinitionPortableGrid.java

@@ -4,7 +4,7 @@ import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskProvider;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDiskSyncData;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
 import com.raoulvdberge.refinedstorage.item.itemblock.ItemBlockPortableGrid;
 import com.raoulvdberge.refinedstorage.tile.grid.portable.IPortableGrid;
 import com.raoulvdberge.refinedstorage.tile.grid.portable.TilePortableGrid;
@@ -17,7 +17,6 @@ import net.minecraftforge.energy.CapabilityEnergy;
 import java.util.UUID;
 
 public class ItemMeshDefinitionPortableGrid implements ItemMeshDefinition {
-    // TODO: Optimize
     @Override
     public ModelResourceLocation getModelLocation(ItemStack stack) {
         ItemHandlerBase disk = new ItemHandlerBase(1);

src/main/java/com/raoulvdberge/refinedstorage/render/tesr/TileEntitySpecialRendererStorageMonitor.java

@@ -2,7 +2,6 @@ package com.raoulvdberge.refinedstorage.render.tesr;
 
 import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.tile.TileStorageMonitor;
-import com.raoulvdberge.refinedstorage.tile.config.IType;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.block.model.IBakedModel;
@@ -27,7 +26,7 @@ public class TileEntitySpecialRendererStorageMonitor extends TileEntitySpecialRe
         float rotY = 0;
         float rotZ = 0;
 
-        String amount = tile.getType() == IType.ITEMS ? API.instance().getQuantityFormatter().formatWithUnits(tile.getAmount()) : API.instance().getQuantityFormatter().formatWithUnits((int) ((float) tile.getAmount() / 1000F));
+        String amount = API.instance().getQuantityFormatter().formatWithUnits(tile.getAmount());
 
         // Very bad, but I don't know how to translate a 2D font width to a 3D font width...
         float textWidth = 0;

src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorageMonitor.java

@@ -2,7 +2,6 @@ package com.raoulvdberge.refinedstorage.tile;
 
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorageMonitor;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
-import com.raoulvdberge.refinedstorage.tile.config.IType;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -14,20 +13,16 @@ import javax.annotation.Nullable;
 
 public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
     public static final TileDataParameter<Integer, TileStorageMonitor> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer, TileStorageMonitor> TYPE = IType.createParameter();
 
-    private static final String NBT_TYPE = "Type";
     private static final String NBT_STACK = "Stack";
     private static final String NBT_AMOUNT = "Amount";
 
-    private int type;
     private int amount;
     @Nullable
     private ItemStack itemStack;
 
     public TileStorageMonitor() {
         dataManager.addWatchedParameter(COMPARE);
-        dataManager.addWatchedParameter(TYPE);
     }
 
     @Override
@@ -44,9 +39,7 @@ public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
     public NBTTagCompound writeUpdate(NBTTagCompound tag) {
         super.writeUpdate(tag);
 
-        tag.setInteger(NBT_TYPE, getNode().getType());
+        ItemStack stack = getNode().getItemFilters().getStackInSlot(0);
-
-        ItemStack stack = getNode().getType() == IType.ITEMS ? getNode().getItemFilter().getStackInSlot(0) : getNode().getFluidFilter().getStackInSlot(0);
 
         if (!stack.isEmpty()) {
             tag.setTag(NBT_STACK, stack.writeToNBT(new NBTTagCompound()));
@@ -61,7 +54,6 @@ public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
     public void readUpdate(NBTTagCompound tag) {
         super.readUpdate(tag);
 
-        type = tag.getInteger(NBT_TYPE);
         itemStack = tag.hasKey(NBT_STACK) ? new ItemStack(tag.getCompoundTag(NBT_STACK)) : null;
         amount = tag.getInteger(NBT_AMOUNT);
     }
@@ -74,10 +66,6 @@ public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
         return receivedDirection != getDirection() || receivedActive != getNode().isActive();
     }
 
-    public int getType() {
-        return type;
-    }
-
     public int getAmount() {
         return amount;
     }

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java

@@ -2,7 +2,7 @@ package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.datasync.DataSerializers;
@@ -50,10 +50,10 @@ public interface IFilterable {
         return false;
     }
 
-    static boolean acceptsFluid(ItemHandlerFluid filters, int mode, int compare, FluidStack stack) {
+    static boolean acceptsFluid(FluidInventory filters, int mode, int compare, FluidStack stack) {
         if (mode == WHITELIST) {
             for (int i = 0; i < filters.getSlots(); ++i) {
-                FluidStack slot = filters.getFluidStackInSlot(i);
+                FluidStack slot = filters.getFluid(i);
 
                 if (slot != null && API.instance().getComparer().isEqual(slot, stack, compare)) {
                     return true;
@@ -63,7 +63,7 @@ public interface IFilterable {
             return false;
         } else if (mode == BLACKLIST) {
             for (int i = 0; i < filters.getSlots(); ++i) {
-                FluidStack slot = filters.getFluidStackInSlot(i);
+                FluidStack slot = filters.getFluid(i);
 
                 if (slot != null && API.instance().getComparer().isEqual(slot, stack, compare)) {
                     return false;

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java

@@ -1,7 +1,7 @@
 package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
-import com.raoulvdberge.refinedstorage.container.ContainerBase;
+import com.raoulvdberge.refinedstorage.inventory.fluid.FluidInventory;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameterClientListener;
 import net.minecraft.network.datasync.DataSerializers;
@@ -18,10 +18,6 @@ public interface IType {
         return new TileDataParameter<>(DataSerializers.VARINT, ITEMS, t -> ((IType) t.getNode()).getType(), (t, v) -> {
             if (v == IType.ITEMS || v == IType.FLUIDS) {
                 ((IType) t.getNode()).setType(v);
-
-                t.getWorld().playerEntities.stream()
-                    .filter(p -> p.openContainer instanceof ContainerBase && ((ContainerBase) p.openContainer).getTile().getPos().equals(t.getPos()))
-                    .forEach(p -> p.openContainer.detectAndSendChanges());
             }
         }, clientListener);
     }
@@ -34,7 +30,7 @@ public interface IType {
 
     void setType(int type);
 
-    IItemHandler getFilterInventory();
+    IItemHandler getItemFilters();
 
-    boolean isServer();
+    FluidInventory getFluidFilters();
 }

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/WirelessGrid.java

@@ -14,7 +14,7 @@ import com.raoulvdberge.refinedstorage.api.util.IFilter;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageCacheListenerGridItem;
 import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilter;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
 import com.raoulvdberge.refinedstorage.item.ItemWirelessGrid;
 import com.raoulvdberge.refinedstorage.network.MessageGridSettingsUpdate;
 import com.raoulvdberge.refinedstorage.util.StackUtils;

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/IPortableGrid.java

@@ -3,7 +3,7 @@ package com.raoulvdberge.refinedstorage.tile.grid.portable;
 import com.raoulvdberge.refinedstorage.api.storage.IStorageCache;
 import com.raoulvdberge.refinedstorage.api.storage.disk.IStorageDisk;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.IItemHandlerModifiable;
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/PortableGrid.java

@@ -21,8 +21,8 @@ import com.raoulvdberge.refinedstorage.apiimpl.storage.StorageTrackerItem;
 import com.raoulvdberge.refinedstorage.apiimpl.storage.disk.StorageDiskItemPortable;
 import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilter;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
 import com.raoulvdberge.refinedstorage.item.ItemWirelessGrid;
 import com.raoulvdberge.refinedstorage.item.itemblock.ItemBlockPortableGrid;
 import com.raoulvdberge.refinedstorage.network.MessageGridSettingsUpdate;

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/TilePortableGrid.java

@@ -28,9 +28,9 @@ import com.raoulvdberge.refinedstorage.block.enums.PortableGridDiskState;
 import com.raoulvdberge.refinedstorage.block.enums.PortableGridType;
 import com.raoulvdberge.refinedstorage.gui.GuiBase;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBase;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerBase;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFilter;
+import com.raoulvdberge.refinedstorage.inventory.item.ItemHandlerFilter;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerTile;
+import com.raoulvdberge.refinedstorage.inventory.listener.ListenerTile;
 import com.raoulvdberge.refinedstorage.item.ItemWirelessGrid;
 import com.raoulvdberge.refinedstorage.item.itemblock.ItemBlockPortableGrid;
 import com.raoulvdberge.refinedstorage.render.constants.ConstantsDisk;
@@ -123,8 +123,8 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
 
     private List<IFilter> filters = new ArrayList<>();
     private List<IGridTab> tabs = new ArrayList<>();
-    private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ItemHandlerListenerTile(this));
+    private ItemHandlerFilter filter = new ItemHandlerFilter(filters, tabs, new ListenerTile(this));
-    private ItemHandlerBase disk = new ItemHandlerBase(1, new ItemHandlerListenerTile(this), s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && ((IStorageDiskProvider) s.getItem()).getType() == StorageType.ITEM) {
+    private ItemHandlerBase disk = new ItemHandlerBase(1, new ListenerTile(this), s -> NetworkNodeDiskDrive.VALIDATOR_STORAGE_DISK.test(s) && ((IStorageDiskProvider) s.getItem()).getType() == StorageType.ITEM) {
         @Override
         protected void onContentsChanged(int slot) {
             super.onContentsChanged(slot);

src/main/java/com/raoulvdberge/refinedstorage/util/StackUtils.java

@@ -21,6 +21,7 @@ import net.minecraftforge.fluids.capability.IFluidHandlerItem;
 import net.minecraftforge.fml.common.network.ByteBufUtils;
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
+import net.minecraftforge.items.ItemHandlerHelper;
 import org.apache.commons.lang3.tuple.Pair;
 
 import javax.annotation.Nonnull;
@@ -60,8 +61,13 @@ public final class StackUtils {
         }
     }
 
-    public static void writeFluidStack(ByteBuf buf, FluidStack stack) {
+    public static void writeFluidStackAndHash(ByteBuf buf, FluidStack stack) {
         buf.writeInt(API.instance().getFluidStackHashCode(stack));
+
+        writeFluidStack(buf, stack);
+    }
+
+    public static void writeFluidStack(ByteBuf buf, FluidStack stack) {
         ByteBufUtils.writeUTF8String(buf, FluidRegistry.getFluidName(stack.getFluid()));
         buf.writeInt(stack.amount);
         ByteBufUtils.writeTag(buf, stack.tag);
@@ -71,6 +77,10 @@ public final class StackUtils {
         return new FluidStack(FluidRegistry.getFluid(ByteBufUtils.readUTF8String(buf)), buf.readInt(), ByteBufUtils.readTag(buf));
     }
 
+    public static Pair<Integer, FluidStack> readFluidStackAndHash(ByteBuf buf) {
+        return Pair.of(buf.readInt(), readFluidStack(buf));
+    }
+
     public static ItemStack nullToEmpty(@Nullable ItemStack stack) {
         return stack == null ? ItemStack.EMPTY : stack;
     }
@@ -197,6 +207,11 @@ public final class StackUtils {
     }
 
     public static Pair<ItemStack, FluidStack> getFluid(ItemStack stack, boolean simulate) {
+        // We won't have the capability on stacks with size bigger than 1.
+        if (stack.getCount() > 1) {
+            stack = ItemHandlerHelper.copyStackWithSize(stack, 1);
+        }
+
         if (stack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) {
             IFluidHandlerItem fluidHandler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);