You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
765 lines
25 KiB
765 lines
25 KiB
package gui;
|
|
|
|
import static data.CorpusType.*;
|
|
import static gui.GUIController.*;
|
|
import static gui.Messages.*;
|
|
import static util.Util.*;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Constructor;
|
|
import java.lang.reflect.Field;
|
|
import java.util.*;
|
|
|
|
import javafx.scene.layout.AnchorPane;
|
|
import javafx.util.Duration;
|
|
import org.apache.commons.io.FileUtils;
|
|
import org.apache.commons.io.IOCase;
|
|
import org.apache.commons.io.LineIterator;
|
|
import org.apache.commons.io.filefilter.FileFilterUtils;
|
|
import org.apache.commons.io.filefilter.TrueFileFilter;
|
|
import org.apache.logging.log4j.LogManager;
|
|
import org.apache.logging.log4j.Logger;
|
|
|
|
import alg.XML_processing;
|
|
import data.Corpus;
|
|
import data.CorpusType;
|
|
import data.Enums.solar.SolarFilters;
|
|
import data.Tax;
|
|
import javafx.collections.ObservableList;
|
|
import javafx.concurrent.Task;
|
|
import javafx.fxml.FXML;
|
|
import javafx.scene.control.*;
|
|
import javafx.scene.layout.Pane;
|
|
import javafx.stage.DirectoryChooser;
|
|
import javafx.stage.Stage;
|
|
import javafx.application.HostServices;
|
|
|
|
public class CorpusTab {
|
|
public final static Logger logger = LogManager.getLogger(CorpusTab.class);
|
|
public Pane setCorpusWrapperP;
|
|
|
|
private Stage stage;
|
|
|
|
@FXML
|
|
private AnchorPane corpusTabPane;
|
|
|
|
@FXML
|
|
private Button chooseCorpusLocationB;
|
|
private File chosenCorpusLocation;
|
|
|
|
@FXML
|
|
private CheckBox readHeaderInfoChB;
|
|
private boolean readHeaderInfo;
|
|
|
|
// @FXML
|
|
// private CheckBox gosUseOrthChB;
|
|
// private boolean gosUseOrth;
|
|
|
|
@FXML
|
|
private Button chooseResultsLocationB;
|
|
|
|
@FXML
|
|
private Button changeLanguageB;
|
|
|
|
@FXML
|
|
private Label chooseCorpusL;
|
|
private String chooseCorpusLabelContent;
|
|
|
|
@FXML
|
|
private Label chooseResultsL;
|
|
private String chooseResultsLabelContent;
|
|
|
|
@FXML
|
|
private ProgressIndicator locationScanPI;
|
|
|
|
@FXML
|
|
private Hyperlink helpH;
|
|
|
|
// *** shared ***
|
|
private Corpus corpus;
|
|
private CorpusType corpusType;
|
|
|
|
// tabs - used to enable/disable
|
|
private Tab stringLevelTabNew2;
|
|
private Tab oneWordAnalysisTab;
|
|
private Tab characterLevelTab;
|
|
private Tab wordFormationTab;
|
|
private Tab wordLevelTab;
|
|
private Tab filterTab;
|
|
private TabPane tabPane;
|
|
private StringAnalysisTabNew2 satNew2Controller;
|
|
private OneWordAnalysisTab oneWordTabController;
|
|
private CharacterAnalysisTab catController;
|
|
private FiltersForSolar ffsController;
|
|
private WordFormationTab wfController;
|
|
private WordLevelTab wlController;
|
|
private HostServices hostService;
|
|
|
|
private String corpusLocation;
|
|
private String corpusFilesSize;
|
|
|
|
/**
|
|
* Hack allowing to modify the default behavior of the tooltips.
|
|
* @param openDelay The open delay, knowing that by default it is set to 1000.
|
|
* @param visibleDuration The visible duration, knowing that by default it is set to 5000.
|
|
* @param closeDelay The close delay, knowing that by default it is set to 200.
|
|
* @param hideOnExit Indicates whether the tooltip should be hide on exit,
|
|
* knowing that by default it is set to false.
|
|
*/
|
|
private static void updateTooltipBehavior(double openDelay, double visibleDuration,
|
|
double closeDelay, boolean hideOnExit) {
|
|
try {
|
|
// Get the non public field "BEHAVIOR"
|
|
Field fieldBehavior = Tooltip.class.getDeclaredField("BEHAVIOR");
|
|
// Make the field accessible to be able to get and set its value
|
|
fieldBehavior.setAccessible(true);
|
|
// Get the value of the static field
|
|
Object objBehavior = fieldBehavior.get(null);
|
|
// Get the constructor of the private static inner class TooltipBehavior
|
|
Constructor<?> constructor = objBehavior.getClass().getDeclaredConstructor(
|
|
Duration.class, Duration.class, Duration.class, boolean.class
|
|
);
|
|
// Make the constructor accessible to be able to invoke it
|
|
constructor.setAccessible(true);
|
|
// Create a new instance of the private static inner class TooltipBehavior
|
|
Object tooltipBehavior = constructor.newInstance(
|
|
new Duration(openDelay), new Duration(visibleDuration),
|
|
new Duration(closeDelay), hideOnExit
|
|
);
|
|
// Set the new instance of TooltipBehavior
|
|
fieldBehavior.set(null, tooltipBehavior);
|
|
} catch (Exception e) {
|
|
throw new IllegalStateException(e);
|
|
}
|
|
}
|
|
|
|
public void initialize() {
|
|
updateTooltipBehavior(0.0, 30000.0,0.0, true);
|
|
|
|
// add CSS style
|
|
corpusTabPane.getStylesheets().add("style.css");
|
|
corpusTabPane.getStyleClass().add("root");
|
|
|
|
stage = new Stage();
|
|
|
|
manageTranslations();
|
|
|
|
// add listeners
|
|
chooseCorpusLocationB.setOnAction(e -> chooseCorpusLocation());
|
|
chooseCorpusLocationB.setTooltip(new Tooltip(I18N.get("message.TOOLTIP_chooseCorpusLocationB")));
|
|
helpH.setOnAction(e -> openHelpWebsite());
|
|
|
|
readHeaderInfoChB.selectedProperty().addListener((observable, oldValue, newValue) -> {
|
|
readHeaderInfo = newValue;
|
|
logger.info("read headers: ", readHeaderInfo);
|
|
});
|
|
readHeaderInfoChB.setTooltip(new Tooltip(I18N.get("message.TOOLTIP_readHeaderInfoChB")));
|
|
|
|
// gosUseOrthChB.selectedProperty().addListener((observable, oldValue, newValue) -> {
|
|
// gosUseOrth = newValue;
|
|
// corpus.setGosOrthMode(gosUseOrth);
|
|
//// wordFormationTab.setDisable(gosUseOrth);
|
|
// satNew2Controller.toggleMode(null);
|
|
// oneWordTabController.toggleMode(null);
|
|
// catController.toggleMode(null);
|
|
//
|
|
// logger.info("gosUseOrth: ", gosUseOrth);
|
|
// });
|
|
|
|
chooseResultsLocationB.setOnAction(e -> chooseResultsLocation(null));
|
|
|
|
changeLanguageB.setOnAction(e -> {
|
|
if (I18N.getLocale() == new Locale.Builder().setLanguage("sl").setRegion("SI").build()){
|
|
I18N.setLocale(Locale.ENGLISH);
|
|
} else {
|
|
I18N.setLocale(new Locale.Builder().setLanguage("sl").setRegion("SI").build());
|
|
}
|
|
Messages.reload();
|
|
|
|
// StringBuilder sb = new StringBuilder();
|
|
// sb.append(corpusLocation)
|
|
// .append("\n")
|
|
// .append(String.format(I18N.get("message.NOTIFICATION_FOUND_X_FILES"), corpusFilesSize))
|
|
// .append("\n")
|
|
// .append(String.format(I18N.get("message.NOTIFICATION_CORPUS"), corpusType.toString()));
|
|
//
|
|
// chooseCorpusLabelContent = sb.toString();
|
|
// chooseCorpusL.textProperty().unbind();
|
|
// chooseCorpusL.setText(chooseCorpusLabelContent);
|
|
Messages.updateChooseCorpusL();
|
|
|
|
logger.info("change language");
|
|
});
|
|
|
|
// set labels and toggle visibility
|
|
// toggleGosChBVisibility();
|
|
|
|
// chooseCorpusLabelContent = Messages.LABEL_CORPUS_LOCATION_NOT_SET;
|
|
// chooseCorpusL.setText(chooseCorpusLabelContent);
|
|
//
|
|
// chooseResultsLabelContent = Messages.LABEL_RESULTS_LOCATION_NOT_SET;
|
|
// chooseResultsL.setText(chooseResultsLabelContent);
|
|
|
|
togglePiAndSetCorpusWrapper(false);
|
|
}
|
|
|
|
private void manageTranslations(){
|
|
chooseCorpusLocationB.textProperty().bind(I18N.createStringBinding("button.setCorpusLocation"));
|
|
readHeaderInfoChB.textProperty().bind(I18N.createStringBinding("checkBox.readHeaderInfo"));
|
|
chooseResultsLocationB.textProperty().bind(I18N.createStringBinding("button.chooseResultsLocation"));
|
|
helpH.textProperty().bind(I18N.createStringBinding("hyperlink.help"));
|
|
changeLanguageB.textProperty().bind(I18N.createStringBinding("button.language"));
|
|
chooseCorpusL.textProperty().bind(I18N.createStringBinding("message.LABEL_CORPUS_LOCATION_NOT_SET"));
|
|
chooseResultsL.textProperty().bind(I18N.createStringBinding("message.LABEL_RESULTS_LOCATION_NOT_SET"));
|
|
|
|
}
|
|
|
|
private void togglePiAndSetCorpusWrapper(boolean piIsActive) {
|
|
locationScanPI.setVisible(piIsActive);
|
|
setCorpusWrapperP.setLayoutX(piIsActive ? 100.0 : 10.0);
|
|
}
|
|
|
|
private void openHelpWebsite(){
|
|
hostService.showDocument(Messages.HELP_URL);
|
|
}
|
|
|
|
/**
|
|
* In order for a directory to pass as a valid corpus location, following criteria has to be met:
|
|
* <ul>
|
|
* <li>it can't be null</li>
|
|
* <li>it has to be readable</li>
|
|
* <li>it has to contain xml files</li>
|
|
* <li>xml files have to contain valid headers from which we can infer the corpus type</li>
|
|
* <li>corpus type must be one of the expected corpus types - as noted in the @see data.CorpusType.class </li>
|
|
* </ul>
|
|
* <p>
|
|
* Additionally, if the user checks to read taxonomy/filters from the corpus files, that read
|
|
* has to produce a non-empty list results list
|
|
*/
|
|
private void chooseCorpusLocation() {
|
|
File selectedDirectory = directoryChooser();
|
|
|
|
if (selectedDirectory != null && ValidationUtil.isReadableDirectory(selectedDirectory)) {
|
|
logger.info("selected corpus dir: ", selectedDirectory.getAbsolutePath());
|
|
|
|
// scan for xml files
|
|
Collection<File> corpusFiles = FileUtils.listFiles(selectedDirectory, FileFilterUtils.suffixFileFilter("xml", IOCase.INSENSITIVE), TrueFileFilter.INSTANCE);
|
|
|
|
|
|
// make sure there are corpus files in selected directory or notify the user about it
|
|
if (corpusFiles.size() == 0) {
|
|
// try .vert
|
|
corpusFiles = FileUtils.listFiles(selectedDirectory, FileFilterUtils.suffixFileFilter("vert", IOCase.INSENSITIVE), TrueFileFilter.INSTANCE);
|
|
Collection<File> corpusFilesRegi = FileUtils.listFiles(selectedDirectory, FileFilterUtils.suffixFileFilter("regi", IOCase.INSENSITIVE), TrueFileFilter.INSTANCE);
|
|
|
|
|
|
// if (!checkRegiFile(corpusFilesRegi)){
|
|
// return;
|
|
// }
|
|
|
|
if (corpusFiles.size() == 0){
|
|
logger.info("alert: ", I18N.get("message.WARNING_CORPUS_NOT_FOUND"));
|
|
showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_CORPUS_NOT_FOUND"), null);
|
|
} else if (corpusFilesRegi.size() == 0){
|
|
GUIController.showAlert(Alert.AlertType.ERROR, String.format(I18N.get("message.ERROR_NO_REGI_FILE_FOUND"), selectedDirectory.getAbsolutePath()));
|
|
} else {
|
|
corpusLocation = selectedDirectory.getAbsolutePath();
|
|
corpusFilesSize = String.valueOf(corpusFiles.size());
|
|
Messages.setChooseCorpusProperties(corpusLocation, corpusFilesSize, corpusType != null ? corpusType.toString() : null);
|
|
corpusType = VERT;
|
|
|
|
corpus.setCorpusType(corpusType);
|
|
|
|
Messages.setChooseCorpusProperties(corpusLocation, corpusFilesSize, corpusType.toString());
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(corpusLocation)
|
|
.append("\n")
|
|
.append(String.format(I18N.get("message.NOTIFICATION_FOUND_X_FILES"), corpusFiles.size()))
|
|
.append("\n")
|
|
.append(String.format(I18N.get("message.NOTIFICATION_CORPUS"), corpusType.toString()));
|
|
|
|
String result = sb.toString();
|
|
|
|
logger.debug(result);
|
|
|
|
initNewCorpus(selectedDirectory, corpusFiles);
|
|
Messages.setChooseCorpusProperties(corpusLocation, corpusFilesSize, corpusType.toString());
|
|
|
|
corpus.setChosenCorpusLocation(selectedDirectory);
|
|
corpus.setDetectedCorpusFiles(corpusFiles);
|
|
|
|
chooseCorpusLabelContent = result;
|
|
if (readHeaderInfo) {
|
|
logger.info("reading header info...");
|
|
readHeaderInfo();
|
|
} else {
|
|
setResults();
|
|
|
|
setCorpusForAnalysis();
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
corpusLocation = selectedDirectory.getAbsolutePath();
|
|
corpusFilesSize = String.valueOf(corpusFiles.size());
|
|
Messages.setChooseCorpusProperties(corpusLocation, corpusFilesSize, corpusType != null ? corpusType.toString() : null);
|
|
|
|
String chooseCorpusLabelContentTmp = detectCorpusType(corpusFiles);
|
|
|
|
if (chooseCorpusLabelContentTmp == null) {
|
|
logger.info("alert: ", I18N.get("message.WARNING_CORPUS_NOT_FOUND"));
|
|
showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_CORPUS_NOT_FOUND"), null);
|
|
} else {
|
|
|
|
initNewCorpus(selectedDirectory, corpusFiles);
|
|
Messages.setChooseCorpusProperties(corpusLocation, corpusFilesSize, corpusType.toString());
|
|
|
|
corpus.setChosenCorpusLocation(selectedDirectory);
|
|
corpus.setDetectedCorpusFiles(corpusFiles);
|
|
chooseCorpusLabelContent = chooseCorpusLabelContentTmp;
|
|
logger.info("corpus dir: ", corpus.getChosenCorpusLocation().getAbsolutePath());
|
|
|
|
if (readHeaderInfo) {
|
|
logger.info("reading header info...");
|
|
readHeaderInfo();
|
|
} else {
|
|
setResults();
|
|
|
|
setCorpusForAnalysis();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If a user selects a valid corpus location, we define a new corpus (so none of the old data gets carried over)
|
|
*
|
|
* @param selectedDirectory
|
|
* @param corpusFiles
|
|
*/
|
|
private void initNewCorpus(File selectedDirectory, Collection<File> corpusFiles) {
|
|
corpus = new Corpus();
|
|
corpus.setCorpusType(corpusType);
|
|
corpus.setDetectedCorpusFiles(corpusFiles);
|
|
corpus.setChosenCorpusLocation(selectedDirectory);
|
|
chooseResultsLocation(selectedDirectory);
|
|
}
|
|
|
|
private void chooseResultsLocation(File dir) {
|
|
// results location can be set either to default value (after selecting valid corpus location) - dir attribute
|
|
// or to a dir picked via directoryChooser (when dir == null
|
|
File selectedDirectory = dir == null ? directoryChooser() : dir;
|
|
|
|
if (selectedDirectory != null) {
|
|
String resultsLocationPath = selectedDirectory.getAbsolutePath().concat(File.separator);
|
|
File chosenResultsLocationTmp = new File(resultsLocationPath);
|
|
|
|
if (!ValidationUtil.isValidDirectory(chosenResultsLocationTmp)) {
|
|
showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_RESULTS_DIR_NOT_VALID"));
|
|
logger.info("alert: ", I18N.get("message.WARNING_RESULTS_DIR_NOT_VALID"));
|
|
} else {
|
|
corpus.setChosenResultsLocation(chosenResultsLocationTmp);
|
|
chooseResultsLabelContent = corpus.getChosenResultsLocation().getAbsolutePath();
|
|
chooseResultsL.textProperty().unbind();
|
|
chooseResultsL.setText(chooseResultsLabelContent);
|
|
logger.info("results dir: " + chooseResultsLabelContent);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setResults() {
|
|
// if everything is ok
|
|
// check and enable checkbox if GOS
|
|
// toggleGosChBVisibility();
|
|
|
|
// set default results location
|
|
String defaultResultsLocationPath = corpus.getChosenCorpusLocation().getAbsolutePath();
|
|
logger.info("setting default results location to: ", defaultResultsLocationPath);
|
|
|
|
Messages.setChooseCorpusL(chooseCorpusL, chooseCorpusLabelContent);
|
|
}
|
|
|
|
private boolean checkRegiFile(Collection<File> corpusFiles) {
|
|
// CorpusType corpusType = corpus.getCorpusType();
|
|
// Collection<File> corpusFiles = corpus.getDetectedCorpusFiles();
|
|
|
|
|
|
for (File file : corpusFiles) {
|
|
// try to open .regi file
|
|
String regiPath = file.getAbsolutePath().substring(0, file.getAbsolutePath().length() - 4) + "regi";
|
|
LineIterator regiIt;
|
|
try {
|
|
// read regi file
|
|
regiIt = FileUtils.lineIterator(new File(regiPath), "UTF-8");
|
|
LineIterator.closeQuietly(regiIt);
|
|
} catch (IOException e) {
|
|
GUIController.showAlert(Alert.AlertType.ERROR, String.format(I18N.get("message.ERROR_NO_REGI_FILE_FOUND"), regiPath));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
}
|
|
|
|
private void readHeaderInfo() {
|
|
CorpusType corpusType = corpus.getCorpusType();
|
|
Collection<File> corpusFiles = corpus.getDetectedCorpusFiles();
|
|
togglePiAndSetCorpusWrapper(true);
|
|
chooseCorpusL.textProperty().unbind();
|
|
chooseCorpusL.setText(I18N.get("message.LABEL_SCANNING_CORPUS"));
|
|
|
|
logger.info("reading header data for ", corpusType.toString());
|
|
|
|
if (corpusType == CorpusType.GIGAFIDA || corpusType == CorpusType.GOS || corpusType == CorpusType.CCKRES || corpusType == CorpusType.SSJ500K || corpusType == CorpusType.GIGAFIDA2) {
|
|
boolean corpusIsSplit = corpusFiles.size() > 1;
|
|
|
|
final Task<HashSet<String>> task = new Task<HashSet<String>>() {
|
|
@Override
|
|
protected HashSet<String> call() throws Exception {
|
|
HashSet<String> values = new HashSet<>();
|
|
long i = 0;
|
|
|
|
if (!corpusIsSplit) {
|
|
updateProgress(-1.0f, -1.0f);
|
|
}
|
|
|
|
for (File file : corpusFiles) {
|
|
values.addAll((Collection<? extends String>) XML_processing.readXmlHeaderTaxonomyAndFilters(file.getAbsolutePath(), corpusIsSplit, corpusType));
|
|
i++;
|
|
|
|
if (corpusIsSplit) {
|
|
// System.out.println(i);
|
|
// System.out.println(corpusFiles.size());
|
|
updateProgress(i, corpusFiles.size());
|
|
}
|
|
}
|
|
|
|
updateProgress(1.0f, 1.0f);
|
|
return values;
|
|
}
|
|
};
|
|
|
|
locationScanPI.progressProperty().bind(task.progressProperty());
|
|
|
|
task.setOnSucceeded(e -> {
|
|
ObservableList<String> readTaxonomy = Tax.getTaxonomyForComboBox(corpusType, task.getValue());
|
|
|
|
if (ValidationUtil.isEmpty(readTaxonomy)) {
|
|
// if no taxonomy found alert the user and keep other tabs disabled
|
|
logger.info("No taxonomy found in headers.");
|
|
GUIController.showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_NO_TAXONOMY_FOUND"));
|
|
} else {
|
|
// set taxonomy, update label
|
|
corpus.setTaxonomy(readTaxonomy);
|
|
corpus.setHeaderRead(true);
|
|
Messages.setChooseCorpusL(chooseCorpusL, chooseCorpusLabelContent);
|
|
setResults();
|
|
setCorpusForAnalysis();
|
|
}
|
|
|
|
togglePiAndSetCorpusWrapper(false);
|
|
|
|
});
|
|
|
|
task.setOnCancelled(e -> togglePiAndSetCorpusWrapper(false));
|
|
task.setOnFailed(e -> togglePiAndSetCorpusWrapper(false));
|
|
|
|
final Thread thread = new Thread(task, "task");
|
|
thread.setDaemon(true);
|
|
thread.start();
|
|
} else if (corpusType == CorpusType.SOLAR) {
|
|
// many many fields
|
|
boolean corpusIsSplit = corpusFiles.size() > 1;
|
|
|
|
final Task<HashMap<String, HashSet<String>>> task = new Task<HashMap<String, HashSet<String>>>() {
|
|
@Override
|
|
protected HashMap<String, HashSet<String>> call() throws Exception {
|
|
HashMap<String, HashSet<String>> values = new HashMap<>();
|
|
long i = 0;
|
|
|
|
if (!corpusIsSplit) {
|
|
updateProgress(-1.0f, -1.0f);
|
|
}
|
|
|
|
for (File file : corpusFiles) {
|
|
HashMap<String, HashSet<String>> tmpvalues = (HashMap<String, HashSet<String>>) XML_processing.readXmlHeaderTaxonomyAndFilters(file.getAbsolutePath(), corpusIsSplit, corpusType);
|
|
|
|
// update final results
|
|
for (Map.Entry<String, HashSet<String>> entry : tmpvalues.entrySet()) {
|
|
if (values.containsKey(entry.getKey())) {
|
|
values.get(entry.getKey()).addAll(entry.getValue());
|
|
} else {
|
|
values.put(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
|
|
i++;
|
|
|
|
if (corpusIsSplit) {
|
|
updateProgress(i, corpusFiles.size());
|
|
}
|
|
}
|
|
|
|
updateProgress(1.0f, 1.0f);
|
|
return values;
|
|
}
|
|
};
|
|
|
|
locationScanPI.progressProperty().bind(task.progressProperty());
|
|
|
|
task.setOnSucceeded(e -> {
|
|
HashMap<String, HashSet<String>> values = task.getValue();
|
|
|
|
if (ValidationUtil.isEmpty(values)) {
|
|
// if no taxonomy found alert the user and keep other tabs disabled
|
|
logger.info("No solar filters found in headers.");
|
|
GUIController.showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_NO_SOLAR_FILTERS_FOUND"));
|
|
} else {
|
|
HashMap<String, ObservableList<String>> filtersForComboBoxes = SolarFilters.getFiltersForComboBoxes(values);
|
|
// set taxonomy, update label
|
|
corpus.setSolarFiltersForXML(values);
|
|
corpus.setSolarFilters(filtersForComboBoxes);
|
|
corpus.setHeaderRead(true);
|
|
Messages.setChooseCorpusL(chooseCorpusL, chooseCorpusLabelContent);
|
|
setResults();
|
|
setCorpusForAnalysis();
|
|
}
|
|
|
|
togglePiAndSetCorpusWrapper(false);
|
|
|
|
});
|
|
|
|
task.setOnCancelled(e -> togglePiAndSetCorpusWrapper(false));
|
|
task.setOnFailed(e -> togglePiAndSetCorpusWrapper(false));
|
|
|
|
final Thread thread = new Thread(task, "task");
|
|
thread.setDaemon(true);
|
|
thread.start();
|
|
} else if (corpusType == CorpusType.VERT) {
|
|
// many many fields
|
|
boolean corpusIsSplit = corpusFiles.size() > 1;
|
|
|
|
final Task<HashSet<String>> task = new Task<HashSet<String>>() {
|
|
@Override
|
|
protected HashSet<String> call() throws Exception {
|
|
HashSet<String> values = new HashSet<>();
|
|
long i = 0;
|
|
|
|
if (!corpusIsSplit) {
|
|
updateProgress(-1.0f, -1.0f);
|
|
}
|
|
|
|
for (File file : corpusFiles) {
|
|
HashSet<String> tmpvalues = XML_processing.readVertHeaderTaxonomyAndFilters(file.getAbsolutePath(), corpusIsSplit, corpusType);
|
|
|
|
// update final results
|
|
for (String entry : tmpvalues) {
|
|
if (!entry.equals("-")) {
|
|
values.add(entry);
|
|
}
|
|
}
|
|
|
|
i++;
|
|
|
|
if (corpusIsSplit) {
|
|
updateProgress(i, corpusFiles.size());
|
|
}
|
|
}
|
|
|
|
updateProgress(1.0f, 1.0f);
|
|
return values;
|
|
}
|
|
};
|
|
|
|
locationScanPI.progressProperty().bind(task.progressProperty());
|
|
|
|
task.setOnSucceeded(e -> {
|
|
ObservableList<String> readTaxonomy = Tax.getTaxonomyForComboBox(corpusType, task.getValue());
|
|
|
|
// if (ValidationUtil.isEmpty(readTaxonomy)) {
|
|
// // if no taxonomy found alert the user and keep other tabs disabled
|
|
// logger.info("No vert filters found in headers.");
|
|
// GUIController.showAlert(Alert.AlertType.ERROR, I18N.get("message.WARNING_NO_SOLAR_FILTERS_FOUND"));
|
|
// } else {
|
|
// set taxonomy, update label
|
|
corpus.setTaxonomy(readTaxonomy);
|
|
corpus.setHeaderRead(true);
|
|
Messages.setChooseCorpusL(chooseCorpusL, chooseCorpusLabelContent);
|
|
setResults();
|
|
setCorpusForAnalysis();
|
|
// }
|
|
|
|
togglePiAndSetCorpusWrapper(false);
|
|
|
|
});
|
|
|
|
task.setOnCancelled(e -> togglePiAndSetCorpusWrapper(false));
|
|
task.setOnFailed(e -> togglePiAndSetCorpusWrapper(false));
|
|
|
|
|
|
final Thread thread = new Thread(task, "task");
|
|
thread.setDaemon(true);
|
|
thread.start();
|
|
}
|
|
|
|
}
|
|
|
|
private void setCorpusForAnalysis() {
|
|
if (corpus.validate()) {
|
|
// new statistic, enable tabs...
|
|
stringLevelTabNew2.setDisable(false);
|
|
satNew2Controller.setCorpus(corpus);
|
|
satNew2Controller.init();
|
|
oneWordAnalysisTab.setDisable(false);
|
|
oneWordTabController.setCorpus(corpus);
|
|
oneWordTabController.init();
|
|
characterLevelTab.setDisable(false);
|
|
catController.setCorpus(corpus);
|
|
catController.init();
|
|
//wordFormationTab.setDisable(false);
|
|
wordLevelTab.setDisable(false);
|
|
//wfController.setCorpus(corpus);
|
|
//wfController.init();
|
|
wlController.setCorpus(corpus);
|
|
wlController.init();
|
|
|
|
if (corpus.getCorpusType() == CorpusType.SOLAR) {
|
|
filterTab.setDisable(false);
|
|
tabPane.getTabs().add(1, filterTab);
|
|
ffsController.setCorpus(corpus);
|
|
ffsController.initFilters();
|
|
} else {
|
|
filterTab.setDisable(true);
|
|
tabPane.getTabs().removeAll(filterTab);
|
|
}
|
|
} else {
|
|
GUIController.showAlert(Alert.AlertType.ERROR, corpus.getValidationErrorsToString());
|
|
}
|
|
}
|
|
|
|
private File directoryChooser() {
|
|
DirectoryChooser directoryChooser = new DirectoryChooser();
|
|
|
|
// open in the folder where the jar is located if possible
|
|
File workingDir = getWorkingDirectory();
|
|
|
|
if (workingDir != null) {
|
|
directoryChooser.setInitialDirectory(workingDir);
|
|
}
|
|
|
|
return directoryChooser.showDialog(stage);
|
|
}
|
|
|
|
/**
|
|
* Hides GOS related checkbox until needed.
|
|
*/
|
|
// private void toggleGosChBVisibility() {
|
|
// gosUseOrthChB.setVisible(corpus != null && corpus.getCorpusType() != null && corpus.getCorpusType() == CorpusType.GOS);
|
|
// }
|
|
|
|
private String detectCorpusType(Collection<File> corpusFiles) {
|
|
// check that we recognize this corpus
|
|
// read first file only, maybe later do all, if toll on resources is acceptable
|
|
File f = corpusFiles.iterator().next();
|
|
String title = XML_processing.readXMLHeaderTag(f.getAbsolutePath(), "title").toLowerCase();
|
|
String attrib = XML_processing.readXMLHeaderAttribute(f.getAbsolutePath(), "body", "base").toLowerCase();
|
|
String test = CCKRES.getNameLowerCase();
|
|
String debug = "";
|
|
|
|
// check if XML file's title contains any of recognized corpus titles
|
|
corpusType = null;
|
|
if (title.contains(SOLAR.getNameLowerCase())) {
|
|
corpusType = SOLAR;
|
|
} else if (title.contains(GIGAFIDA.getNameLowerCase())) {
|
|
String edition = XML_processing.readXMLHeaderTag(f.getAbsolutePath(), "edition").toLowerCase();
|
|
if (Double.valueOf(edition) < 2.0) {
|
|
corpusType = GIGAFIDA;
|
|
} else {
|
|
corpusType = GIGAFIDA2;
|
|
}
|
|
} else if (title.contains(CCKRES.getNameLowerCase())) {
|
|
corpusType = CCKRES;
|
|
} else if (title.contains(GOS.getNameLowerCase())) {
|
|
corpusType = GOS;
|
|
} else if (attrib.contains(SSJ500K.getNameLowerCase())) {
|
|
corpusType = SSJ500K;
|
|
}
|
|
|
|
if (corpusType == null) {
|
|
return null;
|
|
} else {
|
|
corpus.setCorpusType(corpusType);
|
|
|
|
Messages.setChooseCorpusProperties(corpusLocation, corpusFilesSize, corpusType.toString());
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(corpusLocation)
|
|
.append("\n")
|
|
.append(String.format(I18N.get("message.NOTIFICATION_FOUND_X_FILES"), corpusFiles.size()))
|
|
.append("\n")
|
|
.append(String.format(I18N.get("message.NOTIFICATION_CORPUS"), corpusType.toString()));
|
|
|
|
String result = sb.toString();
|
|
|
|
logger.debug(result);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public Corpus getCorpus() {
|
|
return corpus;
|
|
}
|
|
|
|
public void setCorpus(Corpus corpus) {
|
|
this.corpus = corpus;
|
|
}
|
|
|
|
public void setStringLevelTabNew2(Tab stringLevelTabNew2) { this.stringLevelTabNew2 = stringLevelTabNew2; }
|
|
|
|
public void setOneWordAnalysisTab(Tab oneWordAnalysisTab) { this.oneWordAnalysisTab = oneWordAnalysisTab; }
|
|
|
|
public void setCharacterLevelTab(Tab characterLevelTab) { this.characterLevelTab = characterLevelTab; }
|
|
|
|
public void setWordLevelTab(Tab wordLevelTab) {
|
|
this.wordLevelTab = wordLevelTab;
|
|
}
|
|
|
|
public void setFilterTab(Tab filterTab) {
|
|
this.filterTab = filterTab;
|
|
}
|
|
|
|
public void setFfsController(FiltersForSolar ffsController) {
|
|
this.ffsController = ffsController;
|
|
}
|
|
|
|
public void setTabPane(TabPane tabPane) {
|
|
this.tabPane = tabPane;
|
|
}
|
|
|
|
public void setSatNew2Controller(StringAnalysisTabNew2 satNew2Controller) { this.satNew2Controller = satNew2Controller; }
|
|
|
|
public void setOneWordTabController(OneWordAnalysisTab oneWordTabController) { this.oneWordTabController = oneWordTabController; }
|
|
|
|
public void setCatController(CharacterAnalysisTab catController) { this.catController = catController; }
|
|
|
|
/*public void setWfController(WordFormationTab wfController) {
|
|
this.wfController = wfController;
|
|
}*/
|
|
|
|
public void setWlController(WordLevelTab wlController) {
|
|
this.wlController = wlController;
|
|
}
|
|
|
|
public void setWordFormationTab(Tab wordFormationTab) {
|
|
this.wordFormationTab = wordFormationTab;
|
|
}
|
|
|
|
public void setHostServices(HostServices hostServices){
|
|
this.hostService = hostServices;
|
|
}
|
|
}
|