Example usage for javafx.stage FileChooser FileChooser

List of usage examples for javafx.stage FileChooser FileChooser

Introduction

In this page you can find the example usage for javafx.stage FileChooser FileChooser.

Prototype

FileChooser

Source Link

Usage

From source file:de.bayern.gdi.gui.Controller.java

/**
 * Handle config saving./*  w w w.  j  a va2 s  .  c  o m*/
 *
 * @param event The event.
 */
@FXML
protected void handleSaveConfig(ActionEvent event) {
    extractStoredQuery();
    extractBoundingBox();
    extractCql();
    if (validateInput() && validateCqlInput()) {
        FileChooser fileChooser = new FileChooser();
        DirectoryChooser dirChooser = new DirectoryChooser();
        File downloadDir;
        File initDir;

        dirChooser.setTitle(I18n.getMsg("gui.save-dir"));

        if (downloadConfig == null) {
            downloadDir = dirChooser.showDialog(getPrimaryStage());
            String basedir = Config.getInstance().getServices().getBaseDirectory();
            initDir = new File(basedir.isEmpty() ? System.getProperty(USER_DIR) : basedir);
            File uniqueName = Misc.uniqueFile(downloadDir, "config", "xml", null);
            fileChooser.setInitialFileName(uniqueName.getName());
        } else {
            File downloadInitDir = new File(downloadConfig.getDownloadPath());
            if (!downloadInitDir.exists()) {
                downloadInitDir = new File(System.getProperty(USER_DIR));
            }
            dirChooser.setInitialDirectory(downloadInitDir);
            downloadDir = dirChooser.showDialog(getPrimaryStage());

            String path = downloadConfig.getFile().getAbsolutePath();
            path = path.substring(0, path.lastIndexOf(File.separator));
            initDir = new File(path);
            fileChooser.setInitialFileName(downloadConfig.getFile().getName());
        }
        fileChooser.setInitialDirectory(initDir);
        FileChooser.ExtensionFilter xmlFilter = new FileChooser.ExtensionFilter("xml files (*.xml)", "*.xml");
        fileChooser.getExtensionFilters().add(xmlFilter);
        fileChooser.setSelectedExtensionFilter(xmlFilter);
        fileChooser.setTitle(I18n.getMsg("gui.save-conf"));
        File configFile = fileChooser.showSaveDialog(getPrimaryStage());
        if (configFile == null) {
            return;
        }

        if (!configFile.toString().endsWith(".xml")) {
            configFile = new File(configFile.toString() + ".xml");
        }

        this.dataBean.setProcessingSteps(extractProcessingSteps());

        String savePath = downloadDir.getPath();
        DownloadStep ds = dataBean.convertToDownloadStep(savePath);
        try {
            ds.write(configFile);
        } catch (IOException ex) {
            log.warn(ex.getMessage(), ex);
        }
    }
}

From source file:editeurpanovisu.EditeurPanovisu.java

/**
 *
 * @throws IOException/*from w  w w .  j  a  v  a2 s.co m*/
 * @throws InterruptedException
 */
private void projetCharge() throws IOException, InterruptedException {
    paneAttends.setVisible(true);
    while (!paneAttends.isVisible()) {

    }
    if (!repertSauveChoisi) {
        repertoireProjet = currentDir;
    }
    Action reponse = null;
    Localization.setLocale(locale);
    if (!dejaSauve) {
        reponse = Dialogs.create().owner(null).title("Charge un Projet")
                .masthead("Vous n'avez pas sauvegard votre projet").message("Voulez vous le sauver ?")
                .showConfirm();

    }
    if (reponse == Dialog.Actions.YES) {
        try {
            projetSauve();

        } catch (IOException ex) {
            Logger.getLogger(EditeurPanovisu.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    if ((reponse == Dialog.Actions.YES) || (reponse == Dialog.Actions.NO) || (reponse == null)) {
        Thread.sleep(100);
        dejaSauve = true;
        FileChooser repertChoix = new FileChooser();
        FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("fichier panoVisu (*.pvu)",
                "*.pvu");
        repertChoix.getExtensionFilters().add(extFilter);
        File repert = new File(repertoireProjet + File.separator);
        repertChoix.setInitialDirectory(repert);
        fichProjet = null;
        fichProjet = repertChoix.showOpenDialog(stPrincipal);
        if (fichProjet != null) {
            stPrincipal.setTitle("Panovisu v" + numVersion + " : " + fichProjet.getAbsolutePath());
            lblDragDrop.setVisible(false);
            repertoireProjet = fichProjet.getParent();
            ajouteFichierHisto(fichProjet.getAbsolutePath());
            repertSauveChoisi = true;
            deleteDirectory(repertTemp);
            String repertPanovisu = repertTemp + File.separator + "panovisu";
            File rptPanovisu = new File(repertPanovisu);
            rptPanovisu.mkdirs();
            copieDirectory(repertAppli + File.separator + "panovisu", repertPanovisu);
            menuPanoramique.setDisable(false);
            imgAjouterPano.setDisable(false);
            imgAjouterPano.setOpacity(1.0);
            imgSauveProjet.setDisable(false);
            imgSauveProjet.setOpacity(1.0);
            imgVisiteGenere.setDisable(false);
            imgVisiteGenere.setOpacity(1.0);

            paneChoixPanoramique.setVisible(false);

            sauveProjet.setDisable(false);
            sauveSousProjet.setDisable(false);
            visiteGenere.setDisable(false);
            numPoints = 0;
            numImages = 0;
            numHTML = 0;
            imagePanoramique.setImage(null);
            listeChoixPanoramique.getItems().clear();
            listeChoixPanoramiqueEntree.getItems().clear();
            FileReader fr;
            try {
                fr = new FileReader(fichProjet);
                String texte;
                try (BufferedReader br = new BufferedReader(fr)) {
                    texte = "";
                    String ligneTexte;
                    while ((ligneTexte = br.readLine()) != null) {
                        texte += ligneTexte + "\n";
                    }
                }
                try {
                    analyseLigne(texte);
                } catch (ImageReadException ex) {
                    Logger.getLogger(EditeurPanovisu.class.getName()).log(Level.SEVERE, null, ex);
                }

                panoActuel = 0;
                affichePanoChoisit(panoActuel);
                panoCharge = true;
                paneChoixPanoramique.setVisible(true);
                listeChoixPanoramique.setValue(listeChoixPanoramique.getItems().get(0));

            } catch (FileNotFoundException ex) {
                Logger.getLogger(EditeurPanovisu.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }
    paneAttends.setVisible(false);
}

From source file:fr.amap.lidar.amapvox.gui.MainFrameController.java

/**
 * Initializes the controller class.//ww w . ja v a  2s.c o m
 */
@Override
public void initialize(URL url, ResourceBundle rb) {

    this.resourceBundle = rb;

    viewer3DPanelController.setResourceBundle(rb);

    initStrings(rb);

    colorPickerSeries.valueProperty().addListener(new ChangeListener<javafx.scene.paint.Color>() {
        @Override
        public void changed(ObservableValue<? extends javafx.scene.paint.Color> observable,
                javafx.scene.paint.Color oldValue, javafx.scene.paint.Color newValue) {
            if (listViewVoxelsFilesChart.getSelectionModel().getSelectedItems().size() == 1) {
                listViewVoxelsFilesChart.getSelectionModel().getSelectedItem().getSeriesParameters()
                        .setColor(new Color((float) newValue.getRed(), (float) newValue.getGreen(),
                                (float) newValue.getBlue(), 1.0f));
            }
        }
    });

    comboboxScript.getItems().setAll("Daniel script");

    vboxWeighting.disableProperty().bind(checkboxEnableWeighting.selectedProperty().not());

    checkboxEnableWeighting.selectedProperty().addListener(new ChangeListener<Boolean>() {
        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            if (newValue && textAreaWeighting.getText().isEmpty()) {

                int selectedVoxTab = tabPaneVoxelisation.getSelectionModel().getSelectedIndex();

                if (selectedVoxTab == 0) { //ALS
                    fillWeightingData(EchoesWeightParams.DEFAULT_ALS_WEIGHTING);
                } else if (selectedVoxTab == 1) { //TLS
                    fillWeightingData(EchoesWeightParams.DEFAULT_TLS_WEIGHTING);
                }
            }
        }
    });

    /*comboboxTransMode.getItems().setAll(1, 2, 3);
    comboboxTransMode.getSelectionModel().selectFirst();
            
    comboboxPathLengthMode.getItems().setAll("A", "B");
    comboboxPathLengthMode.getSelectionModel().selectFirst();*/

    helpButtonNaNsCorrection.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            helpButtonNaNsCorrectionController.showHelpDialog(resourceBundle.getString("help_NaNs_correction"));
        }
    });

    helpButtonAutoBBox.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            helpButtonAutoBBoxController.showHelpDialog(resourceBundle.getString("help_bbox"));
        }
    });

    helpButtonHemiPhoto.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            helpButtonHemiPhotoController.showHelpDialog(resourceBundle.getString("help_hemiphoto"));
        }
    });

    buttonHelpEmptyShotsFilter.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            buttonHelpEmptyShotsFilterController
                    .showHelpDialog(resourceBundle.getString("help_empty_shots_filter"));
        }
    });

    /*work around, the divider positions values are defined in the fxml,
    but when the window is initialized the values are lost*/
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            splitPaneMain.setDividerPositions(0.75f);
            splitPaneVoxelization.setDividerPositions(0.45f);
        }
    });

    initValidationSupport();
    initPostProcessTab();

    listViewTransmittanceMapSensorPositions.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
    listViewTaskList.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    MenuItem menuItemPadValue1m = new MenuItem("1m voxel size");
    addMenuItemPadValue(menuItemPadValue1m, 3.536958f);

    MenuItem menuItemPadValue2m = new MenuItem("2m voxel size");
    addMenuItemPadValue(menuItemPadValue2m, 2.262798f);

    MenuItem menuItemPadValue3m = new MenuItem("3m voxel size");
    addMenuItemPadValue(menuItemPadValue3m, 1.749859f);

    MenuItem menuItemPadValue4m = new MenuItem("4m voxel size");
    addMenuItemPadValue(menuItemPadValue4m, 1.3882959f);

    MenuItem menuItemPadValue5m = new MenuItem("5m voxel size");
    addMenuItemPadValue(menuItemPadValue5m, 1.0848f);

    menuButtonAdvisablePADMaxValues.getItems().addAll(menuItemPadValue1m, menuItemPadValue2m,
            menuItemPadValue3m, menuItemPadValue4m, menuItemPadValue5m);

    fileChooserSaveCanopyAnalyserOutputFile = new FileChooserContext();
    fileChooserSaveCanopyAnalyserCfgFile = new FileChooserContext();
    fileChooserSaveTransmittanceSimCfgFile = new FileChooserContext();
    fileChooserOpenCanopyAnalyserInputFile = new FileChooserContext();
    listViewCanopyAnalyzerSensorPositions.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    ContextMenu contextMenuProductsList = new ContextMenu();
    MenuItem openImageItem = new MenuItem(RS_STR_OPEN_IMAGE);
    openImageItem.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            File selectedFile = listViewProductsFiles.getSelectionModel().getSelectedItem();

            showImage(selectedFile);
        }
    });

    Menu menuEdit = new Menu(RS_STR_EDIT);

    MenuItem menuItemEditVoxels = new MenuItem("Remove voxels (delete key)");
    MenuItem menuItemFitToContent = new MenuItem("Fit to content");
    MenuItem menuItemCrop = new MenuItem("Crop");

    menuEdit.getItems().setAll(menuItemEditVoxels, menuItemFitToContent, menuItemCrop);

    menuItemFitToContent.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                fitVoxelSpaceToContent(selectedItem);
            }
        }
    });

    menuItemEditVoxels.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                editVoxelSpace(selectedItem);
            }
        }
    });

    menuItemCrop.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                try {
                    voxelSpaceCroppingFrameController.setVoxelFile(selectedItem);
                    voxelSpaceCroppingFrame.show();
                } catch (Exception ex) {
                    showErrorDialog(ex);
                }
            }
        }
    });

    Menu menuExport = new Menu(RS_STR_EXPORT);
    MenuItem menuItemExportDartMaket = new MenuItem("Dart (maket.txt)");
    MenuItem menuItemExportDartPlots = new MenuItem("Dart (plots.xml)");
    MenuItem menuItemExportMeshObj = new MenuItem("Mesh (*.obj)");

    menuItemExportDartMaket.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                exportDartMaket(selectedItem);
            }
        }
    });

    menuItemExportDartPlots.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                exportDartPlots(selectedItem);
            }
        }
    });

    menuItemExportMeshObj.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                exportMeshObj(selectedItem);
            }
        }
    });

    menuExport.getItems().setAll(menuItemExportDartMaket, menuItemExportDartPlots, menuItemExportMeshObj);

    MenuItem menuItemInfo = new MenuItem(RS_STR_INFO);

    menuItemInfo.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            Alert alert = new Alert(AlertType.INFORMATION);

            File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                VoxelFileReader reader;
                try {
                    reader = new VoxelFileReader(selectedItem);
                    VoxelSpaceInfos voxelSpaceInfos = reader.getVoxelSpaceInfos();
                    alert.setTitle("Information");
                    alert.setHeaderText("Voxel space informations");
                    alert.setContentText(voxelSpaceInfos.toString());
                    alert.show();
                } catch (Exception ex) {
                    showErrorDialog(ex);
                }

            }
        }
    });

    final MenuItem menuItemOpenContainingFolder = new MenuItem(RS_STR_OPEN_CONTAINING_FOLDER);

    menuItemOpenContainingFolder.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {

            final File selectedItem = listViewProductsFiles.getSelectionModel().getSelectedItem();

            if (selectedItem != null) {
                if (Desktop.isDesktopSupported()) {
                    new Thread(() -> {
                        try {
                            Desktop.getDesktop().open(selectedItem.getParentFile());
                        } catch (IOException ex) {
                            logger.error("Cannot open directory " + selectedItem);
                        }
                    }).start();
                }

            }

        }
    });

    listViewProductsFiles.setOnContextMenuRequested(new EventHandler<ContextMenuEvent>() {
        @Override
        public void handle(ContextMenuEvent event) {

            if (listViewProductsFiles.getSelectionModel().getSelectedIndices().size() == 1) {

                File selectedFile = listViewProductsFiles.getSelectionModel().getSelectedItem();
                String extension = FileManager.getExtension(selectedFile);

                switch (extension) {
                case ".png":
                case ".bmp":
                case ".jpg":
                    contextMenuProductsList.getItems().setAll(openImageItem, menuItemOpenContainingFolder);
                    contextMenuProductsList.show(listViewProductsFiles, event.getScreenX(), event.getScreenY());
                    break;
                case ".vox":

                default:
                    if (VoxelFileReader.isFileAVoxelFile(selectedFile)) {
                        contextMenuProductsList.getItems().setAll(menuItemInfo, menuItemOpenContainingFolder,
                                menuEdit, menuExport);
                        contextMenuProductsList.show(listViewProductsFiles, event.getScreenX(),
                                event.getScreenY());
                    }
                }

            }

        }
    });

    ContextMenu contextMenuLidarScanEdit = new ContextMenu();
    MenuItem editItem = new MenuItem("Edit");

    editItem.setOnAction(new EventHandler<ActionEvent>() {

        @Override
        public void handle(ActionEvent event) {

            filterFrameController.setFilters("Reflectance", "Deviation", "Amplitude");
            filterFrame.show();

            filterFrame.setOnHidden(new EventHandler<WindowEvent>() {

                @Override
                public void handle(WindowEvent event) {

                    if (filterFrameController.getFilter() != null) {
                        ObservableList<LidarScan> items = listViewHemiPhotoScans.getSelectionModel()
                                .getSelectedItems();
                        for (LidarScan scan : items) {
                            scan.filters.add(filterFrameController.getFilter());
                        }
                    }
                }
            });
        }
    });

    contextMenuLidarScanEdit.getItems().add(editItem);

    listViewHemiPhotoScans.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
    listViewHemiPhotoScans.setOnContextMenuRequested(new EventHandler<ContextMenuEvent>() {

        @Override
        public void handle(ContextMenuEvent event) {
            contextMenuLidarScanEdit.show(listViewHemiPhotoScans, event.getScreenX(), event.getScreenY());
        }
    });

    /**LAD tab initialization**/
    comboboxLADChoice.getItems().addAll(LeafAngleDistribution.Type.UNIFORM, LeafAngleDistribution.Type.SPHERIC,
            LeafAngleDistribution.Type.ERECTOPHILE, LeafAngleDistribution.Type.PLANOPHILE,
            LeafAngleDistribution.Type.EXTREMOPHILE, LeafAngleDistribution.Type.PLAGIOPHILE,
            LeafAngleDistribution.Type.HORIZONTAL, LeafAngleDistribution.Type.VERTICAL,
            LeafAngleDistribution.Type.ELLIPSOIDAL, LeafAngleDistribution.Type.ELLIPTICAL,
            LeafAngleDistribution.Type.TWO_PARAMETER_BETA);

    comboboxLADChoice.getSelectionModel().select(LeafAngleDistribution.Type.SPHERIC);
    comboboxLADChoice.getSelectionModel().selectedItemProperty()
            .addListener(new ChangeListener<LeafAngleDistribution.Type>() {

                @Override
                public void changed(ObservableValue<? extends LeafAngleDistribution.Type> observable,
                        LeafAngleDistribution.Type oldValue, LeafAngleDistribution.Type newValue) {

                    if (newValue == LeafAngleDistribution.Type.TWO_PARAMETER_BETA
                            || newValue == LeafAngleDistribution.Type.ELLIPSOIDAL) {

                        hboxTwoBetaParameters.setVisible(true);

                        if (newValue == LeafAngleDistribution.Type.ELLIPSOIDAL) {
                            labelLADBeta.setVisible(false);
                        } else {
                            labelLADBeta.setVisible(true);
                        }
                    } else {
                        hboxTwoBetaParameters.setVisible(false);
                    }
                }
            });

    ToggleGroup ladTypeGroup = new ToggleGroup();
    radiobuttonLADHomogeneous.setToggleGroup(ladTypeGroup);
    radiobuttonLADLocalEstimation.setToggleGroup(ladTypeGroup);

    /**CHART panel initialization**/

    ToggleGroup profileChartType = new ToggleGroup();
    radiobuttonPreDefinedProfile.setToggleGroup(profileChartType);
    radiobuttonFromVariableProfile.setToggleGroup(profileChartType);

    ToggleGroup profileChartRelativeHeightType = new ToggleGroup();
    radiobuttonHeightFromAboveGround.setToggleGroup(profileChartRelativeHeightType);
    radiobuttonHeightFromBelowCanopy.setToggleGroup(profileChartRelativeHeightType);

    comboboxFromVariableProfile.disableProperty().bind(radiobuttonPreDefinedProfile.selectedProperty());
    comboboxPreDefinedProfile.disableProperty().bind(radiobuttonFromVariableProfile.selectedProperty());

    hboxMaxPADVegetationProfile.visibleProperty().bind(radiobuttonPreDefinedProfile.selectedProperty());

    listViewVoxelsFilesChart.getSelectionModel().selectedIndexProperty()
            .addListener(new ChangeListener<Number>() {

                @Override
                public void changed(ObservableValue<? extends Number> observable, Number oldValue,
                        Number newValue) {

                    if (listViewVoxelsFilesChart.getSelectionModel().getSelectedItems().size() > 1) {
                        colorPickerSeries.setDisable(true);
                    } else if (listViewVoxelsFilesChart.getSelectionModel().getSelectedItems().size() == 1) {

                        VoxelFileChart selectedItem = listViewVoxelsFilesChart.getSelectionModel()
                                .getSelectedItem();
                        Color selectedItemColor = selectedItem.getSeriesParameters().getColor();

                        colorPickerSeries.setDisable(false);
                        colorPickerSeries.setValue(new javafx.scene.paint.Color(
                                selectedItemColor.getRed() / 255.0, selectedItemColor.getGreen() / 255.0,
                                selectedItemColor.getBlue() / 255.0, 1.0));

                        if (newValue.intValue() >= 0) {
                            textfieldLabelVoxelFileChart.setText(
                                    listViewVoxelsFilesChart.getItems().get(newValue.intValue()).label);
                        }
                    }
                }
            });

    textfieldLabelVoxelFileChart.textProperty().addListener(new ChangeListener<String>() {

        @Override
        public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {

            if (listViewVoxelsFilesChart.getSelectionModel().getSelectedIndex() >= 0) {
                listViewVoxelsFilesChart.getSelectionModel().getSelectedItem().label = newValue;
            }
        }
    });

    listViewVoxelsFilesChart.getItems().addListener(new ListChangeListener<VoxelFileChart>() {

        @Override
        public void onChanged(ListChangeListener.Change<? extends VoxelFileChart> c) {

            while (c.next()) {
            }

            if (c.wasAdded() && c.getAddedSize() == c.getList().size()) {

                try {
                    VoxelFileReader reader = new VoxelFileReader(c.getList().get(0).file);
                    String[] columnNames = reader.getVoxelSpaceInfos().getColumnNames();
                    comboboxFromVariableProfile.getItems().clear();
                    comboboxFromVariableProfile.getItems().addAll(columnNames);
                    comboboxFromVariableProfile.getSelectionModel().selectFirst();
                } catch (Exception ex) {
                    logger.error("Cannot read voxel file", ex);
                }
            }

        }
    });

    anchorpaneQuadrats.disableProperty().bind(checkboxMakeQuadrats.selectedProperty().not());

    comboboxSelectAxisForQuadrats.getItems().addAll("X", "Y", "Z");
    comboboxSelectAxisForQuadrats.getSelectionModel().select(1);

    comboboxPreDefinedProfile.getItems().addAll("Vegetation (PAD)");
    comboboxPreDefinedProfile.getSelectionModel().selectFirst();

    radiobuttonSplitCountForQuadrats.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            textFieldSplitCountForQuadrats.setDisable(!newValue);
            textFieldLengthForQuadrats.setDisable(newValue);
        }
    });

    ToggleGroup chartMakeQuadratsSplitType = new ToggleGroup();
    radiobuttonLengthForQuadrats.setToggleGroup(chartMakeQuadratsSplitType);
    radiobuttonSplitCountForQuadrats.setToggleGroup(chartMakeQuadratsSplitType);

    /**Virtual measures panel initialization**/

    comboboxHemiPhotoBitmapOutputMode.getItems().addAll("Pixel", "Color");
    comboboxHemiPhotoBitmapOutputMode.getSelectionModel().selectFirst();

    ToggleGroup virtualMeasuresChoiceGroup = new ToggleGroup();

    toggleButtonLAI2000Choice.setToggleGroup(virtualMeasuresChoiceGroup);
    toggleButtonLAI2200Choice.setToggleGroup(virtualMeasuresChoiceGroup);

    comboboxChooseCanopyAnalyzerSampling.getItems().setAll(500, 4000, 10000);
    comboboxChooseCanopyAnalyzerSampling.getSelectionModel().selectFirst();

    initEchoFiltering();

    data = FXCollections.observableArrayList();

    tableViewSimulationPeriods.setItems(data);
    tableViewSimulationPeriods.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    comboboxChooseDirectionsNumber.getItems().addAll(1, 6, 16, 46, 136, 406);
    comboboxChooseDirectionsNumber.getSelectionModel().select(4);

    ToggleGroup scannerPositionsMode = new ToggleGroup();

    /*radiobuttonScannerPosSquaredArea.setToggleGroup(scannerPositionsMode);
    radiobuttonScannerPosFile.setToggleGroup(scannerPositionsMode);*/

    tableColumnPeriod.setCellValueFactory(
            new Callback<TableColumn.CellDataFeatures<SimulationPeriod, String>, ObservableValue<String>>() {

                @Override
                public ObservableValue<String> call(
                        TableColumn.CellDataFeatures<SimulationPeriod, String> param) {
                    return new SimpleStringProperty(param.getValue().getPeriod().toString());
                }
            });

    tableColumnClearness.setCellValueFactory(
            new Callback<TableColumn.CellDataFeatures<SimulationPeriod, String>, ObservableValue<String>>() {

                @Override
                public ObservableValue<String> call(
                        TableColumn.CellDataFeatures<SimulationPeriod, String> param) {
                    return new SimpleStringProperty(String.valueOf(param.getValue().getClearnessCoefficient()));
                }
            });

    checkboxMultiFiles.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            anchorpaneBoundingBoxParameters.setDisable(newValue);
        }
    });

    hboxGenerateBitmapFiles.disableProperty().bind(checkboxGenerateBitmapFile.selectedProperty().not());
    hboxGenerateTextFile.disableProperty().bind(checkboxGenerateTextFile.selectedProperty().not());

    fileChooserOpenConfiguration = new FileChooser();
    fileChooserOpenConfiguration.setTitle("Choose configuration file");

    fileChooserSaveConfiguration = new FileChooserContext("cfg.xml");
    fileChooserSaveConfiguration.fc.setTitle("Choose output file");

    fileChooserOpenInputFileALS = new FileChooser();
    fileChooserOpenInputFileALS.setTitle("Open input file");
    fileChooserOpenInputFileALS.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Shot files", "*.sht"), new ExtensionFilter("Text Files", "*.txt"),
            new ExtensionFilter("Las Files", "*.las", "*.laz"));

    fileChooserOpenTrajectoryFileALS = new FileChooser();
    fileChooserOpenTrajectoryFileALS.setTitle("Open trajectory file");
    fileChooserOpenTrajectoryFileALS.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Text Files", "*.txt"));

    fileChooserOpenOutputFileALS = new FileChooser();
    fileChooserOpenOutputFileALS.setTitle("Choose output file");

    fileChooserOpenInputFileTLS = new FileChooserContext();
    fileChooserOpenInputFileTLS.fc.setTitle("Open input file");
    fileChooserOpenInputFileTLS.fc.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Text Files", "*.txt"), new ExtensionFilter("Rxp Files", "*.rxp"),
            new ExtensionFilter("Project Rsp Files", "*.rsp"));

    directoryChooserOpenOutputPathTLS = new DirectoryChooser();
    directoryChooserOpenOutputPathTLS.setTitle("Choose output path");

    directoryChooserOpenOutputPathALS = new DirectoryChooser();
    directoryChooserOpenOutputPathALS.setTitle("Choose output path");

    fileChooserSaveOutputFileTLS = new FileChooser();
    fileChooserSaveOutputFileTLS.setTitle("Save voxel file");

    fileChooserSaveTransmittanceTextFile = new FileChooser();
    fileChooserSaveTransmittanceTextFile.setTitle("Save text file");

    directoryChooserSaveTransmittanceBitmapFile = new DirectoryChooser();
    directoryChooserSaveTransmittanceBitmapFile.setTitle("Choose output directory");

    fileChooserSaveHemiPhotoOutputBitmapFile = new FileChooserContext("*.png");
    fileChooserSaveHemiPhotoOutputBitmapFile.fc.setTitle("Save bitmap file");

    directoryChooserSaveHemiPhotoOutputBitmapFile = new DirectoryChooser();
    directoryChooserSaveHemiPhotoOutputBitmapFile.setTitle("Choose bitmap files output directory");

    directoryChooserSaveHemiPhotoOutputTextFile = new DirectoryChooser();
    directoryChooserSaveHemiPhotoOutputTextFile.setTitle("Choose text files output directory");

    fileChooserSaveHemiPhotoOutputTextFile = new FileChooser();
    fileChooserSaveHemiPhotoOutputTextFile.setTitle("Save text file");

    fileChooserOpenVoxelFile = new FileChooser();
    fileChooserOpenVoxelFile.setTitle("Open voxel file");
    fileChooserOpenVoxelFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Voxel Files", "*.vox"));

    fileChooserOpenPopMatrixFile = new FileChooser();
    fileChooserOpenPopMatrixFile.setTitle("Choose matrix file");
    fileChooserOpenPopMatrixFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Text Files", "*.txt"));

    fileChooserOpenSopMatrixFile = new FileChooser();
    fileChooserOpenSopMatrixFile.setTitle("Choose matrix file");
    fileChooserOpenSopMatrixFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Text Files", "*.txt"));

    fileChooserOpenVopMatrixFile = new FileChooser();
    fileChooserOpenVopMatrixFile.setTitle("Choose matrix file");
    fileChooserOpenVopMatrixFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Text Files", "*.txt"));

    fileChooserOpenPonderationFile = new FileChooser();
    fileChooserOpenPonderationFile.setTitle("Choose ponderation file");
    fileChooserOpenPonderationFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Text Files", "*.txt"));

    fileChooserOpenDTMFile = new FileChooser();
    fileChooserOpenDTMFile.setTitle("Choose DTM file");
    fileChooserOpenDTMFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("DTM Files", "*.asc"));

    fileChooserOpenPointCloudFile = new FileChooser();
    fileChooserOpenPointCloudFile.setTitle("Choose point cloud file");
    fileChooserOpenPointCloudFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("TXT Files", "*.txt"));

    fileChooserOpenMultiResVoxelFile = new FileChooser();
    fileChooserOpenMultiResVoxelFile.setTitle("Choose voxel file");
    fileChooserOpenMultiResVoxelFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Voxel Files", "*.vox"));

    fileChooserOpenOutputFileMultiRes = new FileChooser();
    fileChooserOpenOutputFileMultiRes.setTitle("Save voxel file");

    fileChooserAddTask = new FileChooser();
    fileChooserAddTask.setTitle("Choose parameter file");
    fileChooserAddTask.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("XML Files", "*.xml"));

    fileChooserSaveDartFile = new FileChooser();
    fileChooserSaveDartFile.setTitle("Save dart file (.maket)");
    fileChooserSaveDartFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Maket File", "*.maket"));

    fileChooserOpenOutputFileMerging = new FileChooser();
    fileChooserOpenOutputFileMerging.setTitle("Choose voxel file");
    fileChooserOpenOutputFileMerging.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("Voxel Files", "*.vox"));

    fileChooserOpenScriptFile = new FileChooser();
    fileChooserOpenScriptFile.setTitle("Choose script file");

    fileChooserSaveGroundEnergyOutputFile = new FileChooser();
    fileChooserSaveGroundEnergyOutputFile.setTitle("Save ground energy file");

    fileChooserOpenPointsPositionFile = new FileChooser();
    fileChooserOpenPointsPositionFile.setTitle("Choose points file");
    fileChooserOpenPointsPositionFile.getExtensionFilters().addAll(new ExtensionFilter("All Files", "*"),
            new ExtensionFilter("TXT Files", "*.txt"));

    try {
        viewCapsSetupFrame = new Stage();
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/ViewCapsSetupFrame.fxml"));
        Parent root = loader.load();
        viewCapsSetupFrameController = loader.getController();
        viewCapsSetupFrame.setScene(new Scene(root));
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/FilteringPaneComponent.fxml"));
        anchorPaneEchoFilteringRxp = loader.load();
        filteringPaneController = loader.getController();
        filteringPaneController.setFiltersNames("Reflectance", "Amplitude", "Deviation");
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        positionImporterFrame = new Stage();
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/PositionImporterFrame.fxml"));
        Parent root = loader.load();
        positionImporterFrameController = loader.getController();
        positionImporterFrame.setScene(new Scene(root));
        positionImporterFrameController.setStage(positionImporterFrame);
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        voxelSpaceCroppingFrame = new Stage();
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/VoxelSpaceCroppingFrame.fxml"));
        Parent root = loader.load();
        voxelSpaceCroppingFrameController = loader.getController();
        voxelSpaceCroppingFrame.setScene(new Scene(root));
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        attributsImporterFrame = new Stage();
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/AttributsImporterFrame.fxml"));
        Parent root = loader.load();
        attributsImporterFrameController = loader.getController();
        attributsImporterFrame.setScene(new Scene(root));
        attributsImporterFrameController.setStage(attributsImporterFrame);
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        textFileParserFrameController = TextFileParserFrameController.getInstance();
    } catch (Exception ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        transformationFrameController = TransformationFrameController.getInstance();
        transformationFrame = transformationFrameController.getStage();
    } catch (Exception ex) {
        logger.error("Cannot load fxml file", ex);
    }

    updaterFrame = new Stage();

    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/update/UpdaterFrame.fxml"));
        Parent root = loader.load();
        updaterFrameController = loader.getController();
        updaterFrame.setScene(new Scene(root));

    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    riscanProjectExtractor = new RiscanProjectExtractor();
    ptxProjectExtractor = new PTXProjectExtractor();
    ptgProjectExtractor = new PTGProjectExtractor();

    dateChooserFrame = new Stage();

    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/DateChooserFrame.fxml"));
        Parent root = loader.load();
        dateChooserFrameController = loader.getController();
        dateChooserFrame.setScene(new Scene(root));
        dateChooserFrameController.setStage(dateChooserFrame);
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    comboboxModeALS.getItems().addAll(RS_STR_INPUT_TYPE_LAS, RS_STR_INPUT_TYPE_LAZ,
            /*RS_STR_INPUT_TYPE_XYZ, */RS_STR_INPUT_TYPE_SHOTS);

    comboboxModeALS.getSelectionModel().selectedItemProperty().addListener(new ChangeListener<String>() {
        @Override
        public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {

            if (newValue.equals(RS_STR_INPUT_TYPE_SHOTS)) {
                alsVoxValidationSupport.registerValidator(textFieldTrajectoryFileALS, false,
                        Validators.unregisterValidator);
            } else {
                alsVoxValidationSupport.registerValidator(textFieldTrajectoryFileALS, false,
                        Validators.fileExistValidator);
            }
        }
    });

    comboboxModeTLS.getItems().setAll("Rxp scan", "Rsp project", "PTX",
            "PTG"/*, RS_STR_INPUT_TYPE_XYZ, RS_STR_INPUT_TYPE_SHOTS*/);
    comboboxGroundEnergyOutputFormat.getItems().setAll("txt", "png");

    comboboxLaserSpecification.getItems().addAll(LaserSpecification.getPresets());

    comboboxLaserSpecification.getSelectionModel().selectedItemProperty()
            .addListener(new ChangeListener<LaserSpecification>() {
                @Override
                public void changed(ObservableValue<? extends LaserSpecification> observable,
                        LaserSpecification oldValue, LaserSpecification newValue) {
                    DecimalFormatSymbols symb = new DecimalFormatSymbols();
                    symb.setDecimalSeparator('.');
                    DecimalFormat formatter = new DecimalFormat("#####.######", symb);

                    textFieldBeamDiameterAtExit.setText(formatter.format(newValue.getBeamDiameterAtExit()));
                    textFieldBeamDivergence.setText(formatter.format(newValue.getBeamDivergence()));
                }
            });

    comboboxLaserSpecification.getSelectionModel().select(LaserSpecification.LMS_Q560);

    comboboxLaserSpecification.disableProperty().bind(checkboxCustomLaserSpecification.selectedProperty());
    textFieldBeamDiameterAtExit.disableProperty()
            .bind(checkboxCustomLaserSpecification.selectedProperty().not());
    textFieldBeamDivergence.disableProperty().bind(checkboxCustomLaserSpecification.selectedProperty().not());

    listViewProductsFiles.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    listViewProductsFiles.getSelectionModel().selectedIndexProperty().addListener(new ChangeListener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
            int size = listViewProductsFiles.getSelectionModel().getSelectedIndices().size();

            if (size == 1) {
                viewer3DPanelController
                        .updateCurrentVoxelFile(listViewProductsFiles.getSelectionModel().getSelectedItem());
            }
        }
    });

    listViewTaskList.getSelectionModel().selectedIndexProperty().addListener(new ChangeListener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
            int size = listViewTaskList.getSelectionModel().getSelectedIndices().size();

            if (size == 1) {
                buttonLoadSelectedTask.setDisable(false);
            } else {
                buttonLoadSelectedTask.setDisable(true);
            }

            buttonExecute.setDisable(size == 0);
        }
    });

    resetMatrices();

    calculateMatrixFrame = new Stage();

    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/CalculateMatrixFrame.fxml"));
        Parent root = loader.load();
        calculateMatrixFrameController = loader.getController();
        calculateMatrixFrameController.setStage(calculateMatrixFrame);
        Scene scene = new Scene(root);
        calculateMatrixFrame.setScene(scene);
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    filterFrame = new Stage();

    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/FilterFrame.fxml"));
        Parent root = loader.load();
        filterFrameController = loader.getController();
        filterFrameController.setStage(filterFrame);
        filterFrameController.setFilters("Angle");
        filterFrame.setScene(new Scene(root));
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/export/ObjExporterDialog.fxml"));
        Parent root = loader.load();
        objExporterController = loader.getController();
        Stage s = new Stage();
        objExporterController.setStage(s);
        s.setScene(new Scene(root));
    } catch (IOException ex) {
        logger.error("Cannot load fxml file", ex);
    }

    textFieldResolution.textProperty().addListener(new ChangeListener<String>() {
        @Override
        public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
            voxelSpacePanelVoxelizationController.setResolution(Float.valueOf(newValue));
        }
    });

    textFieldResolution.textProperty().addListener(voxelSpacePanelVoxelizationController.getChangeListener());

    checkboxUseDTMFilter.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {

            if (checkboxUseDTMFilter.isSelected()) {
                buttonOpenDTMFile.setDisable(false);
                textfieldDTMPath.setDisable(false);
                textfieldDTMValue.setDisable(false);
                checkboxApplyVOPMatrix.setDisable(false);
                labelDTMValue.setDisable(false);
                labelDTMPath.setDisable(false);
            } else {
                buttonOpenDTMFile.setDisable(true);
                textfieldDTMPath.setDisable(true);
                textfieldDTMValue.setDisable(true);
                checkboxApplyVOPMatrix.setDisable(true);
                labelDTMValue.setDisable(true);
                labelDTMPath.setDisable(true);
            }
        }
    });

    checkboxUseVopMatrix.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            buttonSetVOPMatrix.setDisable(!newValue);
        }
    });

    checkboxUsePopMatrix.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            if (newValue) {
                checkBoxUseDefaultPopMatrix.setDisable(false);
                buttonOpenPopMatrixFile.setDisable(false);
            } else {
                checkBoxUseDefaultPopMatrix.setDisable(true);
                buttonOpenPopMatrixFile.setDisable(true);
            }
        }
    });

    checkboxUseSopMatrix.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            if (newValue) {
                checkBoxUseDefaultSopMatrix.setDisable(false);
                buttonOpenSopMatrixFile.setDisable(false);
            } else {
                checkBoxUseDefaultSopMatrix.setDisable(true);
                buttonOpenSopMatrixFile.setDisable(true);
            }
        }
    });

    checkboxCalculateGroundEnergy.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
            if (newValue) {
                anchorPaneGroundEnergyParameters.setDisable(false);
            } else {
                anchorPaneGroundEnergyParameters.setDisable(true);
            }
        }
    });

    listviewRxpScans.getSelectionModel().selectedItemProperty().addListener(new ChangeListener<LidarScan>() {

        @Override
        public void changed(ObservableValue<? extends LidarScan> observable, LidarScan oldValue,
                LidarScan newValue) {
            if (newValue != null) {
                sopMatrix = newValue.matrix;
                updateResultMatrix();
            }
        }
    });

    comboboxModeTLS.getSelectionModel().selectedIndexProperty().addListener(new ChangeListener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {

            switch (newValue.intValue()) {

            case 1:
            case 2:
            case 3:
                listviewRxpScans.setDisable(false);
                checkboxMergeAfter.setDisable(false);
                textFieldMergedFileName.setDisable(false);
                disableSopMatrixChoice(false);
                labelTLSOutputPath.setText("Output path");
                break;

            default:
                listviewRxpScans.setDisable(true);
                checkboxMergeAfter.setDisable(true);
                textFieldMergedFileName.setDisable(true);
                //disableSopMatrixChoice(true);
                labelTLSOutputPath.setText("Output file");
            }

            if (newValue.intValue() == 0 || newValue.intValue() == 1) {
                checkboxEmptyShotsFilter.setDisable(false);
            } else {
                checkboxEmptyShotsFilter.setDisable(true);
            }
        }
    });

    tabPaneVoxelisation.getSelectionModel().selectedIndexProperty().addListener(new ChangeListener<Number>() {

        @Override
        public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {

            switch (newValue.intValue()) {

            case 1:
                disableSopMatrixChoice(false);
                disablePopMatrixChoice(false);
                checkboxEmptyShotsFilter.setDisable(false);
                break;

            default:
                disableSopMatrixChoice(true);
                disablePopMatrixChoice(true);
                checkboxEmptyShotsFilter.setDisable(true);
            }

            switch (newValue.intValue()) {
            case 0:
                checkboxCalculateGroundEnergy.setDisable(false);

                if (checkboxCalculateGroundEnergy.isSelected()) {
                    anchorPaneGroundEnergyParameters.setDisable(true);
                    checkboxCalculateGroundEnergy.setDisable(false);

                }

                anchorPaneEchoFiltering.getChildren().set(0, anchorPaneEchoFilteringClassifications);

                //anchorPaneEchoFilteringClassifications.setVisible(true);
                anchorpaneBoundingBoxParameters.setDisable(checkboxMultiFiles.isSelected());
                hboxAutomaticBBox.setDisable(false);
                break;
            default:
                anchorPaneGroundEnergyParameters.setDisable(true);
                checkboxCalculateGroundEnergy.setDisable(true);
                anchorPaneEchoFiltering.getChildren().set(0, anchorPaneEchoFilteringRxp);
                //anchorPaneEchoFilteringClassifications.setVisible(false);
                anchorpaneBoundingBoxParameters.setDisable(false);
                hboxAutomaticBBox.setDisable(true);
            }
        }
    });

    int availableCores = Runtime.getRuntime().availableProcessors();

    sliderRSPCoresToUse.setMin(1);
    sliderRSPCoresToUse.setMax(availableCores);
    sliderRSPCoresToUse.setValue(availableCores);

    textFieldInputFileALS.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textFieldTrajectoryFileALS.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textFieldOutputFileALS.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textFieldInputFileTLS.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textFieldOutputFileMerging.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textfieldDTMPath.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textFieldOutputFileGroundEnergy.setOnDragOver(DragAndDropHelper.dragOverEvent);
    listViewTaskList.setOnDragOver(DragAndDropHelper.dragOverEvent);
    listViewProductsFiles.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textfieldVoxelFilePathTransmittance.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textfieldOutputTextFilePath.setOnDragOver(DragAndDropHelper.dragOverEvent);
    textfieldOutputBitmapFilePath.setOnDragOver(DragAndDropHelper.dragOverEvent);

    textFieldInputFileALS.setOnDragDropped(new EventHandler<DragEvent>() {
        @Override
        public void handle(DragEvent event) {
            Dragboard db = event.getDragboard();
            boolean success = false;
            if (db.hasFiles() && db.getFiles().size() == 1) {
                success = true;
                for (File file : db.getFiles()) {
                    if (file != null) {
                        textFieldInputFileALS.setText(file.getAbsolutePath());
                        selectALSInputMode(file);
                    }
                }
            }
            event.setDropCompleted(success);
            event.consume();
        }
    });
    textFieldTrajectoryFileALS.setOnDragDropped(new EventHandler<DragEvent>() {
        @Override
        public void handle(DragEvent event) {
            Dragboard db = event.getDragboard();
            boolean success = false;
            if (db.hasFiles() && db.getFiles().size() == 1) {
                success = true;
                for (File file : db.getFiles()) {
                    if (file != null) {
                        onTrajectoryFileChoosed(file);
                    }
                }
            }
            event.setDropCompleted(success);
            event.consume();
        }
    });

    textFieldInputFileTLS.setOnDragDropped(new EventHandler<DragEvent>() {
        @Override
        public void handle(DragEvent event) {
            Dragboard db = event.getDragboard();
            boolean success = false;
            if (db.hasFiles() && db.getFiles().size() == 1) {
                success = true;
                for (File file : db.getFiles()) {
                    if (file != null) {
                        onInputFileTLSChoosed(file);
                    }
                }
            }
            event.setDropCompleted(success);
            event.consume();
        }
    });

    setDragDroppedSingleFileEvent(textFieldOutputFileALS);
    setDragDroppedSingleFileEvent(textFieldOutputFileMerging);
    setDragDroppedSingleFileEvent(textfieldDTMPath);
    setDragDroppedSingleFileEvent(textFieldOutputFileGroundEnergy);
    setDragDroppedSingleFileEvent(textfieldVoxelFilePathTransmittance);
    setDragDroppedSingleFileEvent(textfieldOutputTextFilePath);
    setDragDroppedSingleFileEvent(textfieldOutputBitmapFilePath);

    listViewTaskList.setOnDragDropped(new EventHandler<DragEvent>() {
        @Override
        public void handle(DragEvent event) {
            Dragboard db = event.getDragboard();
            boolean success = false;
            if (db.hasFiles()) {
                success = true;
                for (File file : db.getFiles()) {
                    addFileToTaskList(file);
                }
            }
            event.setDropCompleted(success);
            event.consume();
        }
    });

    listViewProductsFiles.setOnDragDropped(new EventHandler<DragEvent>() {
        @Override
        public void handle(DragEvent event) {
            Dragboard db = event.getDragboard();
            boolean success = false;
            if (db.hasFiles()) {
                success = true;
                for (File file : db.getFiles()) {
                    addFileToProductsList(file);
                }
            }
            event.setDropCompleted(success);
            event.consume();
        }
    });

    listViewProductsFiles.setOnDragDetected(new EventHandler<MouseEvent>() {

        @Override
        public void handle(MouseEvent event) {

            Dragboard db = listViewProductsFiles.startDragAndDrop(TransferMode.COPY);

            ClipboardContent content = new ClipboardContent();
            content.putFiles(listViewProductsFiles.getSelectionModel().getSelectedItems());
            db.setContent(content);

            event.consume();
        }
    });

    addPointcloudFilterComponent();

    checkboxUsePointcloudFilter.selectedProperty().addListener(new ChangeListener<Boolean>() {

        @Override
        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {

            hBoxPointCloudFiltering.setDisable(!newValue);

            ObservableList<Node> list = vBoxPointCloudFiltering.getChildren();
            for (Node n : list) {
                if (n instanceof PointCloudFilterPaneComponent) {

                    PointCloudFilterPaneComponent panel = (PointCloudFilterPaneComponent) n;
                    panel.disableContent(!newValue);
                }
            }

            buttonAddPointcloudFilter.setDisable(!newValue);

        }
    });

    //displayGThetaAllDistributions();
}

From source file:editeurpanovisu.EditeurPanovisu.java

/**
 *
 * @throws IOException/*  w  w  w .jav  a 2 s  .  c o m*/
 */
private void projetSauve() throws IOException {
    if (!repertSauveChoisi) {
        repertoireProjet = currentDir;
    }
    if (fichProjet == null) {
        FileChooser repertChoix = new FileChooser();
        FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("fichier panoVisu (*.pvu)",
                "*.pvu");
        repertChoix.getExtensionFilters().add(extFilter);
        File repert = new File(repertoireProjet + File.separator);
        repertChoix.setInitialDirectory(repert);
        fichProjet = repertChoix.showSaveDialog(null);

    }
    if (fichProjet != null) {
        sauveFichierProjet();
        ajouteFichierHisto(fichProjet.getAbsolutePath());
    }
}

From source file:editeurpanovisu.EditeurPanovisu.java

/**
 *
 * @throws IOException/*from   ww w.  j a  va  2  s .com*/
 */
private void projetSauveSous() throws IOException {
    if (!repertSauveChoisi) {
        repertoireProjet = currentDir;
    }
    FileChooser repertChoix = new FileChooser();
    FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("fichier panoVisu (*.pvu)",
            "*.pvu");
    repertChoix.getExtensionFilters().add(extFilter);
    File repert = new File(repertoireProjet + File.separator);
    repertChoix.setInitialDirectory(repert);
    fichProjet = repertChoix.showSaveDialog(null);
    if (fichProjet != null) {
        sauveFichierProjet();
        ajouteFichierHisto(fichProjet.getAbsolutePath());

    }

}

From source file:snpviewer.SnpViewer.java

public void drawPaneToPng() {
    if (chromosomeSelector.getSelectionModel().isEmpty()) {
        return;//ww  w.j  a  v  a 2 s  . c o  m
    }
    FileChooser fileChooser = new FileChooser();
    FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("PNG Image Files (*.png)", "*.png");
    fileChooser.getExtensionFilters().add(extFilter);
    fileChooser.setTitle("Save View as Image (.png) File...");
    File pngFile = fileChooser.showSaveDialog(mainWindow);
    if (pngFile == null) {
        return;
    } else if (!pngFile.getName().endsWith(".png")) {
        pngFile = new File(pngFile.getAbsolutePath() + ".png");
    }
    WritableImage image = chromSplitPane.snapshot(null, null);
    if (image == null) {
        Dialogs.showErrorDialog(null, "Error attempting to convert" + " dynamic view to image file",
                "PNG conversion failed", "SNP Viewer");
        return;
    }
    try {
        ImageIO.write(SwingFXUtils.fromFXImage(image, null), "png", pngFile);
        Dialogs.showInformationDialog(null, "Sucessfully saved current view " + "to " + pngFile.getName(),
                "Image Saved", "SNP Viewer");
    } catch (IOException ex) {
        Dialogs.showErrorDialog(null, "Error attempting to convert" + " dynamic view to image file",
                "PNG conversion failed", "SNP Viewer", ex);
    }
}

From source file:snpviewer.SnpViewer.java

public boolean startNewProject() {
    affFiles.clear();//from   w ww  . j av  a  2 s . c  o  m
    unFiles.clear();
    resetObservables();
    genomeVersion = "";
    qualityFilter = null;
    noFilteringRadio.setSelected(true);
    chromSplitPane.getItems().clear();
    labelSplitPane.getItems().clear();
    chromosomeSelector.getItems().clear();
    snpViewSaveDirectory = null;
    clearDragSelectRectangle();
    savedRegions.clear();
    savedRegionsDisplay.clear();
    savedRegionsReference.clear();
    selectionOverlayPane.getChildren().clear();
    selectionOverlayPane.getChildren().add(dragSelectRectangle);

    if (projectRunning) {
        setProgressMode(true);
    }
    FileChooser fileChooser = new FileChooser();
    FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("SNP Viewer Projects (*.svproj)",
            "*.svproj");
    fileChooser.getExtensionFilters().add(extFilter);
    fileChooser.setTitle("Save New SNP Viewer (.svproj) Project As...");
    projectFile = fileChooser.showSaveDialog(mainWindow);
    if (projectFile != null) {
        if (!projectFile.getName().endsWith(".svproj")) {
            projectFile = new File(projectFile.getAbsolutePath() + ".svproj");
        }
        try {
            String projectName = projectFile.getName().replaceAll(".svproj", "");
            File snpViewDir = new File(projectFile.getParentFile() + "/" + projectName + " SNP Viewer files");
            if (snpViewDir.exists()) {
                FileUtils.deleteDirectory(snpViewDir);
            }
            boolean madeDir = snpViewDir.mkdir();
            if (madeDir) {
                snpViewSaveDirectory = snpViewDir;
            } else {
                //display error?
                return false;
            }
        } catch (Exception ex) {
            Dialogs.showErrorDialog(null, "Project Directory Creation Failed", "Error Creating New Project",
                    "Snp Viewer", ex);
        }
        return saveProject(projectFile);
    } else {
        resetView();
        return false;
    }

}

From source file:snpviewer.SnpViewer.java

public void addInputFiles(final boolean isAffected) {
    setProgressMode(true);// ww  w  . j a  v  a2 s.c o  m
    FileChooser fileChooser = new FileChooser();
    fileChooser.getExtensionFilters()
            .add(new FileChooser.ExtensionFilter("Text Files", "*.txt", "AutoSNPa Files", "*.xls"));
    fileChooser.setTitle("Select one or more input (birdseed) files");
    List<File> chosen = fileChooser.showOpenMultipleDialog(null);
    if (chosen == null) {
        setProgressMode(false);
        return;
    }
    cancelButton.setOnAction(new EventHandler<ActionEvent>() {
        @Override
        public void handle(ActionEvent actionEvent) {
            setProgressMode(false);
        };
    });
    ArrayList<File> inputFiles = new ArrayList<>();
    inputFiles.addAll(chosen);
    ArrayList<File> duplicates = new ArrayList<>();
    ArrayList<Integer> indicesToRemove = new ArrayList<>();
    for (int i = 0; i < inputFiles.size(); i++) {
        for (SnpFile s : affFiles) {
            if (inputFiles.get(i).getName().equals(s.getInputFileName())) {
                duplicates.add(inputFiles.get(i));
                indicesToRemove.add(i);
            }
        }
        for (SnpFile s : unFiles) {
            if (inputFiles.get(i).getName().equals(s.getInputFileName())) {
                duplicates.add(inputFiles.get(i));
                indicesToRemove.add(i);
            }
        }
    }
    if (!duplicates.isEmpty()) {
        StringBuilder duplicateString = new StringBuilder();
        for (File d : duplicates) {
            duplicateString.append(d.getName()).append("\n");
        }
        Collections.sort(indicesToRemove, Collections.reverseOrder());
        for (int i : indicesToRemove) {
            inputFiles.remove(i);
        }
        DialogResponse response = Dialogs.showWarningDialog(null,
                "This project already includes the following file(s) with "
                        + "matching names to the file(s) you have just tried to add:" + "\n\n" + duplicateString
                        + "\nIf you want to change the affected "
                        + "status of a file please remove it first.  Any remaining "
                        + "(non-duplicate) files will be processed if you click 'OK'.",
                "Duplicate Input File", "SnpViewer", Dialogs.DialogOptions.OK_CANCEL);
        if (!response.equals(DialogResponse.OK)) {
            setProgressMode(false);
            return;
        }
    }
    if (inputFiles.isEmpty()) {
        setProgressMode(false);
        return;
    }
    final Iterator iter = inputFiles.iterator();
    File input = (File) iter.next();
    int fileCounter = 1;
    if (snpViewSaveDirectory == null) {
        Dialogs.showWarningDialog(null, "Before processing input files " + "please create a project",
                "Create Project", "SNP Viewer");

        boolean success = startNewProject();

        if (!success) {
            setProgressMode(false);
            return;
        }
    }

    addInputFilesWithIterator(isAffected, input, iter, fileCounter, inputFiles.size());
}

From source file:snpviewer.SnpViewer.java

public boolean saveProject() {
    if (projectFile != null) {
        return saveProject(projectFile);
    } else {/*ww w.  j  av  a2s . c o m*/
        FileChooser fileChooser = new FileChooser();
        fileChooser.setTitle("Save Snp Viewer Project (.svproj) As...");
        FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("SNP Viewer Projects",
                "*.svproj");
        fileChooser.getExtensionFilters().add(extFilter);
        projectFile = fileChooser.showSaveDialog(mainWindow);
        if (projectFile != null) {
            if (!projectFile.getName().endsWith(".svproj")) {
                projectFile = new File(projectFile.getAbsolutePath() + ".svproj");
            }
            return saveProject(projectFile);

        } else {
            return false;
        }
    }
}

From source file:snpviewer.SnpViewer.java

public void loadProject() {
    if (projectRunning) {
        /*setProgressMode(true);
        DialogResponse response = Dialogs.showConfirmDialog(null,
        "Do you want to save your current project before starting a new one?", 
            "Save Current Project?", "SNP View");
        if (DialogResponse.YES.equals(response)){
        boolean saved = saveProject();/*from ww  w .  j a  v  a 2  s  .  com*/
        if (! saved){
            setProgressMode(false);
            return;
        }else{
            Dialogs.showInformationDialog(null, projectFile.getName() + " saved sucessfully", 
                    "Save Successful", "SNP View");
        }
        }else if (DialogResponse.CANCEL.equals(response)){
        setProgressMode(false);
        return;
        }*/
    }
    loadProjectButton.setDisable(true);
    newProjectButton.setDisable(true);
    FileChooser fileChooser = new FileChooser();
    fileChooser.getExtensionFilters().add(new FileChooser.ExtensionFilter("SNP Viewer Projects", "*.svproj"));
    fileChooser.setTitle("Open SNP Viewer Project (.svproj) file");
    //setProgressMode(false);
    File loadFile = fileChooser.showOpenDialog(mainWindow);
    loadProjectButton.setDisable(false);
    newProjectButton.setDisable(false);
    if (loadFile != null) {
        try {
            ObjectInputStream is = new ObjectInputStream(
                    new BufferedInputStream(new FileInputStream(loadFile)));
            try {
                projectFile = null;
                projectLabel.setText("Project: none");
                chromSplitPane.getItems().clear();
                labelSplitPane.getItems().clear();
                clearDragSelectRectangle();
                savedRegions.clear();
                savedRegionsDisplay.clear();
                savedRegionsReference.clear();
                selectionOverlayPane.getChildren().clear();
                selectionOverlayPane.getChildren().add(dragSelectRectangle);

                resetObservables();
                genomeVersion = "";
                qualityFilter = null;
                noFilteringRadio.setSelected(true);
                chromosomeSelector.getItems().clear();
                projectFile = (File) is.readObject();//get rid of this?
                projectFile = loadFile;//allow relative referencing

                ArrayList<Color> loadedColors = new ArrayList<>();
                ArrayList<SnpFile> tempAff = new ArrayList<>();
                ArrayList<SnpFile> tempUn = new ArrayList<>();
                tempAff.addAll((ArrayList<SnpFile>) is.readObject());
                tempUn.addAll((ArrayList<SnpFile>) is.readObject());
                ArrayList<SnpFile> tempBoth = new ArrayList<>();
                tempBoth.addAll(tempAff);
                tempBoth.addAll(tempUn);
                genomeVersion = (String) is.readObject();
                qualityFilter = (Double) is.readObject();
                buildLabel.setText(genomeVersion);
                snpViewSaveDirectory = (File) is.readObject();
                savedRegions = (ArrayList<RegionSummary>) is.readObject();
                String projectName = projectFile.getName().replaceAll(".svproj", "");
                if (!snpViewSaveDirectory.exists()) {
                    snpViewSaveDirectory = new File(
                            projectFile.getParentFile() + "/" + projectName + " SNP Viewer files");
                    if (!snpViewSaveDirectory.exists()) {
                        DialogResponse response = Dialogs.showErrorDialog(null,
                                "Can't find project directory (" + snpViewSaveDirectory.getName()
                                        + ") - do you " + "want to try to find it?",
                                "Project directory " + "not found", "SnpViewer", Dialogs.DialogOptions.YES_NO);
                        if (DialogResponse.YES.equals(response)) {
                            DirectoryChooser dirChooser = new DirectoryChooser();
                            dirChooser.setTitle("Locate Project Folder");
                            snpViewSaveDirectory = dirChooser.showDialog(mainWindow);
                            if (snpViewSaveDirectory == null) {
                                returnToInitialState();
                                return;
                            }
                        } else {
                            returnToInitialState();
                            return;
                        }
                    }
                }
                boolean check = checkProjectFolder(snpViewSaveDirectory, tempBoth);
                if (!check) {
                    Dialogs.showErrorDialog(null, "Corrupt project" + " folder - missing files.",
                            "Invalid " + "project folder.", "SnpViewer");
                    returnToInitialState();
                    return;
                }
                for (Color c : colorComp) {
                    String colorString = (String) is.readObject();
                    loadedColors.add(Color.valueOf(colorString));
                }
                for (int ci = 0; ci < loadedColors.size(); ci++) {
                    colorComponantSelector.getSelectionModel().clearAndSelect(ci);
                    colorPicker.setValue(loadedColors.get(ci));
                    colorPicker.fireEvent(new ActionEvent());
                }
                affObserve.addAll(tempAff);
                unObserve.addAll(tempUn);
                colorComponantSelector.getSelectionModel().selectFirst();
                colorComp.clear();
                colorComp.addAll(loadedColors);
                is.close();
                setQualityLabel();
                checkQualitySelection();
                saveProject();
                projectLabel.setText("Project: " + projectFile.getName());
                //addToChromosomeSelector(affFiles);
                //addToChromosomeSelector(unFiles);
                if (!chromosomeSelector.getItems().isEmpty()) {
                    chromosomeSelector.getSelectionModel().selectFirst();
                }
                if (chromosomeSelector.isDisabled()) {
                    chromosomeSelector.setDisable(false);
                }
                //setProgressMode(false);
                if (affObserve.isEmpty() && unObserve.isEmpty()) {
                    resetView();
                }
                projectRunning = true;

            } catch (IOException | ClassNotFoundException ex) {
                resetView();
                projectLabel.setText("Project: none");
                savedRegions.clear();
                savedRegionsDisplay.clear();
                savedRegionsReference.clear();
                resetObservables();
                genomeVersion = "";
                qualityFilter = null;
                noFilteringRadio.setSelected(true);
                chromosomeSelector.getItems().clear();
                ex.printStackTrace();
                Dialogs.showErrorDialog(null, "Could not load project file", "Load Failed", "SNP Viewer", ex);
            }
        } catch (IOException ex) {
            resetView();
            projectLabel.setText("Project: none");
            savedRegions.clear();
            savedRegionsDisplay.clear();
            savedRegionsReference.clear();
            resetObservables();
            genomeVersion = "";
            qualityFilter = null;
            noFilteringRadio.setSelected(true);
            chromosomeSelector.getItems().clear();
            ex.printStackTrace();
            Dialogs.showErrorDialog(null, "Could not load project file - IO error", "Load Failed", "SNP Viewer",
                    ex);
        }
    }
}