mirror of
https://github.com/GTNewHorizons/NotEnoughItems.git
synced 2026-11-12 16:37:45 +00:00
821 lines
25 KiB
Java
821 lines
25 KiB
Java
package codechicken.nei;
|
|
|
|
import codechicken.core.CommonUtils;
|
|
import codechicken.lib.vec.Rectangle4i;
|
|
import codechicken.nei.util.NBTJson;
|
|
import codechicken.nei.recipe.StackInfo;
|
|
import codechicken.nei.recipe.BookmarkRecipeId;
|
|
import codechicken.nei.guihook.GuiContainerManager;
|
|
import com.google.gson.JsonParser;
|
|
import com.google.gson.JsonPrimitive;
|
|
import com.google.gson.JsonObject;
|
|
import com.google.gson.JsonSyntaxException;
|
|
import net.minecraft.client.gui.inventory.GuiContainer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import org.apache.commons.io.IOUtils;
|
|
|
|
import static codechicken.lib.gui.GuiDraw.getMousePosition;
|
|
import static codechicken.lib.gui.GuiDraw.drawRect;
|
|
|
|
import java.awt.Point;
|
|
import java.io.File;
|
|
import java.io.FileReader;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.HashMap;
|
|
|
|
public class BookmarkPanel extends ItemPanel
|
|
{
|
|
|
|
protected File bookmarkFile;
|
|
protected boolean bookmarksIsLoaded = false;
|
|
public int sortedStackIndex = -1;
|
|
public int sortedNamespaceIndex = -1;
|
|
|
|
|
|
public Button namespacePrev;
|
|
public Button namespaceNext;
|
|
public Label namespaceLabel;
|
|
|
|
|
|
protected ArrayList<BookmarkGrid> namespaces = new ArrayList<>();
|
|
public int activeNamespaceIndex = 0;
|
|
|
|
|
|
protected static class BookmarkStackMeta
|
|
{
|
|
public int factor;
|
|
public BookmarkRecipeId recipeId;
|
|
public boolean ingredient = false;
|
|
|
|
|
|
public BookmarkStackMeta(BookmarkRecipeId recipeId, int count, boolean ingredient)
|
|
{
|
|
this.recipeId = recipeId;
|
|
this.factor = count;
|
|
this.ingredient = ingredient;
|
|
}
|
|
|
|
}
|
|
|
|
protected static class BookmarkGrid extends ItemsGrid
|
|
{
|
|
protected List<BookmarkStackMeta> metadata = new ArrayList<>();
|
|
|
|
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, realItems.get(idx), useNBT)) {
|
|
return idx;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public BookmarkStackMeta getMetadata(int idx)
|
|
{
|
|
return metadata.get(idx);
|
|
}
|
|
|
|
public void addItem(ItemStack stackA, BookmarkStackMeta meta)
|
|
{
|
|
realItems.add(stackA);
|
|
metadata.add(meta);
|
|
}
|
|
|
|
public void replaceItem(int idx, ItemStack stack)
|
|
{
|
|
realItems.set(idx, stack);
|
|
}
|
|
|
|
public void removeRecipe(int idx, boolean removeFullRecipe)
|
|
{
|
|
final BookmarkStackMeta meta = getMetadata(idx);
|
|
|
|
if (removeFullRecipe && meta.recipeId != null) {
|
|
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 && recipeIdA.equals(recipeIdB)) {
|
|
removeItem(slotIndex);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
protected boolean removeItem(int idx)
|
|
{
|
|
realItems.remove(idx);
|
|
metadata.remove(idx);
|
|
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));
|
|
}
|
|
|
|
@Override
|
|
protected void drawItem(Rectangle4i rect, int idx, ItemPanelSlot focus)
|
|
{
|
|
|
|
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) {
|
|
|
|
if (focus.slotIndex == idx) {
|
|
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
|
|
} else if (
|
|
LayoutManager.bookmarkPanel.sortedStackIndex == -1 && //disabled when sorting
|
|
NEIClientUtils.shiftKey() && //show only with shift key
|
|
getRecipeId(focus.slotIndex) != null && getRecipeId(idx) != null && getRecipeId(focus.slotIndex).equals(getRecipeId(idx))//is some recipeId
|
|
) {
|
|
drawRect(rect.x, rect.y, rect.w, rect.h, getMetadata(idx).ingredient? 0x88b3b300: 0x88009933);//highlight recipe
|
|
}
|
|
|
|
}
|
|
|
|
GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, getItem(idx), true);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public BookmarkPanel()
|
|
{
|
|
grid = new BookmarkGrid();
|
|
}
|
|
|
|
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 ">";
|
|
}
|
|
};
|
|
|
|
namespaces.add(new BookmarkGrid());
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
}
|
|
|
|
@Override
|
|
public String getLabelText()
|
|
{
|
|
return super.getLabelText() + " [" + grid.size() + "]";
|
|
}
|
|
|
|
public void addOrRemoveItem(ItemStack stackA)
|
|
{
|
|
addOrRemoveItem(stackA, "", null);
|
|
}
|
|
|
|
public void addOrRemoveItem(ItemStack stackover, String handlerName, List<PositionedStack> ingredients)
|
|
{
|
|
loadBookmarksIfNeeded();
|
|
|
|
final Point mousePos = getMousePosition();
|
|
final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
|
|
final boolean addFullRecipe = NEIClientUtils.shiftKey();
|
|
final BookmarkGrid BGrid = (BookmarkGrid) grid;
|
|
|
|
if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackover, true)) {
|
|
BGrid.removeRecipe(slot.slotIndex, addFullRecipe);
|
|
} else {
|
|
final boolean saveStackSize = NEIClientUtils.controlKey();
|
|
final NBTTagCompound nbTagA = StackInfo.itemStackToNBT(stackover, saveStackSize);
|
|
final ItemStack normalizedA = StackInfo.loadFromNBT(nbTagA);
|
|
BookmarkRecipeId recipeId = null;
|
|
|
|
if (NEIClientConfig.saveCurrentRecipeInBookmarksEnabled() && handlerName != "" && ingredients != null && ingredients.size() > 0) {
|
|
recipeId = new BookmarkRecipeId(handlerName, ingredients);
|
|
}
|
|
|
|
final int idx = BGrid.indexOf(normalizedA, recipeId);
|
|
|
|
if (idx != -1) {
|
|
BGrid.removeRecipe(idx, addFullRecipe);
|
|
} else {
|
|
|
|
if (addFullRecipe && 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 if (saveStackSize) {
|
|
unique.put(nbTag, unique.get(nbTag) + 1);
|
|
}
|
|
|
|
}
|
|
|
|
for (NBTTagCompound nbTag : sorted) {
|
|
nbTag.setInteger("Count", nbTag.getInteger("Count") * unique.get(nbTag));
|
|
BGrid.addItem(StackInfo.loadFromNBT(nbTag), new BookmarkStackMeta(recipeId, nbTag.getInteger("Count"), true));
|
|
}
|
|
|
|
}
|
|
|
|
BGrid.addItem(normalizedA, new BookmarkStackMeta(recipeId, nbTagA.getInteger("Count"), false));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
fixCountOfNamespaces();
|
|
saveBookmarks();
|
|
}
|
|
|
|
public BookmarkRecipeId getBookmarkRecipeId(ItemStack stackA)
|
|
{
|
|
|
|
final Point mousePos = getMousePosition();
|
|
final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
|
|
|
|
if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackA, true)) {
|
|
return ((BookmarkGrid) grid).getRecipeId(slot.slotIndex);
|
|
}
|
|
|
|
BookmarkRecipeId recipeId = ((BookmarkGrid) grid).findRecipeId(stackA);
|
|
|
|
if (recipeId == null) {
|
|
|
|
for (int idx = 0; idx < namespaces.size() && 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(namespaces.size() - 1).size() > 0) {
|
|
namespaces.add(new BookmarkGrid());
|
|
} else if (activeNamespaceIndex == namespaces.size() - 2 && grid.size() == 0) {
|
|
namespaces.remove(namespaces.size() - 1);
|
|
}
|
|
|
|
return namespaces.size();
|
|
}
|
|
|
|
protected boolean removeEmptyNamespaces()
|
|
{
|
|
|
|
if (activeNamespaceIndex != namespaces.size() - 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 = namespaces.size() - 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 < namespaces.size() - 1; grpIdx++) {
|
|
final BookmarkGrid grid = namespaces.get(grpIdx);
|
|
|
|
if (grpIdx > 0) {
|
|
strings.add("");//namespace separator; ignore first namespace
|
|
}
|
|
|
|
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, "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 (FileReader reader = new FileReader(bookmarkFile)) {
|
|
NEIClientConfig.logger.info("Loading bookmarks from file {}", bookmarkFile);
|
|
itemStrings = IOUtils.readLines(reader);
|
|
} catch (IOException e) {
|
|
NEIClientConfig.logger.error("Failed to load bookmarks from file {}", bookmarkFile, e);
|
|
return;
|
|
}
|
|
|
|
namespaces.clear();
|
|
namespaces.add(new BookmarkGrid());
|
|
activeNamespaceIndex = 0;
|
|
|
|
final JsonParser parser = new JsonParser();
|
|
|
|
for (String itemStr: itemStrings) {
|
|
try {
|
|
|
|
if (itemStr.isEmpty()) {
|
|
|
|
if (namespaces.get(activeNamespaceIndex).size() > 0) {
|
|
//do not create empty namespaces
|
|
namespaces.add(new BookmarkGrid());
|
|
activeNamespaceIndex++;
|
|
}
|
|
|
|
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(activeNamespaceIndex).addItem(itemStack, new BookmarkStackMeta(
|
|
recipeId,
|
|
jsonObject.has("factor")? jsonObject.get("factor").getAsInt(): 1,
|
|
jsonObject.has("ingredient")? jsonObject.get("ingredient").getAsBoolean(): 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 (namespaces.get(activeNamespaceIndex).size() == 0) {
|
|
activeNamespaceIndex = Math.max(activeNamespaceIndex - 1, 0);
|
|
}
|
|
|
|
grid = namespaces.get(activeNamespaceIndex);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void resize(GuiContainer gui)
|
|
{
|
|
loadBookmarksIfNeeded();
|
|
super.resize(gui);
|
|
|
|
final int buttonHeight = 16;
|
|
final int buttonWidth = 16;
|
|
|
|
final int buttonTop = gui.height - buttonHeight - 2;
|
|
final int leftBorder = LayoutManager.bookmarksButton.x + LayoutManager.bookmarksButton.w + 2;
|
|
final int rightBorder = x + w;
|
|
final int center = leftBorder + (rightBorder - leftBorder) / 2;
|
|
int labelWidth = 2;
|
|
|
|
namespacePrev.h = namespaceNext.h = buttonHeight;
|
|
namespacePrev.w = namespaceNext.w = buttonWidth;
|
|
namespacePrev.y = namespaceNext.y = buttonTop;
|
|
|
|
|
|
if (rightBorder - leftBorder >= 70) {
|
|
labelWidth = 36;
|
|
namespaceLabel.text = getNamespaceLabelText(false);
|
|
} else {
|
|
labelWidth = 18;
|
|
namespaceLabel.text = getNamespaceLabelText(true);
|
|
}
|
|
|
|
namespaceLabel.y = buttonTop + 5;
|
|
namespaceLabel.x = center;
|
|
|
|
namespacePrev.x = center - labelWidth / 2 - 2 - namespacePrev.w;
|
|
namespaceNext.x = center + labelWidth / 2 + 2;
|
|
|
|
}
|
|
|
|
@Override
|
|
public void setVisible()
|
|
{
|
|
super.setVisible();
|
|
|
|
LayoutManager.addWidget(namespacePrev);
|
|
LayoutManager.addWidget(namespaceNext);
|
|
LayoutManager.addWidget(namespaceLabel);
|
|
}
|
|
|
|
@Override
|
|
public int getMarginLeft(GuiContainer gui)
|
|
{
|
|
return 5;
|
|
}
|
|
|
|
@Override
|
|
public int getMarginTop(GuiContainer gui)
|
|
{
|
|
LayoutStyleMinecraft layout = (LayoutStyleMinecraft)LayoutManager.getLayoutStyle();
|
|
return 2 + (((int)Math.ceil((double)layout.buttonCount / layout.numButtons)) * 18);
|
|
}
|
|
|
|
@Override
|
|
public int getWidth(GuiContainer gui)
|
|
{
|
|
return LayoutManager.getLeftSize(gui) - ((gui.xSize + gui.width) / 2 + 3) - 16;
|
|
}
|
|
|
|
@Override
|
|
public int getHeight(GuiContainer gui)
|
|
{
|
|
// - 19 = 22 + 1 -> input in bottom
|
|
return gui.height - getMarginTop(gui) - 23;
|
|
}
|
|
|
|
|
|
@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;
|
|
}
|
|
|
|
} else {
|
|
|
|
if (mouseOverSlot == null && sortedNamespaceIndex != activeNamespaceIndex) {
|
|
mouseOverSlot = getNextSlot(mousex, mousey);
|
|
}
|
|
|
|
if (mouseOverSlot != null) {
|
|
|
|
if (sortedNamespaceIndex != activeNamespaceIndex) {
|
|
BookmarkGrid BGrid = namespaces.get(sortedNamespaceIndex);
|
|
BookmarkStackMeta meta = BGrid.getMetadata(sortedStackIndex);
|
|
ItemStack stack = BGrid.getItem(sortedStackIndex);
|
|
BGrid.removeItem(sortedStackIndex);
|
|
|
|
((BookmarkGrid) grid).addItem(stack, meta);
|
|
|
|
sortedNamespaceIndex = activeNamespaceIndex;
|
|
sortedStackIndex = grid.size() - 1;
|
|
}
|
|
|
|
if (mouseOverSlot.slotIndex != sortedStackIndex) {
|
|
((BookmarkGrid) grid).moveItem(sortedStackIndex, mouseOverSlot.slotIndex);
|
|
sortedStackIndex = mouseOverSlot.slotIndex;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
super.mouseDragged(mousex, mousey, button, heldTime);
|
|
}
|
|
|
|
private ItemPanelSlot getNextSlot(int mousex, int mousey)
|
|
{
|
|
int idx = grid.getPage() * grid.getPerPage() - grid.getPerPage();
|
|
int gSize = grid.size();
|
|
|
|
for (int i = 0; i < grid.getRows() * grid.getColumns() && idx <= gSize; i++) {
|
|
|
|
if (!grid.isInvalidSlot(i)) {
|
|
|
|
if (idx == gSize && grid.getSlotRect(i).contains(mousex, mousey)) {
|
|
return new ItemPanelSlot(idx, null);
|
|
}
|
|
|
|
idx++;
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@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;
|
|
}
|
|
|
|
super.postDraw(mousex, mousey);
|
|
}
|
|
|
|
@Override
|
|
protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot)
|
|
{
|
|
ItemStack stack = grid.getItem(mouseDownSlot);
|
|
|
|
return stack != null? stack.copy(): null;
|
|
}
|
|
|
|
@Override
|
|
public void mouseUp(int mousex, int mousey, int button)
|
|
{
|
|
if (sortedStackIndex != -1) {
|
|
draggedStack = null;
|
|
sortedNamespaceIndex = -1;
|
|
sortedStackIndex = -1;
|
|
mouseDownSlot = -1;
|
|
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();
|
|
}
|
|
|
|
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 BookmarkStackMeta meta = BGrid.getMetadata(slot.slotIndex);
|
|
final boolean addFullRecipe = NEIClientUtils.shiftKey();
|
|
|
|
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)) {
|
|
NBTTagCompound nbTag = StackInfo.itemStackToNBT(BGrid.getItem(slotIndex), true);
|
|
nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + iMeta.factor * shift, iMeta.factor));
|
|
BGrid.replaceItem(slotIndex, StackInfo.loadFromNBT(nbTag));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NBTTagCompound nbTag = StackInfo.itemStackToNBT(slot.item, true);
|
|
nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + meta.factor * shift, meta.factor));
|
|
BGrid.replaceItem(slot.slotIndex, StackInfo.loadFromNBT(nbTag));
|
|
|
|
saveBookmarks();
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
return super.onMouseWheel(shift, mousex, mousey);
|
|
}
|
|
|
|
}
|