diff --git a/src/main/java/codechicken/nei/ItemList.java b/src/main/java/codechicken/nei/ItemList.java index 868df182..14e3575f 100644 --- a/src/main/java/codechicken/nei/ItemList.java +++ b/src/main/java/codechicken/nei/ItemList.java @@ -2,41 +2,22 @@ package codechicken.nei; import java.util.ArrayList; import java.util.Arrays; -import java.util.Comparator; -import java.util.HashMap; -import java.util.HashSet; import java.util.LinkedList; import java.util.List; -import java.util.Map; -import java.util.concurrent.ExecutionException; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinWorkerThread; import java.util.regex.Pattern; -import java.util.stream.Collectors; -import java.util.stream.StreamSupport; -import net.minecraft.client.Minecraft; -import net.minecraft.init.Blocks; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; -import net.minecraft.util.IIcon; -import net.minecraftforge.fluids.IFluidContainerItem; -import com.google.common.base.Throwables; import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ListMultimap; -import codechicken.nei.ThreadOperationTimer.TimeoutException; import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter.ItemFilterProvider; -import codechicken.nei.api.ItemInfo; -import codechicken.nei.recipe.InformationHandler; -import codechicken.nei.recipe.RecipeHandlerRef; -import codechicken.nei.recipe.RepairRecipeHandler; -import codechicken.nei.search.TooltipFilter; import codechicken.nei.util.ItemUntranslator; -import cpw.mods.fml.common.FMLLog; public class ItemList { @@ -54,9 +35,6 @@ public class ItemList { public static final List itemFilterers = new LinkedList<>(); public static final List loadCallbacks = new LinkedList<>(); - private static final HashSet erroredItems = new HashSet<>(); - private static final HashSet stackTraces = new HashSet<>(); - private static Map ordering = new HashMap<>(); /** * Unlike {@link LayoutManager#itemsLoaded}, this indicates whether item loading is actually finished or not. */ @@ -219,237 +197,6 @@ public class ItemList { return filters; } - public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading") { - - private void damageSearch(Item item, List permutations) { - HashSet damageIconSet = new HashSet<>(); - for (int damage = 0; damage < 16; damage++) try { - ItemStack itemstack = new ItemStack(item, 1, damage); - IIcon icon = item.getIconIndex(itemstack); - String name = getTooltip(itemstack); - String s = name + "@" + (icon == null ? 0 : icon.hashCode()); - if (damageIconSet.add(s)) { - permutations.add(itemstack); - } - } catch (TimeoutException t) { - throw t; - } catch (Throwable t) { - NEIServerUtils.logOnce( - t, - stackTraces, - "Ommiting " + item + ":" + damage + " " + item.getClass().getSimpleName(), - item.toString()); - } - } - - private String getTooltip(ItemStack stack) { - try { - return String.join("\n", stack.getTooltip(Minecraft.getMinecraft().thePlayer, false)); - } catch (Throwable ignored) {} - - return ""; - } - - private void updateOrdering(List items) { - final Map newOrdering = new HashMap<>(); - - if (!CollapsibleItems.isEmpty()) { - final HashMap groups = new HashMap<>(); - int orderIndex = 0; - - for (ItemStack stack : items) { - final int groupIndex = CollapsibleItems.getGroupIndex(stack); - - if (groupIndex == -1) { - newOrdering.put(stack, orderIndex++); - } else { - - if (!groups.containsKey(groupIndex)) { - groups.put(groupIndex, orderIndex++); - } - - newOrdering.put(stack, groups.get(groupIndex)); - } - } - } else { - int orderIndex = 0; - - for (ItemStack stack : items) { - newOrdering.put(stack, orderIndex++); - } - } - - ItemList.ordering = newOrdering; - } - - private List getPermutations(Item item) { - final List permutations = new LinkedList<>(ItemInfo.itemOverrides.get(item)); - - if (permutations.isEmpty()) { - item.getSubItems(item, null, permutations); - } - - if (permutations.isEmpty()) { - damageSearch(item, permutations); - } - - permutations.addAll(ItemInfo.itemVariants.get(item)); - - return permutations.stream() - .filter( - stack -> stack.getItem() != null && stack.getItem().delegate.name() != null - && !ItemInfo.isHidden(stack)) - .collect(Collectors.toList()); - } - - private void runChecked(ItemStack stack, Runnable action, String reason) { - int hashOld = 0; - if (stack.hasTagCompound()) { - hashOld = stack.stackTagCompound.hashCode(); - } - - action.run(); - - if (stack.hasTagCompound() && hashOld != stack.stackTagCompound.hashCode()) { - FMLLog.warning( - "NEI: Forced tag update with reason (" + reason - + ") for " - + stack - + "(" - + stack.getItem() - + ")"); - } - } - - private void forceTagCompoundInitialization(ItemStack stack) { - Item item = stack.getItem(); - if (item == null) { - return; - } - if (item instanceof IFluidContainerItem) { - IFluidContainerItem fluidItem = (IFluidContainerItem) item; - runChecked(stack, () -> fluidItem.getFluid(stack), "getFluid"); - } - runChecked(stack, () -> item.isDamaged(stack), "isDamaged"); - runChecked(stack, () -> item.getDamage(stack), "getDamage"); - runChecked(stack, () -> item.showDurabilityBar(stack), "showDurabilityBar"); - runChecked(stack, () -> item.getAttributeModifiers(stack), "getAttributeModifiers"); - runChecked(stack, () -> item.getDurabilityForDisplay(stack), "getDurabilityForDisplay"); - runChecked(stack, () -> item.getItemStackLimit(stack), "getItemStackLimit"); - runChecked(stack, () -> item.getToolClasses(stack), "getToolClasses"); - runChecked(stack, () -> item.getUnlocalizedNameInefficiently(stack), "getUnlocalizedNameInefficiently"); - runChecked(stack, () -> item.hasEffect(stack), "hasEffect"); - runChecked(stack, () -> item.getDigSpeed(stack, Blocks.stone, 0), "getDigSpeed"); - - /* - * unused... for now runChecked(stack, () -> GameRegistry.getFuelValue(stack), "getFuelValue"); - * runChecked(stack, () -> item.getUnlocalizedName(stack), "getUnlocalizedName"); runChecked(stack, () -> - * item.doesContainerItemLeaveCraftingGrid(stack), "doesContainerItemLeaveCraftingGrid"); runChecked(stack, - * () -> item.getItemUseAction(stack), "getItemUseAction"); runChecked(stack, () -> - * item.getMaxItemUseDuration(stack), "getMaxItemUseDuration"); runChecked(stack, () -> - * item.getPotionEffect(stack), "getPotionEffect"); runChecked(stack, () -> item.isPotionIngredient(stack), - * "isPotionIngredient"); runChecked(stack, () -> item.getRarity(stack), "getRarity"); runChecked(stack, () - * -> item.hasCustomEntity(stack), "hasCustomEntity"); runChecked(stack, () -> - * item.getSmeltingExperience(stack), "getSmeltingExperience"); runChecked(stack, () -> - * item.getMaxDamage(stack), "getMaxDamage"); runChecked(stack, () -> item.getDamage(stack), "getDamage"); - * runChecked(stack, stack::isItemDamaged, "isItemDamaged"); runChecked(stack, () -> item.hasEffect(stack, - * 0), "hasEffect"); runChecked(stack, () -> item.getItemEnchantability(stack), "getItemEnchantability"); - * runChecked(stack, () -> item.isBeaconPayment(stack), "isBeaconPayment"); runChecked(stack, () -> - * item.getDamage(stack), "getDamage"); runChecked(stack, () -> item.getDamage(stack), "getDamage"); - * runChecked(stack, () -> item.getDamage(stack), "getDamage"); - */ - } - - // Generate itemlist, permutations, orders, collapsibleitems, and informationhandler stacks - @Override - @SuppressWarnings("unchecked") - public void execute() { - if (!NEIClientConfig.isEnabled() || NEIClientUtils.mc().thePlayer == null) return; - - ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout()); - LayoutManager.itemsLoaded = true; - loadFinished = false; - - SearchField.searchParser.clearCache(); - ItemSorter.instance.ordering.clear(); - CollapsibleItems.clearCache(); - TooltipFilter.clearCache(); - InformationHandler.clearCache(); - - List items = new ArrayList<>(); - ListMultimap itemMap = ArrayListMultimap.create(); - ItemStackSet unique = new ItemStackSet(); - - StreamSupport.stream(((Iterable) Item.itemRegistry).spliterator(), true).forEach(item -> { - if (item == null || item.delegate.name() == null || erroredItems.contains(item)) return; - - try { - timer.reset(item); - List permutations = getPermutations(item); - timer.reset(); - - for (ItemStack stack : permutations) { - if (!unique.contains(stack)) { - - synchronized (unique) { - unique.add(stack); - } - - synchronized (items) { - items.add(stack); - } - - forceTagCompoundInitialization(stack); - - CollapsibleItems.putItem(stack); - TooltipFilter.getSearchTooltip(stack); - InformationHandler.populateStacks(stack); - } - } - - synchronized (itemMap) { - itemMap.putAll(item, permutations); - } - } catch (Throwable t) { - NEIServerConfig.logger.error( - "Removing item: {} from list.\n{}: {}", - item, - t.getMessage(), - Throwables.getStackTraceAsString(t)); - erroredItems.add(item); - } - - }); - - int index = 0; - for (Item item : (Iterable) Item.itemRegistry) { - for (ItemStack stack : itemMap.get(item)) { - ItemSorter.instance.ordering.put(stack, index++); - } - } - - if (interrupted()) return; - ItemSorter.sort(items); - - if (interrupted()) return; - ItemList.items = items; - ItemList.itemMap = itemMap; - for (ItemsLoadedCallback callback : loadCallbacks) callback.itemsLoaded(); - - if (interrupted()) return; - updateOrdering(ItemList.items); - - loadFinished = true; - - RepairRecipeHandler.findRepairRecipesOnceParallel(); - RecipeHandlerRef.clearCache(); - FavoriteRecipes.reload(); - SubsetWidget.updateHiddenItems(); - ItemPanels.bookmarkPanel.load(); - updateFilter.restart(); - } - }; - public static ForkJoinPool forkJoinPool; static { @@ -469,35 +216,12 @@ public class ItemList { forkJoinPool = new ForkJoinPool(poolSize, factory, null, false); } - public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering") { + // The item list pipeline lives in ItemListLoader; these references are kept for backward compatibility. + public static final RestartableTask loadItems = ItemListLoader.loadItems; - @Override - public void execute() { + public static final RestartableTask refreshItems = ItemListLoader.refreshItems; - if (!loadFinished) return; - ItemFilter filter = getItemListFilter(); - ArrayList filtered; - - try { - filtered = ItemList.forkJoinPool.submit( - () -> items.parallelStream().filter(filter::matches) - .collect(Collectors.toCollection(ArrayList::new))) - .get(); - } catch (InterruptedException | ExecutionException e) { - filtered = new ArrayList<>(); - e.printStackTrace(); - stop(); - } - - if (interrupted()) return; - - filtered.sort(Comparator.comparingInt(ItemList.ordering::get)); - - if (interrupted()) return; - - ItemPanel.updateItemList(filtered); - } - }; + public static final RestartableTask updateFilter = ItemListLoader.updateFilter; /** * @deprecated Use updateFilter.restart() diff --git a/src/main/java/codechicken/nei/ItemListLoader.java b/src/main/java/codechicken/nei/ItemListLoader.java new file mode 100644 index 00000000..f5a0b80d --- /dev/null +++ b/src/main/java/codechicken/nei/ItemListLoader.java @@ -0,0 +1,376 @@ +package codechicken.nei; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.stream.Collectors; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.IFluidContainerItem; + +import com.google.common.base.Throwables; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; + +import codechicken.nei.ItemList.ItemsLoadedCallback; +import codechicken.nei.ThreadOperationTimer.TimeoutException; +import codechicken.nei.api.ItemFilter; +import codechicken.nei.api.ItemInfo; +import codechicken.nei.recipe.InformationHandler; +import codechicken.nei.recipe.RecipeHandlerRef; +import codechicken.nei.recipe.RepairRecipeHandler; +import codechicken.nei.search.TooltipFilter; +import cpw.mods.fml.common.FMLLog; + +public class ItemListLoader { + + private static final HashSet erroredItems = new HashSet<>(); + private static final HashSet stackTraces = new HashSet<>(); + private static Map ordering = new HashMap<>(); + + private ItemListLoader() {} + + private static void damageSearch(Item item, List permutations) { + final Set damageIconSet = new HashSet<>(); + final EntityPlayer player = Minecraft.getMinecraft().thePlayer; + + for (int damage = 0; damage < 16; damage++) { + try { + final ItemStack itemstack = new ItemStack(item, 1, damage); + final IIcon icon = item.getIconIndex(itemstack); + final String key = itemstack.getDisplayName() + "@" + + (icon == null ? 0 : icon.hashCode()) + + "@" + + getInformation(itemstack, player); + + if (damageIconSet.add(key)) { + permutations.add(itemstack); + } + } catch (TimeoutException t) { + throw t; + } catch (Throwable t) { + NEIServerUtils.logOnce( + t, + stackTraces, + "Ommiting " + item + ":" + damage + " " + item.getClass().getSimpleName(), + item.toString()); + } + } + } + + private static String getInformation(ItemStack stack, EntityPlayer player) { + try { + final List tooltip = new ArrayList<>(); + stack.getItem().addInformation(stack, player, tooltip, false); + return String.join("\n", tooltip); + } catch (Throwable ignored) {} + + return ""; + } + + private static void updateOrdering(List items) { + final Map newOrdering = new HashMap<>(); + + if (!CollapsibleItems.isEmpty()) { + final HashMap groups = new HashMap<>(); + int orderIndex = 0; + + for (ItemStack stack : items) { + final int groupIndex = CollapsibleItems.getGroupIndex(stack); + + if (groupIndex == -1) { + newOrdering.put(stack, orderIndex++); + } else { + + if (!groups.containsKey(groupIndex)) { + groups.put(groupIndex, orderIndex++); + } + + newOrdering.put(stack, groups.get(groupIndex)); + } + } + } else { + int orderIndex = 0; + + for (ItemStack stack : items) { + newOrdering.put(stack, orderIndex++); + } + } + + ordering = newOrdering; + } + + private static List getPermutations(Item item) { + final List permutations = new LinkedList<>(ItemInfo.itemOverrides.get(item)); + + if (permutations.isEmpty()) { + item.getSubItems(item, null, permutations); + } + + if (permutations.isEmpty()) { + damageSearch(item, permutations); + } + + permutations.addAll(ItemInfo.itemVariants.get(item)); + + return permutations.stream() + .filter( + stack -> stack.getItem() != null && stack.getItem().delegate.name() != null + && !ItemInfo.isHidden(stack)) + .collect(Collectors.toList()); + } + + private static void runChecked(ItemStack stack, Runnable action, String reason) { + int hashOld = 0; + if (stack.hasTagCompound()) { + hashOld = stack.stackTagCompound.hashCode(); + } + + action.run(); + + if (stack.hasTagCompound() && hashOld != stack.stackTagCompound.hashCode()) { + FMLLog.warning( + "NEI: Forced tag update with reason (" + reason + ") for " + stack + "(" + stack.getItem() + ")"); + } + } + + private static void forceTagCompoundInitialization(ItemStack stack) { + Item item = stack.getItem(); + if (item == null) { + return; + } + if (item instanceof IFluidContainerItem) { + IFluidContainerItem fluidItem = (IFluidContainerItem) item; + runChecked(stack, () -> fluidItem.getFluid(stack), "getFluid"); + } + runChecked(stack, () -> item.isDamaged(stack), "isDamaged"); + runChecked(stack, () -> item.getDamage(stack), "getDamage"); + runChecked(stack, () -> item.showDurabilityBar(stack), "showDurabilityBar"); + runChecked(stack, () -> item.getAttributeModifiers(stack), "getAttributeModifiers"); + runChecked(stack, () -> item.getDurabilityForDisplay(stack), "getDurabilityForDisplay"); + runChecked(stack, () -> item.getItemStackLimit(stack), "getItemStackLimit"); + runChecked(stack, () -> item.getToolClasses(stack), "getToolClasses"); + runChecked(stack, () -> item.getUnlocalizedNameInefficiently(stack), "getUnlocalizedNameInefficiently"); + runChecked(stack, () -> item.hasEffect(stack), "hasEffect"); + runChecked(stack, () -> item.getDigSpeed(stack, Blocks.stone, 0), "getDigSpeed"); + + /* + * unused... for now runChecked(stack, () -> GameRegistry.getFuelValue(stack), "getFuelValue"); + * runChecked(stack, () -> item.getUnlocalizedName(stack), "getUnlocalizedName"); runChecked(stack, () -> + * item.doesContainerItemLeaveCraftingGrid(stack), "doesContainerItemLeaveCraftingGrid"); runChecked(stack, () + * -> item.getItemUseAction(stack), "getItemUseAction"); runChecked(stack, () -> + * item.getMaxItemUseDuration(stack), "getMaxItemUseDuration"); runChecked(stack, () -> + * item.getPotionEffect(stack), "getPotionEffect"); runChecked(stack, () -> item.isPotionIngredient(stack), + * "isPotionIngredient"); runChecked(stack, () -> item.getRarity(stack), "getRarity"); runChecked(stack, () -> + * item.hasCustomEntity(stack), "hasCustomEntity"); runChecked(stack, () -> item.getSmeltingExperience(stack), + * "getSmeltingExperience"); runChecked(stack, () -> item.getMaxDamage(stack), "getMaxDamage"); + * runChecked(stack, () -> item.getDamage(stack), "getDamage"); runChecked(stack, stack::isItemDamaged, + * "isItemDamaged"); runChecked(stack, () -> item.hasEffect(stack, 0), "hasEffect"); runChecked(stack, () -> + * item.getItemEnchantability(stack), "getItemEnchantability"); runChecked(stack, () -> + * item.isBeaconPayment(stack), "isBeaconPayment"); runChecked(stack, () -> item.getDamage(stack), "getDamage"); + * runChecked(stack, () -> item.getDamage(stack), "getDamage"); runChecked(stack, () -> item.getDamage(stack), + * "getDamage"); + */ + } + + @SuppressWarnings("unchecked") + private static List gatherItems(ThreadOperationTimer timer) { + ItemSorter.instance.ordering.clear(); + + List items = new ArrayList<>(); + ListMultimap itemMap = ArrayListMultimap.create(); + ItemStackSet unique = new ItemStackSet(); + + final List registryItems = new ArrayList<>(); + for (Item item : (Iterable) Item.itemRegistry) registryItems.add(item); + + registryItems.parallelStream().forEach(item -> { + if (item == null || item.delegate.name() == null || erroredItems.contains(item)) return; + + try { + timer.reset(item); + List permutations = getPermutations(item); + timer.reset(); + + synchronized (itemMap) { + itemMap.putAll(item, permutations); + } + } catch (Throwable t) { + NEIServerConfig.logger.error( + "Removing item: {} from list.\n{}: {}", + item, + t.getMessage(), + Throwables.getStackTraceAsString(t)); + erroredItems.add(item); + } + + }); + + int index = 0; + for (Item item : (Iterable) Item.itemRegistry) { + for (ItemStack stack : itemMap.get(item)) { + ItemSorter.instance.ordering.put(stack, index++); + + if (!unique.contains(stack)) { + unique.add(stack); + items.add(stack); + } + } + } + + ItemList.itemMap = itemMap; + + return items; + } + + private static void buildItemCaches(List items) { + SearchField.searchParser.clearCache(); + TooltipFilter.clearCache(); + InformationHandler.clearCache(); + + items.parallelStream().forEach(stack -> { + try { + forceTagCompoundInitialization(stack); + InformationHandler.populateStacks(stack); + } catch (Throwable t) { + NEIServerConfig.logger.error( + "Failed to build caches for: {}\n{}: {}", + stack, + t.getMessage(), + Throwables.getStackTraceAsString(t)); + } + }); + } + + private static void indexCollapsibleItems(List items) { + CollapsibleItems.clearCache(); + items.parallelStream().forEach(CollapsibleItems::putItem); + } + + public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading") { + + @Override + public void execute() { + if (!NEIClientConfig.isEnabled() || NEIClientUtils.mc().thePlayer == null) return; + + final ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout()); + LayoutManager.itemsLoaded = true; + ItemList.loadFinished = false; + warmTooltips.stop(); + + List items = gatherItems(timer); + + if (interrupted()) return; + buildItemCaches(items); + indexCollapsibleItems(items); + + if (interrupted()) return; + ItemSorter.sort(items); + + if (interrupted()) return; + ItemList.items = items; + for (ItemsLoadedCallback callback : ItemList.loadCallbacks) callback.itemsLoaded(); + + if (interrupted()) return; + updateOrdering(ItemList.items); + + ItemList.loadFinished = true; + + RepairRecipeHandler.findRepairRecipesOnceParallel(); + RecipeHandlerRef.clearCache(); + FavoriteRecipes.reload(); + SubsetWidget.updateHiddenItems(); + updateFilter.restart(); + warmTooltips.restart(); + loadBookmarks.restart(); + } + }; + + public static final RestartableTask warmTooltips = new RestartableTask("NEI Tooltip Caching") { + + @Override + public void execute() { + if (!ItemList.loadFinished) return; + // Use the common pool, not ItemList.forkJoinPool, so it does not queue behind updateFilter. + ItemList.items.parallelStream().forEach(stack -> { + if (interrupted()) return; + try { + TooltipFilter.getSearchTooltip(stack); + } catch (Throwable ignored) {} + }); + } + }; + + public static final RestartableTask loadBookmarks = new RestartableTask("NEI Bookmark Loading") { + + @Override + public void execute() { + ItemPanels.bookmarkPanel.load(); + } + }; + + public static final RestartableTask refreshItems = new RestartableTask("NEI Item Reordering") { + + @Override + public void execute() { + if (!ItemList.loadFinished) return; + + final List items = new ArrayList<>(ItemList.items); + + indexCollapsibleItems(items); + + if (interrupted()) return; + ItemSorter.sort(items); + + if (interrupted()) return; + ItemList.items = items; + updateOrdering(ItemList.items); + + FavoriteRecipes.reload(); + SubsetWidget.updateHiddenItems(); + updateFilter.restart(); + loadBookmarks.restart(); + } + }; + + public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering") { + + @Override + public void execute() { + + if (!ItemList.loadFinished) return; + ItemFilter filter = ItemList.getItemListFilter(); + ArrayList filtered; + + try { + filtered = ItemList.forkJoinPool.submit( + () -> ItemList.items.parallelStream().filter(filter::matches) + .collect(Collectors.toCollection(ArrayList::new))) + .get(); + } catch (InterruptedException | ExecutionException e) { + filtered = new ArrayList<>(); + e.printStackTrace(); + stop(); + } + + if (interrupted()) return; + + filtered.sort(Comparator.comparingInt(ordering::get)); + + if (interrupted()) return; + + ItemPanel.updateItemList(filtered); + } + }; +} diff --git a/src/main/java/codechicken/nei/NEIClientConfig.java b/src/main/java/codechicken/nei/NEIClientConfig.java index a82d5ec3..8250fe78 100644 --- a/src/main/java/codechicken/nei/NEIClientConfig.java +++ b/src/main/java/codechicken/nei/NEIClientConfig.java @@ -311,7 +311,7 @@ public class NEIClientConfig { super.onClick(button); CollapsibleItems.saveStates(); CollapsibleItems.load(); - LayoutManager.markItemsDirty(); + ItemList.refreshItems.restart(); return true; } }); @@ -1025,7 +1025,11 @@ public class NEIClientConfig { }.start(); } else { SubsetWidget.loadHidden(); - ItemList.loadItems.restart(); + if (ItemList.loadFinished) { + ItemList.refreshItems.restart(); + } else { + ItemList.loadItems.restart(); + } } } diff --git a/src/main/java/codechicken/nei/PresetsList.java b/src/main/java/codechicken/nei/PresetsList.java index 6a01d55f..c18d0895 100644 --- a/src/main/java/codechicken/nei/PresetsList.java +++ b/src/main/java/codechicken/nei/PresetsList.java @@ -251,7 +251,7 @@ public class PresetsList { updateSubsets(); CollapsibleItems.saveStates(); CollapsibleItems.load(); - LayoutManager.markItemsDirty(); + ItemList.refreshItems.restart(); } private static void updateSubsets() { diff --git a/src/main/java/codechicken/nei/config/GuiItemSorter.java b/src/main/java/codechicken/nei/config/GuiItemSorter.java index 0dc42170..fb1041df 100644 --- a/src/main/java/codechicken/nei/config/GuiItemSorter.java +++ b/src/main/java/codechicken/nei/config/GuiItemSorter.java @@ -14,6 +14,7 @@ import org.lwjgl.opengl.GL11; import codechicken.lib.config.ConfigTag; import codechicken.lib.math.MathHelper; +import codechicken.nei.ItemList; import codechicken.nei.ItemSorter; import codechicken.nei.ItemSorter.SortEntry; import codechicken.nei.LayoutManager; @@ -121,11 +122,12 @@ public class GuiItemSorter extends GuiOptionPane { list.add(nslot, dragged.e); getTag(opt.configName()).setValue(ItemSorter.getSaveString(list)); - LayoutManager.markItemsDirty(); if (opt.activeTag() == getTag(opt.configName())) { ItemSorter.list = new ArrayList<>(list); } + + ItemList.refreshItems.restart(); } } }