1. /*

  2.  * @(#)GTKFileChooserUI.java	1.19 04/01/13

  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.*;

  19. import javax.swing.border.*;

  20. import javax.swing.filechooser.*;

  21. import javax.swing.event.*;

  22. import javax.swing.plaf.*;

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

  24. import javax.swing.table.*;

  25. 

  26. /**

  27.  * GTK FileChooserUI.

  28.  *

  29.  * @version 1.36 08/21/02

  30.  * @author Leif Samuelsson

  31.  * @author Jeff Dinkins

  32.  */

  33. class GTKFileChooserUI extends SynthFileChooserUI {

  34. 

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

  36.     private JPanel accessoryPanel = null;

  37. 

  38.     private String newFolderButtonText = null;

  39.     private String newFolderErrorSeparator = null;

  40.     private String newFolderErrorText = null;

  41.     private String newFolderDialogText = null;

  42. 

  43.     private String deleteFileButtonText = null;

  44.     private String renameFileButtonText = null;

  45. 

  46.     private String newFolderButtonToolTipText = null;

  47.     private String deleteFileButtonToolTipText = null;

  48.     private String renameFileButtonToolTipText = null;

  49. 

  50.     private int newFolderButtonMnemonic = 0;

  51.     private int deleteFileButtonMnemonic = 0;

  52.     private int renameFileButtonMnemonic = 0;

  53. 

  54.     private String renameFileDialogText = null; 

  55.     private String renameFileErrorTitle = null;

  56.     private String renameFileErrorText = null; 

  57.  

  58. 

  59.     // From Motif

  60. 

  61.     private JPanel rightPanel;

  62.     private JList directoryList;

  63.     private JList fileList;

  64. 

  65.     private JLabel pathField;

  66.     private JTextField fileNameTextField;

  67. 

  68.     private static final Dimension hstrut10 = new Dimension(10, 1);

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

  70. 

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

  72. 

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

  74. 

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

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

  77. 

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

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

  80. 

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

  82. 

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

  84. 

  85.     private String filesLabelText = null;

  86. 

  87.     private String foldersLabelText = null;

  88. 

  89.     private String pathLabelText = null;

  90.     private int pathLabelMnemonic = 0;

  91. 

  92.     private JComboBox directoryComboBox;

  93.     private DirectoryComboBoxModel directoryComboBoxModel;

  94.     private Action directoryComboBoxAction = new DirectoryComboBoxAction();

  95.     private JPanel bottomButtonPanel;

  96.     private GTKDirectoryModel model = null;

  97.     private Action newFolderAction;

  98.     private boolean readOnly;

  99.     private Action approveSelectionAction = new GTKApproveSelectionAction();

  100.     

  101.     public String getFileName() {

  102.         JFileChooser fc = getFileChooser();

  103.         String typedInName = fileNameTextField != null ?

  104.                                  fileNameTextField.getText() : null;

  105.         

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

  107.             return typedInName; 

  108.         }

  109.         

  110.         int mode = fc.getFileSelectionMode();

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

  112.                                  directoryList : fileList;

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

  114.         int len = files.length;

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

  116.         

  117.         // we return all selected file names

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

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

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

  121.         }

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

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

  124.             result.add(typedInName);

  125.         }

  126.         

  127.         StringBuffer buf = new StringBuffer();

  128.         len = result.size();

  129.         

  130.         // construct the resulting string

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

  132.             if (len > 1) {

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

  134.             }

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

  136.             if (len > 1) {

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

  138.             }

  139.         }

  140.         

  141.         return buf.toString();

  142.     }

  143. 

  144.     public void setFileName(String fileName) {

  145. 	if (fileNameTextField != null) {

  146. 	    fileNameTextField.setText(fileName);

  147. 	}

  148.     }

  149. 

  150. //     public String getDirectoryName() {

  151. // 	return pathField.getText();

  152. //     }

  153. 

  154.     public void setDirectoryName(String dirname) {

  155. 	pathField.setText(dirname);

  156.     }

  157. 

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

  159. 	// PENDING

  160.     }

  161. 

  162.     public void rescanCurrentDirectory(JFileChooser fc) {

  163. 	getModel().validateFileCache();

  164.     }

  165. 

  166.     protected JPanel getAccessoryPanel() {

  167. 	return accessoryPanel;

  168.     }

  169. 

  170.     private void updateDefaultButton() {

  171. 	JFileChooser filechooser = getFileChooser();

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

  173. 	if (root == null) {

  174. 	    return;

  175. 	}

  176. 

  177. 	if (filechooser.getControlButtonsAreShown()) {

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

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

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

  181. 	    }

  182. 	} else {

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

  184. 		root.setDefaultButton(null);

  185. 	    }

  186. 	}

  187.     }

  188. 

  189.     protected void doSelectedFileChanged(PropertyChangeEvent e) {

  190. 	super.doSelectedFileChanged(e);

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

  192. 	if (f != null) {

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

  194. 	}

  195.     }

  196. 

  197.     protected void doDirectoryChanged(PropertyChangeEvent e) {

  198. 	directoryList.clearSelection();

  199. 	fileList.clearSelection();

  200. 

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

  202. 	if (currentDirectory != null) {

  203. 	    try {

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

  205. 	    } catch (IOException ioe) {

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

  207. 	    }

  208. 	    directoryComboBoxModel.addItem(currentDirectory);

  209. 	}

  210. 	super.doDirectoryChanged(e);

  211.     }

  212. 

  213.     protected void doAccessoryChanged(PropertyChangeEvent e) {

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

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

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

  217. 	    }

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

  219. 	    if (accessory != null) {

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

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

  222. 		getAccessoryPanel().setMaximumSize(MAX_SIZE);

  223. 	    } else {

  224. 		getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);

  225. 		getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);

  226. 	    }

  227. 	}

  228.     }

  229. 

  230.     protected void doFileSelectionModeChanged(PropertyChangeEvent e) {

  231. 	directoryList.clearSelection();

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

  233. 

  234. 	super.doFileSelectionModeChanged(e);

  235.     }

  236. 

  237.     protected void doMultiSelectionChanged(PropertyChangeEvent e) {

  238. 	if (getFileChooser().isMultiSelectionEnabled()) {

  239. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  240. 	} else {

  241. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  242. 	    fileList.clearSelection();

  243. 	}

  244. 

  245. 	super.doMultiSelectionChanged(e);

  246.     }

  247. 

  248.     protected void doControlButtonsChanged(PropertyChangeEvent e) {

  249. 	super.doControlButtonsChanged(e);

  250. 

  251. 	JFileChooser filechooser = getFileChooser();

  252. 	if (filechooser.getControlButtonsAreShown()) {

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

  254. 	} else {

  255. 	    filechooser.remove(bottomButtonPanel);

  256. 	}

  257. 	updateDefaultButton();

  258.     }

  259. 

  260.     protected void doAncestorChanged(PropertyChangeEvent e) {

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

  262. 	    // Ancestor was added, set initial focus

  263. 	    fileNameTextField.selectAll();

  264. 	    fileNameTextField.requestFocus();

  265. 	    updateDefaultButton();

  266. 	}

  267. 

  268. 	super.doAncestorChanged(e);

  269.     }

  270. 

  271. 

  272. 

  273.     // ********************************************

  274.     // ************ Create Listeners **************

  275.     // ********************************************

  276. 

  277.     public ListSelectionListener createListSelectionListener(JFileChooser fc) {

  278. 	return new SelectionListener();

  279.     }

  280. 

  281.     class DoubleClickListener extends MouseAdapter {

  282. 	JList list;

  283. 	public  DoubleClickListener(JList list) {

  284. 	    this.list = list;

  285. 	}

  286. 

  287. 	public void mouseClicked(MouseEvent e) {

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

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

  290. 		if (index >= 0) {

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

  292. 		    try {

  293. 			// Strip trailing ".."

  294. 			f = f.getCanonicalFile();

  295. 		    } catch (IOException ex) {

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

  297. 		    }

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

  299.                         list.clearSelection();

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

  301.                             rescanCurrentDirectory(getFileChooser());

  302.                         } else {

  303.                             getFileChooser().setCurrentDirectory(f);

  304.                         }

  305. 		    } else {

  306. 			getFileChooser().approveSelection();

  307. 		    }

  308. 		}

  309. 	    }

  310. 	}

  311.     }

  312. 

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

  314. 	return new DoubleClickListener(list);

  315.     }

  316. 

  317. 

  318. 

  319.     protected class SelectionListener implements ListSelectionListener {

  320. 	public void valueChanged(ListSelectionEvent e) {

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

  322. 		JFileChooser chooser = getFileChooser();

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

  324. 

  325. 		if (chooser.isMultiSelectionEnabled()) {

  326. 		    File[] files = null;

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

  328. 		    if (objects != null) {

  329. 			if (objects.length == 1

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

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

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

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

  334. 			    setDirectorySelected(true);

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

  336. 			} else {

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

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

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

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

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

  342. 				    fList.add(f);

  343. 				}

  344. 			    }

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

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

  347. 			    }

  348. 			    setDirectorySelected(false);

  349. 			}

  350. 		    }

  351. 		    chooser.setSelectedFiles(files);

  352. 		} else {

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

  354. 		    if (file != null

  355. 			&& file.isDirectory()

  356. 			&& chooser.isTraversable(file)

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

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

  359. 

  360. 			setDirectorySelected(true);

  361. 			setDirectory(file);

  362. 		    } else {

  363. 			setDirectorySelected(false);

  364. 			if (file != null) {

  365. 			    chooser.setSelectedFile(file);

  366. 			}

  367. 		    }

  368. 		}

  369. 	    }

  370. 	}

  371.     }

  372. 

  373. 

  374.     //

  375.     // ComponentUI Interface Implementation methods

  376.     //

  377.     public static ComponentUI createUI(JComponent c) {

  378.         return new GTKFileChooserUI();

  379.     }

  380. 

  381.     public void installUI(JComponent c) {

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

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

  384. 

  385. 	super.installUI(c);

  386.     }

  387. 

  388.     public void uninstallUI(JComponent c) {

  389. 	super.uninstallUI(c);

  390. 

  391. 	if (accessoryPanel != null) {

  392. 	    accessoryPanel.removeAll();

  393. 	}

  394. 	accessoryPanel = null;

  395. 	getFileChooser().removeAll();

  396.     }

  397. 

  398.     public void installComponents(JFileChooser fc) {

  399. 	super.installComponents(fc);

  400. 

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

  402. 

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

  404. 	fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);

  405. 

  406. 	// Top row of buttons

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

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

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

  410. 

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

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

  413. 	newFolderButton.setMnemonic(newFolderButtonMnemonic);

  414. 	newFolderButton.setToolTipText(newFolderButtonToolTipText);

  415. 	newFolderButton.setText(newFolderButtonText);

  416. 	topButtonPanel.add(newFolderButton);

  417. 

  418. 	JButton deleteFileButton = new JButton(deleteFileButtonText);

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

  420. 	deleteFileButton.setMnemonic(deleteFileButtonMnemonic);

  421. 	deleteFileButton.setToolTipText(deleteFileButtonToolTipText);

  422. 	deleteFileButton.setEnabled(false);

  423. 	topButtonPanel.add(deleteFileButton);

  424. 

  425.         RenameFileAction rfa = new RenameFileAction();

  426.         JButton renameFileButton = new JButton(rfa);

  427.         renameFileButton.setText(renameFileButtonText); 

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

  429. 	renameFileButton.setMnemonic(renameFileButtonMnemonic);

  430. 	renameFileButton.setToolTipText(renameFileButtonToolTipText);

  431. 	topButtonPanel.add(renameFileButton);

  432. 

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

  434. 

  435. 

  436. 	JPanel interior = new JPanel();

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

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

  439. 	align(interior);

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

  441. 

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

  443. 

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

  445.                                                          0, 0) {

  446.             public void layoutContainer(Container target) {

  447.                 super.layoutContainer(target);

  448.                 JComboBox comboBox = directoryComboBox;

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

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

  451.                                        comboBox.getHeight());

  452.                 }

  453.             }

  454.         });

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

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

  457. 	// CurrentDir ComboBox

  458. 	directoryComboBoxModel = createDirectoryComboBoxModel(fc);

  459. 	directoryComboBox = new JComboBox(directoryComboBoxModel);

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

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

  462. 	directoryComboBox.addActionListener(directoryComboBoxAction);

  463. 	directoryComboBox.setRenderer(createDirectoryComboBoxRenderer(fc));

  464. 	directoryComboBox.setMaximumRowCount(8);

  465.         comboBoxPanel.add(directoryComboBox);

  466. 	interior.add(comboBoxPanel);

  467. 

  468. 

  469. 	// interior.add(Box.createRigidArea(vstrut10));

  470. 

  471. 

  472. 	// CENTER: left, right, accessory

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

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

  475. 

  476. 	// SPLIT PANEL: left, right

  477. 	JSplitPane splitPanel = new JSplitPane();

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

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

  480. 

  481. 	// left panel - Filter & directoryList

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

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

  484. 

  485. 	// Add the Directory List

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

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

  488. 	JComponent directoryListLabel =

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

  490. 								     false, false, 0, 0);

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

  492. 	leftPanel.add(directoryListLabel, new GridBagConstraints(

  493.                           0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,

  494.                           GridBagConstraints.HORIZONTAL,

  495.                           SynthLookAndFeel.EMPTY_UIRESOURCE_INSETS, 0, 0));

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

  497.                           0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,

  498.                           GridBagConstraints.BOTH,

  499.                           SynthLookAndFeel.EMPTY_UIRESOURCE_INSETS, 0, 0));

  500. 

  501. 

  502. 	// create files list

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

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

  505. 

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

  507. 	JComponent fileListLabel =

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

  509. 								     false, false, 0, 0);

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

  511. 	rightPanel.add(fileListLabel, new GridBagConstraints(

  512.                           0, 0, 1, 1, 1, 0, GridBagConstraints.WEST,

  513.                           GridBagConstraints.HORIZONTAL,

  514.                           SynthLookAndFeel.EMPTY_UIRESOURCE_INSETS,

  515.                           0, 0));

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

  517.                           0, 1, 1, 1, 1, 1, GridBagConstraints.EAST,

  518.                           GridBagConstraints.BOTH,

  519.                           SynthLookAndFeel.EMPTY_UIRESOURCE_INSETS, 0, 0));

  520. 

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

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

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

  524. 

  525. 	JComponent accessoryPanel = getAccessoryPanel();

  526. 	JComponent accessory = fc.getAccessory();

  527. 	if (accessoryPanel != null) {

  528. 	    if (accessory == null) {

  529. 		accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);

  530. 		accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);

  531. 	    } else {

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

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

  534. 		accessoryPanel.setMaximumSize(MAX_SIZE);

  535. 	    }

  536. 	    align(accessoryPanel);

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

  538. 	}

  539. 	interior.add(centerPanel);

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

  541. 

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

  543.                                                           0, 0));

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

  545. 	JLabel pathFieldLabel = new JLabel(pathLabelText);

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

  547. 	pathFieldLabel.setDisplayedMnemonic(pathLabelMnemonic);

  548. 	align(pathFieldLabel);

  549. 	pathFieldPanel.add(pathFieldLabel);

  550. 

  551. 	File currentDirectory = fc.getCurrentDirectory();

  552. 	String curDirName = null;

  553. 	if (currentDirectory != null) {

  554. 	    curDirName = currentDirectory.getPath();

  555. 	}

  556. 	pathField = new JLabel(curDirName) {

  557. 	    public Dimension getMaximumSize() {

  558. 		Dimension d = super.getMaximumSize();

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

  560. 		return d;

  561. 	    }

  562. 	};

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

  564. 	pathFieldLabel.setLabelFor(pathField);

  565. 	align(pathField);

  566. 	pathFieldPanel.add(pathField);

  567. 	interior.add(pathFieldPanel);

  568. 

  569. 	// add the fileName field

  570. 	fileNameTextField = new JTextField() {

  571. 	    public Dimension getMaximumSize() {

  572. 		Dimension d = super.getMaximumSize();

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

  574. 		return d;

  575. 	    }

  576. 	};

  577.         

  578.         Set forwardTraversalKeys = fileNameTextField.getFocusTraversalKeys(

  579.             KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);

  580.         forwardTraversalKeys = new HashSet(forwardTraversalKeys);

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

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

  583. 

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

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

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

  587. 	interior.add(fileNameTextField);

  588. 

  589. 	// Add buttons

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

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

  592. 	align(bottomButtonPanel);

  593. 

  594. 	JButton cancelButton = getCancelButton(fc);

  595. 	align(cancelButton);

  596. 	cancelButton.setMargin(buttonMargin);

  597. 	bottomButtonPanel.add(cancelButton);

  598. 

  599. 	JButton approveButton = getApproveButton(fc);;

  600. 	align(approveButton);

  601. 	approveButton.setMargin(buttonMargin);

  602. 	bottomButtonPanel.add(approveButton);

  603. 

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

  605.     }

  606. 

  607.     protected void installDefaults(JFileChooser jFileChooser) {

  608.         super.installDefaults(jFileChooser);

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

  610.     }

  611. 

  612.     protected void installStrings(JFileChooser fc) {

  613. 	super.installStrings(fc);

  614. 

  615.         Locale l = fc.getLocale();

  616. 

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

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

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

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

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

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

  623. 

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

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

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

  627. 

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

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

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

  631. 

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

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

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

  635. 

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

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

  638. 	

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

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

  641.     }

  642. 

  643.     protected void uninstallStrings(JFileChooser fc) {

  644. 	super.uninstallStrings(fc);

  645. 

  646. 	newFolderButtonText = null;

  647. 	deleteFileButtonText = null;

  648. 	renameFileButtonText = null;

  649. 

  650. 	newFolderButtonToolTipText = null;

  651. 	deleteFileButtonToolTipText = null;

  652. 	renameFileButtonToolTipText = null;

  653. 

  654.         renameFileDialogText = null; 

  655.         renameFileErrorTitle = null; 

  656.         renameFileErrorText = null; 

  657. 

  658. 	foldersLabelText = null;

  659. 	filesLabelText = null;

  660. 	

  661. 	pathLabelText = null;

  662.     }

  663. 

  664.     protected JScrollPane createFilesList() {

  665. 	fileList = new JList();

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

  667. 

  668. 	if (getFileChooser().isMultiSelectionEnabled()) {

  669. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  670. 	} else {

  671. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  672. 	}

  673. 	

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

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

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

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

  678. 	align(fileList);

  679. 	JScrollPane scrollpane = new JScrollPane(fileList);

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

  681. 	scrollpane.setPreferredSize(prefListSize);

  682. 	scrollpane.setMaximumSize(MAX_SIZE);

  683. 	align(scrollpane);

  684. 	return scrollpane;

  685.     }

  686. 

  687.     protected JScrollPane createDirectoryList() {

  688. 	directoryList = new JList();

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

  690. 	align(directoryList);

  691. 

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

  693. 	directoryList.setModel(new GTKDirectoryListModel());

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

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

  696. 

  697. 	JScrollPane scrollpane = new JScrollPane(directoryList);

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

  699. 	scrollpane.setMaximumSize(MAX_SIZE);

  700. 	scrollpane.setPreferredSize(prefListSize);

  701. 	align(scrollpane);

  702. 	return scrollpane;

  703.     }

  704. 

  705.     protected void createModel() {

  706.         model = new GTKDirectoryModel();

  707.     }

  708. 

  709.     public BasicDirectoryModel getModel() {

  710.         return model;

  711.     }

  712. 

  713.     public Action getApproveSelectionAction() {

  714.         return approveSelectionAction;

  715.     }

  716. 

  717.     private class GTKDirectoryModel extends BasicDirectoryModel {

  718.         FileSystemView fsv;

  719.         private Comparator fileComparator = new Comparator() {

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

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

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

  723.             }

  724.         };

  725. 

  726.         public GTKDirectoryModel() {

  727.             super(getFileChooser());

  728.         }

  729. 

  730.         protected void sort(Vector v) {

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

  732.             Collections.sort(v, fileComparator);

  733.         }

  734.     }

  735. 

  736.     protected class GTKDirectoryListModel extends AbstractListModel implements ListDataListener {

  737.         File curDir;

  738. 	public GTKDirectoryListModel() {

  739. 	    getModel().addListDataListener(this);

  740. 	}

  741. 

  742. 	public int getSize() {

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

  744. 	}

  745. 

  746. 	public Object getElementAt(int index) {

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

  748.                     curDir;

  749. 	}

  750. 

  751. 	public void intervalAdded(ListDataEvent e) {

  752.             fireContentsChanged();

  753. 	}

  754. 

  755. 	// PENDING - implement

  756. 	public void intervalRemoved(ListDataEvent e) {

  757.             fireContentsChanged();

  758. 	}

  759. 

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

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

  762. 	// whole list has changed.

  763. 	public void fireContentsChanged() {

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

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

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

  767. 	}

  768. 

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

  770. 	// out that everything has changed

  771. 	public void contentsChanged(ListDataEvent e) {

  772. 	    fireContentsChanged();

  773. 	}

  774. 

  775.     }

  776. 

  777.     protected class GTKFileListModel extends AbstractListModel implements ListDataListener {

  778. 	public GTKFileListModel() {

  779. 	    getModel().addListDataListener(this);

  780. 	}

  781. 

  782. 	public int getSize() {

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

  784. 	}

  785. 

  786. 	public boolean contains(Object o) {

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

  788. 	}

  789. 

  790. 	public int indexOf(Object o) {

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

  792. 	}

  793. 

  794. 	public Object getElementAt(int index) {

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

  796. 	}

  797. 

  798. 	public void intervalAdded(ListDataEvent e) {

  799.             fireContentsChanged();

  800. 	}

  801. 

  802. 	public void intervalRemoved(ListDataEvent e) {

  803.             fireContentsChanged();

  804. 	}

  805. 

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

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

  808. 	// whole list has changed.

  809. 	public void fireContentsChanged() {

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

  811. 	}

  812. 

  813. 	// PENDING - fire the interval changed

  814. 	public void contentsChanged(ListDataEvent e) {

  815. 	    fireContentsChanged();

  816. 	}

  817. 

  818.     }

  819. 

  820. 

  821.     protected class FileCellRenderer extends DefaultListCellRenderer  {

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

  823. 						      boolean isSelected, boolean cellHasFocus) {

  824. 

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

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

  827. 	    return this;

  828. 	}

  829. 

  830.         public boolean isOpaque() { 

  831.             Color back = getBackground();

  832.             Component p = getParent(); 

  833.             if (p != null) { 

  834.                 p = p.getParent(); 

  835.             }

  836.             // p should now be the JList. 

  837.             boolean colorMatch = (back != null) && (p != null) && 

  838.                 back.equals(p.getBackground()) && 

  839.                             p.isOpaque();

  840.             return !colorMatch && super.isOpaque(); 

  841.         }

  842.     }

  843. 

  844.     protected class DirectoryCellRenderer extends DefaultListCellRenderer  {

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

  846. 						      boolean isSelected, boolean cellHasFocus) {

  847. 

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

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

  850. 	    return this;

  851. 	}

  852. 

  853.         public boolean isOpaque() { 

  854.             Color back = getBackground();

  855.             Component p = getParent(); 

  856.             if (p != null) { 

  857.                 p = p.getParent(); 

  858.             }

  859.             // p should now be the JList. 

  860.             boolean colorMatch = (back != null) && (p != null) && 

  861.                 back.equals(p.getBackground()) && 

  862.                             p.isOpaque();

  863.             return !colorMatch && super.isOpaque(); 

  864.         }

  865.     }

  866. 

  867.     public Dimension getPreferredSize(JComponent c) {

  868. 	Dimension prefSize = new Dimension(PREF_SIZE);

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

  870. 	if (accessory != null) {

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

  872. 	}

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

  874. 	if (d != null) {

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

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

  877. 	} else {

  878. 	    return prefSize;

  879. 	}

  880.     }

  881. 

  882.     public Dimension getMinimumSize(JComponent x)  {

  883. 	return new Dimension(MIN_SIZE);

  884.     }

  885. 

  886.     public Dimension getMaximumSize(JComponent x) {

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

  888.     }

  889. 

  890.     protected void align(JComponent c) {

  891. 	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  892. 	c.setAlignmentY(JComponent.TOP_ALIGNMENT);

  893.     }

  894. 

  895.     protected DirectoryComboBoxRenderer createDirectoryComboBoxRenderer(JFileChooser fc) {

  896. 	return new DirectoryComboBoxRenderer();

  897.     }

  898. 

  899.     public Action getNewFolderAction() {

  900.         if (newFolderAction == null) {

  901.             newFolderAction = new NewFolderAction();

  902.             newFolderAction.setEnabled(!readOnly);

  903.         }

  904.         return newFolderAction;

  905.     }

  906. 

  907.     //

  908.     // Renderer for DirectoryComboBox

  909.     //

  910.     class DirectoryComboBoxRenderer extends SynthComboBoxUI.SynthComboBoxRenderer  {

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

  912. 						      int index, boolean isSelected,

  913. 						      boolean cellHasFocus) {

  914. 

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

  916. 

  917. 	    if (value == null) {

  918. 		setText("");

  919. 		return this;

  920. 	    }

  921. 	    setText(((File)value).getAbsolutePath());

  922. 

  923. 	    return this;

  924. 	}

  925.     }

  926. 

  927. 

  928.     //

  929.     // DataModel for DirectoryComboxbox

  930.     //

  931.     protected DirectoryComboBoxModel createDirectoryComboBoxModel(JFileChooser fc) {

  932. 	return new DirectoryComboBoxModel();

  933.     }

  934. 

  935.     /**

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

  937.      */

  938.     protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {

  939. 	Vector directories = new Vector();

  940. 	File selectedDirectory = null;

  941. 	JFileChooser chooser = getFileChooser();

  942. 	FileSystemView fsv = chooser.getFileSystemView();

  943. 

  944. 	public DirectoryComboBoxModel() {

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

  946. 	    // selectedDirectory

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

  948. 	    if (dir != null) {

  949. 		addItem(dir);

  950. 	    }

  951. 	}

  952. 

  953. 	/**

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

  955. 	 * additionally clears out the previous selected directory and

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

  957. 	 */

  958. 	private void addItem(File directory) {

  959. 

  960. 	    if (directory == null) {

  961. 		return;

  962. 	    }

  963. 

  964.             int oldSize = directories.size();

  965. 	    directories.clear();

  966.             if (oldSize > 0) {

  967.                 fireIntervalRemoved(this, 0, oldSize);

  968.             }

  969. 

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

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

  972. 	    // for example /foo/bar/ becomes /foo/bar

  973. 	    File canonical = null;

  974. 	    try {

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

  976. 	    } catch (IOException e) {

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

  978. 		canonical = directory;

  979. 	    }

  980. 

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

  982. 	    File f = canonical;

  983. 	    do {

  984. 		directories.add(f);

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

  986.             int newSize = directories.size();

  987.             if (newSize > 0) {

  988.                 fireIntervalAdded(this, 0, newSize);

  989.             }

  990. 	    setSelectedItem(canonical);

  991. 	}

  992. 

  993. 	public void setSelectedItem(Object selectedDirectory) {

  994. 	    this.selectedDirectory = (File)selectedDirectory;

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

  996. 	}

  997. 

  998. 	public Object getSelectedItem() {

  999. 	    return selectedDirectory;

  1000. 	}

  1001. 

  1002. 	public int getSize() {

  1003. 	    return directories.size();

  1004. 	}

  1005. 

  1006. 	public Object getElementAt(int index) {

  1007. 	    return directories.elementAt(index);

  1008. 	}

  1009.     }

  1010. 

  1011.     /**

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

  1013.      */

  1014.     protected class DirectoryComboBoxAction extends AbstractAction {

  1015. 	protected DirectoryComboBoxAction() {

  1016. 	    super("DirectoryComboBoxAction");

  1017. 	}

  1018. 

  1019. 	public void actionPerformed(ActionEvent e) {

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

  1021. 	    getFileChooser().setCurrentDirectory(f);

  1022. 	}

  1023.     }

  1024. 

  1025.     /**

  1026.      * Creates a new folder.

  1027.      */

  1028.     private class NewFolderAction extends AbstractAction {

  1029.         protected NewFolderAction() {

  1030.             super("New Folder");

  1031.         }

  1032.         public void actionPerformed(ActionEvent e) {

  1033.             if (readOnly) {

  1034.                 return;

  1035.             }

  1036.             JFileChooser fc = getFileChooser();

  1037.             File currentDirectory = fc.getCurrentDirectory();

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

  1039.                     newFolderDialogText, newFolderButtonText, 

  1040.                     JOptionPane.PLAIN_MESSAGE);

  1041.             

  1042.             if (dirName != null) {

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

  1044.                         (currentDirectory, dirName);

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

  1046.                     JOptionPane.showMessageDialog(fc,

  1047.                             newFolderErrorText + newFolderErrorSeparator + " \"" + 

  1048.                             dirName + "\"",

  1049.                             newFolderErrorText, JOptionPane.ERROR_MESSAGE);

  1050.                 }

  1051.                 fc.rescanCurrentDirectory();

  1052.             }

  1053.         }

  1054.     }

  1055. 

  1056.     private class GTKApproveSelectionAction extends ApproveSelectionAction {

  1057.         public void actionPerformed(ActionEvent e) {

  1058.             if (isDirectorySelected()) {

  1059.                 File dir = getDirectory();

  1060.                 try {

  1061.                     if (dir != null) {

  1062.                         dir = dir.getCanonicalFile();

  1063.                     }

  1064.                     // Strip trailing ".."

  1065.                 } catch (IOException ex) {

  1066.                     // Ok, use f as is

  1067.                 }

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

  1069.                     directoryList.clearSelection();

  1070.                     rescanCurrentDirectory(getFileChooser());

  1071.                     return;

  1072.                 }

  1073.             }

  1074.             super.actionPerformed(e);

  1075.         }

  1076.     }

  1077. 

  1078.     /**

  1079.      * Renames file

  1080.      */

  1081.     private class RenameFileAction extends AbstractAction {

  1082.         protected RenameFileAction() {

  1083.             super("editFileName");

  1084.         }

  1085.         public void actionPerformed(ActionEvent e) {

  1086.             if (getFileName().equals("") || readOnly) {

  1087.                 return;

  1088.             }

  1089.             JFileChooser fc = getFileChooser();

  1090.             File currentDirectory = fc.getCurrentDirectory();

  1091.             String newFileName = (String) JOptionPane.showInputDialog

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

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

  1094.                            renameFileButtonText, JOptionPane.PLAIN_MESSAGE, null, null,

  1095.                            getFileName());

  1096.             

  1097.             if (newFileName != null) {

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

  1099.                         (currentDirectory, getFileName());

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

  1101.                         (currentDirectory, newFileName);

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

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

  1104.                     JOptionPane.showMessageDialog(fc,

  1105.                             new MessageFormat(renameFileErrorText).

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

  1107.                             renameFileErrorTitle, JOptionPane.ERROR_MESSAGE);

  1108.                 } else {

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

  1110.                     fc.rescanCurrentDirectory();

  1111.                 }

  1112.             }

  1113.         }

  1114.     }

  1115. }