1. /*

  2.  * @(#)MetalFileChooserUI.java	1.34 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package javax.swing.plaf.metal;

  12. 

  13. import javax.swing.*;

  14. import javax.swing.filechooser.*;

  15. import javax.swing.event.*;

  16. import javax.swing.plaf.*;

  17. import javax.swing.plaf.basic.*;

  18. import java.awt.*;

  19. import java.awt.event.*;

  20. import java.beans.*;

  21. import java.io.File;

  22. import java.io.IOException;

  23. import java.util.*;

  24. 

  25. /**

  26.  * Metal L&F implementation of a FileChooser.

  27.  *

  28.  * @version 1.34 02/02/00

  29.  * @author Jeff Dinkins

  30.  */

  31. public class MetalFileChooserUI extends BasicFileChooserUI {

  32. 

  33.     // The following are private because the implementation of the

  34.     // Metal FileChooser L&F is not complete yet.

  35.     private JPanel centerPanel;

  36. 

  37.     private JComboBox directoryComboBox;

  38.     private DirectoryComboBoxModel directoryComboBoxModel;

  39.     private Action directoryComboBoxAction = new DirectoryComboBoxAction();

  40. 

  41.     private FilterComboBoxModel filterComboBoxModel;

  42. 

  43.     private JTextField filenameTextField;

  44. 

  45.     private JList list;

  46. 

  47.     private JButton approveButton;

  48.     private JButton cancelButton;

  49.     private JButton upFolderButton;

  50. 

  51.     private JPanel buttonPanel;

  52.     private JPanel bottomPanel;

  53. 

  54.     private JComboBox filterComboBox;

  55. 

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

  57.     private static final Dimension hstrut25 = new Dimension(25, 1);

  58. 

  59.     private static final Dimension vstrut2  = new Dimension(1, 2);

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

  61.     private static final Dimension vstrut15 = new Dimension(1, 15);

  62.     private static final Dimension vstrut20 = new Dimension(1, 20);

  63. 

  64.     private Component bottomBox = Box.createRigidArea(hstrut10);

  65. 

  66.     private static final Insets shrinkwrap = new Insets(0,0,0,0);

  67. 

  68.     // Preferred and Minimum sizes for the dialog box

  69.     private static int PREF_WIDTH = 500;

  70.     private static int PREF_HEIGHT = 300;

  71.     private static Dimension PREF_SIZE = new Dimension(PREF_WIDTH, PREF_HEIGHT);

  72. 

  73.     private static int MIN_WIDTH = 400;

  74.     private static int MIN_HEIGHT = 200;

  75.     private static Dimension MIN_SIZE = new Dimension(MIN_WIDTH, MIN_HEIGHT);

  76. 

  77.     private static int LIST_MIN_WIDTH = 400;

  78.     private static int LIST_MIN_HEIGHT = 100;

  79.     private static Dimension LIST_MIN_SIZE = new Dimension(LIST_MIN_WIDTH, LIST_MIN_HEIGHT);

  80. 

  81. 

  82.     // Labels, mnemonics, and tooltips (oh my!)

  83.     private int    lookInLabelMnemonic = 0;

  84.     private String lookInLabelText = null;

  85. 

  86.     private int    fileNameLabelMnemonic = 0;

  87.     private String fileNameLabelText = null;

  88. 

  89.     private int    filesOfTypeLabelMnemonic = 0;

  90.     private String filesOfTypeLabelText = null;

  91. 

  92.     private String upFolderToolTipText = null;

  93.     private String upFolderAccessibleName = null;

  94. 

  95.     private String homeFolderToolTipText = null;

  96.     private String homeFolderAccessibleName = null;

  97. 

  98.     private String newFolderToolTipText = null;

  99.     private String newFolderAccessibleName = null;

  100. 

  101.     private String listViewButtonToolTipText = null;

  102.     private String listViewButtonAccessibleName = null;

  103. 

  104.     private String detailsViewButtonToolTipText = null;

  105.     private String detailsViewButtonAccessibleName = null;

  106. 

  107.     //

  108.     // ComponentUI Interface Implementation methods

  109.     //

  110.     public static ComponentUI createUI(JComponent c) {

  111.         return new MetalFileChooserUI((JFileChooser) c);

  112.     }

  113. 

  114.     public MetalFileChooserUI(JFileChooser filechooser) {

  115. 	super(filechooser);

  116.     }

  117. 

  118.     public void installUI(JComponent c) {

  119. 	super.installUI(c);

  120.     }

  121. 

  122.     public void uninstallComponents(JFileChooser fc) {

  123. 	fc.removeAll();

  124.     }

  125. 

  126.     public void installComponents(JFileChooser fc) {

  127. 	// set to a Y BoxLayout. The chooser will be layed out top to bottom.

  128. 	fc.setLayout(new BoxLayout(fc, BoxLayout.Y_AXIS));

  129. 	fc.add(Box.createRigidArea(vstrut10));

  130. 

  131. 	// ********************************* //

  132. 	// **** Construct the top panel **** //

  133. 	// ********************************* //

  134. 

  135. 	// Directory manipulation buttons

  136. 	JPanel topPanel = new JPanel();

  137. 	topPanel.setLayout(new BoxLayout(topPanel, BoxLayout.X_AXIS));

  138. 

  139. 	// Add the top panel to the fileChooser

  140. 	fc.add(topPanel);

  141. 	fc.add(Box.createRigidArea(vstrut10));

  142. 

  143. 	// ComboBox Label

  144.      	JLabel l = new JLabel(lookInLabelText);

  145.      	l.setDisplayedMnemonic(lookInLabelMnemonic);

  146. 	l.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  147. 	l.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  148. 	topPanel.add(Box.createRigidArea(new Dimension(14,0)));

  149. 	topPanel.add(l);

  150. 	topPanel.add(Box.createRigidArea(new Dimension(28,0)));

  151. 

  152. 	// CurrentDir ComboBox

  153. 	directoryComboBox = new JComboBox();

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

  155. 	l.setLabelFor(directoryComboBox);

  156. 	directoryComboBoxModel = createDirectoryComboBoxModel(fc);

  157. 	directoryComboBox.setModel(directoryComboBoxModel);

  158. 	directoryComboBox.addActionListener(directoryComboBoxAction);

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

  160. 	directoryComboBox.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  161. 	directoryComboBox.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  162. 

  163. 	topPanel.add(directoryComboBox);

  164. 	topPanel.add(Box.createRigidArea(hstrut10));

  165. 

  166. 	// Up Button

  167. 	upFolderButton = new JButton(upFolderIcon);

  168.      	upFolderButton.setToolTipText(upFolderToolTipText);

  169.      	upFolderButton.getAccessibleContext().setAccessibleName(upFolderAccessibleName);

  170. 	upFolderButton.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  171. 	upFolderButton.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  172. 	upFolderButton.setMargin(shrinkwrap);

  173. 

  174. 	upFolderButton.addActionListener(getChangeToParentDirectoryAction());

  175. 	topPanel.add(upFolderButton);

  176. 	topPanel.add(Box.createRigidArea(hstrut10));

  177. 

  178. 	// Home Button

  179. 	JButton b = new JButton(homeFolderIcon);

  180.      	b.setToolTipText(homeFolderToolTipText);

  181.      	b.getAccessibleContext().setAccessibleName(homeFolderAccessibleName);

  182. 	b.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  183. 	b.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  184. 	b.setMargin(shrinkwrap);

  185. 

  186. 	b.addActionListener(getGoHomeAction());

  187. 	topPanel.add(b);

  188. 	topPanel.add(Box.createRigidArea(hstrut10));

  189. 

  190. 	// New Directory Button

  191. 	b = new JButton(newFolderIcon);

  192.      	b.setToolTipText(newFolderToolTipText);

  193.      	b.getAccessibleContext().setAccessibleName(newFolderAccessibleName);

  194. 	b.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  195. 	b.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  196. 	b.setMargin(shrinkwrap);

  197. 

  198. 	b.addActionListener(getNewFolderAction());

  199. 	topPanel.add(b);

  200. 	topPanel.add(Box.createRigidArea(hstrut10));

  201. 

  202. 	// List Button

  203. 	JToggleButton tb = new JToggleButton(listViewIcon);

  204.      	tb.setToolTipText(listViewButtonToolTipText);

  205.      	tb.getAccessibleContext().setAccessibleName(listViewButtonAccessibleName);

  206. 	tb.setEnabled(false);

  207. 

  208. 	tb.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  209. 	tb.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  210. 	tb.setMargin(shrinkwrap);

  211. 	topPanel.add(tb);

  212. 

  213. 	// Details Button

  214. 	tb = new JToggleButton(detailsViewIcon);

  215.      	tb.setToolTipText(detailsViewButtonToolTipText);

  216.      	tb.getAccessibleContext().setAccessibleName(detailsViewButtonAccessibleName);

  217. 

  218. 	tb.setSelected(true);

  219. 	tb.setEnabled(false);

  220. 	tb.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  221. 	tb.setAlignmentY(JComponent.CENTER_ALIGNMENT);

  222. 	tb.setMargin(shrinkwrap);

  223. 	topPanel.add(tb);

  224. 	topPanel.add(Box.createRigidArea(hstrut10));

  225. 

  226. 	// ************************************** //

  227. 	// ******* Add the directory pane ******* //

  228. 	// ************************************** //

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

  230. 	JPanel p = createList(fc);

  231. 	p.setMinimumSize(LIST_MIN_SIZE);

  232. 	centerPanel.add(p, BorderLayout.CENTER);

  233. 	centerPanel.add(getAccessoryPanel(), BorderLayout.EAST);

  234. 	JComponent accessory = fc.getAccessory();

  235. 	if(accessory != null) {

  236. 	    getAccessoryPanel().add(accessory);

  237. 	}

  238. 	fc.add(centerPanel);

  239. 

  240. 	// ********************************** //

  241. 	// **** Construct the bottom panel ** //

  242. 	// ********************************** //

  243. 	getBottomPanel().setLayout(new BoxLayout(getBottomPanel(), BoxLayout.X_AXIS));

  244. 	getBottomPanel().add(Box.createRigidArea(hstrut10));

  245. 

  246. 	// Add the bottom panel to file chooser

  247. 	fc.add(Box.createRigidArea(vstrut10));

  248. 	fc.add(getBottomPanel());

  249. 	fc.add(Box.createRigidArea(vstrut10));

  250. 

  251. 	// labels

  252. 	JPanel labelPanel = new JPanel();

  253. 	labelPanel.setLayout(new BoxLayout(labelPanel, BoxLayout.Y_AXIS));

  254. 

  255.      	JLabel fnl = new JLabel(fileNameLabelText);

  256.      	fnl.setDisplayedMnemonic(fileNameLabelMnemonic);

  257. 	fnl.setAlignmentY(0);

  258. 	labelPanel.add(fnl);

  259. 

  260. 	labelPanel.add(Box.createRigidArea(vstrut20));

  261. 

  262.      	JLabel ftl = new JLabel(filesOfTypeLabelText);

  263.      	ftl.setDisplayedMnemonic(filesOfTypeLabelMnemonic);

  264. 	labelPanel.add(ftl);

  265. 

  266. 	getBottomPanel().add(labelPanel);

  267. 	getBottomPanel().add(Box.createRigidArea(new Dimension(15, 0)));

  268. 

  269. 	// file entry and filters

  270. 	JPanel fileAndFilterPanel = new JPanel();

  271. 	fileAndFilterPanel.setLayout(new BoxLayout(fileAndFilterPanel, BoxLayout.Y_AXIS));

  272. 	fileAndFilterPanel.add(Box.createRigidArea(vstrut2));

  273. 

  274. 	filenameTextField = new JTextField() {

  275. 	    public Dimension getMaximumSize() {

  276. 		return new Dimension(Short.MAX_VALUE, super.getPreferredSize().height);

  277. 	    }

  278. 	};

  279. 

  280. 	fnl.setLabelFor(filenameTextField);

  281. 	filenameTextField.addActionListener(getApproveSelectionAction());

  282.         filenameTextField.addFocusListener(

  283.                 new FocusAdapter() {

  284.                         public void focusGained(FocusEvent e) {

  285.                                 list.clearSelection();

  286.                         }

  287.                 }

  288.         );

  289. 

  290. 	File f = fc.getSelectedFile();

  291. 	if(f != null) {

  292. 	    setFileName(fc.getName(f));

  293. 	}

  294. 

  295. 	fileAndFilterPanel.add(filenameTextField);

  296. 	fileAndFilterPanel.add(Box.createRigidArea(vstrut15));

  297. 

  298. 	filterComboBoxModel = createFilterComboBoxModel();

  299. 	fc.addPropertyChangeListener(filterComboBoxModel);

  300. 	filterComboBox = new JComboBox(filterComboBoxModel);

  301. 	ftl.setLabelFor(filterComboBox);

  302. 	filterComboBox.setRenderer(createFilterComboBoxRenderer());

  303. 	fileAndFilterPanel.add(filterComboBox);

  304. 

  305. 	getBottomPanel().add(fileAndFilterPanel);

  306. 	getBottomPanel().add(Box.createRigidArea(hstrut10));

  307. 

  308. 	// buttons

  309. 	getButtonPanel().setLayout(new BoxLayout(getButtonPanel(), BoxLayout.Y_AXIS));

  310. 

  311. 	approveButton = new JButton(getApproveButtonText(fc)) {

  312. 	    public Dimension getMaximumSize() {

  313. 		return approveButton.getPreferredSize().width > cancelButton.getPreferredSize().width ?

  314. 		       approveButton.getPreferredSize() : cancelButton.getPreferredSize();

  315. 	    }

  316. 	}; 

  317. 	approveButton.setMnemonic(getApproveButtonMnemonic(fc));

  318. 	approveButton.addActionListener(getApproveSelectionAction());

  319. 	approveButton.setToolTipText(getApproveButtonToolTipText(fc));

  320. 	getButtonPanel().add(approveButton);

  321. 	getButtonPanel().add(Box.createRigidArea(vstrut10));

  322. 

  323. 	cancelButton = new JButton(cancelButtonText) {

  324. 	    public Dimension getMaximumSize() {

  325. 		return approveButton.getPreferredSize().width > cancelButton.getPreferredSize().width ?

  326. 		       approveButton.getPreferredSize() : cancelButton.getPreferredSize();

  327. 	    }

  328. 	}; 

  329. 	cancelButton.setMnemonic(cancelButtonMnemonic);

  330. 	cancelButton.setToolTipText(cancelButtonToolTipText);

  331. 	cancelButton.addActionListener(getCancelSelectionAction());

  332. 	getButtonPanel().add(cancelButton);

  333. 

  334. 	if(fc.getControlButtonsAreShown()) {

  335. 	    addControlButtons();

  336. 	}

  337.     }

  338. 

  339.     protected JPanel getButtonPanel() {

  340. 	if(buttonPanel == null) {

  341. 	    buttonPanel = new JPanel();

  342. 	}

  343. 	return buttonPanel;

  344.     }

  345. 

  346.     protected JPanel getBottomPanel() {

  347. 	if(bottomPanel == null) {

  348. 	    bottomPanel = new JPanel();

  349. 	}

  350. 	return bottomPanel;

  351.     }

  352. 

  353.     protected void installStrings(JFileChooser fc) {

  354. 	super.installStrings(fc);

  355. 

  356. 	lookInLabelMnemonic = UIManager.getInt("FileChooser.lookInLabelMnemonic"); 

  357. 	lookInLabelText = UIManager.getString("FileChooser.lookInLabelText");

  358. 	

  359. 	fileNameLabelMnemonic = UIManager.getInt("FileChooser.fileNameLabelMnemonic");  

  360. 	fileNameLabelText = UIManager.getString("FileChooser.fileNameLabelText"); 

  361. 	

  362. 	filesOfTypeLabelMnemonic = UIManager.getInt("FileChooser.filesOfTypeLabelMnemonic");  

  363. 	filesOfTypeLabelText = UIManager.getString("FileChooser.filesOfTypeLabelText"); 

  364. 	

  365. 	upFolderToolTipText =  UIManager.getString("FileChooser.upFolderToolTipText");

  366. 	upFolderAccessibleName = UIManager.getString("FileChooser.upFolderAccessibleName"); 

  367. 	

  368. 	homeFolderToolTipText =  UIManager.getString("FileChooser.homeFolderToolTipText");

  369. 	homeFolderAccessibleName = UIManager.getString("FileChooser.homeFolderAccessibleName"); 

  370. 	

  371. 	newFolderToolTipText = UIManager.getString("FileChooser.newFolderToolTipText");

  372. 	newFolderAccessibleName = UIManager.getString("FileChooser.newFolderAccessibleName"); 

  373. 	

  374. 	listViewButtonToolTipText = UIManager.getString("FileChooser.listViewButtonToolTipText"); 

  375. 	listViewButtonAccessibleName = UIManager.getString("FileChooser.listViewButtonAccessibleName"); 

  376. 	

  377. 	detailsViewButtonToolTipText = UIManager.getString("FileChooser.detailsViewButtonToolTipText"); 

  378. 	detailsViewButtonAccessibleName = UIManager.getString("FileChooser.detailsViewButtonAccessibleName"); 

  379.     }

  380. 

  381.     protected void installListeners(JFileChooser fc) {

  382. 	super.installListeners(fc);

  383.         ActionMap actionMap = getActionMap();

  384.         SwingUtilities.replaceUIActionMap(fc, actionMap);

  385.     }

  386. 

  387.     protected ActionMap getActionMap() {

  388.         return createActionMap();

  389.     }

  390. 

  391.     protected ActionMap createActionMap() {

  392.         AbstractAction escAction = new AbstractAction() {

  393.             public void actionPerformed(ActionEvent e) {

  394. 		if(editing) {

  395.     		   cancelEdit();

  396. 	           list.repaint();

  397. 		} else {

  398.                    getFileChooser().cancelSelection();

  399. 		}

  400.             }

  401.             public boolean isEnabled(){

  402.                 return getFileChooser().isEnabled();

  403.             }

  404.         };

  405.         ActionMap map = new ActionMapUIResource();

  406.         map.put("cancelSelection", escAction);

  407.         return map;

  408.     }

  409. 

  410.     protected JPanel createList(JFileChooser fc) {

  411. 	JPanel p = new JPanel(new BorderLayout());

  412. 	list = new JList();

  413. 	list.setCellRenderer(new FileRenderer());

  414. 

  415. 	if(fc.isMultiSelectionEnabled()) {

  416. 	    list.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  417. 	} else {

  418. 	    list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  419. 	}

  420. 

  421. 	list.setModel(getModel());

  422. 	list.addListSelectionListener(createListSelectionListener(fc));

  423. 	list.addMouseListener(createDoubleClickListener(fc, list));

  424. 	list.addMouseListener(createSingleClickListener(fc, list));

  425. 	JScrollPane scrollpane = new JScrollPane(list);

  426. 

  427. 

  428. 	p.add(scrollpane, BorderLayout.CENTER);

  429. 	return p;

  430.     }

  431. 

  432.     private MouseListener createSingleClickListener(JFileChooser fc, JList list) {

  433. 	return new SingleClickListener(list);

  434.     }

  435. 

  436.     int lastIndex = -1;

  437.     boolean editing = false;

  438.     int editX = 20;

  439.     int editWidth = 200;

  440. 

  441.     private void setEditIndex(int i) {

  442. 	lastIndex = i;

  443.     }

  444. 

  445.     private void resetEditIndex() {

  446. 	lastIndex = -1;

  447.     }

  448. 

  449.     private void cancelEdit() {

  450. 	editing = false;

  451. 	if(editCell != null) {

  452. 	    list.remove(editCell);

  453. 	}

  454.     }

  455. 

  456.     JTextField editCell = null;

  457.     protected class SingleClickListener extends MouseAdapter {

  458. 	JList list;

  459. 

  460. 	public  SingleClickListener(JList list) {

  461. 	    this.list = list;

  462. 	    editCell = new JTextField();

  463. 	    editCell.addActionListener(new EditActionListener());

  464. 	}

  465. 

  466. 	public void mouseClicked(MouseEvent e) {

  467. 	    if (e.getClickCount() == 1) {

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

  469.                 if(index >= 0 && lastIndex == index && editing == false) {

  470. 		    editing = true;

  471. 		    Rectangle r = list.getCellBounds(index, index);

  472. 		    list.add(editCell);

  473. 		    File f = (File) list.getSelectedValue();

  474. 		    editCell.setText(getFileChooser().getName(f));

  475. 		    editCell.setBounds(editX + r.x, r.y, editWidth, r.height);

  476. 		    editCell.selectAll();

  477. 		} else {

  478. 		    if(index >= 0) {

  479. 			setEditIndex(index);

  480. 		    } else {

  481. 			resetEditIndex();

  482. 		    }

  483. 		    cancelEdit();

  484. 		}

  485. 	    } else {

  486. 		// on double click (open or drill down one directory) be

  487. 		// sure to clear the edit index

  488. 		resetEditIndex();

  489. 		cancelEdit();

  490. 	    }

  491. 	    list.repaint();

  492. 	    

  493. 	}

  494. 

  495.     }

  496. 

  497.     class EditActionListener implements ActionListener {

  498. 	public void actionPerformed(ActionEvent e) {

  499. 	    JTextField tf = (JTextField) e.getSource();

  500. 	    File f = (File) list.getSelectedValue();

  501. 	    String newFileName = tf.getText();

  502. 	    newFileName = newFileName.trim();

  503. 	    if(!newFileName.equals(getFileChooser().getName(f))) {

  504. 		// rename

  505.                 File f2 = getFileChooser().getFileSystemView().createFileObject(

  506.                         getFileChooser().getCurrentDirectory(), newFileName

  507.                 );

  508. 

  509. 		if(f.renameTo(f2)) {

  510. 		    rescanCurrentDirectory(getFileChooser());

  511. 		} else {

  512. 		    // PENDING(jeff) - show a dialog indicating failure

  513. 		}

  514. 	    }

  515. 	    cancelEdit();

  516. 	    list.repaint();

  517. 	} 

  518.     }

  519. 

  520.     protected class FileRenderer extends DefaultListCellRenderer  {

  521. 

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

  523. 						      int index, boolean isSelected,

  524. 						      boolean cellHasFocus) {

  525. 

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

  527. 	    File file = (File) value;

  528. 	    String fileName = getFileChooser().getName(file);

  529. 	    setText(fileName);

  530. 

  531. 	    Icon icon = getFileChooser().getIcon(file);

  532. 	    setIcon(icon);

  533. 

  534. 	    if(isSelected) {

  535. 		// PENDING(jeff) - grab padding (4) below from defaults table.

  536. 		editX = icon.getIconWidth() + 4;

  537. 	    }

  538. 

  539. 	    return this;

  540. 	}

  541.     }

  542. 

  543.     public void uninstallUI(JComponent c) {

  544. 	// Remove listeners

  545. 	c.removePropertyChangeListener(filterComboBoxModel);

  546. 	cancelButton.removeActionListener(getCancelSelectionAction());

  547. 	approveButton.removeActionListener(getApproveSelectionAction());

  548. 	filenameTextField.removeActionListener(getApproveSelectionAction());

  549. 

  550. 	super.uninstallUI(c);

  551.     }

  552. 

  553.     public Dimension getPreferredSize(JComponent c) {

  554. 	return PREF_SIZE;

  555.     }

  556. 

  557.     public Dimension getMinimumSize(JComponent c) {

  558. 	return MIN_SIZE;

  559.     }

  560. 

  561.     public Dimension getMaximumSize(JComponent c) {

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

  563.     }

  564. 

  565.     void setFileSelected() {

  566. 	File f = getFileChooser().getSelectedFile();

  567. 	if(f != null && getModel().contains(f)) {

  568. 	    list.setSelectedIndex(getModel().indexOf(f));

  569. 	    list.ensureIndexIsVisible(list.getSelectedIndex());

  570. 	} else {

  571. 	    list.clearSelection();

  572. 	}

  573.     }

  574. 

  575. 

  576.     /* The following are used by the PropertyChange Listener */

  577.     private void doSelectedFileChanged(PropertyChangeEvent e) {

  578. 	cancelEdit();

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

  580. 	if(f != null) {

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

  582. 	} else {

  583. 	    setFileName(null);

  584. 	}

  585. 	setFileSelected();

  586.     }

  587.     

  588.     private void doDirectoryChanged(PropertyChangeEvent e) {

  589. 	cancelEdit();

  590. 	resetEditIndex();

  591. 	clearIconCache();

  592. 	list.clearSelection();

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

  594. 	if(currentDirectory != null) {

  595. 	    directoryComboBoxModel.addItem(currentDirectory);

  596. 	    // Enable the newFolder action if the current directory

  597. 	    // is writable.

  598. 	    // PENDING(jeff) - broken - fix

  599. 	    getNewFolderAction().setEnabled(currentDirectory.canWrite());

  600. 	    if(currentDirectory.getParent() == null) {

  601.                 upFolderButton.setEnabled(false);

  602.             } else {

  603.                 upFolderButton.setEnabled(true);

  604.             }

  605. 	}

  606.     }

  607. 

  608.     private void doFilterChanged(PropertyChangeEvent e) {

  609. 	cancelEdit();

  610. 	resetEditIndex();

  611. 	clearIconCache();

  612. 	list.clearSelection();

  613.     }

  614. 

  615.     private void doFileSelectionModeChanged(PropertyChangeEvent e) {

  616. 	cancelEdit();

  617. 	resetEditIndex();

  618. 	clearIconCache();

  619. 	list.clearSelection();

  620.     }

  621. 

  622.     private void doMultiSelectionChanged(PropertyChangeEvent e) {

  623. 	if(getFileChooser().isMultiSelectionEnabled()) {

  624. 	    list.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  625. 	} else {

  626. 	    list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  627. 	    list.clearSelection();

  628. 	    getFileChooser().setSelectedFiles(null);

  629. 	}

  630.     }

  631.     

  632.     private void doAccessoryChanged(PropertyChangeEvent e) {

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

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

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

  636. 	    }

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

  638. 	    if(accessory != null) {

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

  640. 	    }

  641. 	}

  642.     }

  643. 

  644.     private void doApproveButtonTextChanged(PropertyChangeEvent e) {

  645. 	JFileChooser chooser = getFileChooser();

  646. 	approveButton.setText(getApproveButtonText(chooser));

  647. 	approveButton.setToolTipText(getApproveButtonToolTipText(chooser));

  648. 	approveButton.setMnemonic(getApproveButtonMnemonic(chooser));

  649.     }

  650. 

  651.     private void doDialogTypeChanged(PropertyChangeEvent e) {

  652. 	JFileChooser chooser = getFileChooser();

  653. 	approveButton.setText(getApproveButtonText(chooser));

  654. 	approveButton.setToolTipText(getApproveButtonToolTipText(chooser));

  655. 	approveButton.setMnemonic(getApproveButtonMnemonic(chooser));

  656.     }

  657. 

  658.     private void doApproveButtonMnemonicChanged(PropertyChangeEvent e) {

  659. 	approveButton.setMnemonic(getApproveButtonMnemonic(getFileChooser()));

  660.     }

  661. 

  662.     private void doControlButtonsChanged(PropertyChangeEvent e) {

  663. 	if(getFileChooser().getControlButtonsAreShown()) {

  664. 	    addControlButtons();

  665. 	} else {

  666. 	    removeControlButtons();

  667. 	}

  668.     }

  669. 

  670.     /*

  671.      * Listen for filechooser property changes, such as

  672.      * the selected file changing, or the type of the dialog changing.

  673.      */

  674.     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

  675. 	return new PropertyChangeListener() {

  676. 	    public void propertyChange(PropertyChangeEvent e) {

  677. 		String s = e.getPropertyName();

  678. 		if(s.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)) {

  679. 		    doSelectedFileChanged(e);

  680. 		} else if(s.equals(JFileChooser.DIRECTORY_CHANGED_PROPERTY)) {

  681. 		    doDirectoryChanged(e);

  682. 		} else if(s.equals(JFileChooser.FILE_FILTER_CHANGED_PROPERTY)) {

  683. 		    doFilterChanged(e);

  684. 		} else if(s.equals(JFileChooser.FILE_SELECTION_MODE_CHANGED_PROPERTY)) {

  685. 		    doFileSelectionModeChanged(e);

  686. 		} else if(s.equals(JFileChooser.MULTI_SELECTION_ENABLED_CHANGED_PROPERTY)) {

  687. 		    doMultiSelectionChanged(e);

  688. 		} else if(s.equals(JFileChooser.ACCESSORY_CHANGED_PROPERTY)) {

  689. 		    doAccessoryChanged(e);

  690. 		} else if(s.equals(JFileChooser.APPROVE_BUTTON_TEXT_CHANGED_PROPERTY)) { 

  691. 		    doApproveButtonTextChanged(e);

  692. 		} else if(s.equals(JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY)) {

  693. 		    doDialogTypeChanged(e);

  694. 		} else if(s.equals(JFileChooser.APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY)) {

  695. 		    doApproveButtonMnemonicChanged(e);

  696. 		} else if(s.equals(JFileChooser.CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY)) {

  697. 		    doControlButtonsChanged(e);

  698. 		}

  699. 	    }

  700. 	};

  701.     }

  702. 

  703. 

  704.     protected void removeControlButtons() {

  705. 	getBottomPanel().remove(getButtonPanel());

  706. 	getBottomPanel().remove(bottomBox);

  707.     }

  708. 

  709.     protected void addControlButtons() {

  710. 	getBottomPanel().add(getButtonPanel());

  711. 	getBottomPanel().add(bottomBox);

  712.     }

  713. 

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

  715. 	if(getModel().contains(f)) {

  716. 	    list.ensureIndexIsVisible(getModel().indexOf(f));

  717. 	}

  718.     }

  719. 

  720.     public void rescanCurrentDirectory(JFileChooser fc) {

  721. 	getModel().invalidateFileCache();

  722. 	getModel().validateFileCache();

  723.     }

  724. 

  725.     public String getFileName() {

  726. 	if(filenameTextField != null) {

  727. 	    return filenameTextField.getText();

  728. 	} else {

  729. 	    return null;

  730. 	}

  731.     }

  732. 

  733.     public void setFileName(String filename) {

  734. 	if(filenameTextField != null) {

  735. 	    filenameTextField.setText(filename);

  736. 	}

  737.     }

  738. 

  739.     public String getDirectoryName() {

  740. 	// PENDING(jeff) - get the name from the directory combobox

  741. 	return null;

  742.     }

  743. 

  744.     public void setDirectoryName(String dirname) {

  745. 	// PENDING(jeff) - set the name in the directory combobox

  746.     }

  747. 

  748.     protected DirectoryComboBoxRenderer createDirectoryComboBoxRenderer(JFileChooser fc) {

  749. 	return new DirectoryComboBoxRenderer();

  750.     }

  751. 

  752.     //

  753.     // Renderer for DirectoryComboBox

  754.     //

  755.     class DirectoryComboBoxRenderer extends DefaultListCellRenderer  {

  756. 	IndentIcon ii = new IndentIcon();

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

  758. 						      int index, boolean isSelected,

  759. 						      boolean cellHasFocus) {

  760. 

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

  762. 

  763. 	    File directory = (File) value;

  764. 	    if(directory == null) {

  765. 		setText("");

  766. 		return this;

  767. 	    }

  768. 

  769.             setText(getFileChooser().getName(directory));

  770. 

  771. 	    // Find the depth of the directory

  772. 	    int depth = 0;

  773. 	    if(index != -1) {

  774. 		File f = directory;

  775. 		while(f.getParent() != null) {

  776. 		    depth++;

  777.                     f = getFileChooser().getFileSystemView().createFileObject(

  778.                         f.getParent()

  779.                     );

  780. 		}

  781. 	    }

  782. 	    

  783. 	    Icon icon = getFileChooser().getIcon(directory);

  784. 

  785. 	    ii.icon = icon;

  786. 	    ii.depth = depth;

  787. 	    

  788. 	    setIcon(ii);

  789. 

  790. 	    return this;

  791. 	}

  792.     }

  793. 

  794.     final static int space = 10;

  795.     class IndentIcon implements Icon {

  796. 

  797. 	Icon icon = null;

  798. 	int depth = 0;

  799. 

  800. 	public void paintIcon(Component c, Graphics g, int x, int y) {

  801. 	    icon.paintIcon(c, g, x+depth*space, y);

  802. 	}

  803. 

  804. 	public int getIconWidth() {

  805. 	    return icon.getIconWidth() + depth*space;

  806. 	}

  807. 

  808. 	public int getIconHeight() {

  809. 	    return icon.getIconHeight();

  810. 	}

  811. 

  812.     }

  813. 

  814.     //

  815.     // DataModel for DirectoryComboxbox

  816.     //

  817.     protected DirectoryComboBoxModel createDirectoryComboBoxModel(JFileChooser fc) {

  818. 	return new DirectoryComboBoxModel();

  819.     }

  820. 

  821.     /**

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

  823.      */

  824.     protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {

  825. 	Vector directories = new Vector();

  826. 	int topIndex = -1;

  827. 	int pathCount = 0;

  828. 

  829. 	File selectedDirectory = null;

  830. 

  831. 	public DirectoryComboBoxModel() {

  832. 	    super();

  833. 

  834. 	    // Add root files to the model

  835. 	    File[] roots = getFileChooser().getFileSystemView().getRoots();

  836. 	    for(int i = 0; i < roots.length; i++) {

  837. 		directories.addElement(roots[i]);

  838. 	    }

  839. 

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

  841. 	    // selectedDirectory

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

  843. 	    if(dir != null) {

  844. 		addItem(dir);

  845. 	    }

  846. 	}

  847. 

  848. 	/**

  849. 	 * Removes the selected directory, and clears out the

  850. 	 * path file entries leading up to that directory.

  851. 	 */

  852. 	private void removeSelectedDirectory() {

  853. 	    if(topIndex >= 0 ) {

  854. 		for(int i = topIndex; i < topIndex + pathCount; i++) {

  855. 		    directories.removeElementAt(topIndex+1);

  856. 		}

  857. 	    }

  858. 	    topIndex = -1;

  859. 	    pathCount = 0;

  860. 	    selectedDirectory = null;

  861. 	}

  862. 

  863. 	/**

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

  865. 	 * additionally clears out the previous selected directory and

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

  867. 	 */

  868. 	private void addItem(File directory) {

  869. 

  870. 	    if(directory == null) {

  871. 		return;

  872. 	    }

  873. 	    if(selectedDirectory != null) {

  874. 		removeSelectedDirectory();

  875. 	    }

  876. 

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

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

  879. 	    // for example /foo/bar/ becomes /foo/bar

  880. 	    File canonical = null;

  881. 	    try {

  882.                 canonical = getFileChooser().getFileSystemView().createFileObject(

  883.                     directory.getCanonicalPath()

  884.                 );

  885. 	    } catch (IOException e) {

  886. 		return; 

  887. 	    }

  888. 

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

  890. 	    File f = canonical;

  891. 	    Vector path = new Vector(10);

  892. 	    while(f.getParent() != null) {

  893. 		path.addElement(f);

  894. 		

  895. 		// Find the index of the top leveo of the passed

  896. 		// in directory

  897. 		if(directories.contains(f)) {

  898. 		    topIndex = directories.indexOf(f); 

  899. 		}

  900. 		

  901.                 f = getFileChooser().getFileSystemView().createFileObject(f.getParent());

  902. 	    }

  903. 	    pathCount = path.size();

  904. 	    

  905. 	    // if we didn't find the top index above, check

  906. 	    // the remaining parent

  907. 	    // PENDING(jeff) - if this fails, we need might

  908. 	    // need to scan all the other roots?

  909. 	    if(topIndex < 0) {

  910. 		if(directories.contains(f)) {

  911. 		    topIndex = directories.indexOf(f); 

  912. 		} else {

  913. 		    directories.addElement(f);

  914. 		}

  915. 	    }

  916. 

  917. 	    // insert all the path directories leading up to the

  918. 	    // selected directory.

  919. 	    for(int i = 0; i < path.size(); i++) {

  920. 		directories.insertElementAt(path.elementAt(i), topIndex+1);

  921. 	    }

  922. 

  923. 	    setSelectedItem(canonical);

  924. 	}

  925. 

  926. 	public void setSelectedItem(Object selectedDirectory) {

  927. 	    this.selectedDirectory = (File) selectedDirectory;

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

  929. 	}

  930. 

  931. 	public Object getSelectedItem() {

  932. 	    return selectedDirectory;

  933. 	}

  934. 

  935. 	public int getSize() {

  936. 	    return directories.size();

  937. 	}

  938. 

  939. 	public Object getElementAt(int index) {

  940. 	    return directories.elementAt(index);

  941. 	}

  942.     }

  943. 

  944.     //

  945.     // Renderer for Types ComboBox

  946.     //

  947.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  948. 	return new FilterComboBoxRenderer();

  949.     }

  950. 

  951.     /**

  952.      * Render different type sizes and styles.

  953.      */

  954.     public class FilterComboBoxRenderer extends DefaultListCellRenderer {

  955. 	public Component getListCellRendererComponent(JList list,

  956. 	    Object value, int index, boolean isSelected,

  957. 	    boolean cellHasFocus) {

  958. 

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

  960. 

  961. 	    FileFilter filter = (FileFilter) value;

  962. 	    if(filter != null) {

  963. 		setText(filter.getDescription());

  964. 	    }

  965. 

  966. 	    return this;

  967. 	}

  968.     }

  969. 

  970.     //

  971.     // DataModel for Types Comboxbox

  972.     //

  973.     protected FilterComboBoxModel createFilterComboBoxModel() {

  974. 	return new FilterComboBoxModel();

  975.     }

  976. 

  977.     /**

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

  979.      */

  980.     protected class FilterComboBoxModel extends AbstractListModel implements ComboBoxModel, PropertyChangeListener {

  981. 	protected FileFilter[] filters;

  982. 	protected FilterComboBoxModel() {

  983. 	    super();

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

  985. 	}

  986. 

  987. 	public void propertyChange(PropertyChangeEvent e) {

  988. 	    String prop = e.getPropertyName();

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

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

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

  992. 	    }

  993. 	}

  994. 

  995. 	public void setSelectedItem(Object filter) {

  996. 	    if(filter != null) {

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

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

  999. 	    }

  1000. 	}

  1001. 

  1002. 	public Object getSelectedItem() {

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

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

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

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

  1007. 	    // setFileFilter in JFileChooser.

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

  1009. 	    boolean found = false;

  1010. 	    if(currentFilter != null) {

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

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

  1013. 			found = true;

  1014. 		    }

  1015. 		}

  1016. 		if(found == false) {

  1017. 		    getFileChooser().addChoosableFileFilter(currentFilter);

  1018. 		}

  1019. 	    }

  1020. 	    return getFileChooser().getFileFilter();

  1021. 	}

  1022. 

  1023. 	public int getSize() {

  1024. 	    if(filters != null) {

  1025. 		return filters.length;

  1026. 	    } else {

  1027. 		return 0;

  1028. 	    }

  1029. 	}

  1030. 

  1031. 	public Object getElementAt(int index) {

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

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

  1034. 		return getFileChooser().getFileFilter();

  1035. 	    }

  1036. 	    if(filters != null) {

  1037. 		return filters[index];

  1038. 	    } else {

  1039. 		return null;

  1040. 	    }

  1041. 	}

  1042.     }

  1043. 

  1044.     public void valueChanged(ListSelectionEvent e) {

  1045. 	File f = getFileChooser().getSelectedFile();

  1046. 	if (!e.getValueIsAdjusting() && f != null && !getFileChooser().isTraversable(f)) {

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

  1048. 	}

  1049.     }

  1050. 

  1051.     /**

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

  1053.      */

  1054.     protected class DirectoryComboBoxAction extends AbstractAction {

  1055. 	protected DirectoryComboBoxAction() {

  1056. 	    super("DirectoryComboBoxAction");

  1057. 	}

  1058. 

  1059. 	public void actionPerformed(ActionEvent e) {

  1060. 	    getFileChooser().setCurrentDirectory((File) directoryComboBox.getSelectedItem());

  1061. 	}

  1062.     }

  1063. 

  1064.     protected JButton getApproveButton(JFileChooser fc) {

  1065. 	return approveButton;

  1066.     }

  1067. 

  1068. }