JavaFX Controls, Layouts & FXML

Menus, Toolbars & Dialogs

18 min Lesson 9 of 12

Menus, Toolbars & Dialogs

Almost every desktop application provides three tiers of user-facing command surface: a menu bar that exposes the full feature set, a toolbar that puts the most frequent actions one click away, and dialogs that prompt the user before a destructive operation or surface a result. JavaFX ships with first-class controls for all three tiers. This lesson walks through each one in practical depth.

Menu Bar

The JavaFX menu bar is assembled from three classes that mirror the visual hierarchy:

MenuBar — the horizontal bar that sits at the top of the window.
Menu — a top-level label (File, Edit, Help …) that opens a drop-down when clicked.
MenuItem — a single clickable entry inside that drop-down.

You build the tree in code, attach setOnAction handlers to each MenuItem, and then place the MenuBar into a layout pane — typically the top slot of a BorderPane.

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;

public class MenuDemo extends Application {

    @Override
    public void start(Stage stage) {
        // ---- File menu ----
        MenuItem newItem  = new MenuItem("New");
        MenuItem openItem = new MenuItem("Open…");
        MenuItem saveItem = new MenuItem("Save");
        MenuItem exitItem = new MenuItem("Exit");

        newItem.setOnAction(e  -> System.out.println("New"));
        openItem.setOnAction(e -> System.out.println("Open"));
        saveItem.setOnAction(e -> System.out.println("Save"));
        exitItem.setOnAction(e -> stage.close());

        Menu fileMenu = new Menu("File");
        fileMenu.getItems().addAll(newItem, openItem, saveItem,
                                   new SeparatorMenuItem(), exitItem);

        // ---- Edit menu ----
        MenuItem cutItem   = new MenuItem("Cut");
        MenuItem copyItem  = new MenuItem("Copy");
        MenuItem pasteItem = new MenuItem("Paste");

        Menu editMenu = new Menu("Edit");
        editMenu.getItems().addAll(cutItem, copyItem, pasteItem);

        // ---- Assemble ----
        MenuBar menuBar = new MenuBar();
        menuBar.getMenus().addAll(fileMenu, editMenu);

        BorderPane root = new BorderPane();
        root.setTop(menuBar);

        stage.setScene(new Scene(root, 600, 400));
        stage.setTitle("Menu Demo");
        stage.show();
    }
}

A SeparatorMenuItem renders as a thin horizontal rule, grouping related items visually without adding a clickable entry.

Keyboard Accelerators

Users expect Ctrl+S to save and Ctrl+N to create a new document. Attach a KeyCombination to any MenuItem via setAccelerator(). JavaFX fires the item's action handler when the key combination is pressed regardless of whether the menu is open.

import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyCodeCombination;
import javafx.scene.input.KeyCombination;

saveItem.setAccelerator(
    new KeyCodeCombination(KeyCode.S, KeyCombination.SHORTCUT_DOWN)
);

Use SHORTCUT_DOWN instead of CONTROL_DOWN. On macOS, SHORTCUT_DOWN maps to the Command key; on Windows and Linux it maps to Ctrl. Using it makes your app feel native on every platform without any conditional code.

CheckMenuItem and RadioMenuItem

Beyond plain items, JavaFX provides two stateful variants that are common in View or Options menus:

CheckMenuItem — shows a check mark when selected. Toggle with setSelected(); read state with isSelected().
RadioMenuItem — part of a ToggleGroup so that only one is selected at a time, exactly like radio buttons.

CheckMenuItem wordWrapItem = new CheckMenuItem("Word Wrap");
wordWrapItem.setSelected(true);   // on by default
wordWrapItem.setOnAction(e -> applyWordWrap(wordWrapItem.isSelected()));

ToggleGroup themeGroup = new ToggleGroup();
RadioMenuItem lightItem = new RadioMenuItem("Light Theme");
RadioMenuItem darkItem  = new RadioMenuItem("Dark Theme");
lightItem.setToggleGroup(themeGroup);
darkItem.setToggleGroup(themeGroup);
lightItem.setSelected(true);

Menu viewMenu = new Menu("View");
viewMenu.getItems().addAll(wordWrapItem, new SeparatorMenuItem(),
                           lightItem, darkItem);

Toolbar

A ToolBar is a horizontal (or vertical) strip of buttons that give users one-click access to the most common actions. Like the menu bar, it belongs in the top region of a BorderPane, placed just below the menu bar using a VBox wrapper.

import javafx.scene.control.Button;
import javafx.scene.control.Separator;
import javafx.scene.control.ToolBar;

Button newBtn  = new Button("New");
Button openBtn = new Button("Open");
Button saveBtn = new Button("Save");

// In a real app you would use ImageView icons instead of text labels
newBtn.setOnAction(e  -> System.out.println("New"));
saveBtn.setOnAction(e -> System.out.println("Save"));

ToolBar toolBar = new ToolBar(newBtn, openBtn, saveBtn,
                               new Separator(),
                               new Button("Cut"),
                               new Button("Copy"),
                               new Button("Paste"));

Add tooltips to every toolbar button. Icon-only buttons are compact but cryptic to new users. A single line sets a tooltip: saveBtn.setTooltip(new Tooltip("Save (Ctrl+S)"));. The platform shows it automatically on hover.

Combine the menu bar and toolbar in a VBox so they stack neatly at the top:

VBox topBox = new VBox(menuBar, toolBar);
root.setTop(topBox);

Alert Dialogs

JavaFX's Alert class wraps the standard dialog patterns that every desktop user recognises. You pick an AlertType, set a message, and call showAndWait(). The call blocks on the JavaFX Application Thread until the user dismisses the dialog, then returns an Optional<ButtonType> describing which button was pressed.

The five built-in alert types are:

AlertType.INFORMATION — informational message, single OK button.
AlertType.WARNING — caution, single OK button.
AlertType.ERROR — error report, single OK button.
AlertType.CONFIRMATION — OK / Cancel buttons, returns the chosen button.
AlertType.NONE — no default buttons; you add your own ButtonTypes.

import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.ButtonType;
import java.util.Optional;

// --- Informational ---
Alert info = new Alert(AlertType.INFORMATION);
info.setTitle("Save Successful");
info.setHeaderText(null);            // no bold header line
info.setContentText("Your file has been saved.");
info.showAndWait();

// --- Confirmation (with result check) ---
Alert confirm = new Alert(AlertType.CONFIRMATION);
confirm.setTitle("Delete File");
confirm.setHeaderText("This action cannot be undone.");
confirm.setContentText("Are you sure you want to delete the selected file?");

Optional<ButtonType> result = confirm.showAndWait();
if (result.isPresent() && result.get() == ButtonType.OK) {
    deleteSelectedFile();
}

Custom Button Labels

When the default "OK" and "Cancel" labels do not match your UI copy, replace them with named ButtonType instances:

ButtonType saveBtn   = new ButtonType("Save");
ButtonType discardBtn = new ButtonType("Discard");
ButtonType cancelBtn  = new ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);

Alert unsaved = new Alert(AlertType.NONE);
unsaved.setTitle("Unsaved Changes");
unsaved.setContentText("Do you want to save changes before closing?");
unsaved.getButtonTypes().setAll(saveBtn, discardBtn, cancelBtn);

Optional<ButtonType> choice = unsaved.showAndWait();
if (choice.isPresent()) {
    if (choice.get() == saveBtn)    { saveAndClose(); }
    else if (choice.get() == discardBtn) { closeWithoutSave(); }
    // else: cancel — do nothing
}

Always call showAndWait(), not show(), for confirmation dialogs. show() is non-blocking — your code continues immediately after displaying the dialog, so the Optional is empty and you cannot know what the user chose. Reserve show() only for non-blocking informational popups where you do not need the result.

TextInputDialog and ChoiceDialog

Two additional built-in dialogs handle common interaction patterns without requiring you to build a custom layout:

TextInputDialog — shows a text field so the user can enter a string. Returns Optional<String>.
ChoiceDialog<T> — shows a ComboBox pre-filled with choices you supply. Returns Optional<T>.

// Ask for a filename
TextInputDialog nameDialog = new TextInputDialog("report.pdf");
nameDialog.setTitle("Save As");
nameDialog.setHeaderText("Enter a file name:");
nameDialog.setContentText("Name:");

Optional<String> name = nameDialog.showAndWait();
name.ifPresent(n -> saveAs(n));

// Let the user pick a theme
ChoiceDialog<String> themeDialog =
        new ChoiceDialog<>("Light", "Light", "Dark", "High Contrast");
themeDialog.setTitle("Select Theme");
themeDialog.setHeaderText(null);
themeDialog.setContentText("Theme:");

themeDialog.showAndWait().ifPresent(t -> applyTheme(t));

Putting It Together

In a real application, the menu bar, toolbar, and dialog code belong in the controller class (which you learned in Lesson 7). The FXML file declares the MenuBar and ToolBar nodes; the controller holds the @FXML-injected references and wires up the action handlers. Dialogs are almost always created imperatively in handler methods — they are transient objects not worth declaring in FXML.

Summary

A professional JavaFX application exposes commands through a MenuBar (full feature set), a ToolBar (quick access), and Alert dialogs (user prompts). Use KeyCodeCombination with SHORTCUT_DOWN for cross-platform accelerators. Prefer showAndWait() and inspect the Optional<ButtonType> return value for any dialog that requires a decision. In the next lesson you will build a complete form-based application that uses all the controls and patterns from this tutorial.