improve file manager
[jSite2.git] / src / net / pterodactylus / jsite / gui / FileManager.java
index faec4ae..68dfb2c 100644 (file)
 package net.pterodactylus.jsite.gui;
 
 import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.FlowLayout;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.io.File;
@@ -28,21 +35,30 @@ import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
 import javax.swing.JDialog;
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTree;
 import javax.swing.event.TreeModelListener;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
 import javax.swing.tree.TreeModel;
 import javax.swing.tree.TreePath;
 
 import net.pterodactylus.jsite.i18n.I18n;
 import net.pterodactylus.jsite.i18n.I18nable;
+import net.pterodactylus.jsite.i18n.gui.I18nAction;
+import net.pterodactylus.jsite.i18n.gui.I18nLabel;
 import net.pterodactylus.jsite.project.Entry;
 import net.pterodactylus.jsite.project.Project;
 import net.pterodactylus.util.data.Node;
 import net.pterodactylus.util.data.Tree;
+import net.pterodactylus.util.io.MimeTypes;
 import net.pterodactylus.util.logging.Logging;
 import net.pterodactylus.util.swing.SwingUtils;
 
@@ -51,7 +67,7 @@ import net.pterodactylus.util.swing.SwingUtils;
  * 
  * @author David ‘Bombe’ Roden <bombe@freenetproject.org>
  */
-public class FileManager extends JDialog implements I18nable {
+public class FileManager extends JDialog implements I18nable, ActionListener, TreeSelectionListener {
 
        /** Logger. */
        private static final Logger logger = Logging.getLogger(FileManager.class.getName());
@@ -62,9 +78,30 @@ public class FileManager extends JDialog implements I18nable {
        /** The tree model for the project files. */
        private final FileTreeModel fileTreeModel;
 
+       /** The “close” action. */
+       private I18nAction closeAction;
+
+       /** The “project files” label. */
+       private I18nLabel projectFilesLabel;
+
        /** The tree that shows the files. */
        private JTree fileTree;
 
+       /** The “insert” action. */
+       private I18nAction insertAction;
+
+       /** The “insert” checkbox. */
+       private JCheckBox insertCheckBox;
+
+       /** The “use custom mime type” action. */
+       private I18nAction useCustomMimeTypeAction;
+
+       /** The “use custom mime type” checkbox. */
+       private JCheckBox useCustomMimeTypeCheckBox;
+
+       /** The “mime type” combo box. */
+       private JComboBox mimeTypeComboBox;
+
        /**
         * Creates a new file manager.
         * 
@@ -78,25 +115,147 @@ public class FileManager extends JDialog implements I18nable {
                logger.log(Level.FINEST, "project: " + project);
                this.project = project;
                fileTreeModel = new FileTreeModel();
+               initActions();
                initComponents();
-               SwingUtils.repackCentered(this);
+               pack();
+               SwingUtils.center(this);
        }
 
        //
-       // PRIVATE ACTIONS
+       // PRIVATE METHODS
        //
 
        /**
+        * Initializes all actions.
+        */
+       private void initActions() {
+               closeAction = new I18nAction("fileManager.button.close") {
+
+                       /**
+                        * {@inheritDoc}
+                        */
+                       public void actionPerformed(ActionEvent e) {
+                               setVisible(false);
+                       }
+               };
+               insertAction = new I18nAction("fileManager.checkbox.insertFile") {
+
+                       /**
+                        * {@inheritDoc}
+                        */
+                       @SuppressWarnings("synthetic-access")
+                       public void actionPerformed(ActionEvent actionEvent) {
+                               useCustomMimeTypeAction.setEnabled(insertCheckBox.isSelected());
+                               mimeTypeComboBox.setEnabled(insertCheckBox.isSelected());
+                               for (Entry entry: getSelectedEntries()) {
+                                       entry.setInsert(insertCheckBox.isSelected());
+                               }
+                       }
+               };
+               insertAction.setEnabled(false);
+               useCustomMimeTypeAction = new I18nAction("fileManager.checkbox.useCustomMimeType") {
+
+                       /**
+                        * {@inheritDoc}
+                        */
+                       @SuppressWarnings("synthetic-access")
+                       public void actionPerformed(ActionEvent actionEvent) {
+                               mimeTypeComboBox.setEnabled(useCustomMimeTypeCheckBox.isSelected());
+                               if (!useCustomMimeTypeCheckBox.isSelected()) {
+                                       for (Entry entry: getSelectedEntries()) {
+                                               entry.setContentType(null);
+                                       }
+                               }
+                       }
+               };
+               useCustomMimeTypeAction.setEnabled(false);
+       }
+
+       /**
         * Initializes all components.
         */
        private void initComponents() {
                JPanel contentPanel = new JPanel(new BorderLayout(12, 12));
+               contentPanel.setBorder(BorderFactory.createEmptyBorder(12, 12, 12, 12));
+
+               contentPanel.add(createFileManagerPanel(), BorderLayout.CENTER);
+               contentPanel.add(createButtonPanel(), BorderLayout.PAGE_END);
+
+               setContentPane(contentPanel);
+       }
+
+       /**
+        * Creates the main panel with the file tree and the file properties.
+        * 
+        * @return The mail panel
+        */
+       private Component createFileManagerPanel() {
+               JPanel fileManagerPanel = new JPanel(new BorderLayout(12, 12));
+
+               JPanel fileTreePanel = new JPanel(new BorderLayout(12, 12));
+               fileManagerPanel.add(fileTreePanel, BorderLayout.LINE_START);
 
                fileTree = new JTree(fileTreeModel);
                fileTree.setShowsRootHandles(false);
-               contentPanel.add(new JScrollPane(fileTree), BorderLayout.CENTER);
+               fileTree.addTreeSelectionListener(this);
+               fileTreePanel.add(new JScrollPane(fileTree), BorderLayout.CENTER);
 
-               setContentPane(contentPanel);
+               projectFilesLabel = new I18nLabel("fileManager.label.projectFiles", fileTree);
+               JPanel projectFilesLabelPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 0, 0));
+               fileTreePanel.add(projectFilesLabelPanel, BorderLayout.NORTH);
+               projectFilesLabelPanel.add(projectFilesLabel);
+
+               JPanel propertiesPanel = new JPanel(new GridBagLayout());
+               fileManagerPanel.add(propertiesPanel, BorderLayout.CENTER);
+               propertiesPanel.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEtchedBorder(), BorderFactory.createEmptyBorder(12, 12, 12, 12)));
+
+               insertCheckBox = new JCheckBox(insertAction);
+               propertiesPanel.add(insertCheckBox, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
+
+               useCustomMimeTypeCheckBox = new JCheckBox(useCustomMimeTypeAction);
+               List<String> allMimeTypes = MimeTypes.getAllMimeTypes();
+               mimeTypeComboBox = new JComboBox(allMimeTypes.toArray(new String[0]));
+               mimeTypeComboBox.setEnabled(false);
+               mimeTypeComboBox.addActionListener(this);
+               propertiesPanel.add(useCustomMimeTypeCheckBox, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(6, 0, 0, 0), 0, 0));
+               propertiesPanel.add(mimeTypeComboBox, new GridBagConstraints(1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(6, 6, 0, 0), 0, 0));
+
+               propertiesPanel.add(new JPanel(), new GridBagConstraints(0, 2, 1, 1, 1.0, 1.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
+
+               return fileManagerPanel;
+       }
+
+       /**
+        * Creates the button panel.
+        * 
+        * @return The button panel
+        */
+       private Component createButtonPanel() {
+               JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING, 12, 12));
+
+               buttonPanel.setBorder(BorderFactory.createEmptyBorder(-12, -12, -12, -12));
+               JButton closeButton = new JButton(closeAction);
+               buttonPanel.add(closeButton);
+
+               getRootPane().setDefaultButton(closeButton);
+               return buttonPanel;
+       }
+
+       /**
+        * Returns a list of all selected entries.
+        * 
+        * @return The selected entries
+        */
+       private List<Entry> getSelectedEntries() {
+               TreePath[] selectedPaths = fileTree.getSelectionPaths();
+               List<Entry> entries = new ArrayList<Entry>();
+               for (TreePath selectedPath: selectedPaths) {
+                       Entry entry = ((FileTreePath) selectedPath.getLastPathComponent()).getFileEntry();
+                       if (entry != null) {
+                               entries.add(entry);
+                       }
+               }
+               return entries;
        }
 
        //
@@ -110,6 +269,53 @@ public class FileManager extends JDialog implements I18nable {
                setTitle(I18n.get("fileManager.title", project.getName()));
        }
 
+       //
+       // INTERFACE TreeSelectionListener
+       //
+
+       /**
+        * {@inheritDoc}
+        */
+       public void valueChanged(TreeSelectionEvent treeSelectionEvent) {
+               TreePath[] selectedPaths = fileTree.getSelectionPaths();
+               if (selectedPaths.length == 1) {
+                       Entry fileEntry = ((FileTreePath) selectedPaths[0].getLastPathComponent()).getFileEntry();
+                       if (fileEntry == null) {
+                               /* some directory node selected. */
+                               insertAction.setEnabled(false);
+                               insertCheckBox.setSelected(false);
+                               useCustomMimeTypeAction.setEnabled(false);
+                               useCustomMimeTypeCheckBox.setSelected(false);
+                               mimeTypeComboBox.setEnabled(false);
+                       } else {
+                               String contentType = fileEntry.getContentType();
+                               insertAction.setEnabled(true);
+                               insertCheckBox.setSelected(fileEntry.isInsert());
+                               useCustomMimeTypeAction.setEnabled(fileEntry.isInsert());
+                               useCustomMimeTypeCheckBox.setSelected(contentType != null);
+                               mimeTypeComboBox.setEnabled(contentType != null);
+                               mimeTypeComboBox.setSelectedItem(contentType);
+                       }
+               }
+       }
+
+       //
+       // INTERFACE ActionListener
+       //
+
+       /**
+        * {@inheritDoc}
+        */
+       public void actionPerformed(ActionEvent actionEvent) {
+               if (actionEvent.getSource() == mimeTypeComboBox) {
+                       String contentType = (String) mimeTypeComboBox.getSelectedItem();
+                       for (Entry entry: getSelectedEntries()) {
+                               entry.setContentType(contentType);
+                       }
+                       useCustomMimeTypeCheckBox.setSelected(contentType != null);
+               }
+       }
+
        /**
         * Model for the tree of files.
         * 
@@ -259,7 +465,52 @@ public class FileManager extends JDialog implements I18nable {
                        Node<FileTreePath> fileTreePathRootNode = fileTreePathTree.getRootNode();
                        fileTreePathRootNode.removeAllChildren();
                        convertTree(File.separator, pathRootNode, fileTreePathRootNode.addChild(new FileTreePath(File.separator, project.getName())));
-                       /* TODO  - now add entries to all file tree path tree nodes. */
+                       /* TODO - now add entries to all file tree path tree nodes. */
+                       addEntries(fileTreePathRootNode.getChild(0), project.getVirtualEntries());
+                       addEntries(fileTreePathRootNode.getChild(0), project.getBasePathEntries());
+               }
+
+               /**
+                * Traverses the tree and assigned {@link Entry}s to every file tree
+                * path whose name matchtes the name of an Entry.
+                * 
+                * @param fileTreePathRootNode
+                *            The root node of the tree to walk
+                * @param entries
+                *            The list of entries
+                */
+               private void addEntries(Node<FileTreePath> fileTreePathRootNode, List<Entry> entries) {
+                       for (Entry entry: entries) {
+                               String completeEntryName = File.separatorChar + entry.getName();
+                               FileTreePath fileTreePath = getFileTreePath(fileTreePathRootNode, completeEntryName);
+                               if (fileTreePath != null) {
+                                       fileTreePath.setFileEntry(entry);
+                               }
+                       }
+               }
+
+               /**
+                * Find the {@link FileTreePath} below the given node that has the given
+                * file path.
+                * 
+                * @param fileTreePathNode
+                *            The node to start searching at
+                * @param filePath
+                *            The path to search
+                * @return The file tree path with the matching file path, or
+                *         <code>null</code> if these is no such file tree path
+                */
+               private FileTreePath getFileTreePath(Node<FileTreePath> fileTreePathNode, String filePath) {
+                       for (Node<FileTreePath> child: fileTreePathNode) {
+                               if (child.getElement().getFilePath().equals(filePath)) {
+                                       return child.getElement();
+                               }
+                               FileTreePath fileTreePath = getFileTreePath(child, filePath);
+                               if (fileTreePath != null) {
+                                       return fileTreePath;
+                               }
+                       }
+                       return null;
                }
 
                /**
@@ -322,16 +573,45 @@ public class FileManager extends JDialog implements I18nable {
 
        }
 
+       /**
+        * Container that is used to back the {@link FileTreeModel}. Each
+        * FileTreePath contains a complete path name, a filename, and the
+        * associated {@link Entry}, if any.
+        * 
+        * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
+        */
        private static class FileTreePath implements Comparable<FileTreePath> {
 
+               /** The complete file path. */
                private final String filePath;
+
+               /** The file name. */
                private final String fileName;
+
+               /** The file entry, if any. */
                private Entry fileEntry;
 
+               /**
+                * Creates a new file tree path with an auto-detected file name. The
+                * file name is everything after the last separator in the complete
+                * path, or the complete path itself if it does not contain any
+                * separators.
+                * 
+                * @param filePath
+                *            The complete file path
+                */
                public FileTreePath(String filePath) {
                        this(filePath, null);
                }
 
+               /**
+                * Creates a new file tree path with the given file path and file name.
+                * 
+                * @param filePath
+                *            The complete file path
+                * @param fileName
+                *            The file name
+                */
                public FileTreePath(String filePath, String fileName) {
                        this.filePath = filePath;
                        if (fileName == null) {
@@ -415,7 +695,7 @@ public class FileManager extends JDialog implements I18nable {
                //
                // INTERFACE Comparable
                //
-               
+
                /**
                 * {@inheritDoc}
                 */