javafx.scene.control.Skin#javafx.scene.control.ComboBox源码实例Demo

/**
 * Fill Ethernet mac information
 */
private void setEthernetMacInfo() {
    clickOn("#protocolDataTab");
    waitForNode("Media Access Protocol");
    clickOn("Media Access Protocol");
    waitForNode("#macDstAddress");
    interact(() -> {
        TextField macDstAddress = find(("#macDstAddress"));
        macDstAddress.setText("12:00:00:00:00:22");

        ComboBox dstMode = find("#macDstMode");
        dstMode.getSelectionModel().select("Fixed");

        TextField macSrcAddress = find(("#macSrcAddress"));
        macSrcAddress.setText("22:00:00:00:00:00");

        ComboBox srcMode = find("#macsrcMode");
        srcMode.getSelectionModel().select("Increment");
    });
}
 

public RTToleranceEditor(PropertySheet.Item parameter) {
  if (!(parameter instanceof RTToleranceParameter))
    throw new IllegalArgumentException();

  // The value field
  valueField = new TextField();

  // The combo box
  ObservableList<String> options =
      FXCollections.observableArrayList("Absolute (sec)", "Relative (%)");
  comboBox = new ComboBox<String>(options);

  // FlowPane setting
  setHgap(10);

  // Add the elements
  getChildren().addAll(valueField, comboBox);
}
 

private void setTableData(List<List<String>> data) {
    tableData = new ObservableListWrapper<>(data);
    int numberOfColumns = data.stream().map(List::size).reduce(Math::max).orElse(0);
    contentTable.getColumns().clear();
    colMapping = new ArrayList<>();
    for (int i = 0; i < numberOfColumns; i++) {
        colMapping.add(DONT_USE);
        TableColumn<List<String>, String> column = new TableColumn<>();
        final int index = i;
        ComboBox<String> selector = generateVariableSelector();
        selector.getSelectionModel().selectedItemProperty().
                addListener((prop, oldValue, newValue) -> colMapping.set(index, newValue));
        column.setGraphic(selector);
        column.setCellValueFactory((TableColumn.CellDataFeatures<List<String>, String> param) -> {
            List<String> row = param.getValue();
            String value = row.size() > index ? row.get(index) : null;
            return new SimpleStringProperty(value);
        });
        contentTable.getColumns().add(column);
    }
    contentTable.setItems(tableData);
}
 

public CreateTerrainDialog(@NotNull final TreeNode<?> parentNode, @NotNull final NodeTree<?> nodeTree) {
    this.parentNode = parentNode;
    this.nodeTree = nodeTree;

    final ComboBox<Integer> totalSizeComboBox = getTotalSizeComboBox();
    totalSizeComboBox.getSelectionModel().select(DEFAULT_TOTAL_SIZE);

    final ComboBox<Integer> patchSizeComboBox = getPatchSizeComboBox();
    patchSizeComboBox.getSelectionModel().select(DEFAULT_PATH_SIZE);

    final ComboBox<Integer> alphaBlendTextureSizeComboBox = getAlphaBlendTextureSizeComboBox();
    alphaBlendTextureSizeComboBox.getSelectionModel().select(DEFAULT_BLEND_TEXTURE_SIZE);

    final ComboBox<HeightMapType> heightMapTypeComboBox = getHeightMapTypeComboBox();
    heightMapTypeComboBox.getSelectionModel().select(HeightMapType.FLAT);

    updatePathSizeValues();
}
 

public String getComboBoxText(ComboBox<?> comboBox, int index, boolean appendText) {
    if (index == -1) {
        return null;
    }
    String original = getComboBoxItemText(comboBox, index);
    String itemText = original;
    int suffixIndex = 0;
    for (int i = 0; i < index; i++) {
        String current = getComboBoxItemText(comboBox, i);
        if (current.equals(original)) {
            if (appendText) {
                itemText = String.format("%s(%d)", original, ++suffixIndex);
            } else {
                itemText = original;
            }
        }
    }
    return itemText;
}
 

public void createRoutePane() {
	routeVbox = addVBox("select route");
	fromLocation = new ComboBox<String>();
	fromLocation.setOnAction(λ -> map.hideDirectionsPane());
	toLocation = new ComboBox<String>();
	toLocation.setOnAction(λ -> map.hideDirectionsPane());
	final Button btn = new Button("draw");
	btn.setOnAction(e -> {
		if (toLocation.getSelectionModel().getSelectedItem() == null
				|| fromLocation.getSelectionModel().getSelectedItem() == null)
			return;
		final MyMarker to = getMarkerByTitle(toLocation.getSelectionModel().getSelectedItem()),
				from = getMarkerByTitle(fromLocation.getSelectionModel().getSelectedItem());
		directionsService.getRoute(
				new DirectionsRequest(from.lat.getLatitude() + ", " + from.lat.getLongitude(),
						to.lat.getLatitude() + ", " + to.lat.getLongitude(), TravelModes.DRIVING),
				this, new DirectionsRenderer(true, mapComponent.getMap(), directionsPane));
	});
	final Button removeBtn = new Button("remove line");
	removeBtn.setOnAction(λ -> map.hideDirectionsPane());
	routeVbox.getChildren().addAll(fromLocation, toLocation, btn, removeBtn);

}
 

private JFXPanel createJFXPanel(){
    final JFXPanelEx panel = new JFXPanelEx();
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            final VBox vbox = new VBox();
            final ComboBox<String> combo = new ComboBox<String>();
            for (int i = 0; i< 101; i++){
                combo.getItems().add("text" + i);
            }
            vbox.getChildren().addAll(combo);
            final Scene scene = new Scene(vbox);
            panel.setScene(scene);
        };
    });
    return panel;
}
 

ComboBox<Country> addCountrySelection() {
    HBox hBox = new HBox();

    hBox.setSpacing(5);
    ComboBox<Country> countryComboBox = new JFXComboBox<>();
    hBox.getChildren().add(countryComboBox);

    addTopLabelWithVBox(gridPane, ++gridRow, Res.get("payment.bank.country"), hBox, 0);

    countryComboBox.setPromptText(Res.get("payment.select.bank.country"));
    countryComboBox.setConverter(new StringConverter<>() {
        @Override
        public String toString(Country country) {
            return country.name + " (" + country.code + ")";
        }

        @Override
        public Country fromString(String s) {
            return null;
        }
    });
    return countryComboBox;
}
 

/**
 * Update a list of available path sizes.
 */
@FxThread
private void updatePathSizeValues() {

    final ComboBox<Integer> pathSizeComboBox = getPatchSizeComboBox();
    final SingleSelectionModel<Integer> selectionModel = pathSizeComboBox.getSelectionModel();
    final Integer current = selectionModel.getSelectedItem();

    final ObservableList<Integer> items = pathSizeComboBox.getItems();
    items.clear();

    final ComboBox<Integer> totalSizeComboBox = getTotalSizeComboBox();
    final Integer naxValue = totalSizeComboBox.getSelectionModel().getSelectedItem();

    for (final Integer value : PATCH_SIZE_VARIANTS) {
        if (value >= naxValue) break;
        items.add(value);
    }

    if (items.contains(current)) {
        selectionModel.select(current);
    } else {
        selectionModel.select(items.get(items.size() - 1));
    }
}
 

@Override
@FxThread
protected void createComponents(@NotNull HBox container) {
    super.createComponents(container);

    enumComboBox = new ComboBox<>();
    enumComboBox.prefWidthProperty()
            .bind(widthProperty().multiply(CONTROL_WIDTH_PERCENT));

    FxControlUtils.onSelectedItemChange(enumComboBox, this::change);

    FxUtils.addClass(enumComboBox,
            CssClasses.PROPERTY_CONTROL_COMBO_BOX);

    FxUtils.addChild(container, enumComboBox);
}
 

@Test
public void selectMultipleDuplicateOption() {
    @SuppressWarnings("unchecked")
    ComboBox<String> comboNode = (ComboBox<String>) getPrimaryStage().getScene().getRoot().lookup(".combo-box");
    IJavaFXElement comboBox = combos.get(0);
    Platform.runLater(() -> {
        comboNode.getItems().add(3, "Option 2");
        comboNode.getItems().add(5, "Option 2");
        comboBox.marathon_select("Option 2(2)");
    });
    new Wait("Waiting for combo box option to be set.") {
        @Override
        public boolean until() {
            return comboNode.getSelectionModel().getSelectedIndex() == 5;
        }
    };
}
 

public static boolean setStyle(Node node, String style) {
    try {
        if (node == null) {
            return false;
        }
        if (node instanceof ComboBox) {
            ComboBox c = (ComboBox) node;
            c.getEditor().setStyle(style);
        } else {
            node.setStyle(style);
        }
        return true;
    } catch (Exception e) {
        return false;
    }
}
 

@NotNull
public static <T> ListCell<T> getComboBoxButtonCell(String title,
                                                    ComboBox<T> comboBox,
                                                    Boolean hideOriginalPrompt) {
    return new ListCell<>() {
        @Override
        protected void updateItem(T item, boolean empty) {
            super.updateItem(item, empty);

            // See https://github.com/jfoenixadmin/JFoenix/issues/610
            if (hideOriginalPrompt)
                this.setVisible(item != null || !empty);

            if (empty || item == null) {
                setText(title);
            } else {
                setText(comboBox.getConverter().toString(item));
            }
        }
    };
}
 

public final void filterUI(){
        GridPane gridLEFT = new GridPane();
        // Labels
        Label stopwordsLabel = new Label("Stop words removal");
        UIUtils.setSize(stopwordsLabel, Main.columnWidthLEFT/2, 24);
        Label resizingLabel = new Label("Resizing");
        UIUtils.setSize(resizingLabel, Main.columnWidthLEFT/2, 24);
        gridLEFT.add(stopwordsLabel,0,0);
        gridLEFT.add(new Rectangle(0,3),0,1);
        gridLEFT.add(resizingLabel,0,2);
        
        // Values
        stopwordLists = new StopwordSets();
        stopwordListsCheckComboBox = new CheckComboBox<>(stopwordLists.availableSets);
        stopwordListsCheckComboBox.setStyle("-fx-font-size: 12px;"); 
        stopwordListsCheckComboBox.skinProperty().addListener(new ChangeListener<Skin>() {
        @Override
        public void changed(ObservableValue<? extends Skin> observable, Skin oldValue, Skin newValue) {
             if(oldValue==null && newValue!=null){
                 CheckComboBoxSkin skin = (CheckComboBoxSkin)newValue;
                 ComboBox combo = (ComboBox)skin.getChildren().get(0);
                 combo.setPrefWidth(Main.columnWidthLEFT/2);
                 combo.setMaxWidth(Double.MAX_VALUE);
             }
        }
});
//        stopwordListsCheckComboBox.setMaxWidth(Double.MAX_VALUE);
                
//        UIUtils.setSize(stopwordListsCheckComboBox,Main.columnWidthLEFT/2, 24);
        gridLEFT.add(stopwordListsCheckComboBox,1,0);
        resizeSlider = new RangeSlider();
        resizeSlider.setBlockIncrement(0.1);
        UIUtils.setSize(resizeSlider,Main.columnWidthLEFT/2, 24);
        resizeSlider.resize(Main.columnWidthLEFT/2, 24);
        gridLEFT.add(resizeSlider,1,2);

        HBox filterDatasetBOTH = new HBox(5);
        filterDatasetBOTH.getChildren().addAll(gridLEFT,createFilterButton());
        grid.add(filterDatasetBOTH,0,11);
    }
 

private ComboBox<String> generateVariableSelector() {
    Set vars = new TreeSet<>();
    actions.stream().map(action -> ActionUtils.getVariableNames(action)).forEach(vars::addAll);
    ComboBox<String> box = new ComboBox<>();
    vars.add(DONT_USE);
    box.getItems().addAll(vars);
    return box;
}
 

@Override
protected Node createEditorControls() {
    final GridPane controls = new GridPane();
    controls.setAlignment(Pos.CENTER);
    controls.setHgap(CONTROLS_DEFAULT_HORIZONTAL_SPACING);

    final Label connectionModeLabel = new Label("Connection Mode:");
    final ObservableList<ConnectionMode> connectionModes = FXCollections.observableArrayList(ConnectionMode.values());
    connectionModeComboBox = new ComboBox<>(connectionModes);
    final Callback<ListView<ConnectionMode>, ListCell<ConnectionMode>> cellFactory = (final ListView<ConnectionMode> p) -> new ListCell<ConnectionMode>() {
        @Override
        protected void updateItem(final ConnectionMode item, boolean empty) {
            super.updateItem(item, empty);
            if (item != null) {
                setText(item.name());
            }
        }
    };
    connectionModeComboBox.setCellFactory(cellFactory);
    connectionModeComboBox.setButtonCell(cellFactory.call(null));
    connectionModeLabel.setLabelFor(connectionModeComboBox);
    connectionModeComboBox.getSelectionModel().selectedItemProperty().addListener((o, n, v) -> {
        update();
    });

    controls.addRow(0, connectionModeLabel, connectionModeComboBox);
    return controls;
}
 

@Override
protected Node createEditorControls() {
    final VBox controls = new VBox();
    controls.setSpacing(CONTROLS_DEFAULT_VERTICAL_SPACING);
    controls.setAlignment(Pos.CENTER);

    final ObservableList<ZoneId> timeZones = FXCollections.observableArrayList();
    ZoneId.getAvailableZoneIds().forEach(id -> {
        timeZones.add(ZoneId.of(id));
    });
    timeZoneComboBox = new ComboBox<>();
    timeZoneComboBox.setItems(timeZones.sorted(zoneIdComparator));
    final Callback<ListView<ZoneId>, ListCell<ZoneId>> cellFactory = (final ListView<ZoneId> p) -> new ListCell<ZoneId>() {
        @Override
        protected void updateItem(final ZoneId item, boolean empty) {
            super.updateItem(item, empty);
            if (item != null) {
                setText(TimeZoneUtilities.getTimeZoneAsString(item));
            }
        }
    };
    timeZoneComboBox.setCellFactory(cellFactory);
    timeZoneComboBox.setButtonCell(cellFactory.call(null));
    timeZoneComboBox.getSelectionModel().select(TimeZone.getTimeZone(ZoneOffset.UTC).toZoneId());
    timeZoneComboBox.getSelectionModel().selectedItemProperty().addListener((o, n, v) -> {
        update();
    });

    controls.getChildren().addAll(timeZoneComboBox);
    return controls;
}
 

@Override
protected Node createEditorControls() {
    final GridPane controls = new GridPane();
    controls.setAlignment(Pos.CENTER);
    controls.setHgap(CONTROLS_DEFAULT_HORIZONTAL_SPACING);

    final Label lineStyleLabel = new Label("Line Style:");
    final ObservableList<LineStyle> lineStyles = FXCollections.observableArrayList(LineStyle.values());
    lineStyleComboBox = new ComboBox<>(lineStyles);
    final Callback<ListView<LineStyle>, ListCell<LineStyle>> cellFactory = (final ListView<LineStyle> p) -> new ListCell<LineStyle>() {
        @Override
        protected void updateItem(final LineStyle item, boolean empty) {
            super.updateItem(item, empty);
            if (item != null) {
                setText(item.name());
            }
        }
    };
    lineStyleComboBox.setCellFactory(cellFactory);
    lineStyleComboBox.setButtonCell(cellFactory.call(null));
    lineStyleLabel.setLabelFor(lineStyleComboBox);
    lineStyleComboBox.getSelectionModel().selectedItemProperty().addListener((o, n, v) -> {
        update();
    });

    controls.addRow(0, lineStyleLabel, lineStyleComboBox);
    return controls;
}
 

public PaintingComponentContainer(@NotNull ModelChangeConsumer changeConsumer, @NotNull Editor3DProvider provider) {
    this.changeConsumer = changeConsumer;
    this.provider = provider;
    this.container = new VBox();
    this.container.prefWidthProperty()
            .bind(widthProperty().subtract(FxConstants.PROPERTY_LIST_OFFSET));

    var toolTypeContainer = new HBox();
    toolTypeContainer.prefWidthProperty()
            .bind(widthProperty().subtract(FxConstants.PROPERTY_LIST_OFFSET));

    var label = new Label(Messages.PAINTING_COMPONENT_CONTAINER_TOOL + ":");
    label.maxWidthProperty().bind(toolTypeContainer.widthProperty()
            .multiply(LABEL_PERCENT));

    componentBox = new ComboBox<>();
    componentBox.setCellFactory(PaintingComponentListCell::new);
    componentBox.setButtonCell(new PaintingComponentListCell(null));
    componentBox.setPromptText("No tools");
    componentBox.prefWidthProperty().bind(toolTypeContainer.widthProperty()
            .multiply(FIELD_PERCENT));
    componentBox.getSelectionModel()
            .selectedItemProperty()
            .addListener(this::activate);

    var resultContainer = new VBox();

    setContent(resultContainer);

    FxUtils.addClass(container, CssClasses.DEF_VBOX)
            .addClass(toolTypeContainer, CssClasses.DEF_HBOX)
            .addClass(resultContainer, CssClasses.PAINTING_COMPONENT_ROOT);

    FxUtils.addChild(toolTypeContainer, label, componentBox)
            .addChild(resultContainer, toolTypeContainer, container);

    var registry = PaintingComponentRegistry.getInstance();

    this.components = registry.createComponents(this);
}
 

@Test
@Category(NoHeadless.class)
public void reset() {
    clickOn(victim);
    clickOn("#combo").clickOn("Odd pages");
    ComboBox<KeyStringValueItem<PredefinedSetOfPages>> combo = lookup("#combo").queryComboBox();
    assertEquals(PredefinedSetOfPages.ODD_PAGES, combo.getSelectionModel().getSelectedItem().getKey());
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> victim.resetView());
    assertEquals(PredefinedSetOfPages.ALL_PAGES, combo.getSelectionModel().getSelectedItem().getKey());
}
 

@Override
@FxThread
protected void createComponents() {
    super.createComponents();

    comboBox = new ComboBox<>();
    comboBox.getItems().addAll(FONTS);
    comboBox.setVisibleRowCount(20);
    comboBox.setConverter(STRING_CONVERTER);
    comboBox.setEditable(true);
    comboBox.prefWidthProperty()
            .bind(widthProperty().multiply(DEFAULT_FIELD_W_PERCENT));

    var selectionModel = comboBox.getSelectionModel();

    var editor = comboBox.getEditor();
    var binding = new AutoCompletionTextFieldBinding<Font>(editor,
            new AwtFontSuggestionProvider(comboBox.getItems()), STRING_CONVERTER);
    binding.setOnAutoCompleted(event -> selectionModel.select(event.getCompletion()));
    binding.prefWidthProperty().bind(comboBox.widthProperty().multiply(1.3));

    FxControlUtils.onSelectedItemChange(comboBox, newValue -> {
        var executorManager = ExecutorManager.getInstance();
        executorManager.addFxTask(() -> editor.positionCaret(newValue.getFontName().length()));
    });

    FxControlUtils.onSelectedItemChange(comboBox, this::change);

    FxUtils.addClass(editor,
                    CssClasses.TRANSPARENT_TEXT_FIELD, CssClasses.TEXT_FIELD_IN_COMBO_BOX)
            .addClass(comboBox,
                    CssClasses.PROPERTY_CONTROL_COMBO_BOX);

    FxUtils.addChild(this, comboBox);
}
 

void setCountryComboBoxAction(ComboBox<Country> countryComboBox) {
    countryComboBox.setOnAction(e -> {
        selectedCountry = countryComboBox.getSelectionModel().getSelectedItem();
        updateFromInputs();
        accountIdInputTextField.resetValidation();
        accountIdInputTextField.validate();
        accountIdInputTextField.requestFocus();
        countryComboBox.requestFocus();
    });
}
 

public HistogramRangeEditor() {

    dataTypeCombo = new ComboBox<HistogramDataType>(
        FXCollections.observableArrayList(HistogramDataType.values()));
    dataTypeCombo.setOnAction(e -> {
      HistogramDataType selectedType = dataTypeCombo.getSelectionModel().getSelectedItem();
      if (selectedType == null)
        return;

      switch (selectedType) {
        case MASS:
          dataRangeComponent.setNumberFormat(MZmineCore.getConfiguration().getMZFormat());
          return;
        case HEIGHT:
        case AREA:
          dataRangeComponent.setNumberFormat(MZmineCore.getConfiguration().getIntensityFormat());
          return;
        case RT:
          dataRangeComponent.setNumberFormat(MZmineCore.getConfiguration().getRTFormat());
          return;
      }
    });
    setLeft(dataTypeCombo);

    dataRangeComponent = new DoubleRangeComponent(NumberFormat.getNumberInstance());
    setCenter(dataRangeComponent);

  }
 

@Override
public ComboBox<ColoringType> createEditingComponent() {
  ObservableList<ColoringType> choicesList = FXCollections.observableArrayList();
  choicesList.add(ColoringType.NOCOLORING);
  choicesList.add(ColoringType.COLORBYFILE);
  for (UserParameter<?, ?> p : MZmineCore.getProjectManager().getCurrentProject()
      .getParameters()) {
    choicesList.add(new ColoringType(p));
  }
  ComboBox<ColoringType> editor = new ComboBox<ColoringType>(choicesList);
  if (value != null)
    editor.getSelectionModel().select(value);
  return editor;
}
 

public RegisterController(GridPane registerPane, ComboBox<String> registerModeBox, Machine machine) {
    this.registerPane = registerPane;
    this.machine = machine;
    this.registerModeBox = registerModeBox;
    //machine.addRegisterListener(this);
    initView();
    TimingRenderer.register(this);
}
 

@Test
public void restoreStateFrom() {
    ComboBox<KeyStringValueItem<PredefinedSetOfPages>> rotationType = lookup("#rotationType").queryComboBox();
    ComboBox<KeyStringValueItem<Rotation>> rotation = lookup("#rotation").queryComboBox();
    Map<String, String> data = new HashMap<>();
    data.put("rotation", Rotation.DEGREES_270.toString());
    data.put("rotationType", PredefinedSetOfPages.EVEN_PAGES.toString());
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> victim.restoreStateFrom(data));
    assertEquals(Rotation.DEGREES_270, rotation.getSelectionModel().getSelectedItem().getKey());
    assertEquals(PredefinedSetOfPages.EVEN_PAGES, rotationType.getSelectionModel().getSelectedItem().getKey());
}
 

@Override
protected int internalInitPanel(GridPane pane, int idx) {
    idx++;
    pane.add(new Label("Responses"), 0, idx);
    ObservableList<BooleanNaming> list = FXCollections.observableArrayList(BooleanNaming.values());
    namingBox = new ComboBox<>(list);
    namingBox.getSelectionModel().select(getMenuItem().getNaming());
    namingBox.valueProperty().addListener((observable, oldValue, newValue) -> callChangeConsumer());
    pane.add(namingBox, 1, idx);
    return idx;
}
 

public static <T> Tuple4<Label, TextField, Label, ComboBox<T>> addTopLabelTextFieldAutocompleteComboBox(
        GridPane gridPane,
        int rowIndex,
        String titleTextfield,
        String titleCombobox
        )
{
    return addTopLabelTextFieldAutocompleteComboBox(gridPane, rowIndex, titleTextfield, titleCombobox, 0);
}
 

public static <T> Tuple3<VBox, Label, ComboBox<T>> addTopLabelComboBox(String title, String prompt, int top) {
    Label label = getTopLabel(title);
    VBox vBox = getTopLabelVBox(top);

    final JFXComboBox<T> comboBox = new JFXComboBox<>();
    comboBox.setPromptText(prompt);

    vBox.getChildren().addAll(label, comboBox);

    return new Tuple3<>(vBox, label, comboBox);
}
 

private void setShaftType(Button editShaft, Button newShaft, final ComboBox<String> shaftSize,
		String selectedItem) {
	shaftSize.getItems().clear();
	if (selectedItem == null)
		return;
	for (String s : Vitamins.listVitaminSizes(selectedItem)) {
		shaftSize.getItems().add(s);
	}
	newShaft.setText("New " + selectedItem);
	// editShaft.setText("Edit "+ conf.getShaftSize());
}