### Paginate Buttons with PaginationHelper

Source: https://github.com/landonjw/gooeylibs/wiki/Page

Example of creating a paginated interface using PaginationHelper. It generates multiple LinkedPages from a list of buttons and a template with placeholders for navigation. Requires GooeyLibs.

```java
        List<Button> buttons = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Button button = GooeyButton.builder()
                    .display(new ItemStack(Item.getItemById(100 + i)))
                    .build();
            buttons.add(button);
        }

        GooeyButton filler = GooeyButton.builder()
                .display(new ItemStack(Blocks.STAINED_GLASS_PANE, 1, EnumDyeColor.BLUE.getMetadata()))
                .build();

        LinkedPageButton previous = LinkedPageButton.builder()
                .title("Previous")
                .display(new ItemStack(Items.DIAMOND))
                .linkType(LinkType.Previous)
                .build();

        LinkedPageButton next = LinkedPageButton.builder()
                .title("Next")
                .display(new ItemStack(Items.DIAMOND))
                .linkType(LinkType.Next)
                .build();

        PlaceholderButton placeholder = new PlaceholderButton();

        ChestTemplate template = ChestTemplate.builder(6)
                .rectangle(1, 1, 4, 7, placeholder)
                .fill(filler)
                .set(5, 3, previous)
                .set(5, 5, next)
                .build();

        LinkedPage firstPage = PaginationHelper.createPagesFromPlaceholders(template, buttons, null);
```

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

### Create a BrewingStandTemplate in Java

Source: https://github.com/landonjw/gooeylibs/wiki/Standard-Templates

Configures slots for bottles, ingredients, and fuel in a brewing stand interface.

```java
		GooeyButton diamond = GooeyButton.builder()
				.display(new ItemStack(Items.DIAMOND))
				.build();

		GooeyButton emerald = GooeyButton.builder()
				.display(new ItemStack(Items.EMERALD))
				.build();

		GooeyButton dirt = GooeyButton.builder()
				.display(new ItemStack(Blocks.DIRT))
				.build();

		BrewingStandTemplate template = BrewingStandTemplate.builder()
				.bottles(dirt) // Applies dirt button to all bottle slots
				.bottle(0, diamond) // Applies diamond button to first bottle slot
				.ingredient(emerald) // Applies emerald button to ingredient slot
                                .fuel(diamond) // Applies diamond button to fuel slot
				.build();
```

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

### Build Grid-Based ChestTemplates

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Shows how to define chest-style inventory layouts using rows, columns, rectangles, and patterns.

```java
import ca.landonjw.gooeylibs2.api.template.types.ChestTemplate;
import ca.landonjw.gooeylibs2.api.button.GooeyButton;
import net.minecraft.item.ItemStack;
import net.minecraft.item.Items;
import net.minecraft.block.Blocks;

GooeyButton diamond = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .build();

GooeyButton emerald = GooeyButton.builder()
    .display(new ItemStack(Items.EMERALD))
    .build();

GooeyButton filler = GooeyButton.builder()
    .display(new ItemStack(Blocks.GRAY_STAINED_GLASS_PANE))
    .title(" ")
    .build();

// Create a 6-row chest template with various layout methods
ChestTemplate template = ChestTemplate.builder(6)
    .set(0, 0, diamond)              // Set specific slot (row 0, col 0)
    .set(5, diamond)                 // Set by index (slot 5)
    .row(1, emerald)                 // Fill entire row 1 with emerald
    .column(4, diamond)              // Fill entire column 4 with diamond
    .rectangle(2, 1, 2, 3, emerald)  // Fill rectangle: startRow, startCol, height, width
    .border(0, 0, 6, 9, filler)      // Draw border around entire chest
    .checker(3, 3, 2, 2, diamond, emerald)  // Checkerboard pattern
    .fill(filler)                    // Fill remaining empty slots
    .build();

// Modify template after creation
template.set(0, 4, GooeyButton.builder()
    .display(new ItemStack(Items.NETHER_STAR))
    .title("Center Button")
    .build());

template.clear();  // Clear all buttons from template
```

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

### Create Interactive GooeyButtons

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Demonstrates creating buttons with basic click handlers, full action context, and direct ItemStack conversion.

```java
import ca.landonjw.gooeylibs2.api.button.GooeyButton;
import ca.landonjw.gooeylibs2.api.button.ButtonAction;
import net.minecraft.item.ItemStack;
import net.minecraft.item.Items;
import java.util.Arrays;

// Basic button with click handler
GooeyButton simpleButton = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .title("Click Me!")
    .lore(Arrays.asList("Line 1", "Line 2", "Line 3"))
    .onClick(() -> System.out.println("Button clicked!"))
    .build();

// Button with full action context
GooeyButton contextButton = GooeyButton.builder()
    .display(new ItemStack(Items.EMERALD))
    .title("Info Button")
    .onClick((action) -> {
        ServerPlayerEntity player = action.getPlayer();  // Player who clicked
        ClickType clickType = action.getClickType();     // Left/right/shift click
        Button button = action.getButton();              // The button instance
        Page page = action.getPage();                    // Page containing the button

        player.sendMessage(new StringTextComponent("You clicked with: " + clickType), player.getUUID());
    })
    .build();

// Create button directly from ItemStack
GooeyButton quickButton = GooeyButton.of(new ItemStack(Items.GOLD_INGOT));
```

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

### Open UI for Multiple Players

Source: https://github.com/landonjw/gooeylibs/wiki/Self-Updating-Items

This code demonstrates how to open a Gooey page for multiple players. Ensure players are already defined.

```java
        GooeyButton button = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .title("foo")
                .build();

        ChestTemplate template = ChestTemplate.builder(6)
                .fill(button)
                .build();

        GooeyPage page = GooeyPage.builder()
                .template(template)
                .title("bar")
                .build();

        UIManager.openUIForcefully(player1, page);
        UIManager.openUIForcefully(player2, page);
```

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

### Build a FurnaceTemplate

Source: https://github.com/landonjw/gooeylibs/wiki/Template

Use FurnaceTemplate.builder() to define input, output, and fuel materials for a crafting interface. Requires GooeyButton instances for each material.

```java
GooeyButton diamond = GooeyButton.builder()
        .display(new ItemStack(Items.DIAMOND))
        .build();

GooeyButton emerald = GooeyButton.builder()
        .display(new ItemStack(Items.EMERALD))
        .build();

GooeyButton dirt = GooeyButton.builder()
        .display(new ItemStack(Blocks.DIRT))
        .build();

FurnaceTemplate template = FurnaceTemplate.builder()
        .inputMaterial(diamond)
        .outputMaterial(emerald)
        .fuel(dirt)
        .build();
```

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

### Create FurnaceTemplate

Source: https://github.com/landonjw/gooeylibs/wiki/Standard-Templates

Use this to define input, output, and fuel materials for a furnace GUI. Requires GooeyButton and ItemStack.

```java
        GooeyButton diamond = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .build();

        GooeyButton emerald = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .build();

        GooeyButton dirt = GooeyButton.builder()
                .display(new ItemStack(Blocks.DIRT))
                .build();

        FurnaceTemplate template = FurnaceTemplate.builder()
                .inputMaterial(diamond)
                .outputMaterial(emerald)
                .fuel(dirt)
                .build();
```

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

### Create and Use InventoryTemplate

Source: https://github.com/landonjw/gooeylibs/wiki/Player-Inventory-Template

Demonstrates creating GooeyButtons, a ChestTemplate, and an InventoryTemplate to build a custom GooeyPage. The InventoryTemplate is added to the page to modify the player's inventory appearance.

```java
        GooeyButton diamond = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .build();

        GooeyButton emerald = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .build();

        GooeyButton dirt = GooeyButton.builder()
                .display(new ItemStack(Blocks.DIRT))
                .build();

        ChestTemplate template = ChestTemplate.builder(6)
                .fill(diamond)
                .build();

        InventoryTemplate playerInvTemplate = InventoryTemplate.builder()
                .row(1, diamond) // Sets the second row to diamond
                .column(2, dirt) // Sets the third column to dirt
                .set(0, 1, emerald) // Sets the slot in the first row and second column to emerald
                .build();

        GooeyPage gooeyPage = GooeyPage.builder()
                .template(template)
                .inventory(playerInvTemplate) // Adds the inventory template to the page
                .build();
```

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

### Create a GooeyPage

Source: https://github.com/landonjw/gooeylibs/wiki/Page

Demonstrates how to create a basic GooeyPage with a ChestTemplate and a button. Requires GooeyLibs.

```java
        GooeyButton button = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .build();

        ChestTemplate template = ChestTemplate.builder(6)
                .fill(button)
                .build();

        GooeyPage page = GooeyPage.builder()
                .template(template)
                .build();
```

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

### Create a CraftingTableTemplate in Java

Source: https://github.com/landonjw/gooeylibs/wiki/Standard-Templates

Sets up a 3x3 crafting grid and a result slot for a crafting table interface.

```java
        GooeyButton diamond = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .build();

        GooeyButton emerald = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .build();

        GooeyButton dirt = GooeyButton.builder()
                .display(new ItemStack(Blocks.DIRT))
                .build();

        CraftingTableTemplate template = CraftingTableTemplate.builder()
                .fillGrid(dirt) // Fills the crafting grid with dirt button
                .setGrid(0, 0, emerald) // Applies dirt button to first row and first column in crafting grid
                .setResultItem(diamond) // Sets the resulting slot to diamond button
                .build();
```

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

### Custom Button Implementation with GooeyLibs

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Create custom button behaviors by extending `ButtonBase`. This allows for internal state management and specialized click logic. Changes to the button's display via `setDisplay` automatically update all viewers.

```java
import ca.landonjw.gooeylibs2.api.button.ButtonBase;
import ca.landonjw.gooeylibs2.api.button.ButtonAction;
import net.minecraft.item.ItemStack;
import net.minecraft.item.Items;
import javax.annotation.Nonnull;

public class ToggleButton extends ButtonBase {

    private boolean active = false;
    private final ItemStack activeDisplay;
    private final ItemStack inactiveDisplay;

    public ToggleButton() {
        super(new ItemStack(Items.RED_WOOL));  // Initial display
        this.activeDisplay = new ItemStack(Items.LIME_WOOL);
        this.inactiveDisplay = new ItemStack(Items.RED_WOOL);
    }

    @Override
    public void onClick(@Nonnull ButtonAction action) {
        active = !active;

        // setDisplay automatically triggers update for all viewers
        if (active) {
            setDisplay(activeDisplay);
            action.getPlayer().sendMessage(
                new StringTextComponent("Toggled ON!"), action.getPlayer().getUUID());
        } else {
            setDisplay(inactiveDisplay);
            action.getPlayer().sendMessage(
                new StringTextComponent("Toggled OFF!"), action.getPlayer().getUUID());
        }
    }

    public boolean isActive() {
        return active;
    }

    public void setActive(boolean active) {
        this.active = active;
        setDisplay(active ? activeDisplay : inactiveDisplay);
    }
}
```

```java
// Usage
ToggleButton toggleButton = new ToggleButton();
ChestTemplate template = ChestTemplate.builder(3)
    .set(1, 4, toggleButton)
    .build();
```

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

### Create a ChestTemplate in Java

Source: https://github.com/landonjw/gooeylibs/wiki/Standard-Templates

Defines a chest inventory layout with a specified number of rows and button placements.

```java
		GooeyButton diamond = GooeyButton.builder()
				.display(new ItemStack(Items.DIAMOND))
				.build();

		GooeyButton emerald = GooeyButton.builder()
				.display(new ItemStack(Items.EMERALD))
				.build();

		GooeyButton dirt = GooeyButton.builder()
				.display(new ItemStack(Blocks.DIRT))
				.build();

		ChestTemplate template = ChestTemplate.builder(6) // Defines a chest template with 6 rows
				.set(0, 0, diamond) // Sets a diamond button in the first row, first column of chest
				.row(1, emerald) // Fills the entire second row with the emerald button
				.fill(dirt) // Fills any empty slots in the chest with dirt button
				.build();
```

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

### Create a DispenserTemplate in Java

Source: https://github.com/landonjw/gooeylibs/wiki/Standard-Templates

Manages slot assignments for a dispenser inventory interface.

```java
        GooeyButton diamond = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .build();

        GooeyButton emerald = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .build();

        GooeyButton dirt = GooeyButton.builder()
                .display(new ItemStack(Blocks.DIRT))
                .build();

        DispenserTemplate template = DispenserTemplate.builder()
                .fill(dirt) // Fills all slots that are empty with dirt button
                .set(0, diamond) // Sets the first slot to diamond button
                .set(0, 1, emerald) // Sets the slot in first row and second column to emerald button
                .build();
```

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

### Create a HopperTemplate in Java

Source: https://github.com/landonjw/gooeylibs/wiki/Standard-Templates

Assigns buttons to the five slots available in a hopper inventory.

```java
        GooeyButton diamond = GooeyButton.builder()
                .display(new ItemStack(Items.DIAMOND))
                .build();

        GooeyButton emerald = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .build();

        GooeyButton dirt = GooeyButton.builder()
                .display(new ItemStack(Blocks.DIRT))
                .build();

        HopperTemplate template = HopperTemplate.builder()
                .set(0, diamond)
                .set(1, emerald)
                .set(2, dirt)
                .build();
```

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

### InventoryTemplate - Player Inventory Overlay

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Creates a client-side overlay on the player's inventory UI. Can be combined with `InventoryListenerButton` to add custom behavior to inventory slots without altering actual inventory contents.

```java
import ca.landonjw.gooeylibs2.api.template.types.InventoryTemplate;
import ca.landonjw.gooeylibs2.api.button.InventoryListenerButton;

// Create listener button for first inventory slot
InventoryListenerButton inventoryListener = new InventoryListenerButton((action) -> {
    ServerPlayerEntity player = action.getPlayer();
    ItemStack clickedItem = player.getInventory().getItem(0);
    player.sendMessage(new StringTextComponent("You clicked: " + clickedItem.getDisplayName().getString()),
        player.getUUID());
});

// Visual overlay buttons
GooeyButton highlightButton = GooeyButton.builder()
    .display(new ItemStack(Blocks.LIME_STAINED_GLASS_PANE))
    .title("Highlighted Slot")
    .build();

// Create inventory template overlay
InventoryTemplate inventoryTemplate = InventoryTemplate.builder()
    .set(0, inventoryListener)              // Add listener to first slot
    .row(3, highlightButton)                // Highlight bottom row (hotbar)
    .column(0, highlightButton)             // Highlight first column
    .build();

// Combine with main template
ChestTemplate mainTemplate = ChestTemplate.builder(6)
    .fill(GooeyButton.builder()
        .display(new ItemStack(Items.DIAMOND))
        .build())
    .build();

GooeyPage page = GooeyPage.builder()
    .title("Inventory Overlay Demo")
    .template(mainTemplate)
    .inventory(inventoryTemplate)  // Attach inventory overlay
    .build();
```

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

### Build an InventoryTemplate

Source: https://github.com/landonjw/gooeylibs/wiki/Template

Use InventoryTemplate.builder() to customize the player's inventory display on a GooeyPage. This template can be combined with InventoryListenerButtons for interactive elements. Modifications are client-side and reset on container close.

```java
GooeyButton diamond = GooeyButton.builder()
        .display(new ItemStack(Items.DIAMOND))
        .build();

GooeyButton emerald = GooeyButton.builder()
        .display(new ItemStack(Items.EMERALD))
        .build();

GooeyButton dirt = GooeyButton.builder()
        .display(new ItemStack(Blocks.DIRT))
        .build();

ChestTemplate template = ChestTemplate.builder(6)
        .fill(diamond)
        .build();

InventoryTemplate playerInvTemplate = InventoryTemplate.builder()
        .row(1, diamond) // Sets the second row to diamond
        .column(2, dirt) // Sets the third column to dirt
        .set(0, 1, emerald) // Sets the slot in the first row and second column to emerald
        .build();

GooeyPage gooeyPage = GooeyPage.builder()
        .template(template)
        .inventory(playerInvTemplate) // Adds the inventory template to the page
        .build();
```

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

### Create PlaceholderButtons

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Instantiate PlaceholderButtons, optionally with a default button, for use in LinkedPages to represent areas where buttons will be dynamically substituted. A default PlaceholderButton represents an empty slot.

```java
PlaceholderButton placeholder1 = new PlaceholderButton();

GooeyButton base = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .title("Hello")
    .onClick(() -> System.out.println("Hello"))
    .build();

PlaceholderButton placeholder2 = new PlaceholderButton(base);
```

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

### Live UI Updates with GooeyLibs

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Implement synchronized UI state across multiple players. Changes to shared page instances, templates, or buttons automatically propagate to all viewers. Manual updates can be forced using `button.update()` or `page.update()`.

```java
import ca.landonjw.gooeylibs2.api.page.GooeyPage;
import ca.landonjw.gooeylibs2.api.template.types.ChestTemplate;

GooeyButton button = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .title("Counter: 0")
    .build();

ChestTemplate template = ChestTemplate.builder(6)
    .fill(button)
    .build();

GooeyPage sharedPage = GooeyPage.builder()
    .template(template)
    .title("Shared Counter")
    .build();

// Open for multiple players - they see the same synchronized page
UIManager.openUIForcefully(player1, sharedPage);
UIManager.openUIForcefully(player2, sharedPage);
```

```java
// Update button display - automatically updates for all viewers
button.setDisplay(new ItemStack(Items.EMERALD));
```

```java
// Update specific slot - automatically updates for all viewers
template.getSlot(0).setButton(GooeyButton.builder()
    .display(new ItemStack(Items.GOLD_INGOT))
    .title("Updated!")
    .build());
```

```java
// Update page title - automatically updates for all viewers
sharedPage.setTitle(new StringTextComponent("New Title"));
```

```java
// Replace entire template - automatically updates for all viewers
ChestTemplate newTemplate = ChestTemplate.builder(3)
    .fill(GooeyButton.builder()
        .display(new ItemStack(Items.NETHER_STAR))
        .build())
    .build();
sharedPage.setTemplate(newTemplate);
```

```java
// Force manual update if needed
button.update();
sharedPage.update();
```

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

### Send a Page to a Player

Source: https://github.com/landonjw/gooeylibs/wiki/Page

Shows how to open a created GooeyPage for a player using UIManager.openPageForcefully. Assumes player and page objects exist.

```java
UIManager.openPageForcefully(player, page);
```

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

### Create and Display GooeyPage

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Defines a UI page with custom buttons and open/close event handlers. Use UIManager to open or close the interface for a player.

```java
import ca.landonjw.gooeylibs2.api.page.GooeyPage;
import ca.landonjw.gooeylibs2.api.UIManager;
import ca.landonjw.gooeylibs2.api.template.types.ChestTemplate;
import net.minecraft.entity.player.ServerPlayerEntity;

GooeyButton button = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .onClick(() -> System.out.println("Clicked!"))
    .build();

ChestTemplate template = ChestTemplate.builder(3)
    .fill(button)
    .build();

// Create page with callbacks
GooeyPage page = GooeyPage.builder()
    .title("My Custom UI")
    .template(template)
    .onOpen((action) -> {
        ServerPlayerEntity player = action.getPlayer();
        System.out.println(player.getName().getString() + " opened the page");
    })
    .onClose((action) -> {
        ServerPlayerEntity player = action.getPlayer();
        System.out.println(player.getName().getString() + " closed the page");
    })
    .build();

// Open page for a player
ServerPlayerEntity player = /* get player reference */;
UIManager.openUIForcefully(player, page);  // Immediately opens, closes any existing UI

// Alternative: wait for current container to close
UIManager.openUIPassively(player, page, 30, TimeUnit.SECONDS);

// Close player's UI programmatically
UIManager.closeUI(player);
```

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

### Implement Automatic Pagination

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Uses PaginationHelper to distribute a list of buttons across multiple linked pages. Requires a template with a PlaceholderButton to define the item area.

```java
import ca.landonjw.gooeylibs2.api.helpers.PaginationHelper;
import ca.landonjw.gooeylibs2.api.button.PlaceholderButton;
import ca.landonjw.gooeylibs2.api.button.linked.LinkedPageButton;
import ca.landonjw.gooeylibs2.api.button.linked.LinkType;
import ca.landonjw.gooeylibs2.api.page.LinkedPage;
import java.util.ArrayList;
import java.util.List;

// Create a list of items to paginate (e.g., 100 items)
List<Button> itemButtons = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    Button itemButton = GooeyButton.builder()
        .display(new ItemStack(Item.byId(100 + i)))
        .title("Item " + (i + 1))
        .onClick((action) -> action.getPlayer().sendMessage(
            new StringTextComponent("Selected item!"), action.getPlayer().getUUID()))
        .build();
    itemButtons.add(itemButton);
}

// Navigation buttons
LinkedPageButton previousButton = LinkedPageButton.builder()
    .display(new ItemStack(Items.ARROW))
    .title("Previous Page")
    .linkType(LinkType.Previous)
    .build();

LinkedPageButton nextButton = LinkedPageButton.builder()
    .display(new ItemStack(Items.ARROW))
    .title("Next Page")
    .linkType(LinkType.Next)
    .build();

// Filler button for decoration
GooeyButton filler = GooeyButton.builder()
    .display(new ItemStack(Blocks.BLUE_STAINED_GLASS_PANE))
    .title(" ")
    .build();

// Placeholder marks where items will be placed
PlaceholderButton placeholder = new PlaceholderButton();

// Build template with placeholder area for items
ChestTemplate template = ChestTemplate.builder(6)
    .rectangle(1, 1, 4, 7, placeholder)  // 28 slots for items per page
    .fill(filler)                         // Fill border
    .set(5, 3, previousButton)            // Previous button bottom-left
    .set(5, 5, nextButton)                // Next button bottom-right
    .build();

// Create paginated pages with dynamic title showing page numbers
LinkedPage.Builder pageBuilder = LinkedPage.builder()
    .title("Items - Page {current}/{total}");  // Placeholders auto-replaced

// Generate linked pages (returns first page)
LinkedPage firstPage = PaginationHelper.createPagesFromPlaceholders(template, itemButtons, pageBuilder);

// Open for player
UIManager.openUIForcefully(player, firstPage);

// Navigate programmatically
LinkedPage secondPage = firstPage.getNext();
LinkedPage lastPage = /* traverse to end */;
int totalPages = firstPage.getTotalPages();
int currentPage = firstPage.getCurrentPage();
```

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

### Implement a custom button

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Extends ButtonBase to store custom state and define behavior triggered by click actions.

```java
public class ExampleButton extends ButtonBase {

    private boolean active;

    protected ExampleButton() {
        super(new ItemStack(Items.DIAMOND));
    }

    @Override
    public void onClick(@Nonnull ButtonAction action) {
        if(active) {
            setDisplay(new ItemStack(Items.DIAMOND));
        }
        else{
            setDisplay(new ItemStack(Items.EMERALD));
        }
        active = !active;
    }

}
```

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

### Create a GooeyButton

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Use the builder pattern to create a GooeyButton with custom display, title, lore, and click behavior.

```java
Button button = GooeyButton.builder()
        .display(new ItemStack(Items.DIAMOND)) // Makes the item take on the appearance of a diamond
        .title("Hello") // Makes the title of the button "Hello"
        .lore(Arrays.asList("Line 1", "Line 2")) // Specifies the lore lines of the item.
        .onClick(() -> doStuff()) // Makes the button invoke doStuff when it is clicked.
        .build();
```

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

### Minecraft Container Templates in GooeyLibs

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Utilize pre-defined templates for common Minecraft containers like Furnaces, Brewing Stands, Hoppers, Dispensers, and Crafting Tables. Each template mirrors the slot layout of its respective container.

```java
import ca.landonjw.gooeylibs2.api.template.types.*;

// Furnace Template - 3 slots: input, fuel, output
FurnaceTemplate furnaceTemplate = FurnaceTemplate.builder()
    .inputMaterial(inputButton)
    .fuel(fuelButton)
    .outputMaterial(outputButton)
    .build();
```

```java
// Brewing Stand Template - 5 slots: 3 bottles, ingredient, fuel
BrewingStandTemplate brewingTemplate = BrewingStandTemplate.builder()
    .bottles(bottleButton)           // All 3 bottle slots
    .bottle(0, specialBottle)        // Override first bottle slot
    .ingredient(ingredientButton)
    .fuel(fuelButton)
    .build();
```

```java
// Hopper Template - 5 slots in a row
HopperTemplate hopperTemplate = HopperTemplate.builder()
    .set(0, button1)
    .set(1, button2)
    .set(2, button3)
    .set(3, button4)
    .set(4, button5)
    .build();
```

```java
// Dispenser Template - 3x3 grid
DispenserTemplate dispenserTemplate = DispenserTemplate.builder()
    .set(0, 0, topLeftButton)   // Row, Column
    .set(1, 1, centerButton)
    .fill(fillerButton)
    .build();
```

```java
// Crafting Table Template - 3x3 grid + result slot
CraftingTableTemplate craftingTemplate = CraftingTableTemplate.builder()
    .fillGrid(ingredientButton)
    .setGrid(1, 1, centerIngredient)  // Row, Column in crafting grid
    .setResultItem(resultButton)
    .build();
```

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

### Create a RateLimitedButton

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Wrap an existing button with RateLimitedButton to enforce a limit on how many times it can be clicked within a specified interval. The rate limit is shared if the button instance is shared.

```java
Button base = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .onClick(() -> System.out.println("Hello world"))
    .build();

// Creates a rate limited button that can only be invoked 3 times every 10 seconds.
RateLimitedButton button = RateLimitedButton.builder()
    .button(base)
    .limit(3)
    .interval(10, TimeUnit.SECONDS)
    .build();
```

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

### Create an InventoryListenerButton

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Create an InventoryListenerButton to add custom click functionality to inventory slots within an InventoryTemplate. The button visually represents the item in the slot.

```java
InventoryListenerButton button = new InventoryListenerButton(() -> {
    System.out.println("Hello world!");
});
InventoryTemplate template = InventoryTemplate.builder()
    .set(0, button)
    .build();
```

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

### Change Page Template

Source: https://github.com/landonjw/gooeylibs/wiki/Self-Updating-Items

Updates the entire template of an existing Gooey page. This change is reflected for all viewers.

```java
        Button button2 = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .title("bar")
                .build();

        Template template2 = DispenserTemplate.builder()
                .fill(button2)
                .build();

        page.setTemplate(template2);
```

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

### RateLimitedButton - Prevent Click Spam

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Wraps a button to limit clicks within a specified interval. Useful for actions that should not be spammed. Rate limits are shared across players if the same button instance is used.

```java
import ca.landonjw.gooeylibs2.api.button.RateLimitedButton;
import java.util.concurrent.TimeUnit;

// Base button with expensive operation
GooeyButton baseButton = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .title("Claim Reward")
    .onClick((action) -> {
        ServerPlayerEntity player = action.getPlayer();
        // Give reward to player
        player.getInventory().add(new ItemStack(Items.DIAMOND, 5));
        player.sendMessage(new StringTextComponent("Claimed 5 diamonds!"), player.getUUID());
    })
    .build();

// Wrap with rate limiting: max 3 clicks per 10 seconds
RateLimitedButton rateLimitedButton = RateLimitedButton.builder()
    .button(baseButton)
    .limit(3)
    .interval(10, TimeUnit.SECONDS)
    .build();

// Check rate limit status
boolean isLimited = rateLimitedButton.isRateLimited();
int remainingClicks = rateLimitedButton.getAllowedRemainingClicks();

// Use in template
ChestTemplate template = ChestTemplate.builder(3)
    .set(1, 4, rateLimitedButton)  // Center slot
    .build();
```

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

### MovableButton - Drag and Drop Functionality

Source: https://context7.com/landonjw/gooeylibs/llms.txt

Enables buttons to be picked up and dropped by players, facilitating drag-and-drop interfaces. Requires handlers for pickup and drop events.

```java
import ca.landonjw.gooeylibs2.api.button.moveable.MovableButton;
import ca.landonjw.gooeylibs2.api.button.moveable.MovableButtonAction;

MovableButton draggableItem = MovableButton.builder()
    .display(new ItemStack(Items.DIAMOND_SWORD))
    .title("Draggable Sword")
    .lore(Arrays.asList("Pick me up!", "Drop me somewhere else"))
    .onClick((action) -> {
        System.out.println("Item clicked at slot " + action.getSlot());
    })
    .onPickup((action) -> {
        ServerPlayerEntity player = action.getPlayer();
        int sourceSlot = action.getSlot();
        System.out.println(player.getName().getString() + " picked up item from slot " + sourceSlot);
    })
    .onDrop((action) -> {
        ServerPlayerEntity player = action.getPlayer();
        int targetSlot = action.getSlot();
        System.out.println(player.getName().getString() + " dropped item at slot " + targetSlot);
    })
    .build();

ChestTemplate template = ChestTemplate.builder(3)
    .set(1, 4, draggableItem)
    .build();
```

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

### Change Button on Page

Source: https://github.com/landonjw/gooeylibs/wiki/Self-Updating-Items

Modifies a specific button within a Gooey page's template. This update is sent to all viewers.

```java
        GooeyButton button2 = GooeyButton.builder()
                .display(new ItemStack(Items.EMERALD))
                .title("bar")
                .build();

        page.getTemplate().getSlot(0).setButton(button2);
```

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

### Force Page Update

Source: https://github.com/landonjw/gooeylibs/wiki/Self-Updating-Items

Manually triggers a refresh for a Gooey page for all viewers. Useful when view state is manipulated in subclasses.

```java
BasePage.update();
```

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

### Handle Button Clicks with ButtonAction

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Utilize the ButtonAction object passed to the onClick method to access contextual information about the click event, such as the player, click type, button instance, and page.

```java
Button button = GooeyButton.builder()
        .display(new ItemStack(Items.DIAMOND))
        .onClick((action) -> {
            EntityPlayerMP player = action.getPlayer(); // The player who clicked the button
            ClickType clickType = action.getClickType(); // The type of click on the button
            Button button = action.getButton(); // The button instance
            Page page = action.getPage(); // The page the button was on when clicked
            // Do Stuff
        })
        .build();
```

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

### Forcefully update a button

Source: https://github.com/landonjw/gooeylibs/wiki/Button

Invokes an update to synchronize button changes for all current viewers.

```java
GooeyButton button = GooeyButton.builder()
    .display(new ItemStack(Items.DIAMOND))
    .build();

// Create page and send to player1 and player2

button.update(); // This will send a call to update the button for player1 and player2.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.