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