add more slots to the processing pattern grid and combine fluids and items(#2535)

* WIP more slots in the patterngrid

* implement more slots for processing pattern

* simplified some calculations, some comments

* bugfixes

* fix accidental formatting changes

* port to 1.16 and some cleanup

* more cleanup

* make code readable

* Combine fluid and item view in pattern grid

* changelog

CHANGELOG.md

@@ -1,6 +1,8 @@
 # Refined Storage Changelog
 
 ### 1.9.17
+- Added more slots to the Pattern Grid (Darkere)
+- Combined Fluid and Item View in the Pattern Grid (Darkere)
 
 ### 1.9.16
 

src/main/java/com/refinedmods/refinedstorage/apiimpl/autocrafting/AllowedTagList.java

@@ -22,8 +22,8 @@ public class AllowedTagList {
     @Nullable
     private final Runnable listener;
 
-    public AllowedTagList(@Nullable Runnable listener) {
+    public AllowedTagList(@Nullable Runnable listener, int size) {
-        for (int i = 0; i < 9; ++i) {
+        for (int i = 0; i < size; ++i) {
             allowedItemTags.add(new HashSet<>());
             allowedFluidTags.add(new HashSet<>());
         }

src/main/java/com/refinedmods/refinedstorage/apiimpl/autocrafting/CraftingPatternFactory.java

@@ -2,6 +2,7 @@ package com.refinedmods.refinedstorage.apiimpl.autocrafting;
 
 import com.refinedmods.refinedstorage.api.autocrafting.ICraftingPattern;
 import com.refinedmods.refinedstorage.api.autocrafting.ICraftingPatternContainer;
+import com.refinedmods.refinedstorage.apiimpl.network.node.GridNetworkNode;
 import com.refinedmods.refinedstorage.item.PatternItem;
 import net.minecraft.fluid.Fluid;
 import net.minecraft.inventory.CraftingInventory;
@@ -39,7 +40,7 @@ public class CraftingPatternFactory {
 
         try {
             if (processing) {
-                for (int i = 0; i < 9; ++i) {
+                for (int i = 0; i < GridNetworkNode.PROCESSING_MATRIX_SIZE; ++i) {
                     fillProcessingInputs(i, stack, inputs, outputs, allowedTagList);
                     fillProcessingFluidInputs(i, stack, fluidInputs, fluidOutputs, allowedTagList);
                 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/GridNetworkNode.java

@@ -79,7 +79,9 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
     private static final String NBT_PROCESSING_MATRIX_FLUIDS = "ProcessingMatrixFluids";
     private static final String NBT_ALLOWED_TAGS = "AllowedTags";
 
-    private final AllowedTagList allowedTagList = new AllowedTagList(this::updateAllowedTags);
+    public static final int PROCESSING_MATRIX_SIZE = 81;
+
+    private final AllowedTagList allowedTagList = new AllowedTagList(this::updateAllowedTags, PROCESSING_MATRIX_SIZE);
 
     private final Container craftingContainer = new Container(ContainerType.CRAFTING, 0) {
         @Override
@@ -97,17 +99,17 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
     private ICraftingRecipe currentRecipe;
     private final CraftingInventory matrix = new CraftingInventory(craftingContainer, 3, 3);
     private final CraftResultInventory result = new CraftResultInventory();
-    private final BaseItemHandler processingMatrix = new BaseItemHandler(9 * 2)
+    private final BaseItemHandler processingMatrix = new BaseItemHandler(PROCESSING_MATRIX_SIZE * 2)
         .addListener(new NetworkNodeInventoryListener(this))
         .addListener((handler, slot, reading) -> {
-            if (!reading && slot < 9) {
+            if (!reading && slot < PROCESSING_MATRIX_SIZE) {
                 allowedTagList.clearItemTags(slot);
             }
         });
-    private final FluidInventory processingMatrixFluids = new FluidInventory(9 * 2, FluidAttributes.BUCKET_VOLUME * 64)
+    private final FluidInventory processingMatrixFluids = new FluidInventory(PROCESSING_MATRIX_SIZE * 2, FluidAttributes.BUCKET_VOLUME * 64)
         .addListener(new NetworkNodeFluidInventoryListener(this))
         .addListener((handler, slot, reading) -> {
-            if (!reading && slot < 9) {
+            if (!reading && slot < PROCESSING_MATRIX_SIZE) {
                 allowedTagList.clearFluidTags(slot);
             }
         });
@@ -146,14 +148,11 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
                 boolean processing = PatternItem.isProcessing(pattern);
 
                 if (processing) {
-                    for (int i = 0; i < 9; ++i) {
+                    for (int i = 0; i < PROCESSING_MATRIX_SIZE; ++i) {
                         processingMatrix.setStackInSlot(i, PatternItem.getInputSlot(pattern, i));
                         processingMatrixFluids.setFluid(i, PatternItem.getFluidInputSlot(pattern, i));
-                    }
+                        processingMatrix.setStackInSlot(PROCESSING_MATRIX_SIZE + i, PatternItem.getOutputSlot(pattern, i));
-
+                        processingMatrixFluids.setFluid(PROCESSING_MATRIX_SIZE + i, PatternItem.getFluidOutputSlot(pattern, i));
-                    for (int i = 0; i < 9; ++i) {
-                        processingMatrix.setStackInSlot(9 + i, PatternItem.getOutputSlot(pattern, i));
-                        processingMatrixFluids.setFluid(9 + i, PatternItem.getFluidOutputSlot(pattern, i));
                     }
 
                     AllowedTagList allowedTagsFromPattern = PatternItem.getAllowedTags(pattern);
@@ -498,10 +497,10 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
             }
 
             if (processingPattern) {
-                for (int i = 0; i < 18; ++i) {
+                for (int i = 0; i < processingMatrix.getSlots(); ++i) {
                     if (!processingMatrix.getStackInSlot(i).isEmpty()) {
-                        if (i >= 9) {
+                        if (i >= PROCESSING_MATRIX_SIZE) {
-                            PatternItem.setOutputSlot(pattern, i - 9, processingMatrix.getStackInSlot(i));
+                            PatternItem.setOutputSlot(pattern, i - PROCESSING_MATRIX_SIZE, processingMatrix.getStackInSlot(i));
                         } else {
                             PatternItem.setInputSlot(pattern, i, processingMatrix.getStackInSlot(i));
                         }
@@ -509,8 +508,8 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
 
                     FluidStack fluid = processingMatrixFluids.getFluid(i);
                     if (!fluid.isEmpty()) {
-                        if (i >= 9) {
+                        if (i >= PROCESSING_MATRIX_SIZE) {
-                            PatternItem.setFluidOutputSlot(pattern, i - 9, fluid);
+                            PatternItem.setFluidOutputSlot(pattern, i - PROCESSING_MATRIX_SIZE, fluid);
                         } else {
                             PatternItem.setFluidInputSlot(pattern, i, fluid);
                         }
@@ -543,7 +542,7 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
             int inputsFilled = 0;
             int outputsFilled = 0;
 
-            for (int i = 0; i < 9; ++i) {
+            for (int i = 0; i < PROCESSING_MATRIX_SIZE; ++i) {
                 if (!processingMatrix.getStackInSlot(i).isEmpty()) {
                     inputsFilled++;
                 }
@@ -553,7 +552,7 @@ public class GridNetworkNode extends NetworkNode implements INetworkAwareGrid, I
                 }
             }
 
-            for (int i = 9; i < 18; ++i) {
+            for (int i = PROCESSING_MATRIX_SIZE; i < processingMatrix.getSlots(); ++i) {
                 if (!processingMatrix.getStackInSlot(i).isEmpty()) {
                     outputsFilled++;
                 }

src/main/java/com/refinedmods/refinedstorage/container/GridContainer.java

@@ -29,6 +29,8 @@ import net.minecraft.network.play.server.SSetSlotPacket;
 import net.minecraftforge.items.SlotItemHandler;
 
 import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
 
 public class GridContainer extends BaseContainer implements ICraftingGridListener {
     private final IGrid grid;
@@ -38,6 +40,9 @@ public class GridContainer extends BaseContainer implements ICraftingGridListene
 
     private ResultCraftingGridSlot craftingResultSlot;
     private LegacyBaseSlot patternResultSlot;
+    private List<Slot> itemPatternSlots = new ArrayList<>();
+    private List<Slot> fluidPatternSlots = new ArrayList<>();
+    private int patternScrollOffset;
 
     public GridContainer(IGrid grid, @Nullable BaseTile gridTile, PlayerEntity player, int windowId) {
         super(RSContainers.GRID, gridTile, player, windowId);
@@ -162,6 +167,8 @@ public class GridContainer extends BaseContainer implements ICraftingGridListene
     }
 
     private void addPatternSlots() {
+        itemPatternSlots.clear();
+        fluidPatternSlots.clear();
         int headerAndSlots = screenInfoProvider.getTopHeight() + (screenInfoProvider.getVisibleRows() * 18);
 
         addSlot(new SlotItemHandler(((GridNetworkNode) grid).getPatterns(), 0, 172, headerAndSlots + 4));
@@ -174,25 +181,28 @@ public class GridContainer extends BaseContainer implements ICraftingGridListene
         int x = ox;
         int y = headerAndSlots + 4;
 
-        for (int i = 0; i < 9 * 2; ++i) {
+        for (int i = 0; i < GridNetworkNode.PROCESSING_MATRIX_SIZE * 2; ++i) {
             int itemFilterSlotConfig = FilterSlot.FILTER_ALLOW_SIZE;
-            if (i < 9) {
+            if (i < GridNetworkNode.PROCESSING_MATRIX_SIZE) {
                 itemFilterSlotConfig |= FilterSlot.FILTER_ALLOW_ALTERNATIVES;
             }
 
             int fluidFilterSlotConfig = FluidFilterSlot.FILTER_ALLOW_SIZE;
-            if (i < 9) {
+            if (i < GridNetworkNode.PROCESSING_MATRIX_SIZE) {
                 fluidFilterSlotConfig |= FluidFilterSlot.FILTER_ALLOW_ALTERNATIVES;
             }
 
-            addSlot(new FilterSlot(((GridNetworkNode) grid).getProcessingMatrix(), i, x, y, itemFilterSlotConfig).setEnableHandler(() -> ((GridNetworkNode) grid).isProcessingPattern() && ((GridNetworkNode) grid).getType() == IType.ITEMS));
+            int finalI = i;
-            addSlot(new FluidFilterSlot(((GridNetworkNode) grid).getProcessingMatrixFluids(), i, x, y, fluidFilterSlotConfig).setEnableHandler(() -> ((GridNetworkNode) grid).isProcessingPattern() && ((GridNetworkNode) grid).getType() == IType.FLUIDS));
+            itemPatternSlots.add(addSlot(new FilterSlot(((GridNetworkNode) grid).getProcessingMatrix(), i, x, y, itemFilterSlotConfig)
+                .setEnableHandler(() -> getSlotEnabled(finalI, true))));
+            fluidPatternSlots.add(addSlot(new FluidFilterSlot(((GridNetworkNode) grid).getProcessingMatrixFluids(), i, x, y, fluidFilterSlotConfig)
+                .setEnableHandler(() -> getSlotEnabled(finalI, false))));
 
             x += 18;
 
             if ((i + 1) % 3 == 0) {
-                if (i == 8) {
+                if (i == GridNetworkNode.PROCESSING_MATRIX_SIZE - 1) {
-                    ox = 98;
+                    ox = 93;
                     x = ox;
                     y = headerAndSlots + 4;
                 } else {
@@ -221,6 +231,42 @@ public class GridContainer extends BaseContainer implements ICraftingGridListene
         addSlot(patternResultSlot);
     }
 
+    private boolean getSlotEnabled(int i, boolean item) {
+        if (!((GridNetworkNode) grid).isProcessingPattern() || !isVisible(i)) {
+            return false;
+        }
+
+        if (item) {
+            if (itemPatternSlots.get(i).getHasStack()) {
+                return true;
+            }
+
+            if (((FluidFilterSlot) fluidPatternSlots.get(i)).hasStack()) {
+                return false;
+            }
+
+            return ((GridNetworkNode) grid).getType() == IType.ITEMS;
+        } else {
+            if (((FluidFilterSlot) fluidPatternSlots.get(i)).hasStack()) {
+                return true;
+            }
+
+            if (itemPatternSlots.get(i).getHasStack()) {
+                return false;
+            }
+
+            return ((GridNetworkNode) grid).getType() == IType.FLUIDS;
+        }
+    }
+
+    private boolean isVisible(int slotNumber) {
+        return (slotNumber >= patternScrollOffset * 3
+            && slotNumber < patternScrollOffset * 3 + 9)
+
+            || (slotNumber >= patternScrollOffset * 3 + GridNetworkNode.PROCESSING_MATRIX_SIZE
+            && slotNumber < patternScrollOffset * 3 + GridNetworkNode.PROCESSING_MATRIX_SIZE + 9);
+    }
+
     public IGrid getGrid() {
         return grid;
     }
@@ -293,4 +339,25 @@ public class GridContainer extends BaseContainer implements ICraftingGridListene
     protected int getDisabledSlotNumber() {
         return grid.getSlotId();
     }
+
+    public void updatePatternSlotPositions(int newOffset) {
+        patternScrollOffset = newOffset;
+        int yPosition = screenInfoProvider.getTopHeight() + (screenInfoProvider.getVisibleRows() * 18) + 4;
+        int originalYPosition = yPosition;
+
+        for (int i = 0; i < itemPatternSlots.size(); i++) {
+
+            if (i == GridNetworkNode.PROCESSING_MATRIX_SIZE) { // reset when reaching output slots
+                yPosition = originalYPosition;
+            }
+
+            if (isVisible(i)) {
+                itemPatternSlots.get(i).yPos = yPosition;
+                fluidPatternSlots.get(i).yPos = yPosition;
+                if ((i + 1) % 3 == 0) {
+                    yPosition += 18;
+                }
+            }
+        }
+    }
 }

src/main/java/com/refinedmods/refinedstorage/container/slot/filter/FluidFilterSlot.java

@@ -52,4 +52,9 @@ public class FluidFilterSlot extends BaseSlot {
     public FluidInventory getFluidInventory() {
         return fluidInventory;
     }
+
+    // not overriding getHasStack as we do the tooltips ourselves
+    public boolean hasStack() {
+        return !fluidInventory.getFluid(getSlotIndex()).isEmpty();
+    }
 }

src/main/java/com/refinedmods/refinedstorage/item/PatternItem.java

@@ -8,6 +8,7 @@ import com.refinedmods.refinedstorage.api.autocrafting.ICraftingPatternProvider;
 import com.refinedmods.refinedstorage.apiimpl.autocrafting.AllowedTagList;
 import com.refinedmods.refinedstorage.apiimpl.autocrafting.CraftingPattern;
 import com.refinedmods.refinedstorage.apiimpl.autocrafting.CraftingPatternFactory;
+import com.refinedmods.refinedstorage.apiimpl.network.node.GridNetworkNode;
 import com.refinedmods.refinedstorage.render.Styles;
 import com.refinedmods.refinedstorage.render.tesr.PatternItemStackTileRenderer;
 import com.refinedmods.refinedstorage.util.ItemStackKey;
@@ -273,7 +274,7 @@ public class PatternItem extends Item implements ICraftingPatternProvider {
             return null;
         }
 
-        AllowedTagList allowedTagList = new AllowedTagList(null);
+        AllowedTagList allowedTagList = new AllowedTagList(null, GridNetworkNode.PROCESSING_MATRIX_SIZE);
 
         allowedTagList.readFromNbt(pattern.getTag().getCompound(NBT_ALLOWED_TAGS));
 

src/main/java/com/refinedmods/refinedstorage/network/grid/GridProcessingTransferMessage.java

@@ -108,11 +108,9 @@ public class GridProcessingTransferMessage {
                         clearInputsAndOutputs(handler);
                         clearInputsAndOutputs(handlerFluid);
 
-                        setInputs(handler, message.inputs);
+                        setInputs(handler, message.inputs, handlerFluid, message.fluidInputs);
-                        setOutputs(handler, message.outputs);
+                        setOutputs(handler, message.outputs, handlerFluid, message.fluidOutputs);
 
-                        setFluidInputs(handlerFluid, message.fluidInputs);
-                        setFluidOutputs(handlerFluid, message.fluidOutputs);
 
                         ((GridNetworkNode) grid).setProcessingPattern(true);
                         ((GridNetworkNode) grid).markDirty();
@@ -125,26 +123,26 @@ public class GridProcessingTransferMessage {
     }
 
     private static void clearInputsAndOutputs(BaseItemHandler handler) {
-        for (int i = 0; i < 9 * 2; ++i) {
+        for (int i = 0; i < handler.getSlots(); ++i) {
             handler.setStackInSlot(i, ItemStack.EMPTY);
         }
     }
 
     private static void clearInputsAndOutputs(FluidInventory handler) {
-        for (int i = 0; i < 9 * 2; ++i) {
+        for (int i = 0; i < handler.getSlots(); ++i) {
             handler.setFluid(i, FluidStack.EMPTY);
         }
     }
 
-    private static void setInputs(BaseItemHandler handler, Collection<ItemStack> stacks) {
+    private static void setInputs(BaseItemHandler handler, Collection<ItemStack> stacks, FluidInventory fluidHandler, Collection<FluidStack> fluidStacks) {
-        setSlots(handler, stacks, 0, 9);
+        setSlots(handler, stacks, fluidHandler, fluidStacks, 0, handler.getSlots() / 2);
     }
 
-    private static void setOutputs(BaseItemHandler handler, Collection<ItemStack> stacks) {
+    private static void setOutputs(BaseItemHandler handler, Collection<ItemStack> stacks, FluidInventory fluidHandler, Collection<FluidStack> fluidStacks) {
-        setSlots(handler, stacks, 9, 18);
+        setSlots(handler, stacks, fluidHandler, fluidStacks, handler.getSlots() / 2, handler.getSlots());
     }
 
-    private static void setSlots(BaseItemHandler handler, Collection<ItemStack> stacks, int begin, int end) {
+    private static void setSlots(BaseItemHandler handler, Collection<ItemStack> stacks, FluidInventory fluidHandler, Collection<FluidStack> fluidStacks, int begin, int end) {
         for (ItemStack stack : stacks) {
             handler.setStackInSlot(begin, stack);
 
@@ -154,20 +152,9 @@ public class GridProcessingTransferMessage {
                 break;
             }
         }
-    }
+        for (FluidStack stack : fluidStacks) {
 
-    private static void setFluidInputs(FluidInventory inventory, Collection<FluidStack> stacks) {
+            fluidHandler.setFluid(begin, stack.copy());
-        setFluidSlots(inventory, stacks, 0, 9);
-    }
-
-    private static void setFluidOutputs(FluidInventory inventory, Collection<FluidStack> stacks) {
-        setFluidSlots(inventory, stacks, 9, 18);
-    }
-
-    private static void setFluidSlots(FluidInventory inventory, Collection<FluidStack> stacks, int begin, int end) {
-        for (FluidStack stack : stacks) {
-
-            inventory.setFluid(begin, stack.copy());
 
             begin++;
 

src/main/java/com/refinedmods/refinedstorage/screen/grid/GridScreen.java

@@ -25,6 +25,7 @@ import com.refinedmods.refinedstorage.screen.widget.SearchWidget;
 import com.refinedmods.refinedstorage.screen.widget.TabListWidget;
 import com.refinedmods.refinedstorage.screen.widget.sidebutton.*;
 import com.refinedmods.refinedstorage.tile.NetworkNodeTile;
+import com.refinedmods.refinedstorage.tile.config.IType;
 import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.grid.GridTile;
 import com.refinedmods.refinedstorage.tile.grid.portable.IPortableGrid;
@@ -38,6 +39,7 @@ import net.minecraft.entity.player.PlayerInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.SoundEvents;
 import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.StringTextComponent;
 import net.minecraft.util.text.TranslationTextComponent;
 import org.lwjgl.glfw.GLFW;
 import yalter.mousetweaks.api.MouseTweaksDisableWheelTweak;
@@ -54,8 +56,10 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
     private SearchWidget searchField;
     private CheckboxWidget exactPattern;
     private CheckboxWidget processingPattern;
+    private CheckboxWidget fluidCheckBox;
 
     private ScrollbarWidget scrollbar;
+    private ScrollbarWidget patternScrollbar;
 
     private final IGrid grid;
     private final TabListWidget<GridContainer> tabs;
@@ -63,7 +67,12 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
     private boolean wasConnected;
     private boolean doSort;
 
+    private final int patternScrollOffsetAbsoluteMax = GridNetworkNode.PROCESSING_MATRIX_SIZE / 3 - 3;
+
     private int slotNumber;
+    private int patternScrollOffset;
+    private int patternScrollOffsetMax;
+    private boolean updatePatternOffset;
 
     public GridScreen(GridContainer container, IGrid grid, PlayerInventory inventory, ITextComponent title) {
         super(container, 227, 0, inventory, title);
@@ -83,6 +92,12 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
                 grid.onTabPageChanged(page);
             }
         });
+
+        if (grid instanceof GridNetworkNode && grid.getGridType() == GridType.PATTERN) {
+            GridNetworkNode node = (GridNetworkNode) grid;
+            node.getProcessingMatrix().addListener((handler, slot, reading) -> updatePatternOffset = true);
+            node.getProcessingMatrixFluids().addListener((handler, slot, reading) -> updatePatternOffset = true);
+        }
     }
 
     @Override
@@ -135,12 +150,24 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
         addSideButton(new GridSizeSideButton(this, grid::getSize, grid::onSizeChanged));
 
         if (grid.getGridType() == GridType.PATTERN) {
+            patternScrollbar = new ScrollbarWidget(this, 160, getTopHeight() + getVisibleRows() * 18 + 4, 6, 18 * 3 - 2, true);
+
+            patternScrollbar.setMaxOffset(patternScrollOffsetAbsoluteMax);
+            patternScrollbar.setOffset(patternScrollOffset); // keep offset when changing between fluid and item view
+
+            container.updatePatternSlotPositions(patternScrollOffset);
+            patternScrollbar.addListener((oldOffset, newOffset) -> {
+                patternScrollOffset = newOffset;
+                container.updatePatternSlotPositions(newOffset);
+            });
+
             processingPattern = addCheckBox(x + 7, y + getTopHeight() + (getVisibleRows() * 18) + 60, new TranslationTextComponent("misc.refinedstorage.processing"), GridTile.PROCESSING_PATTERN.getValue(), btn -> {
                 // Rebuild the inventory slots before the slot change packet arrives.
                 GridTile.PROCESSING_PATTERN.setValue(false, processingPattern.isChecked());
                 ((GridNetworkNode) grid).clearMatrix(); // The server does this but let's do it earlier so the client doesn't notice.
                 this.container.initSlots();
 
+                patternScrollOffset = 0; // reset offset when switching between crafting and processing
                 TileDataManager.setParameter(GridTile.PROCESSING_PATTERN, processingPattern.isChecked());
             });
 
@@ -152,9 +179,14 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
                     GridTile.EXACT_PATTERN.getValue(),
                     btn -> TileDataManager.setParameter(GridTile.EXACT_PATTERN, exactPattern.isChecked())
                 );
-            }
+                patternScrollbar.setEnabled(false);
+            } else {
+                patternScrollbar.setEnabled(true);
 
-            addSideButton(new TypeSideButton(this, GridTile.PROCESSING_TYPE));
+                fluidCheckBox = addCheckBox(processingPattern.x + processingPattern.getWidth() + 5, y + getTopHeight() + (getVisibleRows() * 18) + 60, new StringTextComponent("Fluids"), ((GridNetworkNode) grid).getType() == IType.FLUIDS, button -> {
+                    TileDataManager.setParameter(GridTile.PROCESSING_TYPE, GridTile.PROCESSING_TYPE.getValue() == IType.ITEMS ? IType.FLUIDS : IType.ITEMS);
+                });
+            }
         }
 
         updateScrollbar();
@@ -180,6 +212,11 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
             view.sort();
         }
 
+        if (updatePatternOffset) {
+            updatePatternOffsetMax();
+            updatePatternOffset = false;
+        }
+
         if (isKeyDown(RSKeyBindings.CLEAR_GRID_CRAFTING_MATRIX)) {
             RS.NETWORK_HANDLER.sendToServer(new GridClearMessage());
         }
@@ -342,6 +379,10 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
             }
 
             blit(matrixStack, x + 172, y + getTopHeight() + (getVisibleRows() * 18) + 22, 240, ty * 16, 16, 16);
+            if (processingPattern.isChecked()) {
+                updatePatternScrollbar();
+                patternScrollbar.render(matrixStack);
+            }
         }
 
         tabs.drawForeground(matrixStack, x, y - tabs.getHeight(), mouseX, mouseY, true);
@@ -444,7 +485,9 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
         if (scrollbar.mouseClicked(mouseX, mouseY, clickedButton)) {
             return true;
         }
-
+        if (grid.getGridType() == GridType.PATTERN && patternScrollbar.mouseClicked(mouseX, mouseY, clickedButton)) {
+            return true;
+        }
         if (RS.CLIENT_CONFIG.getGrid().getPreventSortingWhileShiftIsDown()) {
             doSort = !isOverSlotArea(mouseX - guiLeft, mouseY - guiTop) && !isOverCraftingOutputArea(mouseX - guiLeft, mouseY - guiTop);
         }
@@ -520,11 +563,17 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
     public void mouseMoved(double mx, double my) {
         scrollbar.mouseMoved(mx, my);
 
+        if (grid.getGridType() == GridType.PATTERN) {
+            patternScrollbar.mouseMoved(mx, my);
+        }
         super.mouseMoved(mx, my);
     }
 
     @Override
     public boolean mouseReleased(double mx, double my, int button) {
+        if (grid.getGridType() == GridType.PATTERN && patternScrollbar.mouseReleased(mx, my, button)) {
+            return true;
+        }
         return scrollbar.mouseReleased(mx, my, button) || super.mouseReleased(mx, my, button);
     }
 
@@ -534,7 +583,6 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
             if (RS.CLIENT_CONFIG.getGrid().getPreventSortingWhileShiftIsDown()) {
                 doSort = !isOverSlotArea(x - guiLeft, y - guiTop) && !isOverCraftingOutputArea(x - guiLeft, y - guiTop);
             }
-
             if (grid.getGridType() != GridType.FLUID) {
                 if (isOverInventory(x - guiLeft, y - guiTop) && hoveredSlot != null && hoveredSlot.getHasStack()) {
                     RS.NETWORK_HANDLER.sendToServer(new GridItemInventoryScrollMessage(hoveredSlot.getSlotIndex(), hasShiftDown(), delta > 0));
@@ -544,15 +592,23 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
             }
 
             return super.mouseScrolled(x, y, delta);
-        } else {
-            return this.scrollbar.mouseScrolled(x, y, delta) || super.mouseScrolled(x, y, delta);
         }
+
+        if (grid.getGridType() == GridType.PATTERN && isOverPatternArea(x - guiLeft, y - guiTop) && patternScrollbar.mouseScrolled(x, y, delta)) {
+            return true;
+        }
+
+        return this.scrollbar.mouseScrolled(x, y, delta) || super.mouseScrolled(x, y, delta);
     }
 
     private boolean isOverInventory(double x, double y) {
         return RenderUtils.inBounds(8, getYPlayerInventory(), 9 * 18 - 2, 4 * 18 + 2, x, y);
     }
 
+    private boolean isOverPatternArea(double x, double y) {
+        return RenderUtils.inBounds(8, getTopHeight() + getVisibleRows() * 18, 152, 54, x, y);
+    }
+
     @Override
     public boolean charTyped(char unknown1, int unknown2) {
         if (searchField.charTyped(unknown1, unknown2)) {
@@ -602,6 +658,51 @@ public class GridScreen extends BaseScreen<GridContainer> implements IScreenInfo
         }
     }
 
+    //check processing matrix and update maximum offset depending on contents
+    private void updatePatternOffsetMax() {
+        int filledInputSlots = 0;
+        int filledOutputSlots = 0;
+        int lastFilledInputSlot = 0;
+        int lastFilledOutputSlot = 0;
+
+        for (int i = 0; i < GridNetworkNode.PROCESSING_MATRIX_SIZE * 2; i++) {
+            if (!isMatrixSlotEmpty(i)) {
+                if (i > GridNetworkNode.PROCESSING_MATRIX_SIZE - 1) {
+                    filledOutputSlots++;
+                    lastFilledOutputSlot = i - GridNetworkNode.PROCESSING_MATRIX_SIZE - 1;
+                } else {
+                    filledInputSlots++;
+                    lastFilledInputSlot = i;
+                }
+            }
+        }
+
+        int maxFilledSlots = Math.max(filledInputSlots, filledOutputSlots);
+        int maxLastFilledSlot = Math.max(lastFilledInputSlot, lastFilledOutputSlot);
+
+        // offset calculation to show next row if 4 of 9 slots are filled.
+        int filledSlotOffset = Math.floorDiv(maxFilledSlots - 1, 3);
+        // offset to show the last item in the matrix
+        int lastSlotOffset = Math.floorDiv(maxLastFilledSlot, 3) - 2;
+
+        patternScrollOffsetMax = Math.max(filledSlotOffset, lastSlotOffset);
+    }
+
+    private boolean isMatrixSlotEmpty(int slotNumber) {
+        return ((GridNetworkNode) grid).getProcessingMatrix().getStackInSlot(slotNumber).isEmpty()
+            && ((GridNetworkNode) grid).getProcessingMatrixFluids().getFluid(slotNumber).isEmpty();
+    }
+
+    public void updatePatternScrollbar() {
+        patternScrollbar.setEnabled(processingPattern.isChecked() && patternScrollOffsetMax > 0);
+        int oldOffset = patternScrollbar.getOffset();
+        patternScrollbar.setMaxOffset(Math.min(patternScrollOffsetMax, patternScrollOffsetAbsoluteMax));
+
+        if (oldOffset != patternScrollbar.getOffset()) {
+            container.updatePatternSlotPositions(patternScrollbar.getOffset());
+        }
+    }
+
     public void updateScrollbar() {
         scrollbar.setEnabled(getRows() > getVisibleRows());
         scrollbar.setMaxOffset(getRows() - getVisibleRows());

src/main/java/com/refinedmods/refinedstorage/screen/widget/ScrollbarWidget.java

@@ -25,6 +25,7 @@ public class ScrollbarWidget implements IGuiEventListener {
     private int maxOffset;
 
     private boolean clicked = false;
+    private boolean small = false;
 
     private final List<ScrollbarWidgetListener> listeners = new LinkedList<>();
 
@@ -38,6 +39,11 @@ public class ScrollbarWidget implements IGuiEventListener {
         this.height = height;
     }
 
+    public ScrollbarWidget(BaseScreen screen, int x, int y, int width, int height, boolean small) {
+        this(screen, x, y, width, height);
+        this.small = small;
+    }
+
     public void addListener(ScrollbarWidgetListener listener) {
         listeners.add(listener);
     }
@@ -62,7 +68,12 @@ public class ScrollbarWidget implements IGuiEventListener {
         RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
 
         screen.bindTexture(RS.ID, "icons.png");
-        screen.blit(matrixStack, screen.getGuiLeft() + x, screen.getGuiTop() + y + (int) Math.min(height - SCROLLER_HEIGHT, (float) offset / (float) maxOffset * (float) (height - SCROLLER_HEIGHT)), isEnabled() ? 232 : 244, 0, 12, 15);
+        if (small) {
+            screen.blit(matrixStack, screen.getGuiLeft() + x, screen.getGuiTop() + y + (int) Math.min(height - SCROLLER_HEIGHT, (float) offset / (float) maxOffset * (float) (height - SCROLLER_HEIGHT)), isEnabled() ? 218 : 225, 0, 7, SCROLLER_HEIGHT);
+        } else {
+            screen.blit(matrixStack, screen.getGuiLeft() + x, screen.getGuiTop() + y + (int) Math.min(height - SCROLLER_HEIGHT, (float) offset / (float) maxOffset * (float) (height - SCROLLER_HEIGHT)), isEnabled() ? 232 : 244, 0, 12, SCROLLER_HEIGHT);
+        }
+
     }
 
     @Override

src/main/java/com/refinedmods/refinedstorage/screen/widget/sidebutton/TypeSideButton.java

@@ -2,8 +2,6 @@ package com.refinedmods.refinedstorage.screen.widget.sidebutton;
 
 import com.mojang.blaze3d.matrix.MatrixStack;
 import com.refinedmods.refinedstorage.screen.BaseScreen;
-import com.refinedmods.refinedstorage.tile.config.IType;
-import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.util.text.TextFormatting;
@@ -29,6 +27,6 @@ public class TypeSideButton extends SideButton {
 
     @Override
     public void onPress() {
-        TileDataManager.setParameter(type, type.getValue() == IType.ITEMS ? IType.FLUIDS : IType.ITEMS);
+
     }
 }

src/main/resources/META-INF/accesstransformer.cfg

@@ -2,3 +2,4 @@ protected net.minecraft.inventory.container.Container field_75153_a # inventoryI
 protected net.minecraft.inventory.container.Container field_75149_d  # listeners
 protected net.minecraft.client.gui.widget.TextFieldWidget field_146212_n # canLoseFocus
 public net.minecraft.client.gui.widget.button.CheckboxButton field_212943_a # checked
+public-f net.minecraft.inventory.container.Slot field_75221_f # yPos