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