All Classes and Interfaces
Class
Description
Base of MenuKit's own elements: built once by a builder, immutable after.
The builder every MenuKit element's builder extends: the shared vocabulary,
in one place, with the same names everywhere.
Builds a modal dialog with one acknowledge button.
Builder for an AlertDialog Panel.
A rectangle a library names and supplies per screen, for panels to be placed around
with an
AnchorPanelAdapter: a slot group's box (SlotKit), the pause menu's
button column, the title screen's buttons.The screen a container's children are attached to, so a child added after build
attaches the way a child present at the screen's init did (7.3.0).
An interactive button within a
Panel: a raised background with a
centered label, an icon, or a consumer sprite as its whole face.The look this frame, handed to the render hooks.
A boolean setting as a small square with a check mark and a label beside it:
the settings-screen convention, and a lens onto the consumer's boolean.
The one way a list of elements is rendered and receives input.
A mouse click as seen by a
PanelElement: which button, plus the
modifier keys held at the moment the click was dispatched.A color setting: a swatch showing the color, and a lens onto it.
Builds a
ColorField.Lays elements out top to bottom, the vertical counterpart of
Row: it
positions each child with even spacing and a horizontal alignment, and returns a
flat list of positioned PanelElements.Builds one column.
Builds a modal confirm/cancel dialog.
Builder for a ConfirmDialog Panel.
The container region (7.4.0): on a container screen, the player's inventory never
scrolls, and everything above it is one column that scrolls together.
Builds one section of the container region.
Builds one kind of section made per live key.
Where a section's items are: the container it shows.
Tabs on the container screen's panels (7.4.0): a row of tabs, like the creative inventory's,
on an edge of the
container region's container list or inventory
panel.Builds one tab.
The panel edge a tab's row stands on.
Builds a list of groups (
ContainerTabs.groups(String, ModeScope, Supplier, Function)).What a list of groups' sub-tab is (
ContainerTabs.Groups.tab): its group, its key, and the builder to set up.What a tab's icon draws: the mod's own drawing, every frame, in the icon box at
(x, y), width by height.Builds a keyed list of tabs (
ContainerTabs.keyed(String, ModeScope, Supplier)).One mod's part of a shared panel (
SharedPanels, 7.4.0): its elements, its order
in the panel, the mode it shows in and its own visibleWhen, plus the panel's own
declaration (where it goes per mode, its style, its axis and gap, whether it is fixed,
how many fit in a column per mode).Builds a
Contribution.Declarations freeze; state does not.
A line between sections of a panel: a solid fill, no texture, no input.
A single-selection dropdown: a trigger showing the current choice, and a
popover list to pick another from.
A multi-selection dropdown: a trigger summarizing the chosen set, and a
popover list where each row toggles its item.
An easing curve (7.4.0): eased progress for a linear progress
t, both from 0 to
1.Builds a modal dialog that edits a copy of something and writes it back only on Save
(7.3.0): a title, your controls, Cancel and Save.
Builder for an EditDialog Panel.
The colors and spacings MenuKit's elements share.
An element whose position a layout helper (
Row, Column)
computes: its size now, the element itself when ElementSpec.at(int, int) is called with the
computed position.A run of elements laid out left to right at the panel's runtime width,
wrapping onto new rows when it runs out of room: the runtime row.
Focus for widgets MenuKit places on a screen, and the "is this point covered by
MenuKit" checks.
The cycle strip: a small hotbar drawn just right of the vanilla one, showing a ring
of stacks that cycles through the held hotbar slot, with a spring slide each time
the ring turns (since 7.1.0).
Which way a ring reads on screen.
Which way a ring turned.
A slide's start, from
HudCycleStrip.begin().What a mod registers: the ring it would draw for a hotbar slot, if any.
One ring, as a source sees it now.
A HUD element that draws a sprite from the GUI atlas at a given size, using
vanilla's
blitSprite.A timed HUD popup that slides in, stays for a while, then slides back out past the
screen edge it came from, as vanilla's toasts do.
Direction the notification slides in from.
Builds HUD panels: panels drawn on the game's heads-up display.
Configures a progress bar element.
Configures an item display element.
Configures a HUD slot element.
Configures a text element.
A HUD element that draws an item in a hotbar slot.
A picture at a fixed size: the "show a picture" primitive.
A block of text on a raised background: an explanation or a notice inside a
panel.
Input-time context passed to every
PanelElement input method, the input
twin of RenderContext: where the element's containing content
origin is on screen, where the mouse is, and whether the element's
surroundings are disabled.A region on a reference rectangle: one of nine spots, the four corners,
the four edge midpoints, and the center, inset from the edge.
How an item draws at a point in an animation (7.4.0): given the item, its 16 px box and
the animation's progress
t, from 0 to 1, it draws the item.An animation at one point:
animation drawn t of the way through.How big an item draws, about its box's center (1 is as it is), and how far it moves, in GUI pixels.
The
ItemAnimation.Pose at each point of an animation.An item drawn at a fixed size, with its count and durability bar, and
optionally a colored outline.
An item rule: a stack and how another stack has to match it.
How a stack is compared with a rule's.
A setting whose value is an item, or a list of items: slots showing the items the
setting is about, and a lens onto them.
Something the dialog draws,
x, y, w, h in its content's coordinates, and
the box px, py, pw, ph it must stay inside.Builds an
ItemPicker.A list whose rows follow the consumer's data while the screen is open (7.3.0): one
row element per item, added, removed and reordered as the items change, each row
kept for as long as its item's key is in the list.
Builds a
ListView.The sort in use (7.3.0): which
ListView.Builder.sort(Component, Comparator) option, in the order they were
given, and whether it runs backwards.A button that opens a menu of actions (7.3.0): a row's "more" button, with
Duplicate and Delete in it.
One row of the menu: its label, what it does, and whether it destroys something.
PopoverControl.Builder.size(int, int) and at least one action are required; MenuButton.Builder.label(Component) is the trigger's text.Mod entry point for MenuKit and the process-wide facade for HUD panels,
notifications, and the recipe-book query.
Base class for standalone screens built with MenuKit: full-screen, client-local,
interactive UIs not tied to a container menu.
The one place a hover tooltip is queued: every element tooltip and the panel
tooltip go through
MKTooltip.queue(GuiGraphicsExtractor, Component, int, int) instead of calling vanilla's
setTooltipForNextFrame directly.What a tooltip shows, as
MKTooltip.hideWhen(Predicate) sees it.Listener for
MKTooltip.onWheel(MKTooltip.Wheel).Which game mode a declaration is for (7.4.0):
ModeScope.SURVIVAL, ModeScope.CREATIVE or
ModeScope.BOTH.A region outside a reference rectangle: pick a side, pick which end to
align to, and stack away from that end.
The panel host of a library's own screen: a screen class a library ships (a custom
container screen, say) that lays out its own panels the way
MKScreen does,
with the main panel as the frame, and joins MenuKit's claims, modals and draw order
with them.Drawn after a panel's background and before its elements (slot frames, say).
One frame's placements, bottom to top, and the main panel's rectangle (the
screen's
leftPos, topPos, imageWidth, imageHeight), or null when
the screen has no shown main panel.Where a panel landed this frame: its outer rectangle, padding included, in screen
coordinates.
Whether
panel presents the live slot under the point (its claim then routes the point to that slot).Where the screen's title sits, which decides the room reserved for it.
The basic unit of composition.
Builds a
Panel.A visual or interactive element within a
Panel.Where a panel sits: the one placement declaration every host reads.
How a panel is positioned.
Visual style for a panel's background.
Where a panel goes in one mode (7.4.0): what it is placed against, and its position there.
A bar filled to a fraction, read every frame: health, progress, a timer.
Which way the fill grows.
One choice of a single-selection set: a round button with a dot when its value
is the
RadioGroup's selection, and a label beside it.The lens a set of
Radio buttons shares: which value is selected, read
from the consumer every frame and written back when the player picks another.The rectangle a panel is placed against, a reference.
The region layout constants, stacking gaps and edge insets, in one place.
Render-time context passed to every
PanelElement.render(RenderContext).Lays elements out left to right: it positions each child with even spacing and
a vertical alignment, and returns a flat list of positioned
PanelElements.Builds one row.
A vanilla container screen made taller or shorter at a seam (7.4.0): its frame gains
(or loses)
by rows at row seam of its own layout, so screens of nearly one
size can be made exactly one, and a tab row standing on their frames doesn't move as one
opens in place of another.The look of the screen an element is on, which decides how it draws (6.1.0;
renamed in 7.3.0).
Which screens a registered slot (or any feature meant for every inventory screen)
applies to.
Screen-space top-left coordinates of a panel: what a
pixel(...)
placement supplies each frame, and what a panel host resolves every other
placement to (RegionMath.resolveMenu / resolveInside).Puts a
Panel on vanilla container screens.A clipped viewport over pre-positioned elements, scrolled vertically: the
single primitive for "show content larger than its bounds".
A collapsible section: a header row that opens and closes the elements under it.
Panels several mods share (7.4.0).
A slider: vanilla's
AbstractSliderButton, laid out and
lensed by MenuKit.Part of the created-slot contract, beside
SlotScreenHook: a slot library
tells MenuKit when an element places a slot, so the slot is clipped to what its
panel shows of it (7.2.0).What a mod draws on a container screen's slots (7.5.0), under the item or over it, so no
mod mixes into the slot's draw.
What one mod draws on a slot, and the tooltip it answers there.
What
SlotScreenHook.resolveHover(AbstractContainerScreen, double, double) answers for a screen point.What a slot's item draws as on a container screen (7.4.0): a mod says, per slot and per
frame, which
ItemAnimation the item draws with and how far through it is, and the
slot draws that in place of the item.What one mod draws a slot's item as.
The recessed 18×18 slot frame for registered slots that live outside a
vanilla container texture, the one piece of a created slot's presentation
that is panel chrome rather than the slot itself.
The plug a slot library fills so its panel-hosted slots (created slots, drawn inside
MenuKit panels) take hover and clicks through MenuKit's own container-screen
dispatch, without MenuKit naming a slot type.
A grid of slots that scrolls inside its panel when it doesn't fit (7.4.0): as tall as its
live rows while there is room, shorter by whole rows when there isn't, never under its
minimum rows, scrolling past what shows.
Builds a
SlotScroll.Makes cell
index: an element at (x, y) in the grid, shown while shown
holds (on top of whatever hides it on its own).A tab strip and the area below it that shows the selected tab's body.
Where tabs sit within a row; in
Tabs.Mode.SIDEBAR, where the label sits within its tab.How the strip lays out when the tabs don't fit one row.
One tab: an id, a label, a body, and whether it shows.
A tab under construction.
Text drawing shared by MenuKit's elements: one line in a bounded width, and
wrapped text.
A single-line text field: vanilla's
EditBox, laid out and
lensed by MenuKit.A line of text in a
Panel, fixed or read every frame.What a piece of text is for, so the kind of screen decides its color (6.1.0).
A two-state on/off control: MenuKit's general boolean primitive, a lens onto
the consumer's boolean and only a lens.
A timed change between two states, kept per key (7.4.0): one duration and one
Easing, and for each key the mod names (a slot, a container, a tab) where that key
is on its way.Puts a
Panel on vanilla non-container screens: Options,
Controls, KeyBinds, world select, the title screen, and any other
Screen that is not a container screen.Hosts a vanilla-style widget (anything that is a
GuiEventListener and a
Renderable) inside a panel, at the element's own rectangle.Builds a
WidgetHost.Places a widget that is not a vanilla
LayoutElement, or places one in
the consumer's own way: called every frame and before every input event with
the element's rectangle in screen coordinates.Marks a class as a thin wrapper around
ScreenPanelAdapter,
VanillaScreenPanelAdapter or AnchorPanelAdapter, so PanelHost.captureCallerModId() walks past it to credit
the mod that actually called the wrapper, not the library that wrote it.