All Classes and Interfaces
Class
Description
One value that names any addressable thing (a vanilla slot, a created slot, a
panel element or a panel itself), so the engine can resolve every behavior by
address without asking what kind it is.
Names one behavior the window can resolve: gating, visibility, a panel's
opacity, a reaction and so on.
The library's built-in
BehaviorKeys, one constant per behavior.One panel on every group of a category that shows on the open menu, vanilla or created,
on-demand instances included.
Where one of a category's panels goes, and which group it is on.
The client half of a
CustomMenu: its screen class, how each of its
panels looks, and the request to open it.What the client can ask about a slot group while a screen is open.
A slot that is a vanilla
Slot to everything outside it.A group of slots: their
Storage, shift-click priority, right-click handler
and layout.Adds real, server-synced, persistent slots to a vanilla menu.
Configures one group of slots.
What
register() created: the MenuPanel and CreatedSlotGroup,
plus the slot-index range appended to the menu, for consumers that walk the
slots directly.Implemented by consumers to extend storage attachments.
A custom container menu: its created slots, its panels as the server knows them,
and whether each is shown.
Client-side partner to
CustomContainerMenu: a standalone screen whose panels
hold slot groups.A custom drag behavior for created slots.
Action triggered by a key press while this screen is open.
Listener for events inside this screen.
A complete custom menu from one
define(...).register() chain.Configures the menu.
Builds the menu's
CustomContainerMenu.A behavior declaration at one specificity level (per slot, per group and so on):
Decl.Set: this level declares a value, and the cascade stops here and
uses it, an explicit off such as Set(TriBool.FALSE) included.
Decl.Inherit: this level defers, and the cascade falls through to the
next level down.Explicit deferral; the cascade falls through to the next level.
An explicit declared value; the cascade stops here.
What happens to a player-scoped slot's content on death, set per attachment.
In-memory storage that is never saved.
The context a
SlotGate decision runs in: who is acting, and on which slot.A bulk-addressing group: a stable id plus a membership predicate over
Addresses.A container that shows one item's contents, such as a shulker box opened from the
player's inventory, and says where that item is.
Where one item is, as both sides can name it: a top-level slot in the inventory, the
ender chest, a supplied container (
ItemRef.Source.CONTAINER, such as an open
chest) or a carried attachment (ItemRef.Source.CARRIED, named by its id), then
the index inside each container on the way down.One item found by
ItemSources, wherever it sits: a top-level slot, or inside a
shulker box or bundle, any number of containers deep.Where a top-level slot is: the player's inventory, their ender chest, a
Container the caller supplies (an open chest or barrel), which the
Container overloads of ItemSources walk and resolve, or a player
attachment declared carried() (ItemPath.attachment() says which;
since 2.2.0, met only under ItemScope.carried).Where
ItemSources looks: the player's 36 main slots always, and optionally their
carried attachments, the ender chest, the inside of shulker boxes and the inside of
bundles, nested up to a depth limit.Every item a player has, including the ones inside shulker boxes and bundles, to any
depth: one walk, with every write going back up the chain of containers to the
top-level slot.
One item
ItemSources.find(Player, ItemScope, Predicate) saw: where it is, and a copy of it (path().depth() is how deep).A value that rides on an item: "open", "favorite", a mark.
Whether the state is saved with the item.
Called by
ItemSources.walk(ServerPlayer, ItemScope, ItemVisitor) for each item, nearest first.A
Storage that knows its own persistent identity.Factories for
KeyedStorage, a Storage that declares its own
PersistentContainerKey so per-slot state persists for registered slots.What kind of addressable thing an
Address names.One item at an
ItemPath, held for as long as a menu stays open on it: a shulker
box in a chest, or a bundle in a shulker in a chest.Lets a consumer add extra items to the XP repair pool, beyond the slots opted in
through
BehaviorKeys.MENDING.One mendable item plus how to persist its repair.
Supplies a player's extra mend candidates when an XP orb is collected.
A panel as a menu knows it on both sides: its id and whether its slots are shown.
Builds the client
CustomContainerScreen for a registered CustomMenu.Switching a player between menus while one menu, the one they opened in the world,
waits open behind the others.
Why the set-aside menu closed.
Hears the set-aside menu close on its own.
A slot group a menu gets on demand: declared once at init, like a
ParityGroup,
but on no menu until the server adds an instance of it to the menu the player has
open, and gone again when the server removes it or the menu closes.One instance of a kind, on one menu.
Lets a test mod check the click-tag hand-off and the in-world actions: which
operation a sent click carried, and whether an action would be refused.
A click tag as the probe sees it: the operation pair it carries.
A slot group with container parity: real, synced slots on every screen that shows
the player inventory (survival, creative, and every chest, furnace or modded
container), registered in one call with no mixin.
Persistent identity for a
Container, the owner a slot's state
attaches to, in a form that survives session boundaries.Block-entity-backed container (chest, shulker box, furnace, hopper, etc.).
The player's ender chest (distinct from their main inventory).
Entity-backed container (donkey, llama, mule, minecart-with-chest, etc.).
Modded container type.
The player's main inventory, hotbar, armor, and offhand slots.
Marks a
Storage as the player inventory side of a menu, as opposed to the
container side.What the other side runs, as the handshake found it when the player joined.
Where a shift-click goes, on any menu, when a mod knows better than the menu.
One destination in a route.
Answers where a shift-click from
source goes, or null for no opinion.Why a reaction fired.
What a
ReactiveHook receives when a slot's contents change.A consumer's reaction to a slot's synced contents changing on the client, the
value type of the
ON_INSERT_OBSERVED/ON_TAKE_OBSERVED behavior keys.One slot group as it exists on an open menu: what it is called, what kind of
thing it is, and which slots it currently holds.
A plain left double-click on a slot, taken for a mod's own action (open the item, say).
A double-click taken: the slot (the real one), its index on the menu the server has open, and the stack.
A registration's pending pairs, on the client thread.
Whether a first click on
slot's stack, with the cursor empty, may start a pair.A registered slot shown as a
PanelElement.Builds a
SlotElement.Lays out a panel's registered slots to fit its width, the way text and elements
size to fit.
Builds a
SlotFlowElement over slot elements, in flow order.What a slot accepts and releases, and how much of an item it holds: the value of
BehaviorKeys.GATING, the slot author's rule.The registry of
SlotGroupResolvers, one primary per menu class.One slot group as one element, found by its id on whatever menu is open, and shown
in rows.
Builds a
SlotGroupElement.Names one slot group, one coherent run of slots sitting in one place on
screen.
The one group a resolver contributes for
category on a menu: vanilla's
resolvers, and a mod's own resolver for its own menu, name a group this way.A group created through SlotKit, named by its declaration.
Anchors a
Panel to slot groups and slots on container screens: a toolbar
above the player inventory, a readout beside the hotbar, a slot above the offhand.Maps one menu class's instances to slot groups by
SlotGroupCategory,
as slot indices (positions in menu.slots).Every slot group anyone has declared, with no menu open: the menu-free half of
the slot group registry.
One row of the player-facing list.
A player-facing name for several slot groups that are one thing to the player.
A typed handle on a slot, vanilla or created: the slot verbs, plus the generic
WindowHandle.set(BehaviorKey, Decl).The slot layout of a
CustomContainerMenu: which panels it has, which slot
groups each holds, and how shift-click pairs them.One panel's slot groups and its server-side flags.
One declared panel, as built: its id, whether it starts shown, whether a player
may toggle it, and its slot groups in order.
How a slot draws an item while something holds for it: an animation, another model, or a
mark under or over it.
Whether a look applies to
slot's stack this frame.Display names for slots, on the client: labels like "Hotbar 3", "Chestplate" or
"Offhand".
The slot operations vocabulary: the open set of things that can be done
to a slot, what each slot lets through, and the one question every
operation asks before it acts.
Which slot groups an operation can act on.
A
SlotOperations.Veto that is handed the slot's group: SlotGroups.of(SlotRef) of the
slot, resolved once per question and shared by every group veto, or
null when the slot is in no known group.A veto on putting a particular item into a slot, handed the stack about to
land (
incoming, never empty; read it, don't change it) along with the
slot's group as a SlotOperations.GroupVeto gets it.What an operation does to the slot it acts on.
A rule that refuses an operation on a slot, laid over the cascade by a mod
that is not the slot's author.
MenuKit
Placements against slots, for a panel's in(ModeScope, Placement)
(since 2.1.0).The slot an operation is about to act on, as much
of it as the seam can supply.
A vanilla slot's on-screen item box in absolute screen-space pixels, what
VanillaSlotResolver.resolve(AbstractContainerScreen, int) returns.A side-neutral description of one group of registered slots that a
ParityGroup adds to every container the player opens.Entry point for persistent per-slot state.
A typed per-slot state channel, the handle consumers use to read and write slot
state.
Who may write this channel from a client.
Channel visibility.
Where items live: get, set, size and markDirty.
Where a slot group's contents are saved, by owner type.
A
StorageAttachment with death handling, returned only by the
player-anchored factories (StorageAttachment.playerAttached(String, String, int) and
StorageAttachment.customPlayerAttached(CustomAttachmentSpec)).Adapts a
Storage to vanilla's Container interface.Which authority tier a
BehaviorKey belongs to.The value a
Decl.Set carries for a boolean BehaviorKey, so
"explicitly off" is a declared value, distinct from "unset" or "inherit".Finds where a player-inventory slot is on whatever screen is open.
Storage backed by a read function and a write function, so a consumer can
bring any external data source into the
Storage interface.The entry point to the window: where a consumer gets a typed handle to set or read
behavior on anything addressable.
The window's resolution engine: one store, one cascade, one method,
WindowEngine.resolve(Address, BehaviorKey).The base of the window's typed handles: an immutable value that addresses one
thing by its
Address, never by a live reference.Which slot the cursor is over (
WindowSignals.hovered) and which slot was last clicked
(WindowSignals.selected), as Addresses, observed on the client.The window's view of one open menu, which mints typed
WindowHandles.