A Copy Files App using JavaFX - Java Source Code
FileTreeView.java
package com.javaquizplayer.examples.copyfilesapp;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.VBox;
import javafx.scene.layout.HBox;
import javafx.scene.control.TreeView;
import javafx.scene.control.TreeItem;
import javafx.scene.control.Button;
import javafx.scene.control.SelectionMode;
import javafx.scene.control.Tooltip;
import javafx.scene.control.CheckBoxTreeItem;
import javafx.scene.control.cell.CheckBoxTreeCell;
import javafx.scene.control.CheckBoxTreeItem.TreeModificationEvent;
import javafx.stage.DirectoryChooser;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.collections.ObservableList;
import javafx.application.Platform;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Set;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.logging.Logger;
/*
* Main GUI class for this app.
* Builds a tree view of the files for the selected file system root
* directory. Has functions to expand, collapse the file tree and check
* the files and directories for copy and open the copy files dialog.
*/
public class FileTreeView {
private TreeView<Path> tree;
private Button copyBtn;
private CopyDialog copyDialog;
private Path rootDir; // The chosen root or source directory
// All file and directories that are checked are stored here
private Set<Path> checkedItems;
// Indecies of selected directory nodes, used with expand or collapse
// of specific directory nodes.
private List<Integer> selectedIndecies;
// Flag to indicate if the root directory node is in expanded or
// collapsed state. This is used with the tree expand/collapse toggle
// button. In case the node is collapsed it is expanded and vice-versa.
private boolean isExpanded;
private static final String DEFAULT_DIRECTORY =
System.getProperty("user.dir"); // or "user.home"
private static Logger logger;
/*
* Constructor builds and displays the app's main view.
*/
public FileTreeView(Stage primaryStage) {
logger = Logger.getLogger("copy_app_logger");
copyDialog = new CopyDialog();
checkedItems = new HashSet<Path>();
Button expandBtn = new Button('\u2039' + " " + '\u203A');
expandBtn.setTooltip(new Tooltip("Expand or collapse selected tree items"));
expandBtn.setOnAction(e -> expandOrCollapseSelectedItemsRoutine());
Button expandAllBtn = new Button('\u00AB' + " " + '\u00BB');
expandAllBtn.setTooltip(new Tooltip("Expand or collapse entire tree"));
expandAllBtn.setOnAction(e -> expandOrCollapseTreeRoutine());
HBox hb1 = new HBox(15);
hb1.setAlignment(Pos.CENTER);
hb1.getChildren().addAll(expandAllBtn, expandBtn);
Button sourceDirBtn = new Button("Source directory...");
sourceDirBtn.setTooltip(new Tooltip("Set a new root directory"));
sourceDirBtn.setOnAction(e -> {
chooseSourceDirectory(primaryStage);
tree.setRoot(getRootItem());
});
copyBtn = new Button("Copy dialog...");
copyBtn.setTooltip(new Tooltip("Initiate the copy action: opens copy dialog"));
copyBtn.setDisable(true);
copyBtn.setOnAction(e -> copyDialogRoutine());
HBox hb2 = new HBox(15);
hb2.setAlignment(Pos.CENTER);
hb2.getChildren().addAll(sourceDirBtn, copyBtn);
VBox vb = new VBox(20);
vb.setPadding(new Insets(20));
primaryStage.setScene(new Scene(vb, 800, 600)); // w, h
primaryStage.setTitle("Copy Files App");
primaryStage.show();
chooseSourceDirectory(primaryStage);
vb.getChildren().addAll(buildFileTreeView(), hb1, hb2);
}
/*
* Opens the directory chooser with an initial root directory.
* Allows the user to use the same, or select another one.
* In case the chooser is cancelled a root directory is derived.
*/
private void chooseSourceDirectory(Stage primaryStage) {
DirectoryChooser chooser = new DirectoryChooser();
chooser.setTitle("Select a source directory");
chooser.setInitialDirectory(getInitialDirectory().toFile());
File chosenDir = chooser.showDialog(primaryStage);
determineRootDirectory(chosenDir);
copyBtn.setDisable(true);
checkedItems.clear();
isExpanded = false;
logger.info("Root dir chosen: " + rootDir);
}
/*
* Initial root directory set for the directory chooser.
*/
private Path getInitialDirectory() {
return (rootDir == null) ? Paths.get(DEFAULT_DIRECTORY) : rootDir;
}
/*
* The root directory for the tree is derived here.
* If a directory is chosen it is the root directory.
* If not, the previous root directory is used. In case of no
* previous directory the DEFAULT_DIRECTORY is the root.
*/
private void determineRootDirectory(File chosenDir) {
rootDir = (chosenDir != null) ?
chosenDir.toPath() : getInitialDirectory();
}
/*
* Creates and returns the root item for the root directory.
*/
private FileTreeItem getRootItem() {
FileTreeItem rootItem = new FileTreeItem(rootDir);
rootItem.setIndependent(false);
rootItem.addEventHandler(
CheckBoxTreeItem.<Path>checkBoxSelectionChangedEvent(),
(TreeModificationEvent<Path> e) -> handleItemCheckedEvent(e));
return rootItem;
}
/*
* Builds and returns the tree view for the given root item.
*/
private TreeView buildFileTreeView() {
tree = new TreeView<Path>(getRootItem());
tree.setPrefHeight(600.0d);
tree.setTooltip(new Tooltip("Expand (all) or collapse the tree, select items and copy..."));
tree.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
tree.setCellFactory((TreeView<Path> t) -> new TreeCellImpl());
return tree;
}
/*
* Event handler for the tree item checked or unchecked event.
* On checking or unchecking an item the related items are stored
* or removed from a Set collection respectively. These items in
* the collection are used for copying.
*/
private void handleItemCheckedEvent(TreeModificationEvent<Path> e) {
FileTreeItem item = (FileTreeItem) e.getTreeItem();
if (item.isSelected() || item.isIndeterminate()) {
collectCheckedItems(item);
}
else {
removeCollectedCheckedItems(item);
}
copyBtn.setDisable((checkedItems.isEmpty()) ? true : false);
}
private void collectCheckedItems(FileTreeItem item) {
if (item.isSelected() || item.isIndeterminate()) {
// A file or directory is checked, or if a directory
// with files has some items checked: collect these items
checkedItems.add(item.getValue());
}
item.getChildren().forEach(t -> collectCheckedItems((FileTreeItem) t));
}
private void removeCollectedCheckedItems(FileTreeItem item) {
if (! item.isSelected()) {
// A file or directory is unchecked: remove these items
checkedItems.remove(item.getValue());
}
item.getChildren()
.forEach(t -> removeCollectedCheckedItems((FileTreeItem) t));
}
/*
* Expand or collapse the entire file tree.
*/
private void expandOrCollapseTreeRoutine() {
FileTreeItem rootItem = (FileTreeItem) tree.getRoot();
expandOrCollapseTree(rootItem);
isExpanded = (isExpanded) ? false : true;
}
private void expandOrCollapseTree(FileTreeItem item) {
if (! item.isLeaf()) {
item.setExpanded((isExpanded) ? false : true);
item.getChildren().forEach(t -> expandOrCollapseTree((FileTreeItem) t));
}
}
/*
* Expand or collapse the selected items (directories) in the file tree.
* NOTE: this is not the check box select, it is the item selection.
* An item is highlighted when it is selected. Multiple items can
* be selected at a time.
*/
private void expandOrCollapseSelectedItemsRoutine() {
selectedIndecies = new ArrayList<Integer>();
ObservableList<TreeItem<Path>> items =
tree.getSelectionModel().getSelectedItems();
items.forEach(t -> expandOrCollapseSelectedItems((FileTreeItem) t));
setSelectedItems();
}
private void expandOrCollapseSelectedItems(FileTreeItem item) {
if ((item != null) && (! item.isLeaf())) {
selectedIndecies.add(tree.getRow(item));
item.setExpanded((item.isExpanded()) ? false : true);
item.getChildren()
.forEach(t -> expandOrCollapseSelectedItems((FileTreeItem) t));
}
}
/*
* Select the items (retain the selection) which were in selected
* state before the items expand or collapse action.
*/
private void setSelectedItems() {
if (selectedIndecies.isEmpty()) {
return; // there is no selection, can't expand or collapse
}
// One or more items selected
int firstIndex = selectedIndecies.get(0);
int [] remaining = new int [selectedIndecies.size() - 1];
for (int j = 0, i = 1; j < remaining.length; j++) {
remaining [j] = selectedIndecies.get(i);
i++;
}
tree.getSelectionModel().selectIndices(firstIndex, remaining);
}
/*
* Copy dialog button action routine.
* Opens the CopyDialog modal dialog.
*/
private void copyDialogRoutine() {
logger.info("Copy dialog...");
FileTreeItem rootItem = (FileTreeItem) tree.getRoot();
Path sourceDir = rootItem.getValue();
copyDialog.create(sourceDir, checkedItems);
}
/*
* Inner class to render check boxes with file names for the tree items.
*/
private class TreeCellImpl extends CheckBoxTreeCell<Path> {
@Override
public void updateItem(Path path, boolean empty) {
super.updateItem(path, empty);
if (empty) {
setText(null);
}
else {
if (path != null) {
String s = path.getFileName().toString();
setText(s);
}
}
}
}
}
FileTreeItem.java
package com.javaquizplayer.examples.copyfilesapp;
import javafx.scene.control.TreeItem;
import javafx.scene.control.CheckBoxTreeItem;
import javafx.collections.ObservableList;
import javafx.collections.FXCollections;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;
import java.util.stream.Collectors;
/*
* This class is a TreeItem for the given file Path with a checkbox. It does
* this by overriding the TreeItem's getChildren() and the isLeaf() methods.
* Note that CheckBoxTreeItem extends TreeItem.
*/
public class FileTreeItem extends CheckBoxTreeItem<Path> {
// Cache whether the file is a leaf or not. A file is a leaf if
// it is not a directory. The isLeaf() is called often, and doing
// the actual check on Path is expensive.
private boolean isLeaf;
// Do the children and leaf testing only once, and then set these
// booleans to false so that we do not check again during this run.
private boolean isFirstTimeChildren = true;
private boolean isFirstTimeLeaf = true;
/*
* Constructor.
* The parameter is the root or source input directory path used
* to build the file tree with the TreeView control.
*/
public FileTreeItem(Path path) {
super(path);
}
@Override
public boolean isLeaf() {
if (isFirstTimeLeaf) {
isFirstTimeLeaf = false;
Path path = getValue();
isLeaf = Files.isRegularFile(path);
}
return isLeaf;
}
/*
* Returns a list that contains the child TreeItems belonging to the TreeItem.
*/
@Override
public ObservableList<TreeItem<Path>> getChildren() {
if (isFirstTimeChildren) {
isFirstTimeChildren = false;
// First getChildren() call, so we actually go off and
// determine the children of the file contained in this TreeItem.
super.getChildren().setAll(buildChildren(this));
}
return super.getChildren();
}
private ObservableList<TreeItem<Path>> buildChildren(
CheckBoxTreeItem<Path> treeItem) {
Path path = treeItem.getValue();
if ((path != null) && (Files.isDirectory(path))) {
try(Stream<Path> pathStream = Files.list(path)) {
return pathStream
.map(p -> new FileTreeItem(p))
.collect(Collectors.toCollection(() ->
FXCollections.observableArrayList()));
}
catch(IOException e) {
throw new UncheckedIOException(e);
}
}
return FXCollections.emptyObservableList();
}
}CopyDialog.java
package com.javaquizplayer.examples.copyfilesapp;
import javafx.scene.layout.VBox;
import javafx.scene.layout.HBox;
import javafx.scene.control.Dialog;
import javafx.scene.control.TextArea;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Tooltip;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.CheckBox;
import javafx.scene.control.ProgressBar;
import javafx.scene.Scene;
import javafx.scene.text.Font;
import javafx.stage.Stage;
import javafx.stage.Modality;
import javafx.stage.DirectoryChooser;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.collections.FXCollections;
import javafx.concurrent.Task;
import javafx.application.Platform;
import java.util.Set;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Files;
import java.nio.file.FileVisitResult;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.attribute.BasicFileAttributes;
/*
* Constructs the copy files dialog. This is invoked from the app's main GUI.
* This dialog captures the info to perform the copy of the selected files
* in the main view: the target directory, the file filters and an option to
* create a ZIP file. Starts the copy process: the file filters are applied
* to the selected files and the filtered files are copied to the target. The
* process can be cancelled if needed. The process progress is viewed thru a
* progress bar and the status is logged to the status area.
*/
public class CopyDialog {
private TextArea statusArea;
private Button selectTargetBtn;
private Button filtersBtn;
private Button copyBtn;
private Button cancelBtn;
private Button closeBtn;
private CheckBox zipCheckBox;
private ProgressBar progressBar;
private FileFilterDialog fileFiltersDialog;
private FileFilters fileFilters;
// The root or the source directory input from the main GUI with the
// file tree view.
private Path sourceDir;
// The target or destination directory to which the files are copied to.
// This is obtained from a directory chooser in this dialog.
private Path targetDir;
// The files copy is performed in a background thread by this Task object.
// See copyRoutine() method.
private Task<Void> copyTask;
// Counters for total files and directories that are actually copied.
// These are used to show the status after the copy task is complete.
private int copiedFilesCount;
private int copiedDirsCount;
private static final String DEFAULT_DIRECTORY =
System.getProperty("user.dir"); // or "user.home"
private static Logger logger;
/*
* Constructor.
* Creates a copy of the FileFilterDialog.
* Obtains the logger and configures it with the TextAreaLogHandler.
*/
public CopyDialog() {
logger = Logger.getLogger("copy_app_logger");
statusArea = getTextArea();
TextAreaLogHandler handler = new TextAreaLogHandler(statusArea);
logger.addHandler(handler);
fileFiltersDialog = new FileFilterDialog();
}
/*
* Constructs the GUI for the Copy dialog.
*/
public void create(Path sourceDir, Set<Path> selectedFiles) {
this.sourceDir = sourceDir;
Stage dialog = new Stage();
dialog.setResizable(false);
dialog.setTitle("Copy Files");
dialog.initModality(Modality.APPLICATION_MODAL);
dialog.setOnCloseRequest(e -> e.consume()); // disable Close (x) button
Platform.runLater(() -> statusArea.setText(""));
selectTargetBtn = new Button("Target directory...");
selectTargetBtn.setTooltip(new Tooltip("Select a target directory"));
selectTargetBtn.setOnAction(e -> chooseTargetDirectory());
filtersBtn = new Button("Filters...");
filtersBtn.setTooltip(new Tooltip("Apply file filters"));
filtersBtn.setOnAction(e -> getFilters());
filtersBtn.setDisable(true);
zipCheckBox = new CheckBox("Create ZIP file");
zipCheckBox.setDisable(true);
copyBtn = new Button("Copy files...");
copyBtn.setTooltip(new Tooltip("Copy files to target directory"));
copyBtn.setOnAction(e -> copyRoutine(selectedFiles));
copyBtn.setDisable(true);
cancelBtn = new Button("Cancel copy");
cancelBtn.setTooltip(new Tooltip("Cancel or abort the copy process"));
cancelBtn.setOnAction(e -> {
if (copyTask != null) {
copyTask.cancel();
}
});
cancelBtn.setDisable(true);
closeBtn = new Button("Close");
closeBtn.setTooltip(new Tooltip("Close the dialog"));
closeBtn.setOnAction(e -> dialog.close());
HBox btnHb = new HBox(15);
btnHb.setAlignment(Pos.CENTER);
/*
* The ZIP file create option checkbox is available with the
* Windows operating system only.
*/
if (System.getProperty("os.name").toLowerCase().contains("windows")) {
btnHb.getChildren().addAll(selectTargetBtn, filtersBtn, zipCheckBox, copyBtn, cancelBtn, closeBtn);
}
else {
btnHb.getChildren().addAll(selectTargetBtn, filtersBtn, copyBtn, cancelBtn, closeBtn);
}
progressBar = new ProgressBar();
progressBar.setPrefWidth(600.0d);
progressBar.setTooltip(new Tooltip("Copy files process progress"));
HBox statusHb = new HBox();
statusHb.setAlignment(Pos.CENTER);
statusHb.getChildren().addAll(progressBar);
VBox vb = new VBox(20);
vb.setPadding(new Insets(15, 15, 5, 15));
vb.getChildren().addAll(statusArea, statusHb, btnHb);
dialog.setScene(new Scene(vb));
String initialText =
"* Copy Files to a Target Directory * \n" +
"Total directories (includes root) and files selected: " +
selectedFiles.size() + " " +
"\nSource directory: " + sourceDir.toString() + " " +
"\n\nSelect a target directory, apply file filters and copy.\n";
logger.info(initialText);
dialog.showAndWait(); // this shows a modal window
}
private TextArea getTextArea() {
TextArea textArea = new TextArea();
textArea.setTooltip(new Tooltip("Status message area"));
textArea.setPrefRowCount(14);
textArea.setPrefColumnCount(60);
textArea.setEditable(false);
textArea.setFont(new Font("Verdana", 16));
return textArea;
}
/*
* Opens the directory chooser and lets the user select a
* target directory for copying the selected files. The
* directory is verified if it is valid.
*/
private void chooseTargetDirectory() {
DirectoryChooser chooser = new DirectoryChooser();
chooser.setTitle("Select a target directory");
chooser.setInitialDirectory(new File(DEFAULT_DIRECTORY));
File chosenDir = chooser.showDialog(null);
targetDir = (chosenDir == null) ? null : chosenDir.toPath();
if (! verifyDirectories()) {
return;
}
logger.info("Target directory: " + targetDir.toString());
progressBar.progressProperty().unbind();
progressBar.setProgress(0);
fileFilters = null;
zipCheckBox.setDisable(false);
copyBtn.setDisable(false);
filtersBtn.setDisable(false);
filtersBtn.requestFocus();
}
/*
* Checks if the target directory path is not the same as
* that of the source path, or the target is not within the
* source directory structure; shows an alert message.
*/
private boolean verifyDirectories() {
if (targetDir == null) {
showAlertDialog("No directory selected!");
return false;
}
if ((sourceDir.equals(targetDir)) ||
(targetDir.startsWith(sourceDir))) {
showAlertDialog("Source and target directories are same, or " +
"the target is within the source.");
return false;
}
if (targetDir.toFile().list().length > 0) {
logger.warning("The target directory is not empty.");
}
return true;
}
/*
* Displays a modal alert with the supplied message.
*/
private void showAlertDialog(String msg) {
Alert alert = new Alert(AlertType.NONE);
alert.setTitle("Files Copy");
alert.getDialogPane().getButtonTypes().add(ButtonType.OK);
alert.setContentText(msg);
alert.show();
}
/*
* Displays the file filters dialog and captures user input. Gets
* the selected file filter options as an instance of FileFilters.
*/
private void getFilters() {
Dialog<FileFilters> dialog = fileFiltersDialog.create();
Optional<FileFilters> result = dialog.showAndWait();
if (result.isPresent()) {
fileFilters = result.get();
if (fileFilters.getFileTypes().isEmpty()) {
// In case there is no selection in the file types list,
// which is possible with a ListView, the value is set.
fileFilters.setFileTypes(FXCollections.observableArrayList("All"));
}
}
logger.info("File filters: " + fileFilters.toString());
zipCheckBox.requestFocus();
}
/*
* Routine for the Copy files button action.
* 1. Applies the file filters to the selected files.
* 2. Copies the filtered files to target directory.
* 3. Creates a ZIP file if the option is selected.
* These tasks are performed as a JavaFX concurrent Task. At end,
* a status (Succeeded, Failed/exception or Cancelled) is displayed
* in the status message area.
*/
private void copyRoutine(Set<Path> inputSelectedFiles) {
copiedFilesCount = 0;
copiedDirsCount = 0;
copyTask = new Task<Void>() {
int currentCounter;
@Override
protected Void call()
throws Exception {
logger.info("Copying files.");
Platform.runLater(() -> {
copyBtn.setDisable(true);
closeBtn.setDisable(true);
cancelBtn.setDisable(false);
filtersBtn.setDisable(true);
zipCheckBox.setDisable(true);
selectTargetBtn.setDisable(true);
});
Set<Path> filteredFiles = applyFileFilters(inputSelectedFiles);
Map<Boolean, List<Path>> countsMap = filteredFiles.stream()
.collect(Collectors.partitioningBy(p -> Files.isDirectory(p)));
int dirsCount = countsMap.get(true).size() - 1; // minus root dir
int filesCount = countsMap.get(false).size();
logger.info("Filters applied. " +
"Directories [" + ((dirsCount < 0) ? 0 : dirsCount) + "], " +
"Files [" + filesCount + "].");
Thread.sleep(100); // pause for n milliseconds
logger.info("Copy in progress...");
/*
* Walks the source file tree and copies the filtered source
* files to the target directory. The directories and files are
* copied. In case of any existing directories or files in the
* target, they are replaced.
*/
Files.walkFileTree(sourceDir, new SimpleFileVisitor<Path>() {
/*
* Copy the directories.
*/
@Override
public FileVisitResult preVisitDirectory(Path dir,
BasicFileAttributes attrs)
throws IOException {
if (isCancelled()) {
// Task's isCancelled() method returns true
// when its cancel() is executed; in this app
// when the Cancel copy button is clicked.
// Here, the files copy is terminated.
return FileVisitResult.TERMINATE;
}
if (! filteredFiles.contains(dir)) {
return FileVisitResult.SKIP_SUBTREE;
}
Path target = targetDir.resolve(sourceDir.relativize(dir));
try {
Files.copy(dir, target);
copiedDirsCount++;
// Updates the Progess bar using the Task's
// updateProgress(workDone, max) method.
updateProgress(++currentCounter, dirsCount+filesCount);
}
catch (FileAlreadyExistsException e) {
if (! Files.isDirectory(target)) {
throw e;
}
}
return FileVisitResult.CONTINUE;
}
/*
* Copy the files.
*/
@Override
public FileVisitResult visitFile(Path file,
BasicFileAttributes attrs)
throws IOException {
if (isCancelled()) {
// Task's isCancelled() method
// terminates the files copy.
return FileVisitResult.TERMINATE;
}
if (filteredFiles.contains(file)) {
Files.copy(file,
targetDir.resolve(sourceDir.relativize(file)),
StandardCopyOption.REPLACE_EXISTING);
copiedFilesCount++;
// Updates the Progess bar using the Task's
// updateProgress(workDone, max) method.
updateProgress(++currentCounter, dirsCount+filesCount);
}
return FileVisitResult.CONTINUE;
}
});
if (zipCheckBox.isSelected()) {
if (copiedFilesCount > 0) {
logger.info("Creating ZIP file, wait... ");
Thread.sleep(100);
String zipFile = ZipFileCreater.zip(targetDir);
logger.info("ZIP file created: " + zipFile);
}
else {
logger.info("Cannot create ZIP file with files count = 0");
}
}
return null;
}
};
// end copyTask class
progressBar.progressProperty().bind(copyTask.progressProperty());
new Thread(copyTask).start(); // Run the copy task
// Calling event handlers as task's state is transitioned to
// SUCCEEDED, FAILED or CANCELLED.
copyTask.setOnFailed(e -> {
Throwable t = copyTask.getException();
String message = (t != null) ? t.toString() : "Unknown Exception!";
logger.info("There was an error during the copy process:");
logger.info(message);
doTaskEventCloseRoutine(copyTask);
//t.printStackTrace();
});
copyTask.setOnCancelled(e -> {
logger.info("Copy is cancelled by user.");
doTaskEventCloseRoutine(copyTask);
});
copyTask.setOnSucceeded(e -> {
logger.info("Copy completed. " +
"Directories copied [" +
((copiedDirsCount < 1) ? 0 : copiedDirsCount) + "], " +
"Files copied [" + copiedFilesCount + "]");
doTaskEventCloseRoutine(copyTask);
});
}
private void doTaskEventCloseRoutine(Task copyTask) {
logger.info("Status: " + copyTask.getState() + "\n");
logger.info("Select a target directory, apply file filters and copy.");
Platform.runLater(() -> {
selectTargetBtn.setDisable(false);
closeBtn.setDisable(false);
cancelBtn.setDisable(true);
});
}
/*
* Sets the file filters to its default value in case the filters dialog
* is not opened at all. Otherwise the already set value is used. Apply
* the file filters; the filtered files are returned as a Set collection.
*/
private Set<Path> applyFileFilters(Set<Path> selectedFiles)
throws IOException {
if (fileFilters == null) {
fileFilters = FileFilters.getDefault();
logger.info("File filters: " + fileFilters.toString());
}
return new FileFilterApplication().apply(sourceDir,
selectedFiles,
fileFilters);
}
}DateOption.java
package com.javaquizplayer.examples.copyfilesapp;
import java.util.Map;
import java.util.HashMap;
import java.util.EnumSet;
import java.util.stream.Collectors;
import java.util.function.Function;
/*
* Enum class represents the date file filter options.
* Also see FileFilters and FileFiltersDialog.
*/
public enum DateOption {
ALL_DAYS,
TODAY,
LAST_7_DAYS,
LAST_30_DAYS;
@Override
public String toString() {
return getFormattedString(super.toString());
}
/*
* Formats enum's string, for example: from LAST_7_DAYS to: Last 7 days.
* Replaces the underscore ("_") with a blank space. Changes the case to
* first letter upper and remaining lower case.
*/
private static String getFormattedString(String input) {
String s = input.toLowerCase();
s = s.replace("_", " ");
return (s.substring(0, 1).toUpperCase() + s.substring(1, s.length()));
}
/* Map with formatted string as key and enum constant as value */
private static Map<String, DateOption> map;
/* Initially, populates the map */
static {
map = EnumSet.allOf(DateOption.class)
.stream()
.collect(Collectors.toMap(
d -> getFormattedString(d.toString()), Function.identity()));
}
/*
* The lookup for the map. Returns the enum constant for the
* given string representing the constant.
*/
public static DateOption lookup(String s) {
return map.get(s);
}
}FileFilters.java
package com.javaquizplayer.examples.copyfilesapp;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
/*
* This class represents the file filters data. This data is
* captured in the FileFiltersDialog and is applied in the files
* copy routine.
*/
public class FileFilters {
private boolean allFiles;
private DateOption dateOpt;
private ObservableList<String> fileTypes;
/*
* List of file extensions for selection. "All" specifies that select
* all file types. The "" (empty string) specifies that the file has no
* extension.
*/
public static final String [] FILE_EXTENSIONS =
{"All", "java", "class", "txt", "doc", "docx", "xls",
"xlsx", "ppt", "png", "jpg", "pdf", "jar", "exe", "html",
"xhtml", "htm", "mp3", "wmv", ""};
/*
* Constructor with default values.
*/
public FileFilters() {
allFiles = false;
dateOpt = DateOption.ALL_DAYS;
fileTypes = FXCollections.observableArrayList("All");
}
/*
* Returns an instance of FileFilters with following options:
* All files for all days.
*/
public static FileFilters getDefault() {
return new FileFilters();
}
public void setAllFiles(boolean b) {
allFiles = b;
}
public boolean getAllFiles() {
return allFiles;
}
public void setDateOption(DateOption d) {
dateOpt = d;
}
public DateOption getDateOption() {
return dateOpt;
}
public void setFileTypes(ObservableList<String> types) {
fileTypes = types;
}
public ObservableList<String> getFileTypes() {
return fileTypes;
}
@Override
public String toString() {
return dateOpt.toString() + ", " + fileTypes.toString();
}
}
FileFilterDialog.java
package com.javaquizplayer.examples.copyfilesapp;
import javafx.scene.layout.VBox;
import javafx.scene.layout.HBox;
import javafx.scene.control.Dialog;
import javafx.scene.control.CheckBox;
import javafx.scene.control.ToggleGroup;
import javafx.scene.control.RadioButton;
import javafx.scene.control.ListView;
import javafx.scene.control.SelectionMode;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.ButtonBar.ButtonData;
import javafx.geometry.Orientation;
import javafx.geometry.Insets;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
/*
* This class has a single method which builds a dialog to capture file
* filter options. The method returns a dialog with an instance of
* FileFilters with the selected input or a default instance in case the
* dialog is cancelled.
*/
public class FileFilterDialog {
public Dialog<FileFilters> create() {
Dialog<FileFilters> dialog = new Dialog<>();
dialog.setTitle("File Filters");
dialog.setResizable(false);
CheckBox allCheckBox = new CheckBox("Select all files");
ToggleGroup radioGroup = new ToggleGroup();
RadioButton radio1 = new RadioButton(DateOption.ALL_DAYS.toString());
radio1.setSelected(true);
RadioButton radio2 = new RadioButton(DateOption.TODAY.toString());
RadioButton radio3 = new RadioButton(DateOption.LAST_7_DAYS.toString());
RadioButton radio4 = new RadioButton(DateOption.LAST_30_DAYS.toString());
radio1.setToggleGroup(radioGroup);
radio2.setToggleGroup(radioGroup);
radio3.setToggleGroup(radioGroup);
radio4.setToggleGroup(radioGroup);
HBox radioHb = new HBox(15);
radioHb.getChildren().addAll(radio1, radio2, radio3, radio4);
ListView<String> fileTypesList = new ListView<>();
fileTypesList.setPrefHeight(50.0d);
fileTypesList.setItems(FXCollections.observableArrayList(FileFilters.FILE_EXTENSIONS));
fileTypesList.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
fileTypesList.setOrientation(Orientation.HORIZONTAL);
allCheckBox.selectedProperty().addListener(
(ObservableValue<? extends Boolean> ov, Boolean oldVal,
Boolean newVal) -> {
fileTypesList.getSelectionModel().clearSelection();
fileTypesList.getSelectionModel().selectFirst();
fileTypesList.setDisable(newVal);
radio1.setSelected(true);
radio1.setDisable(newVal);
radio2.setDisable(newVal);
radio3.setDisable(newVal);
radio4.setDisable(newVal);
});
VBox vb = new VBox(20);
vb.setPadding(new Insets(20));
vb.getChildren().addAll(allCheckBox, radioHb, fileTypesList);
ButtonType okButtonType = new ButtonType("Okay", ButtonData.OK_DONE);
dialog.getDialogPane().getButtonTypes().add(okButtonType);
Button okBtn = (Button) dialog.getDialogPane().lookupButton(okButtonType);
dialog.setResultConverter((ButtonType b) -> {
if (b == okButtonType) {
FileFilters ff = new FileFilters();
ff.setAllFiles(allCheckBox.isSelected());
String s = ((RadioButton) radioGroup.getSelectedToggle()).getText();
ff.setDateOption(DateOption.lookup(s));
ff.setFileTypes(fileTypesList.getSelectionModel().getSelectedItems());
return ff;
}
return FileFilters.getDefault();
});
dialog.getDialogPane().setContent(vb);
fileTypesList.getSelectionModel().selectFirst();
return dialog;
}
}
FileFilterApplication.java
package com.javaquizplayer.examples.copyfilesapp;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Files;
import java.nio.file.FileVisitResult;
import java.nio.file.SimpleFileVisitor;
import java.util.Set;
import java.util.HashSet;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.ZoneId;
import java.time.Instant;
import java.time.LocalDate;
/*
* Class has a single method which returns the collection of
* Path objects after the file filters are applied. Additionally,
* any empty directories are removed from the filtered collection.
* The input is the selected files, source direcory and the
* file filters.
*/
public class FileFilterApplication {
public FileFilterApplication() {
}
public Set<Path> apply(Path sourceDir,
Set<Path> selectedFiles,
FileFilters filters)
throws IOException {
Set<Path> filteredFiles = new HashSet<>();
Files.walkFileTree(sourceDir, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir,
BasicFileAttributes attrs)
throws IOException {
if (! selectedFiles.contains(dir)) {
// Not a selected directory, skip it
return FileVisitResult.SKIP_SUBTREE;
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file,
BasicFileAttributes attrs)
throws IOException {
if (selectedFiles.contains(file) &&
applyFileTypeFilter(filters, file) &&
applyDateOptionFilter(filters, file)) {
// Add selected files that match the
// file filter criteria
filteredFiles.add(file);
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir,
IOException exc)
throws IOException {
if (dirHasFiles(dir, filteredFiles)) {
// Add directories with files in it
filteredFiles.add(dir);
}
return FileVisitResult.CONTINUE;
}
});
return filteredFiles;
}
/*
* Check if the input dir has any files in it that are already
* filtered. Note this check is not on the file system.
*/
private boolean dirHasFiles(Path inDir, Set<Path> list) {
return list
.stream()
.anyMatch(p -> ((!p.equals(inDir)) && p.startsWith(inDir)));
}
private boolean applyFileTypeFilter(FileFilters filters, Path file) {
return filters.getFileTypes().contains("All") ||
filters.getFileTypes().contains(getFileExtension(file));
}
private String getFileExtension(Path file) {
String fileName = file.getFileName().toString();
int ix = fileName.lastIndexOf(".");
return (ix == -1) ? "" : fileName.substring(ix + 1);
}
private boolean applyDateOptionFilter(FileFilters filters, Path file)
throws IOException {
boolean returnValue = false;
switch (filters.getDateOption()) {
case TODAY:
returnValue = getFileDate(file).isEqual(LocalDate.now());
break;
case LAST_7_DAYS:
returnValue = getFileDate(file).isAfter(LocalDate.now().minusDays(7));
break;
case LAST_30_DAYS:
returnValue = getFileDate(file).isAfter(LocalDate.now().minusDays(30));
break;
default:
returnValue = true;
}
return returnValue;
}
/*
* Returns file's last modified date as a LocalDate.
*/
private LocalDate getFileDate(Path file)
throws IOException {
Instant fileTime = Files.getLastModifiedTime(file).toInstant();
return fileTime.atZone(ZoneId.systemDefault()).toLocalDate();
}
}
AppStarter.java
package com.javaquizplayer.examples.copyfilesapp;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.stage.Stage;
import java.io.IOException;
import java.util.stream.Stream;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.logging.Handler;
/*
* The copy files app's starter program.
* Launches the app and the main GUI.
*/
public class AppStarter extends Application {
private static Logger logger;
private static final String LOG_FILE = "copy_files_app_log_%g.txt";
public static void main(String... args) {
Application.launch(args);
}
/*
* Does some initial configuration for the app.
* Configures logger and its handlers.
* Exits the application if there is an exception.
*/
@Override
public void init() {
try {
configureLogging();
}
catch (IOException ex) {
System.out.println("An IOException occurred during app initialization.");
System.out.println("This happened during the logger configuration.");
System.out.println("See the stack trace below:");
ex.printStackTrace();
Platform.exit(); // NOTE: doesn't run the stop() method.
}
}
/*
* Configures the logger and registers a file handler.
*/
private void configureLogging()
throws IOException {
System.setProperty("java.util.logging.SimpleFormatter.format",
"%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %5$s%n");
logger = Logger.getLogger("copy_app_logger");
logger.setUseParentHandlers(false); // disables console logging
logger.addHandler(new LogFileHandler(LOG_FILE));
logger.setLevel(Level.INFO);
logger.info("Logger is configured");
}
/*
* Displays the main GUI.
*/
@Override
public void start(Stage primaryStage) {
logger.info("Launching the GUI");
new FileTreeView(primaryStage);
}
/*
* Does cleanup and releases resources.
*/
@Override
public void stop() {
logger.info("Closing the app");
// Close the logger's file and stream handlers
Stream.of(logger.getHandlers()).forEach(h -> h.close());
}
}LogFileHandler.java
package com.javaquizplayer.examples.copyfilesapp;
import java.util.logging.SimpleFormatter;
import java.io.IOException;
/*
* Handler to write log messages to a log file.
*/
public class LogFileHandler extends FileHandler {
public LogFileHandler(String pattern)
throws IOException {
super(pattern);
setFormatter(new SimpleFormatter()); // overrides the default xml formatter
}
}TextAreaLogHandler.java
package com.javaquizplayer.examples.copyfilesapp;
import java.util.logging.StreamHandler;
import java.util.logging.LogRecord;
import javafx.scene.control.TextArea;
import javafx.application.Platform;
/*
* Handler to write log messages to the app's GUI (status message area,
* a TextArea control, of the CopyDialog.java).
*/
public class TextAreaLogHandler extends StreamHandler {
TextArea textArea = null;
public TextAreaLogHandler(TextArea textArea) {
this.textArea = textArea;
}
@Override
public void publish(LogRecord record) {
super.publish(record);
flush();
Platform.runLater(() -> textArea.appendText(getFormatter().format(record)));
}
}
ZipFileCreater.java
package com.javaquizplayer.examples.copyfilesapp;
import java.util.zip.ZipOutputStream;
import java.util.zip.ZipEntry;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.Path;
import java.nio.file.FileVisitResult;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
/*
* Class has one static method.
* Creates a ZIP (compressed archive) file for the supplied directory with
* files. This directory is the same as the target directory as a result of
* copy action in Copy Dialog.
* The ZIP file created is in the same directory in which the supplied directory
* is present.
*/
public class ZipFileCreater {
public static String zip(Path input)
throws IOException {
String targetFileNameStr = input.getFileName().toString() + ".zip";
Path targetPath =
Paths.get(input.getParent().toString(), targetFileNameStr);
ZipOutputStream zipOutputStream =
new ZipOutputStream(new FileOutputStream(targetPath.toString()));
Files.walkFileTree(input, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
Path targetfile = input.relativize(file);
ZipEntry zipEntry = new ZipEntry(targetfile.toString());
zipOutputStream.putNextEntry(zipEntry);
try(FileInputStream fileInputStream =
new FileInputStream(file.toString())) {
byte [] buf = new byte [512];
int bytesRead;
while ((bytesRead = fileInputStream.read(buf)) > 0) {
zipOutputStream.write(buf, 0, bytesRead);
}
}
zipOutputStream.closeEntry();
return FileVisitResult.CONTINUE;
}
});
zipOutputStream.close();
return targetPath.toString();
}
}Return to top
This page uses Java code formatting from http://hilite.me/.