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