1. /*

  2.  * @(#)MotifFileChooserUI.java	1.20 01/11/29

  3.  *

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

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

  6.  */

  7. 

  8. package com.sun.java.swing.plaf.motif;

  9. 

  10. import javax.swing.*;

  11. import javax.swing.filechooser.*;

  12. import javax.swing.event.*;

  13. import javax.swing.plaf.*;

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

  15. import java.awt.*;

  16. import java.awt.event.*;

  17. import java.beans.*;

  18. import java.io.File;

  19. import java.io.IOException;

  20. import java.util.*;

  21. 

  22. /**

  23.  * Motif FileChooserUI.

  24.  *

  25.  * @version 1.20 11/29/01

  26.  * @author Jeff Dinkins

  27.  */

  28. public class MotifFileChooserUI extends BasicFileChooserUI {

  29. 

  30.     private FilterComboBoxModel filterComboBoxModel;

  31. 

  32.     protected JList directoryList = null;

  33.     protected JList fileList = null;

  34. 

  35.     protected JTextField pathField = null;

  36.     protected JComboBox filterComboBox = null;

  37.     protected JTextField filenameTextField = null;

  38. 

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

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

  41. 

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

  43. 

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

  45. 

  46.     private static Dimension WITH_ACCELERATOR_PREF_SIZE = new Dimension(650, 450);

  47.     private static Dimension PREF_SIZE = new Dimension(350, 450);

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

  49. 

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

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

  52. 

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

  54. 

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

  56. 

  57.     private JPanel directoryPanel = new JPanel();

  58. 

  59.     protected JButton approveButton;

  60. 

  61.     private String enterFileNameLabelText = null;

  62.     private int enterFileNameLabelMnemonic = 0;

  63. 

  64.     private String filesLabelText = null;

  65.     private int filesLabelMnemonic = 0;

  66. 

  67.     private String foldersLabelText = null;

  68.     private int foldersLabelMnemonic = 0;

  69. 

  70.     private String pathLabelText = null;

  71.     private int pathLabelMnemonic = 0;

  72. 

  73.     private String filterLabelText = null;

  74.     private int filterLabelMnemonic = 0;

  75. 

  76.     public MotifFileChooserUI(JFileChooser filechooser) {

  77. 	super(filechooser);

  78.     }

  79. 

  80.     public String getFileName() {

  81. 	if(filenameTextField != null) {

  82. 	    return filenameTextField.getText();

  83. 	} else {

  84. 	    return null;

  85. 	}

  86.     }

  87. 

  88.     public void setFileName(String filename) {

  89. 	if(filenameTextField != null) {

  90. 	    filenameTextField.setText(filename);

  91. 	}

  92.     }

  93. 

  94.     public String getDirectoryName() {

  95. 	return pathField.getText();

  96.     }

  97. 

  98.     public void setDirectoryName(String dirname) {

  99. 	pathField.setText(dirname);

  100.     }

  101. 

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

  103. 	// PENDING(jeff)

  104.     }

  105. 

  106.     public void rescanCurrentDirectory(JFileChooser fc) {

  107. 	// PENDING(jeff)

  108.     }

  109. 

  110.     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

  111. 	return new PropertyChangeListener() {

  112. 	    public void propertyChange(PropertyChangeEvent e) {

  113. 		String prop = e.getPropertyName();

  114. 		if(prop.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)) {

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

  116. 		    if(f != null) {

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

  118. 			/*

  119. 			  if(model.contains(f)) {

  120. 			  list.setSelectedIndex(model.indexOf(e.getNewValue()));

  121. 			  list.ensureIndexIsVisible(list.getSelectedIndex());

  122. 			  }

  123. 			  */

  124. 		    }

  125. 		} else if(prop.equals(JFileChooser.DIRECTORY_CHANGED_PROPERTY)) {

  126. 		    directoryList.clearSelection();

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

  128. 		    if(currentDirectory != null) {

  129. 			try {

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

  131. 			} catch (IOException ioe) {

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

  133. 			}

  134. 		    }

  135. 		} else if(prop.equals(JFileChooser.FILE_SELECTION_MODE_CHANGED_PROPERTY)) {

  136. 		    directoryList.clearSelection();

  137. 		} else if(prop == JFileChooser.ACCESSORY_CHANGED_PROPERTY) {

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

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

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

  141. 			}

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

  143. 			if(accessory != null) {

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

  145. 			    getAccessoryPanel().setPreferredSize(PREF_ACC_SIZE);

  146. 			    getAccessoryPanel().setMaximumSize(MAX_SIZE);

  147. 			} else {

  148. 			    getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);

  149. 			    getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);

  150. 			}

  151. 		    }

  152. 		} else if(prop == JFileChooser.APPROVE_BUTTON_TEXT_CHANGED_PROPERTY ||

  153. 			  prop == JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY) {

  154. 		    approveButton.setText(getApproveButtonText(getFileChooser()));

  155. 		    approveButton.setToolTipText(getApproveButtonToolTipText(getFileChooser()));

  156. 		}

  157. 	    }

  158. 	};

  159.     }

  160. 

  161.     //

  162.     // ComponentUI Interface Implementation methods

  163.     //

  164.     public static ComponentUI createUI(JComponent c) {

  165.         return new MotifFileChooserUI((JFileChooser)c);

  166.     }

  167. 

  168.     public void installUI(JComponent c) {

  169. 	super.installUI(c);

  170.     }

  171. 

  172.     public void uninstallUI(JComponent c) {

  173. 	getFileChooser().removeAll();

  174. 	super.uninstallUI(c);

  175.     }

  176. 

  177.     public void installComponents(JFileChooser fc) {

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

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

  180. 

  181. 	JPanel interior = new JPanel() {

  182. 	    public Insets getInsets() {

  183. 		return insets;

  184. 	    }

  185. 	};

  186. 	align(interior);

  187. 	interior.setLayout(new BoxLayout(interior, BoxLayout.Y_AXIS));

  188. 

  189. 	fc.add(interior);

  190. 

  191. 	// PENDING(jeff) - I18N

  192. 	JLabel l = new JLabel(pathLabelText);

  193. 	l.setDisplayedMnemonic(pathLabelMnemonic);

  194. 	align(l);

  195. 	interior.add(l);

  196. 

  197. 	File currentDirectory = fc.getCurrentDirectory();

  198. 	String curDirName = null;

  199. 	if(currentDirectory != null) {

  200. 	    curDirName = currentDirectory.getPath();

  201. 	}

  202. 	pathField = new JTextField(curDirName);

  203. 	l.setLabelFor(pathField);

  204. 	align(pathField);

  205. 

  206. 	// Change to folder on return

  207. 	pathField.addActionListener(getUpdateAction());

  208. 	interior.add(pathField);

  209. 

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

  211. 

  212. 

  213. 	// CENTER: left, right accessory

  214. 	JPanel centerPanel = new JPanel();

  215. 	centerPanel.setPreferredSize(MAX_SIZE);

  216. 	centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));

  217. 	align(centerPanel);

  218. 

  219. 	// left panel - Filter & folderList

  220. 	JPanel leftPanel = new JPanel();

  221. 	leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.Y_AXIS));

  222. 	align(leftPanel);

  223. 

  224. 	// add the filter PENDING(jeff) - I18N

  225. 	l = new JLabel(filterLabelText);

  226. 	l.setDisplayedMnemonic(filterLabelMnemonic);

  227. 	align(l);

  228. 	leftPanel.add(l);

  229. 

  230. 	filterComboBox = new JComboBox();

  231.         l.setLabelFor(filterComboBox);

  232. 	filterComboBoxModel = createFilterComboBoxModel();

  233. 	filterComboBox.setModel(filterComboBoxModel);

  234. 	filterComboBox.setRenderer(createFilterComboBoxRenderer());

  235. 	fc.addPropertyChangeListener(filterComboBoxModel);

  236. 	align(filterComboBox);

  237. 	leftPanel.add(filterComboBox);

  238. 

  239. 	// leftPanel.add(Box.createRigidArea(vstrut10));

  240. 

  241. 	// Add the Folder List PENDING(jeff) - I18N

  242. 	l = new JLabel(foldersLabelText);

  243. 	l.setDisplayedMnemonic(foldersLabelMnemonic);

  244. 	align(l);

  245. 	leftPanel.add(l);

  246. 	JScrollPane sp = createDirectoryList();

  247. 	l.setLabelFor(sp);

  248. 	leftPanel.add(sp);

  249. 

  250. 

  251. 	// create files list

  252. 	JPanel rightPanel = new JPanel();

  253. 	align(rightPanel);

  254. 	rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));

  255. 

  256. 	l = new JLabel(filesLabelText);

  257. 	l.setDisplayedMnemonic(filesLabelMnemonic);

  258. 	align(l);

  259. 	rightPanel.add(l);

  260. 	sp = createFilesList();

  261. 	l.setLabelFor(sp);

  262. 	rightPanel.add(sp);

  263. 

  264. 	centerPanel.add(leftPanel);

  265. 	centerPanel.add(Box.createRigidArea(hstrut10));

  266. 	centerPanel.add(rightPanel);

  267. 

  268. 	JComponent accessoryPanel = getAccessoryPanel();

  269. 	JComponent accessory = fc.getAccessory();

  270. 	if(accessoryPanel != null) {

  271. 	    if(accessory == null) {

  272. 		accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);

  273. 		accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);

  274. 	    } else {

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

  276. 		accessoryPanel.setPreferredSize(PREF_ACC_SIZE);

  277. 		accessoryPanel.setMaximumSize(MAX_SIZE);

  278. 	    }

  279. 	    align(accessoryPanel);

  280. 	    centerPanel.add(accessoryPanel);

  281. 	}

  282. 	interior.add(centerPanel);

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

  284. 

  285. 	// add the filename field PENDING(jeff) - I18N

  286. 	l = new JLabel(enterFileNameLabelText);

  287. 	l.setDisplayedMnemonic(enterFileNameLabelMnemonic);

  288. 	align(l);

  289. 	interior.add(l);

  290. 

  291. 	filenameTextField = new JTextField();

  292. 	l.setLabelFor(filenameTextField);

  293. 	filenameTextField.addActionListener(getApproveSelectionAction());

  294. 	align(filenameTextField);

  295. 	filenameTextField.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  296. 	interior.add(filenameTextField);

  297. 

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

  299. 

  300. 	fc.add(new JSeparator());

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

  302. 

  303. 	// Add buttons

  304. 	JPanel buttonPanel = new JPanel();

  305. 	align(buttonPanel);

  306. 	buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));

  307. 	buttonPanel.add(Box.createGlue());

  308. 

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

  310. 	    public Dimension getMaximumSize() {

  311. 		return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);

  312. 	    }

  313. 	};

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

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

  316. 	align(approveButton);

  317. 	approveButton.setMargin(buttonMargin);

  318. 	approveButton.addActionListener(getApproveSelectionAction());

  319. 	buttonPanel.add(approveButton);

  320. 	buttonPanel.add(Box.createGlue());

  321. 

  322. 	JButton updateButton = new JButton(updateButtonText) {

  323. 	    public Dimension getMaximumSize() {

  324. 		return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);

  325. 	    }

  326. 	};

  327. 	updateButton.setMnemonic(updateButtonMnemonic);

  328. 	updateButton.setToolTipText(updateButtonToolTipText);

  329. 	align(updateButton);

  330. 	updateButton.setMargin(buttonMargin);

  331. 	updateButton.addActionListener(getUpdateAction());

  332. 	buttonPanel.add(updateButton);

  333. 	buttonPanel.add(Box.createGlue());

  334. 

  335. 	JButton cancelButton = new JButton(cancelButtonText) {

  336. 	    public Dimension getMaximumSize() {

  337. 		return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);

  338. 	    }

  339. 	};

  340. 	cancelButton.setMnemonic(cancelButtonMnemonic);

  341. 	cancelButton.setToolTipText(cancelButtonToolTipText);

  342. 	align(cancelButton);

  343. 	cancelButton.setMargin(buttonMargin);

  344. 	cancelButton.addActionListener(getCancelSelectionAction());

  345. 	buttonPanel.add(cancelButton);

  346. 	buttonPanel.add(Box.createGlue());

  347. 

  348. 	JButton helpButton = new JButton(helpButtonText) {

  349. 	    public Dimension getMaximumSize() {

  350. 		return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);

  351. 	    }

  352. 	};

  353. 	helpButton.setMnemonic(helpButtonMnemonic);

  354. 	helpButton.setToolTipText(helpButtonToolTipText);

  355. 	align(helpButton);

  356. 	helpButton.setMargin(buttonMargin);

  357. 	helpButton.setEnabled(false);

  358. 	buttonPanel.add(helpButton);

  359. 	buttonPanel.add(Box.createGlue());

  360. 

  361. 	fc.add(buttonPanel);

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

  363. 	fc.add(Box.createGlue());

  364.     }

  365. 

  366.     public void uninstallComponents(JFileChooser fc) {

  367. 	fc.removeAll();

  368.     }

  369. 

  370.     protected void installStrings(JFileChooser fc) {

  371.         super.installStrings(fc);

  372. 

  373. 	enterFileNameLabelText = UIManager.getString("FileChooser.enterFileNameLabelText");

  374. 	enterFileNameLabelMnemonic = UIManager.getInt("FileChooser.enterFileNameLabelMnemonic"); 

  375. 	

  376. 	filesLabelText = UIManager.getString("FileChooser.filesLabelText");

  377. 	filesLabelMnemonic = UIManager.getInt("FileChooser.filesLabelMnemonic"); 

  378. 	

  379. 	foldersLabelText = UIManager.getString("FileChooser.foldersLabelText");

  380. 	foldersLabelMnemonic = UIManager.getInt("FileChooser.foldersLabelMnemonic"); 

  381. 	

  382. 	pathLabelText = UIManager.getString("FileChooser.pathLabelText");

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

  384. 	

  385. 	filterLabelText = UIManager.getString("FileChooser.filterLabelText");

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

  387.     }

  388. 

  389.     protected void installIcons(JFileChooser fc) {

  390. 	// Since motif doesn't have button icons, leave this empty

  391. 	// which overrides the supertype icon loading

  392.     }

  393. 

  394.     protected void uninstallIcons(JFileChooser fc) {

  395. 	// Since motif doesn't have button icons, leave this empty

  396. 	// which overrides the supertype icon loading

  397.     }

  398. 

  399.     protected JScrollPane createFilesList() {

  400. 	fileList = new JList();

  401. 	fileList.setModel(new MotifFileListModel());

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

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

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

  405. 	align(fileList);

  406. 	JScrollPane scrollpane = new JScrollPane(fileList);

  407. 	scrollpane.setPreferredSize(prefListSize);

  408. 	scrollpane.setMaximumSize(MAX_SIZE);

  409. 	align(scrollpane);

  410. 	return scrollpane;

  411.     }

  412. 

  413.     protected JScrollPane createDirectoryList() {

  414. 	directoryList = new JList();

  415. 	align(directoryList);

  416. 

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

  418. 	directoryList.setModel(new MotifDirectoryListModel());

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

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

  421. 

  422. 	JScrollPane scrollpane = new JScrollPane(directoryList);

  423. 	scrollpane.setMaximumSize(MAX_SIZE);

  424. 	scrollpane.setPreferredSize(prefListSize);

  425. 	align(scrollpane);

  426. 	return scrollpane;

  427.     }

  428. 

  429.     public Dimension getPreferredSize(JComponent x) {

  430. 	if(getFileChooser().getAccessory() != null) {

  431. 	    return WITH_ACCELERATOR_PREF_SIZE;

  432. 	} else {

  433. 	    return PREF_SIZE;

  434. 	}

  435.     }

  436. 

  437.     public Dimension getMinimumSize(JComponent x)  {

  438. 	return MIN_SIZE;

  439.     }

  440. 

  441.     public Dimension getMaximumSize(JComponent x) {

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

  443.     }

  444. 

  445.     protected void align(JComponent c) {

  446. 	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  447. 	c.setAlignmentY(JComponent.TOP_ALIGNMENT);

  448.     }

  449. 

  450.     protected class FileCellRenderer extends DefaultListCellRenderer  {

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

  452. 						      boolean isSelected, boolean cellHasFocus) {

  453. 

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

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

  456. 	    return this;

  457. 	}

  458.     }

  459. 

  460.     protected class DirectoryCellRenderer extends DefaultListCellRenderer  {

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

  462. 						      boolean isSelected, boolean cellHasFocus) {

  463. 

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

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

  466. 	    return this;

  467. 	}

  468.     }

  469. 

  470.     protected class MotifDirectoryListModel extends AbstractListModel implements ListDataListener {

  471. 	public MotifDirectoryListModel() {

  472. 	    getModel().addListDataListener(this);

  473. 	}

  474. 

  475. 	public int getSize() {

  476. 	    return getModel().getDirectories().size();

  477. 	}

  478. 

  479. 	public Object getElementAt(int index) {

  480. 	    return getModel().getDirectories().elementAt(index);

  481. 	}

  482. 

  483. 	public void intervalAdded(ListDataEvent e) {

  484. 	}

  485. 

  486. 	// PENDING(jeff) - implement

  487. 	public void intervalRemoved(ListDataEvent e) {

  488. 	}

  489. 

  490. 	// PENDING(jeff) - this is inefficient - should sent out

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

  492. 	// whole list has changed.

  493. 	public void fireContentsChanged() {

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

  495. 	}

  496. 

  497. 	// PENDING(jeff) - fire the correct interval changed - currently sending

  498. 	// out that everything has changed

  499. 	public void contentsChanged(ListDataEvent e) {

  500. 	    fireContentsChanged();

  501. 	}

  502. 

  503.     }

  504. 

  505.     protected class MotifFileListModel extends AbstractListModel implements ListDataListener {

  506. 	public MotifFileListModel() {

  507. 	    getModel().addListDataListener(this);

  508. 	}

  509. 

  510. 	public int getSize() {

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

  512. 	}

  513. 

  514. 	public boolean contains(Object o) {

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

  516. 	}

  517. 

  518. 	public int indexOf(Object o) {

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

  520. 	}

  521. 

  522. 	public Object getElementAt(int index) {

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

  524. 	}

  525. 

  526. 	public void intervalAdded(ListDataEvent e) {

  527. 	}

  528. 

  529. 	// PENDING(jeff) - implement

  530. 	public void intervalRemoved(ListDataEvent e) {

  531. 	}

  532. 

  533. 	// PENDING(jeff) - this is inefficient - should sent out

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

  535. 	// whole list has changed.

  536. 	public void fireContentsChanged() {

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

  538. 	}

  539. 

  540. 	// PENDING(jeff) - fire the interval changed

  541. 	public void contentsChanged(ListDataEvent e) {

  542. 	    fireContentsChanged();

  543. 	}

  544. 

  545.     }

  546. 

  547.     //

  548.     // DataModel for Types Comboxbox

  549.     //

  550.     protected FilterComboBoxModel createFilterComboBoxModel() {

  551. 	return new FilterComboBoxModel();

  552.     }

  553. 

  554.     //

  555.     // Renderer for Types ComboBox

  556.     //

  557.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  558. 	return new FilterComboBoxRenderer();

  559.     }

  560. 

  561. 

  562.     /**

  563.      * Render different type sizes and styles.

  564.      */

  565.     public class FilterComboBoxRenderer extends DefaultListCellRenderer {

  566. 	public Component getListCellRendererComponent(JList list,

  567. 	    Object value, int index, boolean isSelected,

  568. 	    boolean cellHasFocus) {

  569. 

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

  571. 

  572. 	    FileFilter filter = (FileFilter) value;

  573. 	    if(filter != null) {

  574. 		setText(filter.getDescription());

  575. 	    }

  576. 

  577. 	    return this;

  578. 	}

  579.     }

  580. 

  581.     /**

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

  583.      */

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

  585. 	protected FileFilter[] filters;

  586. 	protected FilterComboBoxModel() {

  587. 	    super();

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

  589. 	}

  590. 

  591. 	public void propertyChange(PropertyChangeEvent e) {

  592. 	    String prop = e.getPropertyName();

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

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

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

  596. 	    }

  597. 	}

  598. 

  599. 	public void setSelectedItem(Object filter) {

  600. 	    if(filter != null) {

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

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

  603. 	    }

  604. 	}

  605. 

  606. 	public Object getSelectedItem() {

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

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

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

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

  611. 	    // setFileFilter in JFileChooser.

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

  613. 	    boolean found = false;

  614. 	    if(currentFilter != null) {

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

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

  617. 			found = true;

  618. 		    }

  619. 		}

  620. 		if(found == false) {

  621. 		    getFileChooser().addChoosableFileFilter(currentFilter);

  622. 		}

  623. 	    }

  624. 	    return getFileChooser().getFileFilter();

  625. 	}

  626. 

  627. 	public int getSize() {

  628. 	    if(filters != null) {

  629. 		return filters.length;

  630. 	    } else {

  631. 		return 0;

  632. 	    }

  633. 	}

  634. 

  635. 	public Object getElementAt(int index) {

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

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

  638. 		return getFileChooser().getFileFilter();

  639. 	    }

  640. 	    if(filters != null) {

  641. 		return filters[index];

  642. 	    } else {

  643. 		return null;

  644. 	    }

  645. 	}

  646.     }

  647. 

  648.     protected JButton getApproveButton(JFileChooser fc) {

  649. 	return approveButton;

  650.     }

  651. 

  652. }