Java 类javafx.scene.control.Toggle 实例源码

public TypedToggleGroup() {

        this.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
            @Override
            @SuppressWarnings("unchecked")
            public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) {
                if (newValue != null) {
                    T obj = (T) newValue.getUserData();
                    selectedValueProperty.setValue(obj);
                } else {
                    selectedValueProperty.setValue(null);
                }
            }
        });

    }

private SecretValue getSecretValue(ToggleGroup valueSource, String value, String generated, File file) {
    Toggle current = valueSource.getSelectedToggle();

    String secretString;
    if (current.getUserData().equals("value")) {
        secretString = value;
    } else if (current.getUserData().equals("generated")) {
        Integer numBytesToGenerate = Integer.valueOf(generated);
        // TODO: store as plain bytes?
        byte[] random = Singleton.randomGenerator.generateRandom(numBytesToGenerate);
        secretString = Base64.encodeAsString(random);
    } else {
        String path = null;
        try {
            path = file.getCanonicalPath();
            return SecretValueConverter.inferEncoding(Files.readAllBytes(Paths.get(path)), SecretType.OPAQUE);
        } catch (IOException e) {
            throw new RuntimeException("Failed to read secret from file");
        }
    }

    return new SecretValue(secretString, SecretType.OPAQUE);
}

@Override
public void initialize(URL arg0, ResourceBundle arg1) {

    final Image tempImage = new Image(getClass().getResourceAsStream("/images/Valencia.jpg"));
    tempimg.setImage(tempImage);

    temprb.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        public void changed(ObservableValue<? extends Toggle> ov, Toggle old_toggle, Toggle new_toggle) {
            if (temprb.getSelectedToggle() != null) {
                RadioButton chk = (RadioButton) old_toggle.getToggleGroup().getSelectedToggle();
                System.out.println("Selected Radio Button - " + chk.getText());
                final Image image = new Image(
                        getClass().getResourceAsStream("/images/" + chk.getText().toString() + ".jpg"
                // Cast object to radio button
                // System.out.println("Selected Radio Button -
                // "+chk.getText());

                ));
                tempimg.setImage(image);
            }
        }
    });
}

public TemplateField(String name, String label, boolean isSelected, String constant) {
  this.name = name;
  this.label = label;
  this.isSelected = isSelected;
  this.selection = "YES";
  this.value = constant;

  labelElement = new WikiLabel(label).setWidth(200, 500).setHeight(35);
  buttonYes.setSelected(true);

  group.selectedToggleProperty().addListener((ObservableValue<? extends Toggle> ov, Toggle tOld, Toggle tNew) -> {
    RadioButton btn = (RadioButton) tNew.getToggleGroup().getSelectedToggle();
    setSelection(btn.getId());
  });

  valueText.setOnKeyReleased((KeyEvent event) -> {
    this.value = valueText.getText();
  });
}

@Override
public void changed(ObservableValue<? extends Toggle> pObservableValue, Toggle pOld, Toggle pNew)
{
    if( aScene != null )
    {
        aScene.getStylesheets().clear();
        switch(aSkin.getSelectedToggle().getUserData().toString())
        {
        case "Floral":
            aScene.getStylesheets().add(Welcome.class.getResource("cs1.css").toExternalForm());
            break;

        case "Chintz":
            aScene.getStylesheets().add(Welcome.class.getResource("cs2.css").toExternalForm());
            break;

        default:
            break;
        }

    }
}

public void removeButton(T ref) {
    if (!items.containsKey(ref)) {
        logger.error("removeButton on non-existing ref - {}", ref);
        return;
    }

    final Node item = items.remove(ref);

    if (Platform.isFxApplicationThread()) {
        subContainer.getChildren().remove(item);
    } else {
        Platform.runLater(() -> subContainer.getChildren().remove(item));
    }

    if (toggleable && ref == defaultSelection) {
        defaultSelection = null;
    }

    if (toggleable && ref == currentSelection && defaultSelection != null) {
        currentSelection = defaultSelection;
        itemListener.onItemClicked(currentSelection);
        toggleGroup.selectToggle((Toggle) items.get(currentSelection));
    }
}

/** @return {@link OpenDisplayActionInfo} from sub pane */
private OpenDisplayActionInfo getOpenDisplayAction()
{
    Target target = Target.REPLACE;
    List<Toggle> modes = open_display_targets.getToggles();
    for (int i=0; i<modes.size(); ++i)
        if (modes.get(i).isSelected())
        {
            target = Target.values()[i];
            break;
        }

    return new OpenDisplayActionInfo(open_display_description.getText(),
                                     open_display_path.getText().trim(),
                                     open_display_macros.getMacros(),
                                     target);
}

@Override
public void initialize(URL location, ResourceBundle resources) {
    closeJarButton.setDisable(Main.getLoadedJar() == null);
    loadMappingsButton.setDisable(Main.getLoadedJar() == null);
    mergeMappingsButton.setDisable(Main.getLoadedJar() == null);
    saveMappingsButton.setDisable(Main.getLoadedJar() == null);
    saveMappingsAsButton.setDisable(Main.getLoadedJar() == null);
    resetMappingsButton.setDisable(Main.getLoadedJar() == null);

    final String langRadioPrefix = "langRadio-";
    for (Toggle toggle : languageGroup.getToggles()) {
        if (((RadioMenuItem) toggle).getId().equals(langRadioPrefix + Main.getCurrentLocale())) {
            toggle.setSelected(true);
            break;
        }
    }

    setAccelerators();

    this.initTreeViews();

    RESTART_ALERT.setTitle(Main.getResourceBundle().getString("dialog.restart.title"));
    RESTART_ALERT.setHeaderText(null);
    RESTART_ALERT.setContentText(Main.getResourceBundle().getString("dialog.restart.content"));
}

@Override
public void setValidationSupport(ValidationSupport validationSupport) {
    this.validationSupport = validationSupport;
    Validator<Toggle> operationValidator = (c, newValue) -> {
        String whyBad = null;
        if (newValue != null) {
            String nameOfOperator = ((ToggleButton) newValue).getText();
            BooleanOperator operator = BooleanOperator.valueOf(nameOfOperator);
            if (logicalChecker != null) {
                // Internally the result will depend on amount of children.
                whyBad = logicalChecker
                        .whyOperatorCantBeAppliedToCurrentAmountOfCheckers(operator);
            }
        }
        ValidationResult wrongResult = ValidationResult.fromErrorIf(c,
                whyBad, whyBad != null);
        if (newValue != null) {
            ToggleButton origTB = mapWithButtons.get(origLogicalChecker.getOperator().name());
            buttonStateManager.reportNewValueOfControl(origTB, newValue, c, wrongResult);
        }
        return wrongResult;
    };
    this.validationSupport.registerValidator(segmentedButton, operationValidator);
}

public void initialize() {
    //init values
    mExpanded = new SimpleBooleanProperty(true);
    mSelectedButton = new SimpleObjectProperty<>(SideButton.NONE);

    //minimize the side pane
    handleMenuButtonAction();

    //add toggle listener
    sideButton.selectedToggleProperty().addListener(
            (ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) -> {
                if (newValue != null) {
                    selectedButtonChanged((ToggleButton) newValue);
                } else {
                    oldValue.setSelected(true);
                }
            });
}

public ToggleButtonSample() {
    // create label to show result of selected toggle button
    final Label label = new Label();
    label.setStyle("-fx-font-size: 2em;");
    // create 3 toggle buttons and a toogle group for them
    final ToggleButton tb1 = new ToggleButton("Cat");
    final ToggleButton tb2 = new ToggleButton("Dog");
    final ToggleButton tb3 = new ToggleButton("Horse");
    ToggleGroup group = new ToggleGroup();
    tb1.setToggleGroup(group);
    tb2.setToggleGroup(group);
    tb3.setToggleGroup(group);
    group.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        @Override public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle selectedToggle) {
            if(selectedToggle!=null) {
                label.setText(((ToggleButton) selectedToggle).getText());
            }
            else {
                label.setText("...");
            }
        }
    });
    // select the first button to start with
    group.selectToggle(tb1);
    // add buttons and label to grid and set their positions
    GridPane.setConstraints(tb1,0,0);
    GridPane.setConstraints(tb2,1,0);
    GridPane.setConstraints(tb3,2,0);
    GridPane.setConstraints(label,0,1,3,1);
    GridPane grid = new GridPane();
    grid.setVgap(20);
    grid.setHgap(10);
    getChildren().add(grid);
    grid.getChildren().addAll(tb1, tb2, tb3, label);
}

public ToggleButtonSample() {
    // create label to show result of selected toggle button
    final Label label = new Label();
    label.setStyle("-fx-font-size: 2em;");
    // create 3 toggle buttons and a toogle group for them
    final ToggleButton tb1 = new ToggleButton("Cat");
    final ToggleButton tb2 = new ToggleButton("Dog");
    final ToggleButton tb3 = new ToggleButton("Horse");
    ToggleGroup group = new ToggleGroup();
    tb1.setToggleGroup(group);
    tb2.setToggleGroup(group);
    tb3.setToggleGroup(group);
    group.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        @Override public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle selectedToggle) {
            if(selectedToggle!=null) {
                label.setText(((ToggleButton) selectedToggle).getText());
            }
            else {
                label.setText("...");
            }
        }
    });
    // select the first button to start with
    group.selectToggle(tb1);
    // add buttons and label to grid and set their positions
    GridPane.setConstraints(tb1,0,0);
    GridPane.setConstraints(tb2,1,0);
    GridPane.setConstraints(tb3,2,0);
    GridPane.setConstraints(label,0,1,3,1);
    GridPane grid = new GridPane();
    grid.setVgap(20);
    grid.setHgap(10);
    getChildren().add(grid);
    grid.getChildren().addAll(tb1, tb2, tb3, label);
}

@Override
public void start(Stage stage) {
    stage.setTitle("Toggle Button Sample");
    stage.setWidth(250);
    stage.setHeight(180);

    HBox hbox = new HBox();
    VBox vbox = new VBox();        

    Scene scene = new Scene(new Group(vbox));
    stage.setScene(scene);
    scene.getStylesheets().add("togglebuttonsample/ControlStyle.css");

    Rectangle rect = new Rectangle();
    rect.setHeight(50);
    rect.setFill(Color.WHITE);
    rect.setStroke(Color.DARKGRAY);
    rect.setStrokeWidth(2);
    rect.setArcHeight(10);
    rect.setArcWidth(10);

    final ToggleGroup group = new ToggleGroup();

    group.selectedToggleProperty().addListener(
        (ObservableValue<? extends Toggle> ov, 
        Toggle toggle, Toggle new_toggle) -> {
        if (new_toggle == null)
            rect.setFill(Color.WHITE);
        else
            rect.setFill((Color) group.getSelectedToggle().getUserData());
    });

    ToggleButton tb1 = new ToggleButton("Minor");
    tb1.setToggleGroup(group);
    tb1.setUserData(Color.LIGHTGREEN);
    tb1.setSelected(true);
    tb1.getStyleClass().add("toggle-button1");

    ToggleButton tb2 = new ToggleButton("Major");
    tb2.setToggleGroup(group);
    tb2.setUserData(Color.LIGHTBLUE);
    tb2.getStyleClass().add("toggle-button2");

    ToggleButton tb3 = new ToggleButton("Critical");
    tb3.setToggleGroup(group);
    tb3.setUserData(Color.SALMON);
    tb3.getStyleClass().add("toggle-button3");



    hbox.getChildren().addAll(tb1, tb2, tb3);

    vbox.getChildren().add(new Label("Priority:"));
    vbox.getChildren().add(hbox);
    vbox.getChildren().add(rect);
    vbox.setPadding(new Insets(20, 10, 10, 20));


    stage.show();
    rect.setWidth(hbox.getWidth());
}

/**
 * Add an enumeration of options to a wizard step. Multiple RadioButtons
 * will be used (horizontally-aligned).
 *
 * @param fieldName
 * @param options
 *            list of choices.
 * @param prompt
 *            the text to show on the buttons tooltip.
 * @param defaultValue
 *            the default value to be selected.
 * @return
 */
@SuppressWarnings("unchecked")
public WizardStepBuilder addToggleGroup(final String fieldName, final String[] options, final String[] prompt,
        final int defaultValue)
{
    final ToggleGroup group = new ToggleGroup();

    final HBox box = new HBox();

    for (int i = 0; i < options.length; i++)
    {
        final JFXRadioButton radio = new JFXRadioButton(options[i]);
        radio.setPadding(new Insets(10));
        radio.setToggleGroup(group);
        radio.setTooltip(new Tooltip(prompt[i]));
        radio.setUserData(options[i]);
        if (i == defaultValue)
            radio.setSelected(true);

        box.getChildren().add(radio);
    }

    this.current.getData().put(fieldName, new ReadOnlyObjectWrapper<Toggle>());
    this.current.getData().get(fieldName).bind(group.selectedToggleProperty());
    final Label label = new Label(fieldName);
    GridPane.setHalignment(label, HPos.RIGHT);
    GridPane.setHalignment(box, HPos.LEFT);
    this.current.add(label, 0, this.current.getData().size() - 1);
    this.current.add(box, 1, this.current.getData().size() - 1);
    return this;
}

public  boolean getPlacementToggle() {
    Toggle in = placementToggleGroup.getSelectedToggle();
    boolean out = false;
    if(in == activePlace) out = true;

    return out;
}

@FXML
void initialize() {
    if (Language.RO.equals(langCtr.getLanguage())) {
        engRadio.setSelected(false);
        romRadio.setSelected(true);
    }
    langGroup.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) {
            changeLanguage();
        }
    });
}

/**
 * Set the type of scrolling.
 * @param name: type of scrolling
 */
public void setScrolling(String name) {
    for(Toggle toggle : trackingMode.getToggles()) {
        if(((RadioButton) toggle).getText().equals(name)) {
            trackingMode.selectToggle(toggle);
        }
    }
}

private void clearIndicatorButtons() {
    for (Toggle toggle : indicatorButtons.getToggles()) {
        if (toggle instanceof IndicatorButton) {
            IndicatorButton indicatorButton = (IndicatorButton) toggle;
            indicatorButton.release();
        }
    }
    indicatorButtons.getToggles().clear();
}

@Override
public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) {
    if (newValue == null) {
        controlProperty.setValue((SerializableValue) null);
    } else {
        controlProperty.setValue(new SVRaw(newValue.getUserData().toString(), controlProperty.getInitialPropertyType()));
    }

}

private void setEditorValue(@Nullable SerializableValue newValue) {
    if (newValue == null) {
        toggleGroup.selectToggle(null);
        return;
    }
    for (Toggle toggle : toggleGroup.getToggles()) {
        if (controlProperty.getValue() == null) {
            continue;
        }
        if (toggle.getUserData().equals(controlProperty.getValue().toString())) {
            toggleGroup.selectToggle(toggle);
            return;
        }
    }
}

public boolean isSelected() {
    for (Toggle item : items) {
        if (item.isSelected())
            return true;
    }
    return false;
}

public boolean selectAll(boolean select) {
    boolean changed = false;
    for (Toggle item : items) {
        if (item.isSelected() != select) {
            item.setSelected(select);
            changed = true;
        }
    }
    return changed;
}

public ArrayList<Toggle> getSelectedItems() {
    final ArrayList<Toggle> selectedItems = new ArrayList<>();
    for (Toggle item : items) {
        if (item.isSelected())
            selectedItems.add(item);
    }
    return selectedItems;
}

/**
 * defines what happens, before the GUI is started
 */
public void initialize(URL location, ResourceBundle resources) {

    // set the controller var in the Main class to this Controller
    Main.controller = this;

    updateList();
    log.debug("List updated");

    // Formatting of the listView
    listView.setFixedCellSize(60);
    listView.setItems(items);
    addButton.setSelected(true);
    log.debug("ListView cellSize changed, items assigned");

    // is activated if the text in the searchbox is changed
    searchBox.textProperty().addListener((observable, oldVal, newVal) -> {
        renewSearch(newVal);
    });

    // is called when the selected Search Radiobutton is changed
    searchToggle.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        public void changed(ObservableValue<? extends Toggle> ov, Toggle old_toggle, Toggle new_toggle) {
            renewSearch(searchBox.getText());
        }
    });

    // gets called if an item in the listview is selected -> will load the
    // currently selected item
    // in the overview on the left
    listView.getSelectionModel().getSelectedItems().addListener(new ListChangeListener<ItemBox>() {
        @Override
        public void onChanged(javafx.collections.ListChangeListener.Change<? extends ItemBox> c) {
            //Update the overview section on the left side of the GUI
            updateOverview();
        }
    });

    setupMenuItems();
}

/**
 * Update interval selection
 */
private void updateIntervalSelection() {
    for (Toggle toggle : latencyInterval.getToggles()) {
        if (((RadioButton) toggle).getText().equals(intervalProperty.get())) {
            latencyInterval.selectToggle(toggle);
            return;
        }
    }
}

private void showHttpBody(Toggle value) {
    Object userData = value.getUserData();
    if (userData.equals("request")) {
        bodyPane.setBody(roundTripMessage.get().getRequestBody());
    } else if (userData.equals("response")) {
        bodyPane.setBody(roundTripMessage.get().getResponseBody());
    }
}

public void addAlwaysOneSelectedSupport(final ToggleGroup toggleGroup) {
    toggleGroup.getToggles().addListener((Change<? extends Toggle> c) -> {
        while (c.next()) {
            for (final Toggle addedToggle : c.getAddedSubList()) {
                addConsumeMouseEventfilter(addedToggle);
            }
        }
    });
    toggleGroup.getToggles().forEach(t -> {
        addConsumeMouseEventfilter(t);
    });
}

void updateSelectedScript() {
    ScriptTab tab = listScripts == null ? null : listScripts.getSelectionModel().getSelectedItem();
    if (tab == selectedScript.get())
        return;

    Node lastComponent = splitMain.getItems().get(1);
    Node newComponent = tab == null ? null : tab.getComponent();
    if (lastComponent == newComponent)
        return;

    double loc = splitMain.getDividers().get(0).getPosition();
    splitMain.getItems().set(1, newComponent);
    if (tab != null) {
        maybeRefreshTab(tab);
        splitMain.setDividerPosition(0, loc);
        // Unfortunately need to wait until divider is present before we can set the divider location
        if (selectedScript.get() == null)
            tab.splitEditor.setDividerPosition(0, 0.75);
        else
            tab.splitEditor.setDividerPosition(0, selectedScript.get().splitEditor.getDividers().get(0).getPosition());

        // Update the selected language
        Language language = tab.getLanguage();
        String languageName = language == null ? NO_LANGUAGE : language.toString();
        for (Toggle button : bgLanguages.getToggles()) {
            if (languageName.equals(button.getUserData())) {
                bgLanguages.selectToggle(button);
                break;
            }
        }
    }

    selectedScript.set(tab);
}

public void addAlwaysOneSelectedSupport(final ToggleGroup toggleGroup) {
    toggleGroup.getToggles().addListener((Change<? extends Toggle> c) -> {
        while (c.next()) {
            for (final Toggle addedToggle : c.getAddedSubList()) {
                addConsumeMouseEventfilter(addedToggle);
            }
        }
    });
    toggleGroup.getToggles().forEach(t -> {
        addConsumeMouseEventfilter(t);
    });
}

private void singleGenerateTraceInfoGUI(String line)
{
    Map<TraceLineInfo.Columns, String> valueMap = getMapOfValues(line);
    String ip = valueMap.get(TraceLineInfo.Columns.IP);
    GeoIPInfo geoIPInfo = geoIPResults.get(ip);
    boolean hasLocation = geoIPInfo != null && geoIPInfo.getSuccess();

    valueMap.put(TraceLineInfo.Columns.LABEL, hasLocation ? String.valueOf(label) : "");

    TraceLineInfo currentRow = new TraceLineInfo();
    populateTraceResults(valueMap, currentRow);

    SimpleBooleanProperty checkboxValue = new SimpleBooleanProperty(hasLocation);
    checkboxValue.addListener((ChangeListener<Boolean>) (observable, oldValue, newValue) ->
    {
        Toggle selectedZoomBtn = zoomToggleGroup.getSelectedToggle();
        if (selectedZoomBtn != null)
            selectedZoomBtn.setSelected(false);

        labelUnderMap.setVisible(true);
        generateAndShowImage();
    });

    listOfRows.add(currentRow);
    mapRowToSelectedStatus.put(currentRow, checkboxValue);

    queueOfLinesToAddToTable.add(currentRow);

    if (hasLocation) //otherwise the label won't be used, so don't advance it
    {
        if (label != 'Z')
            label++; //trace is limited to 30 hops, so no need to worry about '9'
        else
            label = '0';
    }
}

public void setDefault(T ref) {
    if (!toggleable) {
        logger.error("setDefault only applies to toggleable item selection");
        return;
    }

    if (items.containsKey(ref)) {
        if (defaultSelection == null && currentSelection == null) {
            currentSelection = ref;
            toggleGroup.selectToggle((Toggle) items.get(ref));
        }
        defaultSelection = ref;
    } else
        logger.error("setDefault on non-existing ref - {}", ref);
}

public void setSelection(T ref) {
    if (items.containsKey(ref)) {
        currentSelection = ref;
        toggleGroup.selectToggle((Toggle) items.get(currentSelection));
    } else {
        if (logger.isWarnEnabled()) logger.warn("setSelection on non-existing ref - {}", ref);
    }
}

private void selectionChanged(final ObservableValue<? extends Toggle> obs, final Toggle oldval, final Toggle newval)
{
    if (!active  &&  newval != null)
    {
        active = true;
        try
        {
            // For now reset to old value.
            // New value will be shown if the PV accepts it and sends a value update.
            toggle.selectToggle(oldval);

            final Object value;
            final VType pv_value = model_widget.runtimePropValue().getValue();
            if (pv_value instanceof VEnum  ||  pv_value instanceof VNumber)
                // PV uses enumerated or numeric type, so write the index
                value = toggle.getToggles().indexOf(newval);
            else // PV uses text
                value = FormatOptionHandler.parse(pv_value,
                                                  ((RadioButton) newval).getText(),
                                                  FormatOption.DEFAULT);
            logger.log(Level.FINE, "Writing " + value);
            toolkit.fireWrite(model_widget, value);
        }
        finally
        {
            active = false;
        }
    }
}

private void deSelectNavigationStateButtons() {
    Toggle tg = navigationStateSegmentedButton.getToggleGroup().getSelectedToggle();
    if (tg != null) {
        tg.setSelected(false);
    }

}

public void setSelectedForProperty(String key, Object val) {

        for (final Toggle b : getToggles()) {
            if (this.metaMap.get(b).get(key).equals(val)) {
                selectToggle(b);
                return;
            }
        }
    }

private Map<Toggle, Object> toToggleMap(Object... values) {
    final Map<Toggle, Object> map = Maps.newHashMap();

    for (int i = 0; i < values.length; i += 2) {
        map.put((Toggle) values[i], values[i + 1]);
    }

    return map;
}

public static boolean addTogglesToGroup(MetaToggleGroup group, Toggle... toggles) {
    for (final Toggle t : toggles) {
        group.add(t, "");
    }

    return true;
}

public Home() {
    group = new ToggleGroup();
    RadioButton rb1 = new RadioButton("Create a new transaction");
    RadioButton rb2 = new RadioButton("Review existing transactions");
    rb1.setToggleGroup(group);
    rb2.setToggleGroup(group);
    rb1.setSelected(true);

    VBox vboxRb = new VBox(10);
    vboxRb.getChildren().addAll(rb1, rb2);

    initGenerateForm();
    initReviewForm();

    rb1.setUserData(generate);
    rb2.setUserData(review);

    vbox = new VBox(25);
    vbox.setPadding(new Insets(50, 50, 50, 50));
    vbox.getChildren().addAll(vboxRb, generate);

    group.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        @Override
        public void changed(ObservableValue<? extends Toggle> ov, Toggle toggle, Toggle new_toggle) {
            vbox.getChildren().remove(1);
            vbox.getChildren().add((NewForm) group.getSelectedToggle().getUserData());
        }
    });
}

/**
 * Constructor that sets up all additional elements.
 * The key listener mimics the Windows-platform function to switch between toggles in a toggle group by using the arrow keys.
 * The focus border can be styled via the CSS-class <code>radio-button-focus-border</code>.
 * @param radioButton
 */
public AeroRadioButtonSkin(RadioButton radioButton) {
    super(radioButton);

    focusBorderRect = new Rectangle(0, 0, Color.TRANSPARENT);
    getChildren().add(focusBorderRect);
    focusBorderRect.setVisible(false);
    focusBorderRect.getStyleClass().add("radio-button-focus-border");
    focusBorderListener = (e) -> focusBorderRect.setVisible(getSkinnable().isFocused());
    getSkinnable().focusedProperty().addListener(focusBorderListener);

    focusTraverseListener = (observable, oldValue, newValue) -> {
        ((RadioButton)oldValue).setFocusTraversable(false);
        ((RadioButton)newValue).setFocusTraversable(true);
    };
    getSkinnable().getToggleGroup().selectedToggleProperty().addListener(focusTraverseListener);

    keyListener = event -> {
        ToggleGroup tg = getSkinnable().getToggleGroup();
        Toggle sel = tg.getSelectedToggle();
        int number = tg.getToggles().indexOf(sel);

        if (event.getCode() == KeyCode.UP) {
            if(number <= tg.getToggles().size() && number>0) {
                getSkinnable().getToggleGroup().selectToggle(tg.getToggles().get(number - 1));
                ((RadioButton)getSkinnable().getToggleGroup().getSelectedToggle()).requestFocus();
            }
        }
        else if (event.getCode() == KeyCode.DOWN) {
            if(number < tg.getToggles().size()-1) {
                getSkinnable().getToggleGroup().selectToggle(getSkinnable().getToggleGroup().getToggles().get(number + 1));
                ((RadioButton)getSkinnable().getToggleGroup().getSelectedToggle()).requestFocus();
            }
        }
    };
    getSkinnable().setOnKeyPressed(keyListener);
}

public static Node getNode(){
    VBox vb = new VBox();

    HBox hb = new HBox();

    final ToggleGroup tg = new ToggleGroup();

    ToggleButton tb1 = new ToggleButton("Blue");
    tb1.setUserData(Color.BLUE);
    tb1.setToggleGroup(tg);
    hb.getChildren().add(tb1);

    ToggleButton tb2 = new ToggleButton("Green");
    tb2.setUserData(Color.GREEN);
    tb2.setToggleGroup(tg);
    hb.getChildren().add(tb2);

    ToggleButton tb3 = new ToggleButton("Yellow");
    tb3.setUserData(Color.YELLOW);
    tb3.setToggleGroup(tg);
    hb.getChildren().add(tb3);

    final Rectangle rect = new Rectangle(240, 100);

    tg.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
        @Override
        public void changed(ObservableValue<? extends Toggle> arg0, Toggle arg1, Toggle arg2) {
            if(tg.selectedToggleProperty()!=null){
                rect.setFill( (Paint)tg.getSelectedToggle().getUserData());
            }
        }
    });
    vb.getChildren().add(hb);
    vb.getChildren().add(rect);


    return vb;
}