JavaFX MenuBar

我就是我 2023-10-15 16:17 60阅读 0赞

The *JavaFX MenuBar* provides JavaFX applications with a visual drop down menu similar to that most desktop applications have at the top of their application window. The JavaFX `MenuBar` is represented by the class `javafx.scene.control.MenuBar` . Here is an example screenshot of what a JavaFX `MenuBar` can look like:

![94741c09a7734a5781c3a31fa4503d67.png][]

### Creating a MenuBar Instance ###

Before you can use the JavaFX `MenuBar` you must create a `MenuBar` instance. Here is an example of creating a JavaFX `MenuBar` instance:

MenuBar menuBar = new MenuBar();

### Adding a MenuBar to the Scene Graph ###

Before a `MenuBar` becomes visible you will have to add it to the JavaFX scene graph. Here is an example of adding a JavaFX `MenuBar` to the scene graph:

import javafx.application.Application;
    import javafx.scene.Scene;
    import javafx.scene.control.Menu;
    import javafx.scene.control.MenuBar;
    import javafx.scene.control.MenuItem;
    import javafx.scene.layout.VBox;
    import javafx.stage.Stage;
    
    public class JavaFXApp extends Application {
    
        public static void main(String[] args) {
            launch(args);
        }
    
        @Override
        public void start(Stage primaryStage) {
            primaryStage.setTitle("JavaFX App");
    
            MenuBar menuBar = new MenuBar();
    
            VBox vBox = new VBox(menuBar);
    
            Scene scene = new Scene(vBox, 960, 600);
    
            primaryStage.setScene(scene);
            primaryStage.show();
        }
    }

Notice how the `MenuBar` is added to the root layout (`VBox`) of the JavaFX scene. This places the `MenuBar` at the top of the application window.

Note that the above example does not add any menus or menu items to the `MenuBar`, so if you run the example you will not actually see the `MenuBar`. We will see how to add menus and menu items in the following sections.

### Creating Menu Instances ###

Once the `MenuBar` instance is created, you can add `Menu` instances to it (`javafx.scene.control.Menu` . A `Menu` instance represents a single vertical menu with nested menu items. Thus, you can add multiple `MenuBar` instances to a `MenuBar` to add multiple vertical drop down menus.

Here is an example of adding a `Menu` to a `MenuBar` :

Menu menu1 = new Menu("Menu 1");
    
    MenuBar menuBar = new MenuBar();
    
    menuBar.getMenus().add(menu1);

Here is a screenshot showing the JavaFX `MenuBar` as configured by the example code above:

![454b24612bff4d2f8d959a4ba9d1fd1d.png][]

As you can see, there is only a single menu in the `MenuBar` titled "Menu 1" . This menu has no menu items nested under it. We will see how to add menu items to a `Menu` in the following sections.

### Menu Graphics ###

You can set a graphic icon for a `Menu` by calling its `setGraphic()` method. The graphic icon will be displayed next to the text label of the menu. Here is an example of setting a graphic icon for a JavaFX `Menu` instance:

Menu menu = new Menu("Menu 1");
    menu.setGraphic(new ImageView("file:volleyball.png"));

Here is how the resulting menu could look in a JavaFX application:

![cee5081c317d4f1aaeb2ae260a9becbd.png][]

### Menu Events ###

A JavaFX `Menu` instance can fire several events which you can listen for in your application. The most commonly used events are:

*  `onShowing`
 *  `onShown`
 *  `onHiding`
 *  `onHidden`

When a `Menu` is clicked with the mouse it shows its contents. This action fires the event `onShowing` before the `Menu` starts showing its menu items. Once the menu is fully visible the `onShown` event is fired.

When an shown (open) `Menu` is clicked with the mouse it hides its contents again. This action fires the event `onHiding` before the `Menu` starts hiding its menu items. Once the menu is fully hidden the `onHidden` event is fired.

You can set `Menu` event listeners for the events above using the methods `setOnShowing()`, `setOnShown()`, `setOnHiding()` and `setOnHidden()`. Here is an example of setting event listeners for these events on a JavaFX `Menu` :

Menu menu = new Menu("Menu 1");
    
    menu.setOnShowing(e -> { System.out.println("Showing Menu 1"); });
    menu.setOnShown  (e -> { System.out.println("Shown Menu 1"); });
    menu.setOnHiding (e -> { System.out.println("Hiding Menu 1"); });
    menu.setOnHidden (e -> { System.out.println("Hidden Menu 1"); });

The `Menu` event listeners set above only print out a message to the console when the events fired. You could do something more advanced in case you needed to.

### Adding Menu Items ###

Once you have created a `Menu` instance you must add one or more `MenuItem` instances to it. Each `MenuItem` corresponds to a menu item in the menu it is added to. Here is an example of adding 2 `MenuItem` instances to a `Menu`, which is then added to a `MenuBar`:

Menu menu = new Menu("Menu 1");
    MenuItem menuItem1 = new MenuItem("Item 1");
    MenuItem menuItem2 = new MenuItem("Item 2");
    
    menu.getItems().add(menuItem1);
    menu.getItems().add(menuItem2);
    
    MenuBar menuBar = new MenuBar();
    menuBar.getMenus().add(menu);

Here is what the resulting JavaFX `MenuBar` would look like, if used in a JavaFX application:

![27c6b6487d8f4bb4b2b327153882e37c.png][]

### MenuItem Graphics ###

You can add an icon to a menu item. You add a graphic icon to a `MenuItem` by calling its `setGraphic()` method, passing as parameter the graphic you want to use for the given `MenuItem`. Here is an example that adds images to the menu items created in the example in the previous section:

Menu menu = new Menu("Menu 1");
    
    MenuItem menuItem1 = new MenuItem("Item 1");
    menuItem1.setGraphic(new ImageView("file:soccer.png"));
    
    MenuItem menuItem2 = new MenuItem("Item 2");
    menuItem1.setGraphic(new ImageView("file:basketball.png"));
    
    menu.getItems().add(menuItem1);
    menu.getItems().add(menuItem2);
    
    MenuBar menuBar = new MenuBar();
    menuBar.getMenus().add(menu);

Here is how a JavaFX `MenuBar` looks with graphic icons added to its menu items:

![44e3e635014848c989ee393192aa56f5.png][]

### MenuItem Events ###

The `MenuBar` configurations created in the previous examples do not react if you select any of the menu items. In order to respond to the selection of a `MenuItem` you must set an event listener on the `MenuItem`. Here is an example of adding an event listener to a JavaFX `MenuItem`:

MenuItem menuItem1 = new MenuItem("Item 1");
    
    menuItem1.setOnAction(e -> {
        System.out.println("Menu Item 1 Selected");
    });

Notice the [Java Lambda][] added as parameter to the `setOnAction()` method of the `MenuItem` . This lambda expression is executed when the menu item is selected.

### Submenus ###

The JavaFX `MenuBar` supports multiple layers of menus. A menu nested inside another menu is called a submenu. The `Menu` class extends the `MenuItem` class and can therefore be used as a menu item inside another `Menu` instance. Here is an example that creates a single JavaFX menu with a submenu inside:

Menu menu = new Menu("Menu 1");
    
    Menu subMenu = new Menu("Menu 1.1");
    MenuItem menuItem11 = new MenuItem("Item 1.1.1");
    subMenu.getItems().add(menuItem11);
    menu.getItems().add(subMenu);
    
    MenuItem menuItem1 = new MenuItem("Item 1");
    menu.getItems().add(menuItem1);
    
    MenuItem menuItem2 = new MenuItem("Item 2");
    menu.getItems().add(menuItem2);
    
    MenuBar menuBar = new MenuBar();
    menuBar.getMenus().add(menu);

The JavaFX `MenuBar` resulting from the above example will look similar to this:

![e4ad67e501c64c43a42a31d5a3cf1dba.png][]

### Check Menu Items ###

The JavaFX `MenuBar` supports using check menu items in a menu. A check menu item is a menu item that can be "selected" and remain selected until unselected later. A small check mark is displayed next to the check menu item as long as it remains selected.

The check menu item is represented by the `CheckMenuItem` (`javafx.scene.control.CheckMenuItem`) class. Here is an example of a JavaFX menu with a `CheckMenuItem` in:

CheckMenuItem checkMenuItem = new CheckMenuItem("Check this!");
    menu.getItems().add(checkMenuItem);

The `Menu` instance then need to be added to a `MenuBar` to be visible, as you have seen in earlier examples. Here is how the resulting menu looks, with the check menu menu item checked:

![c76aff166aad45cb85ef8e7a51cce81d.png][]

### Radio Menu Item ###

The JavaFX `MenuBar` also supports radio menu items. Radio menu items are menu items of which only one of a set of menu items can be selected - just like standard [JavaFX radio buttons][].

The radio menu item is represented by the `RadioMenuItem`. The `RadioMenuItem` instance must be added to a `ToggleGroup` to make them mutually exclusive. That is how JavaFX knows which `RadioMenuItem` instance belong together. Here is an example of a JavaFx menu that uses a set of radio menu items:

Menu menu = new Menu("Menu 1");
    
    RadioMenuItem choice1Item = new RadioMenuItem("Choice 1");
    RadioMenuItem choice2Item = new RadioMenuItem("Choice 2");
    RadioMenuItem choice3Item = new RadioMenuItem("Choice 3");
    
    ToggleGroup toggleGroup = new ToggleGroup();
    toggleGroup.getToggles().add(choice1Item);
    toggleGroup.getToggles().add(choice2Item);
    toggleGroup.getToggles().add(choice3Item);
    
    menu.getItems().add(choice1Item);
    menu.getItems().add(choice2Item);
    menu.getItems().add(choice3Item);
    
    MenuBar menuBar = new MenuBar();
    menuBar.getMenus().add(menu);

Here is how the JavaFx menu resulting from this example code looks:

![5b72192f088c4942a05f7b8f68d4f87f.png][]

### Menu Item Separators ###

The `MenuBar` supports menu item separators. A separator is a horizontal line that separates groups of menu items. A separator is often used to signal to users what menu items are related to each other.

Menu item separators are represented by the `SeparatorMenuItem` class. Here is an example of a menu with two menu items separated by a `SeparatorMenu`:

MenuItem item1 = new MenuItem("Item 1");
    MenuItem item2 = new MenuItem("Item 2");
    SeparatorMenuItem separator = new SeparatorMenuItem();
    
    menu.getItems().add(item1);
    menu.getItems().add(separator);
    menu.getItems().add(item2);
    
    MenuBar menuBar = new MenuBar();
    menuBar.getMenus().add(menu);

Here is how the resulting JavaFX menu would look like:

![477dc163e2ae4f9e99a086d6268404dd.png][]

### Custom Control Menu Items ###

The JavaFX `MenuBar` also supports using custom JavaFX controls as menu items. To do so you need to use the `CustomMenuItem` (`javafx.scene.control.CustomMenuItem`) class.

The `CustomMenuItem` class has a `setContent()` method which you can use to set the custom JavaFX control to show in the menu. Here is an example that shows both a [JavaFX Button][] and a JavaFX `Slider` as custom menu items:

Menu menu = new Menu("Menu 1");
    
    Slider slider = new Slider(0, 100, 50);
    
    CustomMenuItem customMenuItem = new CustomMenuItem();
    customMenuItem.setContent(slider);
    customMenuItem.setHideOnClick(false);
    menu.getItems().add(customMenuItem);
    
    Button button = new Button("Custom Menu Item Button");
    CustomMenuItem customMenuItem2 = new CustomMenuItem();
    customMenuItem2.setContent(button);
    customMenuItem2.setHideOnClick(false);
    menu.getItems().add(customMenuItem2);
    
    MenuBar menuBar = new MenuBar();
    menuBar.getMenus().add(menu);

Notice the call to `CustomMenuItem` `setHideOnClick()` with the value `false` as parameter. This is done to keep the menu open while the user interacts with the custom menu item control. If you set the value to `true` the menu will close as soon as the user clicks the control the first time, making further interaction impossible. For normal menu items you actually do want the menu to close immediately, but for some custom menu items you may not want that. The menu can still be closed by clicking on the menu title again.

Here is how the resulting menu looks:

![cf72788a070040739011c87e3cae8373.png][]

[94741c09a7734a5781c3a31fa4503d67.png]: https://img-blog.csdnimg.cn/94741c09a7734a5781c3a31fa4503d67.png
[454b24612bff4d2f8d959a4ba9d1fd1d.png]: https://img-blog.csdnimg.cn/454b24612bff4d2f8d959a4ba9d1fd1d.png
[cee5081c317d4f1aaeb2ae260a9becbd.png]: https://img-blog.csdnimg.cn/cee5081c317d4f1aaeb2ae260a9becbd.png
[27c6b6487d8f4bb4b2b327153882e37c.png]: https://img-blog.csdnimg.cn/27c6b6487d8f4bb4b2b327153882e37c.png
[44e3e635014848c989ee393192aa56f5.png]: https://img-blog.csdnimg.cn/44e3e635014848c989ee393192aa56f5.png
[Java Lambda]: https://jenkov.com/java/lambda-expressions.html
[e4ad67e501c64c43a42a31d5a3cf1dba.png]: https://img-blog.csdnimg.cn/e4ad67e501c64c43a42a31d5a3cf1dba.png
[c76aff166aad45cb85ef8e7a51cce81d.png]: https://img-blog.csdnimg.cn/c76aff166aad45cb85ef8e7a51cce81d.png
[JavaFX radio buttons]: https://jenkov.com/tutorials/javafx/radiobutton.html
[5b72192f088c4942a05f7b8f68d4f87f.png]: https://img-blog.csdnimg.cn/5b72192f088c4942a05f7b8f68d4f87f.png
[477dc163e2ae4f9e99a086d6268404dd.png]: https://img-blog.csdnimg.cn/477dc163e2ae4f9e99a086d6268404dd.png
[JavaFX Button]: https://jenkov.com/javafx/button.html
[cf72788a070040739011c87e3cae8373.png]: https://img-blog.csdnimg.cn/cf72788a070040739011c87e3cae8373.png