Collapsibleitems (#506)

* Create Collapsible Items; Presets refactoring

* change lang

* fix preset settings

* fix .top

* fix tooltip

---------

Co-authored-by: slprime <[email protected]>
This commit is contained in:
slprimeandslprime authored and GitHub committed 2024-07-26 22:44:54 +07:00
1 parent 1774685af6
commit d61a545d9d
28 files changed
+2678 -1216

No files matched your search

@@ -113,8 +113,13 @@ public class GuiItemSorter extends GuiOptionPane {
if (nslot != list.indexOf(dragged.e)) {
list.remove(dragged.e);
list.add(nslot, dragged.e);
opt.getTag().setValue(ItemSorter.getSaveString(list));
if (opt.activeTag() == opt.getTag()) ItemSorter.list = new ArrayList<>(list);
LayoutManager.markItemsDirty();
if (opt.activeTag() == opt.getTag()) {
ItemSorter.list = new ArrayList<>(list);
}
}
}
}
@@ -80,7 +80,7 @@ public class OptionTextField extends Option {
public List<String> handleTooltip(int mousex, int mousey, List<String> currenttip) {
if (new Rectangle4i(10, 0, textField.x - 10, 20).contains(mousex, mousey)) {
String tip = translateN(name + ".tip");
if (!tip.equals(name + ".tip")) currenttip.add(tip);
if (!tip.equals(namespaced(name + ".tip"))) currenttip.add(tip);
}
return currenttip;
}
@@ -0,0 +1,53 @@
package codechicken.nei.config.preset;
import static codechicken.lib.gui.GuiDraw.drawStringC;
import org.lwjgl.opengl.GL11;
import codechicken.nei.Button;
import codechicken.nei.LayoutManager;
public abstract class CheckboxButton extends Button {
protected boolean checked = false;
public CheckboxButton(String s) {
super(s);
}
public void setChecked(boolean checked) {
this.checked = checked;
this.onChange();
}
public boolean isChecked() {
return this.checked;
}
@Override
public void draw(int mousex, int mousey) {
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glColor4f(1, 1, 1, 1);
int tex;
if ((this.state & 0x3) == 2) {
tex = 0;
} else if ((this.state & 0x4) == 0 && contains(mousex, mousey) || (this.state & 0x3) == 1) {
tex = 2;
} else {
tex = 1;
}
int colour = tex == 2 ? 0xffffa0 : tex == 0 ? 0x601010 : 0xe0e0e0;
LayoutManager.drawButtonBackground(x, y, w, h, true, isChecked() ? 0 : tex);
drawStringC(getRenderLabel(), x + w / 2, y + (h - 8) / 2, colour);
}
public boolean onButtonPress(boolean rightclick) {
this.setChecked(!isChecked());
return true;
}
protected abstract void onChange();
}
@@ -0,0 +1,239 @@
package codechicken.nei.config.preset;
import static codechicken.lib.gui.GuiDraw.getStringWidth;
import java.awt.Rectangle;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import org.lwjgl.opengl.GL11;
import codechicken.core.gui.GuiCCButton;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.LayoutManager;
import codechicken.nei.NEIClientUtils;
import codechicken.nei.PresetsList;
import codechicken.nei.PresetsList.Preset;
import codechicken.nei.config.GuiOptionPane;
import codechicken.nei.config.Option;
public class GuiPresetList extends GuiOptionPane {
private final Option opt;
protected final static int SLOT_HEIGHT = 24;
protected final static int BUTTON_HEIGHT = 20;
protected GuiCCButton createButton;
protected int sortingItemIndex = -1;
public GuiPresetList(Option opt) {
this.opt = opt;
this.createButton = new GuiCCButton(0, 2, 0, 16, NEIClientUtils.translate("presets.new"))
.setActionCommand("create");
}
@Override
public void initGui() {
super.initGui();
this.createButton.width = getStringWidth(this.createButton.text) + 15;
this.createButton.x = width - this.createButton.width - 15;
}
@Override
public void addWidgets() {
super.addWidgets();
add(this.createButton);
}
@Override
public void actionPerformed(String ident, Object... params) {
super.actionPerformed(ident, params);
if (ident.equals("create")) {
cretePreset();
}
}
protected void mouseClicked(int x, int y, int button) {
super.mouseClicked(x, y, button);
}
@Override
protected void mouseMovedOrUp(int x, int y, int button) {
super.mouseMovedOrUp(x, y, button);
if (sortingItemIndex >= 0) {
PresetsList.savePresets();
} else if (button == 0) {
int slot = getSlotMouseOver(x, y);
if (slot != -1) {
Rectangle w = pane.windowBounds();
int mx = x - w.x;
if (mx <= BUTTON_HEIGHT) {
Preset preset = PresetsList.presets.get(slot);
preset.enabled = !preset.enabled;
PresetsList.savePresets();
} else if (mx >= 26 && mx <= w.width - 26 * 2) {
openPreset(slot);
} else if (mx >= w.width - BUTTON_HEIGHT) {
PresetsList.presets.remove(slot);
PresetsList.savePresets();
}
}
}
sortingItemIndex = -1;
}
@Override
protected void mouseClickMove(int x, int y, int button, long time) {
super.mouseClickMove(x, y, button, time);
if (sortingItemIndex == -1) {
Rectangle w = pane.windowBounds();
int mx = x - w.x;
if (mx >= 26 && mx <= w.width - 26 * 2) {
sortingItemIndex = getSlotMouseOver(x, y);
} else {
sortingItemIndex = -2;
}
} else if (sortingItemIndex >= 0) {
Rectangle w = pane.windowBounds();
if (y >= w.y && y <= w.y + w.height) {
int my = y + pane.scrolledPixels() - w.y;
int slot = my / SLOT_HEIGHT;
if (my % SLOT_HEIGHT < BUTTON_HEIGHT && slot < PresetsList.presets.size()
&& slot != -1
&& slot != sortingItemIndex) {
PresetsList.presets.add(slot, PresetsList.presets.remove(sortingItemIndex));
sortingItemIndex = slot;
}
}
}
}
protected int getSlotMouseOver(int x, int y) {
Rectangle w = pane.windowBounds();
if (x >= w.x && x <= w.x + w.width && y >= w.y && y <= w.y + w.height) {
int my = y + pane.scrolledPixels() - w.y;
int slot = my / SLOT_HEIGHT;
if (my % SLOT_HEIGHT < BUTTON_HEIGHT && slot < PresetsList.presets.size()) {
return slot;
}
}
return -1;
}
protected void cretePreset() {
Minecraft.getMinecraft().displayGuiScreen(new GuiPresetSettings(this, -1));
}
protected void openPreset(int slot) {
Minecraft.getMinecraft().displayGuiScreen(new GuiPresetSettings(this, slot));
}
@Override
public int contentHeight() {
return PresetsList.presets.size() * SLOT_HEIGHT;
}
@Override
public void drawContent(int mx, int my, float frame) {
int scrolled = pane.scrolledPixels();
Rectangle w = pane.windowBounds();
int y = 0;
for (int slot = 0; slot < PresetsList.presets.size(); ++slot) {
if (y + SLOT_HEIGHT > scrolled && y < scrolled + w.height) {
if (sortingItemIndex != slot) {
drawSlot(w, slot, w.x, w.y + y - scrolled, mx, my - y);
}
}
y += SLOT_HEIGHT;
}
if (sortingItemIndex >= 0) {
drawSlot(w, sortingItemIndex, w.x, w.y + my - scrolled - BUTTON_HEIGHT / 2, mx, my - y);
}
}
protected void drawSlot(Rectangle w, int slot, int x, int y, int mx, int my) {
final Rectangle4i delete = new Rectangle4i(x + w.width - BUTTON_HEIGHT, y, BUTTON_HEIGHT, BUTTON_HEIGHT);
final Rectangle4i enabled = new Rectangle4i(x, y, BUTTON_HEIGHT, BUTTON_HEIGHT);
final Rectangle4i option = new Rectangle4i(x + 26, y, w.width - 26 * 2, BUTTON_HEIGHT);
final int enabledState = y + my >= w.y && y + my <= w.y + w.height && enabled.contains(x + mx, y + my) ? 2 : 1;
final int optionState = y + my >= w.y && y + my <= w.y + w.height && option.contains(x + mx, y + my) ? 2 : 1;
final int deleteState = y + my >= w.y && y + my <= w.y + w.height && delete.contains(x + mx, y + my) ? 2 : 1;
final Preset preset = PresetsList.presets.get(slot);
final String displayName = preset.name;
final String modeName;
switch (preset.mode) {
case HIDE:
modeName = NEIClientUtils.translate("presets.mode.hide.char");
break;
case REMOVE:
modeName = NEIClientUtils.translate("presets.mode.remove.char");
break;
case GROUP:
modeName = NEIClientUtils.translate("presets.mode.group.char");
break;
default:
modeName = "?";
break;
}
// enabled icon
GL11.glColor4f(1, 1, 1, 1);
LayoutManager.drawButtonBackground(
enabled.x,
enabled.y,
enabled.w,
enabled.h,
true,
preset.enabled ? 0 : enabledState);
GuiDraw.drawString("✔", enabled.x + 7, enabled.y + 6, enabledState == 2 ? 0xFFFFFFA0 : 0xFFE0E0E0);
// preset name
GL11.glColor4f(1, 1, 1, 1);
LayoutManager.drawButtonBackground(option.x, option.y, option.w, option.h, true, optionState);
GuiDraw.drawString("⋮⋮", option.x + 4, option.y + 5, optionState == 2 ? 0xFFFFFFA0 : 0xFFE0E0E0);
GuiDraw.drawString(
NEIClientUtils.cropText(this.fontRendererObj, modeName + ": " + displayName, option.w - 16),
option.x + 6 + 4,
option.y + 6,
optionState == 2 ? 0xFFFFFFA0 : 0xFFE0E0E0);
// remove icon
GL11.glColor4f(1, 1, 1, 1);
LayoutManager.drawButtonBackground(delete.x, delete.y, delete.w, delete.h, true, deleteState);
GuiDraw.drawString("✕", delete.x + 7, delete.y + 6, deleteState == 2 ? 0xFFFFFFA0 : 0xFFE0E0E0);
}
@Override
public GuiScreen getParentScreen() {
return opt.slot.getGui();
}
@Override
public String getTitle() {
return opt.translateN(opt.name);
}
}
@@ -0,0 +1,228 @@
package codechicken.nei.config.preset;
import java.util.LinkedList;
import java.util.List;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.Rectangle;
import codechicken.core.gui.GuiScreenWidget;
import codechicken.nei.Button;
import codechicken.nei.NEIClientUtils;
import codechicken.nei.PresetsList;
import codechicken.nei.PresetsList.Preset;
import codechicken.nei.config.OptionScrollPane;
import codechicken.nei.guihook.GuiContainerManager;
public class GuiPresetSettings extends GuiScreenWidget {
protected final Preset preset;
protected final GuiScreen parent;
protected final int slotIndex;
public int marginleft;
public int margintop;
public int marginright;
public int marginbottom;
protected LeftPanel leftPanel;
protected RightPanel rightPanel;
protected Button backButton;
protected Button saveButton;
public GuiPresetSettings(GuiScreen parent, int slotIndex) {
this.parent = parent;
this.setMargins(6, 20, 6, 30);
this.slotIndex = slotIndex;
if (slotIndex == -1) {
preset = new Preset();
} else {
preset = PresetsList.presets.get(slotIndex).copy();
}
leftPanel = new LeftPanel(preset) {
@Override
protected void onItemsChanges() {
leftPanel.grid.restartFilter();
}
};
rightPanel = new RightPanel(preset, slotIndex) {
@Override
protected void onItemsChanges() {
leftPanel.grid.restartFilter();
}
};
backButton = new Button(NEIClientUtils.translate("options.back")) {
public boolean onButtonPress(boolean rightclick) {
Minecraft.getMinecraft().displayGuiScreen(parent);
return true;
}
};
saveButton = new Button(NEIClientUtils.translate("options.save")) {
public boolean onButtonPress(boolean rightclick) {
if (state == 0) {
if (slotIndex == -1) {
PresetsList.presets.add(preset);
} else {
PresetsList.presets.set(slotIndex, preset);
}
PresetsList.savePresets();
Minecraft.getMinecraft().displayGuiScreen(parent);
return true;
}
return false;
}
};
add(this.leftPanel);
add(this.rightPanel);
}
protected void setMargins(int left, int top, int right, int bottom) {
this.marginleft = left;
this.margintop = top;
this.marginright = right;
this.marginbottom = bottom;
}
protected Rectangle windowBounds() {
return new Rectangle(
this.marginleft,
this.margintop,
this.width - this.marginleft - this.marginright,
this.height - this.margintop - this.marginbottom);
}
@Override
public boolean doesGuiPauseGame() {
return true;
}
@Override
public void updateScreen() {
final Rectangle bounds = windowBounds();
final int panelWidth = bounds.getWidth() * 2 / 5;
this.leftPanel.setSize(bounds.getX(), bounds.getY() + 4, panelWidth, bounds.getHeight() - 6);
this.rightPanel.setSize(
bounds.getX() + bounds.getWidth() - panelWidth,
bounds.getY() + 4,
panelWidth,
bounds.getHeight() - 6);
final int w = Math.min(200, width - 40);
backButton.w = w / 2 - 3;
backButton.h = 20;
backButton.x = (width - w) / 2;
backButton.y = height - 25;
saveButton.state = preset.name.isEmpty() || preset.mode == null || preset.items.isEmpty() ? 2 : 0;
saveButton.w = w / 2 - 3;
saveButton.h = 20;
saveButton.x = width / 2 + 3;
saveButton.y = height - 25;
super.updateScreen();
}
@Override
public void resize() {
this.guiLeft = this.guiTop = 0;
}
@Override
public void drawScreen(int mousex, int mousey, float f) {
Rectangle bounds = windowBounds();
drawDefaultBackground();
drawOverlay(bounds.getY(), bounds.getHeight(), width, zLevel);
drawCenteredString(
Minecraft.getMinecraft().fontRenderer,
NEIClientUtils.translate(this.slotIndex == -1 ? "presets.create" : "presets.update"),
width / 2,
6,
-1);
backButton.draw(mousex, mousey);
saveButton.draw(mousex, mousey);
super.drawScreen(mousex, mousey, f);
List<String> tooltip = new LinkedList<>();
tooltip = leftPanel.handleTooltip(mousex, mousey, tooltip);
tooltip = rightPanel.handleTooltip(mousex, mousey, tooltip);
GuiContainerManager.drawPagedTooltip(Minecraft.getMinecraft().fontRenderer, mousex + 12, mousey - 12, tooltip);
}
@Override
protected void mouseClicked(int x, int y, int button) {
super.mouseClicked(x, y, button);
if (backButton.contains(x, y)) {
backButton.handleClick(x, y, button);
}
if (saveButton.contains(x, y)) {
saveButton.handleClick(x, y, button);
}
}
public static void drawOverlay(int y, int height, int screenwidth, float zLevel) {
OptionScrollPane.drawOverlayTex(0, 0, screenwidth, y, zLevel);
OptionScrollPane.drawOverlayTex(0, y + height, screenwidth, screenwidth - y - height, zLevel);
OptionScrollPane.drawOverlayGrad(0, screenwidth, y, y + 4, zLevel);
OptionScrollPane.drawOverlayGrad(0, screenwidth, y + height, y + height - 4, zLevel);
}
public static void drawOverlayTex(int x, int y, int w, int h, float zLevel) {
GL11.glColor4f(1, 1, 1, 1);
Minecraft.getMinecraft().renderEngine.bindTexture(Gui.optionsBackground);
Tessellator t = Tessellator.instance;
t.startDrawingQuads();
t.addVertexWithUV(x, y, zLevel, 0, 0);
t.addVertexWithUV(x, y + h, zLevel, 0, h / 16D);
t.addVertexWithUV(x + w, y + h, zLevel, w / 16D, h / 16D);
t.addVertexWithUV(x + w, y, zLevel, w / 16D, 0);
t.draw();
}
public static void drawOverlayGrad(int x1, int x2, int y1, int y2, float zLevel) {
GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glDisable(GL11.GL_CULL_FACE);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glShadeModel(GL11.GL_SMOOTH);
Tessellator t = Tessellator.instance;
t.startDrawingQuads();
t.setColorRGBA_I(0, 255);
t.addVertex(x2, y1, zLevel);
t.addVertex(x1, y1, zLevel);
t.setColorRGBA_I(0, 0);
t.addVertex(x1, y2, zLevel);
t.addVertex(x2, y2, zLevel);
t.draw();
GL11.glDisable(GL11.GL_BLEND);
GL11.glEnable(GL11.GL_CULL_FACE);
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
}
@@ -0,0 +1,327 @@
package codechicken.nei.config.preset;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.item.ItemStack;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import codechicken.core.gui.GuiWidget;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemList.AllMultiItemFilter;
import codechicken.nei.ItemPanel.ItemPanelSlot;
import codechicken.nei.ItemsGrid;
import codechicken.nei.Label;
import codechicken.nei.NEIClientUtils;
import codechicken.nei.PresetsList.Preset;
import codechicken.nei.PresetsList.PresetMode;
import codechicken.nei.TextField;
import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemInfo;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerTooltipHandler;
public class LeftPanel extends GuiWidget {
protected static class MouseSelection {
public int startX = -1;
public int startY = -1;
public int startIndex = -1;
public int endIndex = -1;
public Set<ItemStack> items = new HashSet<>();
public MouseSelection(int slotIndex, Rectangle4i rec) {
endIndex = slotIndex;
startIndex = slotIndex;
startX = rec.x;
startY = rec.y;
}
}
protected static final int INPUT_HEIGHT = 20;
public final PresetItemsGrid grid = new PresetItemsGrid() {
@Override
protected ItemFilter getFilter() {
Set<String> identifiers = preset.items;
return new AllMultiItemFilter(
item -> !ItemInfo.hiddenItems.contains(item),
item -> identifiers.contains(Preset.getIdentifier(item)));
}
@Override
protected boolean isSelected(ItemStack stack) {
return mouseSelection != null && mouseSelection.items.contains(stack);
}
};
protected Label nameLabel = new Label(NEIClientUtils.translate("presets.name"), false);
protected TextField nameField = new TextField("name") {
@Override
public void onTextChange(String oldText) {
preset.name = text();
}
};
protected Label modeLabel = new Label(NEIClientUtils.translate("presets.mode"), false);
protected CheckboxButton modeHide;
protected CheckboxButton modeRemove;
protected CheckboxButton modeGroup;
protected CheckboxButton enabledButton;
protected final Preset preset;
protected MouseSelection mouseSelection;
public LeftPanel(Preset preset) {
super(1, 0, 2, 2);
this.preset = preset;
nameField.setText(preset.name);
modeHide = new CheckboxButton(NEIClientUtils.translate("presets.mode.hide")) {
@Override
public boolean isChecked() {
return preset.mode == PresetMode.HIDE;
}
@Override
protected void onChange() {
preset.mode = this.checked ? PresetMode.HIDE : null;
}
};
modeRemove = new CheckboxButton(NEIClientUtils.translate("presets.mode.remove")) {
@Override
public boolean isChecked() {
return preset.mode == PresetMode.REMOVE;
}
@Override
protected void onChange() {
preset.mode = this.checked ? PresetMode.REMOVE : null;
}
};
modeGroup = new CheckboxButton(NEIClientUtils.translate("presets.mode.group")) {
@Override
public boolean isChecked() {
return preset.mode == PresetMode.GROUP;
}
@Override
protected void onChange() {
preset.mode = this.checked ? PresetMode.GROUP : null;
}
};
enabledButton = new CheckboxButton(NEIClientUtils.translate("presets.enabled")) {
@Override
public boolean isChecked() {
return preset.enabled;
}
@Override
protected void onChange() {
preset.enabled = this.checked;
}
};
grid.restartFilter();
}
public void mouseClicked(int x, int y, int button) {
grid.mouseClicked(x, y, button);
if (modeHide.contains(x, y)) {
modeHide.handleClick(x, y, button);
}
if (modeRemove.contains(x, y)) {
modeRemove.handleClick(x, y, button);
}
if (modeGroup.contains(x, y)) {
modeGroup.handleClick(x, y, button);
}
if (enabledButton.contains(x, y)) {
enabledButton.handleClick(x, y, button);
}
if (nameField.contains(x, y)) {
nameField.handleClick(x, y, button);
} else {
nameField.onGuiClick(x, y);
}
if (mouseSelection == null && button == 0) {
ItemPanelSlot slot = grid.getSlotMouseOver(x, y);
if (slot != null) {
mouseSelection = new MouseSelection(slot.slotIndex, grid.getItemRect(slot.slotIndex));
}
}
}
protected void onItemsChanges() {}
public void mouseMovedOrUp(int x, int y, int button) {
nameField.mouseUp(x, y, button);
if (mouseSelection != null && button == 0) {
ItemPanelSlot hoverSlot = grid.getSlotMouseOver(x, y);
if (hoverSlot != null && hoverSlot.slotIndex == mouseSelection.startIndex) {
preset.items.remove(Preset.getIdentifier(hoverSlot.item));
} else if (!mouseSelection.items.isEmpty()) {
for (ItemStack stack : mouseSelection.items) {
preset.items.remove(Preset.getIdentifier(stack));
}
}
mouseSelection = null;
onItemsChanges();
}
}
public void mouseDragged(int x, int y, int button, long time) {
nameField.mouseDragged(x, y, button, time);
if (mouseSelection != null && button == 0) {
final ItemPanelSlot slot = grid.getSlotMouseOver(x, y);
if (slot != null && slot.slotIndex != mouseSelection.endIndex) {
mouseSelection.endIndex = slot.slotIndex;
mouseSelection.items.clear();
final Rectangle4i rec = grid.getItemRect(slot.slotIndex);
final Rectangle4i sel = new Rectangle4i(
Math.min(rec.x, mouseSelection.startX),
Math.min(rec.y, mouseSelection.startY),
Math.max(rec.x, mouseSelection.startX) - Math.min(rec.x, mouseSelection.startX),
Math.max(rec.y, mouseSelection.startY) - Math.min(rec.y, mouseSelection.startY));
for (int ix = sel.x; ix <= sel.x + sel.w; ix += ItemsGrid.SLOT_SIZE) {
for (int iy = sel.y; iy <= sel.y + sel.h; iy += ItemsGrid.SLOT_SIZE) {
ItemPanelSlot over = grid.getSlotMouseOver(ix, iy);
if (over != null) {
mouseSelection.items.add(over.item);
}
}
}
}
}
}
public void update() {
int CHECKBOX_WIDTH = (this.width - 12) / 3;
nameLabel.x = this.x + 2;
nameLabel.y = this.y + 4;
nameLabel.w = this.width;
nameLabel.h = 10;
nameField.x = this.x;
nameField.y = nameLabel.y + nameLabel.h;
nameField.w = this.width - CHECKBOX_WIDTH - 6;
nameField.h = INPUT_HEIGHT;
enabledButton.x = nameField.x + nameField.w + 6;
enabledButton.y = nameField.y;
enabledButton.w = CHECKBOX_WIDTH;
enabledButton.h = INPUT_HEIGHT;
modeLabel.x = this.x + 2;
modeLabel.y = nameField.y + nameField.h + 6;
modeLabel.w = this.width;
modeLabel.h = 10;
modeHide.w = modeRemove.w = modeGroup.w = CHECKBOX_WIDTH;
modeHide.h = modeRemove.h = modeGroup.h = INPUT_HEIGHT;
modeHide.y = modeRemove.y = modeGroup.y = modeLabel.y + modeLabel.h;
modeHide.x = this.x + 1;
modeRemove.x = modeHide.x + modeHide.w + 6;
modeGroup.x = modeRemove.x + modeRemove.w + 6;
grid.setGridSize(
this.x + 1,
modeHide.y + modeHide.h + 2,
this.width - 2,
this.height - (modeHide.y + modeHide.h + 2));
grid.refresh(null);
}
public void draw(int mousex, int mousey, float frame) {
nameLabel.draw(mousex, mousey);
nameField.draw(mousex, mousey);
modeLabel.draw(mousex, mousey);
modeHide.draw(mousex, mousey);
modeRemove.draw(mousex, mousey);
modeGroup.draw(mousex, mousey);
enabledButton.draw(mousex, mousey);
RenderHelper.enableGUIStandardItemLighting();
GL11.glPushMatrix();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
grid.draw(mousex, mousey);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
GL11.glPopMatrix();
RenderHelper.enableStandardItemLighting();
}
public List<String> handleTooltip(int mousex, int mousey, List<String> tooltip) {
ItemPanelSlot over = grid.getSlotMouseOver(mousex, mousey);
if (over != null) {
tooltip = GuiContainerManager.itemDisplayNameMultiline(over.item, null, true);
synchronized (GuiContainerManager.tooltipHandlers) {
for (IContainerTooltipHandler handler : GuiContainerManager.tooltipHandlers) {
tooltip = handler.handleItemTooltip(null, over.item, mousex, mousey, tooltip);
}
}
if (tooltip.size() > 0) {
tooltip.set(0, tooltip.get(0) + GuiDraw.TOOLTIP_LINESPACE); // add space after 'title'
}
} else if (modeHide.contains(mousex, mousey)) {
tooltip.add(NEIClientUtils.translate("presets.mode.hide.tip"));
} else if (modeRemove.contains(mousex, mousey)) {
tooltip.add(NEIClientUtils.translate("presets.mode.remove.tip"));
} else if (modeGroup.contains(mousex, mousey)) {
tooltip.add(NEIClientUtils.translate("presets.mode.group.tip"));
}
return tooltip;
}
public void keyTyped(char c, int keycode) {
nameField.handleKeyPress(keycode, c);
}
}
@@ -0,0 +1,167 @@
package codechicken.nei.config.preset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.Button;
import codechicken.nei.ItemList;
import codechicken.nei.ItemPanel.ItemPanelSlot;
import codechicken.nei.ItemSorter;
import codechicken.nei.ItemsGrid;
import codechicken.nei.Label;
import codechicken.nei.RestartableTask;
import codechicken.nei.api.ItemFilter;
public abstract class PresetItemsGrid extends ItemsGrid {
protected static final int BUTTON_SIZE = 16;
public Button pagePrev;
public Label pageLabel;
public Button pageNext;
protected ArrayList<ItemStack> newItems;
protected final RestartableTask updateFilter = new RestartableTask("NEI Presets Item Filtering") {
@Override
public void execute() {
ArrayList<ItemStack> filtered;
ItemFilter filter = getFilter();
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;
ItemSorter.sort(filtered);
if (interrupted()) return;
updateItemList(filtered);
}
};
public PresetItemsGrid() {
pageLabel = new Label("0/0", true);
pagePrev = new Button("<") {
public boolean onButtonPress(boolean rightclick) {
if (rightclick) {
setPage(0);
} else {
shiftPage(-1);
}
return true;
}
};
pageNext = new Button(">") {
public boolean onButtonPress(boolean rightclick) {
if (rightclick) {
setPage(getNumPages() - 1);
} else {
shiftPage(1);
}
return true;
}
};
}
protected String getLabelText() {
return String.format("%d/%d", getPage(), Math.max(1, getNumPages()));
}
@Override
public void setGridSize(int mleft, int mtop, int w, int h) {
pageLabel.text = getLabelText();
pagePrev.w = pageNext.w = BUTTON_SIZE;
pagePrev.h = pageNext.h = BUTTON_SIZE;
pagePrev.y = pageNext.y = mtop;
pagePrev.x = mleft;
pageNext.x = mleft + w - pageNext.w;
pageLabel.x = mleft + w / 2;
pageLabel.y = pagePrev.y + 5;
super.setGridSize(mleft, mtop + BUTTON_SIZE + 2, w, h - BUTTON_SIZE - 4);
}
@Override
public void draw(int mousex, int mousey) {
pagePrev.draw(mousex, mousey);
pageNext.draw(mousex, mousey);
pageLabel.draw(mousex, mousey);
super.draw(mousex, mousey);
}
public void mouseClicked(int x, int y, int button) {
if (pagePrev.contains(x, y)) {
pagePrev.handleClick(x, y, button);
}
if (pageNext.contains(x, y)) {
pageNext.handleClick(x, y, button);
}
}
public void restartFilter() {
updateFilter.restart();
}
protected void updateItemList(List<ItemStack> newItems) {
this.newItems = new ArrayList<>(newItems);
}
@Override
public void refresh(GuiContainer gui) {
if (this.newItems != null) {
this.realItems = this.newItems;
this.newItems = null;
onItemsChanged();
}
super.refresh(gui);
}
@Override
protected void beforeDrawSlot(@Nullable ItemPanelSlot focused, int slotIdx, Rectangle4i rect) {
if (isSelected(getItem(slotIdx))) {
GuiDraw.drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);
} else {
super.beforeDrawSlot(focused, slotIdx, rect);
}
}
protected abstract boolean isSelected(ItemStack stack);
protected abstract ItemFilter getFilter();
}
@@ -0,0 +1,396 @@
package codechicken.nei.config.preset;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import codechicken.core.gui.GuiWidget;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemList;
import codechicken.nei.ItemList.AllMultiItemFilter;
import codechicken.nei.ItemList.AnyMultiItemFilter;
import codechicken.nei.ItemList.NegatedItemFilter;
import codechicken.nei.ItemPanel.ItemPanelSlot;
import codechicken.nei.ItemsGrid;
import codechicken.nei.NEIClientConfig;
import codechicken.nei.NEIClientUtils;
import codechicken.nei.PresetsList;
import codechicken.nei.PresetsList.Preset;
import codechicken.nei.SearchField.GuiSearchField;
import codechicken.nei.TextField;
import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemInfo;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerTooltipHandler;
import codechicken.nei.util.TextHistory;
import cpw.mods.fml.common.registry.GameRegistry;
public class RightPanel extends GuiWidget {
protected static class MouseSelection {
public int startX = -1;
public int startY = -1;
public int startIndex = -1;
public int endIndex = -1;
public Set<ItemStack> items = new HashSet<>();
public boolean append = true;
public MouseSelection(int slotIndex, Rectangle4i rec, boolean ppnd) {
append = ppnd;
endIndex = slotIndex;
startIndex = slotIndex;
startX = rec.x;
startY = rec.y;
}
}
protected static abstract class PresetSearchField extends TextField {
private static final TextHistory history = new TextHistory();
public PresetSearchField(String ident) {
super(ident);
}
@Override
protected void initInternalTextField() {
field = new GuiSearchField();
field.setMaxStringLength(maxSearchLength);
field.setCursorPositionZero();
}
@Override
public int getTextColour() {
if (!text().isEmpty()) {
return focused() ? 0xFFcc3300 : 0xFF993300;
} else {
return focused() ? 0xFFE0E0E0 : 0xFF909090;
}
}
@Override
public void lastKeyTyped(int keyID, char keyChar) {
if (!focused() && NEIClientConfig.isKeyHashDown("gui.search")) {
setFocus(true);
}
if (focused() && NEIClientConfig.isKeyHashDown("gui.getprevioussearch")) {
handleNavigateHistory(TextHistory.Direction.PREVIOUS);
}
if (focused() && NEIClientConfig.isKeyHashDown("gui.getnextsearch")) {
handleNavigateHistory(TextHistory.Direction.NEXT);
}
}
@Override
public String filterText(String s) {
return EnumChatFormatting.getTextWithoutFormattingCodes(s);
}
public ItemFilter getFilter() {
return ((GuiSearchField) field).getFilter();
}
@Override
public void setFocus(boolean focus) {
final boolean previousFocus = field.isFocused();
if (previousFocus != focus) {
history.add(text());
}
super.setFocus(focus);
}
private boolean handleNavigateHistory(TextHistory.Direction direction) {
if (focused()) {
return history.get(direction, text()).map(newText -> {
setText(newText);
return true;
}).orElse(false);
}
return false;
}
}
protected static final int INPUT_HEIGHT = 20;
protected static final int BUTTON_SIZE = 16;
protected final PresetItemsGrid grid = new PresetItemsGrid() {
@Override
protected ItemFilter getFilter() {
AllMultiItemFilter filter = new AllMultiItemFilter();
filter.filters.add(item -> !ItemInfo.hiddenItems.contains(item));
filter.filters.add(searchField.getFilter());
if (enabledPresets.isChecked()) {
AllMultiItemFilter andFilter = new AllMultiItemFilter();
AnyMultiItemFilter orFilter = new AnyMultiItemFilter();
Set<String> identifiers = PresetsList.presets.stream().flatMap(p -> p.items.stream())
.collect(Collectors.toSet());
andFilter.filters.add(item -> !identifiers.contains(Preset.getIdentifier(item)));
andFilter.filters.add(new NegatedItemFilter(ItemList.collapsibleItems.getItemFilter()));
if (slotIndex != -1) {
orFilter.filters.add(PresetsList.presets.get(slotIndex));
}
orFilter.filters.add(andFilter);
filter.filters.add(orFilter);
}
return filter;
}
@Override
protected boolean isSelected(ItemStack stack) {
if (mouseSelection != null && mouseSelection.items.contains(stack)) {
return mouseSelection.append != false;
}
return preset.items.contains(Preset.getIdentifier(stack));
}
};
protected CheckboxButton enabledPresets;
protected final Preset preset;
protected final int slotIndex;
protected MouseSelection mouseSelection;
protected final PresetSearchField searchField = new PresetSearchField("preset-search") {
@Override
public void onTextChange(String oldText) {
final String newText = text();
if (!newText.equals(oldText)) {
grid.restartFilter();
}
}
};
public RightPanel(Preset preset, int slotIndex) {
super(1, 0, 2, 2);
this.slotIndex = slotIndex;
this.preset = preset;
enabledPresets = new CheckboxButton(NEIClientUtils.translate("presets.filter")) {
@Override
protected void onChange() {
grid.restartFilter();
}
};
enabledPresets.setChecked(true);
grid.restartFilter();
}
public void mouseClicked(int x, int y, int button) {
grid.mouseClicked(x, y, button);
if (enabledPresets.contains(x, y)) {
enabledPresets.handleClick(x, y, button);
}
if (searchField.contains(x, y)) {
searchField.handleClick(x, y, button);
} else {
searchField.onGuiClick(x, y);
}
if (mouseSelection == null && (button == 0 || button == 1)) {
ItemPanelSlot slot = grid.getSlotMouseOver(x, y);
if (slot != null) {
mouseSelection = new MouseSelection(slot.slotIndex, grid.getItemRect(slot.slotIndex), button == 0);
}
}
}
protected void onItemsChanges() {}
public void mouseMovedOrUp(int x, int y, int button) {
searchField.mouseUp(x, y, button);
if (mouseSelection != null && (button == 0 || button == 1)) {
ItemPanelSlot hoverSlot = grid.getSlotMouseOver(x, y);
if (hoverSlot != null && hoverSlot.slotIndex == mouseSelection.startIndex) {
setHidden(hoverSlot.item, button == 0);
} else if (!mouseSelection.items.isEmpty()) {
for (ItemStack stack : mouseSelection.items) {
hideItem(stack, mouseSelection.append);
}
}
mouseSelection = null;
onItemsChanges();
}
}
protected void setHidden(final ItemStack stack, final boolean append) {
if (NEIClientUtils.shiftKey()) {
final List<ItemStack> items = grid.getItems();
for (int i = 0; i < items.size(); i++) {
if (stack.getItem().equals(items.get(i).getItem())) {
hideItem(items.get(i), append);
}
}
} else if (NEIClientUtils.controlKey()) {
final String modId = getModId(stack);
if (modId == null) {
hideItem(stack, append);
} else {
final List<ItemStack> items = grid.getItems();
for (int i = 0; i < items.size(); i++) {
final String mod = getModId(items.get(i));
if (mod != null && mod.equals(modId)) {
hideItem(items.get(i), append);
}
}
}
} else {
hideItem(stack, append);
}
}
protected void hideItem(final ItemStack stack, boolean append) {
if (append) {
preset.items.add(Preset.getIdentifier(stack));
} else {
preset.items.remove(Preset.getIdentifier(stack));
}
}
protected static String getModId(final ItemStack stack) {
try {
return GameRegistry.findUniqueIdentifierFor(stack.getItem()).modId;
} catch (Exception ignored) {}
return null;
}
public void mouseDragged(int x, int y, int button, long time) {
searchField.mouseDragged(x, y, button, time);
if (mouseSelection != null && (button == 0 || button == 1)) {
final ItemPanelSlot slot = grid.getSlotMouseOver(x, y);
if (slot != null && slot.slotIndex != mouseSelection.endIndex) {
mouseSelection.endIndex = slot.slotIndex;
mouseSelection.items.clear();
final Rectangle4i rec = grid.getItemRect(slot.slotIndex);
final Rectangle4i sel = new Rectangle4i(
Math.min(rec.x, mouseSelection.startX),
Math.min(rec.y, mouseSelection.startY),
Math.max(rec.x, mouseSelection.startX) - Math.min(rec.x, mouseSelection.startX),
Math.max(rec.y, mouseSelection.startY) - Math.min(rec.y, mouseSelection.startY));
for (int ix = sel.x; ix <= sel.x + sel.w; ix += ItemsGrid.SLOT_SIZE) {
for (int iy = sel.y; iy <= sel.y + sel.h; iy += ItemsGrid.SLOT_SIZE) {
ItemPanelSlot over = grid.getSlotMouseOver(ix, iy);
if (over != null) {
mouseSelection.items.add(over.item);
}
}
}
}
}
}
public void update() {
enabledPresets.w = 20;
enabledPresets.h = INPUT_HEIGHT;
enabledPresets.x = this.x;
enabledPresets.y = this.y + this.height - 2 - INPUT_HEIGHT;
searchField.w = this.width - enabledPresets.w - 3;
searchField.h = INPUT_HEIGHT;
searchField.x = enabledPresets.x + enabledPresets.w + 3;
searchField.y = enabledPresets.y;
grid.setGridSize(this.x, this.y, this.width, searchField.y - this.y);
grid.refresh(null);
}
public void draw(int mousex, int mousey, float frame) {
enabledPresets.draw(mousex, mousey);
searchField.draw(mousex, mousey);
RenderHelper.enableGUIStandardItemLighting();
GL11.glPushMatrix();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
grid.draw(mousex, mousey);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
GL11.glPopMatrix();
RenderHelper.enableStandardItemLighting();
}
public List<String> handleTooltip(int mousex, int mousey, List<String> tooltip) {
ItemPanelSlot over = grid.getSlotMouseOver(mousex, mousey);
if (over != null) {
tooltip = GuiContainerManager.itemDisplayNameMultiline(over.item, null, true);
synchronized (GuiContainerManager.tooltipHandlers) {
for (IContainerTooltipHandler handler : GuiContainerManager.tooltipHandlers) {
tooltip = handler.handleItemTooltip(null, over.item, mousex, mousey, tooltip);
}
}
if (tooltip.size() > 0) {
tooltip.set(0, tooltip.get(0) + GuiDraw.TOOLTIP_LINESPACE); // add space after 'title'
}
} else if (enabledPresets.contains(mousex, mousey)) {
tooltip.add(NEIClientUtils.translate("presets.filter.tip"));
}
return tooltip;
}
public void keyTyped(char c, int keycode) {
searchField.handleKeyPress(keycode, c);
}
public void mouseScrolled(int x, int y, int scroll) {
if (grid.contains(x, y)) {
grid.shiftPage(-scroll);
}
}
}