Java EventStreams类代码示例

import org.reactfx.EventStreams; //导入依赖的package包/类
private C cellForItem(JsonNode item) {
    C cell = cellPool.getCell(item);

    // apply CSS when the cell is first added to the scene
    Node node = cell.getNode();
    EventStreams.nonNullValuesOf(node.sceneProperty())
                .subscribeForOne(scene -> {
                    node.applyCss();
                });

    // Make cell initially invisible.
    // It will be made visible when it is positioned.
    node.setVisible(false);

    return cell;
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private void setupListeners() {
    ObjectProperty<Point2D> mouseDown = new SimpleObjectProperty<>();

    EventStreams.eventsOf(imageView, MouseEvent.MOUSE_PRESSED).subscribe(e -> {
        Point2D mousePress = imageViewToImage(new Point2D(e.getX(), e.getY()));
        mouseDown.set(mousePress);
    });

    EventStreams.eventsOf(imageView, MouseEvent.MOUSE_DRAGGED).subscribe(e -> {
        Point2D dragPoint = imageViewToImage(new Point2D(e.getX(), e.getY()));
        shift(dragPoint.subtract(mouseDown.get()));
        mouseDown.set(imageViewToImage(new Point2D(e.getX(), e.getY())));
    });

    EventStream<ScrollEvent> scrollEvents = EventStreams.eventsOf(imageView, ScrollEvent.SCROLL);
    EventStream<ScrollEvent> scrollEventsUp = scrollEvents.filter(scrollEvent -> scrollEvent.getDeltaY() < 0);
    EventStream<ScrollEvent> scrollEventsDown = scrollEvents.filter(scrollEvent -> scrollEvent.getDeltaY() > 0);
    scrollEventsUp.subscribe(scrollEvent -> scale = Math.min(scale + 0.25, 3));
    scrollEventsDown.subscribe(scrollEvent -> scale = Math.max(scale - 0.25, 0.25));
    EventStreams.merge(scrollEventsUp, scrollEventsDown).subscribe(scrollEvent -> scaleImageViewport(scale));

    EventStreams.eventsOf(imageView, MouseEvent.MOUSE_CLICKED)
            .filter(mouseEvent -> mouseEvent.getClickCount() == 2)
            .subscribe(mouseEvent -> fitToView());
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private void setupNvidiaListener() {
    log.log(Level.FINER, "Setting nvidia ram listener.");
    EventStreams.nonNullValuesOf(nvidiaService.progressProperty())
            .filter(vramUsage -> vramUsage.doubleValue() > 0)
            .subscribe(vramUsage -> vramBar.setProgress(vramUsage.doubleValue()));

    log.log(Level.FINER, "Setting nvidia timer.");
    nvidiaTimer = FxTimer.createPeriodic(Duration.ofMillis(1000), () -> {
        log.log(Level.FINER, "Timer: checking service");
        if (nvidiaService == null || nvidiaService.isRunning())
            return;

        log.log(Level.FINER, "Timer: starting service");
        nvidiaService.restart();
        nvidiaTimer.restart();
    });
    nvidiaTimer.restart();
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private C cellForItem(T item) {
    C cell = cellPool.getCell(item);

    // apply CSS when the cell is first added to the scene
    Node node = cell.getNode();
    EventStreams.nonNullValuesOf(node.sceneProperty())
            .subscribeForOne(scene -> {
                node.applyCss();
            });

    // Make cell initially invisible.
    // It will be made visible when it is positioned.
    node.setVisible(false);

    return cell;
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@Test
public void test() {
    IntegerProperty src = new SimpleIntegerProperty(0);
    IntegerBinding twice = src.multiply(2);
    Var<Number> twiceVar = Var.fromVal(twice, n -> src.set(n.intValue() / 2));

    List<Number> values = new ArrayList<>();
    EventStreams.valuesOf(twiceVar).subscribe(values::add);

    src.set(1);
    twiceVar.setValue(4);
    twiceVar.setValue(5); // no effect
    twiceVar.setValue(7); // will become 6

    assertEquals(Arrays.asList(0, 2, 4, 6), values);
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@Test
public void testEqualNumberOfFramesForFixedDuration() throws InterruptedException, ExecutionException, TimeoutException {
    Var<Double> src1 = Var.newSimpleVar(0.0);
    Var<Double> src2 = Var.newSimpleVar(0.0);
    Val<Double> anim1 = src1.animate(Duration.ofMillis(500), Interpolator.LINEAR_DOUBLE);
    Val<Double> anim2 = src2.animate(Duration.ofMillis(500), Interpolator.LINEAR_DOUBLE);
    List<Double> vals1 = new ArrayList<>();
    List<Double> vals2 = new ArrayList<>();

    Platform.runLater(() -> {
        EventStreams.valuesOf(anim1).subscribe(vals1::add);
        EventStreams.valuesOf(anim2).subscribe(vals2::add);

        src1.setValue(10.0);
        src2.setValue(20.0);
    });

    waitUntil(anim1, x -> x == 10.0, 1000);
    waitUntil(anim2, x -> x == 20.0, 100);

    assertEquals(vals1.size(), vals2.size());
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@Test
public void testProportionalNumberOfFramesForFixedSpeed() throws InterruptedException, ExecutionException, TimeoutException {
    Var<Integer> src1 = Var.newSimpleVar(0);
    Var<Integer> src2 = Var.newSimpleVar(0);
    Val<Integer> anim1 = src1.animate((a, b) -> Duration.ofMillis(b - a), Interpolator.LINEAR_INTEGER);
    Val<Integer> anim2 = src2.animate((a, b) -> Duration.ofMillis(b - a), Interpolator.LINEAR_INTEGER);
    List<Integer> vals1 = new ArrayList<>();
    List<Integer> vals2 = new ArrayList<>();

    Platform.runLater(() -> {
        EventStreams.valuesOf(anim1).subscribe(vals1::add);
        EventStreams.valuesOf(anim2).subscribe(vals2::add);

        src1.setValue(100);
        src2.setValue(300);
    });

    waitUntil(anim2, x -> x == 300, 1000);

    assertEquals(100, anim1.getValue().intValue());

    // test that the number of frames for 0 -> 300 is at least
    // twice the number of frames for 0 -> 100 (i.e. a conservative test)
    assertThat(vals2.size(), greaterThan(2 * vals1.size()));
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@Test
public void midAnimationChangeTest() throws InterruptedException, ExecutionException, TimeoutException {
    Var<Double> src = Var.newSimpleVar(100.0);
    Val<Double> anim = src.animate(Duration.ofMillis(200), Interpolator.EASE_BOTH_DOUBLE);
    List<Double> vals = new ArrayList<>();

    Platform.runLater(() -> {
        EventStreams.valuesOf(anim).subscribe(vals::add);

        // when animated value reaches 200.0, set src to -1.0
        anim.addListener((obs, old, newVal) -> {
            if(newVal >= 200.0) {
                src.setValue(-1.0);
            }
        });

        src.setValue(300.0);
    });

    waitUntil(anim, x -> x == -1.0, 1000);

    assertTrue("Value 300.0 never reached", vals.stream().noneMatch(x -> x == 300.0));
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@Test
public void test() {
    ObservableList<Integer> list = FXCollections.observableArrayList();
    Val<Integer> size = LiveList.sizeOf(list);
    List<Integer> sizes = new ArrayList<>();
    Subscription sub = EventStreams.valuesOf(size).subscribe(sizes::add);
    list.add(1);
    list.addAll(2, 3, 4);
    assertEquals(Arrays.asList(0, 1, 4), sizes);

    sub.unsubscribe();
    sizes.clear();
    list.addAll(5, 6);
    assertEquals(Arrays.asList(), sizes);

    EventStreams.valuesOf(size).subscribe(sizes::add);
    list.addAll(7, 8);
    assertEquals(Arrays.asList(6, 8), sizes);
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@Override
public void start(Stage primaryStage) {
    TextArea textArea = new TextArea();
    WebView webView = new WebView();
    WebEngine engine = webView.getEngine();

    EventStreams.valuesOf(textArea.textProperty())
            .successionEnds(Duration.ofMillis(500))
            .subscribe(html -> engine.loadContent(html));

    SplitPane root = new SplitPane();
    root.getItems().addAll(textArea, webView);
    Scene scene = new Scene(root);
    primaryStage.setScene(scene);
    primaryStage.show();
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
public void setNeuralImage(NeuralImage newNeuralImage) {
    // Remove previous bindings if applicable
    image.imageProperty().unbind();
    if (neuralImage != null)
        selected.selectedProperty().unbindBidirectional(neuralImage.selectedProperty());
    if (weightChanges != null)
        weightChanges.unsubscribe();

    neuralImage = newNeuralImage;

    if (neuralImage != null) {
        // Bind Image and Selection
        image.imageProperty().bind(neuralImage.imageProperty());
        selected.selectedProperty().bindBidirectional(neuralImage.selectedProperty());

        // Event Streams for Weight to convert between double and string
        weight.setText(String.valueOf(neuralImage.getWeight()));
        weightChanges = EventStreams.changesOf(weight.focusedProperty()).subscribe(focusChange -> {
            if (!focusChange.getNewValue()) { // focusing away from input
                double newWeight = doubleConverter.fromString(weight.getText()).doubleValue();
                neuralImage.setWeight(newWeight);
                if (newWeight == 0)
                    weight.setText("1.0");
            }
        });
    }
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private void setupContentLayersTable() {
    log.log(Level.FINER, "Setting content layer table list.");
    contentLayersTable.setItems(contentLayers);
    contentLayersTable.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    log.log(Level.FINER, "Setting content layer table selection listener.");
    EventStreams.changesOf(contentLayers).subscribe(change -> {
        log.log(Level.FINE, "contentLayers changed");

        List<NamedSelection> selectedContentLayers = contentLayers.stream()
                .filter(NamedSelection::isSelected)
                .collect(Collectors.toList());

        String[] newContentLayers = new String[selectedContentLayers.size()];
        for (int i = 0; i < selectedContentLayers.size(); i++)
            newContentLayers[i] = selectedContentLayers.get(i).getName();
        neuralStyle.setContentLayers(newContentLayers);

        toggleStyleButtons();
    });

    log.log(Level.FINER, "Setting style layer table shortcut listener");
    EventStreams.eventsOf(contentLayersTable, KeyEvent.KEY_RELEASED).filter(spaceBar::match).subscribe(keyEvent -> {
        ObservableList<NamedSelection> selectedStyleLayers =
                contentLayersTable.getSelectionModel().getSelectedItems();
        for (NamedSelection neuralLayer : selectedStyleLayers)
            neuralLayer.setSelected(!neuralLayer.isSelected());
    });

    log.log(Level.FINER, "Setting content layer table column factories.");
    contentLayersTableSelected.setCellValueFactory(new PropertyValueFactory<>("selected"));
    contentLayersTableSelected.setCellFactory(CheckBoxTableCell.forTableColumn(contentLayersTableSelected));

    contentLayersTableName.setCellValueFactory(new PropertyValueFactory<>("name"));
    contentLayersTableName.setCellFactory(TextFieldTableCell.forTableColumn());
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private void setEventStreamers(GroupEntity rect) {
	BooleanBinding animationRunning = rect.getRedoAnimation().statusProperty().isEqualTo(Animation.Status.RUNNING);
	
	EventStream<UndoChange<CustomBoundingBox>> xChanges = makeEventStream(rect.getRect().xProperty(),
			xRect -> new CustomBoundingBox(xRect.doubleValue(), rect.getRect().getY(), rect.getRect().getWidth(), rect.getRect().getHeight(), rect.getRotate()));

	EventStream<UndoChange<CustomBoundingBox>> yChanges = makeEventStream(rect.getRect().yProperty(),
			yRect -> new CustomBoundingBox(rect.getRect().getX(), yRect.doubleValue(), rect.getRect().getWidth(), rect.getRect().getHeight(), rect.getRotate()));

	EventStream<UndoChange<CustomBoundingBox>> widthChanges = makeEventStream(rect.getRect().widthProperty(),
			wRect -> new CustomBoundingBox(rect.getRect().getX(), rect.getRect().getY(), wRect.doubleValue(), rect.getRect().getHeight(), rect.getRotate()));

	EventStream<UndoChange<CustomBoundingBox>> heightChanges = makeEventStream(rect.getRect().heightProperty(),
			hRect -> new CustomBoundingBox(rect.getRect().getX(), rect.getRect().getY(), rect.getRect().getWidth(), hRect.doubleValue(), rect.getRotate()));

	EventStream<UndoChange<CustomBoundingBox>> rotationChanges = makeEventStream(rect.rotateProperty(),
			rRect -> new CustomBoundingBox(rect.getRect().getX(), rect.getRect().getY(), rect.getRect().getWidth(), rect.getRect().getHeight(), rRect.doubleValue()));

	EventStream<UndoChange<CustomBoundingBox>> boundsChanges = EventStreams
			.merge(xChanges, yChanges, widthChanges, heightChanges, rotationChanges).reducible(UndoChange::merge)
			.suspendWhen(animationRunning);

	rect.undoManager = UndoManagerFactory.unlimitedHistoryUndoManager(boundsChanges, UndoChange::invert, c -> {
		rect.getRedoAnimation().getKeyFrames()
				.setAll(new KeyFrame(GroupEntity.getRedoAnimationTime(), 
						new KeyValue(rect.getRect().xProperty(), c.getNewValue().getMinX()),
						new KeyValue(rect.getRect().yProperty(), c.getNewValue().getMinY()),
						new KeyValue(rect.getRect().widthProperty(), c.getNewValue().getWidth()),
						new KeyValue(rect.getRect().heightProperty(), c.getNewValue().getHeight()),
						new KeyValue(rect.rotateProperty(), c.getNewValue().getRotation())
						));
		rect.getRedoAnimation().play();
	}, (c1, c2) -> Optional.of(c1.merge(c2)));

}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
@FXML
protected void initialize() {
  codeBufferActive.bind(Bindings.createBooleanBinding(() -> !queryTabs.getTabs().isEmpty(), queryTabs.getTabs()));

  DBTreeController.initialize(treeView, this);
  consoleController.initialize(consoleLog);
  EventStreams.simpleChangesOf(queryTabs.getTabs())
  .subscribe(e -> e.getRemoved().stream().forEach(t -> tabData.remove(t.getContent()).stopEval()));

  Builder<KeyEvent> mainEvents = EventHandlerHelper.on(EventPattern.keyPressed(KeyCode.S, KeyCombination.CONTROL_DOWN)).act(a -> saveBuffer())//
      .on(EventPattern.keyPressed(KeyCode.O, KeyCombination.CONTROL_DOWN)).act(a -> openBuffer());
  EventHandlerHelper.install(mainFrame.onKeyPressedProperty(), mainEvents.create());
  popupService.register(popupMessageController, consoleButton);
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
/**
 * It allows to link the content of the file specified once called this method
 */
public void assingFile(String filePath) {

  //action when the button is pressed
  Subscription btnClicksub = EventStreams.eventsOf(this, ActionEvent.ACTION).subscribe(evt -> {
    try {
      LocalList<String> lines = new LocalList<String>();
      lines.addAll(Files.readAllLines(FileSystems.getDefault().getPath(filePath)));
      Utils.clipBoardListener.setContentCB(lines.toString());
    } catch (IOException e) {
      Logger.getGlobal().log(Level.WARNING, e.getMessage());
    }
  });
}