"Small" Filter UI Refactor

src/main/java/gregtech/api/items/metaitem/MetaItem.java

@@ -22,7 +22,7 @@
 import gregtech.api.util.Mods;
 import gregtech.client.utils.ToolChargeBarRenderer;
 import gregtech.common.ConfigHolder;
-import gregtech.common.covers.filter.IFilter;
+import gregtech.common.covers.filter.BaseFilter;
 import gregtech.common.creativetab.GTCreativeTabs;
 
 import net.minecraft.client.Minecraft;
@@ -770,7 +770,7 @@ public MetaItem<T> getMetaItem() {
         private final List<IItemBehaviour> behaviours = new ArrayList<>();
         private IItemUseManager useManager;
         private ItemUIFactory uiManager;
-        private IFilter.Factory filterBehavior;
+        private BaseFilter filterBehavior;
         private IItemColorProvider colorProvider;
         private IItemDurabilityManager durabilityManager;
         private IEnchantabilityHelper enchantabilityHelper;
@@ -902,8 +902,8 @@ protected void addItemComponentsInternal(IItemComponent... stats) {
                 if (itemComponent instanceof ItemUIFactory) {
                     this.uiManager = (ItemUIFactory) itemComponent;
                 }
-                if (itemComponent instanceof IFilter.Factory) {
-                    this.filterBehavior = (IFilter.Factory) itemComponent;
+                if (itemComponent instanceof BaseFilter) {
+                    this.filterBehavior = (BaseFilter) itemComponent;
                 }
                 if (itemComponent instanceof IItemColorProvider) {
                     this.colorProvider = (IItemColorProvider) itemComponent;
@@ -954,7 +954,7 @@ public ItemUIFactory getUIManager() {
         }
 
         @Nullable
-        public IFilter.Factory getFilterFactory() {
+        public BaseFilter getFilterBehavior() {
             return filterBehavior;
         }
 

src/main/java/gregtech/common/covers/CoverFluidFilter.java

@@ -113,10 +113,7 @@ public FluidFilterMode getFilterMode() {
     }
 
     public @NotNull BaseFilter getFilter() {
-        var filter = getFilterContainer().getFilter();
-        if (filter == null) return BaseFilter.ERROR_FILTER;
-
-        return filter;
+        return getFilterContainer().getFilter();
     }
 
     public @NotNull BaseFilterContainer getFilterContainer() {
@@ -148,9 +145,9 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
         guiSyncManager.syncValue("filtering_mode", filteringMode);
         this.fluidFilterContainer.setMaxTransferSize(1);
 
-        return getFilter().createPanel(guiSyncManager)
+        return getFilter().getUI().createPanel(getPickItem(), guiSyncManager)
                 .size(176, 212).padding(7)
-                .child(CoverWithUI.createTitleRow(getFilterContainer().getFilterStack()))
+                .child(CoverWithUI.createTitleRow(getPickItem()))
                 .child(Flow.column().widthRel(1f).align(Alignment.TopLeft).top(22).coverChildrenHeight()
                         .child(new EnumRowBuilder<>(FluidFilterMode.class)
                                 .value(filteringMode)
@@ -176,7 +173,7 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
                                         .alignX(1f)))
                         .child(new Rectangle().setColor(UI_TEXT_COLOR).asWidget()
                                 .height(1).widthRel(0.95f).margin(0, 4))
-                        .child(getFilter().createWidgets(guiSyncManager)))
+                        .child(getFilter().getUI().createWidgets(getPickItem(), guiSyncManager)))
                 .child(SlotGroupWidget.playerInventory(false).bottom(7).left(7));
     }
 

src/main/java/gregtech/common/covers/CoverItemFilter.java

@@ -111,10 +111,7 @@ public ItemFilterMode getFilterMode() {
     }
 
     public @NotNull BaseFilter getFilter() {
-        var filter = getFilterContainer().getFilter();
-        if (filter == null) return BaseFilter.ERROR_FILTER;
-
-        return filter;
+        return getFilterContainer().getFilter();
     }
 
     public @NotNull BaseFilterContainer getFilterContainer() {
@@ -150,9 +147,10 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
 
         guiSyncManager.syncValue("filtering_mode", filteringMode);
 
-        return getFilter().createPanel(guiSyncManager)
+        return getFilter().getUI()
+                .createPanel(getPickItem(), guiSyncManager)
                 .size(176, 212).padding(7)
-                .child(CoverWithUI.createTitleRow(getFilterContainer().getFilterStack()).left(4))
+                .child(CoverWithUI.createTitleRow(getPickItem()).left(4))
                 .child(Flow.column().widthRel(1f).align(Alignment.TopLeft).top(22).coverChildrenHeight()
                         .child(new EnumRowBuilder<>(ItemFilterMode.class)
                                 .value(filteringMode)
@@ -178,7 +176,7 @@ public ModularPanel buildUI(SidedPosGuiData guiData, PanelSyncManager guiSyncMan
                                         .alignX(1f)))
                         .child(new Rectangle().setColor(UI_TEXT_COLOR).asWidget()
                                 .height(1).widthRel(0.95f).margin(0, 4))
-                        .child(getFilter().createWidgets(guiSyncManager).left(0)))
+                        .child(getFilter().getUI().createWidgets(getPickItem(), guiSyncManager).left(0)))
                 .child(SlotGroupWidget.playerInventory(false).bottom(7).left(7));
     }
 

src/main/java/gregtech/common/covers/filter/BaseFilter.java

@@ -1,84 +1,77 @@
 package gregtech.common.covers.filter;
 
 import gregtech.api.items.metaitem.MetaItem;
-import gregtech.api.mui.GTGuiTextures;
-import gregtech.api.mui.GTGuis;
+import gregtech.api.items.metaitem.stats.IItemComponent;
 import gregtech.api.util.IDirtyNotifiable;
 import gregtech.common.covers.filter.readers.BaseFilterReader;
+import gregtech.common.items.behaviors.filter.BaseFilterUIManager;
 
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.PacketBuffer;
 import net.minecraftforge.fluids.FluidStack;
 
-import com.cleanroommc.modularui.api.drawable.IKey;
-import com.cleanroommc.modularui.api.widget.IWidget;
-import com.cleanroommc.modularui.screen.ModularPanel;
-import com.cleanroommc.modularui.utils.Alignment;
-import com.cleanroommc.modularui.value.sync.BooleanSyncValue;
-import com.cleanroommc.modularui.value.sync.PanelSyncManager;
-import com.cleanroommc.modularui.widget.ParentWidget;
-import com.cleanroommc.modularui.widget.Widget;
-import com.cleanroommc.modularui.widgets.CycleButtonWidget;
 import org.jetbrains.annotations.NotNull;
 
-public abstract class BaseFilter implements IFilter {
+import java.util.Optional;
+
+public abstract class BaseFilter implements IItemComponent {
 
     public static final BaseFilter ERROR_FILTER = new BaseFilter() {
 
-        private final BaseFilterReader filterReader = new BaseFilterReader(ItemStack.EMPTY, 0);
+        private final BaseFilterReader reader = new BaseFilterReader(0);
 
         @Override
         public BaseFilterReader getFilterReader() {
-            return this.filterReader;
-        }
-
-        @Override
-        public @NotNull ModularPanel createPopupPanel(PanelSyncManager syncManager, String panelName) {
-            return GTGuis.createPopupPanel(panelName, 100, 100)
-                    .child(createWidgets(syncManager));
+            return reader;
         }
 
         @Override
-        public @NotNull ModularPanel createPanel(PanelSyncManager syncManager) {
-            return GTGuis.createPanel("error", 100, 100)
-                    .child(createWidgets(syncManager));
-        }
-
-        @Override
-        public @NotNull Widget<?> createWidgets(PanelSyncManager syncManager) {
-            return IKey.lang("INVALID FILTER").alignment(Alignment.Center).asWidget();
+        public BaseFilter copy() {
+            return this;
         }
 
         @Override
         public FilterType getType() {
-            return FilterType.ITEM;
+            return FilterType.ERROR;
         }
     };
-    protected IDirtyNotifiable dirtyNotifiable;
 
     public abstract BaseFilterReader getFilterReader();
 
+    public abstract BaseFilter copy();
+
+    public final void updateFilterReader(ItemStack stack) {
+        getFilterReader().readStack(stack);
+    }
+
+    public BaseFilterUIManager getUI() {
+        if (getContainerStack().getItem() instanceof MetaItem<?>metaItem) {
+            return Optional.ofNullable(metaItem.getItem(getContainerStack()))
+                    .map(o -> (BaseFilterUIManager) o.getUIManager())
+                    .orElseThrow(IllegalStateException::new);
+        }
+        throw new IllegalStateException();
+    }
+
     public final ItemStack getContainerStack() {
         return this.getFilterReader().getContainer();
     }
 
     public static @NotNull BaseFilter getFilterFromStack(ItemStack stack) {
         if (stack.getItem() instanceof MetaItem<?>metaItem) {
-            var metaValueItem = metaItem.getItem(stack);
-            var factory = metaValueItem == null ? null : metaValueItem.getFilterFactory();
-            if (factory != null)
-                return factory.create(stack);
+            return Optional.ofNullable(metaItem.getItem(stack))
+                    .map(MetaItem.MetaValueItem::getFilterBehavior)
+                    .map(BaseFilter::copy)
+                    .orElse(ERROR_FILTER);
         }
         return ERROR_FILTER;
     }
 
     public final void setBlacklistFilter(boolean blacklistFilter) {
         this.getFilterReader().setBlacklistFilter(blacklistFilter);
-        markDirty();
     }
 
-    @Override
     public final MatchResult match(Object toMatch) {
         if (toMatch instanceof ItemStack stack) {
             return matchItem(stack);
@@ -96,7 +89,6 @@ public MatchResult matchItem(ItemStack itemStack) {
         return MatchResult.NONE;
     }
 
-    @Override
     public final boolean test(Object toTest) {
         boolean b = false;
         if (toTest instanceof ItemStack stack) {
@@ -115,7 +107,6 @@ public boolean testItem(ItemStack toTest) {
         return false;
     }
 
-    @Override
     public final int getTransferLimit(Object o, int transferSize) {
         if (o instanceof ItemStack stack) {
             return getTransferLimit(stack, transferSize);
@@ -125,6 +116,10 @@ public final int getTransferLimit(Object o, int transferSize) {
         return 0;
     }
 
+    public int getTransferLimit(int slot, int transferSize) {
+        return transferSize;
+    }
+
     public int getTransferLimit(FluidStack stack, int transferSize) {
         return 0;
     }
@@ -137,18 +132,6 @@ public final boolean isBlacklistFilter() {
         return getFilterReader().isBlacklistFilter();
     }
 
-    public IWidget createBlacklistUI() {
-        return new ParentWidget<>().coverChildren()
-                .child(new CycleButtonWidget()
-                        .value(new BooleanSyncValue(
-                                this::isBlacklistFilter,
-                                this::setBlacklistFilter))
-                        .stateBackground(0, GTGuiTextures.BUTTON_BLACKLIST[0])
-                        .stateBackground(1, GTGuiTextures.BUTTON_BLACKLIST[1])
-                        .addTooltip(0, IKey.lang("cover.filter.blacklist.disabled"))
-                        .addTooltip(1, IKey.lang("cover.filter.blacklist.enabled")));
-    }
-
     public final int getMaxTransferSize() {
         return this.getFilterReader().getMaxTransferRate();
     }
@@ -162,22 +145,34 @@ public boolean showGlobalTransferLimitSlider() {
     }
 
     public final void setDirtyNotifiable(IDirtyNotifiable dirtyNotifiable) {
-        this.dirtyNotifiable = dirtyNotifiable;
         this.getFilterReader().setDirtyNotifiable(dirtyNotifiable);
     }
 
-    public final void markDirty() {
-        if (dirtyNotifiable != null) {
-            dirtyNotifiable.markAsDirty();
-        }
-    }
-
     public void readFromNBT(NBTTagCompound tag) {
         this.getFilterReader().deserializeNBT(tag);
-        markDirty();
     }
 
     public void writeInitialSyncData(PacketBuffer packetBuffer) {}
 
     public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {}
+
+    public abstract FilterType getType();
+
+    public boolean isItem() {
+        return getType() == FilterType.ITEM;
+    }
+
+    public boolean isFluid() {
+        return getType() == FilterType.FLUID;
+    }
+
+    public boolean isError() {
+        return getType() == FilterType.ERROR;
+    }
+
+    public enum FilterType {
+        ITEM,
+        FLUID,
+        ERROR
+    }
 }

src/main/java/gregtech/common/covers/filter/BaseFilterContainer.java

@@ -33,7 +33,7 @@ public abstract class BaseFilterContainer extends ItemStackHandler {
 
     private int maxTransferSize = 1;
     private int transferSize;
-    private @Nullable BaseFilter currentFilter;
+    private @NotNull BaseFilter currentFilter = BaseFilter.ERROR_FILTER;
     private @Nullable Runnable onFilterInstanceChange;
     private final IDirtyNotifiable dirtyNotifiable;
 
@@ -85,7 +85,7 @@ public void setStackInSlot(int slot, @NotNull ItemStack stack) {
         if (ItemStack.areItemStacksEqual(stack, getFilterStack()))
             return;
 
-        setFilter(BaseFilter.getFilterFromStack(stack));
+        setFilter(stack);
 
         super.setStackInSlot(slot, stack);
     }
@@ -103,15 +103,15 @@ public boolean isItemValid(int slot, @NotNull ItemStack stack) {
     public @NotNull ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
         if (!isItemValid(stack)) return stack;
         var remainder = super.insertItem(slot, stack, simulate);
-        if (!simulate) setFilter(BaseFilter.getFilterFromStack(stack));
+        if (!simulate) setFilter(stack);
         return remainder;
     }
 
     @Override
     public @NotNull ItemStack extractItem(int slot, int amount, boolean simulate) {
         var extracted = super.extractItem(slot, amount, simulate);
         if (!extracted.isEmpty()) {
-            setFilter(null);
+            clearFilter();
         }
         return extracted;
     }
@@ -132,15 +132,26 @@ public void setMaxTransferSize(int maxTransferSize) {
     }
 
     public final boolean hasFilter() {
-        return currentFilter != null;
+        return !currentFilter.isError();
     }
 
-    public final @Nullable BaseFilter getFilter() {
+    public final @NotNull BaseFilter getFilter() {
         return currentFilter;
     }
 
-    public final void setFilter(@Nullable BaseFilter newFilter) {
-        this.currentFilter = BaseFilter.ERROR_FILTER == newFilter ? null : newFilter;
+    public final void clearFilter() {
+        setFilter(BaseFilter.ERROR_FILTER);
+    }
+
+    public final void setFilter(ItemStack stack) {
+        setFilter(BaseFilter.getFilterFromStack(stack));
+        if (hasFilter()) {
+            getFilter().updateFilterReader(stack);
+        }
+    }
+
+    public final void setFilter(@NotNull BaseFilter newFilter) {
+        this.currentFilter = newFilter;
         if (hasFilter()) {
             this.currentFilter.setDirtyNotifiable(this.dirtyNotifiable);
             this.currentFilter.setMaxTransferSize(this.maxTransferSize);
@@ -219,11 +230,15 @@ public IWidget initUI(GuiData data, PanelSyncManager manager) {
         AtomicReference<IPanelHandler> filterPanel = new AtomicReference<>();
         AtomicReference<ItemStack> oldStack = new AtomicReference<>(getFilterStack());
         AtomicInteger counter = new AtomicInteger();
-        if (hasFilter()) filterPanel.set(getFilter().createPanelHandler(manager, counter.getAndIncrement()));
+        if (hasFilter()) {
+            filterPanel.set(getFilter().getUI()
+                    .createPanelHandler(getFilterStack(), manager, counter.getAndIncrement()));
+        }
         manager.registerSyncedAction("update_filter_panel", packet -> {
             if (hasFilter()) {
                 // make new panel handler only when we have a filter
-                filterPanel.set(getFilter().createPanelHandler(manager, counter.getAndIncrement()));
+                filterPanel.set(getFilter().getUI()
+                        .createPanelHandler(getFilterStack(), manager, counter.getAndIncrement()));
             }
         });
         ItemStackHashStrategy strategy = ItemStackHashStrategy.comparingItemDamageCount();