### Complete GuiManager Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

This example demonstrates the full setup and usage of GuiManager, including plugin enablement, GUI creation with custom slots and items, and opening the GUI for a player.

```java
import me.huanmeng.gui.gui.GuiManager;
import me.huanmeng.gui.gui.impl.GuiCustom;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slot;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;

public class MyPlugin extends JavaPlugin {
    private GuiManager guiManager;

    @Override
    public void onEnable() {
        guiManager = new GuiManager(this);
    }

    @Override
    public void onDisable() {
        if (guiManager != null) {
            guiManager.close();
        }
    }

    public void openCustomGui(Player player) {
        GuiCustom gui = new GuiCustom(player);
        gui.line(3);
        gui.title("Custom GUI");
        gui.draw().set(Slot.of(0), Button.of(new ItemStack(Material.DIAMOND)));
        gui.openGui();
    }
}
```

--------------------------------

### Example: Get Button Display Item

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

An example demonstrating how to retrieve the ItemStack for a button.

```java
ItemStack displayItem = button.getShowItem(player);
```

--------------------------------

### Example: Create GuiPage and configure manually

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

This example shows the creation of a GuiPage instance and the subsequent manual configuration of player, items, and slots before applying page settings and opening the GUI.

```java
GuiPage gui = new GuiPage();
gui.setPlayer(player);
gui.allItems = itemList;
gui.elementSlots = slots;
gui.pageSetting(PageSettings.normal(gui));
gui.openGui();
```

--------------------------------

### Complete Bukkit GUI Plugin Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/README.md

A full example demonstrating how to set up and use the Bukkit GUI library within a Spigot plugin. Includes GUI creation, button placement, and event handling.

```java
import me.huanmeng.gui.gui.GuiManager;
import me.huanmeng.gui.gui.impl.GuiCustom;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slot;
import me.huanmeng.gui.gui.slot.Slots;
import me.huanmeng.gui.gui.enums.Result;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;

public class MyPlugin extends JavaPlugin {
    private GuiManager guiManager;

    @Override
    public void onEnable() {
        guiManager = new GuiManager(this);
    }

    @Override
    public void onDisable() {
        if (guiManager != null) {
            guiManager.close();
        }
    }

    public void openMainMenu(Player player) {
        GuiCustom gui = new GuiCustom(player);
        gui.line(3);
        gui.title("§6Main Menu");
        
        // Border
        ItemStack barrier = new ItemStack(Material.BARRIER);
        gui.draw().set(Slots.ofPattern(
            "BBBBBBBBB",
            "BOOOOOOB",
            "BBBBBBBBB"
        ), Button.of(barrier));
        
        // Play button
        gui.draw().set(Slot.of(13), Button.ofPlayerClick(
            new ItemStack(Material.DIAMOND),
            player -> {
                player.sendMessage("Opening game...");
                openGame(player);
            }
        ));
        
        // Close button
        gui.draw().set(Slot.ofBukkit(2, 8), Button.of(
            new ItemStack(Material.BARRIER),
            clickData -> Result.CANCEL_CLOSE
        ));
        
        gui.openGui();
    }
    
    private void openGame(Player player) {
        // Game GUI setup...
    }
}
```

--------------------------------

### Complete Inventory Viewer GUI Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

An example demonstrating how to create a paginated GUI to view a player's inventory. It converts inventory items into buttons and sets up pagination with navigation controls.

```java
import me.huanmeng.gui.gui.impl.GuiPage;
import me.huanmeng.gui.gui.impl.page.PageSettings;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slots;

public class InventoryViewerGui {
    public static void viewInventory(Player viewer, Player target) {
        // Convert inventory items to buttons
        List<Button> buttons = new ArrayList<>();
        for (ItemStack item : target.getInventory().getContents()) {
            if (item != null && !item.getType().isAir()) {
                buttons.add(Button.of(item));
            }
        }
        
        // Create pagination
        Slots slots = Slots.ofPattern(
            "OOOOOOOOO",
            "OOOOOOOOO",
            "XXXXXXXXX"
        );
        
        GuiPage gui = new GuiPage(viewer, buttons, slots);
        gui.line(3);
        gui.title(target.getName() + "'s Inventory - Page 1");
        gui.pageSetting(PageSettings.normal(gui));
        gui.openGui();
    }
}
```

--------------------------------

### Build Example Plugin JAR

Source: https://github.com/huanmeng-qwq/gui/blob/master/test/README.md

Build the example plugin JAR using Gradle. The compiled plugin will be located in the build/libs directory.

```bash
./gradlew :bukkit-gui-example:shadowJar
```

--------------------------------

### Example: Select specific columns

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Demonstrates getting Slots objects for the first, fifth, and ninth columns.

```java
Slots column0 = Slots.ofColumn(0);  // Slots 0, 9, 18
Slots column4 = Slots.ofColumn(4);  // Slots 4, 13, 22
Slots column8 = Slots.ofColumn(8);  // Slots 8, 17, 26
```

--------------------------------

### Example: Slot with Placement Restriction

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slot.md

This example demonstrates how to create a slot that only allows players with 'admin' permissions to place buttons.

```java
Slot restrictedSlot = Slot.of(0, (button, player) -> {
    return player.hasPermission("admin");  // Only admins can place buttons here
});
```

--------------------------------

### Complete Shop GUI Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

A comprehensive example of creating a paginated shop GUI. It includes converting shop items to buttons, defining slot patterns, setting the GUI title, and configuring page navigation.

```java
import me.huanmeng.gui.gui.impl.GuiPage;
import me.huanmeng.gui.gui.impl.page.PageSettings;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slots;
import me.huanmeng.gui.gui.enums.Result;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

public class ShopGui {
    public static void openShop(Player player) {
        // Get all shop items as buttons
        List<Button> shopItems = new ArrayList<>();
        for (ShopItem item : shopManager.getAllItems()) {
            ItemStack display = createShopItemDisplay(item);
            shopItems.add(Button.of(display, clickData -> {
                shopManager.buyItem(player, item);
                return Result.CANCEL_UPDATE;
            }));
        }
        
        // Create pagination GUI
        Slots elementSlots = Slots.ofPattern(
            "OOOOOOOOO",  // Row 0: 9 item slots
            "OOOOOOOOO",  // Row 1: 9 item slots
            "OOOOOOOOO",  // Row 2: 9 item slots
            "XXXXXXXXX"   // Row 3: navigation buttons
        );
        
        GuiPage gui = new GuiPage(player, shopItems, elementSlots);
        gui.line(4);
        gui.title("Shop - Page 1");
        gui.pageSetting(PageSettings.normal(gui));
        gui.openGui();
    }
    
    private static ItemStack createShopItemDisplay(ShopItem item) {
        ItemStack display = item.getItem().clone();
        ItemMeta meta = display.getItemMeta();
        if (meta != null) {
            meta.setLore(Collections.singletonList("Price: $" + item.getPrice()));
            display.setItemMeta(meta);
        }
        return display;
    }
}
```

--------------------------------

### Example: Select specific rows

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Shows how to get Slots objects for the first, second, and third rows of a GUI.

```java
Slots row0 = Slots.ofLine(0);  // Slots 0-8
Slots row1 = Slots.ofLine(1);  // Slots 9-17
Slots row2 = Slots.ofLine(2);  // Slots 18-26
```

--------------------------------

### Example: Forwarding Slot Alias

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slot.md

This example shows how to make slot 1 behave exactly like slot 0 by creating a forwarding slot.

```java
// Clicking slot 1 behaves like clicking slot 0
Slot aliasSlot = Slot.forward(1, 0);
```

--------------------------------

### Basic Page Setting Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Demonstrates how to set up standard previous/next navigation for a GuiPage using PageSettings.normal().

```java
gui.pageSetting(PageSettings.normal(gui));
gui.openGui();
```

--------------------------------

### GuiDraw method chaining example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Example showcasing method chaining with GuiDraw, demonstrating setting individual slots and using the vertical method for layout.

```java
gui.draw()
    .set(0, 0, button1)
    .set(1, 1, button2)
    .set(Slots.ofLine(0), borderButton)
    .vertical(1, 1, 1, 8, fillButton);
```

--------------------------------

### Example: Fill entire GUI

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Shows how to use Slots.all() to apply an action (like filling with a button) to every slot in the GUI.

```java
gui.draw().set(Slots.all(), fillButton);  // Fill entire GUI
```

--------------------------------

### Example: Clickable Button with Dynamic Item

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

An example of creating a clickable button where the item is dynamically provided and a message is sent to the player on click.

```java
Button button = Button.of(
    player -> new ItemStack(Material.DIAMOND),
    clickData -> {
        clickData.player.sendMessage("Diamond clicked!");
        return Result.CANCEL;
    }
);
```

--------------------------------

### Complete GUI Configuration Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/configuration.md

Demonstrates comprehensive configuration of a custom GUI, including size, title, click cancellation, player inventory, periodic updates, navigation, error messages, and button drawing.

```java
import me.huanmeng.gui.gui.impl.GuiCustom;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slot;
import me.huanmeng.gui.gui.slot.Slots;
import me.huanmeng.gui.gui.enums.Result;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;

public class ConfiguredGuiExample {
    public static void createGui(Player player) {
        GuiCustom gui = new GuiCustom(player);
        
        // Size configuration
        gui.line(3);  // 3 rows
        
        // Title configuration
        gui.title(Component.text("Game Menu")
            .color(NamedTextColor.AQUA)
            .decorate(TextDecoration.BOLD));
        
        // Click cancellation configuration
        gui.setCancelClickOther(true);       // Cancel empty slot clicks
        gui.setCancelClickBottom(false);     // Allow bottom inventory clicks
        gui.setCancelMoveHotBarItemToSelf(true);
        gui.setCancelMoveItemToSelf(true);
        gui.setCancelMoveItemToBottom(false);  // Allow moving items out
        
        // Player inventory configuration
        gui.enablePlayerInventory(false);  // No buttons in player inventory
        
        // Periodic updates
        gui.tick(20)  // Every second
           .setTickRefresh(true)
           .addTick(g -> {
               // Update button states every second
               g.refresh(Slots.ofLine(0));
           });
        
        // Navigation configuration
        gui.setAllowReopen(true);
        gui.backGui(p -> new MainMenuGui(p));
        
        // Error handling
        gui.errorMessage(player -> 
            Component.text("An error occurred. Please try again.")
                .color(NamedTextColor.RED)
        );
        
        // When close callback
        gui.whenClose(g -> {
            player.sendMessage("GUI closed!");
        });
        
        // Draw buttons
        gui.draw()
            .set(Slots.ofPattern(
                "BBBBBBBBB",
                "BOOOOOOB",
                "BBBBBBBBB"
            ), Button.of(new ItemStack(Material.BARRIER)))
            .set(Slot.of(13), Button.ofPlayerClick(
                new ItemStack(Material.DIAMOND),
                p -> p.sendMessage("Diamond clicked!")
            ));
        
        gui.openGui();
    }
}
```

--------------------------------

### Example: Access pagination details

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Illustrates how to obtain the Pagination instance from a GuiPage and retrieve the total number of pages available.

```java
Pagination<Button> pagination = gui.pagination();
int totalPages = pagination.totalPages();
```

--------------------------------

### Setup Adventure Platform Support

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/configuration.md

Convenience method for setting up Adventure platform support. Requires the `net.kyori:adventure-platform-bukkit` library.

```java
BukkitAudiences audiences = BukkitAudiences.create(plugin);
GuiManager.instance().setupAdventurePlatform(audiences);

// Remember to close in onDisable()
@Override
public void onDisable() {
    audiences.close();
    GuiManager.instance().close();
}
```

--------------------------------

### Complete GUI Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Demonstrates the creation, configuration, and opening of a custom GUI. Includes setting lines, title, click behavior, player inventory interaction, drawing buttons, and handling ticks and closing events.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(3);
gui.title(Component.text("Inventory").color(NamedTextColor.GOLD));
gui.setCancelClickBottom(false);  // Allow bottom inventory clicks
gui.enablePlayerInventory(false);  // No buttons in player inventory

gui.draw()
    .set(Slot.ofBukkit(0, 0), Button.of(new ItemStack(Material.BARRIER), 
        clickData -> Result.CANCEL_CLOSE))
    .set(Slots.ofPattern(
        "BBBBBBBBB",
        "OOOOOOOOO",
        "OOOOOOOOO"
    ), fillButton);

gui.tick(20)  // Update every second
   .addTick(g -> {
       // Update button states
       g.refresh(Slots.ofPattern("O*"));
   })
   .whenClose(g -> {
       player.sendMessage("GUI closed!");
   })
   .backGui(p -> new MainMenuGui(p))
   .openGui();
```

--------------------------------

### Example: Create and open GuiPage with custom elements per page

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Demonstrates creating a GuiPage with a specific number of items per page (10 in this case), configuring page settings, and then opening the GUI.

```java
List<Button> items = getItems();
Slots slots = Slots.ofPattern("OOOOOOOOO", "OOOOOOOOO", "XXXXXXXXX");
GuiPage gui = new GuiPage(player, items, 10, slots);  // 10 items per page
gui.pageSetting(PageSettings.normal(gui));
gui.openGui();
```

--------------------------------

### Example: Grid with Padding

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Demonstrates a pattern for creating a centered 3x3 grid with one slot of padding on all sides.

```java
// Center 3x3 grid with 1-slot padding on all sides
Slots centerGrid = Slots.ofPattern(
    "XXXXXXXXX",
    "XOOOOOOOX",
    "XOOOOOOOX",
    "XOOOOOOOX",
    "XXXXXXXXX"
);
```

--------------------------------

### Example: Display-Only Button with Static Item

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

An example of creating a display-only button with a fixed ItemStack.

```java
Button staticButton = Button.of(new ItemStack(Material.DIAMOND));
```

--------------------------------

### Example: Clickable Button with Static Item

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

An example of creating a clickable button with a static diamond item that sends a message to the player upon clicking.

```java
Button button = Button.of(new ItemStack(Material.DIAMOND), clickData -> {
    clickData.player.sendMessage("Diamond clicked!");
    return Result.CANCEL;
});
```

--------------------------------

### Custom Page Navigation Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Implement custom page navigation by defining previous and next buttons within a PageSetting. This example shows how to place these buttons and handle page changes.

```java
import me.huanmeng.gui.gui.impl.GuiPage;
import me.huanmeng.gui.gui.impl.page.PageSettings;
import me.huanmeng.gui.gui.impl.page.PageSetting;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slot;

public class CustomNavigationGui {
    public static void openCustom(Player player, List<Button> items) {
        Slots elementSlots = Slots.ofPattern(
            "OOOOOOOOO",
            "OOOOOOOOO",
            "XXXXXXXXX"
        );
        
        GuiPage gui = new GuiPage(player, items, elementSlots);
        gui.line(3);
        
        // Custom page setting
        gui.pageSetting((PageSetting) g -> {
            // Previous button at position (2, 1)
            g.draw().set(Slot.ofBukkit(2, 1), Button.ofPlayerClick(
                new ItemStack(Material.ARROW),
                p -> {
                    if (g.pagination().hasPreviousPage()) {
                        g.pagination().previousPage();
                        g.refresh(true);
                    }
                }
            ));
            
            // Next button at position (2, 7)
            g.draw().set(Slot.ofBukkit(2, 7), Button.ofPlayerClick(
                new ItemStack(Material.ARROW),
                p -> {
                    if (g.pagination().hasNextPage()) {
                        g.pagination().nextPage();
                        g.refresh(true);
                    }
                }
            ));
        });
        
        gui.openGui();
    }
}
```

--------------------------------

### Example: Display-Only Button with Dynamic Item

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

An example of creating a display-only button where the item is determined dynamically based on the player.

```java
Button dynamicButton = Button.of(player -> new ItemStack(Material.DIAMOND));
```

--------------------------------

### Example: Corner slots

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Illustrates selecting only the corner slots of a GUI using a pattern.

```java
Slots corners = Slots.ofPattern(
    "OXXXXXXO",
    "XXXXXXXX",
    "OXXXXXXO"
);
```

--------------------------------

### Example: Checkerboard pattern

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Demonstrates creating a checkerboard pattern of slots using the ofPattern method.

```java
Slots checkerboard = Slots.ofPattern(
    "OXOXOXOXO",
    "XOXOXOXOX",
    "OXOXOXOXO"
);
```

--------------------------------

### Example: Navigate to specific pages

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Shows how to use the page() method to set the GUI to display the first page (index 0) or the third page (index 2).

```java
gui.page(0);  // First page
gui.page(2);  // Third page
```

--------------------------------

### Sequential Slot Filling Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Fills GUI slots sequentially from 0 to 8 with different items using a loop and the set method.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(2);

GuiDraw<GuiCustom> draw = gui.draw();

// Fill slots 0-8 with different items
for (int i = 0; i < 9; i++) {
    ItemStack item = new ItemStack(Material.values()[i % Material.values().length]);
    draw.set(i, Button.of(item));
}

gui.openGui();
```

--------------------------------

### Example: All slots in a 3-row GUI

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Illustrates creating a Slots object representing all slots in a 3-row GUI using the ofPattern method.

```java
Slots all = Slots.ofPattern(
    "OOOOOOOOO",
    "OOOOOOOOO",
    "OOOOOOOOO"
);
```

--------------------------------

### Configure GUI with Method Chaining

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiCustom.md

Illustrates advanced GUI configuration using method chaining for a more compact and readable setup. This is useful for complex GUIs where multiple settings need to be applied.

```java
new GuiCustom(player)
    .line(5)
    .title(Component.text("Advanced GUI", NamedTextColor.AQUA))
    .setCancelClickBottom(false)
    .enablePlayerInventory(false)
    .tick(20)
    .addTick(gui -> {
        // Refresh display every 20 ticks (1 second)
        gui.refresh(false);
    })
    .whenClose(gui -> {
        player.sendMessage("GUI closed!");
    })
    .backGui(p -> new MainMenuGui(p))
    .draw()
        .set(Slots.ofLine(0), fillButton)
        .set(Slot.ofBukkit(1, 0), exitButton)
    .openGui();
```

--------------------------------

### Example: Display Grid with Controls

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Illustrates patterns for a display grid with two rows of content and a separate row for controls, including navigation buttons.

```java
// 2 rows of content, 1 row of controls
Slots displayGrid = Slots.ofPattern(
    "OOOOOOOOO",
    "OOOOOOOOO",
    "XXXXXXXXX"
);

Slots controls = Slots.ofPattern(
    "XXXXXXXXX",
    "XXXXXXXXX",
    "XOOOOOOOX"  // Left and right navigation buttons
);
```

--------------------------------

### Shop Layout Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Demonstrates creating a shop layout in a GUI, including a border, title area, item display, and bottom controls using various GuiDraw methods.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(5);

// Border
ItemStack barrier = new ItemStack(Material.BARRIER);
gui.draw().vertical(0, 0, 4, 8, Button.of(barrier));

// Title area (row 0)
ItemStack title = new ItemStack(Material.GOLD_BLOCK);
gui.draw().set(0, 4, Button.of(title));

// Item display area (rows 1-3)
List<Button> shopItems = getShopItems();
gui.draw().set(Slots.ofPattern(
    "OOOOOOOOO",
    "OOOOOOOOO",
    "OOOOOOOOO"
), shopItems);

// Bottom controls (row 4)
gui.draw()
    .set(4, 2, Button.of(new ItemStack(Material.ARROW), clickData -> {
        // Previous page
        return Result.CANCEL;
    }))
    .set(4, 6, Button.of(new ItemStack(Material.ARROW), clickData -> {
        // Next page
        return Result.CANCEL;
    }));

gui.openGui();
```

--------------------------------

### GuiDraw vertical method example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Example demonstrating the usage of the vertical method to fill different areas of a GUI, including rows, columns, and a center rectangle.

```java
gui.draw()
    // Fill entire first row
    .vertical(0, 0, 0, 8, borderButton)
    // Fill entire last row
    .vertical(2, 0, 2, 8, borderButton)
    // Fill left column
    .vertical(0, 0, 2, 0, borderButton)
    // Fill right column
    .vertical(0, 8, 2, 8, borderButton)
    // Fill a 2x2 center area
    .vertical(1, 3, 2, 5, fillButton);
```

--------------------------------

### Dynamic Button Distribution Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Fills available GUI slots with buttons created from player's inventory items using Slots.ofPattern and the set method.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(3);

List<ItemStack> items = player.getInventory().getContents();
List<Button> buttons = Button.ofItemStacks(Arrays.asList(items));

// Fill available slots with items
gui.draw().set(Slots.ofPattern(
    "OOOOOOOOO",
    "OOOOOOOOO",
    "OOOOOOOOO"
), buttons);

gui.openGui();
```

--------------------------------

### Example: Border slots

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Demonstrates creating a Slots object for the border of a GUI, excluding the inner slots.

```java
Slots border = Slots.ofPattern(
    "BBBBBBBBB",
    "BOOOOOOB",
    "BBBBBBBBB"
);
```

--------------------------------

### Example: Byte pattern selection

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Illustrates creating slots using a byte array to define inclusion and exclusion for each slot across multiple rows.

```java
Slots slots = Slots.ofBytePattern(
    1,1,1,1,1,1,1,1,1,  // Row 0: all included
    0,0,0,0,0,0,0,0,0,  // Row 1: all excluded
    1,1,1,1,1,1,1,1,1   // Row 2: all included
);
```

--------------------------------

### Player and Size Management

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Methods for setting and retrieving the target player, and getting GUI inventory size.

```APIDOC
## setPlayer(Player player)

### Description
Sets the target player for this GUI.

### Method
```java
public void setPlayer(Player player)
```

### Parameters
#### Path Parameters
- **player** (Player) - Required - The player who will view this GUI

## getPlayer()

### Description
Gets the target player viewing this GUI.

### Method
```java
public Player getPlayer()
```

### Returns
`Player` — the player viewing this GUI, or null if not set

## size()

### Description
Gets the total number of slots in this GUI's inventory.

### Method
```java
public int size()
```

### Returns
`int` — the number of slots

## getInventory()

### Description
Gets the cached inventory for this GUI.

### Method
```java
public Inventory getInventory()
```

### Returns
`Inventory` — the cached inventory instance
```

--------------------------------

### openGui()

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Opens the GUI inventory for the player. This is an abstract method that must be implemented by subclasses to handle inventory creation and setup. It returns the GUI instance for method chaining and throws an IllegalArgumentException if no player is set.

```APIDOC
## openGui()

### Description
Opens the GUI inventory for the player. Implementation must handle inventory creation and setup.

### Returns
`G` — this GUI instance for method chaining

### Throws
`IllegalArgumentException` if no player is set
```

--------------------------------

### Using GuiDraw with Slots Patterns Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Demonstrates using GuiDraw with custom slot patterns, specifically excluding a center slot from being filled with a glass button.

```java
import me.huanmeng.gui.gui.slot.Slots;

GuiCustom gui = new GuiCustom(player);
gui.line(3);

// Exclude center slot
Slots availableSlots = Slots.exclude(Slots.all(), Slot.of(13));

gui.draw().set(availableSlots, Button.of(new ItemStack(Material.GLASS)));

gui.openGui();
```

--------------------------------

### Example: Top row only

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Shows how to select only the top row of slots using a pattern string.

```java
Slots topRow = Slots.ofPattern(
    "OOOOOOOOO",
    "XXXXXXXXX",
    "XXXXXXXXX"
);
```

--------------------------------

### Setup Adventure Platform with AudienceProvider

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

Configures the audience resolution using an Adventure AudienceProvider. This is a convenience method for plugins using adventure-platform and automatically handles Player and ConsoleCommandSender. Requires the net.kyori:adventure-platform-bukkit library.

```java
public void setupAdventurePlatform(AudienceProvider audienceProvider)
```

```java
BukkitAudiences audiences = BukkitAudiences.create(plugin);
guiManager.setupAdventurePlatform(audiences);

// Remember to close BukkitAudiences in onDisable()
audiences.close();
```

--------------------------------

### Line Configuration for GuiPage

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Shows how to configure the number of rows (lines) for a GuiPage, which determines the total number of slots available. This example sets the GUI to 6 rows (54 slots).

```java
GuiPage gui = new GuiPage(player, items, slots);
gui.line(6);  // 6 rows = 54 slots total
gui.pageSetting(PageSettings.normal(gui));
gui.openGui();
```

--------------------------------

### Example: Exclude center slot

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Demonstrates creating a Slots selection that includes all slots except the center one.

```java
Slots allExceptCenter = Slots.exclude(
    Slots.all(),
    Slot.of(13)  // Center slot
);

gui.draw().set(allExceptCenter, fillButton);
```

--------------------------------

### Example: Navigation Area (Bottom Row)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Shows patterns for selecting the content area (excluding the bottom row) and just the navigation row.

```java
// Fill everything except bottom row
Slots contentArea = Slots.ofPattern(
    "OOOOOOOOO",
    "OOOOOOOOO",
    "XXXXXXXXX"
);

// Just the navigation row
Slots navigationArea = Slots.ofPattern(
    "XXXXXXXXX",
    "XXXXXXXXX",
    "OOOOOOOOO"
);
```

--------------------------------

### getIndex()

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slot.md

Gets the slot index position in the inventory. Slot indices start at 0 and increment left-to-right, top-to-bottom.

```APIDOC
## getIndex()

### Description
Gets the slot index position in the inventory. Slot indices start at 0 and increment left-to-right, top-to-bottom.

### Returns
`int` - the zero-based slot index

### Example
```java
Slot slot = Slot.of(13);
int index = slot.getIndex();  // Returns 13
```
```

--------------------------------

### setupAdventurePlatform

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/configuration.md

Convenience method for setting up Adventure platform support. Requires the `net.kyori:adventure-platform-bukkit` library.

```APIDOC
## setupAdventurePlatform(AudienceProvider audienceProvider)

### Description
Convenience method for setting up Adventure platform support.

### Requirements
`net.kyori:adventure-platform-bukkit` library

### Parameters
#### Path Parameters
- **audienceProvider** (AudienceProvider) - Required - The AudienceProvider to set up.

### Example
```java
BukkitAudiences audiences = BukkitAudiences.create(plugin);
GuiManager.instance().setupAdventurePlatform(audiences);

// Remember to close in onDisable()
@Override
public void onDisable() {
    audiences.close();
    GuiManager.instance().close();
}
```
```

--------------------------------

### Obtain GuiDraw Instance

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

GuiDraw is typically obtained via the GUI's draw() method. This example shows how to get the drawer instance.

```java
GuiDraw<GuiCustom> drawer = gui.draw();
```

--------------------------------

### ofBukkit(int row, int column)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slot.md

Creates a slot from row and column coordinates (0-indexed, Bukkit style). Both row and column start at 0.

```APIDOC
## ofBukkit(int row, int column)

### Description
Creates a slot from row and column coordinates (0-indexed, Bukkit style). Both row and column start at 0.

### Parameters
#### Path Parameters
- **row** (int) - Required - The row number (0-based)
- **column** (int) - Required - The column number (0-based)

### Returns
`Slot` - a new Slot instance

### Example
```java
Slot topLeft = Slot.ofBukkit(0, 0);
Slot topRight = Slot.ofBukkit(0, 8);
Slot bottomLeft = Slot.ofBukkit(2, 0);
```
```

--------------------------------

### Checkerboard Pattern Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Generates a checkerboard pattern in a GUI using nested loops and the set method to place alternating colored concrete blocks.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(3);

ItemStack black = new ItemStack(Material.BLACK_CONCRETE);
ItemStack white = new ItemStack(Material.WHITE_CONCRETE);
Button blackButton = Button.of(black);
Button whiteButton = Button.of(white);

GuiDraw<GuiCustom> draw = gui.draw();

// Create checkerboard
for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 9; col++) {
        if ((row + col) % 2 == 0) {
            draw.set(row, col, blackButton);
        } else {
            draw.set(row, col, whiteButton);
        }
    }
}

gui.openGui();
```

--------------------------------

### Simple Border Design Example

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Creates a simple border design for a GUI using the vertical method to draw the top, bottom, left, and right borders.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(3);

ItemStack barrier = new ItemStack(Material.BARRIER);
Button borderButton = Button.of(barrier);

gui.draw()
    .vertical(0, 0, 0, 8, borderButton)  // Top row
    .vertical(2, 0, 2, 8, borderButton)  // Bottom row
    .vertical(0, 0, 2, 0, borderButton)  // Left column
    .vertical(0, 8, 2, 8, borderButton)  // Right column
    .openGui();
```

--------------------------------

### Custom GUI Creation with GuiCustom Dsl

Source: https://github.com/huanmeng-qwq/gui/blob/master/README.md

Demonstrates how to open a custom GUI for a player using the GuiCustom DSL. This snippet shows setting up a button with an item and defining its click behavior.

```kotlin
import org.bukkit.entity.Player

fun openGui(player: Player) {
    player.openGui {
        draw {
            setButton(buildSlot(0)) {
                var a = 1
                showingItem = buildButtonItem {
                    ItemStack(Material.values()[a++])
                }
                updateClick {
                    it.inventory.addItem(showingItem!!.get(it))
                }
            }
        }
    }
}
```

--------------------------------

### Get Audience Function for CommandSender

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

Returns the function that resolves a CommandSender to an Adventure Audience. This function can be applied to a player to get their Audience object.

```java
public Function<CommandSender, Audience> audiences()
```

```java
Audience audience = GuiManager.instance().audiences().apply(player);
```

--------------------------------

### Get a fluent API builder for drawing buttons

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Use the `draw()` method to obtain a builder for drawing buttons onto the GUI inventory. This is useful for setting multiple buttons or patterns in a chained manner.

```java
public GuiDraw<G> draw()
```

```java
gui.draw()
    .set(Slot.of(0), button1)
    .set(Slots.ofPattern("XXXXXXXXX"), fillButton)
    .vertical(0, 0, 2, 8, borderButton);
```

--------------------------------

### Basic HGui Usage

Source: https://github.com/huanmeng-qwq/gui/blob/master/test/README.md

Demonstrates the basic usage of HGui by creating a custom GUI with a specified title and lines. The GUI is then opened for the player.

```java
public class MyGui extends HGui {
    public MyGui(Player player, boolean allowBack) {
        super(player, allowBack);
    }

    @Override
    protected AbstractGui<?> gui() {
        GuiCustom gui = new GuiCustom(context.getPlayer());
        gui.line(3);
        gui.title("My GUI");
        // Add buttons...
        return gui;
    }
}

// Open the GUI
new MyGui(player, true).open();
```

--------------------------------

### Configure GuiPage using DSL properties

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Demonstrates setting the allItems and elementSlots properties directly for a DSL-style configuration before applying page settings and opening the GUI.

```java
GuiPage gui = new GuiPage();
gui.allItems = itemList;
gui.elementSlots = slots;
gui.pageSetting(PageSettings.normal(gui));
```

--------------------------------

### getItems(Slots slots)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Gets all ItemStacks from multiple slots.

```APIDOC
## getItems(Slots slots)

### Description
Gets all ItemStacks from multiple slots.

### Parameters
#### Path Parameters
- **slots** (Slots) - Required - The slots to retrieve items from

### Returns
`ItemStack[]` — array of ItemStacks corresponding to the slots
```

--------------------------------

### getItem(Slot slot)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Gets the ItemStack at a specific slot.

```APIDOC
## getItem(Slot slot)

### Description
Gets the ItemStack at a specific slot.

### Parameters
#### Path Parameters
- **slot** (Slot) - Required - The slot position

### Returns
`ItemStack` — the ItemStack at the slot, or null if empty
```

--------------------------------

### getButton(Slot slot)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Gets the button at a specific slot.

```APIDOC
## getButton(Slot slot)

### Description
Gets the button at a specific slot.

### Parameters
#### Path Parameters
- **slot** (Slot) - Required - The slot position

### Returns
`GuiButton` — the button at the slot, or null if none found
```

--------------------------------

### getItem(int index)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Gets the ItemStack at a specific inventory index.

```APIDOC
## getItem(int index)

### Description
Gets the ItemStack at a specific inventory index.

### Parameters
#### Path Parameters
- **index** (int) - Required - The inventory slot index

### Returns
`ItemStack` — the ItemStack at the index, or null if empty
```

--------------------------------

### Get Owning Plugin Instance

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

Returns the plugin instance that owns this GUI manager.

```java
public JavaPlugin plugin()
```

--------------------------------

### Create and Open a Custom Item Shop GUI

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiCustom.md

Demonstrates how to create a custom GUI with a specific number of rows, a title, borders, item buttons, and a close button. Use this for creating interactive shops or inventory screens.

```java
import me.huanmeng.gui.gui.impl.GuiCustom;
import me.huanmeng.gui.gui.button.Button;
import me.huanmeng.gui.gui.slot.Slot;
import me.huanmeng.gui.gui.slot.Slots;
import me.huanmeng.gui.gui.enums.Result;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

public class ExampleGui {
    public static void openShop(Player player) {
        GuiCustom gui = new GuiCustom(player);
        gui.line(4);  // 4 rows = 36 slots
        gui.title("Item Shop");
        
        // Create a border with barriers
        ItemStack barrier = new ItemStack(Material.BARRIER);
        Button borderButton = Button.of(barrier);
        
        // Fill the border (top and bottom rows)
        gui.draw()
            .set(Slots.ofPattern(
                "BBBBBBBBB",
                "OOOOOOOOO",
                "OOOOOOOOO",
                "BBBBBBBBB"
            ), fillButton)
            .set(Slots.ofPattern(
                "XXXXXXXXX",
                "XOOOOOOX",
                "XOOOOOOX",
                "XXXXXXXXX"
            ), borderButton);
        
        // Add item buttons
        ItemStack diamond = new ItemStack(Material.DIAMOND);
        gui.draw().set(Slot.of(10), Button.of(diamond, clickData -> {
            if (buyDiamond(clickData.player)) {
                return Result.CANCEL_UPDATE;
            }
            return Result.CANCEL;
        }));
        
        // Add close button in bottom-right
        ItemStack closeItem = new ItemStack(Material.BARRIER);
        gui.draw().set(Slot.of(35), Button.of(closeItem, clickData -> {
            return Result.CANCEL_CLOSE;
        }));
        
        gui.openGui();
    }
    
    private static boolean buyDiamond(Player player) {
        // Your buy logic here
        return true;
    }
}
```

--------------------------------

### Get Custom GUI Handler

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

Returns the custom GUI handler for managing GUI-specific behaviors.

```java
public GuiHandler guiHandler()
```

--------------------------------

### Get GuiManager Instance

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

Retrieves the singleton instance of the GuiManager. Throws a NullPointerException if no instance has been created.

```java
GuiManager manager = GuiManager.instance();
```

--------------------------------

### Get all slots in the inventory

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Returns a Slots object representing every slot available in the GUI.

```java
static Slots all()
```

--------------------------------

### Paged GUI Creation with GuiPage Dsl

Source: https://github.com/huanmeng-qwq/gui/blob/master/README.md

Illustrates how to build and open a paged GUI using the GuiPage DSL. It configures all items, elements per page, and slot arrangements based on lines.

```kotlin
import org.bukkit.entity.Player

fun openPageGui(player: Player) {
    buildPagedGui {
        allItems = buildButtons {
            for (i in 0..60) {
                button {
                    showingItem = buildButtonItem(ItemStack(Material.values()[i]))
                }
            }
        }
        elementsPerPage = size() - 9
        elementSlots = buildSlotsByLine {
            for (i in 0..9 * line) {
                add(buildSlot(i))
            }
        }
        pageSetting {
            PageSettings.normal(this)
        }
    }.openGui(player)
}
```

--------------------------------

### Get all slots in a specific column

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Retrieves all slots belonging to a specified column (0-based index).

```java
static Slots ofColumn(int column)
```

--------------------------------

### Create and Open a Basic Custom GUI

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/README.md

Create a basic custom inventory GUI with a configurable size and title. Buttons can be set using Slot objects.

```java
GuiCustom gui = new GuiCustom(player);
gui.line(3);
gui.title("My GUI");
gui.draw().set(Slot.of(0), Button.of(new ItemStack(Material.DIAMOND)));
gui.openGui();
```

--------------------------------

### Get all slots in a specific row

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slots.md

Retrieves all slots belonging to a specified row (0-based index).

```java
static Slots ofLine(int line)
```

--------------------------------

### Create and Open a Custom GUI in Java

Source: https://github.com/huanmeng-qwq/gui/blob/master/README.md

Demonstrates how to create a simple custom GUI with a title and an item. Ensure GuiManager is initialized in your plugin's onEnable method.

```java
import me.huanmeng.gui.gui.impl.GuiCustom;
import me.huanmeng.gui.gui.slot.Slot;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

public class Example extends JavaPlugin {
    @Override
    public void onEnable() {
        new GuiManager(this);
    }

    @Override
    public void onDisable() {
        GuiManager.instance().close();
    }

    public static void open(Player player) {
        GuiCustom gui = new GuiCustom(player);
        // Set the line
        gui.line(3);

        // Set the title
        gui.title("Test Gui");

        // Add an apple
        gui.draw().set(Slot.of(1), Button.of(player-> new ItemStack(Material.APPLE)));

        // Open for player
        gui.openGui();
    }
}
```

--------------------------------

### of(int slotIndex)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slot.md

Creates a simple slot at the specified index. Slot indices start at 0.

```APIDOC
## of(int slotIndex)

### Description
Creates a simple slot at the specified index. Slot indices start at 0.

### Parameters
#### Path Parameters
- **slotIndex** (int) - Required - The slot index (0-based)

### Returns
`Slot` - a new Slot instance

### Example
```java
Slot slot = Slot.of(0);      // First slot
Slot slot = Slot.of(13);     // Middle slot
Slot slot = Slot.of(26);     // Last slot in 3-row GUI
```
```

--------------------------------

### Get an ItemStack by slot

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Retrieve an `ItemStack` from a specific `Slot` object. Returns null if the slot is empty.

```java
public ItemStack getItem(Slot slot)
```

--------------------------------

### Create GUI Slots

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Slot.md

Demonstrates three equivalent ways to create a slot at index 13 in a 3-row GUI.

```java
// Three equivalent ways to create the middle slot in a 3-row GUI
Slot slot1 = Slot.of(13);                    // Direct index
Slot slot2 = Slot.ofGame(2, 5);              // Game-style (1-indexed)
Slot slot3 = Slot.ofBukkit(1, 4);            // Bukkit-style (0-indexed)
```

--------------------------------

### Get GUI Instance from Drawer

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiDraw.md

Retrieve the GUI instance that the GuiDraw operates on. Useful for further GUI manipulation.

```java
GuiCustom gui = drawer.gui();
```

--------------------------------

### Instantiate GuiPage with player, items, and slots

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Creates a paginated GUI where the number of elements per page is automatically determined by the available slots. Ensure the PageSettings are applied before opening.

```java
public GuiPage(Player player, List<Button> allItems, Slots elementSlots)
```

--------------------------------

### GuiPage() Constructor

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiPage.md

Creates a new paginated GUI without a player or initial configuration. The player, items, and slots must be configured before opening the GUI.

```APIDOC
## GuiPage()

### Description
Creates a new paginated GUI without a player or initial configuration. The player, items, and slots must be configured before opening the GUI.

### Constructor Signature
```java
public GuiPage()
```

### Example
```java
GuiPage gui = new GuiPage();
gui.setPlayer(player);
gui.allItems = itemList;
gui.elementSlots = slots;
gui.pageSetting(PageSettings.normal(gui));
gui.openGui();
```
```

--------------------------------

### Get GUI Size and Inventory

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Retrieves the total number of slots in the GUI's inventory and the cached inventory instance itself.

```java
public int size()
```

```java
public Inventory getInventory()
```

--------------------------------

### Set and Get Target Player

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Sets or retrieves the target player who will be viewing this GUI. This is essential for personalizing GUI interactions.

```java
public void setPlayer(Player player)
```

```java
public Player getPlayer()
```

--------------------------------

### Get an ItemStack by inventory index

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/AbstractGui.md

Retrieve an `ItemStack` from a specific inventory slot index. Returns null if the slot is empty.

```java
public ItemStack getItem(int index)
```

--------------------------------

### GuiCustom Opening

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiCustom.md

Method for opening the configured GUI for the player.

```APIDOC
## openGui()

### Description
Opens this GUI for the configured player. This method validates the player, initializes the GUI, builds the inventory, fills it with buttons, preserves player cursor items, opens the inventory, caches the state, and re-fills items.

### Returns
- `GuiCustom` — this GUI instance for method chaining

### Throws
- `IllegalArgumentException` if no player is set

### Thread-safe
Handles both sync and async contexts; if called during a click event, schedules opening on the next tick

### Example
```java
gui.line(3)
   .title("My GUI")
   .draw().set(Slot.of(0), Button.of(new ItemStack(Material.DIAMOND)))
   .openGui();
```
```

--------------------------------

### Get an Empty Button

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

Returns an empty button constant that displays no item. This is useful for ensuring a slot is visually empty.

```java
static Button empty()
```

```java
Button empty = Button.empty();
gui.draw().set(Slot.of(0), empty);  // Empty slot
```

--------------------------------

### Using Back Navigation in HGui

Source: https://github.com/huanmeng-qwq/gui/blob/master/test/README.md

Demonstrates how to implement back navigation within an HGui button's click handler. Calling `gui.back()` navigates the player to the previously opened GUI.

```java
// In button click handler
gui.draw().set(Slot.of(0), Button.of(backItem, click -> {
    gui.back();  // Navigate to previous GUI
}));
```

--------------------------------

### setupAdventurePlatform(AudienceProvider audienceProvider)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/GuiManager.md

Configures the audience resolution using an Adventure AudienceProvider. This is a convenience method for plugins using adventure-platform and automatically handles Player and ConsoleCommandSender.

```APIDOC
## setupAdventurePlatform(AudienceProvider audienceProvider)

### Description
Configures the audience resolution using an Adventure `AudienceProvider`. This is a convenience method for plugins using adventure-platform. Automatically handles `Player` and `ConsoleCommandSender`.

### Method
public void setupAdventurePlatform(AudienceProvider audienceProvider)

### Parameters
#### Path Parameters
- **audienceProvider** (AudienceProvider) - Yes - The Adventure audience provider (e.g., BukkitAudiences)

### Requirements
Requires the `net.kyori:adventure-platform-bukkit` library

### Example
```java
BukkitAudiences audiences = BukkitAudiences.create(plugin);
guiManager.setupAdventurePlatform(audiences);

// Remember to close BukkitAudiences in onDisable()
audiences.close();
```
```

--------------------------------

### getShowItem(Player player)

Source: https://github.com/huanmeng-qwq/gui/blob/master/_autodocs/api-reference/Button.md

Gets the ItemStack to display for this button in the inventory. This method is called when the GUI needs to render the button.

```APIDOC
## getShowItem(Player player)

### Description
Gets the ItemStack to display for this button in the inventory. Called when the GUI needs to render the button.

### Method
`getShowItem`

### Parameters
#### Path Parameters
- **player** (Player) - Required - The player viewing the button

### Response
#### Success Response
- **ItemStack** - the ItemStack to display, or null to show no item

### Request Example
```java
ItemStack displayItem = button.getShowItem(player);
```
```