JavaFX ChoiceBox add separator with type safety

Question

I'm looking to add a separator into a choice box and still retain the type safety.

On all of the examples I've seen, they just do the following:

ChoiceBox<Object> cb =  new ChoiceBox<>();
cb.getItems().addAll("one", "two", new Separator(), "fadfadfasd", "afdafdsfas");

Has anyone come up with a solution to be able to add separators and still retain type safety?

I would expect that if I wanted to add separators, I should be able do something along the following:

ChoiceBox<T> cb = new ChoiceBox<T>();
cb.getSeparators().add(1, new Separator()); // 1 is the index of where the separator should be

I shouldn't have to sacrifice type safety just to add separators.

Answer 1

As already noted, are Separators only supported if added to the items (dirty, dirty). To support them along the lines expected in the question, we need to:

• add the notion of list of separator to choiceBox
• make its skin aware of that list

While the former is not a big deal, the latter requires a complete re-write (mostly c&p) of its skin, as everything is tightly hidden in privacy. If the re-write has happened anyway, then it's just a couple of lines more :-)

Just for fun, I'm experimenting with ChoiceBoxX that solves some nasty bugs in its selection handling, so couldn't resist to try.

First, add support to the ChoiceBoxx itself:

/**
 * Adds a separator index to the list. The separator is inserted 
 * after the item with the same index. Client code
 * must keep this list in sync with the data.
 * 
 * @param separator
 */
public final void addSeparator(int separator) {
    if (separatorsList.getValue() == null) {
        separatorsList.setValue(FXCollections.observableArrayList());
    }
    separatorsList.getValue().add(separator);
};

Then some changes in ChoiceBoxXSkin

• must listen to the separatorsList
• must expect index-of-menuItem != index-of-choiceItem
• menuItem must keep its index-of-choiceItem

At its simplest, the listener re-builds the popup, the menuItem stores the dataIndex in its properties and all code that needs to access a popup by its dataIndex is delegated to a method that loops through the menuItems until it finds one that fits:

protected RadioMenuItem getMenuItemFor(int dataIndex) {
    if (dataIndex < 0) return null;
    int loopIndex = dataIndex;
    while (loopIndex < popup.getItems().size()) {
        MenuItem item = popup.getItems().get(loopIndex);

        ObservableMap<Object, Object> properties = item.getProperties();
        Object object = properties.get("data-index");
        if ((object instanceof Integer) && dataIndex == (Integer) object) {
            return item instanceof RadioMenuItem ? (RadioMenuItem)item : null;
        }
        loopIndex++;
    }
    return null;
}

Answer 2

Well you can work around it by creating an interface and then subclassing Separator to implement this interface:

import javafx.application.Application;
import javafx.beans.binding.Bindings;
import javafx.beans.property.ReadOnlyObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.ChoiceBox;
import javafx.scene.control.Separator;
import javafx.scene.layout.GridPane;
import javafx.scene.text.Text;
import javafx.stage.Stage;

public class ChoiceBoxIsSafe extends Application {

    interface FruitInterface { }

    static public class Fruit implements FruitInterface {
        private StringProperty name = new SimpleStringProperty();
        Fruit(String name) {
            this.name.set(name);
        }

        public StringProperty nameProperty() {
            return name;
        }

        @Override
        public String toString() {
            return name.get();
        }
    }

    static public class FruitySeparator extends Separator implements FruitInterface { }

    @Override
    public void start(Stage primaryStage) throws Exception {
        GridPane grid = new GridPane();
        grid.setHgap(10); grid.setVgap(10); grid.setPadding(new Insets(10));

        ChoiceBox<FruitInterface> cb = new ChoiceBox<>();
        cb.getItems().addAll(new Fruit("Apple"), new Fruit("Orange"), new FruitySeparator(), new Fruit("Peach"));

        Text text = new Text("");

        ReadOnlyObjectProperty<FruitInterface> selected = cb.getSelectionModel().selectedItemProperty();
        text.textProperty().bind(Bindings.select(selected, "name"));

        grid.add(cb, 0, 0);
        grid.add(text, 1, 0);

        Scene scene = new Scene(grid);
        primaryStage.setScene(scene);        
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

but that is hardly an "elegant" solution and cannot be done in all cases (e.g. ChoiceBox<String>).

From the implementation of ChoiceBox it certainly looks like it wasn't a good idea to treat Separators like items in the ChoiceBox :-(.

Answer 3

FOR THE REST OF US:

There is a MUCH easier way to do this using code (there are easy ways to do it using FXML too, doing it in code offers more flexibility).

You simply create an ObservableList, then populate it with your items, including the separator then assign that list to the ChoiceBox like this:

private void fillChoiceBox(ChoiceBox choiceBox) {

    ObservableList items = FXCollections.observableArrayList();

    items.add("one");
    items.add("two");
    items.add("three");
    items.add(new Separator());
    items.add("Apples");
    items.add("Oranges");
    items.add("Pears");

    choiceBox.getItems().clear();
    choiceBox.getItems().addAll(items);
}