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

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