mirror of
https://github.com/VolmitSoftware/Iris.git
synced 2025-07-20 03:04:08 +00:00
547 lines
9.9 KiB
Java
547 lines
9.9 KiB
Java
package com.volmit.iris.util;
|
|
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.EventHandler;
|
|
import org.bukkit.event.HandlerList;
|
|
import org.bukkit.event.Listener;
|
|
import org.bukkit.event.inventory.InventoryClickEvent;
|
|
import org.bukkit.event.inventory.InventoryCloseEvent;
|
|
import org.bukkit.event.inventory.InventoryType;
|
|
import org.bukkit.inventory.Inventory;
|
|
import org.bukkit.inventory.ItemStack;
|
|
|
|
import com.volmit.iris.Iris;
|
|
|
|
public class UIWindow implements Window, Listener
|
|
{
|
|
private WindowDecorator decorator;
|
|
private final Player viewer;
|
|
private Callback<Window> eClose;
|
|
private WindowResolution resolution;
|
|
private KMap<Integer, Element> elements;
|
|
private String title;
|
|
private boolean visible;
|
|
private int viewportPosition;
|
|
private int viewportSize;
|
|
private int highestRow;
|
|
private Inventory inventory;
|
|
private int clickcheck;
|
|
private boolean doubleclicked;
|
|
|
|
public UIWindow(Player viewer)
|
|
{
|
|
clickcheck = 0;
|
|
doubleclicked = false;
|
|
this.viewer = viewer;
|
|
this.elements = new KMap<>();
|
|
setTitle("");
|
|
setDecorator(new UIVoidDecorator());
|
|
setResolution(WindowResolution.W9_H6);
|
|
setViewportHeight((int) clip(3, 1, getResolution().getMaxHeight()).intValue());
|
|
setViewportPosition(0);
|
|
}
|
|
|
|
@EventHandler
|
|
public void on(InventoryClickEvent e)
|
|
{
|
|
if(!e.getWhoClicked().equals(viewer))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!isVisible())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 1.14 bukkit api change, removed getTitle() and getName() from Inventory.class
|
|
if(!viewer.getOpenInventory().getTitle().equals(title))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(e.getClickedInventory() == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!e.getView().getType().equals(getResolution().getType()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(e.getClickedInventory().getType().equals(getResolution().getType()))
|
|
{
|
|
Element element = getElement(getLayoutPosition(e.getSlot()), getLayoutRow(e.getSlot()));
|
|
|
|
switch(e.getAction())
|
|
{
|
|
case CLONE_STACK:
|
|
break;
|
|
case COLLECT_TO_CURSOR:
|
|
break;
|
|
case DROP_ALL_CURSOR:
|
|
break;
|
|
case DROP_ALL_SLOT:
|
|
break;
|
|
case DROP_ONE_CURSOR:
|
|
break;
|
|
case DROP_ONE_SLOT:
|
|
break;
|
|
case HOTBAR_MOVE_AND_READD:
|
|
break;
|
|
case HOTBAR_SWAP:
|
|
break;
|
|
case MOVE_TO_OTHER_INVENTORY:
|
|
break;
|
|
case NOTHING:
|
|
break;
|
|
case PICKUP_ALL:
|
|
break;
|
|
case PICKUP_HALF:
|
|
break;
|
|
case PICKUP_ONE:
|
|
break;
|
|
case PICKUP_SOME:
|
|
break;
|
|
case PLACE_ALL:
|
|
break;
|
|
case PLACE_ONE:
|
|
break;
|
|
case PLACE_SOME:
|
|
break;
|
|
case SWAP_WITH_CURSOR:
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
}
|
|
|
|
switch(e.getClick())
|
|
{
|
|
case CONTROL_DROP:
|
|
break;
|
|
case CREATIVE:
|
|
break;
|
|
case DOUBLE_CLICK:
|
|
doubleclicked = true;
|
|
break;
|
|
case DROP:
|
|
break;
|
|
case LEFT:
|
|
|
|
clickcheck++;
|
|
|
|
if(clickcheck == 1)
|
|
{
|
|
J.s(() ->
|
|
{
|
|
if(clickcheck == 1)
|
|
{
|
|
clickcheck = 0;
|
|
|
|
if(element != null)
|
|
{
|
|
element.call(ElementEvent.LEFT, element);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
else if(clickcheck == 2)
|
|
{
|
|
J.s(() ->
|
|
{
|
|
if(doubleclicked)
|
|
{
|
|
doubleclicked = false;
|
|
}
|
|
|
|
else
|
|
{
|
|
scroll(1);
|
|
}
|
|
|
|
clickcheck = 0;
|
|
});
|
|
}
|
|
|
|
break;
|
|
case MIDDLE:
|
|
break;
|
|
case NUMBER_KEY:
|
|
break;
|
|
case RIGHT:
|
|
if(element != null)
|
|
{
|
|
element.call(ElementEvent.RIGHT, element);
|
|
}
|
|
|
|
else
|
|
{
|
|
scroll(-1);
|
|
}
|
|
break;
|
|
case SHIFT_LEFT:
|
|
if(element != null)
|
|
{
|
|
element.call(ElementEvent.SHIFT_LEFT, element);
|
|
}
|
|
break;
|
|
case SHIFT_RIGHT:
|
|
if(element != null)
|
|
{
|
|
element.call(ElementEvent.SHIFT_RIGHT, element);
|
|
}
|
|
break;
|
|
case WINDOW_BORDER_LEFT:
|
|
break;
|
|
case WINDOW_BORDER_RIGHT:
|
|
break;
|
|
case UNKNOWN:
|
|
break;
|
|
case SWAP_OFFHAND:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
e.setCancelled(true);
|
|
|
|
}
|
|
|
|
@EventHandler
|
|
public void on(InventoryCloseEvent e)
|
|
{
|
|
if(!e.getPlayer().equals(viewer))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!e.getPlayer().getOpenInventory().getTitle().equals(title))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(isVisible())
|
|
{
|
|
close();
|
|
callClosed();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public UIWindow setDecorator(WindowDecorator decorator)
|
|
{
|
|
this.decorator = decorator;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public WindowDecorator getDecorator()
|
|
{
|
|
return decorator;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow close()
|
|
{
|
|
setVisible(false);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow open()
|
|
{
|
|
setVisible(true);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow setVisible(boolean visible)
|
|
{
|
|
if(isVisible() == visible)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
if(visible)
|
|
{
|
|
Bukkit.getPluginManager().registerEvents(this, Iris.instance);
|
|
|
|
if(getResolution().getType().equals(InventoryType.CHEST))
|
|
{
|
|
inventory = Bukkit.createInventory(null, getViewportHeight() * 9, getTitle());
|
|
}
|
|
|
|
else
|
|
{
|
|
inventory = Bukkit.createInventory(null, getResolution().getType(), getTitle());
|
|
}
|
|
|
|
viewer.openInventory(inventory);
|
|
this.visible = visible;
|
|
updateInventory();
|
|
}
|
|
|
|
else
|
|
{
|
|
this.visible = visible;
|
|
HandlerList.unregisterAll(this);
|
|
viewer.closeInventory();
|
|
}
|
|
|
|
this.visible = visible;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean isVisible()
|
|
{
|
|
return visible;
|
|
}
|
|
|
|
@Override
|
|
public int getViewportPosition()
|
|
{
|
|
return viewportPosition;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow setViewportPosition(int viewportPosition)
|
|
{
|
|
this.viewportPosition = viewportPosition;
|
|
scroll(0);
|
|
updateInventory();
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public int getMaxViewportPosition()
|
|
{
|
|
return Math.max(0, highestRow - getViewportHeight());
|
|
}
|
|
|
|
@Override
|
|
public UIWindow scroll(int direction)
|
|
{
|
|
viewportPosition = (int) clip(viewportPosition + direction, 0, getMaxViewportPosition()).doubleValue();
|
|
updateInventory();
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public int getViewportHeight()
|
|
{
|
|
return viewportSize;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow setViewportHeight(int height)
|
|
{
|
|
viewportSize = (int) clip(height, 1, getResolution().getMaxHeight()).doubleValue();
|
|
|
|
if(isVisible())
|
|
{
|
|
reopen();
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public String getTitle()
|
|
{
|
|
return title;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow setTitle(String title)
|
|
{
|
|
this.title = title;
|
|
|
|
if(isVisible())
|
|
{
|
|
reopen();
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow setElement(int position, int row, Element e)
|
|
{
|
|
if(row > highestRow)
|
|
{
|
|
highestRow = row;
|
|
}
|
|
|
|
elements.put(getRealPosition((int) clip(position, -getResolution().getMaxWidthOffset(), getResolution().getMaxWidthOffset()).doubleValue(), row), e);
|
|
updateInventory();
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public Element getElement(int position, int row)
|
|
{
|
|
return elements.get(getRealPosition((int) clip(position, -getResolution().getMaxWidthOffset(), getResolution().getMaxWidthOffset()).doubleValue(), row));
|
|
}
|
|
|
|
@Override
|
|
public Player getViewer()
|
|
{
|
|
return viewer;
|
|
}
|
|
|
|
@Override
|
|
public UIWindow onClosed(Callback<Window> window)
|
|
{
|
|
eClose = window;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public int getViewportSlots()
|
|
{
|
|
return getViewportHeight() * getResolution().getWidth();
|
|
}
|
|
|
|
@Override
|
|
public int getLayoutRow(int viewportSlottedPosition)
|
|
{
|
|
return getRow(getRealLayoutPosition(viewportSlottedPosition));
|
|
}
|
|
|
|
@Override
|
|
public int getLayoutPosition(int viewportSlottedPosition)
|
|
{
|
|
return getPosition(viewportSlottedPosition);
|
|
}
|
|
|
|
@Override
|
|
public int getRealLayoutPosition(int viewportSlottedPosition)
|
|
{
|
|
return getRealPosition(getPosition(viewportSlottedPosition), getRow(viewportSlottedPosition) + getViewportPosition());
|
|
}
|
|
|
|
@Override
|
|
public int getRealPosition(int position, int row)
|
|
{
|
|
return (int) (((row * getResolution().getWidth()) + getResolution().getMaxWidthOffset()) + clip(position, -getResolution().getMaxWidthOffset(), getResolution().getMaxWidthOffset()));
|
|
}
|
|
|
|
@Override
|
|
public int getRow(int realPosition)
|
|
{
|
|
return realPosition / getResolution().getWidth();
|
|
}
|
|
|
|
@Override
|
|
public int getPosition(int realPosition)
|
|
{
|
|
return (realPosition % getResolution().getWidth()) - getResolution().getMaxWidthOffset();
|
|
}
|
|
|
|
@Override
|
|
public Window callClosed()
|
|
{
|
|
if(eClose != null)
|
|
{
|
|
eClose.run(this);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasElement(int position, int row)
|
|
{
|
|
return getElement(position, row) != null;
|
|
}
|
|
|
|
@Override
|
|
public WindowResolution getResolution()
|
|
{
|
|
return resolution;
|
|
}
|
|
|
|
public Double clip(double value, double min, double max)
|
|
{
|
|
return Double.valueOf(Math.min(max, Math.max(min, value)));
|
|
}
|
|
|
|
@Override
|
|
public Window setResolution(WindowResolution resolution)
|
|
{
|
|
close();
|
|
this.resolution = resolution;
|
|
setViewportHeight((int) clip(getViewportHeight(), 1, getResolution().getMaxHeight()).doubleValue());
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public Window clearElements()
|
|
{
|
|
highestRow = 0;
|
|
elements.clear();
|
|
updateInventory();
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public Window updateInventory()
|
|
{
|
|
if(isVisible())
|
|
{
|
|
ItemStack[] is = inventory.getContents();
|
|
KSet<ItemStack> isf = new KSet<ItemStack>();
|
|
|
|
for(int i = 0; i < is.length; i++)
|
|
{
|
|
ItemStack isc = is[i];
|
|
ItemStack isx = computeItemStack(i);
|
|
int layoutRow = getLayoutRow(i);
|
|
int layoutPosition = getLayoutPosition(i);
|
|
|
|
if(isx != null && !hasElement(layoutPosition, layoutRow))
|
|
{
|
|
ItemStack gg = isx.clone();
|
|
gg.setAmount(gg.getAmount() + 1);
|
|
isf.add(gg);
|
|
}
|
|
|
|
if(((isc == null) != (isx == null)) || isx != null && isc != null && !isc.equals(isx))
|
|
{
|
|
inventory.setItem(i, isx);
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack computeItemStack(int viewportSlot)
|
|
{
|
|
int layoutRow = getLayoutRow(viewportSlot);
|
|
int layoutPosition = getLayoutPosition(viewportSlot);
|
|
Element e = hasElement(layoutPosition, layoutRow) ? getElement(layoutPosition, layoutRow) : getDecorator().onDecorateBackground(this, layoutPosition, layoutRow);
|
|
|
|
if(e != null)
|
|
{
|
|
return e.computeItemStack();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public Window reopen()
|
|
{
|
|
return this.close().open();
|
|
}
|
|
}
|