javafx.collections.ObservableList Java Examples

private ComboBox<ConstellationColor> makeNamedCombo() {
    final ObservableList<ConstellationColor> namedColors = FXCollections.observableArrayList();
    for (final ConstellationColor c : ConstellationColor.NAMED_COLOR_LIST) {
        namedColors.add(c);
    }
    final ComboBox<ConstellationColor> namedCombo = new ComboBox<>(namedColors);
    namedCombo.setValue(ConstellationColor.WHITE);
    final Callback<ListView<ConstellationColor>, ListCell<ConstellationColor>> cellFactory = (final ListView<ConstellationColor> p) -> new ListCell<ConstellationColor>() {
        @Override
        protected void updateItem(final ConstellationColor item, boolean empty) {
            super.updateItem(item, empty);
            if (item != null) {
                final Rectangle r = new Rectangle(12, 12, item.getJavaFXColor());
                r.setStroke(Color.BLACK);
                setText(item.getName());
                setGraphic(r);
            }
        }
    };
    namedCombo.setCellFactory(cellFactory);
    namedCombo.setButtonCell(cellFactory.call(null));

    return namedCombo;
}
 

/**
 * Sets the list of conversation which can be displayed in this tab.
 * 
 * @param conversations list of conversations
 */
public static void setConversations(ObservableList<Conversation> conversations) {
	instance.conversation.setItems(conversations);
	if (instance.currentConversation != null && conversations.contains(instance.currentConversation)) {
		instance.displayConversation(instance.currentConversation);
	} else {
		instance.displayConversation();
	}
	instance.npc.textProperty().addListener((observable, oldValue, newValue) -> {
	    if (newValue == null || newValue.isEmpty()) {
	    	instance.npc.setStyle("-fx-background-color: red");
	    } else {
	    	instance.npc.setStyle(null);
	    }
	});
}
 

/**
 * Method for generate file items for fileBrowser and add it into container(temporary realization)
 */
private void showContent() {
    ObservableList<FileItem> list = FXCollections.observableArrayList();
    GridView<FileItem> myGrid = new GridView<>(list);
    myGrid.setCellFactory(gridView -> new GridCell<FileItem>() {
        @Override
        public void updateItem(FileItem item, boolean empty) {
            if (empty || item == null) {
                setText(null);
                setGraphic(null);
            } else {
                //setText(item.getName());
                setGraphic(item);
            }

        }
    });
    list.addAll(new FileItem("icon", "Folder1"),
            new FileItem("icon", "Documents"),
            new FileItem("icon", "WorkFiles"),
            new FileItem("icon", "Projects"));
    container.getChildren().add(myGrid);
}
 

/**
 * updates the Save and Load RAM menus so that the the contain a menu item
 * for each RAM in the current machine
 */
private void updateRamMenus() {
    ObservableList<RAM> rams = (ObservableList<RAM>) mediator.getMachine()
            .getModule("rams");
    saveRamMenu.getItems().clear();
    openRamMenu.getItems().clear();

    for (RAM ram : rams) {
        final RAM finalRam = ram;
        MenuItem saveMenuItem = new MenuItem("from " + ram.getName() + "...");
        saveMenuItem.setOnAction(e -> saveRam(finalRam));
        saveRamMenu.getItems().add(saveMenuItem);

        MenuItem openMenuItem = new MenuItem("into " + ram.getName() + "...");
        openMenuItem.setOnAction(e -> openRam(finalRam));
        openRamMenu.getItems().add(openMenuItem);
    }
}
 

protected void drawHorizontalMajorGridLines(final GraphicsContext gc, final Axis yAxis,
        final double xAxisWidthSnapped, final double yAxisHeight) {
    if (!horMajorGridStyleNode.isVisible() && !horMinorGridStyleNode.isVisible()) {
        return;
    }
    final double zeroSnapped = snap(0);
    applyGraphicsStyleFromLineStyle(gc, horMajorGridStyleNode);
    ObservableList<TickMark> tickMarks = yAxis.getTickMarks();
    for (int i = 0; i < tickMarks.size(); i++) {
        double y = snap(yAxis.getDisplayPosition(tickMarks.get(i).getValue()));
        if (y >= 0 && y < yAxisHeight) {
            // gc.strokeLine(zeroSnapped, y, xAxisWidthSnapped, y);
            DashPatternStyle.strokeDashedLine(gc, zeroSnapped, y, xAxisWidthSnapped, y);
        }
    }
}
 

/**
 * Select the item.
 */
@FxThread
private void updateSelection(@NotNull final ObservableValue<? extends TreeItem<TreeNode<?>>> observable,
                             @Nullable final TreeItem<TreeNode<?>> oldValue,
                             @Nullable final TreeItem<TreeNode<?>> treeItem) {

    final ObservableList<TreeItem<TreeNode<?>>> selectedItems = getTreeView()
            .getSelectionModel()
            .getSelectedItems();

    final Array<Object> objects = LocalObjects.get().nextObjectArray();
    objects.clear();

    for (final TreeItem<TreeNode<?>> selectedItem : selectedItems) {
        if (selectedItem == null) continue;
        objects.add(selectedItem.getValue());
    }

    selectionHandler.accept(objects);
}
 

@Override
public ObservableList<TreeItem<File>> getChildren() {
	if (!childrenInitialized) {
		childrenInitialized = true;

		File f = getValue();
		if (f.isDirectory()) {
			File[] files = f.listFiles(filter);
			if (files != null) {
				Arrays.sort(files, FILE_COMPARATOR);
				ArrayList<TreeItem<File>> children = new ArrayList<>();
				for (File file : files)
					children.add(new FileTreeItem(file, filter));
				super.getChildren().setAll(children);
			}
		}
	}
	return super.getChildren();
}
 

public void mbushNgaStatusi(String emri){
    try {
        String sql = "select * from Punet where punetori = '" + emri + "' order by id asc";
        Connection conn = DriverManager.getConnection(CON_STR, "test", "test");
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery(sql);
        ObservableList<TabelaTeDhenatPunetore> data = FXCollections.observableArrayList();
        Format format = new SimpleDateFormat("dd/MM/yyyy");
        String s = "";
        while (rs.next()) {
            s = format.format(rs.getDate("data"));
            data.add(new TabelaTeDhenatPunetore(rs.getInt("id"), rs.getString("lloji"), s,
                    rs.getFloat("qmimi"), rs.getString("konsumatori"), rs.getString("pershkrimi"), rs.getString("kryer"), rs.getString("makina")));
        }

        rs.close();
        stmt.close();
        conn.close();
        table.setItems(data);
    }catch (Exception ex){ex.printStackTrace();}
}
 

/**
 * Sets new table entries for this table, but do not change the structure of the table.
 *
 * @param entries the entries to set
 */
public void updateTable(List<TableEntry> entries) {
    final ObservableList<TableEntry> items = getItems();
    final boolean notHide = !controller.isHideEqualItems();
    items.clear();
    entries.forEach(e -> {
        // there is no harm if this is executed more than once, because only one line is allowed for these
        // two properties (see SingleListenerBooleanProperty for more details)
        e.selectedProperty()
            .addListener((a, o, n) -> selectAllCheckBox.setSelected(n ? selectAllCheckBox.isSelected() : false));
        e.liveStoredEqualProperty().addListener((a, o, n) -> {
            if (controller.isHideEqualItems()) {
                if (n) {
                    getItems().remove(e);
                } else {
                    getItems().add(e);
                }
            }
        });
        if (notHide || !e.liveStoredEqualProperty().get()) {
            items.add(e);
        }
    });
}
 

public static void addIfNotPresent( ObservableList<String> styleClasses,
                                    String... cssClasses ) {
    for ( String cssClass : cssClasses ) {
        if ( !styleClasses.contains( cssClass ) ) {
            styleClasses.add( cssClass );
        }
    }
}
 

/**
 * 選択肢が変更された時の処理
 */
private void change() {
    TypeOption type = this.type.getSelectionModel().getSelectedItem();
    ScaleOption scale = this.term.getSelectionModel().getSelectedItem();

    ZonedDateTime baseDate = scale.convert(ZonedDateTime.now(), type);
    ZonedDateTime min = scale.min(baseDate);
    ZonedDateTime max = scale.max(baseDate);

    Map<ZonedDateTime, Double> data = this.load(type, scale, min, max);

    XYChart.Series<String, Number> series = new XYChart.Series<>();
    series.setName(type.toString());

    boolean stacked = this.stacked.isSelected();
    ObservableList<String> categories = FXCollections.observableArrayList();
    double current = 0D;
    for (Entry<ZonedDateTime, Double> entry : data.entrySet()) {
        String key = scale.getFormat().format(entry.getKey().withZoneSameInstant(ZoneId.of("Asia/Tokyo")));
        if (stacked) {
            current += entry.getValue();
        } else {
            current = entry.getValue();
        }
        categories.add(key);
        series.getData().add(new XYChart.Data<>(key, current));
    }
    this.chart.setTitle(type + "(" + scale + ")");
    this.chart.getData().clear();
    this.xAxis.getCategories().clear();
    this.xAxis.setCategories(categories);
    this.chart.getData().add(series);
}
 

public static final ObservableList<Paint> getStandardFillStyle() {
    final ObservableList<Paint> values = FXCollections.observableArrayList();
    for (Color colour : fillColorProperty().get()) {
        values.add(FillPatternStyleHelper.getDefaultHatch(colour.brighter(), hatchShiftByIndexProperty().get()));
    }
    return values;
}
 

/**
 * Notify about adding the element.
 *
 * @param parent the parent.
 * @param child  the child.
 * @param index  the index.
 */
@FxThread
public void notifyAdded(@Nullable final Object parent, @Nullable final Object child, final int index) {

    if (child == null || parent == null) {
        return;
    }

    final TreeView<TreeNode<?>> treeView = getTreeView();
    final TreeItem<TreeNode<?>> parentItem = findItemForValue(treeView, parent);
    if (parentItem == null || findItemForValue(parentItem, child) != null) {
        return;
    }

    final TreeNode<?> childNode = FACTORY_REGISTRY.createFor(child);
    if (childNode == null) {
        return;
    }

    final TreeNode<?> parentNode = parentItem.getValue();
    parentNode.notifyChildPreAdd(childNode);

    final TreeItem<TreeNode<?>> childItem = new TreeItem<>(childNode);
    final ObservableList<TreeItem<TreeNode<?>>> children = parentItem.getChildren();

    if (index == -1) {
        children.add(childItem);
    } else {
        children.add(index, childItem);
    }

    parentItem.setExpanded(true);
    parentNode.notifyChildAdded(childNode);

    fill(childItem, false, -1);
}
 

@Override
public ObservableList<TreeItem<DirTreeNode>> getChildren() {
    if (isFirstTimeChildren) {
        isFirstTimeChildren = false;
        System.out.println("get children of " + getValue());

        // First getChildren() call, so we actually go off and 
        // determine the children of the File contained in this TreeItem.
        super.getChildren().setAll(buildChildren());
    }
    
    return super.getChildren();
}
 

/** @return Index of the selected tab. -1 if there are no buttons or nothing selected */
public int getSelectedTab()
{
    final ObservableList<Node> siblings = buttons.getChildren();
    for (int i=0; i<siblings.size(); ++i)
        if (((ToggleButton) siblings.get(i)).isSelected())
            return i;
    return -1;
}
 

public void applyCurrentTheme(Stage... stages) {

        ObservableList<EditorConfigBean.Theme> editorTheme = editorConfigBean.getEditorTheme();

        if (editorTheme.isEmpty()) {
            return;
        }

        EditorConfigBean.Theme theme = editorTheme.get(0);
        String themeUri = theme.themeUri();

        if (isNull(themeUri)) {
            return;
        }

        threadService.runActionLater(() -> {
            try {

                String aceTheme = theme.getAceTheme();
//                editorConfigBean.updateAceTheme(aceTheme);

                for (Stage stage : stages) {
                    if (nonNull(stage) && nonNull(stage.getScene())) {
                        ObservableList<String> stylesheets = stage.getScene().getStylesheets();
                        stylesheets.clear();
                        stylesheets.add(themeUri);
                    }
                }

                terminalConfigBean.changeTheme(theme);

            } catch (Exception e) {
                logger.error("Error occured while setting new theme {}", theme);
            }
        });
    }
 

@Test
public void testNavigate() throws IOException {
	ObservableList<Node> pages = getPages();
	assertNotNull(pages);

	/* first page */
	String page_1 = "/testpage1.fxml";
	navigationService.navigate(page_1);
	Mockito.verify(fxmlLoaderProvider, Mockito.times(1)).create(page_1);
	Mockito.verify(fxmlLoader, Mockito.times(1)).load();
	Mockito.verify(controller, Mockito.times(1)).setContent(elements[0]);
	assertTrue(pages.size() == 1);
	assertEquals(pages.get(0), elements[0]);

	/* second page */
	String page_2 = "/testpage2.fxml";
	navigationService.navigate(page_2);
	Mockito.verify(fxmlLoaderProvider, Mockito.times(1)).create(page_2);
	Mockito.verify(fxmlLoader, Mockito.times(2)).load();
	Mockito.verify(controller, Mockito.times(1)).setContent(elements[1]);
	assertTrue(pages.size() == 2);
	assertEquals(pages.get(0), elements[0]);
	assertEquals(pages.get(1), elements[1]);

	/* third page */
	String page_3 = "/testpage3.fxml";
	navigationService.navigate(page_3);
	Mockito.verify(fxmlLoaderProvider, Mockito.times(1)).create(page_3);
	Mockito.verify(fxmlLoader, Mockito.times(3)).load();
	Mockito.verify(controller, Mockito.times(1)).setContent(elements[2]);
	assertTrue(pages.size() == 3);
	assertEquals(pages.get(0), elements[0]);
	assertEquals(pages.get(1), elements[1]);
	assertEquals(pages.get(2), elements[2]);
}
 

/**
 * Set the clones to the new array passed as a parameter.
 * Does not check for validity.
 *
 * @param newClones Object array containing new set of clones
 */
public void setClones(ObservableList newClones)
{
    IO[] ios = new IO[newClones.size()];
    for (int i = 0; i < newClones.size(); i++) {
        ios[i] = (IO) newClones.get(i);
    }
    clones = ios;
}
 

public void deleteRedisKeyAction() {
    ObservableList list = mc.redisValueTable.getSelectionModel().getSelectedItems();
    if (list.isEmpty()) {
        Toast.makeText("请选择要删除的记录").show(mc.pane.getScene().getWindow());
        return;
    }
    StringBuilder key = new StringBuilder();
    int i = 0;
    for (Object object : list) {
        Map mp = (Map) object;
        key.append(mp.get("key"));
        if (i != list.size() - 1) {
            key.append(",");
        }
        i++;
    }
    Alert a = new Alert(Alert.AlertType.CONFIRMATION);
    a.setTitle("确认删除");
    a.setContentText("确认要删除[" + key + "]这些键值吗？");
    a.initOwner(mc.pane.getScene().getWindow());
    Optional<ButtonType> o = a.showAndWait();
    if (o.get().getButtonData().equals(ButtonBar.ButtonData.OK_DONE)) {
        String[] keys = key.toString().split(",");
        String name = (String) mc.redisDatabaseList.getSelectionModel().getSelectedItem();
        RedisUtil.deleteKeys(name, keys);
        Toast.makeText("删除成功", Duration.seconds(1)).show(mc.pane.getScene().getWindow());
        mc.paginationForValue.getPageFactory().call(0);
    }
}
 

/**
 * レベル分布
 * @param ships 対象艦
 */
private void setBubble(List<Ship> ships) {
    this.bubble.getData().clear();

    Map<TypeGroup, List<Integer>> value = ships.stream()
            .collect(Collectors.groupingBy(TypeGroup::toTypeGroup,
                    Collectors.mapping(Ship::getLv, Collectors.toList())));

    for (TypeGroup group : TypeGroup.values()) {
        List<Integer> levels = value.get(group);
        if (levels != null) {
            double average = levels.stream()
                    .mapToInt(Integer::intValue)
                    .average()
                    .orElse(0);
            int size = levels.size();
            levels.sort(Integer::compareTo);
            double median = (size % 2 == 0)
                    ? (double) (levels.get(size / 2) + levels.get(Math.max(size / 2 - 1, 0))) / 2
                    : (double) levels.get(size / 2);

            ObservableList<XYChart.Data<Double, Double>> datas = FXCollections.observableArrayList();
            datas.add(new XYChart.Data<>(average, median, ((double) size) / 5));
            XYChart.Series<Double, Double> series = new XYChart.Series<>(group.name(), datas);
            this.bubble.getData().add(series);
        }
    }
}
 

private void setContent(final Node content) {
    final ObservableList<Node> items = pane.getItems();
    if (items.size() >= 2) {
        items.set(1, content);
    } else {
        items.add(content);
    }
}
 

@Override
public void changeHeight(final double heightDelta) {
	final ObservableList<Double> points = getPoints();
	final List<Double> pointsY = new ArrayList<>();

	for (int i = 1; i < points.size(); i += 2) {
		pointsY.add(points.get(i));
	}

	final double height = Collections.max(pointsY);
	final double scaleFactor = (height + heightDelta) / height;

	setScaleY(getScaleY() * scaleFactor);
}
 

protected void performSelection() {
    if (!(getChart() instanceof XYChart)) {
        return;
    }
    final XYChart xyChart = (XYChart) getChart();

    if (!isShiftDown()) {
        markedPoints.clear();
    }

    findDataPoint(xyChart.getFirstAxis(Orientation.HORIZONTAL), xyChart.getFirstAxis(Orientation.VERTICAL),
            xyChart.getDatasets());

    for (final Renderer rend : xyChart.getRenderers()) {
        final ObservableList<Axis> axes = rend.getAxes();
        findDataPoint(getFirstAxis(axes, Orientation.HORIZONTAL), getFirstAxis(axes, Orientation.VERTICAL),
                rend.getDatasets());
    }

    if (markedPoints.isEmpty()) {
        editEnable.set(false);
    } else {
        editEnable.set(true);
    }

    updateMarker();
}
 

@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;
}
 

private static void calcNoOfNodes(Node node) {
    if (node instanceof Parent) {
        if (((Parent) node).getChildrenUnmodifiable().size() != 0) {
            ObservableList<Node> tempChildren = ((Parent) node).getChildrenUnmodifiable();
            noOfNodes += tempChildren.size();
            for (Node n : tempChildren) {
                calcNoOfNodes(n);
                //System.out.println(n.getStyleClass().toString());
            }
        }
    }
}
 

@Test
public void idempotentSetLengthOffsetTest() {
    // create VirtualFlow with 1 big cell
    Rectangle rect = new Rectangle(500, 500);
    ObservableList<Rectangle> items = FXCollections.singletonObservableList(rect);
    VirtualFlow<Rectangle, Cell<Rectangle, Rectangle>> vf = VirtualFlow.createVertical(items, Cell::wrapNode);
    vf.resize(100, 100); // size of VirtualFlow less than that of the cell
    vf.layout();

    vf.setLengthOffset(10.0);
    vf.setLengthOffset(10.0);
    vf.layout();
    assertEquals(-10.0, rect.getBoundsInParent().getMinY(), 0.01);
}
 

private void onManageFavourites() {
    FavouriteHistoryStage favouriteHistoryStage = new FavouriteHistoryStage(new RunHistoryInfo("favourites"));
    favouriteHistoryStage.getStage().showAndWait();
    ObservableList<JSONObject> items = historyView.getItems();
    items.clear();
    items.addAll(runHistoryInfo.getTests());
}
 

public static void setJournal(ObservableList<JournalEntry> journal) {
	instance.journalList.setCellFactory(param -> new DraggableListCell<>());
	instance.journalList.setItems(journal);
	instance.journalList.getSelectionModel().selectedItemProperty().addListener(event -> {
		instance.selectEntry();
	});
	instance.journalList.setOnMouseClicked(event -> {
		if (event.getButton() == MouseButton.PRIMARY && event.getClickCount() == 2) {
			instance.editEntry();
		}
	});
}
 

@Test
public void testMaxCharactersForBuyPriceWithNoOffers() {
    OfferBook offerBook = mock(OfferBook.class);
    final ObservableList<OfferBookListItem> offerBookListItems = FXCollections.observableArrayList();

    when(offerBook.getOfferBookListItems()).thenReturn(offerBookListItems);

    final OfferBookChartViewModel model = new OfferBookChartViewModel(offerBook, empty, null, null, null);
    assertEquals(0, model.maxPlacesForBuyPrice.intValue());
}
 

private void populateSongTable(VBox cell, Album selectedAlbum) { 	
	// Retrieves albums songs and stores them as an observable list.
	ObservableList<Song> albumSongs = FXCollections.observableArrayList(selectedAlbum.getSongs());
	
    playingColumn.setCellFactory(x -> new PlayingTableCell<Song, Boolean>());
    titleColumn.setCellFactory(x -> new ControlPanelTableCell<Song, String>());
    lengthColumn.setCellFactory(x -> new ClippedTableCell<Song, String>());
    playsColumn.setCellFactory(x -> new ClippedTableCell<Song, Integer>());

    // Sets each column item.
    playingColumn.setCellValueFactory(new PropertyValueFactory<Song, Boolean>("playing"));
    titleColumn.setCellValueFactory(new PropertyValueFactory<Song, String>("title"));
    lengthColumn.setCellValueFactory(new PropertyValueFactory<Song, String>("length"));
    playsColumn.setCellValueFactory(new PropertyValueFactory<Song, Integer>("playCount"));
    
    // Adds songs to table.
    songTable.setItems(albumSongs);
    double height = (albumSongs.size() + 1) * 50 + 2;
    Animation songTableLoadAnimation = new Transition() {
    	{
    		setCycleDuration(Duration.millis(250));
            setInterpolator(Interpolator.EASE_BOTH);
    	}
    	
    	protected void interpolate(double frac) {
    		songTable.setMinHeight(frac * height);
            songTable.setPrefHeight(frac * height);
    	}
    };
    songTableLoadAnimation.play();
}