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());
    }
  });
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
/**
 * Creates a LiveDirs instance to be used from a designated thread.
 * @param projector converts the ({@link T}) {@link TreeItem#getValue()} into a {@link Path} object
 * @param injector converts a given {@link Path} object into {@link T}. The reverse of {@code projector}
 * @param externalInitiator object to represent an initiator of an external
 * file-system change.
 * @param clientThreadExecutor executor to execute actions on the caller
 * thread. Used to publish updates and errors on the caller thread.
 * @throws IOException
 */
public LiveDirs(I externalInitiator, Function<T, Path> projector, Function<Path, T> injector, Executor clientThreadExecutor) throws IOException {
    this.externalInitiator = externalInitiator;
    this.clientThreadExecutor = clientThreadExecutor;
    this.dirWatcher = new DirWatcher(clientThreadExecutor);
    this.model = new LiveDirsModel<>(externalInitiator, projector, injector);
    this.io = new LiveDirsIO<>(dirWatcher, model, clientThreadExecutor);

    this.dirWatcher.signalledKeys().subscribe(this::processKey);
    this.errors = EventStreams.merge(dirWatcher.errors(), model.errors(), localErrors);
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private static EventStream<Boolean> booleanPulse(javafx.util.Duration javafxDuration, EventStream<?> restartImpulse) {
    Duration duration = Duration.ofMillis(Math.round(javafxDuration.toMillis()));
    EventStream<?> ticks = EventStreams.restartableTicks(duration, restartImpulse);
    return StateMachine.init(false)
            .on(restartImpulse.withDefaultEvent(null)).transition((state, impulse) -> true)
            .on(ticks).transition((state, tick) -> !state)
            .toStateStream();
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private void setupServiceListeners() {
    // handle each Worker.State
    log.log(Level.FINER, "Setting state listener.");
    EventStreams.valuesOf(neuralService.stateProperty()).subscribe(state -> {
        switch (state) {
            case SCHEDULED:
                log.log(Level.FINER, "Neural service: Scheduled.");
                statusLabel.setText(bundle.getString("neuralServiceStatusScheduled"));
                startButton.setDisable(true);
                stopButton.setDisable(false);
                progress.setProgress(0);
                break;
            case READY:
                log.log(Level.FINER, "Neural service: Ready.");
                statusLabel.setText(bundle.getString("neuralServiceStatusReady"));
                startButton.setDisable(false);
                stopButton.setDisable(true);
                break;
            case RUNNING:
                log.log(Level.FINER, "Neural service: Running.");
                statusLabel.setText(bundle.getString("neuralServiceStatusRunning"));
                startButton.setDisable(true);
                stopButton.setDisable(false);
                break;
            case SUCCEEDED:
                log.log(Level.FINER, "Neural service: Succeeded.");
                statusLabel.setText(bundle.getString("neuralServiceStatusFinished"));
                startButton.setDisable(false);
                stopButton.setDisable(true);
                progress.setProgress(100);
                break;
            case CANCELLED:
                log.log(Level.FINER, "Neural service: Cancelled.");
                statusLabel.setText(bundle.getString("neuralServiceStatusCancelled"));
                startButton.setDisable(false);
                stopButton.setDisable(true);
                break;
            case FAILED:
                log.log(Level.FINER, "Neural service: Failed.");
                statusLabel.setText(bundle.getString("neuralServiceStatusFailed"));
                startButton.setDisable(false);
                stopButton.setDisable(true);
                break;
        }
    });

    log.log(Level.FINER, "Setting Image Output Service listener.");
    EventStreams.nonNullValuesOf(imageOutputService.valueProperty()).subscribe(valueProperty -> {
        log.log(Level.FINER, "Received updated Image Outputs from Service.");
        Map<String, Set<String>> results = imageOutputService.getValue();
        updateNeuralOutputs(results);
        updateImageView();
    });

    log.log(Level.FINER, "Setting progress listener.");
    EventStreams.nonNullValuesOf(neuralService.progressProperty())
            .subscribe(value -> progress.setProgress(value.doubleValue()));

    log.log(Level.FINER, "Setting running listener.");
    final ColorAdjust highlighted = new ColorAdjust(0, 0, 0.3, 0);
    EventStreams.nonNullValuesOf(neuralService.runningProperty())
            .subscribe(running -> {
               if (running)
                   statusLabel.setEffect(highlighted);
               else
                   statusLabel.setEffect(null);
            });
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
private void setupContentImageList() {
    log.log(Level.FINER, "Setting content image list.");
    contentImageList.setItems(contentImages);
    contentImageList.setFixedCellSize(NeuralImage.THUMBNAIL_SIZE);

    log.log(Level.FINER, "Setting content image list selection listener.");
    EventStreams.valuesOf(contentImageList.getSelectionModel().selectedItemProperty())
            .subscribe(newSelection -> {
                log.log(Level.FINE, "Content image changed: " + newSelection);
                if (newSelection == null)
                    neuralStyle.setContentImage(null);
                else
                    neuralStyle.setContentImage(newSelection.getImageFile());
                toggleStyleButtons();
            });

    log.log(Level.FINER, "Setting content image list column factory.");
    contentImageList.setCellFactory(new Callback<ListView<NeuralImage>, ListCell<NeuralImage>>() {
        @Override
        public ListCell<NeuralImage> call(ListView<NeuralImage> param) {
            return new ListCell<NeuralImage>() {
                NeuralImageCell neuralImageCell = new NeuralImageCell(false);

                @Override
                public void updateItem(NeuralImage neuralImage, boolean empty) {
                    super.updateItem(neuralImage, empty);

                    neuralImageCell.setNeuralImage(neuralImage);

                    if (empty || neuralImage == null) {
                        setText(null);
                        setGraphic(null);
                    } else {
                        neuralImageCell.setNeuralImage(neuralImage);
                        setText(null);
                        setGraphic(neuralImageCell.getCellLayout());
                    }
                }
            };
        }
    });
}
 

import org.reactfx.EventStreams; //导入依赖的package包/类
public Scene createScene() {
    String basename = getClass().getPackage().getName().replace('.', '/') + "/app";
    URL fxml = getClass().getClassLoader().getResource(basename + ".fxml");
    FXMLLoader fxmlLoader = new FXMLLoader(fxml);
    fxmlLoader.setControllerFactory(param -> AppView.this);
    Parent root = null;
    try {
        root = (Parent) fxmlLoader.load();
    } catch (IOException e) {
        throw new IllegalStateException(e);
    }

    organization.textProperty().addListener((observable, oldValue, newValue) -> {
        model.setState(isBlank(newValue) ? DISABLED : READY);
    });

    model.stateProperty().addListener((observable, oldValue, newValue) ->
        Platform.runLater(() -> {
            switch (newValue) {
                case DISABLED:
                    enabled.setValue(false);
                    running.setValue(false);
                    break;
                case READY:
                    enabled.setValue(true);
                    running.setValue(false);
                    break;
                case RUNNING:
                    enabled.setValue(false);
                    running.setValue(true);
                    break;
            }
        }));

    ObservableList<Repository> items = createJavaFXThreadProxyList(model.getRepositories().sorted());

    repositories.setItems(items);
    EventStreams.sizeOf(items).subscribe(v -> total.setText(String.valueOf(v)));
    organization.textProperty().bindBidirectional(model.organizationProperty());
    bindBidirectional(limit.textProperty(), model.limitProperty(), new NumberStringConverter());
    loadButton.disableProperty().bind(Bindings.not(enabled));
    cancelButton.disableProperty().bind(Bindings.not(running));
    progress.visibleProperty().bind(running);

    Scene scene = new Scene(root);
    scene.getStylesheets().addAll(basename + ".css", "bootstrapfx.css");
    return scene;
}