src/net/pterodactylus/jsite/gui/FileManager.java

   1 /*
   2  * jSite2 - FileManager.java -
   3  * Copyright © 2008 David Roden
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 package net.pterodactylus.jsite.gui;
  21
  22 import java.awt.BorderLayout;
  23 import java.awt.Color;
  24 import java.awt.Component;
  25 import java.awt.Dimension;
  26 import java.awt.FlowLayout;
  27 import java.awt.Font;
  28 import java.awt.GridBagConstraints;
  29 import java.awt.GridBagLayout;
  30 import java.awt.Insets;
  31 import java.awt.Point;
  32 import java.awt.event.ActionEvent;
  33 import java.awt.event.ActionListener;
  34 import java.awt.event.MouseEvent;
  35 import java.awt.event.MouseListener;
  36 import java.beans.PropertyChangeEvent;
  37 import java.beans.PropertyChangeListener;
  38 import java.io.File;
  39 import java.util.ArrayList;
  40 import java.util.Collections;
  41 import java.util.HashMap;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.logging.Level;
  45 import java.util.logging.Logger;
  46
  47 import javax.swing.BorderFactory;
  48 import javax.swing.JButton;
  49 import javax.swing.JCheckBox;
  50 import javax.swing.JComboBox;
  51 import javax.swing.JDialog;
  52 import javax.swing.JLabel;
  53 import javax.swing.JOptionPane;
  54 import javax.swing.JPanel;
  55 import javax.swing.JPopupMenu;
  56 import javax.swing.JScrollPane;
  57 import javax.swing.JTextField;
  58 import javax.swing.JTree;
  59 import javax.swing.event.TreeModelEvent;
  60 import javax.swing.event.TreeModelListener;
  61 import javax.swing.event.TreeSelectionEvent;
  62 import javax.swing.event.TreeSelectionListener;
  63 import javax.swing.tree.DefaultTreeCellRenderer;
  64 import javax.swing.tree.TreeModel;
  65 import javax.swing.tree.TreePath;
  66
  67 import net.pterodactylus.jsite.i18n.I18n;
  68 import net.pterodactylus.jsite.i18n.I18nable;
  69 import net.pterodactylus.jsite.i18n.gui.I18nAction;
  70 import net.pterodactylus.jsite.i18n.gui.I18nLabel;
  71 import net.pterodactylus.jsite.i18n.gui.I18nMenu;
  72 import net.pterodactylus.jsite.project.FileOverride;
  73 import net.pterodactylus.jsite.project.Project;
  74 import net.pterodactylus.jsite.project.ProjectFile;
  75 import net.pterodactylus.util.io.MimeTypes;
  76 import net.pterodactylus.util.logging.Logging;
  77 import net.pterodactylus.util.swing.SwingUtils;
  78
  79 /**
  80  * Manages physical and virtual files in a project.
  81  *
  82  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  83  */
  84 public class FileManager extends JDialog implements I18nable, ActionListener, TreeSelectionListener, MouseListener {
  85
  86         /** Logger. */
  87         private static final Logger logger = Logging.getLogger(FileManager.class.getName());
  88
  89         /** The Swing interface. */
  90         private final SwingInterface swingInterface;
  91
  92         /** The project whose files to manage. */
  93         private final Project project;
  94
  95         /** The tree model for the project files. */
  96         private final ProjectFileTreeModel fileTreeModel;
  97
  98         /** The tree cell renderer. */
  99         private final FileCellRenderer fileCellRenderer;
 100
 101         /** The “rescan” action. */
 102         private I18nAction rescanAction;
 103
 104         /** The “close” action. */
 105         private I18nAction closeAction;
 106
 107         /** The “set default file” action. */
 108         private I18nAction setDefaultFileAction;
 109
 110         /** The “insert” action. */
 111         private I18nAction insertAction;
 112
 113         /** The “project files” label. */
 114         private I18nLabel projectFilesLabel;
 115
 116         /** The tree that shows the files. */
 117         private JTree fileTree;
 118
 119         /** The scroll pane that holds the file tree. */
 120         private JScrollPane fileScrollPane;
 121
 122         /** The “file properties” label. */
 123         private I18nLabel filePropertiesLabel;
 124
 125         /** The “file path” label. */
 126         private I18nLabel filePathLabel;
 127
 128         /** The “file path” textfield. */
 129         private JTextField filePathTextField;
 130
 131         /** The “file name” label. */
 132         private I18nLabel fileNameLabel;
 133
 134         /** The “file name” textfield. */
 135         private JTextField fileNameTextField;
 136
 137         /** The “file size” label. */
 138         private I18nLabel fileSizeLabel;
 139
 140         /** The “file size” text field. */
 141         private JTextField fileSizeTextField;
 142
 143         /** The “override” label. */
 144         private I18nLabel overrideLabel;
 145
 146         /** The “override active” action. */
 147         private I18nAction overrideAction;
 148
 149         /** The “override action” checkbox. */
 150         private JCheckBox overrideCheckBox;
 151
 152         /** The context menu for the tree. */
 153         private JPopupMenu treeContextMenu;
 154
 155         /** The “apply override” menu. */
 156         private I18nMenu overrideMenu;
 157
 158         /** The “apply insert override” action. */
 159         private I18nAction applyInsertOverrideAction;
 160
 161         /** The “apply mime type override” action. */
 162         private I18nAction applyMimeTypeOverrideAction;
 163
 164         /** The “remove override” action. */
 165         private I18nAction removeOverrideAction;
 166
 167         /**
 168          * Creates a new file manager.
 169          *
 170          * @param swingInterface
 171          *            The Swing interface
 172          * @param project
 173          *            The project whose files to manage
 174          */
 175         public FileManager(SwingInterface swingInterface, Project project) {
 176                 super(swingInterface.getMainWindow(), I18n.get("fileManager.title", project.getName()), true);
 177                 logger.log(Level.FINEST, "project: " + project);
 178                 this.swingInterface = swingInterface;
 179                 this.project = project;
 180                 fileTreeModel = new ProjectFileTreeModel();
 181                 project.addPropertyChangeListener(fileTreeModel);
 182                 fileCellRenderer = new FileCellRenderer();
 183                 initActions();
 184                 initComponents();
 185                 pack();
 186                 SwingUtils.center(this);
 187         }
 188
 189         //
 190         // ACTIONS
 191         //
 192
 193         /**
 194          * @see java.awt.Component#setVisible(boolean)
 195          */
 196         @Override
 197         public void setVisible(boolean visible) {
 198                 if (visible) {
 199                         initiateFileScan();
 200                 }
 201                 super.setVisible(visible);
 202         }
 203
 204         //
 205         // PRIVATE METHODS
 206         //
 207
 208         /**
 209          * Initializes all actions.
 210          */
 211         private void initActions() {
 212                 closeAction = new I18nAction("fileManager.button.close") {
 213
 214                         /**
 215                          * {@inheritDoc}
 216                          */
 217                         @SuppressWarnings("synthetic-access")
 218                         public void actionPerformed(ActionEvent e) {
 219                                 String defaultFile = project.getDefaultFile();
 220                                 if ((defaultFile == null) || (defaultFile.length() == 0)) {
 221                                         /* TODO - i18n */
 222                                         JOptionPane.showMessageDialog(FileManager.this, I18n.get(""), I18n.get(""), JOptionPane.ERROR_MESSAGE);
 223                                         return;
 224                                 }
 225                                 ProjectFile projectFile = project.getFile(defaultFile);
 226                                 if (projectFile == null) {
 227                                         JOptionPane.showMessageDialog(FileManager.this, I18n.get(""), I18n.get(""), JOptionPane.ERROR_MESSAGE);
 228                                         return;
 229                                 }
 230                                 setVisible(false);
 231                         }
 232                 };
 233                 rescanAction = new I18nAction("fileManager.button.rescan") {
 234
 235                         /**
 236                          * {@inheritDoc}
 237                          */
 238                         @SuppressWarnings("synthetic-access")
 239                         public void actionPerformed(ActionEvent actionEvent) {
 240                                 initiateFileScan();
 241                         }
 242                 };
 243                 setDefaultFileAction = new I18nAction("fileManager.menu.item.setDefaultFile") {
 244
 245                         /**
 246                          * {@inheritDoc}
 247                          */
 248                         @SuppressWarnings("synthetic-access")
 249                         public void actionPerformed(ActionEvent actionEvent) {
 250                                 TreePath selectedPath = fileTree.getSelectionPath();
 251                                 if (selectedPath == null) {
 252                                         logger.log(Level.WARNING, "nothing selected!");
 253                                         return;
 254                                 }
 255                                 ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) selectedPath.getLastPathComponent();
 256                                 if (isHidden(projectFileWrapper)) {
 257                                         /* TODO - i18n */
 258                                         JOptionPane.showMessageDialog(FileManager.this, I18n.get(""), I18n.get(""), JOptionPane.ERROR_MESSAGE);
 259                                         return;
 260                                 }
 261                                 if (projectFileWrapper.getProjectFile().isDirectory()) {
 262                                         /* TODO - i18n */
 263                                         JOptionPane.showMessageDialog(FileManager.this, I18n.get(""), I18n.get(""), JOptionPane.ERROR_MESSAGE);
 264                                         return;
 265                                 }
 266                                 String completePath = projectFileWrapper.getProjectFile().getCompletePath();
 267                                 project.setDefaultFile(completePath);
 268                         }
 269                 };
 270                 insertAction = new I18nAction("fileManager.menu.item.insert") {
 271
 272                         /**
 273                          * {@inheritDoc}
 274                          */
 275                         public void actionPerformed(ActionEvent e) {
 276                                 /* TODO */
 277                         }
 278                 };
 279                 overrideAction = new I18nAction("fileManager.checkbox.overrideActive") {
 280
 281                         /**
 282                          * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
 283                          */
 284                         public void actionPerformed(ActionEvent actionEvent) {
 285                                 /* TODO */
 286                         }
 287                 };
 288                 applyInsertOverrideAction = new I18nAction("fileManager.menu.item.applyInsertOverride") {
 289
 290                         /**
 291                          * {@inheritDoc}
 292                          */
 293                         @SuppressWarnings("synthetic-access")
 294                         public void actionPerformed(ActionEvent actionEvent) {
 295                                 applyInsertOverride();
 296                         }
 297                 };
 298                 applyMimeTypeOverrideAction = new I18nAction("fileManager.menu.item.applyMimeTypeOverride") {
 299
 300                         /**
 301                          * {@inheritDoc}
 302                          */
 303                         @SuppressWarnings("synthetic-access")
 304                         public void actionPerformed(ActionEvent actionEvent) {
 305                                 applyMimeTypeOverride();
 306                         }
 307                 };
 308                 removeOverrideAction = new I18nAction("fileManager.menu.item.removeOverride") {
 309
 310                         /**
 311                          * {@inheritDoc}
 312                          */
 313                         @SuppressWarnings("synthetic-access")
 314                         public void actionPerformed(ActionEvent actionEvent) {
 315                                 removeOverride();
 316                         }
 317                 };
 318         }
 319
 320         /**
 321          * Initializes all components.
 322          */
 323         private void initComponents() {
 324                 treeContextMenu = new JPopupMenu();
 325                 treeContextMenu.add(setDefaultFileAction);
 326
 327                 overrideMenu = new I18nMenu("fileManager.menu.override");
 328                 treeContextMenu.add(overrideMenu);
 329
 330                 overrideMenu.add(applyInsertOverrideAction);
 331                 overrideMenu.add(applyMimeTypeOverrideAction);
 332                 overrideMenu.addSeparator();
 333                 overrideMenu.add(removeOverrideAction);
 334
 335                 JPanel contentPanel = new JPanel(new BorderLayout(12, 12));
 336                 contentPanel.setBorder(BorderFactory.createEmptyBorder(12, 12, 12, 12));
 337
 338                 contentPanel.add(createFileManagerPanel(), BorderLayout.CENTER);
 339                 contentPanel.add(createButtonPanel(), BorderLayout.PAGE_END);
 340
 341                 setContentPane(contentPanel);
 342         }
 343
 344         /**
 345          * Creates the main panel with the file tree and the file properties.
 346          *
 347          * @return The mail panel
 348          */
 349         private Component createFileManagerPanel() {
 350                 JPanel fileManagerPanel = new JPanel(new BorderLayout(12, 12));
 351
 352                 /* file tree panel */
 353                 JPanel fileTreePanel = new JPanel(new BorderLayout(12, 12));
 354                 fileManagerPanel.add(fileTreePanel, BorderLayout.LINE_START);
 355
 356                 fileTree = new JTree(fileTreeModel);
 357                 fileTree.setShowsRootHandles(false);
 358                 fileTree.addTreeSelectionListener(this);
 359                 fileTree.addMouseListener(this);
 360                 fileTree.setCellRenderer(fileCellRenderer);
 361                 fileTreePanel.add(fileScrollPane = new JScrollPane(fileTree), BorderLayout.CENTER);
 362                 fileScrollPane.setPreferredSize(new Dimension(200, 350));
 363
 364                 projectFilesLabel = new I18nLabel("fileManager.label.projectFiles", fileTree);
 365                 JPanel projectFilesLabelPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 0, 0));
 366                 fileTreePanel.add(projectFilesLabelPanel, BorderLayout.NORTH);
 367                 projectFilesLabelPanel.add(projectFilesLabel);
 368
 369                 /* the right panel */
 370                 JPanel rightPanel = new JPanel(new BorderLayout(12, 12));
 371                 fileManagerPanel.add(rightPanel, BorderLayout.CENTER);
 372
 373                 /* properties panel */
 374                 JPanel propertiesPanel = new JPanel(new GridBagLayout());
 375                 rightPanel.add(propertiesPanel, BorderLayout.CENTER);
 376                 propertiesPanel.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEtchedBorder(), BorderFactory.createEmptyBorder(12, 12, 12, 12)));
 377                 propertiesPanel.setPreferredSize(new Dimension(400, 350));
 378
 379                 filePropertiesLabel = new I18nLabel("fileManager.label.fileProperties");
 380                 filePropertiesLabel.setFont(filePropertiesLabel.getFont().deriveFont(Font.BOLD));
 381                 propertiesPanel.add(filePropertiesLabel, new GridBagConstraints(0, 0, 2, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
 382
 383                 filePathLabel = new I18nLabel("fileManager.label.filePath");
 384                 filePathTextField = new JTextField();
 385                 filePathTextField.setEditable(false);
 386                 propertiesPanel.add(filePathLabel, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 24, 0, 0), 0, 0));
 387                 propertiesPanel.add(filePathTextField, new GridBagConstraints(1, 1, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 12, 0, 0), 0, 0));
 388
 389                 fileNameLabel = new I18nLabel("fileManager.label.fileName");
 390                 fileNameTextField = new JTextField();
 391                 fileNameTextField.setEditable(false);
 392                 propertiesPanel.add(fileNameLabel, new GridBagConstraints(0, 2, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 24, 0, 0), 0, 0));
 393                 propertiesPanel.add(fileNameTextField, new GridBagConstraints(1, 2, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 12, 0, 0), 0, 0));
 394
 395                 fileSizeLabel = new I18nLabel("fileManager.label.fileSize");
 396                 fileSizeTextField = new JTextField();
 397                 fileSizeTextField.setEditable(false);
 398                 propertiesPanel.add(fileSizeLabel, new GridBagConstraints(0, 3, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 24, 0, 0), 0, 0));
 399                 propertiesPanel.add(fileSizeTextField, new GridBagConstraints(1, 3, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 12, 0, 0), 0, 0));
 400
 401                 /* override settings. */
 402                 overrideLabel = new I18nLabel("fileManager.label.override");
 403                 overrideLabel.setFont(overrideLabel.getFont().deriveFont(Font.BOLD));
 404                 propertiesPanel.add(overrideLabel, new GridBagConstraints(0, 4, 2, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(24, 0, 0, 0), 0, 0));
 405
 406                 overrideCheckBox = new JCheckBox(overrideAction);
 407                 propertiesPanel.add(overrideCheckBox, new GridBagConstraints(0, 5, 2, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(12, 24, 0, 0), 0, 0));
 408
 409                 /* glue panel. */
 410                 propertiesPanel.add(new JPanel(), new GridBagConstraints(0, 6, 2, 1, 1.0, 1.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
 411
 412                 /* action button panel */
 413                 JPanel actionButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 12, 12));
 414                 rightPanel.add(actionButtonPanel, BorderLayout.PAGE_END);
 415                 actionButtonPanel.setBorder(BorderFactory.createEtchedBorder());
 416
 417                 JButton rescanButton = new JButton(rescanAction);
 418                 actionButtonPanel.add(rescanButton);
 419
 420                 return fileManagerPanel;
 421         }
 422
 423         /**
 424          * Creates the button panel.
 425          *
 426          * @return The button panel
 427          */
 428         private Component createButtonPanel() {
 429                 JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING, 12, 12));
 430
 431                 buttonPanel.setBorder(BorderFactory.createEmptyBorder(-12, -12, -12, -12));
 432                 JButton closeButton = new JButton(closeAction);
 433                 buttonPanel.add(closeButton);
 434
 435                 getRootPane().setDefaultButton(closeButton);
 436                 return buttonPanel;
 437         }
 438
 439         /**
 440          * Initiates a file scan.
 441          */
 442         private void initiateFileScan() {
 443                 swingInterface.getThreadPool().execute(new Runnable() {
 444
 445                         /**
 446                          * @see java.lang.Runnable#run()
 447                          */
 448                         @SuppressWarnings("synthetic-access")
 449                         public void run() {
 450                                 fileTree.setEnabled(false);
 451                                 rescanAction.setEnabled(false);
 452                                 ProjectFile baseProjectFile = project.getBaseFile();
 453                                 if (baseProjectFile != null) {
 454                                         fileTreeModel.setBaseProjectFile(baseProjectFile);
 455                                 }
 456                                 // fileScrollPane.revalidate();
 457                                 rescanAction.setEnabled(true);
 458                                 fileTree.setEnabled(true);
 459                         }
 460
 461                 });
 462         }
 463
 464         /**
 465          * Checks whether the given mouse event is a popup trigger and occured over
 466          * a file. If so, the context menu is shown.
 467          *
 468          * @param mouseEvent
 469          *            The mouse event to check
 470          */
 471         private void maybeShowContextMenu(MouseEvent mouseEvent) {
 472                 if (!mouseEvent.isPopupTrigger()) {
 473                         return;
 474                 }
 475                 Point eventLocation = mouseEvent.getPoint();
 476                 TreePath[] selectedPaths = fileTree.getSelectionPaths();
 477                 if ((selectedPaths == null) || (selectedPaths.length == 0)) {
 478                         /* try to find item under click. */
 479                         TreePath clickedPath = fileTree.getPathForLocation(mouseEvent.getX(), mouseEvent.getY());
 480                         if (clickedPath != null) {
 481                                 fileTree.setSelectionPath(clickedPath);
 482                                 selectedPaths = new TreePath[] { clickedPath };
 483                         } else {
 484                                 logger.log(Level.FINER, "nothing selected for context menu");
 485                                 return;
 486                         }
 487                 }
 488                 if (selectedPaths.length == 1) {
 489                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) selectedPaths[0].getLastPathComponent();
 490                         ProjectFile projectFile = projectFileWrapper.getProjectFile();
 491                         setDefaultFileAction.setEnabled(!isHidden(projectFileWrapper) && projectFile.isFile() && !projectFile.getCompletePath().equals(project.getDefaultFile()));
 492                 } else {
 493                         setDefaultFileAction.setEnabled(false);
 494                 }
 495                 treeContextMenu.show(fileTree, eventLocation.x, eventLocation.y);
 496         }
 497
 498         /**
 499          * Finds whether the {@link ProjectFile} given by
 500          * <code>projectFileWrapper</code> is hidden.
 501          *
 502          * @param projectFileWrapper
 503          *            The wrapped project file
 504          * @return <code>true</code> if the file is hidden and should not be
 505          *         inserted, <code>false</code> otherwise
 506          */
 507         private boolean isHidden(ProjectFileWrapper projectFileWrapper) {
 508                 ProjectFile projectFile = projectFileWrapper.getProjectFile();
 509                 FileOverride fileOverride = project.getFileOverrides().get(projectFile.getCompletePath());
 510                 logger.log(Level.FINEST, "fileOverride: " + fileOverride);
 511                 return ((fileOverride == null) && projectFile.isHidden()) || ((fileOverride != null) && (Boolean.TRUE.equals(fileOverride.isInsert())));
 512         }
 513
 514         /**
 515          * Opens the “apply insert override” dialog and lets the user apply an
 516          * override for the “insert” setting for multiple files.
 517          */
 518         private void applyInsertOverride() {
 519                 JCheckBox insertCheckBox = new JCheckBox(I18n.get("fileManager.checkbox.insertFile.name"));
 520                 String okString = I18n.get("general.button.okay.name");
 521                 String cancelString = I18n.get("general.button.cancel.name");
 522                 int choice = JOptionPane.showOptionDialog(this, new Object[] { I18n.get("fileManager.dialog.insertOverride.message"), insertCheckBox }, I18n.get("fileManager.dialog.insertOverride.title"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[] { okString, cancelString }, okString);
 523                 logger.log(Level.FINEST, "choice: " + choice);
 524                 if ((choice == JOptionPane.CLOSED_OPTION) || (choice == 1)) {
 525                         return;
 526                 }
 527                 logger.log(Level.INFO, "selected insert override: " + insertCheckBox.isSelected());
 528                 List<ProjectFileWrapper> selectedProjectFileWrappers = getSelectedProjectFileWrappers(true);
 529                 for (ProjectFileWrapper selectedProjectFileWrapper : selectedProjectFileWrappers) {
 530                         ProjectFile projectFile = selectedProjectFileWrapper.getProjectFile();
 531                         FileOverride fileOverride = project.getFileOverride(projectFile);
 532                         if (fileOverride == null) {
 533                                 fileOverride = new FileOverride();
 534                                 project.addFileOverride(projectFile, fileOverride);
 535                         }
 536                         fileOverride.setInsert(insertCheckBox.isSelected());
 537                 }
 538         }
 539
 540         /**
 541          * Opens the “apply mime type override” dialog and lets the user apply an
 542          * override for the “mime type” setting for multiple files.
 543          */
 544         private void applyMimeTypeOverride() {
 545                 List<String> allMimeTypes = MimeTypes.getAllMimeTypes();
 546                 allMimeTypes.add(0, null);
 547                 JComboBox mimeTypeComboBox = new JComboBox(allMimeTypes.toArray());
 548                 String okString = I18n.get("general.button.okay.name");
 549                 String cancelString = I18n.get("general.button.cancel.name");
 550                 int choice = JOptionPane.showOptionDialog(this, new Object[] { I18n.get("fileManager.dialog.mimeTypeOverride.message"), mimeTypeComboBox }, I18n.get("fileManager.dialog.mimeTypeOverride.title"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[] { okString, cancelString }, okString);
 551                 if ((choice == JOptionPane.CLOSED_OPTION) || (choice == 1)) {
 552                         return;
 553                 }
 554                 logger.log(Level.FINE, "selected mime type: " + mimeTypeComboBox.getSelectedItem());
 555                 List<ProjectFileWrapper> selectedProjectFileWrappers = getSelectedProjectFileWrappers(true);
 556                 for (ProjectFileWrapper selectedProjectFileWrapper : selectedProjectFileWrappers) {
 557                         ProjectFile projectFile = selectedProjectFileWrapper.getProjectFile();
 558                         FileOverride fileOverride = project.getFileOverride(projectFile);
 559                         if (fileOverride == null) {
 560                                 fileOverride = new FileOverride();
 561                                 project.addFileOverride(projectFile, fileOverride);
 562                         }
 563                         fileOverride.setContentType((String) mimeTypeComboBox.getSelectedItem());
 564                 }
 565         }
 566
 567         /**
 568          * Removes the overrides of all selected files.
 569          */
 570         private void removeOverride() {
 571                 String continueString = I18n.get("general.button.continue.name");
 572                 String cancelString = I18n.get("general.button.cancel.name");
 573                 List<ProjectFileWrapper> selectedProjectFileWrappers = getSelectedProjectFileWrappers(true);
 574                 int choice = JOptionPane.showOptionDialog(this, I18n.get("fileManager.dialog.removeOverride.message", selectedProjectFileWrappers.size()), I18n.get("fileManager.dialog.removeOverride.title"), JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE, null, new Object[] { continueString, cancelString }, continueString);
 575                 if ((choice == JOptionPane.CLOSED_OPTION) || (choice == 1)) {
 576                         return;
 577                 }
 578                 for (ProjectFileWrapper selectedProjectFileWrapper : selectedProjectFileWrappers) {
 579                         project.removeFileOverride(selectedProjectFileWrapper.getProjectFile());
 580                 }
 581         }
 582
 583         /**
 584          * Returns all currently selected {@link ProjectFileWrapper}s.
 585          *
 586          * @param filesOnly
 587          *            <code>true</code> to return only selected files,
 588          *            <code>false</code> to include directories
 589          * @return All selected project file wrappers
 590          */
 591         private List<ProjectFileWrapper> getSelectedProjectFileWrappers(boolean filesOnly) {
 592                 List<ProjectFileWrapper> selectedProjectFileWrappers = new ArrayList<ProjectFileWrapper>();
 593                 TreePath[] selectedPaths = fileTree.getSelectionPaths();
 594                 if (selectedPaths != null) {
 595                         for (TreePath selectedPath : selectedPaths) {
 596                                 ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) selectedPath.getLastPathComponent();
 597                                 if (filesOnly && !projectFileWrapper.getProjectFile().isFile()) {
 598                                         continue;
 599                                 }
 600                                 selectedProjectFileWrappers.add(projectFileWrapper);
 601                         }
 602                 }
 603                 return selectedProjectFileWrappers;
 604         }
 605
 606         //
 607         // INTERFACE I18nable
 608         //
 609
 610         /**
 611          * {@inheritDoc}
 612          */
 613         public void updateI18n() {
 614                 setTitle(I18n.get("fileManager.title", project.getName()));
 615                 projectFilesLabel.updateI18n();
 616                 filePropertiesLabel.updateI18n();
 617                 filePathLabel.updateI18n();
 618         }
 619
 620         //
 621         // INTERFACE TreeSelectionListener
 622         //
 623
 624         /**
 625          * {@inheritDoc}
 626          */
 627         public void valueChanged(TreeSelectionEvent treeSelectionEvent) {
 628                 TreePath[] selectedPaths = fileTree.getSelectionPaths();
 629                 filePathTextField.setText("");
 630                 fileNameTextField.setText("");
 631                 fileSizeTextField.setText("");
 632                 overrideAction.setEnabled(false);
 633                 if ((selectedPaths != null) && (selectedPaths.length == 1)) {
 634                         Object lastPathComponent = selectedPaths[0].getLastPathComponent();
 635                         if (!(lastPathComponent instanceof ProjectFileWrapper)) {
 636                                 logger.log(Level.SEVERE, "lastPathComponent is not a ProjectFileWrapper!");
 637                                 return;
 638                         }
 639                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) lastPathComponent;
 640                         ProjectFile projectFile = projectFileWrapper.getProjectFile();
 641                         if (projectFile.isFile()) {
 642                                 String completePath = projectFile.getCompletePath();
 643                                 int lastSeparator = completePath.lastIndexOf(File.separatorChar);
 644                                 if (lastSeparator == -1) {
 645                                         filePathTextField.setText("");
 646                                 } else {
 647                                         filePathTextField.setText(completePath.substring(0, lastSeparator));
 648                                 }
 649                                 fileNameTextField.setText(projectFile.getName());
 650                                 fileSizeTextField.setText(String.valueOf(projectFile.getSize()));
 651                         }
 652                         overrideAction.setEnabled(true);
 653                 } else if ((selectedPaths != null) && (selectedPaths.length > 1)) {
 654                 }
 655         }
 656
 657         //
 658         // INTERFACE ActionListener
 659         //
 660
 661         /**
 662          * {@inheritDoc}
 663          */
 664         public void actionPerformed(ActionEvent actionEvent) {
 665                 /* TODO */
 666         }
 667
 668         //
 669         // INTERFACE MouseListener
 670         //
 671
 672         /**
 673          * {@inheritDoc}
 674          */
 675         public void mouseClicked(MouseEvent mouseEvent) {
 676                 maybeShowContextMenu(mouseEvent);
 677         }
 678
 679         /**
 680          * {@inheritDoc}
 681          */
 682         public void mouseEntered(MouseEvent mouseEvent) {
 683                 /* ignore. */
 684         }
 685
 686         /**
 687          * {@inheritDoc}
 688          */
 689         public void mouseExited(MouseEvent mouseEvent) {
 690                 /* ignore. */
 691         }
 692
 693         /**
 694          * {@inheritDoc}
 695          */
 696         public void mousePressed(MouseEvent mouseEvent) {
 697                 maybeShowContextMenu(mouseEvent);
 698         }
 699
 700         /**
 701          * {@inheritDoc}
 702          */
 703         public void mouseReleased(MouseEvent mouseEvent) {
 704                 maybeShowContextMenu(mouseEvent);
 705         }
 706
 707         /**
 708          * Tree cell renderer that takes care of certain display properties for
 709          * project-specific stuff.
 710          *
 711          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 712          */
 713         private class FileCellRenderer extends DefaultTreeCellRenderer {
 714
 715                 /**
 716                  * Empty constructor.
 717                  */
 718                 FileCellRenderer() {
 719                         /* do nothing. */
 720                 }
 721
 722                 /**
 723                  * @see javax.swing.tree.TreeCellRenderer#getTreeCellRendererComponent(javax.swing.JTree,
 724                  *      java.lang.Object, boolean, boolean, boolean, int, boolean)
 725                  */
 726                 @SuppressWarnings("synthetic-access")
 727                 @Override
 728                 public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
 729                         Component superCellRenderer = super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
 730                         if (!(superCellRenderer instanceof JLabel)) {
 731                                 logger.log(Level.SEVERE, "superCellRenderer is not a JLabel!");
 732                                 return superCellRenderer;
 733                         }
 734                         if (!(value instanceof ProjectFileWrapper)) {
 735                                 logger.log(Level.SEVERE, "value is not a ProjectFileWrapper!");
 736                                 return superCellRenderer;
 737                         }
 738                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) value;
 739                         ProjectFile projectFile = projectFileWrapper.getProjectFile();
 740                         String completePath = projectFile.getCompletePath();
 741                         boolean paintBold = false;
 742                         boolean paintHalfColor = false;
 743                         if (projectFile.isFile() && projectFile.isHidden()) {
 744                                 /* TODO - check override */
 745                                 paintHalfColor = true;
 746                         } else if (completePath.equals(project.getDefaultFile())) {
 747                                 paintBold = true;
 748                         } else if (projectFile.getParents().size() == 1) {
 749                                 paintBold = true;
 750                         }
 751                         if (paintHalfColor) {
 752                                 /* TODO - cache colors */
 753                                 Color foreground = superCellRenderer.getForeground();
 754                                 Color background = selected ? getBackgroundSelectionColor() : getBackgroundNonSelectionColor();
 755                                 Color averageColor = new Color((foreground.getRed() + background.getRed()) / 2, (foreground.getGreen() + background.getGreen()) / 2, (foreground.getBlue() + background.getBlue()) / 2);
 756                                 superCellRenderer.setForeground(averageColor);
 757                         } else {
 758                                 superCellRenderer.setForeground(selected ? getTextSelectionColor() : getTextNonSelectionColor());
 759                         }
 760                         if (paintBold) {
 761                                 superCellRenderer.setFont(superCellRenderer.getFont().deriveFont(Font.BOLD));
 762                         } else {
 763                                 superCellRenderer.setFont(superCellRenderer.getFont().deriveFont(Font.PLAIN));
 764                         }
 765                         return superCellRenderer;
 766                 }
 767
 768         }
 769
 770         /**
 771          * TreeModel that is based on {@link Project#getBaseFile()}.
 772          *
 773          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 774          */
 775         private class ProjectFileTreeModel implements TreeModel, PropertyChangeListener {
 776
 777                 /** Tree model listeners. */
 778                 private final List<TreeModelListener> treeModelListeners = Collections.synchronizedList(new ArrayList<TreeModelListener>());
 779
 780                 /** The base project file. */
 781                 private ProjectFile baseProjectFile;
 782
 783                 /** Maps path names to project files. */
 784                 private final Map<String, ProjectFile> pathProjectFiles = Collections.synchronizedMap(new HashMap<String, ProjectFile>());
 785
 786                 /** Maps project files to wrappers. */
 787                 private final Map<ProjectFile, ProjectFileWrapper> projectFileWrappers = Collections.synchronizedMap(new HashMap<ProjectFile, ProjectFileWrapper>());
 788
 789                 /**
 790                  * Empty constructor.
 791                  */
 792                 ProjectFileTreeModel() {
 793                         /* do nothing. */
 794                 }
 795
 796                 //
 797                 // EVENT MANAGEMENT
 798                 //
 799
 800                 /**
 801                  * {@inheritDoc}
 802                  */
 803                 public void addTreeModelListener(TreeModelListener treeModelListener) {
 804                         treeModelListeners.add(treeModelListener);
 805                 }
 806
 807                 /**
 808                  * {@inheritDoc}
 809                  */
 810                 public void removeTreeModelListener(TreeModelListener treeModelListener) {
 811                         treeModelListeners.remove(treeModelListener);
 812                 }
 813
 814                 /**
 815                  * Notifies all listeners that a node has changed.
 816                  *
 817                  * @param changedProjectFileWrapper
 818                  *            The wrapper around the changed project file
 819                  */
 820                 protected void fireTreeNodesChanged(ProjectFileWrapper changedProjectFileWrapper) {
 821                         ProjectFile changedProjectFile = changedProjectFileWrapper.getProjectFile();
 822                         ProjectFile changedProjectFileParent = changedProjectFile.getParent();
 823                         ProjectFile currentProjectFileParent = changedProjectFile;
 824                         List<ProjectFileWrapper> parentProjectFileWrappers = new ArrayList<ProjectFileWrapper>();
 825                         do {
 826                                 parentProjectFileWrappers.add(0, projectFileWrappers.get(currentProjectFileParent));
 827                                 currentProjectFileParent = currentProjectFileParent.getParent();
 828                         } while (currentProjectFileParent != null);
 829                         TreeModelEvent treeModelEvent = new TreeModelEvent(this, parentProjectFileWrappers.toArray(), new int[] { getIndexOfChild(projectFileWrappers.get(changedProjectFileParent), changedProjectFileWrapper) }, new Object[] { changedProjectFileWrapper });
 830                         for (TreeModelListener treeModelListener : treeModelListeners) {
 831                                 treeModelListener.treeNodesChanged(treeModelEvent);
 832                         }
 833                 }
 834
 835                 /**
 836                  * Notifies all listeners that the tree structure has changed
 837                  * significantly.
 838                  *
 839                  * @see TreeModelListener#treeStructureChanged(TreeModelEvent)
 840                  * @param newRootNode
 841                  */
 842                 protected void fireTreeStructureChanged(ProjectFileWrapper newRootNode) {
 843                         for (TreeModelListener treeModelListener : treeModelListeners) {
 844                                 treeModelListener.treeStructureChanged(new TreeModelEvent(this, new Object[] { newRootNode }));
 845                         }
 846                 }
 847
 848                 //
 849                 // ACCESSORS
 850                 //
 851
 852                 /**
 853                  * Sets the new base project file. This causes the model to reload.
 854                  *
 855                  * @param baseProjectFile
 856                  *            The new base project file
 857                  */
 858                 @SuppressWarnings("synthetic-access")
 859                 public synchronized void setBaseProjectFile(ProjectFile baseProjectFile) {
 860                         this.baseProjectFile = baseProjectFile;
 861                         projectFileWrappers.clear();
 862                         pathProjectFiles.clear();
 863                         createWrappers(baseProjectFile);
 864                         projectFileWrappers.get(baseProjectFile).setNameOverride(project.getName());
 865                         fireTreeStructureChanged(projectFileWrappers.get(baseProjectFile));
 866                 }
 867
 868                 //
 869                 // PRIVATE METHODS
 870                 //
 871
 872                 /**
 873                  * Creates {@link ProjectFileWrapper}s for all files below the given
 874                  * project file.
 875                  *
 876                  * @param projectFile
 877                  *            The base project file for all project files to create
 878                  *            wrappers for
 879                  */
 880                 private void createWrappers(ProjectFile projectFile) {
 881                         projectFileWrappers.put(projectFile, new ProjectFileWrapper(projectFile));
 882                         pathProjectFiles.put(projectFile.getCompletePath(), projectFile);
 883                         for (ProjectFile projectFileChild : projectFile.getFiles()) {
 884                                 if (projectFileChild.isDirectory()) {
 885                                         createWrappers(projectFileChild);
 886                                 }
 887                                 projectFileWrappers.put(projectFileChild, new ProjectFileWrapper(projectFileChild));
 888                                 pathProjectFiles.put(projectFileChild.getCompletePath(), projectFileChild);
 889                         }
 890                 }
 891
 892                 //
 893                 // INTERFACE TreeModel
 894                 //
 895
 896                 /**
 897                  * {@inheritDoc}
 898                  */
 899                 public Object getRoot() {
 900                         return projectFileWrappers.get(baseProjectFile);
 901                 }
 902
 903                 /**
 904                  * {@inheritDoc}
 905                  */
 906                 @SuppressWarnings("synthetic-access")
 907                 public Object getChild(Object parent, int index) {
 908                         if (!(parent instanceof ProjectFileWrapper)) {
 909                                 logger.log(Level.SEVERE, "parent is not a ProjectFileWrapper!");
 910                                 return null;
 911                         }
 912                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) parent;
 913                         ProjectFile projectFile = projectFileWrapper.getProjectFile();
 914                         return projectFileWrappers.get(projectFile.getFiles().get(index));
 915                 }
 916
 917                 /**
 918                  * {@inheritDoc}
 919                  */
 920                 @SuppressWarnings("synthetic-access")
 921                 public int getChildCount(Object parent) {
 922                         if (!(parent instanceof ProjectFileWrapper)) {
 923                                 logger.log(Level.SEVERE, "parent is not a ProjectFileWrapper!");
 924                                 return -1;
 925                         }
 926                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) parent;
 927                         ProjectFile projectFile = projectFileWrapper.getProjectFile();
 928                         return projectFile.getFiles().size();
 929                 }
 930
 931                 /**
 932                  * {@inheritDoc}
 933                  */
 934                 @SuppressWarnings("synthetic-access")
 935                 public int getIndexOfChild(Object parent, Object child) {
 936                         if (!(parent instanceof ProjectFileWrapper)) {
 937                                 logger.log(Level.SEVERE, "parent is not a ProjectFileWrapper!");
 938                                 return -1;
 939                         }
 940                         if (!(child instanceof ProjectFileWrapper)) {
 941                                 logger.log(Level.SEVERE, "child is not a ProjectFileWrapper!");
 942                                 return -1;
 943                         }
 944                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) parent;
 945                         ProjectFile projectFile = projectFileWrapper.getProjectFile();
 946                         return projectFile.getFiles().indexOf(((ProjectFileWrapper) child).getProjectFile());
 947                 }
 948
 949                 /**
 950                  * {@inheritDoc}
 951                  */
 952                 @SuppressWarnings("synthetic-access")
 953                 public boolean isLeaf(Object node) {
 954                         if (!(node instanceof ProjectFileWrapper)) {
 955                                 logger.log(Level.SEVERE, "node is not a ProjectFileWrapper!");
 956                                 return true;
 957                         }
 958                         ProjectFileWrapper projectFileWrapper = (ProjectFileWrapper) node;
 959                         return projectFileWrapper.getProjectFile().isFile();
 960                 }
 961
 962                 /**
 963                  * {@inheritDoc}
 964                  */
 965                 public void valueForPathChanged(TreePath path, Object newValue) {
 966                         /* ignore, items will not be modified in tree. */
 967                 }
 968
 969                 //
 970                 // INTERFACE PropertyChangeListener
 971                 //
 972
 973                 /**
 974                  * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
 975                  */
 976                 @SuppressWarnings("synthetic-access")
 977                 public void propertyChange(PropertyChangeEvent propertyChangeEvent) {
 978                         if (Project.PROPERTY_DEFAULT_FILE.equals(propertyChangeEvent.getPropertyName())) {
 979                                 if (propertyChangeEvent.getOldValue() != null) {
 980                                         String oldCompletePath = (String) propertyChangeEvent.getOldValue();
 981                                         ProjectFile oldProjectFile = pathProjectFiles.get(oldCompletePath);
 982                                         ProjectFileWrapper oldProjectFileWrapper = projectFileWrappers.get(oldProjectFile);
 983                                         System.out.println("oldProjectFileWrapper: " + oldProjectFileWrapper);
 984                                         fireTreeNodesChanged(oldProjectFileWrapper);
 985                                 }
 986                                 String newCompletePath = (String) propertyChangeEvent.getNewValue();
 987                                 ProjectFile newProjectFile = pathProjectFiles.get(newCompletePath);
 988                                 ProjectFileWrapper newProjectFileWrapper = projectFileWrappers.get(newProjectFile);
 989                                 System.out.println("newProjectFileWrapper: " + newProjectFileWrapper);
 990                                 fireTreeNodesChanged(newProjectFileWrapper);
 991                                 /* HACK - swing sucks a bit. */
 992                                 fileTree.setShowsRootHandles(false);
 993                         }
 994                 }
 995
 996         }
 997
 998         /**
 999          * Wrapper around a {@link ProjectFile} that overwrites
1000          * {@link Object#toString()} to return the project file’s name.
1001          *
1002          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
1003          */
1004         private static class ProjectFileWrapper {
1005
1006                 /** The wrapped project file. */
1007                 private final ProjectFile projectFile;
1008
1009                 /** The override name. */
1010                 private String nameOverride;
1011
1012                 /**
1013                  * Creates a new wrapper around a project file.
1014                  *
1015                  * @param projectFile
1016                  *            The project file to wrap
1017                  */
1018                 public ProjectFileWrapper(ProjectFile projectFile) {
1019                         this.projectFile = projectFile;
1020                 }
1021
1022                 /**
1023                  * Returns the wrapped project file.
1024                  *
1025                  * @return The wrapped project file
1026                  */
1027                 public ProjectFile getProjectFile() {
1028                         return projectFile;
1029                 }
1030
1031                 /**
1032                  * Sets the name override. If the name override is not <code>null</code>
1033                  * it will be shown insted of the project file’s name.
1034                  *
1035                  * @param nameOverride
1036                  *            The name override
1037                  */
1038                 void setNameOverride(String nameOverride) {
1039                         this.nameOverride = nameOverride;
1040                 }
1041
1042                 /**
1043                  * {@inheritDoc}
1044                  */
1045                 @Override
1046                 public String toString() {
1047                         return (nameOverride != null) ? nameOverride : projectFile.getName();
1048                 }
1049
1050         }
1051
1052 }