How to increase the number of possible selections within a ToggleGroup (e.g. RadioButtons)?

I am somewhat new to programming and new to OOP (2nd Java project over all right now) and would love any hints or help.

I am currently working on a character creation program for my very own pen&paper game. I am using JavaFX (without FXML and thus without SceneBuilder) for the GUI part. I am working with Eclipse Neon on JDK1.8.0_131.

Here is my issue:
tl;dr: How to increase the number of possible selections within a ToggleGroup?
I am about to create a list of options for the user to choose from. The list consist of about 30 different advantages he or she can choose to improve their character. The allowed maximum of chosen options depends on the character and varies around 5. I already implemented an array of pairs (I know about HashMaps), where each entry is a pair consisting of the advantage's name and an integer representing its costs (they vary in their values, so in their costs).
The list itself should now be implemented via

ScrollPane scrollAdv = new ScrollPane();
VBox vBoxAdv = new VBox();
scrollAdv.setContent(vBoxAdv);
Pair<String, Integer>[] listAdv = info.getAdvantages();
for (int i = 0; i < listAdv.length; i++) {
    String name = listAdv[i].getKey(); // delivers the 1st entry of a pair
    int costs = listAdv[i].getValue(); // delivers the 2nd entry of a pair
    ToggleButton toggleButton = new ToggleButton();
    toggleButton.setUserData(name);
    toggleButton.setText(name + " (" + costs + ")");
    vBoxAdv.getChildren().add(toggleButton);
}

Note that I don't care too much about ToggleButtons and they could easily be replaced with RadioButtons. Both work the same way, if I understood the documentation correctly. They both use ToggleGroup to make sure, only one option is selected.
So while you probably guessed so by now, what I want to do is give the user the possibility to chose more than one option at once. I do not want to make it so the user has to chose one option after the other, while resetting the list in between.

Thanks for reading and thanks in advance for any help or hints.

edit: I could always just add a counter which refreshes whenever one option is selected or deselected and blocks any selection if it's < 1, but I thought that there should be a better solution, e.g. increase the built-in limit of 1 which ToggleGroup seems to be using.

Solution

One way would be to disable the remaining toggles when the limit is reached. Here's a ToggleSet class that does that:

import java.util.ArrayList;
import java.util.List;

import javafx.beans.Observable;
import javafx.beans.binding.Bindings;
import javafx.beans.binding.IntegerBinding;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.collections.transformation.FilteredList;
import javafx.scene.Node ;
import javafx.scene.control.Toggle;

public class ToggleSet<T extends Node & Toggle>  {

    private final ObservableList<T> toggles = FXCollections.observableArrayList(t -> new Observable[] {t.selectedProperty()});
    private final FilteredList<T> selectedToggles = toggles.filtered(t -> ((Toggle)t).isSelected());
    private final IntegerProperty maximumSelectable = new SimpleIntegerProperty(0);

    private final IntegerBinding numSelected = Bindings.size(selectedToggles);

    public ToggleSet(int maximumSelectable) {

        this.maximumSelectable.addListener((obs, oldMax, newMax) -> {
            if (newMax.intValue() < numSelected.get()) {
                List<Toggle> togglesToClear = new ArrayList<>(selectedToggles.subList(0, numSelected.get() - newMax.intValue()));
                togglesToClear.forEach(t -> t.setSelected(false));
            }
        });

        setMaximumSelectable(maximumSelectable);
    }

    public ToggleSet() {
        this(0);
    }

    public ObservableList<T> getSelectedToggles() {
        return FXCollections.unmodifiableObservableList(selectedToggles) ;
    }

    public IntegerProperty maximumSelectableProperty() {
        return maximumSelectable ;
    }

    public final int getMaximumSelectable() {
        return maximumSelectableProperty().get();
    }

    public final void setMaximumSelectable(int maximumSelectable) {
        maximumSelectableProperty().set(maximumSelectable);
    }

    public void addToggle(T toggle) {
        if (numSelected.get() >= getMaximumSelectable()) {
            toggle.setSelected(false);
        }
        toggles.add(toggle);
        toggle.disableProperty().bind(toggle.selectedProperty().not().and(numSelected.greaterThanOrEqualTo(maximumSelectable)));
    }

    public void removeToggle(T toggle) {
        toggles.remove(toggle);
        toggle.disableProperty().unbind();
    }

}

Here's an example testing it:

import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Label;
import javafx.scene.control.RadioButton;
import javafx.scene.control.Spinner;
import javafx.scene.control.ToggleButton;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

public class ToggleSetTest extends Application {

    @Override
    public void start(Stage primaryStage) {
        ToggleSet<ToggleButton> toggleSet = new ToggleSet<>(5);
        GridPane grid = new GridPane() ;

        Spinner<Integer> maxSelectedSpinner = new Spinner<>(0, 20, 5);
        maxSelectedSpinner.getValueFactory().valueProperty().bindBidirectional(toggleSet.maximumSelectableProperty().asObject());

        grid.add(new HBox(2, new Label("Maximum selected"), maxSelectedSpinner), 0, 0, 2, 1);

        grid.addRow(1,  new Label("Selection"), new Label("Include in set"));

        for (int i = 1; i <= 20 ; i++) {
            RadioButton button = new RadioButton("Button "+i);
            CheckBox checkBox = new CheckBox();
            checkBox.selectedProperty().addListener((obs, wasChecked, isNowChecked) -> {
                if (isNowChecked) {
                    toggleSet.addToggle(button);
                } else {
                    toggleSet.removeToggle(button);
                }
            });
            checkBox.setSelected(true);
            grid.addRow(i + 1, button, checkBox);
        }
        grid.setPadding(new Insets(10));
        grid.setHgap(5);
        grid.setVgap(2);
        Scene scene = new Scene(grid);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

If you want the same behavior as the ToggleGroup, where the previous selection becomes unselected, it's a little trickier, but the following should work:

import java.util.ArrayList;
import java.util.List;

import javafx.beans.Observable;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.Property;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.value.ChangeListener;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Node ;
import javafx.scene.control.Toggle;

public class ToggleSet<T extends Node & Toggle>  {

    private final ObservableList<T> toggles = FXCollections.observableArrayList(t -> new Observable[] {t.selectedProperty()});
    private final ObservableList<T> selectedToggles = FXCollections.observableArrayList();
    private final IntegerProperty maximumSelectable = new SimpleIntegerProperty(0);

    private final ChangeListener<Boolean> toggleListener = (obs, wasSelected, isNowSelected) -> {
        @SuppressWarnings("unchecked")
        T toggle = (T) ((Property<?>)obs).getBean();
        if (isNowSelected) {
            selectedToggles.add(toggle);
            ensureWithinMax();
        } else {
            selectedToggles.remove(toggle);
        }
    };

    public ToggleSet(int maximumSelectable) {

        this.maximumSelectable.addListener((obs, oldMax, newMax) -> ensureWithinMax());
        setMaximumSelectable(maximumSelectable);
    }

    private void ensureWithinMax() {
        if (this.maximumSelectable.get() < selectedToggles.size()) {
            List<Toggle> togglesToClear = new ArrayList<>(selectedToggles.subList(0, selectedToggles.size() - this.maximumSelectable.get()));
            togglesToClear.forEach(t -> t.setSelected(false));
        }
    }

    public ToggleSet() {
        this(0);
    }

    public ObservableList<T> getSelectedToggles() {
        return FXCollections.unmodifiableObservableList(selectedToggles) ;
    }

    public IntegerProperty maximumSelectableProperty() {
        return maximumSelectable ;
    }

    public final int getMaximumSelectable() {
        return maximumSelectableProperty().get();
    }

    public final void setMaximumSelectable(int maximumSelectable) {
        maximumSelectableProperty().set(maximumSelectable);
    }

    public void addToggle(T toggle) {
        if (toggle.isSelected()) {
            selectedToggles.add(toggle);
            ensureWithinMax();
        }
        toggle.selectedProperty().addListener(toggleListener);
        toggles.add(toggle);
    }

    public void removeToggle(T toggle) {
        toggle.selectedProperty().removeListener(toggleListener);
        toggles.remove(toggle);
    }

}

(Use the same test code.)