1. /*

  2.  * @(#)MotifFileChooserUI.java	1.22 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 com.sun.java.swing.plaf.motif;

  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.  * Motif FileChooserUI.

  27.  *

  28.  * @version 1.22 02/02/00

  29.  * @author Jeff Dinkins

  30.  */

  31. public class MotifFileChooserUI extends BasicFileChooserUI {

  32. 

  33.     private FilterComboBoxModel filterComboBoxModel;

  34. 

  35.     protected JList directoryList = null;

  36.     protected JList fileList = null;

  37. 

  38.     protected JTextField pathField = null;

  39.     protected JComboBox filterComboBox = null;

  40.     protected JTextField filenameTextField = null;

  41. 

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

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

  44. 

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

  46. 

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

  48. 

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

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

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

  52. 

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

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

  55. 

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

  57. 

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

  59. 

  60.     private JPanel directoryPanel = new JPanel();

  61. 

  62.     protected JButton approveButton;

  63. 

  64.     private String enterFileNameLabelText = null;

  65.     private int enterFileNameLabelMnemonic = 0;

  66. 

  67.     private String filesLabelText = null;

  68.     private int filesLabelMnemonic = 0;

  69. 

  70.     private String foldersLabelText = null;

  71.     private int foldersLabelMnemonic = 0;

  72. 

  73.     private String pathLabelText = null;

  74.     private int pathLabelMnemonic = 0;

  75. 

  76.     private String filterLabelText = null;

  77.     private int filterLabelMnemonic = 0;

  78. 

  79.     public MotifFileChooserUI(JFileChooser filechooser) {

  80. 	super(filechooser);

  81.     }

  82. 

  83.     public String getFileName() {

  84. 	if(filenameTextField != null) {

  85. 	    return filenameTextField.getText();

  86. 	} else {

  87. 	    return null;

  88. 	}

  89.     }

  90. 

  91.     public void setFileName(String filename) {

  92. 	if(filenameTextField != null) {

  93. 	    filenameTextField.setText(filename);

  94. 	}

  95.     }

  96. 

  97.     public String getDirectoryName() {

  98. 	return pathField.getText();

  99.     }

  100. 

  101.     public void setDirectoryName(String dirname) {

  102. 	pathField.setText(dirname);

  103.     }

  104. 

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

  106. 	// PENDING(jeff)

  107.     }

  108. 

  109.     public void rescanCurrentDirectory(JFileChooser fc) {

  110. 	// PENDING(jeff)

  111.     }

  112. 

  113.     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

  114. 	return new PropertyChangeListener() {

  115. 	    public void propertyChange(PropertyChangeEvent e) {

  116. 		String prop = e.getPropertyName();

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

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

  119. 		    if(f != null) {

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

  121. 		    }

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

  123. 		    directoryList.clearSelection();

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

  125. 		    if(currentDirectory != null) {

  126. 			try {

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

  128. 			} catch (IOException ioe) {

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

  130. 			}

  131. 		    }

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

  133. 		    directoryList.clearSelection();

  134. 		} else if(prop == JFileChooser.MULTI_SELECTION_ENABLED_CHANGED_PROPERTY) {

  135. 		    if(getFileChooser().isMultiSelectionEnabled()) {

  136. 			fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  137. 		    } else {

  138. 			fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  139. 			fileList.clearSelection();

  140. 			getFileChooser().setSelectedFiles(null);

  141. 		    }

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

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

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

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

  146. 			}

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

  148. 			if(accessory != null) {

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

  150. 			    getAccessoryPanel().setPreferredSize(PREF_ACC_SIZE);

  151. 			    getAccessoryPanel().setMaximumSize(MAX_SIZE);

  152. 			} else {

  153. 			    getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);

  154. 			    getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);

  155. 			}

  156. 		    }

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

  158. 			  prop == JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY) {

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

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

  161. 		}

  162. 	    }

  163. 	};

  164.     }

  165. 

  166.     //

  167.     // ComponentUI Interface Implementation methods

  168.     //

  169.     public static ComponentUI createUI(JComponent c) {

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

  171.     }

  172. 

  173.     public void installUI(JComponent c) {

  174. 	super.installUI(c);

  175.     }

  176. 

  177.     public void uninstallUI(JComponent c) {

  178. 	getFileChooser().removeAll();

  179. 	super.uninstallUI(c);

  180.     }

  181. 

  182.     public void installComponents(JFileChooser fc) {

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

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

  185. 

  186. 	JPanel interior = new JPanel() {

  187. 	    public Insets getInsets() {

  188. 		return insets;

  189. 	    }

  190. 	};

  191. 	align(interior);

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

  193. 

  194. 	fc.add(interior);

  195. 

  196. 	// PENDING(jeff) - I18N

  197. 	JLabel l = new JLabel(pathLabelText);

  198. 	l.setDisplayedMnemonic(pathLabelMnemonic);

  199. 	align(l);

  200. 	interior.add(l);

  201. 

  202. 	File currentDirectory = fc.getCurrentDirectory();

  203. 	String curDirName = null;

  204. 	if(currentDirectory != null) {

  205. 	    curDirName = currentDirectory.getPath();

  206. 	}

  207. 	pathField = new JTextField(curDirName);

  208. 	l.setLabelFor(pathField);

  209. 	align(pathField);

  210. 

  211. 	// Change to folder on return

  212. 	pathField.addActionListener(getUpdateAction());

  213. 	interior.add(pathField);

  214. 

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

  216. 

  217. 

  218. 	// CENTER: left, right accessory

  219. 	JPanel centerPanel = new JPanel();

  220. 	centerPanel.setPreferredSize(MAX_SIZE);

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

  222. 	align(centerPanel);

  223. 

  224. 	// left panel - Filter & folderList

  225. 	JPanel leftPanel = new JPanel();

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

  227. 	align(leftPanel);

  228. 

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

  230. 	l = new JLabel(filterLabelText);

  231. 	l.setDisplayedMnemonic(filterLabelMnemonic);

  232. 	align(l);

  233. 	leftPanel.add(l);

  234. 

  235. 	filterComboBox = new JComboBox();

  236.         l.setLabelFor(filterComboBox);

  237. 	filterComboBoxModel = createFilterComboBoxModel();

  238. 	filterComboBox.setModel(filterComboBoxModel);

  239. 	filterComboBox.setRenderer(createFilterComboBoxRenderer());

  240. 	fc.addPropertyChangeListener(filterComboBoxModel);

  241. 	align(filterComboBox);

  242. 	leftPanel.add(filterComboBox);

  243. 

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

  245. 

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

  247. 	l = new JLabel(foldersLabelText);

  248. 	l.setDisplayedMnemonic(foldersLabelMnemonic);

  249. 	align(l);

  250. 	leftPanel.add(l);

  251. 	JScrollPane sp = createDirectoryList();

  252. 	l.setLabelFor(sp);

  253. 	leftPanel.add(sp);

  254. 

  255. 

  256. 	// create files list

  257. 	JPanel rightPanel = new JPanel();

  258. 	align(rightPanel);

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

  260. 

  261. 	l = new JLabel(filesLabelText);

  262. 	l.setDisplayedMnemonic(filesLabelMnemonic);

  263. 	align(l);

  264. 	rightPanel.add(l);

  265. 	sp = createFilesList();

  266. 	l.setLabelFor(sp);

  267. 	rightPanel.add(sp);

  268. 

  269. 	centerPanel.add(leftPanel);

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

  271. 	centerPanel.add(rightPanel);

  272. 

  273. 	JComponent accessoryPanel = getAccessoryPanel();

  274. 	JComponent accessory = fc.getAccessory();

  275. 	if(accessoryPanel != null) {

  276. 	    if(accessory == null) {

  277. 		accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);

  278. 		accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);

  279. 	    } else {

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

  281. 		accessoryPanel.setPreferredSize(PREF_ACC_SIZE);

  282. 		accessoryPanel.setMaximumSize(MAX_SIZE);

  283. 	    }

  284. 	    align(accessoryPanel);

  285. 	    centerPanel.add(accessoryPanel);

  286. 	}

  287. 	interior.add(centerPanel);

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

  289. 

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

  291. 	l = new JLabel(enterFileNameLabelText);

  292. 	l.setDisplayedMnemonic(enterFileNameLabelMnemonic);

  293. 	align(l);

  294. 	interior.add(l);

  295. 

  296. 	filenameTextField = new JTextField();

  297. 	l.setLabelFor(filenameTextField);

  298. 	filenameTextField.addActionListener(getApproveSelectionAction());

  299. 	align(filenameTextField);

  300. 	filenameTextField.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  301. 	interior.add(filenameTextField);

  302. 

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

  304. 

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

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

  307. 

  308. 	// Add buttons

  309. 	JPanel buttonPanel = new JPanel();

  310. 	align(buttonPanel);

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

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

  313. 

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

  315. 	    public Dimension getMaximumSize() {

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

  317. 	    }

  318. 	};

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

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

  321. 	align(approveButton);

  322. 	approveButton.setMargin(buttonMargin);

  323. 	approveButton.addActionListener(getApproveSelectionAction());

  324. 	buttonPanel.add(approveButton);

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

  326. 

  327. 	JButton updateButton = new JButton(updateButtonText) {

  328. 	    public Dimension getMaximumSize() {

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

  330. 	    }

  331. 	};

  332. 	updateButton.setMnemonic(updateButtonMnemonic);

  333. 	updateButton.setToolTipText(updateButtonToolTipText);

  334. 	align(updateButton);

  335. 	updateButton.setMargin(buttonMargin);

  336. 	updateButton.addActionListener(getUpdateAction());

  337. 	buttonPanel.add(updateButton);

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

  339. 

  340. 	JButton cancelButton = new JButton(cancelButtonText) {

  341. 	    public Dimension getMaximumSize() {

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

  343. 	    }

  344. 	};

  345. 	cancelButton.setMnemonic(cancelButtonMnemonic);

  346. 	cancelButton.setToolTipText(cancelButtonToolTipText);

  347. 	align(cancelButton);

  348. 	cancelButton.setMargin(buttonMargin);

  349. 	cancelButton.addActionListener(getCancelSelectionAction());

  350. 	buttonPanel.add(cancelButton);

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

  352. 

  353. 	JButton helpButton = new JButton(helpButtonText) {

  354. 	    public Dimension getMaximumSize() {

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

  356. 	    }

  357. 	};

  358. 	helpButton.setMnemonic(helpButtonMnemonic);

  359. 	helpButton.setToolTipText(helpButtonToolTipText);

  360. 	align(helpButton);

  361. 	helpButton.setMargin(buttonMargin);

  362. 	helpButton.setEnabled(false);

  363. 	buttonPanel.add(helpButton);

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

  365. 

  366. 	fc.add(buttonPanel);

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

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

  369.     }

  370. 

  371.     public void uninstallComponents(JFileChooser fc) {

  372. 	fc.removeAll();

  373.     }

  374. 

  375.     protected void installStrings(JFileChooser fc) {

  376.         super.installStrings(fc);

  377. 

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

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

  380. 	

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

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

  383. 	

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

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

  386. 	

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

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

  389. 	

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

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

  392.     }

  393. 

  394.     protected void installIcons(JFileChooser fc) {

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

  396. 	// which overrides the supertype icon loading

  397.     }

  398. 

  399.     protected void uninstallIcons(JFileChooser fc) {

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

  401. 	// which overrides the supertype icon loading

  402.     }

  403. 

  404.     protected JScrollPane createFilesList() {

  405. 	fileList = new JList();

  406. 

  407. 	if(getFileChooser().isMultiSelectionEnabled()) {

  408. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  409. 	} else {

  410. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  411. 	}

  412. 	

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

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

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

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

  417. 	align(fileList);

  418. 	JScrollPane scrollpane = new JScrollPane(fileList);

  419. 	scrollpane.setPreferredSize(prefListSize);

  420. 	scrollpane.setMaximumSize(MAX_SIZE);

  421. 	align(scrollpane);

  422. 	return scrollpane;

  423.     }

  424. 

  425.     protected JScrollPane createDirectoryList() {

  426. 	directoryList = new JList();

  427. 	align(directoryList);

  428. 

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

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

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

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

  433. 

  434. 	JScrollPane scrollpane = new JScrollPane(directoryList);

  435. 	scrollpane.setMaximumSize(MAX_SIZE);

  436. 	scrollpane.setPreferredSize(prefListSize);

  437. 	align(scrollpane);

  438. 	return scrollpane;

  439.     }

  440. 

  441.     public Dimension getPreferredSize(JComponent x) {

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

  443. 	    return WITH_ACCELERATOR_PREF_SIZE;

  444. 	} else {

  445. 	    return PREF_SIZE;

  446. 	}

  447.     }

  448. 

  449.     public Dimension getMinimumSize(JComponent x)  {

  450. 	return MIN_SIZE;

  451.     }

  452. 

  453.     public Dimension getMaximumSize(JComponent x) {

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

  455.     }

  456. 

  457.     protected void align(JComponent c) {

  458. 	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  459. 	c.setAlignmentY(JComponent.TOP_ALIGNMENT);

  460.     }

  461. 

  462.     protected class FileCellRenderer extends DefaultListCellRenderer  {

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

  464. 						      boolean isSelected, boolean cellHasFocus) {

  465. 

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

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

  468. 	    return this;

  469. 	}

  470.     }

  471. 

  472.     protected class DirectoryCellRenderer extends DefaultListCellRenderer  {

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

  474. 						      boolean isSelected, boolean cellHasFocus) {

  475. 

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

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

  478. 	    return this;

  479. 	}

  480.     }

  481. 

  482.     protected class MotifDirectoryListModel extends AbstractListModel implements ListDataListener {

  483. 	public MotifDirectoryListModel() {

  484. 	    getModel().addListDataListener(this);

  485. 	}

  486. 

  487. 	public int getSize() {

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

  489. 	}

  490. 

  491. 	public Object getElementAt(int index) {

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

  493. 	}

  494. 

  495. 	public void intervalAdded(ListDataEvent e) {

  496. 	}

  497. 

  498. 	// PENDING(jeff) - implement

  499. 	public void intervalRemoved(ListDataEvent e) {

  500. 	}

  501. 

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

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

  504. 	// whole list has changed.

  505. 	public void fireContentsChanged() {

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

  507. 	}

  508. 

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

  510. 	// out that everything has changed

  511. 	public void contentsChanged(ListDataEvent e) {

  512. 	    fireContentsChanged();

  513. 	}

  514. 

  515.     }

  516. 

  517.     protected class MotifFileListModel extends AbstractListModel implements ListDataListener {

  518. 	public MotifFileListModel() {

  519. 	    getModel().addListDataListener(this);

  520. 	}

  521. 

  522. 	public int getSize() {

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

  524. 	}

  525. 

  526. 	public boolean contains(Object o) {

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

  528. 	}

  529. 

  530. 	public int indexOf(Object o) {

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

  532. 	}

  533. 

  534. 	public Object getElementAt(int index) {

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

  536. 	}

  537. 

  538. 	public void intervalAdded(ListDataEvent e) {

  539. 	}

  540. 

  541. 	// PENDING(jeff) - implement

  542. 	public void intervalRemoved(ListDataEvent e) {

  543. 	}

  544. 

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

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

  547. 	// whole list has changed.

  548. 	public void fireContentsChanged() {

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

  550. 	}

  551. 

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

  553. 	public void contentsChanged(ListDataEvent e) {

  554. 	    fireContentsChanged();

  555. 	}

  556. 

  557.     }

  558. 

  559.     //

  560.     // DataModel for Types Comboxbox

  561.     //

  562.     protected FilterComboBoxModel createFilterComboBoxModel() {

  563. 	return new FilterComboBoxModel();

  564.     }

  565. 

  566.     //

  567.     // Renderer for Types ComboBox

  568.     //

  569.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  570. 	return new FilterComboBoxRenderer();

  571.     }

  572. 

  573. 

  574.     /**

  575.      * Render different type sizes and styles.

  576.      */

  577.     public class FilterComboBoxRenderer extends DefaultListCellRenderer {

  578. 	public Component getListCellRendererComponent(JList list,

  579. 	    Object value, int index, boolean isSelected,

  580. 	    boolean cellHasFocus) {

  581. 

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

  583. 

  584. 	    FileFilter filter = (FileFilter) value;

  585. 	    if(filter != null) {

  586. 		setText(filter.getDescription());

  587. 	    }

  588. 

  589. 	    return this;

  590. 	}

  591.     }

  592. 

  593.     /**

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

  595.      */

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

  597. 	protected FileFilter[] filters;

  598. 	protected FilterComboBoxModel() {

  599. 	    super();

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

  601. 	}

  602. 

  603. 	public void propertyChange(PropertyChangeEvent e) {

  604. 	    String prop = e.getPropertyName();

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

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

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

  608. 	    }

  609. 	}

  610. 

  611. 	public void setSelectedItem(Object filter) {

  612. 	    if(filter != null) {

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

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

  615. 	    }

  616. 	}

  617. 

  618. 	public Object getSelectedItem() {

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

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

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

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

  623. 	    // setFileFilter in JFileChooser.

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

  625. 	    boolean found = false;

  626. 	    if(currentFilter != null) {

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

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

  629. 			found = true;

  630. 		    }

  631. 		}

  632. 		if(found == false) {

  633. 		    getFileChooser().addChoosableFileFilter(currentFilter);

  634. 		}

  635. 	    }

  636. 	    return getFileChooser().getFileFilter();

  637. 	}

  638. 

  639. 	public int getSize() {

  640. 	    if(filters != null) {

  641. 		return filters.length;

  642. 	    } else {

  643. 		return 0;

  644. 	    }

  645. 	}

  646. 

  647. 	public Object getElementAt(int index) {

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

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

  650. 		return getFileChooser().getFileFilter();

  651. 	    }

  652. 	    if(filters != null) {

  653. 		return filters[index];

  654. 	    } else {

  655. 		return null;

  656. 	    }

  657. 	}

  658.     }

  659. 

  660.     protected JButton getApproveButton(JFileChooser fc) {

  661. 	return approveButton;

  662.     }

  663. 

  664. }