v1.1.0 – GUI sprites, picture sizes and one pack for the client

Everything here is new; menus, configs and plugins made for 1.0 keep working unchanged.

• GUI sprites as icons: icon: "gui:hud/heart/full", gui:mob_effect/speed,
  gui:statistics/item_crafted, gui:icon/checkmark and about 100 more (hearts, food, armor, air,
  every status effect, statistics, small icons) wherever an item id goes, in YAML and the API. Drawn
  from the client's own textures at their own size in the middle of the icon place; sprites in the
  plain dialog; the menu designer shows them after loading a client jar again.
• Docs: <sprite:...> and <head:...> work in tooltips, titles and messages.
• Pictures in other sizes: width / height (the other side follows the aspect ratio) or
  scale on an image element. Glyphwork resizes the picture when it builds the pack and adds it
  as an extra picture; YAML menus add their sizes by themselves, plugins announce theirs with
  Glyphwork.get().imageSize("logo", 32, 0) / imageScale(...) and draw them with
  Image.size(w, h) / .scale(s) (experimental). The menu designer shows the size. Without sizes
  the pack stays exactly as before.
• One pack for the client: pack.include-source-pack: true puts the server's own resource pack
  (icons.source-pack) into the Glyphwork pack; its pack.mcmeta and pack.png are kept, Glyphwork's
  own files win. Empty resource-pack= in server.properties then. Helps with client mods that keep
  only the last server pack, and saves merging by hand as with hosting: provided.
• Menu designer: Glyphwork version. Pick the version your server runs: newer settings are hidden
  or marked, and the check list names everything that needs a newer version. The docs mark what
  came after 1.0 with since 1.1.

v1.0.0 – stable API, tabs, scroll panes, feeds and Bedrock

1.0: the API, the menu format and config.yml are now stable (see "Compatibility" in the
README). Before that promise some names were cleaned up; plugins built against 0.9 need these
changes, YAML menus and configs keep working (old keys are still read, with a hint in the log).

• Renamed (API): ListView.onSelect → onClick; Choice.onSelect, Checkbox.onToggle and
  Tabs.onSelect → onChange; Button.textColor and Checkbox.textColor → color;
  Grid.label / labelColor → text / color; Bar.color → fill; Tabs.tint →
  inactiveTint; DisplayMode.SIMPLE → PLAIN (stored choices carry over).

• Changed (API): visible, enabled and checked take a Predicate<View>; sliders and form
  numbers use double (Form.Values.number returns a double); form fields are the final classes
  Form.TextField, CheckboxField, SliderField, ChoiceField; Label.DARK is gone, a label
  without color (null, the default) uses the skin's text color; Click.openUrl accepts only
  http/https; Scene.Builder.build() rejects two lists, grids, tabs or scroll panes with the same id.

• New (API): Click.page(listId, n), tab(tabsId, tabId) and scroll(scrollId, offset);
  @NullMarked package; @ApiStatus.Internal on renderer getters, @ApiStatus.Experimental on
  tabs, scroll panes, big heads, text styles, item tooltips, the own plain view and redrawAfter.

• Renamed (YAML): button text-color → color, bar color → fill, tabs tint →
  inactive-tint. The input: action now splits at | with spaces, like require:.

• Cooldowns need an id (unique in the menu) or a cooldown-key: before, an element without
  them was keyed by its position, so adding an element moved cooldowns to other buttons. Stored is
  when a key was last used; each element waits its own time from then (a key used with different
  times is mentioned in the log). Running cooldowns of 0.9 start anew.

• Values from outside are text: feed and web entries, %item_...% and %input% can no longer
  add MiniMessage tags (colors, click events) or be filled in as another placeholder; |raw keeps
  the tags for a source you trust. Placeholders of a text are filled in one pass.

• Checks when loading menus: an unknown filter (%x|dat%) or an invalid alias is an error;
  frames the skin does not have, missing pictures, open: / give-item: targets without a menu
  and a command used by two menus are hints, in the log and after /glyphwork reload.

• config.yml cleaned up (config-version: 1): max-height → pack.min-height,
  fallback → plain-dialog, icons / icon-source-pack → icons.enabled /
  icons.source-pack, feeds.date-format → date-format; the pack prompt text lives only in the
  language files (pack.prompt). Unknown or misspelled keys are reported. "Simple" is called
  "plain" everywhere (/glyphwork display plain, /glyphwork test plain; the old words still work).
  Edited language files: cmd.simple → cmd.plain, display.simple / display.info-simple →
  display.plain / display.info-plain, fallback.* → plain.* (the log names old keys).

• Lists, grids, tabs and scroll panes without an id get one that is unique in the whole menu;
  before, the same element in several tabs shared its page.

• Own plain view: plain: in a menu (API Scene.Builder.plain(...)) defines the dialog for
  players without the pack and Bedrock players by hand, with columns: 1|2; same variables as the
  pixel GUI.

• Grayed-out buttons in the plain dialog stay visible in gray; a click sends their tooltip
  (e.g. the remaining cooldown) instead of doing nothing visible.

• Pack from your server or proxy: pack.hosting: provided sends no pack; merge
  plugins/Glyphwork/pack/glyphwork.zip into the pack your server or proxy (Velocity) sends.
  pack.provided-loaded: always (a required pack) or server-pack (the server.properties answer)
  tells Glyphwork who has it.

• Designer: a dashed area marks the room for the page buttons below lists and grids, with a hint
  when another element is in the way.

• Plain dialog with pictures: players without the pack see item icons in front of button, list
  and grid texts (sprite components the client draws from its own textures), and long button texts
  switch the buttons to one wide column instead of cutting them (measured over all tabs, so the
  layout stays when switching). Tabs become a clickable line above the buttons of the active tab
  (on Bedrock: tab buttons and a divider).

• Bedrock players (Geyser, optionally Floodgate; found without a hard dependency) always get the
  plain dialog, which Geyser turns into a Bedrock form, and no Java pack request; join menus open
  at once for them. Their buttons show the first tooltip line below the text (forms have no
  tooltips), and their forms close after a click until the server sends the next one, so a
  quick second click can no longer hit a button of the previous screen and closing a menu closes
  it (Geyser's waiting form could not be removed from the server). Timed redraws (cooldowns,
  refresh, loading feeds) send a new form only when something visible changed, instead of closing
  and reopening it every second (and at most one every 5 s).

• Text formatting: labels, buttons and list entries understand MiniMessage for parts of their
  text (<b>, <i>, <u>, <st>, colors); labels also have bold, italic, underline and
  strikethrough for the whole text. Bold counts 1 px per character when cutting, centering and
  wrapping; underline and strikethrough are drawn as pixel-exact lines of their own. API:
  markup(true) on Label, Button and ListView, plus the four switches on Label. |discord now turns
  Discord markdown into this formatting; |discord-plain keeps the old plain text.

• Fix: a line break inside a value (chat messages, web data, PlaceholderAPI, %input%) no
  longer breaks the layout of the whole menu; single-line text shows it as a space.

• Clearer web errors: refused requests (401/403) say what to check, e.g. that Discord needs
  Authorization: "Bot <token>", without showing the token.

• Placeholder filters: |date formats dates (ISO, RFC, Unix time) and |discord makes Discord
  markup readable (mentions, emojis, timestamps, markdown), for %item_...%, %menu_...% and
  %web_...%. docs/menus.md shows a Discord channel as a web source.

• JSON web sources: web: in config.yml (url, every, optional headers) and
  %web_<name>_<path>% in any text (%web_status_players.online%, indexes and length for arrays);
  items-from: "web:<name>.<path>" turns a JSON array into list entries (%item_<key>%, nested keys
  with dots). Loaded in the background with the same limits as feeds.

• Feeds: items-from: "rss:https://..." fills lists and grids from an RSS or Atom feed (title,
  text, date, link, author), loaded in the background, cached (feeds.cache, date-format
  in config.yml), safe against external entities and limited to 1 MB / 50 entries. The menu
  draws itself again when a feed arrives for the first time.

• Detail views: %item_text% of a feed is the whole text with paragraphs (up to 4000
  characters), %item_summary% the short one-line version; selected-if on list and grid entries
  highlights e.g. the clicked one (API ListView/Grid.selectedIf); a scroll pane id with
  placeholders keeps one position per content. Together: list on the left, article on the right.

• Action url: shows a web address in a small native dialog with Open and Back
  (url: %item_link% for feed entries); API Click.openUrl.

• Scroll panes: type: scroll / Scroll.of(...) shows part of its elements in a window with a
  scroll bar (▲ / ▼ by step px, a click on the track jumps there) while the rest of the menu stays
  in place. Only what fits completely is drawn and clickable; any element works inside. The plain
  dialog lists all of them, the designer shows and scrolls the pane.

• Long menus: the pack height now follows the tallest YAML menu (rounded up to 32 px, at most
  2048 px), so frames are drawn in menus of any height and the dialog scrolls them natively, mouse
  wheel included. pack.min-height is only the minimum (for scenes of plugins); small servers keep the
  small pack.

• Tabs: type: tabs / Tabs.of(...) puts tabs on top of a panel; the active tab merges with
  the panel into one frame, the others sit slightly lower and darker behind it. Only the active
  tab's elements are drawn and clickable, a click on another tab switches. Elements inside a tab are
  placed relative to the panel and can be anything (templates, show-if and cooldowns included);
  var keeps the active tab in a menu variable. The designer draws and switches tabs too.

• Action add: counts: add: points 1, add: amount -1 min 1 max 64 (amounts and limits may
  be placeholders, decimals work) and redraws the menu like set:.

• Saved variables: persist: true (or a list of names) keeps menu variables in the player's
  data, so they survive logouts and restarts; set: name without a value removes the saved value.

• Cooldowns: cooldown: 1h (30s, 5m, 1d 12h …) on buttons, hitboxes, icons, panels,
  pictures and heads: each player can use the element once per period, kept in the player's data.
  A button on cooldown is grayed out with the remaining time as tooltip; cooldown-key shares one
  cooldown between elements; a failed require does not use it up. While a cooldown runs, the
  open menu redraws itself when the shown time changes and when it ends (API: View.redrawAfter).
  Texts: cooldown.tooltip / cooldown.wait in the language files, or per element
  cooldown-tooltip / cooldown-message with %cooldown%.

• Menus that open by themselves: open-on: { join: true } (or first) opens a menu when a
  player joins, once the G...

v0.9.0 – forms, menu controls and the menu designer

• Menu designer in the browser (https://flyingfinger1.github.io/Glyphwork/designer.html, next
  to the skin editor): place and resize elements with the mouse, edit their options, variables,
  forms and templates in side panels, try the menu out (actions, controls, forms work on preview
  variables) and download the .yml file. Load your own Minecraft client jar (read only in the
  browser) for real item icons and the real font; resource packs add their textures and items.
  Guide in docs/menu-designer.md.
• Forms: several native input fields at once (text, multi-line text, slider, checkbox,
  choice) in a dialog of their own with OK / Cancel; afterwards the menu is shown again. In YAML a
  menu lists them under forms: and opens one with the action form: name; every field belongs to
  a menu variable (starts with its value, OK writes it back), then the form's actions run. API:
  Click.form(Form, values -> ...); values are checked (length, range, step, known options).
  New example example-forms.yml; the example trader picks its amount with a slider.
• Slider, checkbox and choice in the menu: new elements drawn from the skin (slider,
  checkbox, choice in YAML with var:; Slider, Checkbox, Choice in the API). A click on a
  slider's track moves the knob there (hovering shows the value first), a checkbox toggles, a choice
  button steps back (left half) or forward (right half). The variable is set, the element's
  actions run and the menu redraws. The plain dialog offers them as buttons (one step down/up,
  toggle, next option). example-forms.yml shows them next to a form.
• Counts on icons: count: 64 (YAML, also for list and grid items, placeholders allowed) and
  Icon.count(...), Grid.count(...), ListView.count(...) write a stack size at the bottom right
  of the icon, white with a shadow like in the inventory; 1 and empty show nothing. The plain
  dialog writes it after the name ("Diamond ×64"). The example trader shows its pack sizes.
• Auto-refresh: refresh: 5 in a menu (or Scene.Builder.refresh(Duration)) redraws the open
  menu every few seconds, so placeholders and dynamic lists stay current. Clicks on the previous
  drawing still work; it stops when the player closes the menu (also with ESC), opens another one or
  an inventory. example-players.yml refreshes every 5 seconds and shows the players per world as
  counts.
• Text shadows like in vanilla: the text of buttons, lists, grid cells and the page arrows now
  has a drop shadow (before, all text was flat). Grayed-out buttons stay flat, and so do labels,
  like inventory titles; shadow: true (YAML) or Label.shadow(true) turns it on for a label.
  Arrows of a page button that cannot be used are gray now.
• English examples: the example menus exist in English (example*.yml) and German
  (beispiel*.yml); on first start the set of the server's language is exported (language, or
  fallback-language when it is auto, default English). The demo (/glyphwork test) speaks the
  player's language (keys demo.* in the language files), and the example plugin is in English
  (/trader, /haendler still works).
• Skins renamed: the built-in skins are now dark and parchment (were dunkel and
  pergament).
• List frames and the menu background are rounded up to whole tiles: rows of a list whose
  height is no multiple of 8 (2 rows of 18 px) stuck out of the frame, and content near the bottom
  of a menu with such a height sat on or past the edge. Other frames still round down.
• New placeholder %time%: the server clock (HH:MM:SS).
• Closing a menu with its exit button or ESC now ends the player's session right away (before, it
  stayed until the next menu).

Upgrading: the built-in skins dunkel/pergament are now dark/parchment; if your config says theme: dunkel, change it to theme: dark (the old exported folder keeps working until you delete it).

Downloads: Glyphwork-0.9.0.jar (plugin), glyphwork-api-0.9.0.jar (compile against it, do not shade), glyphwork-example-0.9.0.jar (example plugin, optional).

v0.8.0 – player heads

• Player heads as icons: head:<name or uuid> wherever an item id goes (YAML icon:, API
  Icon.head(...), grids, lists, buttons). The client draws heads as 8 x 8 px and only on its 9 px
  text grid; so that a head still sits in the middle of its button, row or cell, the element moves
  with it (up to 4 px) and the log names the y that avoids the move (table in docs/menus.md).
  Lists with heads want a row height of 9 or 18, grids a cell pitch of 18 or 27; lists of
  online-players default to 18 px rows. Online players send their skin along. Heads also appear in
  the plain dialog, in front of the label.
• Placeholders work in the icon of icon elements and buttons (icon: "head:%player%").
• Buttons whose height is no multiple of the tile size center their text and icon on the height
  that is actually drawn (a 20 px button is drawn 16 px high); before, the text sat too low.
• Lists that mix heads and item icons put both in one 16 px column, so all texts start at the same x.
• Dynamic lists of online-players have %item_head% (and %item_icon%) for the player's head;
  beispiel-spieler.yml uses it.

Downloads: Glyphwork-0.8.0.jar (plugin), glyphwork-api-0.8.0.jar (compile against it, do not shade), glyphwork-example-0.8.0.jar (example plugin, optional).

v0.7.0 – languages, menu variables and dynamic lists

• Languages: all messages, Glyphwork's own dialogs (display mode, plain view, text prompt) and
  command words in English and German. language: auto (default) uses each player's game language,
  everyone else gets fallback-language (en); or set a fixed language. Texts are MiniMessage files in
  plugins/Glyphwork/lang/ (exported on start): change single keys or add a language as
  lang/<code>.yml. Command words work in every language (/glyphwork display and
  /glyphwork darstellung); tab completion suggests the player's own.
• pack.prompt empty (new default) = the prompt from the language files. The old German default
  prompt in existing configs is treated the same way.
• /glyphwork pack from the console answers instead of doing nothing; /glyphwork status shows
  each player's language.
• Menu variables: variables: with defaults, the actions set: name value and toggle: name,
  and %menu_name% in every text, condition and action. The menu redraws itself after set/toggle.
  Tabs, search fields and switches without code. open: takes placeholders.
• Dynamic lists: items-from: online-players or worlds fills a list or grid each time it is
  drawn; item: describes the entries with %item%, %item_world%, %item_players% ...
  (filterable with show-if). Misspelled %item_...% are reported on load.
• Conditions accept an empty text as '' (%menu_filter% != '').
• New example beispiel-spieler.yml (tabs, player search, worlds); existing servers find it in
  src/main/resources/menus/.

Upgrading: nothing to do. The new config.yml keys language and fallback-language default to auto and en when missing; the language files are written to plugins/Glyphwork/lang/ on start. The old German pack.prompt is replaced by the prompt from the language files automatically.

Downloads: Glyphwork-0.7.0.jar (plugin), glyphwork-api-0.7.0.jar (compile against it, do not shade), glyphwork-example-0.7.0.jar (example plugin, optional).

v0.6.0 – conditions and templates for menus

• Conditions in YAML menus: show-if on every element and list/grid item, enabled-if and
  disabled-tooltip on buttons, and a require: action that stops the remaining actions when its
  condition does not hold. Conditions compare placeholders and values (== != > >= < <= contains !contains, numbers as numbers); a list means all must hold.
• Templates for YAML menus: reusable elements or groups in menus/_*.yml (for all menus) or
  under templates: (one menu), used with { use: name, x, y, key: value } and filled in at
  {key} / {key|default}. Settings of the use entry replace those of one-element templates.
• New example beispiel-warps.yml with _beispiel-vorlagen.yml (put into menus/ on first start; existing servers find them in
  src/main/resources/menus/).
• API: visible(Function<View, Boolean>) on every element.

Downloads: Glyphwork-0.6.0.jar (plugin), glyphwork-api-0.6.0.jar (compile against it, do not shade), glyphwork-example-0.6.0.jar (example plugin, optional).

v0.5.0 – example plugin and more skins

• Example plugin (example/): a trader (/haendler) built against glyphwork-api
  the way another plugin would use it: item icons in a grid, amount buttons and a text prompt, a buy
  button that is only active when the player can pay, and an options screen for the display mode.
  Releases attach it as glyphwork-example-<version>.jar.
• Two more built-in skins: dunkel (dark, light text) and pergament (parchment), next to
  vanilla. All built-in skins are exported to themes/ on start when their folder is missing.
• Text color per skin: "text": "#RRGGBB" in theme.json colors labels that use the default
  color (Label.DARK) and the page numbers, so dark skins stay readable. The skin editor has a text
  color field and a template choice (Vanilla, Dunkel, Pergament) for New.
• CI: GitHub Actions updated to their current versions.

Downloads: Glyphwork-0.5.0.jar (plugin), glyphwork-api-0.5.0.jar (compile against it, do not shade), glyphwork-example-0.5.0.jar (example plugin, optional).

v0.4.0 – icons from the server's resource pack

• Icons match the server's resource pack: icon-source-pack: auto (default) reads the pack
  from server.properties on start (download cached by hash; also a zip path or URL). Textures it
  replaces are measured, so icons line up; items it defines become icons ("myserver:ruby"), and
  vanilla items it re-models show the new texture. Icons are placed like in the inventory: the
  whole 16×16 texture at a fixed spot, so the art sits where the texture draws it.
• No broken boxes without the server pack: Glyphwork checks whether a player loaded the server
  pack and leaves out icons that need its textures for players who did not (grid cells show a
  short name instead).
• Sturdier fonts: text, vanilla icons and server-pack icons are separate fonts in the pack.
  The client throws away a whole font when one texture is missing, so a missing texture can no
  longer take text or vanilla icons with it.

Note for testing: client mods that take over server resource packs (e.g. "Server Resource Pack
Checker") can drop the server pack as soon as Glyphwork's pack arrives. Glyphwork cannot see that;
those players get boxes for server-pack icons, or can switch to "Ohne Icons".

Downloads: Glyphwork-0.4.0.jar (plugin), glyphwork-api-0.4.0.jar (compile against it, do not shade).

Glyphwork 0.3.0

• Item icons: Icon element, Grid.icon, Button.icon, ListView.icon, and icon: in YAML
  menus (element, button, list and grid items). The pack only references the item and block
  textures every client already has (no Minecraft image is shipped); 1595 items have an icon, items
  drawn by special renderers (heads, chests, beds, banners, shields, shulker boxes) do not.
  icons: false in config.yml leaves them out of the pack. Third demo page "Items".
• Grids accept frame("none").
• Display mode per player (FULL, NO_ICONS, SIMPLE) for players whose own resource pack
  tears the menus: /glyphwork darstellung (native dialog, works even when the pixel GUI breaks),
  API Glyphwork#displayMode and #sendPack, and players.commands: false to hide /glyphwork
  from players so servers can offer it in their own system.

Known limit: icon (and text) widths are taken from the vanilla textures. A resource pack that crops
item textures very differently can shift icons on a line by a few pixels; players can switch to
"Ohne Icons" or "Einfach".

Downloads: Glyphwork-0.3.0.jar (plugin), glyphwork-api-0.3.0.jar (compile against it, do not shade).

Glyphwork 0.2.0

Plugin

• YAML menus for server admins: every *.yml in plugins/Glyphwork/menus/ is a menu with
  labels, buttons, panels (any tile shape), hitboxes, lists and grids. See
  docs/menus.md.
• Actions: run a command as the player or the console, chat message (MiniMessage), sound, open
  another menu, back, close, refresh, and input: to ask for a text that the next action uses as
  %input%.
• Placeholders: %player%, %world%, %online% and every PlaceholderAPI placeholder when it
  is installed (optional, no hard dependency).
• A command per menu (command:, aliases:, permission:), registered at runtime and on
  /glyphwork reload; admins open any menu with /glyphwork menu <id> [player].
• Permissions per menu, per button (otherwise grayed out) and per list/grid entry (otherwise
  hidden).
• Clear errors: problems name the file and the setting, e.g.
  warps.yml.elements[2].widht: unknown setting (allowed: ..., width, ...); broken files are
  skipped, the others still load. /glyphwork reload shows them in chat.
• Two German example menus are put into menus/ on first start.

Releases

• Releases are also published to Modrinth (as beta while the version is 0.x).

Downloads: Glyphwork-0.2.0.jar (plugin), glyphwork-api-0.2.0.jar (compile against it, do not shade).