mirror of
https://github.com/GTNewHorizons/NotEnoughItems.git
synced 2026-11-12 00:17:51 +00:00
1184 lines
42 KiB
Java
1184 lines
42 KiB
Java
package codechicken.nei;
|
|
|
|
import static codechicken.lib.gui.GuiDraw.drawRect;
|
|
import static codechicken.lib.gui.GuiDraw.getMousePosition;
|
|
import static codechicken.nei.NEIClientUtils.getGuiContainer;
|
|
import static codechicken.nei.NEIClientUtils.translate;
|
|
|
|
import java.awt.Point;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.WeakHashMap;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import net.minecraft.client.gui.FontRenderer;
|
|
import net.minecraft.client.gui.inventory.GuiContainer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
|
|
import org.apache.commons.io.IOUtils;
|
|
import org.lwjgl.opengl.GL11;
|
|
|
|
import com.google.gson.JsonObject;
|
|
import com.google.gson.JsonParser;
|
|
import com.google.gson.JsonPrimitive;
|
|
import com.google.gson.JsonSyntaxException;
|
|
|
|
import codechicken.core.CommonUtils;
|
|
import codechicken.lib.vec.Rectangle4i;
|
|
import codechicken.nei.ItemPanel.ItemPanelSlot;
|
|
import codechicken.nei.api.IBookmarkContainerHandler;
|
|
import codechicken.nei.guihook.GuiContainerManager;
|
|
import codechicken.nei.recipe.BookmarkRecipeId;
|
|
import codechicken.nei.recipe.StackInfo;
|
|
import codechicken.nei.util.NBTJson;
|
|
import codechicken.nei.util.ReadableNumberConverter;
|
|
|
|
public class BookmarkPanel extends PanelWidget {
|
|
|
|
protected File bookmarkFile;
|
|
protected boolean bookmarksIsLoaded = false;
|
|
public int sortedStackIndex = -1;
|
|
public int sortedNamespaceIndex = -1;
|
|
|
|
public Button namespacePrev;
|
|
public Button namespaceNext;
|
|
public Button pullBookmarkedItems;
|
|
public Label namespaceLabel;
|
|
|
|
protected List<BookmarkGrid> namespaces = new ArrayList<>();
|
|
protected int activeNamespaceIndex = 0;
|
|
|
|
protected static class BookmarkStackMeta {
|
|
|
|
public int factor;
|
|
public BookmarkRecipeId recipeId;
|
|
public boolean ingredient = false;
|
|
public boolean fluidDisplay = false;
|
|
|
|
public BookmarkStackMeta(BookmarkRecipeId recipeId, int count, boolean ingredient, boolean fluidDisplay) {
|
|
this.recipeId = recipeId;
|
|
this.factor = count;
|
|
this.ingredient = ingredient;
|
|
this.fluidDisplay = fluidDisplay;
|
|
}
|
|
}
|
|
|
|
public static enum BookmarkViewMode {
|
|
DEFAULT,
|
|
TODO_LIST
|
|
}
|
|
|
|
public static class BookmarkGrid extends ItemsGrid {
|
|
|
|
protected static final float SCALE_SPEED = 0.1f;
|
|
|
|
protected List<List<Integer>> gridMask;
|
|
protected List<BookmarkStackMeta> metadata = new ArrayList<>();
|
|
protected WeakHashMap<ItemStack, Float> animation = new WeakHashMap<>();
|
|
|
|
protected BookmarkViewMode viewMode = BookmarkViewMode.DEFAULT;
|
|
protected boolean[] todoSpaces;
|
|
protected int todoItemsCount = 0;
|
|
|
|
public BookmarkGrid() {
|
|
this.setShowRecipeTooltips(true);
|
|
}
|
|
|
|
public void setViewMode(BookmarkViewMode mode) {
|
|
if (viewMode == mode) {
|
|
return;
|
|
}
|
|
|
|
viewMode = mode;
|
|
|
|
if (mode == BookmarkViewMode.DEFAULT) {
|
|
sortIngredients(false);
|
|
todoItemsCount = 0;
|
|
gridMask = null;
|
|
}
|
|
|
|
onGridChanged();
|
|
}
|
|
|
|
public BookmarkViewMode getViewMode() {
|
|
return viewMode;
|
|
}
|
|
|
|
@Override
|
|
public int getNumPages() {
|
|
if (gridMask != null) {
|
|
return gridMask.size();
|
|
}
|
|
|
|
return super.getNumPages();
|
|
}
|
|
|
|
@Override
|
|
protected List<Integer> getMask() {
|
|
if (gridMask != null) {
|
|
return gridMask.size() > page ? gridMask.get(page) : new ArrayList<>();
|
|
}
|
|
|
|
return super.getMask();
|
|
}
|
|
|
|
private void sortIngredients(final boolean forward) {
|
|
BookmarkStackMeta meta;
|
|
int dir = forward ? 1 : -1;
|
|
|
|
for (int i = 0; i < realItems.size(); i++) {
|
|
meta = metadata.get(i);
|
|
|
|
if (meta.recipeId != null && !meta.ingredient) {
|
|
int shift = 0;
|
|
|
|
for (int j = i + 1; j < realItems.size(); j++) {
|
|
if (meta.recipeId.equals(metadata.get(j).recipeId)) {
|
|
if (i + shift + dir != j) {
|
|
realItems.add(i + shift + Math.max(dir, 0), realItems.remove(j));
|
|
metadata.add(i + shift + Math.max(dir, 0), metadata.remove(j));
|
|
}
|
|
shift++;
|
|
}
|
|
}
|
|
|
|
for (int j = i + shift - 1; j >= 0; j--) {
|
|
if (meta.recipeId.equals(metadata.get(j).recipeId)) {
|
|
if (i + shift + dir != j) {
|
|
realItems.add(i + shift + Math.min(dir, 0), realItems.remove(j));
|
|
metadata.add(i + shift + Math.min(dir, 0), metadata.remove(j));
|
|
}
|
|
shift--;
|
|
}
|
|
}
|
|
|
|
i += Math.max(0, shift);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void generateToDoSpaces() {
|
|
todoItemsCount = 0;
|
|
gridMask = new ArrayList<>();
|
|
|
|
if (rows * columns == 0) {
|
|
return;
|
|
}
|
|
|
|
BookmarkStackMeta meta;
|
|
boolean isFirstColumn = false;
|
|
boolean isIngredient = false;
|
|
int size = size();
|
|
int idx = 0;
|
|
|
|
while (idx < size) {
|
|
ArrayList<Integer> pmask = new ArrayList<>();
|
|
int lastIdx = idx;
|
|
|
|
for (int i = 0, perPage = rows * columns; i < perPage && idx < size; i++) {
|
|
|
|
if (isInvalidSlot(i)) {
|
|
pmask.add(null);
|
|
} else {
|
|
meta = getMetadata(idx);
|
|
isFirstColumn = (i % columns) == 0;
|
|
isIngredient = meta.recipeId != null && meta.ingredient;
|
|
|
|
if (isFirstColumn && !isIngredient) {
|
|
pmask.add(idx++);
|
|
|
|
todoItemsCount++;
|
|
} else if (isIngredient && (!isFirstColumn || i + 1 < perPage && isInvalidSlot(i + 1))) {
|
|
// The ingredients that do not fit on the first line are moved to the second starting with
|
|
// the second column. This condition checks whether the second column is available. If not
|
|
// available, the ingredient takes the first column
|
|
pmask.add(idx++);
|
|
} else {
|
|
pmask.add(null);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (lastIdx == idx) {
|
|
break;
|
|
}
|
|
|
|
gridMask.add(pmask);
|
|
}
|
|
}
|
|
|
|
protected void onGridChanged() {
|
|
super.onGridChanged();
|
|
|
|
if (getViewMode() == BookmarkViewMode.TODO_LIST) {
|
|
sortIngredients(true);
|
|
generateToDoSpaces();
|
|
}
|
|
}
|
|
|
|
public int indexOf(ItemStack stackA, BookmarkRecipeId recipeId) {
|
|
final boolean useNBT = NEIClientConfig.useNBTInBookmarks();
|
|
|
|
for (int idx = 0; idx < realItems.size(); idx++) {
|
|
final BookmarkStackMeta meta = getMetadata(idx);
|
|
if ((recipeId == null && meta.recipeId == null
|
|
|| recipeId != null && meta.recipeId != null && recipeId.equals(meta.recipeId))
|
|
&& StackInfo.equalItemAndNBT(stackA, getItem(idx), useNBT)) {
|
|
return idx;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public BookmarkStackMeta getMetadata(int idx) {
|
|
return metadata.get(idx);
|
|
}
|
|
|
|
public void addItem(ItemStack stackA, BookmarkStackMeta meta) {
|
|
addItem(stackA, meta, true);
|
|
}
|
|
|
|
public void addItem(ItemStack stackA, BookmarkStackMeta meta, boolean animate) {
|
|
realItems.add(stackA);
|
|
metadata.add(meta);
|
|
|
|
if (animate && !NEIClientConfig.shouldCacheItemRendering() && NEIClientConfig.areBookmarksAnimated()) {
|
|
animation.put(stackA, 0f);
|
|
}
|
|
|
|
onGridChanged();
|
|
}
|
|
|
|
public void replaceItem(int idx, ItemStack stack) {
|
|
realItems.set(idx, stack);
|
|
onGridChanged();
|
|
}
|
|
|
|
public void removeRecipe(int idx, boolean removeFullRecipe) {
|
|
final BookmarkStackMeta meta = getMetadata(idx);
|
|
|
|
if (meta.recipeId != null && (removeFullRecipe || !meta.ingredient)) {
|
|
removeRecipe(meta.recipeId);
|
|
} else {
|
|
removeItem(idx);
|
|
}
|
|
}
|
|
|
|
public void removeRecipe(BookmarkRecipeId recipeIdA) {
|
|
BookmarkRecipeId recipeIdB;
|
|
|
|
for (int slotIndex = metadata.size() - 1; slotIndex >= 0; slotIndex--) {
|
|
recipeIdB = getRecipeId(slotIndex);
|
|
|
|
if (recipeIdB != null && recipeIdB.equals(recipeIdA)) {
|
|
removeItem(slotIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected boolean removeItem(int idx) {
|
|
animation.remove(getItem(idx));
|
|
realItems.remove(idx);
|
|
metadata.remove(idx);
|
|
onGridChanged();
|
|
return true;
|
|
}
|
|
|
|
public BookmarkRecipeId getRecipeId(int idx) {
|
|
return getMetadata(idx).recipeId;
|
|
}
|
|
|
|
public BookmarkRecipeId findRecipeId(ItemStack stackA) {
|
|
final boolean useNBT = NEIClientConfig.useNBTInBookmarks();
|
|
|
|
for (int idx = 0; idx < realItems.size(); idx++) {
|
|
if (StackInfo.equalItemAndNBT(stackA, getItem(idx), useNBT)) {
|
|
return getRecipeId(idx);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void moveItem(int src, int dst) {
|
|
realItems.add(dst, realItems.remove(src));
|
|
metadata.add(dst, metadata.remove(src));
|
|
onGridChanged();
|
|
}
|
|
|
|
private boolean isPartOfFocusedRecipe(ItemPanelSlot focused, int myIdx) {
|
|
return NEIClientUtils.shiftKey() && focused != null
|
|
&& LayoutManager.bookmarkPanel.sortedStackIndex == -1
|
|
&& getRecipeId(focused.slotIndex) != null
|
|
&& getRecipeId(myIdx) != null
|
|
&& getRecipeId(focused.slotIndex).equals(getRecipeId(myIdx));
|
|
}
|
|
|
|
@Override
|
|
protected void drawSlotOutline(@Nullable ItemPanelSlot focus, int idx, Rectangle4i rect) {
|
|
|
|
if (LayoutManager.bookmarkPanel.sortedNamespaceIndex == LayoutManager.bookmarkPanel.activeNamespaceIndex
|
|
&& LayoutManager.bookmarkPanel.sortedStackIndex == idx) {
|
|
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555); // highlight
|
|
} else if (focus != null) {
|
|
BookmarkStackMeta meta = getMetadata(idx);
|
|
if (isPartOfFocusedRecipe(focus, idx)) {
|
|
drawRect(rect.x, rect.y, rect.w, rect.h, meta.ingredient ? 0x88b3b300 : 0x88009933); // highlight
|
|
// recipe
|
|
} else if (focus.slotIndex == idx) {
|
|
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555); // highlight
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void drawItem(Rectangle4i rect, int idx) {
|
|
if (LayoutManager.bookmarkPanel.sortedNamespaceIndex != LayoutManager.bookmarkPanel.activeNamespaceIndex
|
|
|| LayoutManager.bookmarkPanel.sortedStackIndex != idx) {
|
|
final ItemStack stack = getItem(idx);
|
|
final BookmarkStackMeta meta = getMetadata(idx);
|
|
final String stackSize = meta.factor < 0 || meta.fluidDisplay ? ""
|
|
: ReadableNumberConverter.INSTANCE.toWideReadableForm(stack.stackSize);
|
|
if (animation.containsKey(stack) && animation.get(stack) < 1) {
|
|
final float currentScale = animation.get(stack) + SCALE_SPEED;
|
|
animation.put(stack, currentScale);
|
|
drawPoppingItem(rect, stack, stackSize, currentScale);
|
|
} else {
|
|
GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, stack, true, stackSize);
|
|
if (meta.recipeId != null && !meta.ingredient && NEIClientConfig.showRecipeMarker()) {
|
|
drawRecipeMarker(rect.x, rect.y, GuiContainerManager.getFontRenderer(stack));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void drawPoppingItem(Rectangle4i rect, ItemStack stack, String stackSize, float currentScale) {
|
|
GL11.glScalef(currentScale, currentScale, currentScale); // push & pop matrix crashes the game
|
|
|
|
GuiContainerManager.drawItem(
|
|
Math.round((rect.x + 1 + (SLOT_SIZE / 2 - currentScale * SLOT_SIZE / 2)) / currentScale),
|
|
Math.round((rect.y + 1 + (SLOT_SIZE / 2 - currentScale * SLOT_SIZE / 2)) / currentScale),
|
|
stack,
|
|
true,
|
|
stackSize);
|
|
|
|
GL11.glScalef(1 / currentScale, 1 / currentScale, 1 / currentScale);
|
|
}
|
|
|
|
protected void drawRecipeMarker(int offsetX, int offsetY, FontRenderer fontRenderer) {
|
|
final float scaleFactor = fontRenderer.getUnicodeFlag() ? 0.85f : 0.5f;
|
|
final float inverseScaleFactor = 1.0f / scaleFactor;
|
|
|
|
GuiContainerManager.enable2DRender();
|
|
GL11.glScaled(scaleFactor, scaleFactor, scaleFactor);
|
|
|
|
final int X = (int) (((float) offsetX + 1.0f) * inverseScaleFactor);
|
|
final int Y = (int) (((float) offsetY + 1.0f) * inverseScaleFactor);
|
|
fontRenderer.drawStringWithShadow("R", X, Y, 0xA0A0A0);
|
|
|
|
GL11.glScaled(inverseScaleFactor, inverseScaleFactor, inverseScaleFactor);
|
|
GuiContainerManager.enable3DRender();
|
|
}
|
|
}
|
|
|
|
public BookmarkPanel() {
|
|
grid = new BookmarkGrid();
|
|
}
|
|
|
|
@Override
|
|
public void init() {
|
|
super.init();
|
|
|
|
namespaceLabel = new Label("1", true);
|
|
|
|
namespacePrev = new Button("Prev") {
|
|
|
|
public boolean onButtonPress(boolean rightclick) {
|
|
|
|
if (rightclick) {
|
|
return false;
|
|
}
|
|
|
|
return prevNamespace();
|
|
}
|
|
|
|
@Override
|
|
public String getRenderLabel() {
|
|
return "<";
|
|
}
|
|
};
|
|
|
|
namespaceNext = new Button("Next") {
|
|
|
|
public boolean onButtonPress(boolean rightclick) {
|
|
if (rightclick) {
|
|
return false;
|
|
}
|
|
|
|
return nextNamespace();
|
|
}
|
|
|
|
@Override
|
|
public String getRenderLabel() {
|
|
return ">";
|
|
}
|
|
};
|
|
|
|
pullBookmarkedItems = new Button("Pull") {
|
|
|
|
public boolean onButtonPress(boolean rightclick) {
|
|
if (rightclick) {
|
|
return false;
|
|
}
|
|
return pullBookmarkItems();
|
|
}
|
|
|
|
@Override
|
|
public String getRenderLabel() {
|
|
return "P";
|
|
}
|
|
};
|
|
|
|
namespaces.add(new BookmarkGrid());
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
}
|
|
|
|
@Override
|
|
public String getLabelText() {
|
|
int size = grid.size();
|
|
|
|
if (((BookmarkGrid) grid).getViewMode() == BookmarkViewMode.TODO_LIST) {
|
|
size = ((BookmarkGrid) grid).todoItemsCount;
|
|
}
|
|
|
|
return String.format("(%d/%d) [%d]", getPage(), Math.max(1, getNumPages()), size);
|
|
}
|
|
|
|
public void addItem(ItemStack itemStack) {
|
|
addItem(itemStack, true);
|
|
}
|
|
|
|
public void addItem(ItemStack itemStack, boolean saveStackSize) {
|
|
final BookmarkGrid BGrid = (BookmarkGrid) grid;
|
|
int idx = BGrid.indexOf(itemStack, true);
|
|
if (idx != -1) {
|
|
BGrid.removeItem(idx);
|
|
}
|
|
addOrRemoveItem(itemStack, null, null, false, saveStackSize);
|
|
}
|
|
|
|
public int getNameSpaceSize() {
|
|
return namespaces.size();
|
|
}
|
|
|
|
public void addOrRemoveItem(ItemStack stackA) {
|
|
addOrRemoveItem(stackA, null, null, false, false);
|
|
}
|
|
|
|
public void addOrRemoveItem(ItemStack stackover, final String handlerName, final List<PositionedStack> ingredients,
|
|
boolean saveIngredients, boolean saveStackSize) {
|
|
loadBookmarksIfNeeded();
|
|
|
|
final Point mousePos = getMousePosition();
|
|
final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
|
|
final BookmarkGrid BGrid = (BookmarkGrid) grid;
|
|
|
|
if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackover, true)) {
|
|
BGrid.removeRecipe(slot.slotIndex, saveIngredients);
|
|
} else {
|
|
final NBTTagCompound nbTagA = StackInfo.itemStackToNBT(stackover, saveStackSize);
|
|
final ItemStack normalizedA = StackInfo.loadFromNBT(nbTagA);
|
|
BookmarkRecipeId recipeId = null;
|
|
|
|
if (handlerName != "" && ingredients != null) {
|
|
recipeId = new BookmarkRecipeId(handlerName, ingredients);
|
|
}
|
|
|
|
final int idx = BGrid.indexOf(normalizedA, recipeId);
|
|
|
|
if (idx != -1) {
|
|
BGrid.removeRecipe(idx, saveIngredients);
|
|
} else {
|
|
|
|
if (saveIngredients && handlerName != "" && ingredients != null) {
|
|
final Map<NBTTagCompound, Integer> unique = new HashMap<>();
|
|
final ArrayList<NBTTagCompound> sorted = new ArrayList<>();
|
|
|
|
BGrid.removeRecipe(recipeId);
|
|
|
|
for (PositionedStack stack : ingredients) {
|
|
final NBTTagCompound nbTag = StackInfo.itemStackToNBT(stack.item, saveStackSize);
|
|
|
|
if (unique.get(nbTag) == null) {
|
|
unique.put(nbTag, 1);
|
|
sorted.add(nbTag);
|
|
} else {
|
|
unique.put(nbTag, unique.get(nbTag) + 1);
|
|
}
|
|
}
|
|
|
|
for (NBTTagCompound nbTag : sorted) {
|
|
final int count = nbTag.getInteger("Count") * unique.get(nbTag);
|
|
nbTag.setInteger("Count", count);
|
|
BGrid.addItem(
|
|
StackInfo.loadFromNBT(nbTag),
|
|
new BookmarkStackMeta(
|
|
recipeId != null ? recipeId.copy() : null,
|
|
(saveStackSize ? 1 : -1) * count,
|
|
true,
|
|
nbTag.hasKey("gtFluidName")));
|
|
}
|
|
}
|
|
|
|
BGrid.addItem(
|
|
normalizedA,
|
|
new BookmarkStackMeta(
|
|
recipeId,
|
|
(saveStackSize ? 1 : -1) * nbTagA.getInteger("Count"),
|
|
false,
|
|
nbTagA.hasKey("gtFluidName")));
|
|
}
|
|
}
|
|
|
|
fixCountOfNamespaces();
|
|
saveBookmarks();
|
|
}
|
|
|
|
public BookmarkRecipeId getBookmarkRecipeId(int slotIndex) {
|
|
return ((BookmarkGrid) grid).getRecipeId(slotIndex);
|
|
}
|
|
|
|
public BookmarkRecipeId getBookmarkRecipeId(ItemStack stackA) {
|
|
BookmarkRecipeId recipeId = ((BookmarkGrid) grid).findRecipeId(stackA);
|
|
|
|
if (recipeId == null) {
|
|
for (int idx = 0; idx < getNameSpaceSize() && recipeId == null; idx++) {
|
|
if (idx == activeNamespaceIndex) continue;
|
|
recipeId = namespaces.get(idx).findRecipeId(stackA);
|
|
}
|
|
}
|
|
|
|
return recipeId;
|
|
}
|
|
|
|
protected String getNamespaceLabelText(boolean shortFormat) {
|
|
String activePage = String.valueOf(activeNamespaceIndex + 1);
|
|
|
|
return shortFormat ? activePage : (activePage + "/" + fixCountOfNamespaces());
|
|
}
|
|
|
|
protected int fixCountOfNamespaces() {
|
|
|
|
if (namespaces.get(getNameSpaceSize() - 1).size() > 0) {
|
|
namespaces.add(new BookmarkGrid());
|
|
} else if (activeNamespaceIndex == getNameSpaceSize() - 2 && grid.size() == 0) {
|
|
namespaces.remove(getNameSpaceSize() - 1);
|
|
}
|
|
|
|
return getNameSpaceSize();
|
|
}
|
|
|
|
protected boolean removeEmptyNamespaces() {
|
|
|
|
if (activeNamespaceIndex != getNameSpaceSize() - 1 && grid.size() == 0) {
|
|
namespaces.remove(activeNamespaceIndex);
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected boolean prevNamespace() {
|
|
if (!bookmarksIsLoaded) {
|
|
return false;
|
|
}
|
|
|
|
fixCountOfNamespaces();
|
|
removeEmptyNamespaces();
|
|
|
|
if (activeNamespaceIndex == 0) {
|
|
activeNamespaceIndex = getNameSpaceSize() - 1;
|
|
} else {
|
|
activeNamespaceIndex--;
|
|
}
|
|
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected boolean nextNamespace() {
|
|
if (!bookmarksIsLoaded) {
|
|
return false;
|
|
}
|
|
|
|
if (removeEmptyNamespaces()) {
|
|
return true;
|
|
}
|
|
|
|
if (activeNamespaceIndex == fixCountOfNamespaces() - 1) {
|
|
activeNamespaceIndex = 0;
|
|
} else {
|
|
activeNamespaceIndex++;
|
|
}
|
|
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
|
|
return true;
|
|
}
|
|
|
|
public void setBookmarkFile(String worldPath) {
|
|
|
|
final File dir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
|
|
|
|
if (!dir.exists()) {
|
|
dir.mkdirs();
|
|
}
|
|
|
|
bookmarkFile = new File(dir, "bookmarks.ini");
|
|
|
|
if (!bookmarkFile.exists()) {
|
|
final File globalBookmarks = new File(CommonUtils.getMinecraftDir(), "saves/NEI/global/bookmarks.ini");
|
|
final File configBookmarks = new File(NEIClientConfig.configDir, "bookmarks.ini");
|
|
final File defaultBookmarks = configBookmarks.exists() ? configBookmarks : globalBookmarks;
|
|
|
|
if (defaultBookmarks.exists()) {
|
|
|
|
try {
|
|
bookmarkFile.createNewFile();
|
|
|
|
InputStream src = new FileInputStream(defaultBookmarks);
|
|
OutputStream dst = new FileOutputStream(bookmarkFile);
|
|
|
|
IOUtils.copy(src, dst);
|
|
|
|
src.close();
|
|
dst.close();
|
|
|
|
} catch (IOException e) {}
|
|
}
|
|
}
|
|
|
|
bookmarksIsLoaded = false;
|
|
}
|
|
|
|
public void saveBookmarks() {
|
|
|
|
if (bookmarkFile == null) {
|
|
return;
|
|
}
|
|
|
|
ArrayList<String> strings = new ArrayList<>();
|
|
|
|
for (int grpIdx = 0; grpIdx < getNameSpaceSize() - 1; grpIdx++) {
|
|
final BookmarkGrid grid = namespaces.get(grpIdx);
|
|
|
|
JsonObject settings = new JsonObject();
|
|
settings.add("viewmode", new JsonPrimitive(grid.getViewMode().toString()));
|
|
settings.add("active", new JsonPrimitive(activeNamespaceIndex == grpIdx));
|
|
strings.add("; " + NBTJson.toJson(settings));
|
|
|
|
for (int idx = 0; idx < grid.size(); idx++) {
|
|
|
|
try {
|
|
final NBTTagCompound nbTag = StackInfo.itemStackToNBT(grid.getItem(idx));
|
|
|
|
if (nbTag != null) {
|
|
JsonObject row = new JsonObject();
|
|
BookmarkStackMeta meta = grid.getMetadata(idx);
|
|
|
|
row.add("item", NBTJson.toJsonObject(nbTag));
|
|
row.add("factor", new JsonPrimitive(meta.factor));
|
|
row.add("ingredient", new JsonPrimitive(meta.ingredient));
|
|
|
|
if (meta.recipeId != null) {
|
|
row.add("recipeId", meta.recipeId.toJsonObject());
|
|
}
|
|
|
|
strings.add(NBTJson.toJson(row));
|
|
}
|
|
|
|
} catch (JsonSyntaxException e) {
|
|
NEIClientConfig.logger.error("Failed to stringify bookmarked ItemStack to json string");
|
|
}
|
|
}
|
|
}
|
|
|
|
try (FileOutputStream output = new FileOutputStream(bookmarkFile)) {
|
|
IOUtils.writeLines(strings, "\n", output, StandardCharsets.UTF_8);
|
|
} catch (IOException e) {
|
|
NEIClientConfig.logger.error("Filed to save bookmarks list to file {}", bookmarkFile, e);
|
|
}
|
|
}
|
|
|
|
public void loadBookmarksIfNeeded() {
|
|
|
|
if (bookmarksIsLoaded) {
|
|
return;
|
|
}
|
|
|
|
bookmarksIsLoaded = true;
|
|
|
|
if (bookmarkFile == null || !bookmarkFile.exists()) {
|
|
return;
|
|
}
|
|
|
|
List<String> itemStrings;
|
|
try (FileInputStream reader = new FileInputStream(bookmarkFile)) {
|
|
NEIClientConfig.logger.info("Loading bookmarks from file {}", bookmarkFile);
|
|
itemStrings = IOUtils.readLines(reader, StandardCharsets.UTF_8);
|
|
} catch (IOException e) {
|
|
NEIClientConfig.logger.error("Failed to load bookmarks from file {}", bookmarkFile, e);
|
|
return;
|
|
}
|
|
|
|
namespaces.clear();
|
|
namespaces.add(new BookmarkGrid());
|
|
activeNamespaceIndex = -1;
|
|
|
|
final JsonParser parser = new JsonParser();
|
|
int namespaceIndex = 0;
|
|
|
|
for (String itemStr : itemStrings) {
|
|
|
|
try {
|
|
|
|
if (itemStr.isEmpty()) {
|
|
itemStr = "; {}";
|
|
}
|
|
|
|
if (itemStr.startsWith("; ")) {
|
|
JsonObject settings = parser.parse(itemStr.substring(2)).getAsJsonObject();
|
|
|
|
if (namespaces.get(namespaceIndex).size() > 0) {
|
|
// do not create empty namespaces
|
|
namespaces.add(new BookmarkGrid());
|
|
namespaceIndex++;
|
|
}
|
|
|
|
if (settings.get("viewmode") != null) {
|
|
namespaces.get(namespaceIndex)
|
|
.setViewMode(BookmarkViewMode.valueOf(settings.get("viewmode").getAsString()));
|
|
}
|
|
|
|
if (settings.get("active") != null && settings.get("active").getAsBoolean()) {
|
|
activeNamespaceIndex = namespaceIndex;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
JsonObject jsonObject = parser.parse(itemStr).getAsJsonObject();
|
|
BookmarkRecipeId recipeId = null;
|
|
NBTTagCompound itemStackNBT;
|
|
|
|
if (jsonObject.get("item") != null) {
|
|
itemStackNBT = (NBTTagCompound) NBTJson.toNbt(jsonObject.get("item"));
|
|
} else { // old format
|
|
itemStackNBT = (NBTTagCompound) NBTJson.toNbt(jsonObject);
|
|
}
|
|
|
|
if (jsonObject.get("recipeId") != null && jsonObject.get("recipeId") instanceof JsonObject) {
|
|
recipeId = new BookmarkRecipeId((JsonObject) jsonObject.get("recipeId"));
|
|
}
|
|
|
|
ItemStack itemStack = StackInfo.loadFromNBT(itemStackNBT);
|
|
|
|
if (itemStack != null) {
|
|
namespaces.get(namespaceIndex).addItem(
|
|
itemStack,
|
|
new BookmarkStackMeta(
|
|
recipeId,
|
|
jsonObject.has("factor") ? jsonObject.get("factor").getAsInt() : 0,
|
|
jsonObject.has("ingredient") ? jsonObject.get("ingredient").getAsBoolean() : false,
|
|
itemStackNBT.hasKey("gtFluidName")),
|
|
false);
|
|
} else {
|
|
NEIClientConfig.logger.warn(
|
|
"Failed to load bookmarked ItemStack from json string, the item no longer exists:\n{}",
|
|
itemStr);
|
|
}
|
|
|
|
} catch (IllegalArgumentException | JsonSyntaxException e) {
|
|
NEIClientConfig.logger.error("Failed to load bookmarked ItemStack from json string:\n{}", itemStr);
|
|
}
|
|
}
|
|
|
|
if (activeNamespaceIndex == -1) {
|
|
activeNamespaceIndex = namespaceIndex;
|
|
}
|
|
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
}
|
|
|
|
@Override
|
|
public void resize(GuiContainer gui) {
|
|
loadBookmarksIfNeeded();
|
|
super.resize(gui);
|
|
}
|
|
|
|
@Override
|
|
protected int resizeHeader(GuiContainer gui) {
|
|
final LayoutStyleMinecraft layout = (LayoutStyleMinecraft) LayoutManager.getLayoutStyle();
|
|
final int rows = (int) Math.ceil((double) layout.buttonCount / layout.numButtons);
|
|
final int diff = rows * BookmarkGrid.SLOT_SIZE + getMarginTop(gui) - y;
|
|
|
|
if (diff > 0) {
|
|
y += diff;
|
|
h -= diff;
|
|
}
|
|
|
|
return super.resizeHeader(gui);
|
|
}
|
|
|
|
@Override
|
|
protected int resizeFooter(GuiContainer gui) {
|
|
final int BUTTON_SIZE = 16;
|
|
|
|
final ButtonCycled button = LayoutManager.bookmarksButton;
|
|
final int leftBorder = y + h > button.y ? button.x + button.w + 2 : x;
|
|
final int rightBorder = x + w;
|
|
final int center = leftBorder + Math.max(0, (rightBorder - leftBorder) / 2);
|
|
int labelWidth = 2;
|
|
|
|
namespacePrev.h = namespaceNext.h = pullBookmarkedItems.h = BUTTON_SIZE;
|
|
namespacePrev.w = namespaceNext.w = pullBookmarkedItems.w = BUTTON_SIZE;
|
|
namespacePrev.y = namespaceNext.y = pullBookmarkedItems.y = y + h - BUTTON_SIZE;
|
|
|
|
if (rightBorder - leftBorder >= 70) {
|
|
labelWidth = 36;
|
|
namespaceLabel.text = getNamespaceLabelText(false);
|
|
} else {
|
|
labelWidth = 18;
|
|
namespaceLabel.text = getNamespaceLabelText(true);
|
|
}
|
|
|
|
namespaceLabel.y = namespacePrev.y + 5;
|
|
namespaceLabel.x = center;
|
|
|
|
namespacePrev.x = center - labelWidth / 2 - 2 - namespacePrev.w;
|
|
namespaceNext.x = center + labelWidth / 2 + 2;
|
|
pullBookmarkedItems.x = center + 2 * labelWidth / 2 + 2;
|
|
|
|
return BUTTON_SIZE + 2;
|
|
}
|
|
|
|
@Override
|
|
public void setVisible() {
|
|
super.setVisible();
|
|
|
|
if (grid.getPerPage() > 0) {
|
|
LayoutManager.addWidget(namespacePrev);
|
|
LayoutManager.addWidget(namespaceNext);
|
|
LayoutManager.addWidget(namespaceLabel);
|
|
if (BookmarkContainerInfo.getBookmarkContainerHandler(getGuiContainer()) != null) {
|
|
LayoutManager.addWidget(pullBookmarkedItems);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected String getPositioningSettingName() {
|
|
return "world.panels.bookmarks";
|
|
}
|
|
|
|
public int getMarginLeft(GuiContainer gui) {
|
|
return PADDING;
|
|
}
|
|
|
|
public int getMarginTop(GuiContainer gui) {
|
|
return PADDING;
|
|
}
|
|
|
|
public int getWidth(GuiContainer gui) {
|
|
return gui.width - (gui.xSize + gui.width) / 2 - PADDING * 2;
|
|
}
|
|
|
|
public int getHeight(GuiContainer gui) {
|
|
return gui.height - getMarginTop(gui) - PADDING;
|
|
}
|
|
|
|
protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot) {
|
|
final ItemStack stack = grid.getItem(mouseDownSlot);
|
|
|
|
if (stack == null) {
|
|
return null;
|
|
}
|
|
|
|
final BookmarkStackMeta meta = ((BookmarkGrid) grid).getMetadata(mouseDownSlot);
|
|
int amount = stack.stackSize;
|
|
|
|
if (meta.factor < 0 && !meta.fluidDisplay) {
|
|
amount = NEIClientConfig.showItemQuantityWidget() ? NEIClientConfig.getItemQuantity() : 0;
|
|
|
|
if (amount == 0) {
|
|
amount = stack.getMaxStackSize();
|
|
}
|
|
}
|
|
|
|
return NEIServerUtils.copyStack(stack, amount);
|
|
}
|
|
|
|
@Override
|
|
public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
|
|
|
|
if (button == 0 && NEIClientUtils.shiftKey() && mouseDownSlot >= 0) {
|
|
ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
|
|
|
|
if (sortedStackIndex == -1) {
|
|
final ItemStack stack = grid.getItem(mouseDownSlot);
|
|
|
|
if (stack != null
|
|
&& (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 250)) {
|
|
sortedNamespaceIndex = activeNamespaceIndex;
|
|
sortedStackIndex = mouseDownSlot;
|
|
grid.onGridChanged();
|
|
}
|
|
|
|
} else {
|
|
|
|
if (sortedNamespaceIndex != activeNamespaceIndex) {
|
|
final BookmarkGrid hoverGrid = namespaces.get(activeNamespaceIndex);
|
|
final BookmarkGrid sortedGrid = namespaces.get(sortedNamespaceIndex);
|
|
|
|
if (mouseOverSlot != null || getNextSlot(new Point(mousex, mousey)) >= 0) {
|
|
final ItemStack stack = sortedGrid.getItem(sortedStackIndex);
|
|
final BookmarkStackMeta meta = sortedGrid.getMetadata(sortedStackIndex);
|
|
|
|
sortedGrid.removeItem(sortedStackIndex);
|
|
hoverGrid.addItem(stack, meta, false);
|
|
|
|
sortedNamespaceIndex = activeNamespaceIndex;
|
|
sortedStackIndex = hoverGrid.indexOf(stack, meta.recipeId);
|
|
}
|
|
|
|
} else if (mouseOverSlot == null || mouseOverSlot.slotIndex != sortedStackIndex) {
|
|
final BookmarkGrid sortedGrid = namespaces.get(sortedNamespaceIndex);
|
|
|
|
if (mouseOverSlot != null && sortedGrid.getViewMode() == BookmarkViewMode.DEFAULT) {
|
|
sortedGrid.moveItem(sortedStackIndex, mouseOverSlot.slotIndex);
|
|
sortedStackIndex = mouseOverSlot.slotIndex;
|
|
} else if (sortedGrid.getViewMode() == BookmarkViewMode.TODO_LIST) {
|
|
final ItemStack stack = sortedGrid.getItem(sortedStackIndex);
|
|
final BookmarkStackMeta meta = sortedGrid.getMetadata(sortedStackIndex);
|
|
final boolean isIngredient = sortedStackIndex > 0 && meta.recipeId != null
|
|
&& meta.ingredient
|
|
&& meta.recipeId.equals(sortedGrid.getRecipeId(sortedStackIndex - 1));
|
|
|
|
if (!isIngredient) {
|
|
mouseOverSlot = getSlotMouseOver(grid.marginLeft + grid.paddingLeft, mousey);
|
|
|
|
if (mouseOverSlot != null && sortedStackIndex != mouseOverSlot.slotIndex) {
|
|
sortedGrid.moveItem(sortedStackIndex, mouseOverSlot.slotIndex);
|
|
sortedStackIndex = sortedGrid.indexOf(stack, meta.recipeId);
|
|
}
|
|
|
|
} else if (mouseOverSlot != null && meta.recipeId != null
|
|
&& sortedGrid.getMetadata(mouseOverSlot.slotIndex).ingredient
|
|
&& meta.recipeId.equals(sortedGrid.getRecipeId(mouseOverSlot.slotIndex))) {
|
|
sortedGrid.moveItem(sortedStackIndex, mouseOverSlot.slotIndex);
|
|
sortedStackIndex = sortedGrid.indexOf(stack, meta.recipeId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
super.mouseDragged(mousex, mousey, button, heldTime);
|
|
}
|
|
|
|
private int getNextSlot(final Point point) {
|
|
final List<Integer> mask = grid.getMask();
|
|
final int columns = grid.getColumns();
|
|
final int perPage = grid.getRows() * columns;
|
|
final boolean line = ((BookmarkGrid) grid).getViewMode() == BookmarkViewMode.TODO_LIST;
|
|
|
|
for (int i = mask.size(); i < perPage; i++) {
|
|
if (!grid.isInvalidSlot(i) && (!line || (i % columns) == 0)) {
|
|
|
|
if (point == null || grid.getSlotRect(i).contains(point.x, point.y)) {
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public void postDraw(int mousex, int mousey) {
|
|
|
|
if (sortedStackIndex != -1) {
|
|
GuiContainerManager.drawItems.zLevel += 100;
|
|
GuiContainerManager.drawItem(
|
|
mousex - 8,
|
|
mousey - 8,
|
|
namespaces.get(sortedNamespaceIndex).getItem(sortedStackIndex).copy(),
|
|
true);
|
|
GuiContainerManager.drawItems.zLevel -= 100;
|
|
}
|
|
|
|
if (ItemPanels.itemPanel.draggedStack != null && this.contains(mousex, mousey)) {
|
|
final int idx = getNextSlot(null);
|
|
|
|
if (idx >= 0) {
|
|
Rectangle4i rect = grid.getSlotRect(idx);
|
|
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555); // highlight
|
|
}
|
|
}
|
|
|
|
super.postDraw(mousex, mousey);
|
|
}
|
|
|
|
@Override
|
|
public boolean handleClickExt(int mousex, int mousey, int button) {
|
|
|
|
if (new Rectangle4i(pagePrev.x + pagePrev.w, pagePrev.y, pageNext.x - (pagePrev.x + pagePrev.w), pagePrev.h)
|
|
.contains(mousex, mousey)) {
|
|
final BookmarkGrid BGrid = (BookmarkGrid) grid;
|
|
|
|
if (BGrid.getViewMode() == BookmarkViewMode.DEFAULT) {
|
|
BGrid.setViewMode(BookmarkViewMode.TODO_LIST);
|
|
} else {
|
|
BGrid.setViewMode(BookmarkViewMode.DEFAULT);
|
|
}
|
|
|
|
saveBookmarks();
|
|
return true;
|
|
} else {
|
|
return super.handleClickExt(mousex, mousey, button);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public List<String> handleTooltip(int mx, int my, List<String> tooltip) {
|
|
|
|
if (new Rectangle4i(pagePrev.x + pagePrev.w, pagePrev.y, pageNext.x - (pagePrev.x + pagePrev.w), pagePrev.h)
|
|
.contains(mx, my)) {
|
|
tooltip.add(translate("bookmark.viewmode.toggle.tip"));
|
|
}
|
|
if (new Rectangle4i(pullBookmarkedItems.x, pullBookmarkedItems.y, pullBookmarkedItems.w, pullBookmarkedItems.h)
|
|
.contains(mx, my) && BookmarkContainerInfo.getBookmarkContainerHandler(getGuiContainer()) != null) {
|
|
tooltip.add(translate("bookmark.pullBookmarkedItems.tip"));
|
|
}
|
|
|
|
return super.handleTooltip(mx, my, tooltip);
|
|
}
|
|
|
|
@Override
|
|
public void mouseUp(int mousex, int mousey, int button) {
|
|
if (sortedStackIndex != -1) {
|
|
draggedStack = null;
|
|
sortedNamespaceIndex = -1;
|
|
sortedStackIndex = -1;
|
|
mouseDownSlot = -1;
|
|
grid.onGridChanged(); /* make sure grid redraws the new item */
|
|
saveBookmarks();
|
|
} else {
|
|
super.mouseUp(mousex, mousey, button);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onMouseWheel(int shift, int mousex, int mousey) {
|
|
|
|
if (new Rectangle4i(
|
|
namespacePrev.x,
|
|
namespacePrev.y,
|
|
namespaceNext.x + namespaceNext.w - namespacePrev.x,
|
|
namespacePrev.h).contains(mousex, mousey)) {
|
|
|
|
if (shift > 0) {
|
|
prevNamespace();
|
|
} else {
|
|
nextNamespace();
|
|
}
|
|
|
|
saveBookmarks();
|
|
return true;
|
|
}
|
|
|
|
if (!contains(mousex, mousey)) {
|
|
return false;
|
|
}
|
|
|
|
if (NEIClientUtils.controlKey()) {
|
|
final ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
|
|
|
|
if (slot != null) {
|
|
final BookmarkGrid BGrid = (BookmarkGrid) grid;
|
|
final BookmarkRecipeId recipeId = BGrid.getRecipeId(slot.slotIndex);
|
|
final boolean addFullRecipe = NEIClientUtils.shiftKey();
|
|
|
|
if (NEIClientUtils.altKey()) {
|
|
shift *= slot.item.getMaxStackSize();
|
|
}
|
|
|
|
if (addFullRecipe) {
|
|
BookmarkStackMeta iMeta;
|
|
|
|
for (int slotIndex = grid.size() - 1; slotIndex >= 0; slotIndex--) {
|
|
iMeta = BGrid.getMetadata(slotIndex);
|
|
|
|
if (iMeta.recipeId != null && iMeta.recipeId.equals(recipeId) && slotIndex != slot.slotIndex) {
|
|
shiftStackSize(slotIndex, shift);
|
|
}
|
|
}
|
|
}
|
|
|
|
shiftStackSize(slot.slotIndex, shift);
|
|
|
|
saveBookmarks();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return super.onMouseWheel(shift, mousex, mousey);
|
|
}
|
|
|
|
protected void shiftStackSize(int slotIndex, int shift) {
|
|
final BookmarkGrid BGrid = (BookmarkGrid) grid;
|
|
final NBTTagCompound nbTag = StackInfo.itemStackToNBT(BGrid.getItem(slotIndex), true);
|
|
final BookmarkStackMeta meta = BGrid.getMetadata(slotIndex);
|
|
final int factor = Math.abs(meta.factor);
|
|
|
|
if (nbTag.getInteger("Count") == factor && meta.factor < 0 && shift > 0) {
|
|
meta.factor = factor;
|
|
} else {
|
|
meta.factor = nbTag.getInteger("Count") == factor && shift < 0 ? -1 * factor : factor;
|
|
if ((long) nbTag.getInteger("Count") + ((long) factor * shift) <= Integer.MAX_VALUE) {
|
|
nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + factor * shift, factor));
|
|
BGrid.replaceItem(slotIndex, StackInfo.loadFromNBT(nbTag));
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean pullBookmarkItems() {
|
|
IBookmarkContainerHandler containerHandler = BookmarkContainerInfo
|
|
.getBookmarkContainerHandler(getGuiContainer());
|
|
if (containerHandler == null) {
|
|
return false;
|
|
}
|
|
containerHandler.pullBookmarkItemsFromContainer(getGuiContainer(), ((BookmarkGrid) grid).realItems);
|
|
return true;
|
|
}
|
|
}
|