list = new ArrayList<>(1);
+
+ list.add(new PositionedPane(slot, pane));
+
+ this.panes.add(list);
+ }
+
+ /**
+ * Adds a pane to a selected page. If the page does not exist and is exactly one larger than the current highest
+ * page index, this method will create a new page with the specified pane. If the page does not exist and is more
+ * than one larger than the current highest page index, this method will throw an {@link IllegalArgumentException}.
+ * If the page is negative, an {@link IllegalArgumentException} will also be thrown. If there are currently no
+ * pages, only index 0 is valid and will create a new page with the specified pane added to it.
+ *
+ * For example, if the pages 0, 1, ..., n currently exist, then:
+ *
+ * - Indexes < 0 will throw an exception
+ * - Indexes 0, 1, ..., n will add the pane to the respective page
+ * - Index n + 1 will create a new page with the specified pane
+ * - Indexes > n + 1 will throw an exception
+ *
+ *
+ * @param page the page to assign the pane to
+ * @param slot the slot of the pane
+ * @param pane the new pane
+ * @throws IllegalArgumentException if the page is less than 0 or more than one larger than the current highest page
+ * index
+ */
+ public void addPane(int page, @NotNull Slot slot, @NotNull Pane pane) {
+ if (page < 0) {
+ throw new IllegalArgumentException("Non-positive page indexes are not allowed");
+ }
+
+ if (page > this.panes.size()) {
+ throw new IllegalArgumentException("Page index outside range of existing pages");
+ }
+
+ if (page == this.panes.size()) {
+ addPage(slot, pane);
+ } else {
+ this.panes.get(page).add(new PositionedPane(slot, pane));
+
+ this.panes.get(page).sort(Comparator.comparing(positionedPane -> positionedPane.getPane().getPriority()));
+ }
+ }
+
+ /**
+ * Sets the current displayed page. If the specified page does not exist an {@link ArrayIndexOutOfBoundsException}
+ * is thrown.
+ *
+ * @param page the page
+ * @throws ArrayIndexOutOfBoundsException if the page does not exist
+ */
+ public void setPage(int page) {
+ if (page < 0 || page >= this.panes.size()) {
+ throw new ArrayIndexOutOfBoundsException("Page outside of range");
+ }
+
+ this.page = page;
+ }
+
+ /**
+ * Populates the PaginatedPane based on the provided list by adding new pages until all items can fit.
+ * This can be helpful when dealing with lists of unknown size.
+ *
+ * @param items The list to populate the pane with
+ * @param plugin the plugin that will be the owner of the items created
+ * @see #populateWithItemStacks(List)
+ * @since 0.10.8
+ */
+ public void populateWithItemStacks(@NotNull List<@NotNull ItemStack> items, @NotNull Plugin plugin) {
+ //Don't do anything if the list is empty
+ if (items.isEmpty()) {
+ return;
+ }
+
+ int itemsPerPage = this.height * this.length;
+ int pagesNeeded = (int) Math.max(Math.ceil(items.size() / (double) itemsPerPage), 1);
+
+ for (int i = 0; i < pagesNeeded; i++) {
+ OutlinePane page = new OutlinePane(this.length, this.height);
+
+ for (int j = 0; j < itemsPerPage; j++) {
+ //Check if the loop reached the end of the list
+ int index = i * itemsPerPage + j;
+
+ if (index >= items.size()) {
+ break;
+ }
+
+ page.addItem(new GuiItem(items.get(index), plugin));
+ }
+
+ this.addPane(i, Slot.fromIndex(0), page);
+ }
+ }
+
+ /**
+ * Populates the PaginatedPane based on the provided list by adding new pages until all items can fit.
+ * This can be helpful when dealing with lists of unknown size.
+ *
+ * @param items The list to populate the pane with
+ */
+ public void populateWithItemStacks(@NotNull List items) {
+ populateWithItemStacks(items, JavaPlugin.getProvidingPlugin(PaginatedPane.class));
+ }
+
+ /**
+ * Populates the PaginatedPane based on the provided list by adding new pages until all items can fit.
+ * This can be helpful when dealing with lists of unknown size.
+ *
+ * @param items The list to populate the pane with
+ */
+ @Contract("null -> fail")
+ public void populateWithGuiItems(@NotNull List items) {
+ //Don't do anything if the list is empty
+ if (items.isEmpty()) {
+ return;
+ }
+
+ int itemsPerPage = this.height * this.length;
+ int pagesNeeded = (int) Math.max(Math.ceil(items.size() / (double) itemsPerPage), 1);
+
+ for (int i = 0; i < pagesNeeded; i++) {
+ OutlinePane page = new OutlinePane(this.length, this.height);
+
+ for (int j = 0; j < itemsPerPage; j++) {
+ int index = i * itemsPerPage + j;
+
+ //Check if the loop reached the end of the list
+ if (index >= items.size()) {
+ break;
+ }
+
+ page.addItem(items.get(index));
+ }
+
+ this.addPane(i, Slot.fromIndex(0), page);
+ }
+ }
+
+ /**
+ * This method creates a list of ItemStacks all with the given {@code material} and the display names.
+ * After that it calls {@link #populateWithItemStacks(List)}
+ * This method also translates the color char {@code &} for all names.
+ *
+ * @param displayNames The display names for all the items
+ * @param material The material to use for the {@link org.bukkit.inventory.ItemStack}s
+ * @param plugin the plugin that will be the owner of the created items
+ * @see #populateWithNames(List, Material)
+ * @since 0.10.8
+ */
+ public void populateWithNames(@NotNull List displayNames, @Nullable Material material,
+ @NotNull Plugin plugin) {
+ if(material == null || material == Material.AIR) return;
+
+ populateWithItemStacks(displayNames.stream().map(name -> {
+ ItemStack itemStack = new ItemStack(material);
+ ItemMeta itemMeta = itemStack.getItemMeta();
+ itemMeta.setDisplayName(ChatColor.translateAlternateColorCodes('&', name));
+ itemStack.setItemMeta(itemMeta);
+ return itemStack;
+ }).collect(Collectors.toList()), plugin);
+ }
+
+ /**
+ * This method creates a list of ItemStacks all with the given {@code material} and the display names.
+ * After that it calls {@link #populateWithItemStacks(List)}
+ * This method also translates the color char {@code &} for all names.
+ *
+ * @param displayNames The display names for all the items
+ * @param material The material to use for the {@link org.bukkit.inventory.ItemStack}s
+ */
+ public void populateWithNames(@NotNull List displayNames, @Nullable Material material) {
+ populateWithNames(displayNames, material, JavaPlugin.getProvidingPlugin(PaginatedPane.class));
+ }
+
+ @NotNull
+ @Override
+ public GuiItemContainer display() {
+ GuiItemContainer container = new GuiItemContainer(getLength(), getHeight());
+
+ if (this.page < 0 || this.page >= this.panes.size()) {
+ return container;
+ }
+
+ List panes = this.panes.get(page);
+
+ if (panes == null) {
+ return container;
+ }
+
+ for (PositionedPane positionedPane : panes) {
+ Pane pane = positionedPane.getPane();
+
+ if (!pane.isVisible()) {
+ continue;
+ }
+
+ Slot slot = positionedPane.getSlot();
+
+ container.apply(pane.display(), slot.getX(getLength()), slot.getY(getLength()));
+ }
+
+ return container;
+ }
+
+ @Override
+ public boolean click(@NotNull Gui gui, @NotNull GuiComponent guiComponent, @NotNull InventoryClickEvent event,
+ @NotNull Slot slot) {
+ int x = slot.getX(getLength());
+ int y = slot.getY(getLength());
+
+ //this isn't our item
+ if (x < 0 || x >= getLength() || y < 0 || y >= getHeight()) {
+ return false;
+ }
+
+ callOnClick(event);
+
+ boolean success = false;
+
+ if (this.page < 0 || this.page >= this.panes.size()) {
+ return false;
+ }
+
+ for (PositionedPane positionedPane : this.panes.get(this.page)) {
+ Pane pane = positionedPane.getPane();
+
+ if (!pane.isVisible()) {
+ continue;
+ }
+
+ Slot paneSlot = positionedPane.getSlot();
+ Slot innerSlot = Slot.fromXY(x - paneSlot.getX(getLength()), y - paneSlot.getY(getLength()));
+
+ success = success || pane.click(gui, guiComponent, event, innerSlot);
+ }
+
+ return success;
+ }
+
+ @NotNull
+ @Contract(pure = true)
+ @Override
+ public PaginatedPane copy() {
+ PaginatedPane paginatedPane = new PaginatedPane(this.length, this.height, getPriority());
+
+ for (int page = 0; page < this.panes.size(); page++) {
+ List panes = this.panes.get(page);
+
+ for (PositionedPane positionedPane : panes) {
+ paginatedPane.addPane(page, positionedPane.getSlot(), positionedPane.getPane().copy());
+ }
+ }
+
+ paginatedPane.setVisible(isVisible());
+ paginatedPane.onClick = this.onClick;
+
+ paginatedPane.uuid = this.uuid;
+
+ paginatedPane.page = this.page;
+
+ return paginatedPane;
+ }
+
+ /**
+ * Deletes a page and all its associated panes from this paginated pane. It also decrements the indexes of all pages
+ * beyond the specified page by one. For example, given a sequence of pages 0, 1, 2, 3, 4, upon removing page 2, the
+ * new sequence of pages will be 0, 1, 2, 3. If the specified page does not exist, then this method will silently do
+ * nothing.
+ *
+ * @param page the page to delete
+ * @since 0.10.5
+ */
+ public void deletePage(int page) {
+ if (page < 0 || page >= this.panes.size()) {
+ return;
+ }
+
+ this.panes.remove(page);
+ }
+
+ @NotNull
+ @Contract(pure = true)
+ @Override
+ public Collection getPanes() {
+ Collection panes = new HashSet<>();
+
+ for (List positionedPanes : this.panes) {
+ for (PositionedPane positionedPane : positionedPanes) {
+ panes.add(positionedPane.getPane());
+ }
+ }
+
+ return panes;
+ }
+
+ /**
+ * Gets all the panes from inside the specified page of this pane. If the specified page is not existent, this
+ * method will throw an {@link IllegalArgumentException}. If the specified page is existent, but doesn't
+ * have any panes, the returned collection will be empty. The returned collection is unmodifiable. The returned
+ * collection is not synchronized and no guarantees should be made as to the safety of concurrently accessing the
+ * returned collection. If synchronized behaviour should be allowed, the returned collection must be synchronized
+ * externally.
+ *
+ * @param page the panes of this page will be returned
+ * @return a collection of panes belonging to the specified page
+ * @since 0.5.13
+ * @throws IllegalArgumentException if the page does not exist
+ */
+ @NotNull
+ @Contract(pure = true)
+ public Collection getPanes(int page) {
+ if (page < 0 || this.page >= this.panes.size()) {
+ throw new IllegalArgumentException("Invalid page");
+ }
+
+ Collection positionedPanes = this.panes.get(page);
+
+ if (positionedPanes == null) {
+ throw new IllegalArgumentException("Invalid page");
+ }
+
+ Collection panes = new HashSet<>(positionedPanes.size());
+
+ for (PositionedPane positionedPane : positionedPanes) {
+ panes.add(positionedPane.getPane());
+ }
+
+ return Collections.unmodifiableCollection(panes);
+ }
+
+ @NotNull
+ @Contract(pure = true)
+ @Override
+ public Collection getItems() {
+ return getPanes().stream().flatMap(pane -> pane.getItems().stream()).collect(Collectors.toList());
+ }
+
+ @Override
+ public void clear() {
+ panes.clear();
+ }
+
+ /**
+ * Loads a paginated pane from a given element
+ *
+ * @param instance the instance class
+ * @param element the element
+ * @param plugin the plugin that will be used to create the items
+ * @return the paginated pane
+ * @since 0.10.8
+ */
+ @NotNull
+ public static PaginatedPane load(@NotNull Object instance, @NotNull Element element, @NotNull Plugin plugin) {
+ if (!element.hasAttribute("length")) {
+ throw new XMLLoadException("Paginated pane XML tag does not have the mandatory length attribute");
+ }
+
+ if (!element.hasAttribute("height")) {
+ throw new XMLLoadException("Paginated pane XML tag does not have the mandatory height attribute");
+ }
+
+ int length;
+ int height;
+
+ try {
+ length = Integer.parseInt(element.getAttribute("length"));
+ } catch (NumberFormatException exception) {
+ throw new XMLLoadException("Length attribute is not an integer", exception);
+ }
+
+ try {
+ height = Integer.parseInt(element.getAttribute("height"));
+ } catch (NumberFormatException exception) {
+ throw new XMLLoadException("Height attribute is not an integer", exception);
+ }
+
+ PaginatedPane paginatedPane = new PaginatedPane(length, height);
+
+ Pane.load(paginatedPane, instance, element);
+
+ if (element.hasAttribute("id")) {
+ element.setIdAttribute("id", true);
+ element.setUserData("pane", paginatedPane, null);
+ }
+
+ if (element.hasAttribute("populate")) {
+ return paginatedPane;
+ }
+
+ int pageCount = 0;
+
+ NodeList childNodes = element.getChildNodes();
+ for (int i = 0; i < childNodes.getLength(); i++) {
+ Node item = childNodes.item(i);
+ if (item.getNodeType() != Node.ELEMENT_NODE)
+ continue;
+
+ if(!item.getNodeName().equals("page"))
+ throw new XMLLoadException("Panes have to be inside page tag");
+
+ NodeList innerNodes = item.getChildNodes();
+
+ for (int j = 0; j < innerNodes.getLength(); j++) {
+ Node innerNode = innerNodes.item(j);
+
+ if (innerNode.getNodeType() != Node.ELEMENT_NODE) {
+ continue;
+ }
+
+ Pane pane = Gui.loadPane(instance, innerNode, plugin);
+
+ paginatedPane.addPane(pageCount, Slot.deserialize((Element) innerNode), pane);
+ }
+
+ pageCount++;
+ }
+
+ return paginatedPane;
+ }
+}
diff --git a/IF/src/main/java/com/github/stefvanschie/inventoryframework/pane/Pane.java b/IF/src/main/java/com/github/stefvanschie/inventoryframework/pane/Pane.java
index 79a7afed8..39e5113e5 100644
--- a/IF/src/main/java/com/github/stefvanschie/inventoryframework/pane/Pane.java
+++ b/IF/src/main/java/com/github/stefvanschie/inventoryframework/pane/Pane.java
@@ -1,50 +1,34 @@
package com.github.stefvanschie.inventoryframework.pane;
-import com.github.stefvanschie.inventoryframework.gui.InventoryComponent;
+import com.github.stefvanschie.inventoryframework.gui.GuiComponent;
import com.github.stefvanschie.inventoryframework.gui.type.util.Gui;
import com.github.stefvanschie.inventoryframework.gui.GuiItem;
import com.github.stefvanschie.inventoryframework.exception.XMLLoadException;
-import com.github.stefvanschie.inventoryframework.exception.XMLReflectionException;
-import com.github.stefvanschie.inventoryframework.util.SkullUtil;
+import com.github.stefvanschie.inventoryframework.pane.util.GuiItemContainer;
+import com.github.stefvanschie.inventoryframework.pane.util.Mask;
+import com.github.stefvanschie.inventoryframework.pane.util.Slot;
+import com.github.stefvanschie.inventoryframework.util.InventoryViewUtil;
import com.github.stefvanschie.inventoryframework.util.UUIDTagType;
import com.github.stefvanschie.inventoryframework.util.XMLUtil;
-import com.google.common.primitives.Primitives;
-import org.apache.commons.lang3.reflect.MethodUtils;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.bukkit.enchantments.Enchantment;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.inventory.meta.SkullMeta;
-import org.bukkit.plugin.java.JavaPlugin;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
import java.lang.UnsupportedOperationException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
* The base class for all panes.
*/
public abstract class Pane {
- /**
- * The starting position of this pane, which is 0 by default
- */
- protected int x = 0, y = 0;
-
/**
* Length is horizontal, height is vertical
*/
@@ -65,36 +49,26 @@ public abstract class Pane {
* The consumer that will be called once a players clicks in this pane
*/
@Nullable
- protected Consumer onClick;
+ protected Consumer onClick;
/**
* A unique identifier for panes to locate them by
*/
protected UUID uuid;
- /**
- * A map containing the mappings for properties for items
- */
- @NotNull
- private static final Map> PROPERTY_MAPPINGS = new HashMap<>();
-
/**
* Constructs a new default pane
*
- * @param x the upper left x coordinate of the pane
- * @param y the upper left y coordinate of the pane
* @param length the length of the pane
* @param height the height of the pane
* @param priority the priority of the pane
+ * @since 0.12.0
*/
- protected Pane(int x, int y, int length, int height, @NotNull Priority priority) {
+ protected Pane(int length, int height, @NotNull Priority priority) {
if (length == 0 || height == 0) {
throw new IllegalArgumentException("Length and height of pane must be greater than zero");
}
- this.x = x;
- this.y = y;
-
this.length = length;
this.height = height;
@@ -124,18 +98,6 @@ protected Pane(int length, int height) {
this.uuid = UUID.randomUUID();
}
- /**
- * Constructs a new default pane
- *
- * @param x the upper left x coordinate of the pane
- * @param y the upper left y coordinate of the pane
- * @param length the length of the pane
- * @param height the height of the pane
- */
- protected Pane(int x, int y, int length, int height) {
- this(x, y, length, height, Priority.NORMAL);
- }
-
/**
* Makes a copy of this pane and returns it. This makes a deep copy of the pane. This entails that the underlying
* panes and/or items will be copied as well. The returned pane will never be reference equal to the current pane.
@@ -167,24 +129,6 @@ public void setHeight(int height) {
this.height = height;
}
- /**
- * Set the x coordinate of this pane
- *
- * @param x the new x coordinate
- */
- public void setX(int x) {
- this.x = x;
- }
-
- /**
- * Set the y coordinate of this pane
- *
- * @param y the new y coordinate
- */
- public void setY(int y) {
- this.y = y;
- }
-
/**
* Returns the length of this pane
*
@@ -218,36 +162,13 @@ public UUID getUUID() {
}
/**
- * Gets the x coordinate of this pane
- *
- * @return the x coordinate
- */
- @Contract(pure = true)
- public int getX() {
- return x;
- }
-
- /**
- * Gets the y coordinate of this pane
- *
- * @return the y coordinate
- */
- @Contract(pure = true)
- public int getY() {
- return y;
- }
-
- /**
- * Has to set all the items in the right spot inside the inventory
+ * Returns a {@link GuiItemContainer} with all the items that should be displayed of this pane.
*
- * @param inventoryComponent the inventory component in which the items should be displayed
- * @param paneOffsetX the pane's offset on the x axis
- * @param paneOffsetY the pane's offset on the y axis
- * @param maxLength the maximum length of the pane
- * @param maxHeight the maximum height of the pane
+ * @return a container containing all the items to be displayed
+ * @since 0.12.0
*/
- public abstract void display(@NotNull InventoryComponent inventoryComponent, int paneOffsetX, int paneOffsetY,
- int maxLength, int maxHeight);
+ @NotNull
+ public abstract GuiItemContainer display();
/**
* Returns the pane's visibility state
@@ -272,18 +193,13 @@ public void setVisible(boolean visible) {
* Called whenever there is being clicked on this pane
*
* @param gui the gui in which was clicked
- * @param inventoryComponent the inventory component in which this pane resides
+ * @param guiComponent the gui component in which this pane resides
* @param event the event that occurred while clicking on this item
* @param slot the slot that was clicked in
- * @param paneOffsetX the pane's offset on the x axis
- * @param paneOffsetY the pane's offset on the y axis
- * @param maxLength the maximum length of the pane
- * @param maxHeight the maximum height of the pane
* @return whether the item was found or not
*/
- public abstract boolean click(@NotNull Gui gui, @NotNull InventoryComponent inventoryComponent,
- @NotNull InventoryClickEvent event, int slot, int paneOffsetX, int paneOffsetY,
- int maxLength, int maxHeight);
+ public abstract boolean click(@NotNull Gui gui, @NotNull GuiComponent guiComponent,
+ @NotNull InventoryClickEvent event, @NotNull Slot slot);
/**
* Sets the priority of this pane
@@ -294,216 +210,14 @@ public void setPriority(@NotNull Priority priority) {
this.priority = priority;
}
- /**
- * Loads an item from an instance and an element
- *
- * @param instance the instance
- * @param element the element
- * @return the gui item
- */
- @NotNull
- @Contract(pure = true)
- public static GuiItem loadItem(@NotNull Object instance, @NotNull Element element) {
- String id = element.getAttribute("id");
- Material material = Objects.requireNonNull(Material.matchMaterial(id.toUpperCase(Locale.getDefault())));
- boolean hasAmount = element.hasAttribute("amount");
- boolean hasDamage = element.hasAttribute("damage");
- int amount = hasAmount ? Integer.parseInt(element.getAttribute("amount")) : 1;
- short damage = hasDamage ? Short.parseShort(element.getAttribute("damage")) : 0;
-
- //noinspection deprecation
- ItemStack itemStack = new ItemStack(material, amount, damage);
-
- List