├── plugin.yml ├── .gitattributes ├── .gitignore ├── src └── me │ └── libraryaddict │ └── inventory │ ├── events │ ├── AnvilCloseEvent.java │ ├── PageCloseEvent.java │ ├── NamedCloseEvent.java │ ├── PagesClickEvent.java │ ├── PagesTurnEvent.java │ ├── NamedPageClickEvent.java │ ├── AnvilTypeEvent.java │ ├── ItemClickEvent.java │ └── AnvilClickEvent.java │ ├── Page.java │ ├── PageLayout.java │ ├── NamedInventory.java │ ├── AnvilInventory.java │ ├── InventoryApi.java │ ├── ItemBuilder.java │ ├── ClickInventory.java │ └── PageInventory.java └── pom.xml /plugin.yml: -------------------------------------------------------------------------------- 1 | name: InventoryApi 2 | main: me.libraryaddict.inventory.InventoryApi 3 | author: libraryaddict 4 | version: ${buildNumber} §fbuilt on §a${buildDate} -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | *.sln merge=union 7 | *.csproj merge=union 8 | *.vbproj merge=union 9 | *.fsproj merge=union 10 | *.dbproj merge=union 11 | 12 | # Standard to msysgit 13 | *.doc diff=astextplain 14 | *.DOC diff=astextplain 15 | *.docx diff=astextplain 16 | *.DOCX diff=astextplain 17 | *.dot diff=astextplain 18 | *.DOT diff=astextplain 19 | *.pdf diff=astextplain 20 | *.PDF diff=astextplain 21 | *.rtf diff=astextplain 22 | *.RTF diff=astextplain 23 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Windows image file caches 2 | Thumbs.db 3 | ehthumbs.db 4 | 5 | # Folder config file 6 | Desktop.ini 7 | 8 | # Recycle Bin used on file shares 9 | $RECYCLE.BIN/ 10 | 11 | # Windows Installer files 12 | *.cab 13 | *.msi 14 | *.msm 15 | *.msp 16 | 17 | # ========================= 18 | # Operating System Files 19 | # ========================= 20 | 21 | # OSX 22 | # ========================= 23 | 24 | .DS_Store 25 | .AppleDouble 26 | .LSOverride 27 | 28 | # Icon must ends with two \r. 29 | Icon 30 | 31 | # Thumbnails 32 | ._* 33 | 34 | # Files that might appear on external disk 35 | .Spotlight-V100 36 | .Trashes 37 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/AnvilCloseEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import me.libraryaddict.inventory.AnvilInventory; 4 | import org.bukkit.entity.Player; 5 | import org.bukkit.event.Event; 6 | import org.bukkit.event.HandlerList; 7 | 8 | public class AnvilCloseEvent extends Event { 9 | private static final HandlerList handlers = new HandlerList(); 10 | 11 | public static HandlerList getHandlerList() { 12 | return handlers; 13 | } 14 | 15 | private AnvilInventory inv; 16 | 17 | public AnvilCloseEvent(AnvilInventory inventory) { 18 | this.inv = inventory; 19 | } 20 | 21 | public HandlerList getHandlers() { 22 | return handlers; 23 | } 24 | 25 | public AnvilInventory getInventory() { 26 | return inv; 27 | } 28 | 29 | public Player getPlayer() { 30 | return inv.getPlayer(); 31 | } 32 | 33 | public String getName() { 34 | return getInventory().getName(); 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/PageCloseEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import me.libraryaddict.inventory.PageInventory; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.Event; 7 | import org.bukkit.event.HandlerList; 8 | 9 | public class PageCloseEvent extends Event { 10 | private static final HandlerList handlers = new HandlerList(); 11 | 12 | public static HandlerList getHandlerList() { 13 | return handlers; 14 | } 15 | 16 | private PageInventory inv; 17 | 18 | public PageCloseEvent(PageInventory inventory) { 19 | this.inv = inventory; 20 | } 21 | 22 | public HandlerList getHandlers() { 23 | return handlers; 24 | } 25 | 26 | public PageInventory getInventory() { 27 | return inv; 28 | } 29 | 30 | public Player getPlayer() { 31 | return inv.getPlayer(); 32 | } 33 | 34 | public String getName() { 35 | return getInventory().getName(); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/NamedCloseEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import me.libraryaddict.inventory.NamedInventory; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.Event; 7 | import org.bukkit.event.HandlerList; 8 | 9 | public class NamedCloseEvent extends Event { 10 | private static final HandlerList handlers = new HandlerList(); 11 | 12 | public static HandlerList getHandlerList() { 13 | return handlers; 14 | } 15 | 16 | private NamedInventory inv; 17 | 18 | public NamedCloseEvent(NamedInventory inventory) { 19 | this.inv = inventory; 20 | } 21 | 22 | public HandlerList getHandlers() { 23 | return handlers; 24 | } 25 | 26 | public NamedInventory getInventory() { 27 | return inv; 28 | } 29 | 30 | public Player getPlayer() { 31 | return inv.getPlayer(); 32 | } 33 | 34 | public String getName() { 35 | return getInventory().getName(); 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/PagesClickEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.event.HandlerList; 5 | import org.bukkit.event.inventory.InventoryClickEvent; 6 | import org.bukkit.inventory.ItemStack; 7 | 8 | import me.libraryaddict.inventory.PageInventory; 9 | 10 | public class PagesClickEvent extends ItemClickEvent { 11 | private static final HandlerList handlers = new HandlerList(); 12 | public static HandlerList getHandlerList() { 13 | return handlers; 14 | } 15 | 16 | private PageInventory inv; 17 | 18 | public PagesClickEvent(PageInventory inventory, int slot, InventoryClickEvent invEvent) { 19 | super(slot, invEvent); 20 | this.inv = inventory; 21 | } 22 | 23 | public HandlerList getHandlers() { 24 | return handlers; 25 | } 26 | 27 | public PageInventory getInventory() { 28 | return inv; 29 | } 30 | 31 | public ItemStack getItemStack() { 32 | if (slot >= 0) 33 | return inv.getItem(slot); 34 | return null; 35 | } 36 | 37 | @Override 38 | public Player getPlayer() { 39 | return inv.getPlayer(); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/PagesTurnEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.event.HandlerList; 5 | import org.bukkit.event.inventory.InventoryClickEvent; 6 | import org.bukkit.inventory.ItemStack; 7 | 8 | import me.libraryaddict.inventory.PageInventory; 9 | 10 | public class PagesTurnEvent extends ItemClickEvent { 11 | private static final HandlerList handlers = new HandlerList(); 12 | 13 | public static HandlerList getHandlerList() { 14 | return handlers; 15 | } 16 | 17 | private PageInventory inv; 18 | private int newPage; 19 | 20 | public PagesTurnEvent(PageInventory inventory, int slot, InventoryClickEvent invEvent, int newPage) { 21 | super(slot, invEvent); 22 | this.inv = inventory; 23 | this.newPage = newPage; 24 | } 25 | 26 | public int getNewPage() { 27 | return newPage; 28 | } 29 | 30 | public HandlerList getHandlers() { 31 | return handlers; 32 | } 33 | 34 | public PageInventory getInventory() { 35 | return inv; 36 | } 37 | 38 | public ItemStack getItemStack() { 39 | if (slot >= 0) 40 | return inv.getItem(slot); 41 | return null; 42 | } 43 | 44 | @Override 45 | public Player getPlayer() { 46 | return inv.getPlayer(); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/NamedPageClickEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.event.HandlerList; 5 | import org.bukkit.event.inventory.InventoryClickEvent; 6 | import org.bukkit.inventory.ItemStack; 7 | 8 | import me.libraryaddict.inventory.NamedInventory; 9 | import me.libraryaddict.inventory.Page; 10 | 11 | public class NamedPageClickEvent extends ItemClickEvent { 12 | private static final HandlerList handlers = new HandlerList(); 13 | 14 | public static HandlerList getHandlerList() { 15 | return handlers; 16 | } 17 | 18 | private NamedInventory inv; 19 | private Page page; 20 | 21 | public NamedPageClickEvent(NamedInventory inventory, Page page, int slot, InventoryClickEvent invEvent) { 22 | super(slot, invEvent); 23 | this.inv = inventory; 24 | this.page = page; 25 | } 26 | 27 | public HandlerList getHandlers() { 28 | return handlers; 29 | } 30 | 31 | public NamedInventory getInventory() { 32 | return inv; 33 | } 34 | 35 | public ItemStack getItemStack() { 36 | if (slot >= 0) 37 | return inv.getItem(slot); 38 | return null; 39 | } 40 | 41 | public Page getPage() { 42 | return page; 43 | } 44 | 45 | @Override 46 | public Player getPlayer() { 47 | return inv.getPlayer(); 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/AnvilTypeEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.event.Event; 5 | import org.bukkit.event.HandlerList; 6 | import me.libraryaddict.inventory.AnvilInventory; 7 | 8 | public class AnvilTypeEvent extends Event { 9 | private static final HandlerList handlers = new HandlerList(); 10 | 11 | public static HandlerList getHandlerList() { 12 | return handlers; 13 | } 14 | 15 | private boolean cancelled; 16 | private AnvilInventory inv; 17 | private String lettering; 18 | 19 | public AnvilTypeEvent(AnvilInventory inventory, String lettering) { 20 | this.inv = inventory; 21 | this.lettering = lettering; 22 | } 23 | 24 | public HandlerList getHandlers() { 25 | return handlers; 26 | } 27 | 28 | public AnvilInventory getInventory() { 29 | return inv; 30 | } 31 | 32 | public String getString() { 33 | return lettering; 34 | } 35 | 36 | public String getName() { 37 | return getInventory().getName(); 38 | } 39 | 40 | public void setString(String newString) { 41 | this.lettering = newString; 42 | } 43 | 44 | public boolean isCancelled() { 45 | return cancelled; 46 | } 47 | 48 | public void setCancelled(boolean cancel) { 49 | cancelled = cancel; 50 | } 51 | 52 | public Player getPlayer() { 53 | return inv.getPlayer(); 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/Page.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | public class Page { 4 | private String pageName; 5 | private String pageTitle; 6 | 7 | public Page(String pageName) { 8 | this(pageName, pageName); 9 | } 10 | 11 | public Page(String pageName, String pageDisplayTitle) { 12 | this.pageTitle = pageDisplayTitle; 13 | this.pageName = pageName; 14 | } 15 | 16 | public boolean equals(Object obj) { 17 | if (this == obj) 18 | return true; 19 | if (obj == null) 20 | return false; 21 | if (getClass() != obj.getClass()) 22 | return false; 23 | Page other = (Page) obj; 24 | if (!getPageName().equals(other.getPageName())) 25 | return false; 26 | return true; 27 | } 28 | 29 | public String getPageDisplayTitle() { 30 | return pageTitle; 31 | } 32 | 33 | public String getPageName() { 34 | return pageName; 35 | } 36 | 37 | @Override 38 | public int hashCode() { 39 | final int prime = 31; 40 | int result = 1; 41 | result = prime * result + getPageName().hashCode(); 42 | return result; 43 | } 44 | 45 | public void setDisplayTitle(String newTitle) { 46 | this.pageTitle = newTitle; 47 | } 48 | 49 | @Override 50 | public String toString() { 51 | return "Page[Name=" + getPageName() + ", Title=" + getPageDisplayTitle() + "]"; 52 | } 53 | 54 | } 55 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/ItemClickEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import me.libraryaddict.inventory.ClickInventory; 4 | import org.bukkit.entity.Player; 5 | import org.bukkit.event.Cancellable; 6 | import org.bukkit.event.Event; 7 | import org.bukkit.event.HandlerList; 8 | import org.bukkit.event.inventory.InventoryClickEvent; 9 | import org.bukkit.inventory.ItemStack; 10 | 11 | public abstract class ItemClickEvent extends Event implements Cancellable { 12 | private static final HandlerList handlers = new HandlerList(); 13 | 14 | public static HandlerList getHandlerList() { 15 | return handlers; 16 | } 17 | 18 | private boolean cancelled; 19 | private InventoryClickEvent invEvent; 20 | 21 | protected int slot; 22 | 23 | public ItemClickEvent(int slot, InventoryClickEvent invEvent) { 24 | this.slot = slot; 25 | this.invEvent = invEvent; 26 | } 27 | 28 | public InventoryClickEvent getEvent() { 29 | return invEvent; 30 | } 31 | 32 | public HandlerList getHandlers() { 33 | return handlers; 34 | } 35 | 36 | public abstract ClickInventory getInventory(); 37 | 38 | public abstract ItemStack getItemStack(); 39 | 40 | public String getName() { 41 | return getInventory().getName(); 42 | } 43 | 44 | public abstract Player getPlayer(); 45 | 46 | public int getSlot() { 47 | return slot; 48 | } 49 | 50 | public boolean isCancelled() { 51 | return cancelled; 52 | } 53 | 54 | public void setCancelled(boolean cancel) { 55 | cancelled = cancel; 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/events/AnvilClickEvent.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory.events; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.event.Event; 5 | import org.bukkit.event.HandlerList; 6 | import org.bukkit.event.inventory.InventoryClickEvent; 7 | import org.bukkit.inventory.ItemStack; 8 | 9 | import me.libraryaddict.inventory.AnvilInventory; 10 | import me.libraryaddict.inventory.AnvilInventory.AnvilSlot; 11 | 12 | public class AnvilClickEvent extends Event { 13 | private static final HandlerList handlers = new HandlerList(); 14 | 15 | public static HandlerList getHandlerList() { 16 | return handlers; 17 | } 18 | 19 | private boolean cancelled; 20 | private AnvilInventory inv; 21 | private AnvilSlot slot; 22 | private InventoryClickEvent event; 23 | 24 | public AnvilClickEvent(AnvilInventory inventory, AnvilSlot slot, InventoryClickEvent invEvent) { 25 | this.inv = inventory; 26 | this.event = invEvent; 27 | this.slot = slot; 28 | } 29 | 30 | public HandlerList getHandlers() { 31 | return handlers; 32 | } 33 | 34 | public AnvilInventory getInventory() { 35 | return inv; 36 | } 37 | 38 | public ItemStack getItemStack() { 39 | return inv.getItem(slot); 40 | } 41 | 42 | public InventoryClickEvent getEvent() { 43 | return event; 44 | } 45 | 46 | public String getName() { 47 | return getInventory().getName(); 48 | } 49 | 50 | public String getItemName() { 51 | return getInventory().getItemName(); 52 | } 53 | 54 | public AnvilSlot getSlot() { 55 | return slot; 56 | } 57 | 58 | public boolean isCancelled() { 59 | return cancelled; 60 | } 61 | 62 | public void setCancelled(boolean cancel) { 63 | cancelled = cancel; 64 | } 65 | 66 | public Player getPlayer() { 67 | return inv.getPlayer(); 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/PageLayout.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.util.ArrayList; 4 | import org.bukkit.inventory.ItemStack; 5 | 6 | public class PageLayout { 7 | 8 | private static String empty = "X"; 9 | private static String full = "O"; 10 | 11 | public static void setStringFormat(String noItem, String aItem) { 12 | empty = noItem; 13 | full = aItem; 14 | } 15 | 16 | private int invSize = 0; 17 | private ArrayList size = new ArrayList(); 18 | 19 | public PageLayout(String... strings) { 20 | invSize = strings.length * 9; 21 | for (int slot = 0; slot < strings.length * 9; slot++) { 22 | String string = strings[(int) Math.floor((double) slot / 9D)]; 23 | if (string.length() != 9) 24 | throw new RuntimeException("String is not a length of 9. String is a length of " + string.length() + ". " 25 | + string); 26 | String letter = string.substring(slot % 9, (slot % 9) + 1); 27 | if (letter.equalsIgnoreCase(empty)) { 28 | continue; 29 | } else if (letter.equalsIgnoreCase(full)) { 30 | size.add(slot); 31 | } else 32 | throw new RuntimeException("Unrecognised value " + letter); 33 | } 34 | } 35 | 36 | public ItemStack[] generate(ArrayList items) { 37 | return generate(items.toArray(new ItemStack[items.size()])); 38 | } 39 | 40 | public ItemStack[] generate(ItemStack... items) { 41 | ItemStack[] itemArray = new ItemStack[invSize]; 42 | for (int i = 0; i < size.size(); i++) { 43 | if (i < items.length) { 44 | ItemStack itemToInsert = items[i]; 45 | if (itemToInsert != null) 46 | itemArray[size.get(i)] = itemToInsert.clone(); 47 | } 48 | } 49 | return itemArray; 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | InventoryApi 5 | InventoryApi 6 | 0.0.1-SNAPSHOT 7 | 8 | src 9 | clean package 10 | target 11 | InventoryApi 12 | 13 | 14 | maven-compiler-plugin 15 | 2.3.2 16 | 17 | 1.6 18 | 1.6 19 | 20 | 21 | 22 | org.codehaus.mojo 23 | buildnumber-maven-plugin 24 | 1.0-beta-4 25 | 26 | 27 | validate 28 | 29 | create 30 | 31 | 32 | 33 | 34 | true 35 | false 36 | {0,number} 37 | 38 | buildNumber 39 | 40 | 41 | 42 | 43 | 44 | 45 | . 46 | true 47 | ${project.basedir} 48 | 49 | plugin.yml 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | md_5-repo 58 | http://repo.md-5.net/content/groups/public/ 59 | 60 | 61 | comphenix-rep 62 | Comphenix Repository 63 | http://repo.comphenix.net/content/groups/public 64 | 65 | 66 | 67 | 68 | 69 | dd-MM-yyyy HH:mm 70 | ${maven.build.timestamp} 71 | 72 | 73 | 74 | scm:svn:http://127.0.0.1/svn/my-project 75 | scm:svn:https://127.0.0.1/svn/my-project 76 | HEAD 77 | http://127.0.0.1/websvn/my-project 78 | 79 | 80 | 81 | com.comphenix.protocol 82 | ProtocolLib 83 | 3.4.0-SNAPSHOT 84 | 85 | 86 | org.spigotmc 87 | spigot-api 88 | 1.7.10-R0.1-SNAPSHOT 89 | 90 | 91 | org.spigotmc 92 | spigot 93 | 1.7.10-R0.1-SNAPSHOT 94 | 95 | 96 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/NamedInventory.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.util.Arrays; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | 7 | import me.libraryaddict.inventory.events.NamedPageClickEvent; 8 | 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.Material; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.event.inventory.InventoryClickEvent; 13 | import org.bukkit.inventory.ItemStack; 14 | 15 | public final class NamedInventory extends ClickInventory { 16 | 17 | protected Page currentPage; 18 | protected HashMap pageDirectors = new HashMap(); 19 | protected HashMap pages = new HashMap(); 20 | 21 | public NamedInventory(Player player) { 22 | this(null, player); 23 | } 24 | 25 | @Deprecated 26 | public NamedInventory(Player player, boolean dymanicInventory) { 27 | this(player); 28 | } 29 | 30 | public NamedInventory(String inventoryName, Player player) { 31 | super(inventoryName, player); 32 | } 33 | 34 | public Page getCurrentPage() { 35 | return currentPage; 36 | } 37 | 38 | public ItemStack[] getPage(Page page) { 39 | return pages.get(page); 40 | } 41 | 42 | public Page getPage(String pageName) { 43 | for (Page page : pages.keySet()) 44 | if (page.getPageName().equals(pageName)) 45 | return page; 46 | return null; 47 | } 48 | 49 | public Page getPageLink(ItemStack item) { 50 | return pageDirectors.get(item); 51 | } 52 | 53 | public HashMap getPages() { 54 | return pages; 55 | } 56 | 57 | public String getTitle() { 58 | return currentPage.getPageDisplayTitle(); 59 | } 60 | 61 | public void linkPage(ItemStack item, Page page) { 62 | pageDirectors.put(item, page); 63 | } 64 | 65 | public void linkPage(ItemStack item, String pageName) { 66 | Page page = getPage(pageName); 67 | if (page != null) { 68 | linkPage(item, page); 69 | } 70 | } 71 | 72 | protected void onInventoryClick(InventoryClickEvent event) { 73 | ItemStack item = event.getCurrentItem(); 74 | if (checkInMenu(event.getRawSlot())) { 75 | if (item != null && pageDirectors.containsKey(item)) { 76 | event.setCancelled(true); 77 | setPage(pageDirectors.get(item)); 78 | return; 79 | } 80 | int slot = event.getSlot(); 81 | if (isPlayerInventory()) { 82 | slot -= 9; 83 | if (slot < 0) { 84 | slot += 36; 85 | } 86 | } 87 | NamedPageClickEvent itemClickEvent = new NamedPageClickEvent(this, currentPage, slot, event); 88 | if (!isModifiable()) { 89 | itemClickEvent.setCancelled(true); 90 | } 91 | Bukkit.getPluginManager().callEvent(itemClickEvent); 92 | if (itemClickEvent.isCancelled()) { 93 | event.setCancelled(true); 94 | } 95 | } else if (!this.isModifiable() && event.isShiftClick() && item != null && item.getType() != Material.AIR) { 96 | for (int slot = 0; slot < currentInventory.getSize(); slot++) { 97 | ItemStack invItem = currentInventory.getItem(slot); 98 | if (invItem == null || invItem.getType() == Material.AIR 99 | || (invItem.isSimilar(item) && invItem.getAmount() < invItem.getMaxStackSize())) { 100 | event.setCancelled(true); 101 | break; 102 | } 103 | } 104 | } 105 | } 106 | 107 | public void openInventory() { 108 | if (isInventoryInUse()) { 109 | return; 110 | } 111 | if (isPlayerInventory()) { 112 | saveContents(); 113 | } 114 | if (currentPage == null) { 115 | if (pages.isEmpty()) { 116 | pages.put(new Page("Inventory"), new ItemStack[0]); 117 | } 118 | currentPage = pages.keySet().iterator().next(); 119 | } 120 | if (currentInventory == null) { 121 | ItemStack[] pageItems = getPage(currentPage); 122 | if (isPlayerInventory()) { 123 | currentInventory = getPlayer().getInventory(); 124 | } else { 125 | currentInventory = Bukkit.createInventory(null, pageItems.length, getTitle()); 126 | } 127 | setItems(pageItems); 128 | } 129 | openInv(); 130 | } 131 | 132 | public void removePage(Page page) { 133 | pages.remove(page); 134 | } 135 | 136 | public void setPage(Page newPage) { 137 | if (pages.containsKey(newPage)) { 138 | Page oldPage = currentPage; 139 | currentPage = newPage; 140 | if (isInventoryInUse()) { 141 | ItemStack[] pageItems = pages.get(currentPage); 142 | if (!isPlayerInventory() 143 | && (pageItems.length != currentInventory.getSize() || !oldPage.getPageDisplayTitle().equals(getTitle()))) { 144 | currentInventory = Bukkit.createInventory(null, pageItems.length, getTitle()); 145 | currentInventory.setContents(pageItems); 146 | openInv(); 147 | } else { 148 | setItems(pageItems); 149 | } 150 | } 151 | } 152 | } 153 | 154 | public void setPage(Page page, ItemStack... items) { 155 | if (items.length % 9 != 0) { 156 | items = Arrays.copyOf(items, (int) (Math.ceil((double) items.length / 9D) * 9)); 157 | } 158 | if (items.length > (isPlayerInventory() ? 36 : 54)) { 159 | throw new RuntimeException("A inventory size of " + items.length + " was passed when the max is " 160 | + (isPlayerInventory() ? 36 : 54)); 161 | } 162 | pages.put(page, items); 163 | if (currentPage == null) { 164 | currentPage = page; 165 | } else if (currentPage.equals(page)) { 166 | setPage(page); 167 | } 168 | } 169 | 170 | public void setPage(Page page, List items) { 171 | setPage(page, items.toArray(new ItemStack[items.size()])); 172 | } 173 | 174 | public void setPage(String pageName) { 175 | Page page = getPage(pageName); 176 | if (page != null) { 177 | setPage(page); 178 | } 179 | } 180 | 181 | public NamedInventory setPlayerInventory() { 182 | super.setPlayerInventory(); 183 | return this; 184 | } 185 | 186 | public void setTitle(String newTitle) { 187 | if (newTitle != null && getCurrentPage() != null) { 188 | if (!getCurrentPage().getPageDisplayTitle().equals(newTitle)) { 189 | setPage(new Page(getCurrentPage().getPageName(), newTitle), getPage(getCurrentPage())); 190 | } 191 | } 192 | } 193 | 194 | public void unlinkPage(ItemStack item) { 195 | pageDirectors.remove(item); 196 | } 197 | } 198 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/AnvilInventory.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.lang.reflect.InvocationTargetException; 4 | import java.util.HashMap; 5 | 6 | import me.libraryaddict.inventory.events.AnvilClickEvent; 7 | import me.libraryaddict.inventory.events.AnvilTypeEvent; 8 | import net.minecraft.server.v1_7_R4.ContainerAnvil; 9 | import net.minecraft.server.v1_7_R4.EntityHuman; 10 | import net.minecraft.server.v1_7_R4.EntityPlayer; 11 | import net.minecraft.util.com.google.common.base.Objects; 12 | 13 | import org.apache.commons.lang.StringUtils; 14 | import org.bukkit.Bukkit; 15 | import org.bukkit.Material; 16 | import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer; 17 | import org.bukkit.entity.Player; 18 | import org.bukkit.event.inventory.InventoryClickEvent; 19 | import org.bukkit.inventory.ItemStack; 20 | 21 | import com.comphenix.protocol.PacketType; 22 | import com.comphenix.protocol.ProtocolLibrary; 23 | import com.comphenix.protocol.events.PacketContainer; 24 | import com.comphenix.protocol.reflect.StructureModifier; 25 | 26 | public class AnvilInventory extends ClickInventory { 27 | private class AnvilContainer extends ContainerAnvil { 28 | private String n; 29 | 30 | public AnvilContainer(EntityHuman entity) { 31 | super(entity.inventory, entity.world, 0, 0, 0, entity); 32 | } 33 | 34 | @Override 35 | public boolean a(EntityHuman entityhuman) { 36 | return true; 37 | } 38 | 39 | @Override 40 | public void a(String origString) { 41 | AnvilTypeEvent event = new AnvilTypeEvent(AnvilInventory.this, origString); 42 | Bukkit.getPluginManager().callEvent(event); 43 | String newString = event.getString(); 44 | if (!event.isCancelled()) { 45 | this.n = newString; 46 | itemName = origString; 47 | setItemName(newString); 48 | if (getSlot(2).hasItem()) { 49 | net.minecraft.server.v1_7_R4.ItemStack itemstack = getSlot(2).getItem(); 50 | 51 | if (StringUtils.isBlank(newString)) 52 | itemstack.t(); 53 | else { 54 | itemstack.c(this.n); 55 | } 56 | } 57 | } 58 | 59 | e(); 60 | } 61 | 62 | } 63 | 64 | public enum AnvilSlot { 65 | INPUT_LEFT(0), INPUT_RIGHT(1), OUTPUT(2); 66 | 67 | private int slot; 68 | 69 | private AnvilSlot(int slot) { 70 | this.slot = slot; 71 | } 72 | 73 | public int getSlot() { 74 | return slot; 75 | } 76 | 77 | public static AnvilSlot bySlot(int slot) { 78 | for (AnvilSlot anvilSlot : values()) { 79 | if (anvilSlot.getSlot() == slot) { 80 | return anvilSlot; 81 | } 82 | } 83 | 84 | return null; 85 | } 86 | } 87 | 88 | private HashMap items = new HashMap(); 89 | private String itemName; 90 | private HashMap data = new HashMap(); 91 | 92 | public void setItemName(String newString) { 93 | if (!Objects.equal(newString, itemName)) { 94 | ItemBuilder builder = new ItemBuilder(Material.PAPER); 95 | ItemStack item = currentInventory.getItem(AnvilSlot.OUTPUT.getSlot()); 96 | if (item != null && item.getType() != Material.AIR) { 97 | builder = new ItemBuilder(item); 98 | } 99 | builder.setRawTitle(newString); 100 | this.itemName = newString; 101 | setSlot(AnvilSlot.INPUT_LEFT, builder.build()); 102 | } 103 | } 104 | 105 | public Object getData(Object obj) { 106 | if (data.containsKey(obj)) { 107 | return data.get(obj); 108 | } 109 | return null; 110 | } 111 | 112 | public AnvilInventory setData(Object obj, Object value) { 113 | data.put(obj, value); 114 | return this; 115 | } 116 | 117 | public String getItemName() { 118 | return itemName; 119 | } 120 | 121 | public AnvilInventory(String inventoryName, Player player) { 122 | super(inventoryName, player); 123 | } 124 | 125 | public void setSlot(AnvilSlot slot, ItemStack item) { 126 | items.put(slot, item); 127 | if (currentInventory != null) { 128 | currentInventory.setItem(slot.getSlot(), item); 129 | } 130 | if (item != null && item.hasItemMeta()) { 131 | this.itemName = item.getItemMeta().getDisplayName(); 132 | if (itemName == null) { 133 | itemName = ""; 134 | } 135 | } 136 | } 137 | 138 | public void openInventory() { 139 | if (isInventoryInUse()) { 140 | return; 141 | } 142 | EntityPlayer p = ((CraftPlayer) getPlayer()).getHandle(); 143 | 144 | AnvilContainer container = new AnvilContainer(p); 145 | openInv(); 146 | int c = p.nextContainerCounter(); 147 | 148 | PacketContainer packet = new PacketContainer(PacketType.Play.Server.OPEN_WINDOW); 149 | StructureModifier mods = packet.getModifier(); 150 | mods.write(0, c); 151 | mods.write(1, 8); 152 | mods.write(2, "Repairing"); 153 | mods.write(3, 9); 154 | mods.write(4, true); 155 | try { 156 | ProtocolLibrary.getProtocolManager().sendServerPacket(getPlayer(), packet); 157 | } catch (InvocationTargetException e) { 158 | e.printStackTrace(); 159 | } 160 | 161 | // Set their active container to the container 162 | p.activeContainer = container; 163 | 164 | // Set their active container window id to that counter stuff 165 | p.activeContainer.windowId = c; 166 | 167 | // Add the slot listener 168 | p.activeContainer.addSlotListener(p); // Set the items to the items from the inventory given 169 | currentInventory = container.getBukkitView().getTopInventory(); 170 | 171 | for (AnvilSlot slot : items.keySet()) { 172 | currentInventory.setItem(slot.getSlot(), items.get(slot)); 173 | } 174 | } 175 | 176 | public void closeInventory(boolean forceClose) { 177 | currentInventory.clear(); 178 | super.closeInventory(forceClose); 179 | } 180 | public void closeInventory() { 181 | currentInventory.clear(); 182 | super.closeInventory(); 183 | } 184 | 185 | public ItemStack getItem(AnvilSlot slot) { 186 | ItemStack item = currentInventory == null ? items.get(slot) : currentInventory.getItem(slot.getSlot()); 187 | ItemBuilder builder = new ItemBuilder(item); 188 | builder.setRawTitle(getItemName()); 189 | return builder.build(); 190 | } 191 | 192 | @Override 193 | protected void onInventoryClick(InventoryClickEvent event) { 194 | if (event.getRawSlot() < 3) { 195 | AnvilClickEvent clickEvent = new AnvilClickEvent(AnvilInventory.this, AnvilSlot.bySlot(event.getRawSlot()), event); 196 | if (!this.isModifiable()) { 197 | clickEvent.setCancelled(true); 198 | } 199 | Bukkit.getPluginManager().callEvent(clickEvent); 200 | if (clickEvent.isCancelled()) { 201 | event.setCancelled(true); 202 | } 203 | } else if (event.isShiftClick()) { 204 | event.setCancelled(true); 205 | } 206 | } 207 | 208 | @Override 209 | public String getTitle() { 210 | return null; 211 | } 212 | 213 | @Override 214 | public void setTitle(String newTitle) { 215 | } 216 | 217 | } 218 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/InventoryApi.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.List; 6 | 7 | import org.apache.commons.lang.StringUtils; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.ChatColor; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.Listener; 13 | import org.bukkit.event.inventory.InventoryClickEvent; 14 | import org.bukkit.event.inventory.InventoryCloseEvent; 15 | import org.bukkit.event.inventory.InventoryDragEvent; 16 | import org.bukkit.event.player.PlayerQuitEvent; 17 | import org.bukkit.inventory.ItemStack; 18 | import org.bukkit.inventory.meta.ItemMeta; 19 | import org.bukkit.plugin.java.JavaPlugin; 20 | 21 | public class InventoryApi extends JavaPlugin implements Listener { 22 | 23 | private static ArrayList inventories = new ArrayList(); 24 | 25 | /** 26 | * Generates a empty array of ItemStack rounded up to the nearest 9 27 | */ 28 | public static ItemStack[] generateEmptyPage(int itemsSize) { 29 | itemsSize = (int) (Math.ceil((double) itemsSize / 9)) * 9; 30 | return new ItemStack[Math.min(54, itemsSize)]; 31 | } 32 | 33 | /** 34 | * Returns a hidden string in the itemstack which is hidden using displayname 35 | */ 36 | public static String getHiddenString(ItemStack item) { 37 | // Only the color chars at the end of the string is it 38 | StringBuilder builder = new StringBuilder(); 39 | if (!item.getItemMeta().hasDisplayName()) 40 | return null; 41 | char[] chars = item.getItemMeta().getDisplayName().toCharArray(); 42 | for (int i = 0; i < chars.length; i++) { 43 | char c = chars[i]; 44 | if (c == ChatColor.COLOR_CHAR) 45 | continue; 46 | if (i + 1 < chars.length) { 47 | if (chars[i + 1] == ChatColor.COLOR_CHAR && i > 1 && chars[i - 1] == ChatColor.COLOR_CHAR) 48 | builder.append(c); 49 | else if (builder.length() > 0) 50 | builder = new StringBuilder(); 51 | } else if (i > 0 && chars[i - 1] == ChatColor.COLOR_CHAR) 52 | builder.append(c); 53 | } 54 | if (builder.length() == 0) 55 | return null; 56 | return builder.toString(); 57 | } 58 | 59 | public static NamedInventory[] getNamedInventories(Player p) { 60 | if (!p.hasMetadata("NamedInventory")) 61 | return new NamedInventory[2]; 62 | return ((NamedInventory[]) p.getMetadata("NamedInventory").get(0).value()).clone(); 63 | } 64 | 65 | /** 66 | * Gets the named inventory of a player 67 | */ 68 | public static NamedInventory getNamedInventory(Player p) { 69 | NamedInventory[] invs = getNamedInventories(p); 70 | return invs[0]; 71 | } 72 | 73 | /** 74 | * Gets the named inventory of a player 75 | */ 76 | public static AnvilInventory getAnvilInventory(Player p) { 77 | if (!p.hasMetadata("AnvilInventory")) 78 | return null; 79 | return ((AnvilInventory[]) p.getMetadata("AnvilInventory").get(0).value())[0]; 80 | } 81 | 82 | public static PageInventory[] getPageInventories(Player p) { 83 | if (!p.hasMetadata("PageInventory")) 84 | return new PageInventory[2]; 85 | return ((PageInventory[]) p.getMetadata("PageInventory").get(0).value()).clone(); 86 | } 87 | 88 | /** 89 | * Gets the page inventory of a player 90 | */ 91 | public static PageInventory getPageInventory(Player p) { 92 | PageInventory[] invs = getPageInventories(p); 93 | return invs[0]; 94 | } 95 | 96 | /** 97 | * Does the itemstack have a hidden string using chatcolors in it 98 | */ 99 | public static boolean hasHiddenString(ItemStack item) { 100 | return getHiddenString(item) != null; 101 | } 102 | 103 | public static void registerInventory(ClickInventory inv) { 104 | inventories.add(inv); 105 | } 106 | 107 | /** 108 | * Sets a hidden string in the itemstack displayname 109 | */ 110 | public static ItemStack setHiddenString(ItemStack itemToName, String name) { 111 | String itemName = ChatColor.WHITE + toReadable(itemToName.getType().name()); 112 | ItemMeta meta = itemToName.getItemMeta(); 113 | if (meta.hasDisplayName()) 114 | itemName = meta.getDisplayName(); 115 | for (int i = 0; i < name.length(); i++) { 116 | itemName += ChatColor.COLOR_CHAR + name.substring(i, i + 1); 117 | } 118 | meta.setDisplayName(itemName); 119 | itemToName.setItemMeta(meta); 120 | return itemToName; 121 | } 122 | 123 | /** 124 | * Generates a item with the given Material, Data, Name and Lore 125 | */ 126 | @Deprecated 127 | public static ItemStack setNameAndLore(ItemStack item, String name, List lore) { 128 | ItemMeta meta = item.getItemMeta(); 129 | if (name != null) { 130 | if (ChatColor.stripColor(name).equals(name)) 131 | name = ChatColor.WHITE + name; 132 | meta.setDisplayName(name); 133 | } 134 | if (lore != null && lore.size() > 0) { 135 | meta.setLore(lore); 136 | } 137 | item.setItemMeta(meta); 138 | return item; 139 | } 140 | 141 | /** 142 | * Generates a item with the given Material, Data, Name and Lore 143 | */ 144 | @Deprecated 145 | public static ItemStack setNameAndLore(ItemStack item, String name, String... lore) { 146 | return setNameAndLore(item, name, Arrays.asList(lore)); 147 | } 148 | 149 | /** 150 | * Creates a itemstack which is unlike existing itemstacks in that it has a unique displayname 151 | */ 152 | public static ItemStack setUniqueItem(ItemStack item) { 153 | return setHiddenString(item, System.currentTimeMillis() + ""); 154 | } 155 | 156 | private static String toReadable(String string) { 157 | String[] names = string.split("_"); 158 | for (int i = 0; i < names.length; i++) { 159 | names[i] = names[i].substring(0, 1) + names[i].substring(1).toLowerCase(); 160 | } 161 | return (StringUtils.join(names, " ")); 162 | } 163 | 164 | protected static void unregisterInventory(ClickInventory inv) { 165 | inventories.remove(inv); 166 | } 167 | 168 | @EventHandler 169 | public void onClose(InventoryCloseEvent event) { 170 | int found = 0; 171 | for (ClickInventory inv : new ArrayList(inventories)) { 172 | if (inv.getPlayer() == event.getPlayer()) { 173 | if (inv.isInventoryInUse()) { 174 | inv.closeInventory(false); 175 | } 176 | if (found++ == 1) 177 | break; 178 | } 179 | } 180 | } 181 | 182 | /** 183 | * Ignore this 184 | */ 185 | public void onEnable() { 186 | ClickInventory.plugin = this; 187 | Bukkit.getPluginManager().registerEvents(this, this); 188 | } 189 | 190 | @EventHandler 191 | public void onInventoryClick(InventoryClickEvent event) { 192 | int found = 0; 193 | for (ClickInventory cInv : new ArrayList(inventories)) { 194 | if (cInv.getPlayer() == event.getWhoClicked()) { 195 | cInv.onInventoryClick(event); 196 | if (found++ == 1) 197 | break; 198 | } 199 | } 200 | } 201 | 202 | @EventHandler 203 | public void onInventoryDrag(InventoryDragEvent event) { 204 | int found = 0; 205 | for (ClickInventory inv : new ArrayList(inventories)) { 206 | if (inv.getPlayer() == event.getWhoClicked()) { 207 | inv.onInventoryDrag(event); 208 | if (found++ == 1) 209 | break; 210 | } 211 | } 212 | } 213 | 214 | @EventHandler 215 | public void onQuit(PlayerQuitEvent event) { 216 | int found = 0; 217 | for (ClickInventory inv : new ArrayList(inventories)) { 218 | if (inv.getPlayer() == event.getPlayer()) { 219 | if (inv.isInventoryInUse()) { 220 | inv.closeInventory(false); 221 | } 222 | if (found++ == 1) 223 | break; 224 | } 225 | } 226 | } 227 | 228 | } 229 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/ItemBuilder.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.HashMap; 6 | import java.util.List; 7 | import java.util.Map; 8 | 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.ChatColor; 11 | import org.bukkit.Color; 12 | import org.bukkit.Material; 13 | import org.bukkit.enchantments.Enchantment; 14 | import org.bukkit.inventory.ItemStack; 15 | import org.bukkit.inventory.meta.ItemMeta; 16 | import org.bukkit.inventory.meta.LeatherArmorMeta; 17 | import org.bukkit.potion.Potion; 18 | 19 | /** 20 | * @author PaulBGD from https://gist.github.com/PaulBGD/9831d28b1c7bdba0cddd 21 | * 22 | * This however was modified for my own needs 23 | */ 24 | public class ItemBuilder { 25 | 26 | private int amount; 27 | private Color color; 28 | private final short data; 29 | private final HashMap enchants = new HashMap(); 30 | private final List lore = new ArrayList(); 31 | private Material mat; 32 | // private Potion potion; 33 | private String title = null; 34 | 35 | public ItemBuilder(ItemStack item) { 36 | this(item.getType(), item.getDurability()); 37 | this.amount = item.getAmount(); 38 | this.enchants.putAll(item.getEnchantments()); 39 | if (item.getType() == Material.POTION) { 40 | // setPotion(Potion.fromItemStack(item)); 41 | } 42 | if (item.hasItemMeta()) { 43 | ItemMeta meta = item.getItemMeta(); 44 | if (meta.hasDisplayName()) { 45 | this.title = meta.getDisplayName(); 46 | } 47 | if (meta.hasLore()) { 48 | this.lore.addAll(meta.getLore()); 49 | } 50 | if (meta instanceof LeatherArmorMeta) { 51 | this.setColor(((LeatherArmorMeta) meta).getColor()); 52 | } 53 | } 54 | } 55 | 56 | public ItemBuilder(Material mat) { 57 | this(mat, 1); 58 | } 59 | 60 | public ItemBuilder(Material mat, int amount) { 61 | this(mat, amount, (short) 0); 62 | } 63 | 64 | public ItemBuilder(Material mat, int amount, short data) { 65 | this.mat = mat; 66 | this.amount = amount; 67 | this.data = data; 68 | } 69 | 70 | public ItemBuilder(Material mat, short data) { 71 | this(mat, 1, data); 72 | } 73 | 74 | public ItemBuilder addEnchantment(Enchantment enchant, int level) { 75 | if (enchants.containsKey(enchant)) { 76 | enchants.remove(enchant); 77 | } 78 | enchants.put(enchant, level); 79 | return this; 80 | } 81 | 82 | public ItemBuilder addLore(String lore, int maxLength) { 83 | this.lore.addAll(split(lore, maxLength)); 84 | return this; 85 | } 86 | 87 | public ItemBuilder addLores(List lores, int maxLength) { 88 | for (String lore : lores) { 89 | addLore(lore, maxLength); 90 | } 91 | return this; 92 | } 93 | 94 | public ItemBuilder addLore(String... lores) { 95 | for (String lore : lores) { 96 | this.lore.add(ChatColor.GRAY + lore); 97 | } 98 | return this; 99 | } 100 | 101 | private static ArrayList split(String string, int maxLength) { 102 | String[] split = string.split(" "); 103 | string = ""; 104 | ArrayList newString = new ArrayList(); 105 | for (int i = 0; i < split.length; i++) { 106 | string += (string.length() == 0 ? "" : " ") + split[i]; 107 | if (ChatColor.stripColor(string).length() > maxLength) { 108 | newString 109 | .add((newString.size() > 0 ? ChatColor.getLastColors(newString.get(newString.size() - 1)) : "") + string); 110 | string = ""; 111 | } 112 | } 113 | if (string.length() > 0) 114 | newString.add((newString.size() > 0 ? ChatColor.getLastColors(newString.get(newString.size() - 1)) : "") + string); 115 | return newString; 116 | } 117 | 118 | public ItemBuilder addLores(List lores) { 119 | this.lore.addAll(lores); 120 | return this; 121 | } 122 | 123 | public ItemStack build() { 124 | Material mat = this.mat; 125 | if (mat == null) { 126 | mat = Material.AIR; 127 | Bukkit.getLogger().warning("Null material!"); 128 | } else if (mat == Material.AIR) { 129 | Bukkit.getLogger().warning("Air material!"); 130 | } 131 | ItemStack item = new ItemStack(mat, this.amount, this.data); 132 | ItemMeta meta = item.getItemMeta(); 133 | if (meta != null) { 134 | if (this.title != null) { 135 | meta.setDisplayName(this.title); 136 | } 137 | if (!this.lore.isEmpty()) { 138 | meta.setLore(this.lore); 139 | } 140 | if (meta instanceof LeatherArmorMeta) { 141 | ((LeatherArmorMeta) meta).setColor(this.color); 142 | } 143 | item.setItemMeta(meta); 144 | } 145 | item.addUnsafeEnchantments(this.enchants); 146 | // if (this.potion != null) { 147 | // this.potion.apply(item); 148 | // } 149 | return item; 150 | } 151 | 152 | public ItemBuilder clone() { 153 | ItemBuilder newBuilder = new ItemBuilder(this.mat); 154 | 155 | newBuilder.setTitle(this.title); 156 | for (String lore : this.lore) { 157 | newBuilder.addLore(lore); 158 | } 159 | for (Map.Entry entry : this.enchants.entrySet()) { 160 | newBuilder.addEnchantment(entry.getKey(), entry.getValue()); 161 | } 162 | newBuilder.setColor(this.color); 163 | // newBuilder.potion = this.potion; 164 | 165 | return newBuilder; 166 | } 167 | 168 | public HashMap getAllEnchantments() { 169 | return this.enchants; 170 | } 171 | 172 | public Color getColor() { 173 | return this.color; 174 | } 175 | 176 | public int getEnchantmentLevel(Enchantment enchant) { 177 | return this.enchants.get(enchant); 178 | } 179 | 180 | public List getLore() { 181 | return this.lore; 182 | } 183 | 184 | public String getTitle() { 185 | return this.title; 186 | } 187 | 188 | public Material getType() { 189 | return this.mat; 190 | } 191 | 192 | public boolean hasEnchantment(Enchantment enchant) { 193 | return this.enchants.containsKey(enchant); 194 | } 195 | 196 | public boolean isItem(ItemStack item) { 197 | ItemMeta meta = item.getItemMeta(); 198 | if (item.getType() != this.getType()) { 199 | return false; 200 | } 201 | if (!meta.hasDisplayName() && this.getTitle() != null) { 202 | return false; 203 | } 204 | if (!meta.getDisplayName().equals(this.getTitle())) { 205 | return false; 206 | } 207 | if (!meta.hasLore() && !this.getLore().isEmpty()) { 208 | return false; 209 | } 210 | if (meta.hasLore()) { 211 | for (String lore : meta.getLore()) { 212 | if (!this.getLore().contains(lore)) { 213 | return false; 214 | } 215 | } 216 | } 217 | for (Enchantment enchant : item.getEnchantments().keySet()) { 218 | if (!this.hasEnchantment(enchant)) { 219 | return false; 220 | } 221 | } 222 | return true; 223 | } 224 | 225 | public ItemBuilder setAmount(int amount) { 226 | this.amount = amount; 227 | return this; 228 | } 229 | 230 | public ItemBuilder setColor(Color color) { 231 | if (!this.mat.name().contains("LEATHER_")) { 232 | throw new IllegalArgumentException("Can only dye leather armor!"); 233 | } 234 | this.color = color; 235 | return this; 236 | } 237 | 238 | public ItemBuilder setPotion(Potion potion) { 239 | if (this.mat != Material.POTION) { 240 | this.mat = Material.POTION; 241 | } 242 | // this.potion = potion; 243 | return this; 244 | } 245 | 246 | public ItemBuilder setTitle(String title) { 247 | this.title = (title == null ? null 248 | : (title.length() > 2 && ChatColor.getLastColors(title.substring(0, 2)).length() == 0 ? ChatColor.WHITE : "")) 249 | + title; 250 | return this; 251 | } 252 | 253 | public ItemBuilder setRawTitle(String title) { 254 | this.title = title; 255 | return this; 256 | } 257 | 258 | public ItemBuilder setTitle(String title, int maxLength) { 259 | if (title != null && ChatColor.stripColor(title).length() > maxLength) { 260 | ArrayList lores = split(title, maxLength); 261 | for (int i = 1; i < lores.size(); i++) { 262 | this.lore.add(lores.get(i)); 263 | } 264 | title = lores.get(0); 265 | } 266 | setTitle(title); 267 | return this; 268 | } 269 | 270 | public ItemBuilder setType(Material mat) { 271 | this.mat = mat; 272 | return this; 273 | } 274 | 275 | public ItemBuilder addLores(String[] description, int maxLength) { 276 | return addLores(Arrays.asList(description), maxLength); 277 | } 278 | 279 | } -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/ClickInventory.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.lang.reflect.Array; 4 | import java.lang.reflect.Field; 5 | import java.util.HashMap; 6 | 7 | import me.libraryaddict.inventory.events.NamedCloseEvent; 8 | import me.libraryaddict.inventory.events.PageCloseEvent; 9 | 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.Material; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.inventory.InventoryClickEvent; 14 | import org.bukkit.event.inventory.InventoryDragEvent; 15 | import org.bukkit.inventory.Inventory; 16 | import org.bukkit.inventory.ItemStack; 17 | import org.bukkit.metadata.FixedMetadataValue; 18 | import org.bukkit.plugin.java.JavaPlugin; 19 | 20 | public abstract class ClickInventory { 21 | protected static JavaPlugin plugin; 22 | protected Inventory currentInventory; 23 | protected boolean inventoryInUse; 24 | private boolean modifiable; 25 | private Player player; 26 | private boolean playerInventoryUsed; 27 | private ItemStack[] previousContents; 28 | private String inventoryName; 29 | private HashMap savedData = new HashMap(); 30 | 31 | protected void saveContents() { 32 | this.previousContents = getPlayer().getInventory().getContents().clone(); 33 | } 34 | 35 | public Object getData(Object key) { 36 | return savedData.get(key); 37 | } 38 | 39 | public ClickInventory setData(Object key, Object obj) { 40 | if (obj == null) { 41 | this.savedData.remove(key); 42 | } else { 43 | this.savedData.put(key, obj); 44 | } 45 | return this; 46 | } 47 | 48 | public ClickInventory(String inventoryName, Player player) { 49 | this.player = player; 50 | if (inventoryName == null) { 51 | inventoryName = getClass().getSimpleName(); 52 | } 53 | this.inventoryName = inventoryName; 54 | } 55 | 56 | public String getName() { 57 | return inventoryName; 58 | } 59 | 60 | public ClickInventory setPlayerInventory() { 61 | if (!isInventoryInUse()) { 62 | this.playerInventoryUsed = true; 63 | } 64 | return this; 65 | } 66 | 67 | public void closeInventory() { 68 | closeInventory(true); 69 | } 70 | 71 | protected void onInventoryDrag(InventoryDragEvent event) { 72 | if (!isModifiable()) { 73 | for (int slot : event.getRawSlots()) { 74 | if (checkInMenu(slot)) { 75 | event.setCancelled(true); 76 | return; 77 | } 78 | } 79 | } 80 | } 81 | 82 | protected boolean checkInMenu(int rawSlot) { 83 | if (isPlayerInventory()) { 84 | if (getPlayer().getOpenInventory().getTopInventory().getHolder() != getPlayer()) { 85 | rawSlot -= getPlayer().getOpenInventory().getTopInventory().getSize(); 86 | } 87 | return rawSlot >= 0 && rawSlot < currentInventory.getSize(); 88 | } 89 | return rawSlot < currentInventory.getSize(); 90 | } 91 | 92 | public boolean isPlayerInventory() { 93 | return playerInventoryUsed; 94 | } 95 | 96 | protected abstract void onInventoryClick(InventoryClickEvent event); 97 | 98 | private void closeInventory(boolean forceClose, boolean restoreInventory) { 99 | InventoryApi.unregisterInventory(this); 100 | inventoryInUse = false; 101 | if (getPlayer().hasMetadata(getClass().getSimpleName())) { 102 | E[] invs = (E[]) getPlayer().getMetadata(getClass().getSimpleName()).get(0).value(); 103 | if (invs[isPlayerInventory() ? 1 : 0] == this) { 104 | invs[isPlayerInventory() ? 1 : 0] = null; 105 | } 106 | } 107 | if (this instanceof NamedInventory) { 108 | Bukkit.getPluginManager().callEvent(new NamedCloseEvent((NamedInventory) this)); 109 | } 110 | if (this instanceof PageInventory) { 111 | Bukkit.getPluginManager().callEvent(new PageCloseEvent((PageInventory) this)); 112 | } 113 | if (forceClose && (!isPlayerInventory() || (getPlayer().getOpenInventory().getTopInventory().equals(currentInventory)))) { 114 | getPlayer().closeInventory(); 115 | } 116 | if (isPlayerInventory() && restoreInventory) { 117 | getPlayer().getInventory().clear(); 118 | getPlayer().getInventory().setContents(previousContents); 119 | Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { 120 | public void run() { 121 | getPlayer().updateInventory(); 122 | } 123 | }); 124 | } 125 | } 126 | 127 | public void closeInventory(boolean forceClose) { 128 | closeInventory(forceClose, true); 129 | } 130 | 131 | /** 132 | * Gets the item in a slot. Returns null if no item or if item is null 133 | */ 134 | public ItemStack getItem(int slot) { 135 | if (isPlayerInventory()) { 136 | slot += 9; 137 | if (slot >= 36) { 138 | slot -= 36; 139 | } 140 | } 141 | if (currentInventory != null && currentInventory.getSize() > slot) { 142 | return currentInventory.getItem(slot); 143 | } 144 | return null; 145 | } 146 | 147 | protected void setItems(ItemStack[] items) { 148 | if (isPlayerInventory()) { 149 | for (int i = 0; i < items.length; i++) { 150 | setItem(i, items[i]); 151 | } 152 | } else { 153 | currentInventory.setContents(items); 154 | } 155 | } 156 | 157 | protected void setItem(int slot, ItemStack item) { 158 | if (isPlayerInventory()) { 159 | slot += 9; 160 | if (slot >= 36) { 161 | slot -= 36; 162 | } 163 | } 164 | currentInventory.setItem(slot, item); 165 | } 166 | 167 | /** 168 | * Gets the player using this 169 | */ 170 | public Player getPlayer() { 171 | return player; 172 | } 173 | 174 | public boolean isInventoryInUse() { 175 | return this.inventoryInUse; 176 | } 177 | 178 | public boolean isModifiable() { 179 | return modifiable; 180 | } 181 | 182 | /** 183 | * Internal method to open the inventory or switch them 184 | */ 185 | protected void openInv() { 186 | /** 187 | * If ever getting bugs with opening a inventory and items glitch and no itemclickevent fires. Make sure you cancel the 188 | * click event you used to get this.. And didn't open a new inventory as the old one closed. 189 | */ 190 | boolean isSwitchingInventory = isInventoryInUse(); 191 | ItemStack heldItem = null; 192 | ClickInventory[] invs = new ClickInventory[2]; 193 | for (String inv : new String[] { "PageInventory", "NamedInventory", "AnvilInventory" }) { 194 | if (getPlayer().hasMetadata(inv)) { 195 | E[] invss = (E[]) (getPlayer().hasMetadata(inv) ? getPlayer().getMetadata(inv).get(0).value() : null); 196 | if (invss != null) { 197 | for (int i = 0; i < 2; i++) { 198 | if (invss[i] != null) { 199 | invs[i] = (ClickInventory) invss[i]; 200 | } 201 | } 202 | } 203 | } 204 | } 205 | if (!isPlayerInventory()) { 206 | inventoryInUse = false; 207 | boolean previous = false; 208 | if (invs[1] != null) { 209 | previous = ((ClickInventory) invs[1]).inventoryInUse; 210 | ((ClickInventory) invs[1]).inventoryInUse = false; 211 | } 212 | if (isSwitchingInventory) { 213 | heldItem = getPlayer().getItemOnCursor(); 214 | getPlayer().setItemOnCursor(new ItemStack(Material.AIR)); 215 | } 216 | try { 217 | Object player = getPlayer().getClass().getDeclaredMethod("getHandle").invoke(getPlayer()); 218 | Class c = Class.forName(player.getClass().getName().replace("Player", "Human")); 219 | Object defaultContainer = c.getField("defaultContainer").get(player); 220 | Field activeContainer = c.getField("activeContainer"); 221 | if (activeContainer.get(player) == defaultContainer) { 222 | if (!(this instanceof AnvilInventory)) 223 | getPlayer().openInventory(currentInventory); 224 | } else { 225 | // Do this so that other inventories know their time is over. 226 | Class.forName("org.bukkit.craftbukkit." + c.getName().split("\\.")[3] + ".event.CraftEventFactory") 227 | .getMethod("handleInventoryCloseEvent", c).invoke(null, player); 228 | activeContainer.set(player, defaultContainer); 229 | if (!(this instanceof AnvilInventory)) 230 | getPlayer().openInventory(currentInventory); 231 | } 232 | } catch (Exception ex) { 233 | ex.printStackTrace(); 234 | } 235 | if (invs[1] != null) { 236 | ((ClickInventory) invs[1]).inventoryInUse = previous; 237 | } 238 | } else { 239 | getPlayer().updateInventory(); 240 | if (!isSwitchingInventory && getPlayer().getOpenInventory().getTopInventory().getHolder() == getPlayer()) { 241 | getPlayer().openInventory(Bukkit.createInventory(null, 0, getTitle())); 242 | } 243 | } 244 | if (!isSwitchingInventory) { 245 | InventoryApi.registerInventory(this); 246 | int slot = isPlayerInventory() ? 1 : 0; 247 | if (invs[slot] != null) { 248 | if (invs[slot].inventoryInUse) { 249 | invs[slot].closeInventory(false, false); 250 | } 251 | if (isPlayerInventory()) { 252 | this.previousContents = ((ClickInventory) invs[1]).previousContents; 253 | } 254 | } 255 | E[] inv = (E[]) (getPlayer().hasMetadata(getClass().getSimpleName()) ? getPlayer() 256 | .getMetadata(getClass().getSimpleName()).get(0).value() : (E[]) Array.newInstance(getClass(), 2)); 257 | inv[slot] = (E) this; 258 | getPlayer().setMetadata(getClass().getSimpleName(), new FixedMetadataValue(plugin, inv)); 259 | } else { 260 | if (heldItem != null && heldItem.getType() != Material.AIR) { 261 | getPlayer().setItemOnCursor(heldItem); 262 | getPlayer().updateInventory(); 263 | } 264 | } 265 | inventoryInUse = true; 266 | } 267 | 268 | public abstract String getTitle(); 269 | 270 | public void setModifiable(boolean modifiable) { 271 | this.modifiable = modifiable; 272 | } 273 | 274 | public abstract void setTitle(String newTitle); 275 | 276 | } 277 | -------------------------------------------------------------------------------- /src/me/libraryaddict/inventory/PageInventory.java: -------------------------------------------------------------------------------- 1 | package me.libraryaddict.inventory; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.HashMap; 6 | 7 | import me.libraryaddict.inventory.events.PagesTurnEvent; 8 | import me.libraryaddict.inventory.events.PagesClickEvent; 9 | 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.ChatColor; 12 | import org.bukkit.Material; 13 | import org.bukkit.entity.Player; 14 | import org.bukkit.event.inventory.InventoryClickEvent; 15 | import org.bukkit.inventory.ItemStack; 16 | 17 | public final class PageInventory extends ClickInventory { 18 | 19 | protected ItemStack backAPage, forwardsAPage, exitInventory; 20 | protected int currentPage; 21 | protected boolean dynamicInventorySize = true; 22 | private int inventorySize = 54; 23 | protected boolean pageDisplayedInTitle; 24 | protected HashMap pages = new HashMap(); 25 | protected String title = "Inventory"; 26 | private String titleFormat = "%Title% - Page %Page%"; 27 | 28 | public PageInventory(Player player) { 29 | this(null, player); 30 | } 31 | 32 | public PageInventory(Player player, boolean dymanicInventory) { 33 | this(null, player, dymanicInventory); 34 | } 35 | 36 | public PageInventory(Player player, int inventorySize) { 37 | this(null, player, inventorySize); 38 | } 39 | 40 | public PageInventory(String inventoryName, Player player) { 41 | super(inventoryName, player); 42 | } 43 | 44 | public PageInventory(String inventoryName, Player player, boolean dymanicInventory) { 45 | super(inventoryName, player); 46 | dynamicInventorySize = dymanicInventory; 47 | } 48 | 49 | public PageInventory(String inventoryName, Player player, int inventorySize) { 50 | super(inventoryName, player); 51 | this.inventorySize = Math.min(54, (int) (Math.ceil((double) inventorySize / 9)) * 9); 52 | this.dynamicInventorySize = false; 53 | pages.put(0, new ItemStack[0]); 54 | } 55 | 56 | public ItemStack getExitInventory() { 57 | return exitInventory; 58 | } 59 | 60 | public void setExitInventory(ItemStack item) { 61 | this.exitInventory = item; 62 | } 63 | 64 | /** 65 | * Get the itemstack which is the backpage 66 | */ 67 | public ItemStack getBackPage() { 68 | if (backAPage == null) { 69 | backAPage = InventoryApi.setNameAndLore(new ItemStack(Material.SIGN), ChatColor.RED + "Back", 70 | new String[] { ChatColor.BLUE + "Click this to move back" }); 71 | } 72 | return backAPage; 73 | } 74 | 75 | /** 76 | * Get the current page number 77 | */ 78 | public int getCurrentPage() { 79 | return currentPage; 80 | } 81 | 82 | /** 83 | * Get the itemstack which is the next page 84 | */ 85 | public ItemStack getForwardsPage() { 86 | if (forwardsAPage == null) { 87 | forwardsAPage = InventoryApi.setNameAndLore(new ItemStack(Material.SIGN), ChatColor.RED + "Forward", 88 | new String[] { ChatColor.BLUE + "Click this to move forward" }); 89 | } 90 | return forwardsAPage; 91 | } 92 | 93 | @Override 94 | public String getTitle() { 95 | return getPageTitle(); 96 | } 97 | 98 | /** 99 | * Get the items in a page 100 | */ 101 | public ItemStack[] getPage(int pageNumber) { 102 | if (pages.containsKey(pageNumber)) 103 | return pages.get(pageNumber); 104 | return null; 105 | } 106 | 107 | /** 108 | * Get pages 109 | */ 110 | public HashMap getPages() { 111 | return pages; 112 | } 113 | 114 | protected String getPageTitle() { 115 | return (this.isPageDisplayedInTitle() ? titleFormat.replace("%Title%", title).replace("%Page%", 116 | (getCurrentPage() + 1) + "") : title); 117 | } 118 | 119 | public boolean isPageDisplayedInTitle() { 120 | return this.pageDisplayedInTitle; 121 | } 122 | 123 | protected void onInventoryClick(InventoryClickEvent event) { 124 | ItemStack item = event.getCurrentItem(); 125 | if (this.checkInMenu(event.getRawSlot())) { 126 | if (item != null) { 127 | int newPage = 0; 128 | if (item.equals(getBackPage())) { 129 | newPage = -1; 130 | } else if (item.equals(getForwardsPage())) { 131 | newPage = 1; 132 | } 133 | if (newPage != 0) { 134 | PagesTurnEvent newEvent = new PagesTurnEvent(this, event.getSlot(), event, getCurrentPage() + newPage); 135 | Bukkit.getPluginManager().callEvent(newEvent); 136 | if (!newEvent.isCancelled()) { 137 | setPage(getCurrentPage() + newPage); 138 | } 139 | event.setCancelled(true); 140 | return; 141 | } 142 | } 143 | int slot = event.getSlot(); 144 | if (isPlayerInventory()) { 145 | slot -= 9; 146 | if (slot < 0) { 147 | slot += 36; 148 | } 149 | } 150 | PagesClickEvent itemClickEvent = new PagesClickEvent(this, slot, event); 151 | if (!isModifiable()) { 152 | itemClickEvent.setCancelled(true); 153 | } 154 | Bukkit.getPluginManager().callEvent(itemClickEvent); 155 | if (itemClickEvent.isCancelled()) { 156 | event.setCancelled(true); 157 | } 158 | } else if (!this.isModifiable() && event.isShiftClick() && item != null && item.getType() != Material.AIR) { 159 | for (int slot = 0; slot < currentInventory.getSize(); slot++) { 160 | ItemStack invItem = currentInventory.getItem(slot); 161 | if (invItem == null || invItem.getType() == Material.AIR 162 | || (invItem.isSimilar(item) && item.getAmount() < item.getMaxStackSize())) { 163 | event.setCancelled(true); 164 | break; 165 | } 166 | } 167 | } 168 | } 169 | 170 | /** 171 | * Opens the inventory for use 172 | */ 173 | public void openInventory() { 174 | if (isInventoryInUse()) 175 | return; 176 | saveContents(); 177 | ItemStack[] pageItems = getItemsForPage(); 178 | if (currentInventory == null) { 179 | if (isPlayerInventory()) { 180 | currentInventory = getPlayer().getInventory(); 181 | } else { 182 | currentInventory = Bukkit.createInventory(null, pageItems.length, getPageTitle()); 183 | } 184 | } 185 | setItems(pageItems); 186 | openInv(); 187 | } 188 | 189 | private ItemStack[] getItemsForPage() { 190 | ItemStack[] pageItems = pages.get(Math.max(getCurrentPage(), 0)); 191 | int pageSize = pageItems.length; 192 | if (pages.size() > 1 || this.getExitInventory() != null) { 193 | pageSize += 9; 194 | } 195 | if (!this.dynamicInventorySize || isPlayerInventory()) { 196 | pageSize = isPlayerInventory() ? 36 : inventorySize; 197 | } else { 198 | pageSize = (int) (((pageSize + 8) / 9) * 9); 199 | } 200 | pageItems = Arrays.copyOf(pageItems, pageSize); 201 | if (getCurrentPage() > 0 || getExitInventory() != null) { 202 | pageItems[pageItems.length - 9] = getCurrentPage() == 0 ? getExitInventory() : getBackPage(); 203 | } 204 | if (pages.size() - 1 > getCurrentPage()) { 205 | pageItems[pageItems.length - 1] = getForwardsPage(); 206 | } 207 | return pageItems; 208 | } 209 | 210 | /** 211 | * Sets the itemstack which is the back page 212 | */ 213 | public void setBackPage(ItemStack newBack) { 214 | backAPage = newBack; 215 | } 216 | 217 | /** 218 | * Sets the itemstack which is the forwards page 219 | */ 220 | public void setForwardsPage(ItemStack newForwards) { 221 | forwardsAPage = newForwards; 222 | } 223 | 224 | public ArrayList getItems() { 225 | ArrayList items = new ArrayList(); 226 | for (int i = 0; i < pages.size(); i++) { 227 | ItemStack[] itemArray = pages.get(i); 228 | for (int a = 0; a < itemArray.length - (pages.size() > 1 ? 9 : 0); a++) { 229 | items.add(itemArray[a]); 230 | } 231 | } 232 | return items; 233 | } 234 | 235 | /** 236 | * Moves the inventory to a page 237 | */ 238 | public void setPage(int newPage) { 239 | if (pages.containsKey(newPage)) { 240 | currentPage = newPage; 241 | if (isInventoryInUse()) { 242 | ItemStack[] pageItems = getItemsForPage(); 243 | if (!isPlayerInventory() 244 | && (pageItems.length != currentInventory.getSize() || !currentInventory.getTitle().equalsIgnoreCase( 245 | getPageTitle()))) { 246 | currentInventory = Bukkit.createInventory(null, pageItems.length, getPageTitle()); 247 | currentInventory.setContents(pageItems); 248 | openInv(); 249 | } else { 250 | setItems(pageItems); 251 | } 252 | } 253 | } 254 | } 255 | 256 | public void setPageDisplayedInTitle(boolean displayPage) { 257 | if (this.isPageDisplayedInTitle() != displayPage) { 258 | this.pageDisplayedInTitle = displayPage; 259 | if (isInventoryInUse()) { 260 | setPage(getCurrentPage()); 261 | } 262 | } 263 | } 264 | 265 | /** 266 | * @Title = %Title% 267 | * @Page = %Page% 268 | */ 269 | public void setPageDisplayTitleFormat(String titleFormat) { 270 | this.titleFormat = titleFormat; 271 | if (isInventoryInUse()) { 272 | setPage(getCurrentPage()); 273 | } 274 | } 275 | 276 | /** 277 | * Auto fills out the pages with these items 278 | */ 279 | public void setPages(ArrayList allItems) { 280 | setPages(allItems.toArray(new ItemStack[allItems.size()])); 281 | } 282 | 283 | /** 284 | * Auto fills out the pages with these items 285 | */ 286 | public void setPages(ItemStack... allItems) { 287 | pages.clear(); 288 | int invPage = 0; 289 | boolean usePages = getExitInventory() != null || allItems.length > inventorySize; 290 | ItemStack[] items = null; 291 | int currentSlot = 0; 292 | int baseSize = isPlayerInventory() ? 36 : inventorySize; 293 | for (int currentItem = 0; currentItem < allItems.length; currentItem++) { 294 | if (items == null) { 295 | int newSize = allItems.length - currentItem; 296 | if (usePages && newSize + 9 > baseSize) { 297 | newSize = baseSize - 9; 298 | } else if (newSize > baseSize) { 299 | newSize = baseSize; 300 | } 301 | items = new ItemStack[newSize]; 302 | } 303 | ItemStack item = allItems[currentItem]; 304 | items[currentSlot++] = item; 305 | if (currentSlot == items.length) { 306 | pages.put(invPage, items); 307 | invPage++; 308 | currentSlot = 0; 309 | items = null; 310 | } 311 | } 312 | if (pages.keySet().size() < getCurrentPage()) 313 | currentPage = pages.keySet().size() - 1; 314 | if (allItems.length == 0) { 315 | int size = isPlayerInventory() ? 36 : inventorySize; 316 | if (!isPlayerInventory() && dynamicInventorySize) { 317 | size = 9; 318 | } 319 | items = InventoryApi.generateEmptyPage(size); 320 | if (getExitInventory() != null) { 321 | items[0] = getExitInventory(); 322 | } 323 | pages.put(0, items); 324 | } 325 | setPage(getCurrentPage()); 326 | } 327 | 328 | public PageInventory setPlayerInventory() { 329 | super.setPlayerInventory(); 330 | return this; 331 | } 332 | 333 | /** 334 | * Sets the title of the next page opened 335 | */ 336 | public void setTitle(String newTitle) { 337 | if (!getTitle().equals(newTitle)) { 338 | title = newTitle; 339 | if (isInventoryInUse()) { 340 | setPage(getCurrentPage()); 341 | } 342 | } 343 | } 344 | 345 | } 346 | --------------------------------------------------------------------------------