1. /*

  2.  * @(#)GTKFileChooserUI.java	1.26 04/06/01

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.java.swing.plaf.gtk;

  8. 

  9. import java.awt.*;

  10. import java.awt.event.*;

  11. import java.beans.*;

  12. import java.io.File;

  13. import java.io.FileNotFoundException;

  14. import java.io.IOException;

  15. import java.text.MessageFormat;

  16. import java.util.*;

  17. 

  18. import javax.swing.plaf.synth.*;

  19. import javax.swing.*;

  20. import javax.swing.border.*;

  21. import javax.swing.filechooser.*;

  22. import javax.swing.event.*;

  23. import javax.swing.plaf.*;

  24. import javax.swing.plaf.basic.BasicDirectoryModel;

  25. import javax.swing.table.*;

  26. import sun.swing.plaf.synth.*;

  27. import sun.swing.FilePane;

  28. 

  29. /**

  30.  * GTK FileChooserUI.

  31.  *

  32.  * @version 1.36 08/21/02

  33.  * @author Leif Samuelsson

  34.  * @author Jeff Dinkins

  35.  */

  36. class GTKFileChooserUI extends SynthFileChooserUI {

  37. 

  38.     // The accessoryPanel is a container to place the JFileChooser accessory component

  39.     private JPanel accessoryPanel = null;

  40. 

  41.     private String newFolderButtonText = null;

  42.     private String newFolderErrorSeparator = null;

  43.     private String newFolderErrorText = null;

  44.     private String newFolderDialogText = null;

  45. 

  46.     private String deleteFileButtonText = null;

  47.     private String renameFileButtonText = null;

  48. 

  49.     private String newFolderButtonToolTipText = null;

  50.     private String deleteFileButtonToolTipText = null;

  51.     private String renameFileButtonToolTipText = null;

  52. 

  53.     private int newFolderButtonMnemonic = 0;

  54.     private int deleteFileButtonMnemonic = 0;

  55.     private int renameFileButtonMnemonic = 0;

  56. 

  57.     private String renameFileDialogText = null; 

  58.     private String renameFileErrorTitle = null;

  59.     private String renameFileErrorText = null; 

  60.  

  61.     private JComboBox filterComboBox;

  62.     private FilterComboBoxModel filterComboBoxModel;

  63. 

  64.     // From Motif

  65. 

  66.     private JPanel rightPanel;

  67.     private JList directoryList;

  68.     private JList fileList;

  69. 

  70.     private JLabel pathField;

  71.     private JTextField fileNameTextField;

  72. 

  73.     private static final Dimension hstrut3 = new Dimension(3, 1);

  74.     private static final Dimension vstrut10 = new Dimension(1, 10);

  75. 

  76.     private static final Insets insets = new Insets(10, 10, 10, 10);

  77. 

  78.     private static Dimension prefListSize = new Dimension(75, 150);

  79. 

  80.     private static Dimension PREF_SIZE = new Dimension(435, 360);

  81.     private static Dimension MIN_SIZE = new Dimension(200, 300);

  82. 

  83.     private static Dimension PREF_ACC_SIZE = new Dimension(10, 10);

  84.     private static Dimension ZERO_ACC_SIZE = new Dimension(1, 1);

  85. 

  86.     private static Dimension MAX_SIZE = new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);

  87. 

  88.     private static final Insets buttonMargin = new Insets(3, 3, 3, 3);

  89. 

  90.     private String filesLabelText = null;

  91.     private String foldersLabelText = null;

  92.     private String pathLabelText = null;

  93.     private String filterLabelText = null;

  94. 

  95.     private int pathLabelMnemonic = 0;

  96.     private int filterLabelMnemonic = 0;

  97. 

  98.     private JComboBox directoryComboBox;

  99.     private DirectoryComboBoxModel directoryComboBoxModel;

  100.     private Action directoryComboBoxAction = new DirectoryComboBoxAction();

  101.     private JPanel bottomButtonPanel;

  102.     private GTKDirectoryModel model = null;

  103.     private Action newFolderAction;

  104.     private JPanel interior;

  105.     private boolean readOnly;

  106.     private boolean showDirectoryIcons;

  107.     private boolean showFileIcons;

  108.     private GTKFileView fileView = new GTKFileView();

  109.     private PropertyChangeListener gtkFCPropertyChangeListener;

  110.     private Action approveSelectionAction = new GTKApproveSelectionAction();

  111.     private GTKDirectoryListModel directoryListModel;

  112. 

  113.     public GTKFileChooserUI(JFileChooser filechooser) {

  114.         super(filechooser);

  115.     }

  116. 

  117.     public String getFileName() {

  118.         JFileChooser fc = getFileChooser();

  119.         String typedInName = fileNameTextField != null ?

  120.             fileNameTextField.getText() : null;

  121.          

  122.         if (!fc.isMultiSelectionEnabled()) {

  123.             return typedInName; 

  124.         }

  125.          

  126.         int mode = fc.getFileSelectionMode();

  127.         JList list = mode == JFileChooser.DIRECTORIES_ONLY ?

  128.             directoryList : fileList;

  129.         Object[] files = list.getSelectedValues();

  130.         int len = files.length;

  131.         Vector result = new Vector(len + 1);

  132.          

  133.         // we return all selected file names

  134.         for (int i = 0; i < len; i++) {

  135.             File file = (File)files[i];

  136.             result.add(file.getName());

  137.         }

  138.         // plus the file name typed into the text field, if not already there

  139.         if (typedInName != null && !result.contains(typedInName)) {

  140.             result.add(typedInName);

  141.         }

  142.          

  143.         StringBuffer buf = new StringBuffer();

  144.         len = result.size();

  145.          

  146.         // construct the resulting string

  147.         for (int i=0; i<len; i++) {

  148.             if (len > 1) {

  149.                 buf.append(" \"");

  150.             }

  151.             buf.append(result.get(i));

  152.             if (len > 1) {

  153.                 buf.append("\"");

  154.             }

  155.         }

  156.         return buf.toString();

  157.     }

  158. 

  159.     public void setFileName(String fileName) {

  160. 	if (fileNameTextField != null) {

  161. 	    fileNameTextField.setText(fileName);

  162. 	}

  163.     }

  164. 

  165. //     public String getDirectoryName() {

  166. // 	return pathField.getText();

  167. //     }

  168. 

  169.     public void setDirectoryName(String dirname) {

  170. 	pathField.setText(dirname);

  171.     }

  172. 

  173.     public void ensureFileIsVisible(JFileChooser fc, File f) {

  174. 	// PENDING

  175.     }

  176. 

  177.     public void rescanCurrentDirectory(JFileChooser fc) {

  178. 	getModel().validateFileCache();

  179.     }

  180. 

  181.     public JPanel getAccessoryPanel() {

  182. 	return accessoryPanel;

  183.     }

  184. 

  185.     // ***********************

  186.     // * FileView operations *

  187.     // ***********************

  188. 

  189.     public FileView getFileView(JFileChooser fc) {

  190. 	return fileView;

  191.     }

  192. 

  193.     private class GTKFileView extends BasicFileView {

  194. 	public GTKFileView() {

  195. 	    iconCache = null;

  196. 	}

  197. 

  198. 	public void clearIconCache() {

  199. 	}

  200. 

  201. 	public Icon getCachedIcon(File f) {

  202. 	    return null;

  203. 	}

  204. 

  205. 	public void cacheIcon(File f, Icon i) {

  206. 	}

  207. 

  208. 	public Icon getIcon(File f) {

  209. 	    return (f != null && f.isDirectory()) ? directoryIcon : fileIcon;

  210. 	}

  211.     }

  212. 

  213. 

  214.     private void updateDefaultButton() {

  215. 	JFileChooser filechooser = getFileChooser();

  216. 	JRootPane root = SwingUtilities.getRootPane(filechooser);

  217. 	if (root == null) {

  218. 	    return;

  219. 	}

  220. 

  221. 	if (filechooser.getControlButtonsAreShown()) {

  222. 	    if (root.getDefaultButton() == null) {

  223. 		root.setDefaultButton(getApproveButton(filechooser));

  224. 		getCancelButton(filechooser).setDefaultCapable(false);

  225. 	    }

  226. 	} else {

  227. 	    if (root.getDefaultButton() == getApproveButton(filechooser)) {

  228. 		root.setDefaultButton(null);

  229. 	    }

  230. 	}

  231.     }

  232. 

  233.     protected void doSelectedFileChanged(PropertyChangeEvent e) {

  234. 	super.doSelectedFileChanged(e);

  235. 	File f = (File) e.getNewValue();

  236. 	if (f != null) {

  237. 	    setFileName(getFileChooser().getName(f));

  238. 	}

  239.     }

  240. 

  241.     protected void doDirectoryChanged(PropertyChangeEvent e) {

  242. 	directoryList.clearSelection();

  243. 	fileList.clearSelection();

  244. 

  245. 	File currentDirectory = getFileChooser().getCurrentDirectory();

  246. 	if (currentDirectory != null) {

  247. 	    try {

  248. 		setDirectoryName(((File)e.getNewValue()).getCanonicalPath());

  249. 	    } catch (IOException ioe) {

  250. 		setDirectoryName(((File)e.getNewValue()).getAbsolutePath());

  251. 	    }

  252. 	    directoryComboBoxModel.addItem(currentDirectory);

  253.             directoryListModel.directoryChanged();

  254. 	}

  255. 	super.doDirectoryChanged(e);

  256.     }

  257. 

  258.     protected void doAccessoryChanged(PropertyChangeEvent e) {

  259. 	if (getAccessoryPanel() != null) {

  260. 	    if (e.getOldValue() != null) {

  261. 		getAccessoryPanel().remove((JComponent)e.getOldValue());

  262. 	    }

  263. 	    JComponent accessory = (JComponent)e.getNewValue();

  264. 	    if (accessory != null) {

  265. 		getAccessoryPanel().add(accessory, BorderLayout.CENTER);

  266. 		getAccessoryPanel().setPreferredSize(accessory.getPreferredSize());

  267. 		getAccessoryPanel().setMaximumSize(MAX_SIZE);

  268. 	    } else {

  269. 		getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);

  270. 		getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);

  271. 	    }

  272. 	}

  273.     }

  274. 

  275.     protected void doFileSelectionModeChanged(PropertyChangeEvent e) {

  276. 	directoryList.clearSelection();

  277. 	rightPanel.setVisible(((Integer)e.getNewValue()).intValue() != JFileChooser.DIRECTORIES_ONLY);

  278. 

  279. 	super.doFileSelectionModeChanged(e);

  280.     }

  281. 

  282.     protected void doMultiSelectionChanged(PropertyChangeEvent e) {

  283. 	if (getFileChooser().isMultiSelectionEnabled()) {

  284. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  285. 	} else {

  286. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  287. 	    fileList.clearSelection();

  288. 	}

  289. 

  290. 	super.doMultiSelectionChanged(e);

  291.     }

  292. 

  293.     protected void doControlButtonsChanged(PropertyChangeEvent e) {

  294. 	super.doControlButtonsChanged(e);

  295. 

  296. 	JFileChooser filechooser = getFileChooser();

  297. 	if (filechooser.getControlButtonsAreShown()) {

  298. 	    filechooser.add(bottomButtonPanel, BorderLayout.SOUTH);

  299. 	} else {

  300. 	    filechooser.remove(bottomButtonPanel);

  301. 	}

  302. 	updateDefaultButton();

  303.     }

  304. 

  305.     protected void doAncestorChanged(PropertyChangeEvent e) {

  306. 	if (e.getOldValue() == null && e.getNewValue() != null) {

  307. 	    // Ancestor was added, set initial focus

  308. 	    fileNameTextField.selectAll();

  309. 	    fileNameTextField.requestFocus();

  310. 	    updateDefaultButton();

  311. 	}

  312. 

  313. 	super.doAncestorChanged(e);

  314.     }

  315. 

  316. 

  317. 

  318.     // ********************************************

  319.     // ************ Create Listeners **************

  320.     // ********************************************

  321. 

  322.     public ListSelectionListener createListSelectionListener(JFileChooser fc) {

  323. 	return new SelectionListener();

  324.     }

  325. 

  326.     class DoubleClickListener extends MouseAdapter {

  327. 	JList list;

  328. 	public  DoubleClickListener(JList list) {

  329. 	    this.list = list;

  330. 	}

  331. 

  332. 	public void mouseClicked(MouseEvent e) {

  333. 	    if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2) {

  334. 		int index = list.locationToIndex(e.getPoint());

  335. 		if (index >= 0) {

  336. 		    File f = (File) list.getModel().getElementAt(index);

  337. 		    try {

  338. 			// Strip trailing ".."

  339. 			f = f.getCanonicalFile();

  340. 		    } catch (IOException ex) {

  341. 			// That's ok, we'll use f as is

  342. 		    }

  343. 		    if (getFileChooser().isTraversable(f)) {

  344.                         list.clearSelection();

  345.                         if (getFileChooser().getCurrentDirectory().equals(f)){

  346.                             rescanCurrentDirectory(getFileChooser());

  347.                         } else {

  348.                             getFileChooser().setCurrentDirectory(f);

  349.                         }

  350. 		    } else {

  351. 			getFileChooser().approveSelection();

  352. 		    }

  353. 		}

  354. 	    }

  355. 	}

  356.     }

  357. 

  358.     protected MouseListener createDoubleClickListener(JFileChooser fc, JList list) {

  359. 	return new DoubleClickListener(list);

  360.     }

  361. 

  362. 

  363. 

  364.     protected class SelectionListener implements ListSelectionListener {

  365. 	public void valueChanged(ListSelectionEvent e) {

  366. 	    if (!e.getValueIsAdjusting()) {

  367. 		JFileChooser chooser = getFileChooser();

  368. 		JList list = (JList) e.getSource();

  369. 

  370. 		if (chooser.isMultiSelectionEnabled()) {

  371. 		    File[] files = null;

  372. 		    Object[] objects = list.getSelectedValues();

  373. 		    if (objects != null) {

  374. 			if (objects.length == 1

  375. 			    && ((File)objects[0]).isDirectory()

  376. 			    && chooser.isTraversable(((File)objects[0]))

  377. 			    && (chooser.getFileSelectionMode() != chooser.DIRECTORIES_ONLY

  378. 				|| !chooser.getFileSystemView().isFileSystem(((File)objects[0])))) {

  379. 			    setDirectorySelected(true);

  380. 			    setDirectory(((File)objects[0]));

  381. 			} else {

  382. 			    ArrayList fList = new ArrayList(objects.length);

  383. 			    for (int i = 0; i < objects.length; i++) {

  384. 				File f = (File)objects[i];

  385. 				if ((chooser.isFileSelectionEnabled() && f.isFile())

  386. 				    || (chooser.isDirectorySelectionEnabled() && f.isDirectory())) {

  387. 				    fList.add(f);

  388. 				}

  389. 			    }

  390. 			    if (fList.size() > 0) {

  391. 				files = (File[])fList.toArray(new File[fList.size()]);

  392. 			    }

  393. 			    setDirectorySelected(false);

  394. 			}

  395. 		    }

  396. 		    chooser.setSelectedFiles(files);

  397. 		} else {

  398. 		    File file = (File)list.getSelectedValue();

  399. 		    if (file != null

  400. 			&& file.isDirectory()

  401. 			&& chooser.isTraversable(file)

  402. 			&& (chooser.getFileSelectionMode() != chooser.DIRECTORIES_ONLY

  403. 			    || !chooser.getFileSystemView().isFileSystem(file))) {

  404. 

  405. 			setDirectorySelected(true);

  406. 			setDirectory(file);

  407. 		    } else {

  408. 			setDirectorySelected(false);

  409. 			if (file != null) {

  410. 			    chooser.setSelectedFile(file);

  411. 			}

  412. 		    }

  413. 		}

  414. 	    }

  415. 	}

  416.     }

  417. 

  418. 

  419.     //

  420.     // ComponentUI Interface Implementation methods

  421.     //

  422.     public static ComponentUI createUI(JComponent c) {

  423.         return new GTKFileChooserUI((JFileChooser)c);

  424.     }

  425. 

  426.     public void installUI(JComponent c) {

  427. 	accessoryPanel = new JPanel(new BorderLayout(10, 10));

  428. 	accessoryPanel.setName("GTKFileChooser.accessoryPanel");

  429. 

  430. 	super.installUI(c);

  431.     }

  432. 

  433.     public void uninstallUI(JComponent c) {

  434.         c.removePropertyChangeListener(filterComboBoxModel);

  435.         super.uninstallUI(c);

  436. 

  437.         if (accessoryPanel != null) {

  438.             accessoryPanel.removeAll();

  439.         }

  440.         accessoryPanel = null;

  441.         getFileChooser().removeAll();

  442.     }

  443. 

  444.     public void installComponents(JFileChooser fc) {

  445.         super.installComponents(fc);

  446. 

  447.         boolean leftToRight = fc.getComponentOrientation().isLeftToRight();

  448. 

  449.         fc.setLayout(new BorderLayout());

  450.         fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);

  451. 

  452.         // Top row of buttons

  453.         JPanel topButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));

  454.         topButtonPanel.setBorder(new EmptyBorder(10, 10, 0, 10));

  455.         topButtonPanel.setName("GTKFileChooser.topButtonPanel");

  456. 

  457.         if (!UIManager.getBoolean("FileChooser.readOnly")) {

  458.             JButton newFolderButton = new JButton(getNewFolderAction());

  459.             newFolderButton.setName("GTKFileChooser.newFolderButton");

  460.             newFolderButton.setMnemonic(newFolderButtonMnemonic);

  461.             newFolderButton.setToolTipText(newFolderButtonToolTipText);

  462.             newFolderButton.setText(newFolderButtonText);

  463.             topButtonPanel.add(newFolderButton);

  464.         }

  465.         JButton deleteFileButton = new JButton(deleteFileButtonText);

  466.         deleteFileButton.setName("GTKFileChooser.deleteFileButton");

  467.         deleteFileButton.setMnemonic(deleteFileButtonMnemonic);

  468.         deleteFileButton.setToolTipText(deleteFileButtonToolTipText);

  469.         deleteFileButton.setEnabled(false);

  470.         topButtonPanel.add(deleteFileButton);

  471. 

  472.         RenameFileAction rfa = new RenameFileAction();

  473.         JButton renameFileButton = new JButton(rfa);

  474.         if (readOnly) {

  475.             rfa.setEnabled(false);

  476.         }

  477.         renameFileButton.setText(renameFileButtonText); 

  478.         renameFileButton.setName("GTKFileChooser.renameFileButton");

  479.         renameFileButton.setMnemonic(renameFileButtonMnemonic);

  480.         renameFileButton.setToolTipText(renameFileButtonToolTipText);

  481.         topButtonPanel.add(renameFileButton);

  482. 

  483.         fc.add(topButtonPanel, BorderLayout.NORTH);

  484. 

  485. 

  486.         interior = new JPanel();

  487.         interior.setBorder(new EmptyBorder(0, 10, 10, 10));

  488.         interior.setName("GTKFileChooser.interiorPanel");

  489.         align(interior);

  490.         interior.setLayout(new BoxLayout(interior, BoxLayout.PAGE_AXIS));

  491. 

  492.         fc.add(interior, BorderLayout.CENTER);

  493. 

  494.         JPanel comboBoxPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,

  495.                                                          0, 0) {

  496.             public void layoutContainer(Container target) {

  497.                 super.layoutContainer(target);

  498.                 JComboBox comboBox = directoryComboBox;

  499.                 if (comboBox.getWidth() > target.getWidth()) {

  500.                     comboBox.setBounds(0, comboBox.getY(), target.getWidth(),

  501.                                        comboBox.getHeight());

  502.                 }

  503.             }

  504.         });

  505.         comboBoxPanel.setBorder(new EmptyBorder(0, 0, 4, 0));

  506.         comboBoxPanel.setName("GTKFileChooser.directoryComboBoxPanel");

  507.         // CurrentDir ComboBox

  508.         directoryComboBoxModel = createDirectoryComboBoxModel(fc);

  509.         directoryComboBox = new JComboBox(directoryComboBoxModel);

  510.         directoryComboBox.setName("GTKFileChooser.directoryComboBox");

  511.         directoryComboBox.putClientProperty( "JComboBox.lightweightKeyboardNavigation", "Lightweight" );

  512.         directoryComboBox.addActionListener(directoryComboBoxAction);

  513.         directoryComboBox.setMaximumRowCount(8);

  514.         comboBoxPanel.add(directoryComboBox);

  515.         interior.add(comboBoxPanel);

  516. 

  517. 

  518.         // CENTER: left, right, accessory

  519.         JPanel centerPanel = new JPanel(new BorderLayout());

  520.         centerPanel.setName("GTKFileChooser.centerPanel");

  521. 

  522.         // SPLIT PANEL: left, right

  523.         JSplitPane splitPanel = new JSplitPane();

  524.         splitPanel.setName("GTKFileChooser.splitPanel");

  525.         splitPanel.setDividerLocation((PREF_SIZE.width-8)/2);

  526. 

  527.         // left panel - Filter & directoryList

  528.         JPanel leftPanel = new JPanel(new GridBagLayout());

  529.         leftPanel.setName("GTKFileChooser.directoryListPanel");

  530. 

  531.         // Add the Directory List

  532.         // Create a label that looks like button (should be a table header)

  533.         TableCellRenderer headerRenderer = new JTableHeader().getDefaultRenderer();

  534.         JComponent directoryListLabel =

  535.             (JComponent)headerRenderer.getTableCellRendererComponent(null, foldersLabelText,

  536.                                                                      false, false, 0, 0);

  537.         directoryListLabel.setName("GTKFileChooser.directoryListLabel");

  538.         leftPanel.add(directoryListLabel, new GridBagConstraints(

  539.                           0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,

  540.                           GridBagConstraints.HORIZONTAL,

  541.                           new Insets(0, 0, 0, 0), 0, 0));

  542.         leftPanel.add(createDirectoryList(), new GridBagConstraints(

  543.                           0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,

  544.                           GridBagConstraints.BOTH,

  545.                           new Insets(0, 0, 0, 0), 0, 0));

  546. 

  547. 

  548.         // create files list

  549.         rightPanel = new JPanel(new GridBagLayout());

  550.         rightPanel.setName("GTKFileChooser.fileListPanel");

  551. 

  552.         headerRenderer = new JTableHeader().getDefaultRenderer();

  553.         JComponent fileListLabel =

  554.             (JComponent)headerRenderer.getTableCellRendererComponent(null, filesLabelText,

  555.                                                                      false, false, 0, 0);

  556.         fileListLabel.setName("GTKFileChooser.fileListLabel");

  557.         rightPanel.add(fileListLabel, new GridBagConstraints(

  558.                           0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,

  559.                           GridBagConstraints.HORIZONTAL,

  560.                           new Insets(0, 0, 0, 0), 0, 0));

  561.         rightPanel.add(createFilesList(), new GridBagConstraints(

  562.                           0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,

  563.                           GridBagConstraints.BOTH,

  564.                           new Insets(0, 0, 0, 0), 0, 0));

  565. 

  566.         splitPanel.add(leftPanel,  leftToRight ? JSplitPane.LEFT : JSplitPane.RIGHT);

  567.         splitPanel.add(rightPanel, leftToRight ? JSplitPane.RIGHT : JSplitPane.LEFT);

  568.         centerPanel.add(splitPanel, BorderLayout.CENTER);

  569. 

  570.         JComponent accessoryPanel = getAccessoryPanel();

  571.         JComponent accessory = fc.getAccessory();

  572.         if (accessoryPanel != null) {

  573.             if (accessory == null) {

  574.                 accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);

  575.                 accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);

  576.             } else {

  577.                 getAccessoryPanel().add(accessory, BorderLayout.CENTER);

  578.                 accessoryPanel.setPreferredSize(accessory.getPreferredSize());

  579.                 accessoryPanel.setMaximumSize(MAX_SIZE);

  580.             }

  581.             align(accessoryPanel);

  582.             centerPanel.add(accessoryPanel, BorderLayout.AFTER_LINE_ENDS);

  583.         }

  584.         interior.add(centerPanel);

  585.         interior.add(Box.createRigidArea(vstrut10));

  586. 

  587.         JPanel pathFieldPanel = new JPanel(new FlowLayout(FlowLayout.LEADING,

  588.                                                           0, 0));

  589.         pathFieldPanel.setBorder(new EmptyBorder(0, 0, 4, 0));

  590.         JLabel pathFieldLabel = new JLabel(pathLabelText);

  591.         pathFieldLabel.setName("GTKFileChooser.pathFieldLabel");

  592.         pathFieldLabel.setDisplayedMnemonic(pathLabelMnemonic);

  593.         align(pathFieldLabel);

  594.         pathFieldPanel.add(pathFieldLabel);

  595.         pathFieldPanel.add(Box.createRigidArea(hstrut3));

  596. 

  597.         File currentDirectory = fc.getCurrentDirectory();

  598.         String curDirName = null;

  599.         if (currentDirectory != null) {

  600.             curDirName = currentDirectory.getPath();

  601.         }

  602.         pathField = new JLabel(curDirName) {

  603.             public Dimension getMaximumSize() {

  604.                 Dimension d = super.getMaximumSize();

  605.                 d.height = getPreferredSize().height;

  606.                 return d;

  607.             }

  608.         };

  609.         pathField.setName("GTKFileChooser.pathField");

  610.         pathFieldLabel.setLabelFor(pathField);

  611.         align(pathField);

  612.         pathFieldPanel.add(pathField);

  613.         interior.add(pathFieldPanel);

  614. 

  615.         // add the fileName field

  616.         fileNameTextField = new JTextField() {

  617.             public Dimension getMaximumSize() {

  618.                 Dimension d = super.getMaximumSize();

  619.                 d.height = getPreferredSize().height;

  620.                 return d;

  621.             }

  622.         };

  623.         Set forwardTraversalKeys = fileNameTextField.getFocusTraversalKeys(

  624.             KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);

  625.         forwardTraversalKeys = new HashSet(forwardTraversalKeys);

  626.         forwardTraversalKeys.remove(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));

  627.         fileNameTextField.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, forwardTraversalKeys);

  628. 

  629.         fileNameTextField.setName("GTKFileChooser.fileNameTextField");

  630.         fileNameTextField.getActionMap().put("fileNameCompletionAction", getFileNameCompletionAction());

  631.         fileNameTextField.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0), "fileNameCompletionAction");

  632.         interior.add(fileNameTextField);

  633. 

  634.         // Add the filter combo box

  635.         JPanel panel = new JPanel();

  636.         panel.setLayout(new FlowLayout(FlowLayout.LEADING, 0, 0));

  637.         panel.setBorder(new EmptyBorder(0, 0, 4, 0));

  638.         JLabel filterLabel = new JLabel(filterLabelText);

  639.         filterLabel.setName("GTKFileChooser.filterLabel");

  640.         filterLabel.setDisplayedMnemonic(filterLabelMnemonic);

  641.         panel.add(filterLabel);

  642. 

  643.         filterComboBoxModel = createFilterComboBoxModel();

  644.         fc.addPropertyChangeListener(filterComboBoxModel);

  645.         filterComboBox = new JComboBox(filterComboBoxModel);

  646.         filterComboBox.setRenderer(createFilterComboBoxRenderer());

  647.         filterLabel.setLabelFor(filterComboBox);

  648. 

  649.         interior.add(Box.createRigidArea(vstrut10));

  650.         interior.add(panel);

  651.         interior.add(filterComboBox);

  652. 

  653.         // Add buttons

  654.         bottomButtonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING));

  655.         bottomButtonPanel.setName("GTKFileChooser.bottomButtonPanel");

  656.         align(bottomButtonPanel);

  657. 

  658.         JButton cancelButton = getCancelButton(fc);

  659.         align(cancelButton);

  660.         cancelButton.setMargin(buttonMargin);

  661.         bottomButtonPanel.add(cancelButton);

  662. 

  663.         JButton approveButton = getApproveButton(fc);;

  664.         align(approveButton);

  665.         approveButton.setMargin(buttonMargin);

  666.         bottomButtonPanel.add(approveButton);

  667. 

  668.         fc.add(bottomButtonPanel, BorderLayout.SOUTH);

  669.     }

  670. 

  671.     protected void installListeners(JFileChooser fc) {

  672. 	super.installListeners(fc);

  673. 

  674. 	gtkFCPropertyChangeListener = new GTKFCPropertyChangeListener();

  675. 	fc.addPropertyChangeListener(gtkFCPropertyChangeListener);

  676.     }

  677. 

  678.     protected void uninstallListeners(JFileChooser fc) {

  679. 	super.uninstallListeners(fc);

  680. 

  681. 	if (gtkFCPropertyChangeListener != null) {

  682. 	    fc.removePropertyChangeListener(gtkFCPropertyChangeListener);

  683. 	}

  684.     }

  685. 

  686.     private class GTKFCPropertyChangeListener implements PropertyChangeListener {

  687. 	public void propertyChange(PropertyChangeEvent e) {

  688. 	    String prop = e.getPropertyName();

  689. 	    if (prop.equals("GTKFileChooser.showDirectoryIcons")) {

  690. 		showDirectoryIcons = Boolean.TRUE.equals(e.getNewValue());

  691. 	    } else if (prop.equals("GTKFileChooser.showFileIcons")) {

  692. 		showFileIcons      = Boolean.TRUE.equals(e.getNewValue());

  693. 	    }

  694. 	}

  695.     }

  696. 

  697.     protected void installDefaults(JFileChooser fc) {

  698. 	super.installDefaults(fc);

  699. 	readOnly = UIManager.getBoolean("FileChooser.readOnly");

  700. 	showDirectoryIcons =

  701. 	    Boolean.TRUE.equals(fc.getClientProperty("GTKFileChooser.showDirectoryIcons"));

  702. 	showFileIcons =

  703. 	    Boolean.TRUE.equals(fc.getClientProperty("GTKFileChooser.showFileIcons"));

  704.     }

  705. 

  706.     protected void installIcons(JFileChooser fc) {

  707. 	directoryIcon    = UIManager.getIcon("FileView.directoryIcon");

  708. 	fileIcon         = UIManager.getIcon("FileView.fileIcon");

  709.     }

  710. 

  711.     protected void installStrings(JFileChooser fc) {

  712.         super.installStrings(fc);

  713. 

  714.         Locale l = fc.getLocale();

  715. 

  716.         newFolderDialogText = UIManager.getString("FileChooser.newFolderDialogText", l);

  717.         newFolderErrorText = UIManager.getString("FileChooser.newFolderErrorText",l);

  718.         newFolderErrorSeparator = UIManager.getString("FileChooser.newFolderErrorSeparator",l);

  719.         newFolderButtonText = UIManager.getString("FileChooser.newFolderButtonText", l);

  720.         deleteFileButtonText = UIManager.getString("FileChooser.deleteFileButtonText", l);

  721.         renameFileButtonText = UIManager.getString("FileChooser.renameFileButtonText", l);

  722. 

  723.         newFolderButtonMnemonic = UIManager.getInt("FileChooser.newFolderButtonMnemonic", l);

  724.         deleteFileButtonMnemonic = UIManager.getInt("FileChooser.deleteFileButtonMnemonic", l);

  725.         renameFileButtonMnemonic = UIManager.getInt("FileChooser.renameFileButtonMnemonic", l);

  726. 

  727.         newFolderButtonToolTipText = UIManager.getString("FileChooser.newFolderButtonToolTipText", l);

  728.         deleteFileButtonToolTipText = UIManager.getString("FileChooser.deleteFileButtonToolTipText", l);

  729.         renameFileButtonToolTipText = UIManager.getString("FileChooser.renameFileButtonToolTipText", l);

  730. 

  731.         renameFileDialogText = UIManager.getString("FileChooser.renameFileDialogText", l); 

  732.         renameFileErrorTitle = UIManager.getString("FileChooser.renameFileErrorTitle", l);

  733.         renameFileErrorText = UIManager.getString("FileChooser.renameFileErrorText", l);

  734. 

  735.         foldersLabelText = UIManager.getString("FileChooser.foldersLabelText",l);

  736.         filesLabelText = UIManager.getString("FileChooser.filesLabelText",l);

  737.         

  738.         pathLabelText = UIManager.getString("FileChooser.pathLabelText",l);

  739.         pathLabelMnemonic = UIManager.getInt("FileChooser.pathLabelMnemonic"); 

  740. 

  741.         filterLabelText = UIManager.getString("FileChooser.filterLabelText", l);

  742.         filterLabelMnemonic = UIManager.getInt("FileChooser.filterLabelMnemonic"); 

  743.     }

  744. 

  745.     protected void uninstallStrings(JFileChooser fc) {

  746. 	super.uninstallStrings(fc);

  747. 

  748. 	newFolderButtonText = null;

  749. 	deleteFileButtonText = null;

  750. 	renameFileButtonText = null;

  751. 

  752. 	newFolderButtonToolTipText = null;

  753. 	deleteFileButtonToolTipText = null;

  754. 	renameFileButtonToolTipText = null;

  755. 

  756.         renameFileDialogText = null; 

  757.         renameFileErrorTitle = null; 

  758.         renameFileErrorText = null; 

  759. 

  760. 	foldersLabelText = null;

  761. 	filesLabelText = null;

  762. 	

  763. 	pathLabelText = null;

  764. 

  765.         newFolderDialogText = null;

  766.         newFolderErrorText = null;

  767.         newFolderErrorSeparator = null;

  768.     }

  769. 

  770.     protected JScrollPane createFilesList() {

  771. 	fileList = new JList();

  772. 	fileList.setName("GTKFileChooser.fileList");

  773. 

  774. 	if (getFileChooser().isMultiSelectionEnabled()) {

  775. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  776. 	} else {

  777. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  778. 	}

  779. 	

  780. 	fileList.setModel(new GTKFileListModel());

  781. 	fileList.setCellRenderer(new FileCellRenderer());

  782. 	fileList.addListSelectionListener(createListSelectionListener(getFileChooser()));

  783. 	fileList.addMouseListener(createDoubleClickListener(getFileChooser(), fileList));

  784. 	align(fileList);

  785. 	JScrollPane scrollpane = new JScrollPane(fileList);

  786.     scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

  787. 	scrollpane.setName("GTKFileChooser.fileListScrollPane");

  788. 	scrollpane.setPreferredSize(prefListSize);

  789. 	scrollpane.setMaximumSize(MAX_SIZE);

  790. 	align(scrollpane);

  791. 	return scrollpane;

  792.     }

  793. 

  794.     protected JScrollPane createDirectoryList() {

  795. 	directoryList = new JList();

  796. 	directoryList.setName("GTKFileChooser.directoryList");

  797. 	align(directoryList);

  798. 

  799. 	directoryList.setCellRenderer(new DirectoryCellRenderer());

  800.         directoryListModel = new GTKDirectoryListModel();

  801. 	directoryList.setModel(directoryListModel);

  802. 	directoryList.addMouseListener(createDoubleClickListener(getFileChooser(), directoryList));

  803. 	directoryList.addListSelectionListener(createListSelectionListener(getFileChooser()));

  804. 

  805. 	JScrollPane scrollpane = new JScrollPane(directoryList);

  806.     scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);    

  807. 	scrollpane.setName("GTKFileChooser.directoryListScrollPane");

  808. 	scrollpane.setMaximumSize(MAX_SIZE);

  809. 	scrollpane.setPreferredSize(prefListSize);

  810. 	align(scrollpane);

  811. 	return scrollpane;

  812.     }

  813. 

  814.     protected void createModel() {

  815.         model = new GTKDirectoryModel();

  816.     }

  817. 

  818.     public BasicDirectoryModel getModel() {

  819.         return model;

  820.     }

  821. 

  822.     public Action getApproveSelectionAction() {

  823.         return approveSelectionAction;

  824.     }

  825. 

  826.     private class GTKDirectoryModel extends BasicDirectoryModel {

  827.         FileSystemView fsv;

  828.         private Comparator fileComparator = new Comparator() {

  829.             public int compare(Object o, Object o1) {

  830.                 return fsv.getSystemDisplayName((File) o).compareTo

  831.                       (fsv.getSystemDisplayName((File) o1));    

  832.             }

  833.         };

  834. 

  835.         public GTKDirectoryModel() {

  836.             super(getFileChooser());

  837.         }

  838. 

  839.         protected void sort(Vector<? extends File> v) {

  840.             fsv = getFileChooser().getFileSystemView();

  841.             Collections.sort(v, fileComparator);

  842.         }

  843.     }

  844. 

  845.     protected class GTKDirectoryListModel extends AbstractListModel implements ListDataListener {

  846.         File curDir;

  847. 	public GTKDirectoryListModel() {

  848. 	    getModel().addListDataListener(this);

  849.             directoryChanged();

  850. 	}

  851. 

  852. 	public int getSize() {

  853. 	    return getModel().getDirectories().size() + 1;

  854. 	}

  855. 

  856. 	public Object getElementAt(int index) {

  857.             return index > 0 ? getModel().getDirectories().elementAt(index - 1):

  858.                     curDir;

  859. 	}

  860. 

  861. 	public void intervalAdded(ListDataEvent e) {

  862. 	    fireIntervalAdded(this, e.getIndex0(), e.getIndex1());

  863. 	}

  864. 

  865. 	public void intervalRemoved(ListDataEvent e) {

  866. 	    fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());

  867. 	}

  868. 

  869. 	// PENDING - this is inefficient - should sent out

  870. 	// incremental adjustment values instead of saying that the

  871. 	// whole list has changed.

  872. 	public void fireContentsChanged() {

  873. 	    fireContentsChanged(this, 0, getModel().getDirectories().size()-1);

  874. 	}

  875. 

  876. 	// PENDING - fire the correct interval changed - currently sending

  877. 	// out that everything has changed

  878. 	public void contentsChanged(ListDataEvent e) {

  879. 	    fireContentsChanged();

  880. 	}

  881. 

  882.         private void directoryChanged() {

  883.             curDir = getFileChooser().getFileSystemView().createFileObject(

  884.                     getFileChooser().getCurrentDirectory(), ".");

  885.         }

  886.     }

  887. 

  888.     protected class GTKFileListModel extends AbstractListModel implements ListDataListener {

  889. 	public GTKFileListModel() {

  890. 	    getModel().addListDataListener(this);

  891. 	}

  892. 

  893. 	public int getSize() {

  894. 	    return getModel().getFiles().size();

  895. 	}

  896. 

  897. 	public boolean contains(Object o) {

  898. 	    return getModel().getFiles().contains(o);

  899. 	}

  900. 

  901. 	public int indexOf(Object o) {

  902. 	    return getModel().getFiles().indexOf(o);

  903. 	}

  904. 

  905. 	public Object getElementAt(int index) {

  906. 	    return getModel().getFiles().elementAt(index);

  907. 	}

  908. 

  909. 	public void intervalAdded(ListDataEvent e) {

  910. 	    fireIntervalAdded(this, e.getIndex0(), e.getIndex1());

  911. 	}

  912. 

  913. 	public void intervalRemoved(ListDataEvent e) {

  914. 	    fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());

  915. 	}

  916. 

  917. 	// PENDING - this is inefficient - should sent out

  918. 	// incremental adjustment values instead of saying that the

  919. 	// whole list has changed.

  920. 	public void fireContentsChanged() {

  921. 	    fireContentsChanged(this, 0, getModel().getFiles().size()-1);

  922. 	}

  923. 

  924. 	// PENDING - fire the interval changed

  925. 	public void contentsChanged(ListDataEvent e) {

  926. 	    fireContentsChanged();

  927. 	}

  928. 

  929.     }

  930. 

  931. 

  932.     protected class FileCellRenderer extends DefaultListCellRenderer  {

  933. 	public Component getListCellRendererComponent(JList list, Object value, int index,

  934. 						      boolean isSelected, boolean cellHasFocus) {

  935. 

  936. 	    super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  937. 	    setText(getFileChooser().getName((File) value));

  938. 	    if (showFileIcons) {

  939. 		setIcon(getFileChooser().getIcon((File)value));

  940. 	    }

  941. 	    return this;

  942. 	}

  943.     }

  944. 

  945.     protected class DirectoryCellRenderer extends DefaultListCellRenderer  {

  946. 	public Component getListCellRendererComponent(JList list, Object value, int index,

  947. 						      boolean isSelected, boolean cellHasFocus) {

  948. 

  949. 	    super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  950. 

  951. 	    if (showDirectoryIcons) {

  952. 		setIcon(getFileChooser().getIcon((File)value));

  953. 		setText(getFileChooser().getName((File)value));

  954. 	    } else {

  955. 		setText(getFileChooser().getName((File)value) + "/");

  956. 	    }

  957. 	    return this;

  958. 	}

  959.     }

  960. 

  961.     public Dimension getPreferredSize(JComponent c) {

  962. 	Dimension prefSize = new Dimension(PREF_SIZE);

  963. 	JComponent accessory = getFileChooser().getAccessory();

  964. 	if (accessory != null) {

  965. 	    prefSize.width += accessory.getPreferredSize().width + 20;

  966. 	}

  967. 	Dimension d = c.getLayout().preferredLayoutSize(c);

  968. 	if (d != null) {

  969. 	    return new Dimension(d.width < prefSize.width ? prefSize.width : d.width,

  970. 				 d.height < prefSize.height ? prefSize.height : d.height);

  971. 	} else {

  972. 	    return prefSize;

  973. 	}

  974.     }

  975. 

  976.     public Dimension getMinimumSize(JComponent x)  {

  977. 	return new Dimension(MIN_SIZE);

  978.     }

  979. 

  980.     public Dimension getMaximumSize(JComponent x) {

  981. 	return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);

  982.     }

  983. 

  984.     protected void align(JComponent c) {

  985. 	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  986. 	c.setAlignmentY(JComponent.TOP_ALIGNMENT);

  987.     }

  988. 

  989.     public Action getNewFolderAction() {

  990.         if (newFolderAction == null) {

  991.             newFolderAction = new NewFolderAction();

  992.             newFolderAction.setEnabled(!readOnly);

  993.         }

  994.         return newFolderAction;

  995.     }

  996. 

  997.     //

  998.     // DataModel for DirectoryComboxbox

  999.     //

  1000.     protected DirectoryComboBoxModel createDirectoryComboBoxModel(JFileChooser fc) {

  1001. 	return new DirectoryComboBoxModel();

  1002.     }

  1003. 

  1004.     /**

  1005.      * Data model for a type-face selection combo-box.

  1006.      */

  1007.     protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {

  1008. 	Vector directories = new Vector();

  1009. 	File selectedDirectory = null;

  1010. 	JFileChooser chooser = getFileChooser();

  1011. 	FileSystemView fsv = chooser.getFileSystemView();

  1012. 

  1013. 	public DirectoryComboBoxModel() {

  1014. 	    // Add the current directory to the model, and make it the

  1015. 	    // selectedDirectory

  1016. 	    File dir = getFileChooser().getCurrentDirectory();

  1017. 	    if (dir != null) {

  1018. 		addItem(dir);

  1019. 	    }

  1020. 	}

  1021. 

  1022. 	/**

  1023. 	 * Adds the directory to the model and sets it to be selected,

  1024. 	 * additionally clears out the previous selected directory and

  1025. 	 * the paths leading up to it, if any.

  1026. 	 */

  1027. 	private void addItem(File directory) {

  1028. 

  1029. 	    if (directory == null) {

  1030. 		return;

  1031. 	    }

  1032. 

  1033.             int oldSize = directories.size();

  1034. 	    directories.clear();

  1035.             if (oldSize > 0) {

  1036.                 fireIntervalRemoved(this, 0, oldSize);

  1037.             }

  1038. 

  1039. 	    // Get the canonical (full) path. This has the side

  1040. 	    // benefit of removing extraneous chars from the path,

  1041. 	    // for example /foo/bar/ becomes /foo/bar

  1042. 	    File canonical = null;

  1043. 	    try {

  1044. 		canonical = fsv.createFileObject(directory.getCanonicalPath());

  1045. 	    } catch (IOException e) {

  1046. 		// Maybe drive is not ready. Can't abort here.

  1047. 		canonical = directory;

  1048. 	    }

  1049. 

  1050. 	    // create File instances of each directory leading up to the top

  1051. 	    File f = canonical;

  1052. 	    do {

  1053. 		directories.add(f);

  1054. 	    } while ((f = f.getParentFile()) != null);

  1055.             int newSize = directories.size();

  1056.             if (newSize > 0) {

  1057.                 fireIntervalAdded(this, 0, newSize);

  1058.             }

  1059. 	    setSelectedItem(canonical);

  1060. 	}

  1061. 

  1062. 	public void setSelectedItem(Object selectedDirectory) {

  1063. 	    this.selectedDirectory = (File)selectedDirectory;

  1064.             fireContentsChanged(this, -1, -1);

  1065. 	}

  1066. 

  1067. 	public Object getSelectedItem() {

  1068. 	    return selectedDirectory;

  1069. 	}

  1070. 

  1071. 	public int getSize() {

  1072. 	    return directories.size();

  1073. 	}

  1074. 

  1075. 	public Object getElementAt(int index) {

  1076. 	    return directories.elementAt(index);

  1077. 	}

  1078.     }

  1079. 

  1080.     /**

  1081.      * Acts when DirectoryComboBox has changed the selected item.

  1082.      */

  1083.     protected class DirectoryComboBoxAction extends AbstractAction {

  1084. 	protected DirectoryComboBoxAction() {

  1085. 	    super("DirectoryComboBoxAction");

  1086. 	}

  1087. 

  1088. 	public void actionPerformed(ActionEvent e) {

  1089. 	    File f = (File)directoryComboBox.getSelectedItem();

  1090. 	    getFileChooser().setCurrentDirectory(f);

  1091. 	}

  1092.     }

  1093. 

  1094.     /**

  1095.      * Creates a new folder.

  1096.      */

  1097.     private class NewFolderAction extends AbstractAction {

  1098.         protected NewFolderAction() {

  1099.             super(FilePane.ACTION_NEW_FOLDER);

  1100.         }

  1101.         public void actionPerformed(ActionEvent e) {

  1102.             if (readOnly) {

  1103.                 return;

  1104.             }

  1105.             JFileChooser fc = getFileChooser();

  1106.             File currentDirectory = fc.getCurrentDirectory();

  1107.             String dirName = (String) JOptionPane.showInputDialog(fc, 

  1108.                     newFolderDialogText, newFolderButtonText, 

  1109.                     JOptionPane.PLAIN_MESSAGE);

  1110.             

  1111.             if (dirName != null) {

  1112.                 File newDir = fc.getFileSystemView().createFileObject

  1113.                         (currentDirectory, dirName);

  1114.                 if (newDir == null || !newDir.mkdir()) {

  1115.                     JOptionPane.showMessageDialog(fc,

  1116.                             newFolderErrorText + newFolderErrorSeparator + " \"" + 

  1117.                             dirName + "\"",

  1118.                             newFolderErrorText, JOptionPane.ERROR_MESSAGE);

  1119.                 }

  1120.                 fc.rescanCurrentDirectory();

  1121.             }

  1122.         }

  1123.     }

  1124. 

  1125.     private class GTKApproveSelectionAction extends ApproveSelectionAction {

  1126.         public void actionPerformed(ActionEvent e) {

  1127.             if (isDirectorySelected()) {

  1128.                 File dir = getDirectory();

  1129.                 try {

  1130.                     if (dir != null) {

  1131.                         dir = dir.getCanonicalFile();

  1132.                     }

  1133.                     // Strip trailing ".."

  1134.                 } catch (IOException ex) {

  1135.                     // Ok, use f as is

  1136.                 }

  1137.                 if (getFileChooser().getCurrentDirectory().equals(dir)) {

  1138.                     directoryList.clearSelection();

  1139.                     rescanCurrentDirectory(getFileChooser());

  1140.                     return;

  1141.                 }

  1142.             }

  1143.             super.actionPerformed(e);

  1144.         }

  1145.     }

  1146. 

  1147.     /**

  1148.      * Renames file

  1149.      */

  1150.     private class RenameFileAction extends AbstractAction {

  1151.         protected RenameFileAction() {

  1152.             super(FilePane.ACTION_EDIT_FILE_NAME);

  1153.         }

  1154.         public void actionPerformed(ActionEvent e) {

  1155.             if (getFileName().equals("")) {

  1156.                 return;

  1157.             }

  1158.             JFileChooser fc = getFileChooser();

  1159.             File currentDirectory = fc.getCurrentDirectory();

  1160.             String newFileName = (String) JOptionPane.showInputDialog

  1161.                    (fc, new MessageFormat(renameFileDialogText).format

  1162.                            (new Object[] { getFileName() }),

  1163.                            renameFileButtonText, JOptionPane.PLAIN_MESSAGE, null, null,

  1164.                            getFileName());

  1165.             

  1166.             if (newFileName != null) {

  1167.                 File oldFile = fc.getFileSystemView().createFileObject

  1168.                         (currentDirectory, getFileName());

  1169.                 File newFile = fc.getFileSystemView().createFileObject

  1170.                         (currentDirectory, newFileName);

  1171.                 if (oldFile == null || newFile == null || 

  1172.                         !getModel().renameFile(oldFile, newFile)) {

  1173.                     JOptionPane.showMessageDialog(fc,

  1174.                             new MessageFormat(renameFileErrorText).

  1175.                             format(new Object[] { getFileName(), newFileName}),

  1176.                             renameFileErrorTitle, JOptionPane.ERROR_MESSAGE);

  1177.                 } else {

  1178.                     setFileName(getFileChooser().getName(newFile));

  1179.                     fc.rescanCurrentDirectory();

  1180.                 }

  1181.             }

  1182.         }

  1183.     }

  1184. 

  1185.     //

  1186.     // Renderer for Filter ComboBox

  1187.     //

  1188.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  1189.         return new FilterComboBoxRenderer();

  1190.     }

  1191. 

  1192.     /**

  1193.      * Render different filters

  1194.      */

  1195.     public class FilterComboBoxRenderer extends DefaultListCellRenderer implements UIResource {

  1196.         public String getName() {

  1197.             // As SynthComboBoxRenderer's are asked for a size BEFORE they

  1198.             // are parented getName is overriden to force the name to be

  1199.             // ComboBox.renderer if it isn't set. If we didn't do this the

  1200.             // wrong style could be used for size calculations.

  1201.             String name = super.getName();

  1202.             if (name == null) {

  1203.                 return "ComboBox.renderer";

  1204.             }

  1205.             return name;

  1206.         }

  1207. 

  1208.         public Component getListCellRendererComponent(JList list, Object value,

  1209.                                                       int index, boolean isSelected,

  1210.                                                       boolean cellHasFocus) {

  1211. 

  1212.             super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  1213. 

  1214.             setName("ComboBox.listRenderer");

  1215. 

  1216.             if (value != null) {

  1217.                 if (value instanceof FileFilter) {

  1218.                     setText(((FileFilter) value).getDescription());

  1219.                 }

  1220.             } else {

  1221.                 setText("");

  1222.             }

  1223. 

  1224.             return this;

  1225.         }

  1226.     }

  1227. 

  1228.     //

  1229.     // DataModel for Filter Combobox

  1230.     //

  1231.     protected FilterComboBoxModel createFilterComboBoxModel() {

  1232.         return new FilterComboBoxModel();

  1233.     }

  1234. 

  1235.     /**

  1236.      * Data model for filter combo-box.

  1237.      */

  1238.     protected class FilterComboBoxModel extends AbstractListModel

  1239.             implements ComboBoxModel, PropertyChangeListener {

  1240.         protected FileFilter[] filters;

  1241. 

  1242.         protected FilterComboBoxModel() {

  1243.             super();

  1244.             filters = getFileChooser().getChoosableFileFilters();

  1245.         }

  1246. 

  1247.         public void propertyChange(PropertyChangeEvent e) {

  1248.             String prop = e.getPropertyName();

  1249.             if (prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {

  1250.                 filters = (FileFilter[]) e.getNewValue();

  1251.                 fireContentsChanged(this, -1, -1);

  1252.             } else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {

  1253.                 fireContentsChanged(this, -1, -1);

  1254.             }

  1255.         }

  1256. 

  1257.         public void setSelectedItem(Object filter) {

  1258.             if (filter != null) {

  1259.                 getFileChooser().setFileFilter((FileFilter) filter);

  1260.                 setFileName(null);

  1261.                 fireContentsChanged(this, -1, -1);

  1262.             }

  1263.         }

  1264. 

  1265.         public Object getSelectedItem() {

  1266.             // Ensure that the current filter is in the list.

  1267.             // NOTE: we shouldnt' have to do this, since JFileChooser adds

  1268.             // the filter to the choosable filters list when the filter

  1269.             // is set. Lets be paranoid just in case someone overrides

  1270.             // setFileFilter in JFileChooser.

  1271.             FileFilter currentFilter = getFileChooser().getFileFilter();

  1272.             boolean found = false;

  1273.             if (currentFilter != null) {

  1274.                 for (int i = 0; i < filters.length; i++) {

  1275.                     if (filters[i] == currentFilter) {

  1276.                         found = true;

  1277.                     }

  1278.                 }

  1279.                 if (found == false) {

  1280.                     getFileChooser().addChoosableFileFilter(currentFilter);

  1281.                 }

  1282.             }

  1283.             return getFileChooser().getFileFilter();

  1284.         }

  1285. 

  1286.         public int getSize() {

  1287.             if (filters != null) {

  1288.                 return filters.length;

  1289.             } else {

  1290.                 return 0;

  1291.             }

  1292.         }

  1293. 

  1294.         public Object getElementAt(int index) {

  1295.             if (index > getSize() - 1) {

  1296.                 // This shouldn't happen. Try to recover gracefully.

  1297.                 return getFileChooser().getFileFilter();

  1298.             }

  1299.             if (filters != null) {

  1300.                 return filters[index];

  1301.             } else {

  1302.                 return null;

  1303.             }

  1304.         }

  1305.     }

  1306. }