Examples with Task javafx.concurrent.Task used on opensource projects

Example 21 with Task

use of javafx.concurrent.Task in project latexdraw by arnobl.

the class LaTeXDraw method start.

@Override
public void start(final Stage stage) {
    final Task<Void> task = new Task<Void>() {

        @Override
        protected Void call() throws IOException {
            updateProgress(0.1, 1d);
            Platform.runLater(() -> {
                mainStage = new Stage(StageStyle.DECORATED);
                mainStage.setIconified(true);
                mainStage.setTitle(LABEL_APP);
            });
            final Parent root = // NON-NLS
            FXMLLoader.load(// NON-NLS
            getClass().getResource("/fxml/UI.fxml"), // NON-NLS
            LangTool.INSTANCE.getBundle(), new LatexdrawBuilderFactory(injector), instanceCallBack);
            updateProgress(0.6, 1d);
            final Scene scene = new Scene(root);
            updateProgress(0.7, 1d);
            // NON-NLS
            scene.getStylesheets().add("css/style.css");
            updateProgress(0.8, 1d);
            Platform.runLater(() -> {
                mainStage.setScene(scene);
                updateProgress(0.9, 1d);
                mainStage.show();
                registerScene(scene);
                final PreferencesSetter prefSetter = injector.getInstance(PreferencesSetter.class);
                prefSetter.readXMLPreferences();
                // Preventing the stage to close automatically.
                mainStage.addEventHandler(WindowEvent.WINDOW_CLOSE_REQUEST, WindowEvent::consume);
                // NON-NLS
                mainStage.getIcons().add(new Image("/res/LaTeXDrawIcon.png"));
                mainStage.centerOnScreen();
                injector.getInstance(MagneticGrid.class).update();
                injector.getInstance(TabSelector.class).centreViewport();
                injector.getInstance(Canvas.class).requestFocus();
                // Checking a new version if required.
                if (VersionChecker.WITH_UPDATE && injector.getInstance(PreferencesSetter.class).isVersionCheckEnable()) {
                    new Thread(new VersionChecker(injector.getInstance(StatusBarController.class))).start();
                }
                setModified(false);
            });
            return null;
        }
    };
    task.setOnFailed(BadaboomCollector.INSTANCE);
    showSplash(stage, task);
    new Thread(task).start();
}

Example 22 with Task

use of javafx.concurrent.Task in project tokentool by RPTools.

the class TokenTool_Controller method cacheOverlays.

private TreeItem<Path> cacheOverlays(File dir, TreeItem<Path> parent, int THUMB_SIZE) throws IOException {
    log.info("Caching " + dir.getAbsolutePath());
    TreeItem<Path> root = new TreeItem<>(dir.toPath());
    root.setExpanded(false);
    File[] files = dir.listFiles();
    final String I18N_CACHE_TEXT = I18N.getString("TokenTool.treeview.caching");
    final Task<Void> task = new Task<Void>() {

        @Override
        protected Void call() throws Exception {
            for (File file : files) {
                if (loadOverlaysThread.isInterrupted())
                    break;
                if (file.isDirectory()) {
                    cacheOverlays(file, root, THUMB_SIZE);
                } else {
                    Path filePath = file.toPath();
                    TreeItem<Path> imageNode = new TreeItem<>(filePath, ImageUtil.getOverlayThumb(new ImageView(), filePath));
                    root.getChildren().add(imageNode);
                    loadCount.getAndIncrement();
                    overlayTreeProgressBar.progressProperty().set(loadCount.doubleValue() / overlayCount);
                }
            }
            if (parent != null) {
                // When we show the overlay image, the TreeItem value is empty so we need to
                // sort those to the bottom for a cleaner look and keep sub dir's at the top.
                // If a node has no children then it's an overlay, otherwise it's a directory...
                root.getChildren().sort(new Comparator<TreeItem<Path>>() {

                    @Override
                    public int compare(TreeItem<Path> o1, TreeItem<Path> o2) {
                        if (o1.getChildren().size() == 0 && o2.getChildren().size() == 0)
                            return 0;
                        else if (o1.getChildren().size() == 0)
                            return Integer.MAX_VALUE;
                        else if (o2.getChildren().size() == 0)
                            return Integer.MIN_VALUE;
                        else
                            return o1.getValue().compareTo(o2.getValue());
                    }
                });
                parent.getChildren().add(root);
                parent.getChildren().sort(new Comparator<TreeItem<Path>>() {

                    @Override
                    public int compare(TreeItem<Path> o1, TreeItem<Path> o2) {
                        if (o1.getChildren().size() == 0 && o2.getChildren().size() == 0)
                            return 0;
                        else if (o1.getChildren().size() == 0)
                            return Integer.MAX_VALUE;
                        else if (o2.getChildren().size() == 0)
                            return Integer.MIN_VALUE;
                        else
                            return o1.getValue().compareTo(o2.getValue());
                    }
                });
            }
            return null;
        }
    };
    overlayTreeProgressBar.progressProperty().addListener(observable -> {
        Platform.runLater(() -> progressBarLabel.setText(I18N_CACHE_TEXT + Math.round(overlayCount - loadCount.doubleValue()) + "..."));
    });
    // Only add this listener to the parent task so it's only called once
    if (parent == null) {
        overlayTreeProgressBar.progressProperty().addListener(observable -> {
            Platform.runLater(() -> {
                if (overlayTreeProgressBar.getProgress() >= 1)
                    treeViewFinish();
            });
        });
    }
    executorService.execute(task);
    return root;
}

Example 23 with Task

use of javafx.concurrent.Task in project tokentool by RPTools.

the class ManageOverlays_Controller method loadImages.

private void loadImages(File dir) {
    // Clear Details panel
    clearDetails();
    currentDirectory = dir;
    File[] files = dir.listFiles(ImageUtil.SUPPORTED_FILENAME_FILTER);
    Task<Void> task = new Task<Void>() {

        @Override
        public Void call() {
            for (File file : files) {
                Path filePath = file.toPath();
                if (loadOverlaysThread.isInterrupted()) {
                    Platform.runLater(() -> overlayViewFlowPane.getChildren().clear());
                    break;
                }
                try {
                    ToggleButton overlayButton = new ToggleButton();
                    ImageView imageViewNode = ImageUtil.getOverlayThumb(new ImageView(), filePath);
                    overlayButton.getStyleClass().add("overlay-toggle-button");
                    overlayButton.setGraphic(imageViewNode);
                    overlayButton.setUserData(file);
                    overlayButton.setToggleGroup(overlayToggleGroup);
                    overlayButton.addEventHandler(ActionEvent.ACTION, event -> {
                        // No modifier keys used so add toggle group back to all buttons
                        resetToggleGroup();
                        // Also set button to selected due to resetting toggle groups & no unselecting needed, makes for better interface IMO
                        overlayButton.setSelected(true);
                        // Update the Details panel with the last selected overlay
                        File overlayFile = (File) overlayButton.getUserData();
                        updateDetails(overlayFile, (ImageView) overlayButton.getGraphic(), overlayButton.isSelected());
                        // Consume the event, no more logic needed
                        event.consume();
                    });
                    overlayButton.setOnMouseClicked(new EventHandler<MouseEvent>() {

                        @Override
                        public void handle(MouseEvent event) {
                            // Allow multiple selections if shortcutKey+left_mouse is pressed
                            if (event.getButton().equals(MouseButton.PRIMARY) && event.isShortcutDown()) {
                                // Update the Details panel with the last selected overlay
                                File overlayFile = (File) overlayButton.getUserData();
                                updateDetails(overlayFile, (ImageView) overlayButton.getGraphic(), true);
                                // Remove the toggle group to allow multiple toggle button selection
                                overlayButton.setToggleGroup(null);
                                // Select the button
                                overlayButton.setSelected(true);
                                // Consume the event, no more logic needed
                                event.consume();
                            }
                        }
                    });
                    Platform.runLater(() -> overlayViewFlowPane.getChildren().add(overlayButton));
                } catch (IOException e) {
                    log.error("Loading image: " + filePath.getFileName(), e);
                }
            }
            return null;
        }
    };
    loadOverlaysThread.interrupt();
    executorService.execute(task);
}

Example 24 with Task

use of javafx.concurrent.Task in project bisq-desktop by bisq-network.

the class VerifyTask method call.

/**
 * Starts the task and therefore the actual download.
 *
 * @return A reference to the created file or {@code null} if no file could be found at the provided URL
 * @throws IOException Forwarded exceotions from HttpURLConnection and file handling methods
 */
@Override
protected List<BisqInstaller.VerifyDescriptor> call() throws IOException {
    log.debug("VerifyTask started...");
    Optional<BisqInstaller.FileDescriptor> installer = fileDescriptors.stream().filter(fileDescriptor -> BisqInstaller.DownloadType.INSTALLER.equals(fileDescriptor.getType())).findFirst();
    if (!installer.isPresent()) {
        log.error("No installer file found.");
        return Lists.newArrayList();
    }
    Optional<BisqInstaller.FileDescriptor> signingKeyOptional = fileDescriptors.stream().filter(fileDescriptor -> BisqInstaller.DownloadType.SIGNING_KEY.equals(fileDescriptor.getType())).findAny();
    List<BisqInstaller.VerifyDescriptor> verifyDescriptors = Lists.newArrayList();
    if (signingKeyOptional.isPresent()) {
        final BisqInstaller.FileDescriptor signingKeyFD = signingKeyOptional.get();
        StringBuilder sb = new StringBuilder();
        try {
            Scanner scanner = new Scanner(new FileReader(signingKeyFD.getSaveFile()));
            while (scanner.hasNext()) {
                sb.append(scanner.next());
            }
            scanner.close();
        } catch (Exception e) {
            log.error(e.toString());
            e.printStackTrace();
            BisqInstaller.VerifyDescriptor.VerifyDescriptorBuilder verifyDescriptorBuilder = BisqInstaller.VerifyDescriptor.builder();
            verifyDescriptorBuilder.verifyStatusEnum(BisqInstaller.VerifyStatusEnum.FAIL);
            verifyDescriptors.add(verifyDescriptorBuilder.build());
            return verifyDescriptors;
        }
        String signingKey = sb.toString();
        List<BisqInstaller.FileDescriptor> sigs = fileDescriptors.stream().filter(fileDescriptor -> BisqInstaller.DownloadType.SIG.equals(fileDescriptor.getType())).collect(Collectors.toList());
        // iterate all signatures available to us
        for (BisqInstaller.FileDescriptor sig : sigs) {
            BisqInstaller.VerifyDescriptor.VerifyDescriptorBuilder verifyDescriptorBuilder = BisqInstaller.VerifyDescriptor.builder().sigFile(sig.getSaveFile());
            // Sigs are linked to keys, extract all keys which have the same id
            List<BisqInstaller.FileDescriptor> keys = fileDescriptors.stream().filter(keyDescriptor -> BisqInstaller.DownloadType.KEY.equals(keyDescriptor.getType())).filter(keyDescriptor -> sig.getId().equals(keyDescriptor.getId())).collect(Collectors.toList());
            // iterate all keys which have the same id
            for (BisqInstaller.FileDescriptor key : keys) {
                if (signingKey.equals(key.getId())) {
                    verifyDescriptorBuilder.keyFile(key.getSaveFile());
                    try {
                        verifyDescriptorBuilder.verifyStatusEnum(BisqInstaller.verifySignature(key.getSaveFile(), sig.getSaveFile(), installer.get().getSaveFile()));
                        updateMessage(key.getFileName());
                    } catch (Exception e) {
                        verifyDescriptorBuilder.verifyStatusEnum(BisqInstaller.VerifyStatusEnum.FAIL);
                        log.error(e.toString());
                        e.printStackTrace();
                    }
                    verifyDescriptors.add(verifyDescriptorBuilder.build());
                } else {
                    log.trace("key not matching the defined in signingKey. We try the next.");
                }
            }
        }
    } else {
        log.error("signingKey is not found");
        BisqInstaller.VerifyDescriptor.VerifyDescriptorBuilder verifyDescriptorBuilder = BisqInstaller.VerifyDescriptor.builder();
        verifyDescriptorBuilder.verifyStatusEnum(BisqInstaller.VerifyStatusEnum.FAIL);
        verifyDescriptors.add(verifyDescriptorBuilder.build());
    }
    return verifyDescriptors;
}

Example 25 with Task

use of javafx.concurrent.Task in project jgnash by ccavanaugh.

the class RegisterActions method exportTransactions.

static void exportTransactions(final Account account, final LocalDate startDate, final LocalDate endDate) {
    final ResourceBundle resources = ResourceUtils.getBundle();
    final Preferences pref = Preferences.userNodeForPackage(RegisterActions.class);
    final FileChooser fileChooser = new FileChooser();
    final File initialDirectory = new File(pref.get(EXPORT_DIR, System.getProperty("user.home")));
    // Protect against an IllegalArgumentException
    if (initialDirectory.isDirectory()) {
        fileChooser.setInitialDirectory(initialDirectory);
    }
    fileChooser.getExtensionFilters().addAll(new FileChooser.ExtensionFilter(resources.getString("Label.CsvFiles") + " (*.csv)", "*.csv"), new FileChooser.ExtensionFilter(resources.getString("Label.OfxFiles") + " (*.ofx)", "*.ofx"), new FileChooser.ExtensionFilter(resources.getString("Label.SpreadsheetFiles") + " (*.xls)", "*.xls"), new FileChooser.ExtensionFilter(resources.getString("Label.SpreadsheetFiles") + " (*.xlsx)", "*.xlsx"));
    final File file = fileChooser.showSaveDialog(MainView.getPrimaryStage());
    final File exportFile;
    if (file != null) {
        if (!FileUtils.fileHasExtension(file.getName())) {
            // fix up the file name if the user did not specify it
            final String fileExtension = fileChooser.getSelectedExtensionFilter().getExtensions().get(0).substring(1);
            exportFile = new File(FileUtils.stripFileExtension(file.getAbsolutePath()) + fileExtension);
        } else {
            exportFile = file;
        }
        pref.put(EXPORT_DIR, exportFile.getParentFile().getAbsolutePath());
        final Task<Void> exportTask = new Task<>() {

            @Override
            protected Void call() {
                updateMessage(resources.getString("Message.PleaseWait"));
                updateProgress(-1, Long.MAX_VALUE);
                if (OFX.equals(FileUtils.getFileExtension(exportFile.getName()))) {
                    final OfxExport export = new OfxExport(account, startDate, endDate, exportFile);
                    export.exportAccount();
                } else if (FileUtils.getFileExtension(exportFile.getName()).contains(XLS)) {
                    final AbstractReportTableModel reportTableModel = AccountRegisterReport.createReportModel(account, startDate, endDate, false, "", "", true);
                    Workbook.export(reportTableModel, exportFile);
                } else {
                    CsvExport.exportAccount(account, startDate, endDate, exportFile.toPath());
                }
                return null;
            }
        };
        new Thread(exportTask).start();
        StaticUIMethods.displayTaskProgress(exportTask);
    }
}