From c027169dfe9503a9d913589eb322cc11ddad0baa Mon Sep 17 00:00:00 2001
From: shedaniel <daniel@shedaniel.me>
Date: Tue, 23 Mar 2021 00:02:16 +0800
Subject: Improve UncertainDisplayViewingScreen

Signed-off-by: shedaniel <daniel@shedaniel.me>
---
 .../api/gui/config/entry/FilteringRulesScreen.java |   2 +-
 .../gui/config/entry/RecipeScreenTypeEntry.java    |  24 +-
 .../rei/gui/AbstractDisplayViewingScreen.java      | 141 ++++++
 .../rei/gui/AbstractRecipeViewingScreen.java       | 141 ------
 .../rei/gui/CompositeDisplayViewingScreen.java     | 422 +++++++++++++++++
 .../shedaniel/rei/gui/ContainerScreenOverlay.java  |   2 +-
 .../rei/gui/DefaultDisplayViewingScreen.java       | 515 +++++++++++++++++++++
 .../shedaniel/rei/gui/PreRecipeViewingScreen.java  | 215 ---------
 .../me/shedaniel/rei/gui/RecipeViewingScreen.java  | 515 ---------------------
 .../rei/gui/UncertainDisplayViewingScreen.java     | 294 ++++++++++++
 .../rei/gui/VillagerRecipeViewingScreen.java       | 422 -----------------
 .../rei/gui/plugin/DefaultRuntimePlugin.java       |  12 +-
 .../gui/widget/DefaultDisplayChoosePageWidget.java | 211 +++++++++
 .../rei/gui/widget/FavoritesListWidget.java        |   2 +-
 .../rei/gui/widget/RecipeChoosePageWidget.java     | 211 ---------
 .../me/shedaniel/rei/impl/ClientHelperImpl.java    |  20 +-
 .../me/shedaniel/rei/impl/ConfigManagerImpl.java   |   6 +-
 .../me/shedaniel/rei/impl/ConfigObjectImpl.java    |  14 +-
 .../rei/impl/DynamicErrorFreeEntryListWidget.java  |   2 +-
 .../me/shedaniel/rei/impl/widgets/PanelWidget.java |   4 +-
 20 files changed, 1627 insertions(+), 1548 deletions(-)
 create mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/AbstractDisplayViewingScreen.java
 delete mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/AbstractRecipeViewingScreen.java
 create mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/CompositeDisplayViewingScreen.java
 create mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/DefaultDisplayViewingScreen.java
 delete mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/PreRecipeViewingScreen.java
 delete mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/RecipeViewingScreen.java
 create mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/UncertainDisplayViewingScreen.java
 delete mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/VillagerRecipeViewingScreen.java
 create mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/widget/DefaultDisplayChoosePageWidget.java
 delete mode 100644 runtime/src/main/java/me/shedaniel/rei/gui/widget/RecipeChoosePageWidget.java

(limited to 'runtime/src/main/java/me')

diff --git a/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/FilteringRulesScreen.java b/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/FilteringRulesScreen.java
index daffac707..5cf8a567b 100644
--- a/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/FilteringRulesScreen.java
+++ b/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/FilteringRulesScreen.java
@@ -45,7 +45,7 @@ import java.util.List;
 import java.util.Objects;
 import java.util.function.BiFunction;
 
-import static me.shedaniel.rei.gui.RecipeViewingScreen.CHEST_GUI_TEXTURE;
+import static me.shedaniel.rei.gui.DefaultDisplayViewingScreen.CHEST_GUI_TEXTURE;
 
 public class FilteringRulesScreen extends Screen {
     private final FilteringEntry entry;
diff --git a/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/RecipeScreenTypeEntry.java b/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/RecipeScreenTypeEntry.java
index 3f32747e9..6da592c47 100644
--- a/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/RecipeScreenTypeEntry.java
+++ b/runtime/src/main/java/me/shedaniel/rei/api/gui/config/entry/RecipeScreenTypeEntry.java
@@ -27,8 +27,8 @@ import com.google.common.collect.ImmutableList;
 import com.mojang.blaze3d.platform.Window;
 import com.mojang.blaze3d.vertex.PoseStack;
 import me.shedaniel.clothconfig2.gui.entries.TooltipListEntry;
-import me.shedaniel.rei.api.gui.config.RecipeScreenType;
-import me.shedaniel.rei.gui.PreRecipeViewingScreen;
+import me.shedaniel.rei.api.gui.config.DisplayScreenType;
+import me.shedaniel.rei.gui.UncertainDisplayViewingScreen;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.chat.NarratorChatListener;
 import net.minecraft.client.gui.components.AbstractButton;
@@ -41,18 +41,18 @@ import java.util.List;
 import java.util.Optional;
 import java.util.function.Consumer;
 
-public class RecipeScreenTypeEntry extends TooltipListEntry<RecipeScreenType> {
+public class RecipeScreenTypeEntry extends TooltipListEntry<DisplayScreenType> {
     private int width;
-    private final RecipeScreenType original;
-    private RecipeScreenType type;
-    private RecipeScreenType defaultValue;
-    private Consumer<RecipeScreenType> save;
+    private final DisplayScreenType original;
+    private DisplayScreenType type;
+    private DisplayScreenType defaultValue;
+    private Consumer<DisplayScreenType> save;
     private final AbstractWidget buttonWidget = new AbstractButton(0, 0, 0, 20, NarratorChatListener.NO_TITLE) {
         @Override
         public void onPress() {
-            Minecraft.getInstance().setScreen(new PreRecipeViewingScreen(getConfigScreen(), type, false, original -> {
+            Minecraft.getInstance().setScreen(new UncertainDisplayViewingScreen(getConfigScreen(), type, false, original -> {
                 Minecraft.getInstance().setScreen(getConfigScreen());
-                type = original ? RecipeScreenType.ORIGINAL : RecipeScreenType.VILLAGER;
+                type = original ? DisplayScreenType.ORIGINAL : DisplayScreenType.COMPOSITE;
             }));
         }
         
@@ -65,7 +65,7 @@ public class RecipeScreenTypeEntry extends TooltipListEntry<RecipeScreenType> {
     private final List<GuiEventListener> children = ImmutableList.of(buttonWidget);
     
     @SuppressWarnings("deprecation")
-    public RecipeScreenTypeEntry(int width, Component fieldName, RecipeScreenType type, RecipeScreenType defaultValue, Consumer<RecipeScreenType> save) {
+    public RecipeScreenTypeEntry(int width, Component fieldName, DisplayScreenType type, DisplayScreenType defaultValue, Consumer<DisplayScreenType> save) {
         super(fieldName, null);
         this.original = type;
         this.width = width;
@@ -80,12 +80,12 @@ public class RecipeScreenTypeEntry extends TooltipListEntry<RecipeScreenType> {
     }
     
     @Override
-    public RecipeScreenType getValue() {
+    public DisplayScreenType getValue() {
         return type;
     }
     
     @Override
-    public Optional<RecipeScreenType> getDefaultValue() {
+    public Optional<DisplayScreenType> getDefaultValue() {
         return Optional.ofNullable(defaultValue);
     }
     
diff --git a/runtime/src/main/java/me/shedaniel/rei/gui/AbstractDisplayViewingScreen.java b/runtime/src/main/java/me/shedaniel/rei/gui/AbstractDisplayViewingScreen.java
new file mode 100644
index 000000000..bfa985be7
--- /dev/null
+++ b/runtime/src/main/java/me/shedaniel/rei/gui/AbstractDisplayViewingScreen.java
@@ -0,0 +1,141 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.gui;
+
+import com.google.common.collect.Lists;
+import me.shedaniel.math.Rectangle;
+import me.shedaniel.rei.api.gui.widgets.Slot;
+import me.shedaniel.rei.api.gui.widgets.Widget;
+import me.shedaniel.rei.api.ingredient.EntryStack;
+import me.shedaniel.rei.api.registry.display.Display;
+import me.shedaniel.rei.api.registry.display.DisplayCategory;
+import me.shedaniel.rei.api.util.CollectionUtils;
+import me.shedaniel.rei.gui.widget.EntryWidget;
+import me.shedaniel.rei.impl.ClientHelperImpl;
+import net.minecraft.client.gui.chat.NarratorChatListener;
+import net.minecraft.client.gui.components.events.ContainerEventHandler;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Map;
+
+public abstract class AbstractDisplayViewingScreen extends Screen implements RecipeScreen {
+    protected final Map<DisplayCategory<?>, List<Display>> categoryMap;
+    protected final List<DisplayCategory<?>> categories;
+    protected EntryStack<?> ingredientStackToNotice = EntryStack.empty();
+    protected EntryStack<?> resultStackToNotice = EntryStack.empty();
+    protected int selectedCategoryIndex = 0;
+    protected int tabsPerPage;
+    protected Rectangle bounds;
+    
+    protected AbstractDisplayViewingScreen(Map<DisplayCategory<?>, List<Display>> categoryMap, @Nullable ResourceLocation category, int tabsPerPage) {
+        super(NarratorChatListener.NO_TITLE);
+        this.categoryMap = categoryMap;
+        this.categories = Lists.newArrayList(categoryMap.keySet());
+        this.tabsPerPage = tabsPerPage;
+        if (category != null) {
+            for (int i = 0; i < categories.size(); i++) {
+                if (categories.get(i).getIdentifier().equals(category)) {
+                    this.selectedCategoryIndex = i;
+                    break;
+                }
+            }
+        }
+    }
+    
+    @Override
+    public Rectangle getBounds() {
+        return bounds;
+    }
+    
+    @Override
+    public void addIngredientStackToNotice(EntryStack<?> stack) {
+        this.ingredientStackToNotice = stack;
+    }
+    
+    @Override
+    public void addResultStackToNotice(EntryStack<?> stack) {
+        this.resultStackToNotice = stack;
+    }
+    
+    @Override
+    public boolean isPauseScreen() {
+        return false;
+    }
+    
+    @Override
+    public ResourceLocation getCurrentCategory() {
+        return getSelectedCategory().getIdentifier();
+    }
+    
+    public DisplayCategory<Display> getSelectedCategory() {
+        return (DisplayCategory<Display>) categories.get(selectedCategoryIndex);
+    }
+    
+    protected void previousCategory() {
+        int currentCategoryIndex = selectedCategoryIndex;
+        currentCategoryIndex--;
+        if (currentCategoryIndex < 0)
+            currentCategoryIndex = categories.size() - 1;
+        ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, categories.get(currentCategoryIndex).getIdentifier(), ingredientStackToNotice, resultStackToNotice);
+    }
+    
+    protected void nextCategory() {
+        int currentCategoryIndex = selectedCategoryIndex;
+        currentCategoryIndex++;
+        if (currentCategoryIndex >= categories.size())
+            currentCategoryIndex = 0;
+        ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, categories.get(currentCategoryIndex).getIdentifier(), ingredientStackToNotice, resultStackToNotice);
+    }
+    
+    protected void transformIngredientNotice(List<Widget> setupDisplay, EntryStack<?> noticeStack) {
+        transformNotice(Slot.INPUT, setupDisplay, noticeStack);
+    }
+    
+    protected void transformResultNotice(List<Widget> setupDisplay, EntryStack<?> noticeStack) {
+        transformNotice(Slot.OUTPUT, setupDisplay, noticeStack);
+    }
+    
+    private static void transformNotice(int marker, List<? extends GuiEventListener> setupDisplay, EntryStack<?> noticeStack) {
+        if (noticeStack.isEmpty())
+            return;
+        for (GuiEventListener widget : setupDisplay) {
+            if (widget instanceof EntryWidget) {
+                EntryWidget entry = (EntryWidget) widget;
+                if (entry.getNoticeMark() == marker && entry.getEntries().size() > 1) {
+                    EntryStack<?> stack = CollectionUtils.findFirstOrNullEqualsExact(entry.getEntries(), noticeStack);
+                    if (stack != null) {
+                        entry.clearStacks();
+                        entry.entry(stack);
+                    }
+                }
+            } else if (widget instanceof ContainerEventHandler) {
+                transformNotice(marker, ((ContainerEventHandler) widget).children(), noticeStack);
+            }
+        }
+    }
+}
diff --git a/runtime/src/main/java/me/shedaniel/rei/gui/AbstractRecipeViewingScreen.java b/runtime/src/main/java/me/shedaniel/rei/gui/AbstractRecipeViewingScreen.java
deleted file mode 100644
index c7fdcfc54..000000000
--- a/runtime/src/main/java/me/shedaniel/rei/gui/AbstractRecipeViewingScreen.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * This file is licensed under the MIT License, part of Roughly Enough Items.
- * Copyright (c) 2018, 2019, 2020 shedaniel
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package me.shedaniel.rei.gui;
-
-import com.google.common.collect.Lists;
-import me.shedaniel.math.Rectangle;
-import me.shedaniel.rei.api.gui.widgets.Slot;
-import me.shedaniel.rei.api.gui.widgets.Widget;
-import me.shedaniel.rei.api.ingredient.EntryStack;
-import me.shedaniel.rei.api.registry.display.Display;
-import me.shedaniel.rei.api.registry.display.DisplayCategory;
-import me.shedaniel.rei.api.util.CollectionUtils;
-import me.shedaniel.rei.gui.widget.EntryWidget;
-import me.shedaniel.rei.impl.ClientHelperImpl;
-import net.minecraft.client.gui.chat.NarratorChatListener;
-import net.minecraft.client.gui.components.events.ContainerEventHandler;
-import net.minecraft.client.gui.components.events.GuiEventListener;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.resources.ResourceLocation;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-import java.util.Map;
-
-public abstract class AbstractRecipeViewingScreen extends Screen implements RecipeScreen {
-    protected final Map<DisplayCategory<?>, List<Display>> categoryMap;
-    protected final List<DisplayCategory<?>> categories;
-    protected EntryStack<?> ingredientStackToNotice = EntryStack.empty();
-    protected EntryStack<?> resultStackToNotice = EntryStack.empty();
-    protected int selectedCategoryIndex = 0;
-    protected int tabsPerPage;
-    protected Rectangle bounds;
-    
-    protected AbstractRecipeViewingScreen(Map<DisplayCategory<?>, List<Display>> categoryMap, @Nullable ResourceLocation category, int tabsPerPage) {
-        super(NarratorChatListener.NO_TITLE);
-        this.categoryMap = categoryMap;
-        this.categories = Lists.newArrayList(categoryMap.keySet());
-        this.tabsPerPage = tabsPerPage;
-        if (category != null) {
-            for (int i = 0; i < categories.size(); i++) {
-                if (categories.get(i).getIdentifier().equals(category)) {
-                    this.selectedCategoryIndex = i;
-                    break;
-                }
-            }
-        }
-    }
-    
-    @Override
-    public Rectangle getBounds() {
-        return bounds;
-    }
-    
-    @Override
-    public void addIngredientStackToNotice(EntryStack<?> stack) {
-        this.ingredientStackToNotice = stack;
-    }
-    
-    @Override
-    public void addResultStackToNotice(EntryStack<?> stack) {
-        this.resultStackToNotice = stack;
-    }
-    
-    @Override
-    public boolean isPauseScreen() {
-        return false;
-    }
-    
-    @Override
-    public ResourceLocation getCurrentCategory() {
-        return getSelectedCategory().getIdentifier();
-    }
-    
-    public DisplayCategory<Display> getSelectedCategory() {
-        return (DisplayCategory<Display>) categories.get(selectedCategoryIndex);
-    }
-    
-    protected void previousCategory() {
-        int currentCategoryIndex = selectedCategoryIndex;
-        currentCategoryIndex--;
-        if (currentCategoryIndex < 0)
-            currentCategoryIndex = categories.size() - 1;
-        ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, categories.get(currentCategoryIndex).getIdentifier(), ingredientStackToNotice, resultStackToNotice);
-    }
-    
-    protected void nextCategory() {
-        int currentCategoryIndex = selectedCategoryIndex;
-        currentCategoryIndex++;
-        if (currentCategoryIndex >= categories.size())
-            currentCategoryIndex = 0;
-        ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, categories.get(currentCategoryIndex).getIdentifier(), ingredientStackToNotice, resultStackToNotice);
-    }
-    
-    protected void transformIngredientNotice(List<Widget> setupDisplay, EntryStack<?> noticeStack) {
-        transformNotice(Slot.INPUT, setupDisplay, noticeStack);
-    }
-    
-    protected void transformResultNotice(List<Widget> setupDisplay, EntryStack<?> noticeStack) {
-        transformNotice(Slot.OUTPUT, setupDisplay, noticeStack);
-    }
-    
-    private static void transformNotice(int marker, List<? extends GuiEventListener> setupDisplay, EntryStack<?> noticeStack) {
-        if (noticeStack.isEmpty())
-            return;
-        for (GuiEventListener widget : setupDisplay) {
-            if (widget instanceof EntryWidget) {
-                EntryWidget entry = (EntryWidget) widget;
-                if (entry.getNoticeMark() == marker && entry.getEntries().size() > 1) {
-                    EntryStack<?> stack = CollectionUtils.findFirstOrNullEqualsExact(entry.getEntries(), noticeStack);
-                    if (stack != null) {
-                        entry.clearStacks();
-                        entry.entry(stack);
-                    }
-                }
-            } else if (widget instanceof ContainerEventHandler) {
-                transformNotice(marker, ((ContainerEventHandler) widget).children(), noticeStack);
-            }
-        }
-    }
-}
diff --git a/runtime/src/main/java/me/shedaniel/rei/gui/CompositeDisplayViewingScreen.java b/runtime/src/main/java/me/shedaniel/rei/gui/CompositeDisplayViewingScreen.java
new file mode 100644
index 000000000..40826d9f3
--- /dev/null
+++ b/runtime/src/main/java/me/shedaniel/rei/gui/CompositeDisplayViewingScreen.java
@@ -0,0 +1,422 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.gui;
+
+import com.google.common.collect.Lists;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import me.shedaniel.clothconfig2.ClothConfigInitializer;
+import me.shedaniel.clothconfig2.api.ScissorsHandler;
+import me.shedaniel.clothconfig2.api.ScrollingContainer;
+import me.shedaniel.math.Point;
+import me.shedaniel.math.Rectangle;
+import me.shedaniel.math.impl.PointHelper;
+import me.shedaniel.rei.api.registry.category.ButtonArea;
+import me.shedaniel.rei.api.ClientHelper;
+import me.shedaniel.rei.api.config.ConfigObject;
+import me.shedaniel.rei.api.REIHelper;
+import me.shedaniel.rei.api.gui.DisplayRenderer;
+import me.shedaniel.rei.api.gui.widgets.Button;
+import me.shedaniel.rei.api.gui.widgets.Tooltip;
+import me.shedaniel.rei.api.gui.widgets.Widget;
+import me.shedaniel.rei.api.gui.widgets.Widgets;
+import me.shedaniel.rei.api.ingredient.EntryIngredient;
+import me.shedaniel.rei.api.registry.category.CategoryRegistry;
+import me.shedaniel.rei.api.registry.display.Display;
+import me.shedaniel.rei.api.registry.display.DisplayCategory;
+import me.shedaniel.rei.api.view.ViewSearchBuilder;
+import me.shedaniel.rei.gui.widget.TabWidget;
+import me.shedaniel.rei.impl.ClientHelperImpl;
+import me.shedaniel.rei.impl.InternalWidgets;
+import me.shedaniel.rei.impl.REIHelperImpl;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.chat.NarratorChatListener;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.resources.language.I18n;
+import net.minecraft.client.resources.sounds.SimpleSoundInstance;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@ApiStatus.Internal
+public class CompositeDisplayViewingScreen extends AbstractDisplayViewingScreen {
+    private final List<Widget> widgets = Lists.newArrayList();
+    private final List<Button> buttonList = Lists.newArrayList();
+    private final List<DisplayRenderer> displayRenderers = Lists.newArrayList();
+    private final List<TabWidget> tabs = Lists.newArrayList();
+    public Rectangle scrollListBounds;
+    private int selectedRecipeIndex = 0;
+    private final ScrollingContainer scrolling = new ScrollingContainer() {
+        @Override
+        public Rectangle getBounds() {
+            return new Rectangle(scrollListBounds.x + 1, scrollListBounds.y + 1, scrollListBounds.width - 2, scrollListBounds.height - 2);
+        }
+        
+        @Override
+        public int getMaxScrollHeight() {
+            int i = 0;
+            for (Button button : buttonList) {
+                i += button.getBounds().height;
+            }
+            return i;
+        }
+    };
+    private float scrollBarAlpha = 0;
+    private float scrollBarAlphaFuture = 0;
+    private long scrollBarAlphaFutureTime = -1;
+    private int tabsPage = -1;
+    
+    public CompositeDisplayViewingScreen(Map<DisplayCategory<?>, List<Display>> categoryMap, @Nullable ResourceLocation category) {
+        super(categoryMap, category, 8);
+    }
+    
+    @Override
+    public void recalculateCategoryPage() {
+        this.tabsPage = -1;
+    }
+    
+    @Override
+    public void init() {
+        super.init();
+        boolean isCompactTabs = ConfigObject.getInstance().isUsingCompactTabs();
+        int tabSize = isCompactTabs ? 24 : 28;
+        scrolling.draggingScrollBar = false;
+        this.children.clear();
+        this.widgets.clear();
+        this.buttonList.clear();
+        this.displayRenderers.clear();
+        this.tabs.clear();
+        int largestWidth = width - 100;
+        int largestHeight = height - 40;
+        DisplayCategory<Display> category = (DisplayCategory<Display>) categories.get(selectedCategoryIndex);
+        Display display = categoryMap.get(category).get(selectedRecipeIndex);
+        int guiWidth = Mth.clamp(category.getDisplayWidth(display) + 30, 0, largestWidth) + 100;
+        int guiHeight = Mth.clamp(category.getDisplayHeight() + 40, 166, largestHeight);
+        this.tabsPerPage = Math.max(5, Mth.floor((guiWidth - 20d) / tabSize));
+        if (this.tabsPage == -1) {
+            this.tabsPage = selectedCategoryIndex / tabsPerPage;
+        }
+        this.bounds = new Rectangle(width / 2 - guiWidth / 2, height / 2 - guiHeight / 2, guiWidth, guiHeight);
+        
+        List<EntryIngredient> workstations = CategoryRegistry.getInstance().get(category.getIdentifier()).getWorkstations();
+        if (!workstations.isEmpty()) {
+            int ww = Mth.floor((bounds.width - 16) / 18f);
+            int w = Math.min(ww, workstations.size());
+            int h = Mth.ceil(workstations.size() / ((float) ww));
+            int xx = bounds.x + 16;
+            int yy = bounds.y + bounds.height + 2;
+            widgets.add(Widgets.createCategoryBase(new Rectangle(xx - 5, bounds.y + bounds.height - 5, 10 + w * 16, 12 + h * 16)));
+            widgets.add(Widgets.createSlotBase(new Rectangle(xx - 1, yy - 1, 2 + w * 16, 2 + h * 16)));
+            int index = 0;
+            for (EntryIngredient workingStation : workstations) {
+                widgets.add(new DefaultDisplayViewingScreen.WorkstationSlotWidget(xx, yy, workingStation));
+                index++;
+                xx += 16;
+                if (index >= ww) {
+                    index = 0;
+                    xx = bounds.x + 16;
+                    yy += 16;
+                }
+            }
+        }
+        
+        this.widgets.add(Widgets.createCategoryBase(bounds));
+        this.scrollListBounds = new Rectangle(bounds.x + 4, bounds.y + 17, 97 + 5, guiHeight - 17 - 7);
+        this.widgets.add(Widgets.createSlotBase(scrollListBounds));
+        
+        Rectangle recipeBounds = new Rectangle(bounds.x + 100 + (guiWidth - 100) / 2 - category.getDisplayWidth(display) / 2, bounds.y + bounds.height / 2 - category.getDisplayHeight() / 2, category.getDisplayWidth(display), category.getDisplayHeight());
+        List<Widget> setupDisplay = category.setupDisplay(display, recipeBounds);
+        transformIngredientNotice(setupDisplay, ingredientStackToNotice);
+        transformResultNotice(setupDisplay, resultStackToNotice);
+        this.widgets.addAll(setupDisplay);
+        Optional<ButtonArea> supplier = CategoryRegistry.getInstance().get(category.getIdentifier()).getPlusButtonArea();
+        if (supplier.isPresent() && supplier.get().get(recipeBounds) != null)
+            this.widgets.add(InternalWidgets.createAutoCraftingButtonWidget(recipeBounds, supplier.get().get(recipeBounds), new TextComponent(supplier.get().getButtonText()), () -> display, setupDisplay, category));
+        
+        int index = 0;
+        for (Display recipeDisplay : categoryMap.get(category)) {
+            int finalIndex = index;
+            DisplayRenderer displayRenderer;
+            displayRenderers.add(displayRenderer = category.getDisplayRenderer(recipeDisplay));
+            buttonList.add(Widgets.createButton(new Rectangle(bounds.x + 5, 0, displayRenderer.getWidth(), displayRenderer.getHeight()), NarratorChatListener.NO_TITLE)
+                    .onClick(button -> {
+                        selectedRecipeIndex = finalIndex;
+                        CompositeDisplayViewingScreen.this.init();
+                    })
+                    .containsMousePredicate((button, point) -> {
+                        return (button.getBounds().contains(point) && scrollListBounds.contains(point)) || button.isFocused();
+                    })
+                    .onRender((matrices, button) -> button.setEnabled(selectedRecipeIndex != finalIndex)));
+            index++;
+        }
+        int tabV = isCompactTabs ? 166 : 192;
+        for (int i = 0; i < tabsPerPage; i++) {
+            int j = i + tabsPage * tabsPerPage;
+            if (categories.size() > j) {
+                DisplayCategory<?> tabCategory = categories.get(j);
+                TabWidget tab;
+                tabs.add(tab = TabWidget.create(i, tabSize, bounds.x + bounds.width / 2 - Math.min(categories.size() - tabsPage * tabsPerPage, tabsPerPage) * tabSize / 2, bounds.y, 0, tabV, widget -> {
+                    Minecraft.getInstance().getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+                    if (widget.selected)
+                        return false;
+                    ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, tabCategory.getIdentifier(), ingredientStackToNotice, resultStackToNotice);
+                    return true;
+                }));
+                tab.setRenderer(tabCategory, tabCategory.getIcon(), tabCategory.getTitle(), j == selectedCategoryIndex);
+            }
+        }
+        this.widgets.add(Widgets.createButton(new Rectangle(bounds.x + 2, bounds.y - 16, 10, 10), new TranslatableComponent("text.rei.left_arrow"))
+                .onClick(button -> {
+                    tabsPage--;
+                    if (tabsPage < 0)
+                        tabsPage = Mth.ceil(categories.size() / (float) tabsPerPage) - 1;
+                    CompositeDisplayViewingScreen.this.init();
+                })
+                .enabled(categories.size() > tabsPerPage));
+        this.widgets.add(Widgets.createButton(new Rectangle(bounds.x + bounds.width - 12, bounds.y - 16, 10, 10), new TranslatableComponent("text.rei.right_arrow"))
+                .onClick(button -> {
+                    tabsPage++;
+                    if (tabsPage > Mth.ceil(categories.size() / (float) tabsPerPage) - 1)
+                        tabsPage = 0;
+                    CompositeDisplayViewingScreen.this.init();
+                })
+                .enabled(categories.size() > tabsPerPage));
+        
+        this.widgets.add(Widgets.createClickableLabel(new Point(bounds.x + 4 + scrollListBounds.width / 2, bounds.y + 6), categories.get(selectedCategoryIndex).getTitle(), label -> {
+            ClientHelper.getInstance().openView(ViewSearchBuilder.builder().addAllCategories().fillPreferredOpenedCategory());
+        }).tooltipLine(I18n.get("text.rei.view_all_categories")).noShadow().color(0xFF404040, 0xFFBBBBBB).hoveredColor(0xFF0041FF, 0xFFFFBD4D));
+        
+        this.children.addAll(buttonList);
+        this.widgets.addAll(tabs);
+        this.children.addAll(widgets);
+    }
+    
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if (scrolling.updateDraggingState(mouseX, mouseY, button)) {
+            scrollBarAlpha = 1;
+            return true;
+        }
+        if (ConfigObject.getInstance().getNextPageKeybind().matchesMouse(button)) {
+            selectedRecipeIndex++;
+            if (selectedRecipeIndex >= categoryMap.get(categories.get(selectedCategoryIndex)).size())
+                selectedRecipeIndex = 0;
+            init();
+            return true;
+        } else if (ConfigObject.getInstance().getPreviousPageKeybind().matchesMouse(button)) {
+            selectedRecipeIndex--;
+            if (selectedRecipeIndex < 0)
+                selectedRecipeIndex = categoryMap.get(categories.get(selectedCategoryIndex)).size() - 1;
+            init();
+            return true;
+        }
+        for (GuiEventListener entry : children())
+            if (entry.mouseClicked(mouseX, mouseY, button)) {
+                setFocused(entry);
+                if (button == 0)
+                    setDragging(true);
+                return true;
+            }
+        return super.mouseClicked(mouseX, mouseY, button);
+    }
+    
+    @Override
+    public boolean charTyped(char char_1, int int_1) {
+        for (GuiEventListener listener : children())
+            if (listener.charTyped(char_1, int_1))
+                return true;
+        return super.charTyped(char_1, int_1);
+    }
+    
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        double height = scrolling.getMaxScrollHeight();
+        if (scrollListBounds.contains(mouseX, mouseY) && height > scrollListBounds.height - 2) {
+            scrolling.offset(ClothConfigInitializer.getScrollStep() * -amount, true);
+            if (scrollBarAlphaFuture == 0)
+                scrollBarAlphaFuture = 1f;
+            if (System.currentTimeMillis() - scrollBarAlphaFutureTime > 300f)
+                scrollBarAlphaFutureTime = System.currentTimeMillis();
+            return true;
+        }
+        REIHelperImpl.isWithinRecipeViewingScreen = true;
+        for (GuiEventListener listener : children()) {
+            if (listener.mouseScrolled(mouseX, mouseY, amount)) {
+                REIHelperImpl.isWithinRecipeViewingScreen = false;
+                return true;
+            }
+        }
+        REIHelperImpl.isWithinRecipeViewingScreen = false;
+        int tabSize = ConfigObject.getInstance().isUsingCompactTabs() ? 24 : 28;
+        if (mouseX >= bounds.x && mouseX <= bounds.getMaxX() && mouseY >= bounds.y - tabSize && mouseY < bounds.y) {
+            if (amount < 0) selectedCategoryIndex++;
+            else if (amount > 0) selectedCategoryIndex--;
+            if (selectedCategoryIndex < 0) selectedCategoryIndex = categories.size() - 1;
+            else if (selectedCategoryIndex >= categories.size()) selectedCategoryIndex = 0;
+            ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, categories.get(selectedCategoryIndex).getIdentifier(), ingredientStackToNotice, resultStackToNotice);
+            return true;
+        }
+        if (bounds.contains(PointHelper.ofMouse())) {
+            if (amount < 0 && categoryMap.get(categories.get(selectedCategoryIndex)).size() > 1) {
+                selectedRecipeIndex++;
+                if (selectedRecipeIndex >= categoryMap.get(categories.get(selectedCategoryIndex)).size())
+                    selectedRecipeIndex = 0;
+                init();
+                return true;
+            } else if (categoryMap.get(categories.get(selectedCategoryIndex)).size() > 1) {
+                selectedRecipeIndex--;
+                if (selectedRecipeIndex < 0)
+                    selectedRecipeIndex = categoryMap.get(categories.get(selectedCategoryIndex)).size() - 1;
+                init();
+                return true;
+            }
+        }
+        return super.mouseScrolled(mouseX, mouseY, amount);
+    }
+    
+    @Override
+    public void render(PoseStack matrices, int mouseX, int mouseY, float delta) {
+        if (ConfigObject.getInstance().isCompositeScrollBarPermanent()) {
+            scrollBarAlphaFutureTime = System.currentTimeMillis();
+            scrollBarAlphaFuture = 0;
+            scrollBarAlpha = 1;
+        } else if (scrollBarAlphaFutureTime > 0) {
+            long l = System.currentTimeMillis() - scrollBarAlphaFutureTime;
+            if (l > 300f) {
+                if (scrollBarAlphaFutureTime == 0) {
+                    scrollBarAlpha = scrollBarAlphaFuture;
+                    scrollBarAlphaFutureTime = -1;
+                } else if (l > 2000f && scrollBarAlphaFuture == 1) {
+                    scrollBarAlphaFuture = 0;
+                    scrollBarAlphaFutureTime = System.currentTimeMillis();
+                } else
+                    scrollBarAlpha = scrollBarAlphaFuture;
+            } else {
+                if (scrollBarAlphaFuture == 0)
+                    scrollBarAlpha = Math.min(scrollBarAlpha, 1 - Math.min(1f, l / 300f));
+                else if (scrollBarAlphaFuture == 1)
+                    scrollBarAlpha = Math.max(Math.min(1f, l / 300f), scrollBarAlpha);
+            }
+        }
+        scrolling.updatePosition(delta);
+        this.fillGradient(matrices, 0, 0, this.width, this.height, -1072689136, -804253680);
+        int yOffset = 0;
+        for (Widget widget : widgets) {
+            widget.render(matrices, mouseX, mouseY, delta);
+        }
+        super.render(matrices, mouseX, mouseY, delta);
+        RenderSystem.pushMatrix();
+        ScissorsHandler.INSTANCE.scissor(scrolling.getBounds());
+        for (Button button : buttonList) {
+            button.getBounds().y = scrollListBounds.y + 1 + yOffset - (int) scrolling.scrollAmount;
+            if (button.getBounds().getMaxY() > scrollListBounds.getMinY() && button.getBounds().getMinY() < scrollListBounds.getMaxY()) {
+                button.render(matrices, mouseX, mouseY, delta);
+            }
+            yOffset += button.getBounds().height;
+        }
+        for (int i = 0; i < buttonList.size(); i++) {
+            if (buttonList.get(i).getBounds().getMaxY() > scrollListBounds.getMinY() && buttonList.get(i).getBounds().getMinY() < scrollListBounds.getMaxY()) {
+                displayRenderers.get(i).setZ(1);
+                displayRenderers.get(i).render(matrices, buttonList.get(i).getBounds(), mouseX, mouseY, delta);
+                Optional.ofNullable(displayRenderers.get(i).getTooltip(new Point(mouseX, mouseY))).ifPresent(Tooltip::queue);
+            }
+        }
+        scrolling.renderScrollBar(0, scrollBarAlpha, REIHelper.getInstance().isDarkThemeEnabled() ? 0.8f : 1f);
+        ScissorsHandler.INSTANCE.removeLastScissor();
+        RenderSystem.popMatrix();
+    }
+    
+    @Override
+    public boolean mouseReleased(double double_1, double double_2, int int_1) {
+        for (GuiEventListener entry : children())
+            if (entry.mouseReleased(double_1, double_2, int_1))
+                return true;
+        return super.mouseReleased(double_1, double_2, int_1);
+    }
+    
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int int_1, double double_3, double double_4) {
+        if (scrolling.mouseDragged(mouseX, mouseY, int_1, double_3, double_4)) {
+            scrollBarAlphaFutureTime = System.currentTimeMillis();
+            scrollBarAlphaFuture = 1f;
+            return true;
+        }
+        for (GuiEventListener entry : children())
+            if (entry.mouseDragged(mouseX, mouseY, int_1, double_3, double_4))
+                return true;
+        return super.mouseDragged(mouseX, mouseY, int_1, double_3, double_4);
+    }
+    
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (keyCode == 258 && !minecraft.options.keyInventory.matches(keyCode, scanCode)) {
+            boolean boolean_1 = !hasShiftDown();
+            if (!this.changeFocus(boolean_1))
+                this.changeFocus(boolean_1);
+            return true;
+        }
+        if (ConfigObject.getInstance().getNextPageKeybind().matchesKey(keyCode, scanCode)) {
+            if (categoryMap.get(categories.get(selectedCategoryIndex)).size() > 1) {
+                selectedRecipeIndex++;
+                if (selectedRecipeIndex >= categoryMap.get(categories.get(selectedCategoryIndex)).size())
+                    selectedRecipeIndex = 0;
+                init();
+                return true;
+            }
+            return false;
+        } else if (ConfigObject.getInstance().getPreviousPageKeybind().matchesKey(keyCode, scanCode)) {
+            if (categoryMap.get(categories.get(selectedCategoryIndex)).size() > 1) {
+                selectedRecipeIndex--;
+                if (selectedRecipeIndex < 0)
+                    selectedRecipeIndex = categoryMap.get(categories.get(selectedCategoryIndex)).size() - 1;
+                init();
+                return true;
+            }
+            return false;
+        }
+        for (GuiEventListener element : children())
+            if (element.keyPressed(keyCode, scanCode, modifiers))
+                return true;
+        if (keyCode == 256 || this.minecraft.options.keyInventory.matches(keyCode, scanCode)) {
+            Minecraft.getInstance().setScreen(REIHelper.getInstance().getPreviousScreen());
+            return true;
+        }
+        if (keyCode == 259) {
+            if (REIHelperImpl.getInstance().hasLastRecipeScreen())
+                minecraft.setScreen(REIHelperImpl.getInstance().getLastRecipeScreen());
+            else
+                minecraft.setScreen(REIHelper.getInstance().getPreviousScreen());
+            return true;
+        }
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+}
diff --git a/runtime/src/main/java/me/shedaniel/rei/gui/ContainerScreenOverlay.java b/runtime/src/main/java/me/shedaniel/rei/gui/ContainerScreenOverlay.java
index e466e342b..258cd52fd 100644
--- a/runtime/src/main/java/me/shedaniel/rei/gui/ContainerScreenOverlay.java
+++ b/runtime/src/main/java/me/shedaniel/rei/gui/ContainerScreenOverlay.java
@@ -600,7 +600,7 @@ public class ContainerScreenOverlay extends REIOverlay {
             }
         }
         Screen currentScreen = Minecraft.getInstance().screen;
-        if (!(currentScreen instanceof RecipeViewingScreen) || !((RecipeViewingScreen) currentScreen).choosePageActivated) {
+        if (!(currentScreen instanceof DefaultDisplayViewingScreen) || !((DefaultDisplayViewingScreen) currentScreen).choosePageActivated) {
             for (Tooltip tooltip : TOOLTIPS) {
                 if (tooltip != null)
                     renderTooltip(matrices, tooltip);
diff --git a/runtime/src/main/java/me/shedaniel/rei/gui/DefaultDisplayViewingScreen.java b/runtime/src/main/java/me/shedaniel/rei/gui/DefaultDisplayViewingScreen.java
new file mode 100644
index 000000000..67c98d0ee
--- /dev/null
+++ b/runtime/src/main/java/me/shedaniel/rei/gui/DefaultDisplayViewingScreen.java
@@ -0,0 +1,515 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.gui;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.math.Matrix4f;
+import me.shedaniel.clothconfig2.api.ModifierKeyCode;
+import me.shedaniel.math.Point;
+import me.shedaniel.math.Rectangle;
+import me.shedaniel.math.impl.PointHelper;
+import me.shedaniel.rei.api.registry.category.ButtonArea;
+import me.shedaniel.rei.api.ClientHelper;
+import me.shedaniel.rei.api.config.ConfigObject;
+import me.shedaniel.rei.api.REIHelper;
+import me.shedaniel.rei.api.gui.widgets.Button;
+import me.shedaniel.rei.api.gui.widgets.Panel;
+import me.shedaniel.rei.api.gui.widgets.Widget;
+import me.shedaniel.rei.api.gui.widgets.Widgets;
+import me.shedaniel.rei.api.ingredient.EntryIngredient;
+import me.shedaniel.rei.api.ingredient.EntryStack;
+import me.shedaniel.rei.api.registry.category.CategoryRegistry;
+import me.shedaniel.rei.api.registry.display.Display;
+import me.shedaniel.rei.api.registry.display.DisplayCategory;
+import me.shedaniel.rei.api.util.CollectionUtils;
+import me.shedaniel.rei.api.util.ImmutableLiteralText;
+import me.shedaniel.rei.api.view.ViewSearchBuilder;
+import me.shedaniel.rei.gui.widget.EntryWidget;
+import me.shedaniel.rei.gui.widget.DefaultDisplayChoosePageWidget;
+import me.shedaniel.rei.gui.widget.TabWidget;
+import me.shedaniel.rei.impl.ClientHelperImpl;
+import me.shedaniel.rei.impl.InternalWidgets;
+import me.shedaniel.rei.impl.REIHelperImpl;
+import me.shedaniel.rei.impl.widgets.PanelWidget;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.chat.NarratorChatListener;
+import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.resources.language.I18n;
+import net.minecraft.client.resources.sounds.SimpleSoundInstance;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+@ApiStatus.Internal
+public class DefaultDisplayViewingScreen extends AbstractDisplayViewingScreen {
+    public static final ResourceLocation CHEST_GUI_TEXTURE = new ResourceLocation("roughlyenoughitems", "textures/gui/recipecontainer.png");
+    private final List<Widget> preWidgets = Lists.newArrayList();
+    private final List<Widget> widgets = Lists.newArrayList();
+    private final Map<Rectangle, List<Widget>> recipeBounds = Maps.newHashMap();
+    private final List<TabWidget> tabs = Lists.newArrayList();
+    public int page;
+    public int categoryPages = -1;
+    public boolean choosePageActivated = false;
+    public DefaultDisplayChoosePageWidget choosePageWidget;
+    @Nullable
+    private Panel workingStationsBaseWidget;
+    private Button recipeBack, recipeNext, categoryBack, categoryNext;
+    private EntryStack<?> ingredientStackToNotice = EntryStack.empty();
+    private EntryStack<?> resultStackToNotice = EntryStack.empty();
+    
+    public DefaultDisplayViewingScreen(Map<DisplayCategory<?>, List<Display>> categoriesMap, @Nullable ResourceLocation category) {
+        super(categoriesMap, category, 5);
+        this.bounds = new Rectangle(0, 0, 176, 150);
+    }
+    
+    @Override
+    public void recalculateCategoryPage() {
+        this.categoryPages = -1;
+    }
+    
+    @Nullable
+    public Panel getWorkingStationsBaseWidget() {
+        return workingStationsBaseWidget;
+    }
+    
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (keyCode == 256 && choosePageActivated) {
+            choosePageActivated = false;
+            init();
+            return true;
+        }
+        if (keyCode == 258 && !minecraft.options.keyInventory.matches(keyCode, scanCode)) {
+            boolean boolean_1 = !hasShiftDown();
+            if (!this.changeFocus(boolean_1))
+                this.changeFocus(boolean_1);
+            return true;
+        }
+        if (choosePageActivated)
+            return choosePageWidget.keyPressed(keyCode, scanCode, modifiers);
+        else if (ConfigObject.getInstance().getNextPageKeybind().matchesKey(keyCode, scanCode)) {
+            if (recipeNext.isEnabled())
+                recipeNext.onClick();
+            return recipeNext.isEnabled();
+        } else if (ConfigObject.getInstance().getPreviousPageKeybind().matchesKey(keyCode, scanCode)) {
+            if (recipeBack.isEnabled())
+                recipeBack.onClick();
+            return recipeBack.isEnabled();
+        }
+        for (GuiEventListener element : children())
+            if (element.keyPressed(keyCode, scanCode, modifiers))
+                return true;
+        if (keyCode == 256 || this.minecraft.options.keyInventory.matches(keyCode, scanCode)) {
+            Minecraft.getInstance().setScreen(REIHelper.getInstance().getPreviousScreen());
+            return true;
+        }
+        if (keyCode == 259) {
+            if (REIHelperImpl.getInstance().hasLastRecipeScreen())
+                minecraft.setScreen(REIHelperImpl.getInstance().getLastRecipeScreen());
+            else
+                minecraft.setScreen(REIHelper.getInstance().getPreviousScreen());
+            return true;
+        }
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+    
+    @Override
+    public void init() {
+        super.init();
+        boolean isCompactTabs = ConfigObject.getInstance().isUsingCompactTabs();
+        int tabSize = isCompactTabs ? 24 : 28;
+        this.children.clear();
+        this.recipeBounds.clear();
+        this.tabs.clear();
+        this.preWidgets.clear();
+        this.widgets.clear();
+        int largestWidth = width - 100;
+        int largestHeight = Math.max(height - 34 - 30, 100);
+        int maxWidthDisplay = CollectionUtils.mapAndMax(getCurrentDisplayed(), getSelectedCategory()::getDisplayWidth, Comparator.naturalOrder()).orElse(150);
+        int guiWidth = Math.max(maxWidthDisplay + 40, 190);
+        this.tabsPerPage = Math.max(5, Mth.floor((guiWidth - 20d) / tabSize));
+        if (this.categoryPages == -1) {
+            this.categoryPages = Math.max(0, selectedCategoryIndex / tabsPerPage);
+        }
+        this.bounds = new Rectangle(width / 2 - guiWidth / 2, height / 2 - largestHeight / 2, guiWidth, largestHeight);
+        if (ConfigObject.getInstance().isSubsetsEnabled()) {
+            this.bounds.setLocation(this.bounds.getX(), this.bounds.getY() + 15);
+            this.bounds.setSize(this.bounds.getWidth(), this.bounds.getHeight() - 10);
+        }
+        this.page = Mth.clamp(page, 0, getCurrentTotalPages() - 1);
+        this.widgets.add(Widgets.createButton(new Rectangle(bounds.x, bounds.y - 16, 10, 10), new TranslatableComponent("text.rei.left_arrow"))
+                .onClick(button -> {
+                    categoryPages--;
+                    if (categoryPages < 0)
+                        categoryPages = Mth.ceil(categories.size() / (float) tabsPerPage) - 1;
+                    DefaultDisplayViewingScreen.this.init();
+                })
+                .enabled(categories.size() > tabsPerPage));
+        this.widgets.add(Widgets.createButton(new Rectangle(bounds.x + bounds.width - 10, bounds.y - 16, 10, 10), new TranslatableComponent("text.rei.right_arrow"))
+                .onClick(button -> {
+                    categoryPages++;
+                    if (categoryPages > Mth.ceil(categories.size() / (float) tabsPerPage) - 1)
+                        categoryPages = 0;
+                    DefaultDisplayViewingScreen.this.init();
+                })
+                .enabled(categories.size() > tabsPerPage));
+        widgets.add(categoryBack = Widgets.createButton(new Rectangle(bounds.getX() + 5, bounds.getY() + 5, 12, 12), new TranslatableComponent("text.rei.left_arrow"))
+                .onClick(button -> previousCategory()).tooltipLine(I18n.get("text.rei.previous_category")));
+        widgets.add(Widgets.createClickableLabel(new Point(bounds.getCenterX(), bounds.getY() + 7), getSelectedCategory().getTitle(), clickableLabelWidget -> {
+            ClientHelper.getInstance().openView(ViewSearchBuilder.builder().addAllCategories().fillPreferredOpenedCategory());
+        }).tooltipLine(I18n.get("text.rei.view_all_categories")));
+        widgets.add(categoryNext = Widgets.createButton(new Rectangle(bounds.getMaxX() - 17, bounds.getY() + 5, 12, 12), new TranslatableComponent("text.rei.right_arrow"))
+                .onClick(button -> nextCategory()).tooltipLine(I18n.get("text.rei.next_category")));
+        categoryBack.setEnabled(categories.size() > 1);
+        categoryNext.setEnabled(categories.size() > 1);
+        
+        widgets.add(recipeBack = Widgets.createButton(new Rectangle(bounds.getX() + 5, bounds.getY() + 19, 12, 12), new TranslatableComponent("text.rei.left_arrow"))
+                .onClick(button -> {
+                    page--;
+                    if (page < 0)
+                        page = getCurrentTotalPages() - 1;
+                    DefaultDisplayViewingScreen.this.init();
+                }).tooltipLine(I18n.get("text.rei.previous_page")));
+        widgets.add(Widgets.createClickableLabel(new Point(bounds.getCenterX(), bounds.getY() + 21), NarratorChatListener.NO_TITLE, label -> {
+            DefaultDisplayViewingScreen.this.choosePageActivated = true;
+            DefaultDisplayViewingScreen.this.init();
+        }).onRender((matrices, label) -> {
+            label.setText(new ImmutableLiteralText(String.format("%d/%d", page + 1, getCurrentTotalPages())));
+            label.setClickable(getCurrentTotalPages() > 1);
+        }).tooltipSupplier(label -> label.isClickable() ? I18n.get("text.rei.choose_page") : null));
+        widgets.add(recipeNext = Widgets.createButton(new Rectangle(bounds.getMaxX() - 17, bounds.getY() + 19, 12, 12), new TranslatableComponent("text.rei.right_arrow"))
+                .onClick(button -> {
+                    page++;
+                    if (page >= getCurrentTotalPages())
+                        page = 0;
+                    DefaultDisplayViewingScreen.this.init();
+                }).tooltipLine(I18n.get("text.rei.next_page")));
+        recipeBack.setEnabled(getCurrentTotalPages() > 1);
+        recipeNext.setEnabled(getCurrentTotalPages() > 1);
+        int tabV = isCompactTabs ? 166 : 192;
+        for (int i = 0; i < tabsPerPage; i++) {
+            int j = i + categoryPages * tabsPerPage;
+            if (categories.size() > j) {
+                TabWidget tab;
+                tabs.add(tab = TabWidget.create(i, tabSize, bounds.x + bounds.width / 2 - Math.min(categories.size() - categoryPages * tabsPerPage, tabsPerPage) * tabSize / 2, bounds.y, 0, tabV, widget -> {
+                    Minecraft.getInstance().getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
+                    if (widget.getId() + categoryPages * tabsPerPage == selectedCategoryIndex)
+                        return false;
+                    ClientHelperImpl.getInstance().openRecipeViewingScreen(categoryMap, categories.get(widget.getId() + categoryPages * tabsPerPage).getIdentifier(), ingredientStackToNotice, resultStackToNotice);
+                    return true;
+                }));
+                tab.setRenderer(categories.get(j), categories.get(j).getIcon(), categories.get(j).getTitle(), tab.getId() + categoryPages * tabsPerPage == selectedCategoryIndex);
+            }
+        }
+        Optional<ButtonArea> supplier = CategoryRegistry.getInstance().get(getCurrentCategory()).getPlusButtonArea();
+        int recipeHeight = getSelectedCategory().getDisplayHeight();
+        List<Display> currentDisplayed = getCurrentDisplayed();
+        for (int i = 0; i < currentDisplayed.size(); i++) {
+            final Display display = currentDisplayed.get(i);
+            final Supplier<Display> displaySupplier = () -> display;
+            int displayWidth = getSelectedCategory().getDisplayWidth(displaySupplier.get());
+            final Rectangle displayBounds = new Rectangle(getBounds().getCenterX() - displayWidth / 2, getBounds().getCenterY() + 16 - recipeHeight * (getRecipesPerPage() + 1) / 2 - 2 * (getRecipesPerPage() + 1) + recipeHeight * i + 4 * i, displayWidth, recipeHeight);
+            List<Widget> setupDisplay = getSelectedCategory().setupDisplay(display, displayBounds);
+            transformIngredientNotice(setupDisplay, ingredientStackToNotice);
+            transformResultNotice(setupDisplay, resultStackToNotice);
+            recipeBounds.put(displayBounds, setupDisplay);
+            this.widgets.addAll(setupDisplay);
+            if (supplier.isPresent() && supplier.get().get(displayBounds) != null)
+                this.widgets.add(InternalWidgets.createAutoCraftingButtonWidget(displayBounds, supplier.get().get(displayBounds), new TextComponent(supplier.get().getButtonText()), displaySupplier, setupDisplay, getSelectedCategory()));
+        }
+        if (choosePageActivated)
+            choosePageWidget = new DefaultDisplayChoosePageWidget(this, page, getCurrentTotalPages());
+        else
+            choosePageWidget = null;
+        
+        workingStationsBaseWidget = null;
+        List<EntryIngredient> workstations = CategoryRegistry.getInstance().get(getCurrentCategory()).getWorkstations();
+        if (!workstations.isEmpty()) {
+            int hh = Mth.floor((bounds.height - 16) / 18f);
+            int actualHeight = Math.min(hh, workstations.size());
+            int innerWidth = Mth.ceil(workstations.size() / ((float) hh));
+            int xx = bounds.x - (8 + innerWidth * 16) + 6;
+            int yy = bounds.y + 16;
+            preWidgets.add(workingStationsBaseWidget = Widgets.createCategoryBase(new Rectangle(xx - 5, yy - 5, 15 + innerWidth * 16, 10 + actualHeight * 16)));
+            preWidgets.add(Widgets.createSlotBase(new Rectangle(xx - 1, yy - 1, innerWidth * 16 + 2, actualHeight * 16 + 2)));
+            int index = 0;
+            xx += (innerWidth - 1) * 16;
+            for (EntryIngredient workingStation : workstations) {
+                preWidgets.add(new WorkstationSlotWidget(xx, yy, workingStation));
+                index++;
+                yy += 16;
+                if (index >= hh) {
+                    index = 0;
+                    yy = bounds.y + 16;
+                    xx -= 16;
+                }
+            }
+        }
+        
+        children.addAll(tabs);
+        children.addAll(widgets);
+        children.addAll(preWidgets);
+    }
+    
+    public List<Widget> getWidgets() {
+        return widgets;
+    }
+    
+    public List<Display> getCurrentDisplayed() {
+        List<Display> list = Lists.newArrayList();
+        int recipesPerPage = getRecipesPerPage();
+        List<Display> displays = categoryMap.get(getSelectedCategory());
+        for (int i = 0; i <= recipesPerPage; i++) {
+            if (page * (recipesPerPage + 1) + i < displays.size()) {
+                list.add(displays.get(page * (recipesPerPage + 1) + i));
+            }
+        }
+        return list;
+    }
+    
+    public int getPage() {
+        return page;
+    }
+    
+    public int getCategoryPage() {
+        return categoryPages;
+    }
+    
+    private int getRecipesPerPage() {
+        DisplayCategory<Display> selectedCategory = getSelectedCategory();
+        if (selectedCategory.getFixedDisplaysPerPage() > 0)
+            return selectedCategory.getFixedDisplaysPerPage() - 1;
+        int height = selectedCategory.getDisplayHeight();
+        return Mth.clamp(Mth.floor(((double) this.bounds.getHeight() - 36) / ((double) height + 4)) - 1, 0, Math.min(ConfigObject.getInstance().getMaxRecipePerPage() - 1, selectedCategory.getMaximumDisplaysPerPage() - 1));
+    }
+    
+    @Override
+    public void render(PoseStack matrices, int mouseX, int mouseY, float delta) {
+        this.fillGradient(matrices, 0, 0, this.width, this.height, -1072689136, -804253680);
+        for (Widget widget : preWidgets) {
+            widget.render(matrices, mouseX, mouseY, delta);
+        }
+        PanelWidget.render(matrices, bounds, -1);
+        if (REIHelper.getInstance().isDarkThemeEnabled()) {
+            fill(matrices, bounds.x + 17, bounds.y + 5, bounds.x + bounds.width - 17, bounds.y + 17, 0xFF404040);
+            fill(matrices, bounds.x + 17, bounds.y + 19, bounds.x + bounds.width - 17, bounds.y + 30, 0xFF404040);
+        } else {
+            fill(matrices, bounds.x + 17, bounds.y + 5, bounds.x + bounds.width - 17, bounds.y + 17, 0xFF9E9E9E);
+            fill(matrices, bounds.x + 17, bounds.y + 19, bounds.x + bounds.width - 17, bounds.y + 31, 0xFF9E9E9E);
+        }
+        for (TabWidget tab : tabs) {
+            if (!tab.isSelected())
+                tab.render(matrices, mouseX, mouseY, delta);
+        }
+        super.render(matrices, mouseX, mouseY, delta);
+        for (Widget widget : widgets) {
+            widget.render(matrices, mouseX, mouseY, delta);
+        }
+        RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+        for (TabWidget tab : tabs) {
+            if (tab.isSelected())
+                tab.render(matrices, mouseX, mouseY, delta);
+        }
+        {
+            ModifierKeyCode export = ConfigObject.getInstance().getExportImageKeybind();
+            if (export.matchesCurrentKey() || export.matchesCurrentMouse()) {
+                for (Map.Entry<Rectangle, List<Widget>> entry : recipeBounds.entrySet()) {
+                    Rectangle bounds = entry.getKey();
+                    setBlitOffset(470);
+                    if (bounds.contains(mouseX, mouseY)) {
+                        fillGradient(matrices, bounds.x, bounds.y, bounds.getMaxX(), bounds.getMaxY(), 1744822402, 1744822402);
+                        Component text = new TranslatableComponent("text.rei.release_export", export.getLocalizedName().plainCopy().getString());
+                        MultiBufferSource.BufferSource immediate = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
+                        matrices.pushPose();
+                        matrices.translate(0.0D, 0.0D, 480);
+                        Matrix4f matrix4f = matrices.last().pose();
+                        font.drawInBatch(text.getVisualOrderText(), bounds.getCenterX() - font.width(text) / 2f, bounds.getCenterY() - 4.5f, 0xff000000, false, matrix4f, immediate, false, 0, 15728880);
+                        immediate.endBatch();
+                        matrices.popPose();
+                    } else {
+                        fillGradient(matrices, bounds.x, bounds.y, bounds.getMaxX(), bounds.getMaxY(), 1744830463, 1744830463);
+                    }
+                    setBlitOffset(0);
+                }
+            }
+        }
+        if (choosePageActivated) {
+            setBlitOffset(500);
+            this.fillGradient(matrices, 0, 0, this.width, this.height, -1072689136, -804253680);
+            setBlitOffset(0);
+            choosePageWidget.render(matrices, mouseX, mouseY, delta);
+        }
+    }
+    
+    @Override
+    public boolean keyReleased(int keyCode, int scanCode, int modifiers) {
+        ModifierKeyCode export = ConfigObject.getInstance().getExportImageKeybind();
+        if (export.matchesKey(keyCode, scanCode)) {
+            for (Map.Entry<Rectangle, List<Widget>> entry : recipeBounds.entrySet()) {
+                Rectangle bounds = entry.getKey();
+                if (bounds.contains(PointHelper.ofMouse())) {
+                    RecipeDisplayExporter.exportRecipeDisplay(bounds, entry.getValue());
+                    break;
+                }
+            }
+        }
+        return super.keyReleased(keyCode, scanCode, modifiers);
+    }
+    
+    public int getCurrentTotalPages() {
+        return getTotalPages(selectedCategoryIndex);
+    }
+    
+    public int getTotalPages(int categoryIndex) {
+        return Mth.ceil(categoryMap.get(categories.get(categoryIndex)).size() / (double) (getRecipesPerPage() + 1));
+    }
+    
+    @Override
+    public boo