CheckBoxTree.java

import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTree;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.filechooser.FileSystemView;
import javax.swing.Box;
import javax.swing.JTextField;
import javax.swing.JFileChooser;
import javax.swing.JDialog;
import javax.swing.AbstractAction;
import javax.swing.KeyStroke;
import javax.swing.ActionMap;
import javax.swing.JComponent;
import javax.swing.InputMap;
import javax.swing.SwingWorker;

import javax.swing.UIManager;
//import javax.swing.plaf.nimbus.NimbusLookAndFeel;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.Color;
import java.awt.Font;
import java.awt.HeadlessException;
import java.awt.Container;
import java.awt.LayoutManager;
import java.awt.Insets;
import java.awt.Cursor;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.KeyEvent;
import java.awt.event.ActionEvent;

import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
//import java.io.AccessDeniedException;

import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.Locale;
import java.util.stream.Stream;
import java.util.stream.Collectors;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

import java.text.Collator;
import java.text.DecimalFormat;



/**
 * Type d'élément affiché dans l'explorateur.
 */
enum FileNodeType {
	CURRENT_DIRECTORY,
	PARENT_DIRECTORY,
	DIRECTORY,
	FILE
}


/**
 * Objet représentant un élément de l'arbre.
 */
class FileNode {
	private final File file;
	private final FileNodeType type;
	private final long size;
	private final long nbFiles;
	private final long lastModified;
	
	
	/*
	private long getFolderSize(File folder) {
		long length = 0;
		if (folder.exists()) {
			File[] files = folder.listFiles();
			int count = files.length;
			//System.out.println("folder.listFiles = " + Integer.toString(count));
			for (int i = 0; i < count; i++) {
				if (files[i].isFile()) {
					length += files[i].length();
				}
				else {
					length += getFolderSize(files[i]);
				}
			}
		}
		return length;
	}
	*/
	
	
	private static long getFolderSize(String directoryPath) throws IOException {
		// Walk the directory tree, starting at 'directoryPath'
		try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath))) {
			// Filter to count only regular files (exclude directories/symlinks)
			return pathStream
				.filter(Files::isRegularFile) // Count only files (not dirs)
				.mapToLong(path -> {
					try {
						return Files.size(path); // Utilise Files.size au lieu de Files.length
					} catch (IOException e) {
						//throw new UncheckedIOException(e);
						return 0L;
					}
					catch (SecurityException e) {
						return 0L;
					}
					//catch (AccessDeniedException e) {
					//	return 0L;
					//}
				})
				.sum(); // Terminal operation: sum all matching paths
		}
		catch (IOException e) {
			return 0L;
		}
	}
	
	private static long countFiles(String directoryPath) throws IOException {
		// Walk the directory tree, starting at 'directoryPath'
		try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath))) {
			// Filter to count only regular files (exclude directories/symlinks)
			return pathStream
				.filter(Files::isRegularFile) // Count only files (not dirs)
				.count(); // Terminal operation: count all matching paths
		}
	}
	
	public FileNode(File file, FileNodeType type) {
		this.file = file;
		this.type = type;
		/*
		 * Récupération des métadonnées des fichiers.
		 */
		if (file != null && file.exists()) {
			if (file.isFile()) {
				this.size = file.length();
				this.nbFiles = 1L;
				this.lastModified = file.lastModified();
			}
			else {
				//this.size = getFolderSize(file);
				//this.size = file.listFiles().length;
				long nbVar = 0L;
				long nbVar2 = 0L;
				if (type != FileNodeType.PARENT_DIRECTORY) {
					try {
						//nbVar = countFiles(file.getAbsolutePath());
						nbVar = getFolderSize(file.getAbsolutePath());
					}
					catch (IOException ex) {
						//ex.printStackTrace();
					}
					try {
						nbVar2 = countFiles(file.getAbsolutePath());
					}
					catch (IOException ex) {
						//ex.printStackTrace();
					}
				}
				this.size = nbVar;
				this.nbFiles = nbVar2;
				this.lastModified = file.lastModified();
			}
			//this.size = file.length();
			//this.lastModified = file.lastModified();
		} else {
			this.size = 0L;
			this.nbFiles = 0L;
			this.lastModified = 0L;
		}
	}
	
	public File getFile() {
		return file;
	}
	public FileNodeType getType() {
		return type;
	}
	public long getSize() {
		return size;
	}
	public long getNbFiles() {
		return nbFiles;
	}
	public long getLastModified() {
		return lastModified;
	}
	public boolean isDirectory() {
		return type == FileNodeType.DIRECTORY
				|| type == FileNodeType.PARENT_DIRECTORY;
	}
	public boolean isFile() {
		return type == FileNodeType.FILE;
	}
	public boolean isParentDirectory() {
		return type == FileNodeType.PARENT_DIRECTORY;
	}
	@Override
	public String toString() {
		if (isParentDirectory()) {
			return ".." + FileSystems.getDefault().getSeparator();
		}
		return file.getName();
		/*
		switch (type) {
			case CURRENT_DIRECTORY:
				return file.getAbsolutePath();
			case PARENT_DIRECTORY:
				return "../";
			case DIRECTORY:
			case FILE:
			default:
				return file.getName();
		}
		*/
	}
}


/**
 * JTree personnalisé permettant de sélectionner les fichiers.
 */
class JCheckBoxTree extends JTree {
	private final CheckBoxTreeCellRenderer renderer;
	public JCheckBoxTree(DefaultTreeModel model) {
		super(model);
		renderer = new CheckBoxTreeCellRenderer();
		setCellRenderer(renderer);
		setRootVisible(true);
		setShowsRootHandles(true);
		setRowHeight(24);
	}
	/**
	 * Retourne le renderer utilisé par l'arbre.
	 */
	public CheckBoxTreeCellRenderer getCheckBoxRenderer() {
		return renderer;
	}
}


/**
 * Renderer Swing de l'arbre.
 *
 * Affiche :
 *   [Checkbox] [Icône] [Nom] [Taille] [Dernière modification]
 *
 * Le renderer ne stocke PAS l'état de sélection.
 * Il se contente d'afficher l'état fourni par le modèle.
 */
class CheckBoxTreeCellRenderer extends JPanel implements TreeCellRenderer {
	private final JCheckBox checkBox;
	private final JLabel iconLabel;
	private final JLabel textLabel;
	private final JLabel sizeLabel;
	private final JLabel dateLabel;
	private final FileSystemView fileSystemView;
	private static final Color JAVA_BACKGROUND = new Color(255, 210, 210);
	private static final Color OTHER_BACKGROUND = new Color(240, 240, 255);
	private static final DateTimeFormatter DATE_FORMATTER = 
		DateTimeFormatter.ofPattern("    dd/MM/yyyy HH:mm:ss");
	
	public CheckBoxTreeCellRenderer() {
		//setLayout(new BorderLayout(5, 0));
		setLayout(new FileTreeRowLayout());
		setOpaque(false);
		fileSystemView = FileSystemView.getFileSystemView();
		/*
		 * Checkbox.
		 */
		checkBox = new JCheckBox();
		checkBox.setOpaque(false);
		checkBox.setMargin(new Insets(0, 0, 0, 0)); // Évite que la checkbox possède une marge
		/*
		 * Icône du fichier/dossier.
		 */
		iconLabel = new JLabel();
		/*
		 * Nom du fichier/dossier.
		 */
		textLabel = new JLabel();
		/*
		 * Taille du fichier
		 */
		sizeLabel = new JLabel();
		sizeLabel.setHorizontalAlignment(JLabel.RIGHT); // Alignement à droite pour la taille.
		/*
		 * Date de modification du fichier
		 */
		dateLabel = new JLabel();
		dateLabel.setHorizontalAlignment(JLabel.LEFT); // La date est alignée à gauche.
		
		//add(checkBox, BorderLayout.WEST);
		//add(iconLabel, BorderLayout.CENTER);
		//add(textLabel, BorderLayout.EAST);
		add(checkBox);
		add(iconLabel);
		add(textLabel);
		add(sizeLabel);
		add(dateLabel);
	}
	@Override
	public Component getTreeCellRendererComponent(
			JTree tree,
			Object value,
			boolean selected,
			boolean expanded,
			boolean leaf,
			int row,
			boolean hasFocus) {
		DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
		Object userObject = node.getUserObject();
		/*
		 * Nettoyage du renderer
		 */
		checkBox.setVisible(false);
		checkBox.setSelected(false);
		iconLabel.setIcon(null);
		textLabel.setText("");
		textLabel.setBackground(null);
		textLabel.setForeground(Color.BLACK);
		sizeLabel.setText("");
		dateLabel.setText("");
		/*
		* Couleur de fond de la ligne.
		*/
		if (selected) {
			setOpaque(true);
			//System.out.println(UIManager.getColor("Tree.selectionBackground"));
			//System.out.println(tree.getBackground());
			//System.out.println(" ");
			//if (UIManager.getColor("Tree.selectionBackground") == tree.getBackground()) {
			//	setBackground(new Color(192, 192, 220));
			//}
			setBackground(UIManager.getColor("Tree.selectionBackground"));
			//setBackground(new Color(192, 192, 220));
			//setBackground(new Color(184, 207, 229));
		}
		else {
			setOpaque(false);
			//setBackground(tree.getBackground());
		}
		/*
		 * Objet inattendu
		 */
		if (!(userObject instanceof FileNode)) {
			textLabel.setText(String.valueOf(userObject));
			return this;
		}
		FileNode fileNode = (FileNode) userObject;
		File file = fileNode.getFile();
		
		if (isRootNode(tree, node)) {
			/*
			 * ============================
			 * En-tête du répertoire courant
			 * ============================
			 */
			checkBox.setVisible(true);
			if (tree instanceof FileExplorerTree) {
				FileExplorerTree fileTree = (FileExplorerTree) tree;
				boolean retVal = fileTree.areAllFilesSelected();
				//System.out.println(retVal);
				checkBox.setSelected(retVal);
			}
			/*
			 * Pas d'icône dans la colonne
			 * checkbox/icône pour l'en-tête.
			 */
			//iconLabel.setIcon(null);
			iconLabel.setIcon(fileSystemView.getSystemIcon(file));
			/*
			 * Nom du répertoire courant.
			 */
			textLabel.setText(fileNode.toString());
			textLabel.setOpaque(false);
			textLabel.setForeground(Color.BLACK);
			textLabel.setFont(new Font("SansSerif", Font.BOLD, 12));
			/*
			 * En-tête de la colonne Taille.
			 */
			sizeLabel.setText("Size");
			sizeLabel.setHorizontalAlignment(JLabel.RIGHT); // or LEFT
			sizeLabel.setFont(new Font("SansSerif", Font.BOLD, 12));
			/*
			 * En-tête de la colonne Date.
			 */
			dateLabel.setText("Date modified");
			dateLabel.setHorizontalAlignment(JLabel.RIGHT); // or RIGHT or CENTER
			dateLabel.setFont(new Font("SansSerif", Font.BOLD, 12));
			return this;
		}
		else {
			textLabel.setFont(new Font("SansSerif", Font.PLAIN, 12));
			sizeLabel.setFont(new Font("SansSerif", Font.PLAIN, 12));
			dateLabel.setFont(new Font("SansSerif", Font.PLAIN, 12));
		}
		/*
		 * ============================
		 * Icône native
		 * ============================
		 */
		if (file != null) {
			iconLabel.setIcon(fileSystemView.getSystemIcon(file));
		}
		/*
		 * ============================
		 * Nom
		 * ============================
		 */
		textLabel.setText(fileNode.toString());
		/*
		 * ============================
		 * Checkbox
		 * ============================
		 */
		if (fileNode.isFile()) {
			checkBox.setVisible(true);
			if (tree instanceof FileExplorerTree) {
				FileExplorerTree fileTree = (FileExplorerTree) tree;
				checkBox.setSelected(fileTree.isFileSelected(file));
			}
			// Mise en évidence des fichiers Java.
			if (file.getName().toLowerCase().endsWith(".java")) {
				//textLabel.setOpaque(true);
				textLabel.setBackground(JAVA_BACKGROUND);
				textLabel.setForeground(Color.RED);
			}
			else {
				//textLabel.setOpaque(false);
				//textLabel.setOpaque(true);
				textLabel.setBackground(OTHER_BACKGROUND);
				textLabel.setForeground(Color.BLUE);
			}
		}
		else {
			// Dossiers
			textLabel.setOpaque(false);
			textLabel.setForeground(Color.BLACK);
		}
		/*
		 * ============================
		 * Taille & Date de modification
		 * ============================
		 */
		if (fileNode.isFile()) {
			sizeLabel.setText(formatFileSize(fileNode.getSize()));
			dateLabel.setText(formatLastModified(fileNode.getLastModified()));
			dateLabel.setHorizontalAlignment(JLabel.RIGHT); // or RIGHT or CENTER
		}
		else {
			//sizeLabel.setText(" "); // Pour les dossiers.
			//dateLabel.setText(" ");
			if (fileNode.isParentDirectory()) {
				sizeLabel.setText(" "); // Pour les dossiers.
				dateLabel.setText(" ");
			}
			else { //if (fileNode.isDirectory())
				sizeLabel.setText(formatFileSize(fileNode.getSize())); // + "["+ fileNode.getNbFiles() + " files]");
				if (fileNode.getNbFiles() > 1) {
					//sizeLabel.setText(fileNode.getSize() + " items"); // with file.listFiles().length
					dateLabel.setText("    [" + fileNode.getNbFiles() + " files]"); // with Files.walk()
				}
				else {
					//sizeLabel.setText(fileNode.getSize() + " item"); // with file.listFiles().length
					dateLabel.setText("    [" + fileNode.getNbFiles() + " file]"); // with Files.walk()
				}
				dateLabel.setHorizontalAlignment(JLabel.LEFT); // or RIGHT or CENTER
				//sizeLabel.setText(formatFileSize(fileNode.getSize()));
				//dateLabel.setText(formatLastModified(fileNode.getLastModified()));
				//dateLabel.setText(" ");
			}
			
		}
		return this;
	}
	
	private boolean isRootNode(JTree tree, DefaultMutableTreeNode node) {
		Object root = tree.getModel().getRoot();
		return root == node;
	}
	
	/**
	 * Convertit une taille exprimée en octets
	 * en une chaîne lisible.
	 */
	private String formatFileSize(long size) {
		if (size < 1024) {
			return size + " o";
		}
		if (size < 1024L * 1024L) {
			return String.format("%.1f Ko", size / 1024.0);
		}
		if (size < 1024L * 1024L * 1024L) {
			return String.format("%.1f Mo", size / (1024.0 * 1024.0));
		}
		return String.format("%.1f Go", size / (1024.0 * 1024.0 * 1024.0));
	}
	
	/**
	 * Convertit le timestamp de dernière
	 * modification en date/heure locale.
	 */
	private String formatLastModified(long timestamp) {
		Instant instant = Instant.ofEpochMilli(timestamp);
		LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
		return DATE_FORMATTER.format(dateTime);
	}
}

	/**
	* Layout horizontal spécialisé pour les lignes du JTree.
	* Colonnes :
	*   [Checkbox] [Icône] [Nom] [Taille] [Dernière modification]
	* Les largeurs sont fixes, ce qui permet d'obtenir un véritable
	* alignement vertical entre les différentes lignes du JTree.
	*/
	class FileTreeRowLayout implements LayoutManager {
		/*
		 * Largeurs des colonnes.
		 */
		public static final int CHECKBOX_WIDTH = 30;
		public static final int ICON_WIDTH     = 32;
		public static final int NAME_WIDTH     = 300;
		public static final int SIZE_WIDTH     = 100;
		public static final int DATE_WIDTH     = 150;
		/*
		 * Hauteur d'une ligne.
		 */
		private static final int ROW_HEIGHT = 24;
		@Override
		public void addLayoutComponent(String name, Component comp) {
			// Rien à faire.
		}
		@Override
		public void removeLayoutComponent(Component comp) {
			// Rien à faire.
		}
		@Override
		public Dimension preferredLayoutSize(Container parent) {
			int width = CHECKBOX_WIDTH + ICON_WIDTH + NAME_WIDTH + SIZE_WIDTH + DATE_WIDTH;
			return new Dimension(width, ROW_HEIGHT);
		}
		@Override
		public Dimension minimumLayoutSize(Container parent) {
			return preferredLayoutSize(parent);
		}
		@Override
		public void layoutContainer(Container parent) {
			int x = 0;
			int height = parent.getHeight();
			Component[] components = parent.getComponents();
			/*
			 * Ordre attendu :
			 *   0 = checkbox
			 *   1 = icône
			 *   2 = nom
			 *   3 = taille
			 *   4 = date
			 */
			if (components.length > 0) {
				components[0].setBounds(x, 0, CHECKBOX_WIDTH, height);
				x += CHECKBOX_WIDTH;
			}
			if (components.length > 1) {
				components[1].setBounds(x, 0, ICON_WIDTH, height);
				x += ICON_WIDTH;
			}
			if (components.length > 2) {
				components[2].setBounds(x, 0, NAME_WIDTH, height);
				x += NAME_WIDTH;
			}
			if (components.length > 3) {
				components[3].setBounds(x, 0, SIZE_WIDTH, height);
				x += SIZE_WIDTH;
			}
			if (components.length > 4) {
				components[4].setBounds(x, 0, DATE_WIDTH, height);
			}
		}
	}


/**
 * JTree spécialisé pour l'explorateur de fichiers.
 */
class FileExplorerTree extends JTree {
	private final Set<File> selectedFiles;
	
	public FileExplorerTree(DefaultTreeModel model, Set<File> selectedFiles) {
		super(model);
		this.selectedFiles = selectedFiles;
		setCellRenderer(new CheckBoxTreeCellRenderer());
		setRootVisible(true);
		setShowsRootHandles(true);
		setRowHeight(24);
		/*
		 * Gestion des clics.
		 */
		addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				TreePath path = getPathForLocation(e.getX(), e.getY());
				if (path == null) {
					return;
				}
				DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
				Object userObject = node.getUserObject();
				if (!(userObject instanceof FileNode)) {
					return;
				}
				FileNode fileNode = (FileNode) userObject;
				/*
				 * Double-clic :
				 * uniquement pour naviguer dans les dossiers.
				 */
				if (e.getClickCount() == 2
						&& e.getButton() == MouseEvent.BUTTON1) {
					if (fileNode.isDirectory()) {
						firePropertyChange("directoryDoubleClicked", null, fileNode.getFile());
					}
					return;
				}
				/*
				 * Simple clic :
				 * uniquement sur les fichiers.
				 */
				if (e.getClickCount() == 1
						&& e.getButton() == MouseEvent.BUTTON1) {
					if (fileNode.isFile()) {
						toggleFile(fileNode.getFile());
						repaint();
						firePropertyChange("selectionChanged", null, fileNode.getFile());
					}
					else {
						//if (path.getPathCount() == 1) { // simple clic sur la racine
						if (node == (DefaultMutableTreeNode) getModel().getRoot()) {
							boolean select = !areAllFilesSelected();
							toggleAllFiles(select);
						}
					}
				}
			}
		});
		setupKeyboardActions(); // gestion du clavier
	}
	
	private void setupKeyboardActions() {
		InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
		ActionMap actionMap = getActionMap();
		inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "toggleFile");
		inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0), "toggleFile");
		actionMap.put("toggleFile", new AbstractAction() {
			@Override
			public void actionPerformed(ActionEvent e) {
				TreePath path = getSelectionPath();
				if (path == null) {
					return;
				}
				DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
				Object userObject = node.getUserObject();
				if (!(userObject instanceof FileNode)) {
					return;
				}
				FileNode fileNode = (FileNode) userObject;
				/*
				 * On ne permet de cocher/décocher que les fichiers, pas les dossiers.
				 */
				if (fileNode.isFile()) {
					toggleFile(fileNode.getFile());
					repaint();
					FileExplorerTree.this.firePropertyChange("selectionChanged", null, fileNode.getFile());
				}
				else {
					//if (path.getPathCount() == 1) { // simple clic sur la racine
					if (node == (DefaultMutableTreeNode) getModel().getRoot()) {
						boolean select = !areAllFilesSelected();
						toggleAllFiles(select);
					}
				}
			}
		});
	}
	
	public boolean areAllFilesSelected() {
		DefaultMutableTreeNode root = (DefaultMutableTreeNode) getModel().getRoot();
		return areAllFilesSelected(root);
	}
	
	private boolean areAllFilesSelected(DefaultMutableTreeNode node) {
		boolean FilesIsSelected = false;
		for (int i = 0; i < node.getChildCount(); i++) {
			DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(i);
			Object userObject = child.getUserObject();
			if (userObject instanceof FileNode) {
				FileNode fileNode = (FileNode) userObject;
				if (fileNode.isFile()) {
					if (!selectedFiles.contains(fileNode.getFile())) {
						return false;
					}
					else {
						FilesIsSelected = true;
					}
				}
			}
			//if (!areAllFilesSelected(child)) {
			//	return false;
			//}
		}
		return FilesIsSelected;
	}
	
	private void toggleAllFiles(boolean select) {
		DefaultMutableTreeNode root = (DefaultMutableTreeNode) getModel().getRoot();
		toggleFilesRecursively(root, select);
		repaint();
		firePropertyChange("selectionChanged", null, null);
	}
	
	private void toggleFilesRecursively(DefaultMutableTreeNode node, boolean select) {
		for (int i = 0; i < node.getChildCount(); i++) {
			DefaultMutableTreeNode child =
					(DefaultMutableTreeNode) node.getChildAt(i);
			Object userObject = child.getUserObject();
			if (userObject instanceof FileNode) {
				FileNode fileNode = (FileNode) userObject;
				if (fileNode.isFile()) {
					if (select) {
						selectedFiles.add(fileNode.getFile());
					} else {
						selectedFiles.remove(fileNode.getFile());
					}
				}
			}
			// On continue à parcourir les sous-dossiers.
			toggleFilesRecursively(child, select);
		}
	}
	
	private void toggleFile(File file) {
		if (selectedFiles.contains(file)) {
			selectedFiles.remove(file);
		} else {
			selectedFiles.add(file);
		}
	}
	public boolean isFileSelected(File file) {
		return selectedFiles.contains(file);
	}
	
	public long nbFilesCount() {
		long sum = 0;
		DefaultMutableTreeNode root = (DefaultMutableTreeNode) getModel().getRoot();
		for (int i = 0; i < root.getChildCount(); i++) {
			DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i);
			Object userObject = child.getUserObject();
			if (userObject instanceof FileNode) {
				FileNode fileNode = (FileNode) userObject;
				//System.out.println(Long.toString(fileNode.getNbFiles()));
				sum += fileNode.getNbFiles();
			}
		}
		return sum;
	}
	
	public long sizeAllFiles() {
		long sum = 0;
		DefaultMutableTreeNode root = (DefaultMutableTreeNode) getModel().getRoot();
		for (int i = 0; i < root.getChildCount(); i++) {
			DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i);
			Object userObject = child.getUserObject();
			if (userObject instanceof FileNode) {
				FileNode fileNode = (FileNode) userObject;
				//System.out.println(Long.toString(fileNode.getNbFiles()));
				sum += fileNode.getSize();
			}
		}
		return sum;
	}
}


/**
 * Application principale.
 */
public class CheckBoxTree extends JFrame {
	private final JTextArea textArea;
	private final JTextField textPath;
	private final JLabel statusBar;
	private final Set<File> selectedFiles;
	private File currentDirectory;
	private FileExplorerTree tree;
	private DefaultTreeModel treeModel;
	private static String fileSeparator = FileSystems.getDefault().getSeparator();
	
	/*
	private class FileInfo {
		final Path path;
		final String name;
		final boolean directory;
		
		FileInfo(Path path) {
			this.path = path;
			this.name = path.getFileName().toString();
			this.directory = Files.isDirectory(path);
		}
	}
	*/
	private static final class FileEntry {
		final File file;
		final String name;
		final boolean directory;
		FileEntry(File file) {
			this.file = file;
			this.name = file.getName();
			this.directory = file.isDirectory();
		}
	}
	
	public void setHourglass(boolean value) {
		if (value) {
			setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
		}
		else {
			setCursor(Cursor.getDefaultCursor());
		}
	}
	
	private String formatFileSize(long size) {
		if (size < 1024) {
			return size + " o";
		}
		if (size < 1024L * 1024L) {
			return String.format("%.1f Ko", size / 1024.0);
		}
		if (size < 1024L * 1024L * 1024L) {
			return String.format("%.1f Mo", size / (1024.0 * 1024.0));
		}
		return String.format("%.1f Go", size / (1024.0 * 1024.0 * 1024.0));
	}
	
	private static String longTimeToString(long value) {
		if (value < 1000) {
			double elapsedTimeSeconds = value / 1000.0;
			return String.format("%.3f sec.", elapsedTimeSeconds);
		}
		else {
			if (value < 60000L) {
				double elapsedTimeSeconds = value / 1000.0;
				return String.format("%.1f sec.", elapsedTimeSeconds);
				//return Long.toString(value) + " sec.";
			}
			else if (value < 3600000L) {
				value /= 1000;
				if ((value % 60L) == 0)
					return Long.toString(value / 60L) + " min.";
				else
					return Long.toString(value / 60L) + " min." +
							Long.toString(value % 60L) + " sec.";
			}
			else {
				value /= 1000;
				if ((value % 3600L) == 0)
					return Long.toString(value / 3600L) + " h.";
				else {
					String sRet = Long.toString(value / 3600L) + " h.";
					value = value % 3600L;
					if ((value % 60L) == 0)
						sRet = sRet + Long.toString(value / 60L) + " min.";
					else
						sRet = sRet + Long.toString(value / 60L) + " min." +
							Long.toString(value % 60L) + " sec.";
					return sRet;
				}
			}
		}
	}
	
	/**
	 * Création de l'arbre.
	 */
	private FileExplorerTree createTree() {
		DefaultMutableTreeNode root = new DefaultMutableTreeNode(new FileNode(currentDirectory, FileNodeType.DIRECTORY));
		treeModel = new DefaultTreeModel(root);
		FileExplorerTree fileTree = new FileExplorerTree(treeModel, selectedFiles);
		fileTree.addPropertyChangeListener(
				"directoryDoubleClicked",
				evt -> {
					File directory = (File) evt.getNewValue();
					loadDirectory(directory);
				}
		);
		fileTree.addPropertyChangeListener(
				"selectionChanged",
				evt -> updateStatusBar()
		);
		return fileTree;
	}
	
	private static String stripLeadingZeros(String value) {
		int i = 0;
		while (i < value.length() - 1 && value.charAt(i) == '0') {
			i++;
		}
		return value.substring(i);
	}
	/*
	private static int naturalCompare(String s1, String s2, Collator collator) {
		int i = 0;
		int j = 0;
		while (i < s1.length() && j < s2.length()) {
			char c1 = s1.charAt(i);
			char c2 = s2.charAt(j);
			// Les deux caractères commencent un nombre
			if (Character.isDigit(c1) && Character.isDigit(c2)) {
				int start1 = i;
				int start2 = j;
				// Cherche la fin du nombre
				while (i < s1.length()
						&& Character.isDigit(s1.charAt(i))) {
					i++;
				}
				while (j < s2.length()
						&& Character.isDigit(s2.charAt(j))) {
					j++;
				}
				String num1 = s1.substring(start1, i);
				String num2 = s2.substring(start2, j);
				// Supprime les zéros à gauche
				//String n1 = num1.replaceFirst("^0+(?!$)", "");
				//String n2 = num2.replaceFirst("^0+(?!$)", "");
				String n1 = stripLeadingZeros(num1);
				String n2 = stripLeadingZeros(num2);
				
				// Compare d'abord la longueur :
				// 2 chiffres < 10 chiffres
				if (n1.length() != n2.length()) {
					return n1.length() < n2.length() ? -1 : 1;
				}
				// Même longueur : comparaison lexicographique
				int result = n1.compareTo(n2);
				if (result != 0) {
					return result;
				}
				// Même valeur numérique.
				// On peut départager "001" et "1".
				if (num1.length() != num2.length()) {
					return num1.length() < num2.length() ? -1 : 1;
				}
				continue;
			}
			// Comparaison de la partie non numérique
			int start1 = i;
			int start2 = j;
			while (i < s1.length()
					&& !Character.isDigit(s1.charAt(i))) {
				i++;
			}
			while (j < s2.length()
					&& !Character.isDigit(s2.charAt(j))) {
				j++;
			}
			String part1 = s1.substring(start1, i);
			String part2 = s2.substring(start2, j);
			int result = collator.compare(part1, part2);
			if (result != 0) {
				return result;
			}
		}
		// Si tout ce qui précède est identique,
		// le plus court vient en premier.
		if (i < s1.length()) {
			return 1;
		}
		if (j < s2.length()) {
			return -1;
		}
		return 0;
	}
	*/
	
	private static boolean isDigit(char c) {
		return c >= '0' && c <= '9';
	}
	private static int naturalCompare(FileEntry e1, FileEntry e2, Collator collator) {
		String s1 = e1.name;
		String s2 = e2.name;
		int i = 0;
		int j = 0;
		while (i < s1.length() && j < s2.length()) {
			char c1 = s1.charAt(i);
			char c2 = s2.charAt(j);
			// =================================================
			// Les deux caractères commencent un nombre
			// =================================================
			if (isDigit(c1) && isDigit(c2)) {
				int start1 = i;
				int start2 = j;
				// Cherche la fin du nombre
				while (i < s1.length() && isDigit(s1.charAt(i))) {
					i++;
				}
				while (j < s2.length() && isDigit(s2.charAt(j))) {
					j++;
				}
				int end1 = i;
				int end2 = j;
				// -------------------------------------------------
				// Ignore les zéros à gauche
				// -------------------------------------------------
				int significantStart1 = start1;
				while (significantStart1 < end1
						&& s1.charAt(significantStart1) == '0') {
					significantStart1++;
				}
				int significantStart2 = start2;
				while (significantStart2 < end2
						&& s2.charAt(significantStart2) == '0') {
					significantStart2++;
				}
				/*
				 * Cas particulier :
				 *
				 * "000" -> valeur 0
				 * "00"  -> valeur 0
				 *
				 * On conserve néanmoins les longueurs originales
				 * pour pouvoir les départager.
				 */
				int significantLength1 = end1 - significantStart1;
				int significantLength2 = end2 - significantStart2;
				// Tous les chiffres étaient des zéros
				if (significantLength1 == 0) {
					significantLength1 = 1;
				}
				if (significantLength2 == 0) {
					significantLength2 = 1;
				}
				// -------------------------------------------------
				// 1. Nombre de chiffres significatifs
				// -------------------------------------------------
				if (significantLength1 != significantLength2) {
					return significantLength1 < significantLength2
							? -1
							: 1;
				}
				// -------------------------------------------------
				// 2. Comparaison de la valeur numérique
				// -------------------------------------------------
				for (int k = 0; k < significantLength1; k++) {
					char n1 = s1.charAt((end1 - significantLength1) + k);
					char n2 = s2.charAt((end2 - significantLength2) + k);
					if (n1 != n2) {
						return n1 < n2 ? -1 : 1;
					}
				}
				// -------------------------------------------------
				// 3. Même valeur numérique
				//
				// Exemple :
				//     "1"   < "01" < "001"
				// -------------------------------------------------
				int originalLength1 = end1 - start1;
				int originalLength2 = end2 - start2;
				if (originalLength1 != originalLength2) {
					return originalLength1 < originalLength2 ? -1 : 1;
				}
				continue;
			}
			// =================================================
			// Partie texte
			// =================================================
			int start1 = i;
			int start2 = j;
			while (i < s1.length() && !isDigit(s1.charAt(i))) {
				i++;
			}
			while (j < s2.length() && !isDigit(s2.charAt(j))) {
				j++;
			}
			int result = collator.compare(s1.substring(start1, i), s2.substring(start2, j));
			if (result != 0) {
				return result;
			}
		}
		// =====================================================
		// Une chaîne est un préfixe de l'autre
		// =====================================================
		if (i < s1.length()) {
			return 1;
		}
		if (j < s2.length()) {
			return -1;
		}
		return 0;
	}
	
	/**
	 * Charge le contenu d'un répertoire.
	 */
	private void loadDirectory(File directory) {
		if (directory == null) {
			return;
		}
		if (!directory.isDirectory()) {
			return;
		}
		statusBar.setText("Scanning the directory in progress. Please wait...");
		//statusBar.revalidate(); // Recalcule la disposition du composant
		statusBar.repaint(); // Force un redessin du composant
		
		/*
		// Créer un SwingWorker pour exécuter le chargement en arrière-plan
		SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
			@Override
			protected Void doInBackground() throws Exception {
				loadDirectory(directory);
				return null;
			}
			@Override
			protected void done() {
				//updateStatusBar();
				statusBar.setText("No file selected");
				statusBar.revalidate();
				statusBar.repaint();
			}
		};
		// Démarrer le worker
		worker.execute();
		*/
		
		SwingUtilities.invokeLater(() -> {
			setHourglass(true);
			long startTime = System.currentTimeMillis();
			/*
			 * La navigation réinitialise la sélection.
			 */
			selectedFiles.clear();
			currentDirectory = directory.getAbsoluteFile();
			/*
			 * Nouveau modèle.
			 */
			DefaultMutableTreeNode root = new DefaultMutableTreeNode(new FileNode(currentDirectory, FileNodeType.DIRECTORY));
			/*
			 * ============================
			 * Répertoire parent
			 * ============================
			 */
			File parent = currentDirectory.getParentFile();
			if (parent != null) {
				root.add(new DefaultMutableTreeNode(new FileNode(parent, FileNodeType.PARENT_DIRECTORY)));
			}
			/*
			 * ============================
			 * Contenu du répertoire
			 * ============================
			 */
			 
			/*
			Collator collator = Collator.getInstance(Locale.FRENCH);
			collator.setStrength(Collator.PRIMARY);
			File[] files = currentDirectory.listFiles();
			if (files != null) {
				//
				// Sort by :
				// 1. directories
				// 2. files
				// 3. filenames with "natural sort"
				//
				
				Arrays.sort(files, new Comparator<File>() {
					@Override
					public int compare(File f1, File f2) {
						// 1. Directories before files
						boolean dir1 = f1.isDirectory();
						boolean dir2 = f2.isDirectory();
						if (dir1 && !dir2) {
							return -1;
						}
						if (!dir1 && dir2) {
							return 1;
						}
						// 2. "natural sort" method
						return naturalCompare(f1.getName(), f2.getName(),collator);
						//return f1.getName().compareToIgnoreCase(f2.getName()); // old method
					}
				});
				
				//Arrays.sort(files, WindowsFileComparator.INSTANCE); // external Java file (not ready yet)
				
				for (File file : files) {
					FileNodeType type;
					if (file.isDirectory()) {
						type = FileNodeType.DIRECTORY;
					} else {
						type = FileNodeType.FILE;
					}
					root.add(new DefaultMutableTreeNode(new FileNode(file, type)));
				}
			}
			*/
			/*
			Path currentPath = currentDirectory.toPath();
			try (Stream<Path> stream = Files.list(currentPath)) {
				List<Path> paths = stream.collect(Collectors.toList());
				Collator collator = Collator.getInstance(Locale.FRENCH);
				collator.setStrength(Collator.PRIMARY);
				paths.sort(new Comparator<Path>() {
					@Override
					public int compare(Path p1, Path p2) {
						boolean dir1 = Files.isDirectory(p1);
						boolean dir2 = Files.isDirectory(p2);
						if (dir1 != dir2) {
							return dir1 ? -1 : 1;
						}
						return naturalCompare(
								p1.getFileName().toString(),
								p2.getFileName().toString(),
								collator);
					}
				});
				for (Path path : paths) {
					File file = path.toFile();
					FileNodeType type = Files.isDirectory(path)
							? FileNodeType.DIRECTORY
							: FileNodeType.FILE;
					root.add(new DefaultMutableTreeNode(new FileNode(file, type)));
				}
			}
			catch (IOException ex) {
				//ex.printStackTrace();
			}
			*/
			/*
			try (Stream<Path> stream = Files.list(currentDirectory.toPath())) {
				List<FileInfo> files = stream
						.map(FileInfo::new)
						.collect(Collectors.toList());
				Collator collator = Collator.getInstance(Locale.FRENCH);
				collator.setStrength(Collator.PRIMARY);
				files.sort(new Comparator<FileInfo>() {
					@Override
					public int compare(FileInfo f1, FileInfo f2) {
						// Répertoires avant fichiers
						if (f1.directory != f2.directory) {
							return f1.directory ? -1 : 1;
						}
						// Tri naturel
						return naturalCompare(f1.name, f2.name, collator);
					}
				});
				for (FileInfo info : files) {
					FileNodeType type = info.directory
							? FileNodeType.DIRECTORY
							: FileNodeType.FILE;
					root.add(new DefaultMutableTreeNode(
							new FileNode(info.path.toFile(), type)));
				}
			}
			catch (IOException ex) {
				//ex.printStackTrace();
			}
			*/
			
			List<FileEntry> entries = new ArrayList<FileEntry>();
			try (Stream<Path> stream = Files.list(currentDirectory.toPath())) {
				stream.forEach(path -> {
					entries.add(new FileEntry(path.toFile()));
				});
			}
			catch (IOException ex) {
				//ex.printStackTrace();
			}
			Collator collator = Collator.getInstance(Locale.FRENCH);
			collator.setStrength(Collator.PRIMARY);
			
			entries.sort(new Comparator<FileEntry>() {
				@Override
				public int compare(FileEntry e1, FileEntry e2) {
					// Répertoires avant fichiers
					if (e1.directory != e2.directory) {
						return e1.directory ? -1 : 1;
					}
					// Tri naturel
					//return naturalCompare(e1.name, e2.name, collator);
					return naturalCompare(e1, e2, collator);
				}
			});
			
			/*
			entries.sort((e1, e2) -> {
				if (e1.directory != e2.directory) {
					return e1.directory ? -1 : 1;
				}
				return naturalCompare(e1, e2, collator);
			});
			*/
			for (FileEntry entry : entries) {
				FileNodeType type = entry.directory
						? FileNodeType.DIRECTORY
						: FileNodeType.FILE;
				root.add(new DefaultMutableTreeNode(
						new FileNode(entry.file, type)));
			}
			
			/*
			 * Remplacement du modèle.
			 */
			treeModel = new DefaultTreeModel(root);
			tree.setModel(treeModel);
			/*
			 * Mise à jour du titre.
			 */
			//setTitle("My file explorer - " + currentDirectory.getAbsolutePath());
			setTitle("My file explorer - [" + currentDirectory.getName() + "]");
			String str1 = currentDirectory.getAbsolutePath();
			if (!str1.isEmpty()) {
				if (!(fileSeparator.equals(str1.substring(str1.length() - 1))))
					str1 = str1 + fileSeparator;
			}
			else str1 = "." + fileSeparator;
			textPath.setText(str1);
			
			//updateStatusBar();
			// End of timing
			long endTime = System.currentTimeMillis();
			// Elapsed time calculation
			long elapsedTimeMillis = endTime - startTime;
			//long elapsedTimeSeconds = elapsedTimeMillis / 1000 + 1;
			//System.out.println(elapsedTimeSeconds);
			
			String endStr;
			long result = tree.nbFilesCount();
			long result2 = tree.sizeAllFiles();
			if (result > 1) endStr = new DecimalFormat("#,###").format(result) +" Files]";
			else endStr = "1 File]";
			endStr = " [" + formatFileSize(result2) + "] [" + endStr;
			
			statusBar.setText("Scan terminated [" + longTimeToString(elapsedTimeMillis) + 
				"]" + endStr);
			setHourglass(false);
		});
	}
	
	
	/**
	 * Mise à jour de la barre de statut.
	 */
	private void updateStatusBar() {
		int count = selectedFiles.size();
		if (count == 0) {
			statusBar.setText("No file selected");
		} else if (count == 1) {
			statusBar.setText("1 file selected");
		} else {
			statusBar.setText(Integer.toString(count) + " files selected");
		}
	}
	
	/*
	 * Action déclenchée par le bouton.
	 */
	private void executerAction() {
		if (selectedFiles.isEmpty()) {
			JOptionPane.showMessageDialog(this, "No file selected.", "Action", JOptionPane.INFORMATION_MESSAGE);
			return;
		}
		/*
		 * Copie de la sélection.
		 * Cela évite que le traitement utilise directement la collection interne.
		 */
		List<File> filesToProcess = new ArrayList<File>(selectedFiles);
		/*
		 * Exemple :
		 * affichage des fichiers sélectionnés.
		 */
		StringBuilder message = new StringBuilder();
		message.append("Files selected :\n\n");
		for (File file : filesToProcess) {
			message.append(file.getAbsolutePath());
			message.append("\n");
		}
		textArea.setText(message.toString());
		/*
		 * C'est ici que devra être placé
		 * le véritable traitement.
		 */
	}
	
	/**
	 * Choix du répertoire déclenchée par le bouton "Ouvrir"
	 */
	private void executerOpen() {
		//Create a file chooser
		JFileChooser fileChooser = new JFileChooser(){
			@Override
			protected JDialog createDialog( Component parent ) throws HeadlessException {
				JDialog dialog = super.createDialog( parent );
				//dialog.setIconImage(icon);
				return dialog;
			}
		};
		//fileChooser.setMultiSelectionEnabled(false);
		fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
		fileChooser.setPreferredSize(new Dimension(600,600));
		//fileChooser.setDialogTitle(buttonOpen.getText());
		fileChooser.setDialogTitle("Choose the working directory");
		//if (fileSeparator.equals(txtPath2.getText()))
		if (!currentDirectory.exists())
			fileChooser.setCurrentDirectory(new File(System.getProperty("user.dir")));
		else
			fileChooser.setCurrentDirectory(currentDirectory);
		int returnVal = fileChooser.showOpenDialog(null);
		if (returnVal == JFileChooser.APPROVE_OPTION) {
			//txtPath2.setText(fileChooser.getPath());
			File file = fileChooser.getSelectedFile();
			if (file.exists())
			{
				// Refresh TreeView
				loadDirectory(file);
			}
		} 
	}
	
	/**
	 * Création de la barre de menus.
	 */
	private void createMenuBar() {
		JMenuBar menuBar =
				new JMenuBar();
		JMenu menuFichier =
				new JMenu("File");
		JMenuItem itemQuitter =
				new JMenuItem("Quit");
		itemQuitter.addActionListener(
				e -> System.exit(0)
		);
		menuFichier.add(itemQuitter);
		JMenu menuAPropos =
				new JMenu("About");
		JMenuItem itemAPropos =
				new JMenuItem("About");
		itemAPropos.addActionListener(
				e -> afficherBoiteDialogueAPropos()
		);
		menuAPropos.add(itemAPropos);
		menuBar.add(menuFichier);
		menuBar.add(menuAPropos);
		setJMenuBar(menuBar);
	}
	
	/**
	 * Boîte "À propos".
	 */
	private void afficherBoiteDialogueAPropos() {
		//ImageIcon icon = new ImageIcon("CheckBoxTree.png");
		ImageIcon icon = new ImageIcon(getClass().getClassLoader().getResource("CheckBoxTree.png"));
		if (icon.getIconWidth() != 128 || icon.getIconHeight() != 128) {
			icon = new ImageIcon(icon.getImage().getScaledInstance(128, 128, Image.SCALE_SMOOTH));
		}
		String message = "<html>"
				+ "<div style='text-align: center;'>"
				+ "<h2>My Application</h2>"
				+ "<p><b>Author :</b> Votre Nom</p>"
				+ "<p><b>Creation date :</b> 16/08/2026</p>"
				+ "<p><b>Description :</b> "
				+ "A Java Swing file explorer.</p>"
				+ "</div></html>";
		JOptionPane.showMessageDialog(this, message, "About", JOptionPane.INFORMATION_MESSAGE, icon);
	}
	
	public CheckBoxTree() {
		/*
		 * ============================
		 * Initialisation
		 * ============================
		 */
		selectedFiles = new LinkedHashSet<File>();
		//currentDirectory = new File(".").getAbsoluteFile();
		currentDirectory = new File(System.getProperty("user.dir")).getAbsoluteFile();
		/*
		 * ============================
		 * Fenêtre
		 * ============================
		 */
		setTitle("My file explorer");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setLayout(new BorderLayout());
		/*
		 * ============================
		 * Menu
		 * ============================
		 */
		createMenuBar();
		/*
		 * ============================
		 * Zone supérieure
		 * ============================
		 */
		JPanel panelZoneCentrale = new JPanel(new BorderLayout());
		panelZoneCentrale.setPreferredSize(new Dimension(800, 150));
		textArea = new JTextArea();
		textArea.setLineWrap(true);
		textArea.setWrapStyleWord(true);
		JScrollPane textScrollPane = new JScrollPane(textArea);
		panelZoneCentrale.add(textScrollPane, BorderLayout.CENTER);
		JButton buttonAction = new JButton("Action");
		buttonAction.addActionListener(e -> executerAction());
		panelZoneCentrale.add(buttonAction, BorderLayout.EAST);
		add(panelZoneCentrale, BorderLayout.NORTH);
		/*
		 * ============================
		 * Arbre
		 * ============================
		 */
		tree = createTree();
		JScrollPane treeScrollPane = new JScrollPane(tree);
		// Bandeau supérieur avec une bordure en haut et bas
		JPanel panelCenter = new JPanel(new BorderLayout());
		JPanel panelPath = new JPanel(new BorderLayout());
		panelPath.setPreferredSize(new Dimension(600, 40));
		panelPath.setBorder(BorderFactory.createEmptyBorder(5, 0, 5, 0)); //top, left, bottom, right
		textPath = new JTextField();
		textPath.setEditable(false);
		// Change text font size
		textPath.setFont(new Font("SansSerif",Font.PLAIN,14)); //(new Font("Serif",Font.BOLD,12));
		// Change text font color
		textPath.setBackground(Color.WHITE);
		textPath.setForeground(Color.BLACK);
		panelPath.add(textPath, BorderLayout.CENTER);
		JButton buttonOpen = new JButton("Open");
		buttonOpen.addActionListener(e -> executerOpen());
		JPanel panelButton = new JPanel(new BorderLayout());
		// Ajoute un espace entre textPath et buttonOpen
		panelButton.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 0));
		panelButton.add(buttonOpen, BorderLayout.CENTER);
		panelPath.add(panelButton,BorderLayout.EAST);
		panelCenter.add(panelPath, BorderLayout.NORTH);
		panelCenter.add(treeScrollPane, BorderLayout.CENTER);
		// Ajoute ces panels à la frame principale
		add(panelCenter, BorderLayout.CENTER);
		/*
		 * ============================
		 * Barre de statut
		 * ============================
		 */
		statusBar = new JLabel();
		statusBar.setText(" ");
		statusBar.setHorizontalAlignment(SwingConstants.LEFT);
		statusBar.setBorder(BorderFactory.createEtchedBorder());
		add(statusBar, BorderLayout.SOUTH);
		/*
		 * Chargement initial.
		 */
		loadDirectory(currentDirectory);
		//statusBar.setText("No file selected");
		//updateStatusBar();
		/*
		 * ============================
		 * Fenêtre
		 * ============================
		 */
		setSize(800, 800);
		//setPreferredSize(new Dimension(800, 800));
		setLocationRelativeTo(null);
	}
	
	/**
	 * Point d'entrée.
	 */
	public static void main(String[] args) {
		try {
			boolean UIstyleFound = false;
			UIManager.LookAndFeelInfo[] looks = UIManager.getInstalledLookAndFeels();
			for (UIManager.LookAndFeelInfo look : looks) {
				//System.out.println(look.getClassName());
				if (look.getClassName().toLowerCase().endsWith(".nimbuslookandfeel")) {
					UIstyleFound = true;
					
				}
			}
			if (UIstyleFound) {
				//UIManager.setLookAndFeel(new javax.swing.plaf.metal.MetalLookAndFeel());
				//UIManager.setLookAndFeel(new javax.swing.plaf.nimbus.NimbusLookAndFeel());
				//UIManager.setLookAndFeel(new com.sun.java.swing.plaf.motif.MotifLookAndFeel());
				//UIManager.setLookAndFeel(new com.sun.java.swing.plaf.gtk.GTKLookAndFeel());
				//UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
				//UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
				//UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
				UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
			}
			else {
				System.out.println(UIManager.getSystemLookAndFeelClassName());
				UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
			}
		}
		catch (Exception ex) {
			//ex.printStackTrace();
		}
		finally {
			SwingUtilities.invokeLater(() -> {
						CheckBoxTree application = new CheckBoxTree();
						//application.pack();
						application.setVisible(true);
					}
			);
		}
	}
}