GT New Horizons ModularUI Documentation

https://gtnh.miraheze.org/wiki
Admin
Documentation for ModularUI, a widget-based GUI library for Minecraft mods that simplifies GUI...
Tokens:3,643
Snippets:40
Trust Score:9.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Building Synced Item GUI with ModularUI

Source: https://gtnh.miraheze.org/wiki/ModularUI

Example of building a synced GUI for an Item by implementing `IGuiHolder`. A `ModularPanel` is created and a widget is added as a child.

```java
public class MyItem extends Item implements IGuiHolder<GuiData> {

    @Override
    public ModularPanel buildUI(GuiData guiData, PanelSyncManager guiSyncManager) {
        return new ModularPanel("mymod:test_item")
            .child(IKey.str("Hello").asWidget());
    }


```

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

### Building Synced TileEntity GUI with ModularUI

Source: https://gtnh.miraheze.org/wiki/ModularUI

Example of building a synced GUI for a TileEntity by implementing `IGuiHolder`. A `ModularPanel` is created and a widget is added as a child.

```java
public class MyTileEntity extends TileEntity implements IGuiHolder<PosGuiData> {

    @Override
    public ModularPanel buildUI(PosGuiData guiData, PanelSyncManager guiSyncManager) {
        return new ModularPanel("mymod:test_tile")
            .child(IKey.str("Hello").asWidget());
    }
}

```

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

### Building MetaTileEntity GUI with ModularUI2

Source: https://gtnh.miraheze.org/wiki/ModularUI

Example of building a MetaTileEntity GUI using `GTGuis.mteTemplatePanelBuilder`. Ensure `useMui2` is overridden to `true` and `GTGuis.GLOBAL_SWITCH_MUI2` is set to true for testing, or use `forceUseMui2`.

```java
@Override
public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager) {
    return GTGuis.mteTemplatePanelBuilder(this, data, syncManager)
        .build()
        .child(IKey.str("Hello").asWidget());
}

```

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

### Implementing a Toggle Button with Sync Handler

Source: https://gtnh.miraheze.org/wiki/ModularUI

Shows how to create a TileEntity that uses a ToggleButton with a BooleanSyncValue for server-client synchronization. The BooleanSyncValue handles getting and setting the boolean state.

```java
public class MyTileEntity extends TileEntity implements IGuiHolder<PosGuiData> {

    private boolean state;

    @Override
    public ModularPanel buildUI(PosGuiData guiData, PanelSyncManager guiSyncManager) {
        return new ModularPanel("mymod:test_tile")
            .child(new ToggleButton()
                .value(new BooleanSyncValue(() -> this.state, val -> this.state = val))
                .center());
    }
}
```

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

### Registering Slot Group for Shift-Click Functionality

Source: https://gtnh.miraheze.org/wiki/ModularUI

Example of registering a slot group named 'item_inv' with a size of 1 using `syncManager.registerSlotGroup()`. This is necessary for implementing shift-click functionality for item slots.

```java
@Override
public ModularPanel buildUI(PosGuiData data, PanelSyncManager syncManager) {
    syncManager.registerSlotGroup("item_inv", 1);
    ...
    panel.child(new ItemSlot().slot(new ModularSlot(inventoryHandler, index).slotGroup("item_inv")));
}

```

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

### Opening Client-only GUI with ModularUI

Source: https://gtnh.miraheze.org/wiki/ModularUI

Demonstrates how to open a client-only GUI by creating a `ModularPanel` instance and passing it to `ClientGUI.open`. No specific interface is required for client-only GUIs.

```java
ClientGUI.open(new ModularPanel("mymod:client_gui").child(IKey.str("Hello").asWidget()));

```

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

### Creating Simple and Customized Item Slots

Source: https://gtnh.miraheze.org/wiki/ModularUI

Illustrates how to create a basic item slot using `new ItemSlot().slot(inventoryHandler, index)`. For more control, use `new ItemSlot().slot(new ModularSlot(...).filter(...).accessibility(...))` to customize behavior without altering the backing item handler.

```java
new ItemSlot().slot(inventoryHandler, index) // Simple slot

new ItemSlot().slot(new ModularSlot(inventoryHandler, index)
    .filter(this::filter)
    .accessibility(false, true)) // Customize slot behavior without changing backing item handler

```

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

### Widget Positioning and Sizing in ModularUI

Source: https://gtnh.miraheze.org/wiki/ModularUI

Demonstrates methods for positioning and sizing widgets relative to their parent. Use `.center()` for centering, `.bottom(margin).right(margin)` for corner placement, and `.leftRelAnchor(offset, size)` for tangent alignment.

```java
.center() // This places the widget at the center of the parent widget.

.bottom(2).right(2) // This places the widget at the bottom-right corner of the parent widget with 2px of margin, with size of the self considered.

.leftRelAnchor(0f, 1f) // This places the widget tangent at the left side of the parent widget, with size of the self considered.

```

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

### Popup Panel Implementation

Source: https://gtnh.miraheze.org/wiki/ModularUI

Open a popup panel using syncManager.panel and open() method on the IPanelHandler. This is typically triggered by a button press.

```java
IPanelHandler popupPanel = syncManager.panel("popup_panel", (syncManager, syncHandler) -> new ModularPanel(), true);
rootPanel.child(new ButtonWidget<>()
    .onMousePressed(mouseButton -> popupPanel.open()));
```

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

### Item Slot Initialization with IItemHandler

Source: https://gtnh.miraheze.org/wiki/ModularUI

Shows different ways to initialize an `IItemHandler` for use with `ItemSlot` widgets. Options include `ItemStackHandler` for new inventories, `ItemStackHandler` with an existing array, and `InvWrapper` for existing `IInventory` implementations.

```java
private final IItemHandler inventoryHandler = new ItemStackHandler(size); // This is recommended for newly created inventory. Make sure to implement save/load to persist data.

private final IItemHandler inventoryHandler = new ItemStackHandler(itemArray); // If you're already storing items with array or list.

private final IItemHandler inventoryHandler = new InvWrapper(this); // If you're already storing items with bare ItemStack and TileEntity implements IInventory.

```

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

### Opening MetaTileEntity GUI on Right Click

Source: https://gtnh.miraheze.org/wiki/ModularUI

Standard implementation for opening a GUI when a player right-clicks a MetaTileEntity. This method should be overridden in your TileEntity class.

```java
@Override
public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
    openGui(aPlayer);
    return true;
}

```

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

### Adding Widgets to a Panel in ModularUI

Source: https://gtnh.miraheze.org/wiki/ModularUI

Demonstrates how to add child widgets like FluidSlot and text labels to a panel using the builder pattern. Ensure FluidSlot is imported if used.

```java
panel
    .child(new FluidSlot()
        .syncHandler(new FluidTank(16000)))
    .child(IKey.lang("mymod.awesome_text")
        .asWidget())
```

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

### Opening Synced Item GUI on Item Right Click

Source: https://gtnh.miraheze.org/wiki/ModularUI

Code to open a synced GUI for an Item when a player right-clicks it. This should be placed in your Item class.

```java
@Override
public ItemStack onItemRightClick(ItemStack itemStackIn, World worldIn, EntityPlayer player) {
    if (!worldIn.isRemote) {
        GuiFactories.item().open(player);
    }
    return super.onItemRightClick(itemStackIn, worldIn, player);
}

```

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

### Opening Synced TileEntity GUI on Block Activation

Source: https://gtnh.miraheze.org/wiki/ModularUI

Code to open a synced GUI for a TileEntity when the block is activated by a player. This should be placed in your Block class.

```java
public class MyBlock extends Block implements ITileEntityProvider {

    @Override
    public boolean onBlockActivated(World worldIn, int x, int y, int z, EntityPlayer playerIn, int side, float hitX, float hitY, float hitZ) {
        if (!worldIn.isRemote) {
            GuiFactories.tileEntity().open(playerIn, x, y, z);
        }
        return true;
    }
}

```

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

### Fluid Slot Implementation

Source: https://gtnh.miraheze.org/wiki/ModularUI

Implement IFluidTank for fluid slot widgets. Use FluidTank for new inventories and FluidStackTank if already storing FluidStacks. Customize tank behavior with FluidSlotSyncHandler.

```java
private final IFluidTank fluidTank = new FluidTank(capacity); // This is recommended for newly created inventory. Make sure to implement save/load to persist data.
```

```java
private final IFluidTank fluidTank = new FluidStackTank(() -> this.fluidStack, fluidStack -> this.fluidStack = fluidStack); // If you're already storing fluids with bare FluidStack.
```

```java
new FluidSlot().syncHandler(fluidTank) // Simple slot
```

```java
new FluidSlot().syncHandler(
   new FluidSlotSyncHandler(fluidTank)
       .canFillSlot(false)) // Customize tank behavior without changing backing fluid tank
```

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

### Layouting Grouped Widgets in a Row with ModularUI

Source: https://gtnh.miraheze.org/wiki/ModularUI

Shows how to arrange multiple widgets in a row using `Flow.row()`. The `.coverChildren()` method ensures the container fits its children, and `.child()` adds individual widgets.

```java
Flow.row()
    .coverChildren()
    .child(new ToggleButton())
    .child(new ToggleButton())
    .child(new ToggleButton())

```

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

### Text Widget Creation

Source: https://gtnh.miraheze.org/wiki/ModularUI

Create text widgets using IKey. Supports plain, translatable, and dynamic text. Use .asWidget() to convert to a widget.

```java
IKey.str("Hello").asWidget() // Text as a widget
```

```java
IKey.lang("mymod.fancy_text", argument).asWidget() // Translatable text as a widget
```

```java
IKey.dynamic(() -> "Current time: " + System.currentTimeMillis()).asWidget() // Dynamic text as a widget
```

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

### Texture and Drawable Usage

Source: https://gtnh.miraheze.org/wiki/ModularUI

Create and use textures, item icons, and rectangles as drawables. Textures can be built with a location and adaptable borders. Drawables can be used as backgrounds, overlays, or converted to widgets.

```java
UITexture myTexture = UITexture.builder()
    .location("mymod", "gui/my_texture")
    .adaptable(2) // Lets it automatically scale while keeping 2px of border unchanged
    .build(); // Registers texture. Don't call more than once for the same texture
```

```java
myTexture.asWidget() // Texture as a widget
```

```java
otherWidget.background(myTexture) // Use texture as a background of other widget
```

```java
otherWidget.overlay(IKey.str("Hello")) // Text is also IDrawable
```

```java
otherWidget.overlay(new ItemDrawable(myItem).asIcon().alignment(Alignment.Center)) // Display item icon as fixed size of overlay on top of other widget
```

```java
anotherWidget.background(
    new Rectangle()
        .setColor(Color.argb(255, 0, 0, 255))
);
```

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

### Synchronization with Sync Values

Source: https://gtnh.miraheze.org/wiki/ModularUI

Implement synchronization for GUI elements using Sync Values. IntSyncValue can be used with TextFieldWidget. InteractionSyncHandler is used for buttons.

```java
new TextFieldWidget()
    .value(new IntSyncValue(() -> this.threshold, val -> this.threshold = val)) // IntSyncValue implements IStringValue and thus can be used for TextFieldWidget
```

```java
new ButtonWidget<>()
    .syncHandler(new InteractionSyncHandler()
        .setOnMousePressed(mouseData -> {})) // Gets called on both the client and the server when button is clicked
```

```java
syncManager.syncValue("my_sync_value", new DoubleSyncValue(() -> this.val, val -> this.val = val)) // Sync handler can be registered separately
```
Tokens:
Raw