1. /*

  2.  * @(#)MotifFileChooserUI.java	1.39 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. 

  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.39 01/13/04

  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. 

  77.     private String fileNameString(File file) {

  78.         if (file == null) {

  79.             return null;

  80.         } else {

  81.             JFileChooser fc = getFileChooser();

  82.             if (fc.isDirectorySelectionEnabled() && !fc.isFileSelectionEnabled()) {

  83.                 return file.getPath();

  84.             } else {

  85.                 return file.getName();

  86.             }

  87.         }

  88.     }

  89. 

  90.     private String fileNameString(File[] files) {

  91.         StringBuffer buf = new StringBuffer();

  92.         for (int i = 0; files != null && i < files.length; i++) {

  93.             if (i > 0) {

  94.                 buf.append(" ");

  95.             }

  96.             if (files.length > 1) {

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

  98.             }

  99.             buf.append(fileNameString(files[i]));

  100.             if (files.length > 1) {

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

  102.             }

  103.         }

  104.         return buf.toString();

  105.     }

  106. 

  107. 

  108.     public MotifFileChooserUI(JFileChooser filechooser) {

  109. 	super(filechooser);

  110.     }

  111. 

  112.     public String getFileName() {

  113. 	if(filenameTextField != null) {

  114. 	    return filenameTextField.getText();

  115. 	} else {

  116. 	    return null;

  117. 	}

  118.     }

  119. 

  120.     public void setFileName(String filename) {

  121. 	if(filenameTextField != null) {

  122. 	    filenameTextField.setText(filename);

  123. 	}

  124.     }

  125. 

  126.     public String getDirectoryName() {

  127. 	return pathField.getText();

  128.     }

  129. 

  130.     public void setDirectoryName(String dirname) {

  131. 	pathField.setText(dirname);

  132.     }

  133. 

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

  135. 	// PENDING(jeff)

  136.     }

  137. 

  138.     public void rescanCurrentDirectory(JFileChooser fc) {

  139. 	// PENDING(jeff)

  140.     }

  141. 

  142.     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

  143. 	return new PropertyChangeListener() {

  144. 	    public void propertyChange(PropertyChangeEvent e) {

  145. 		String prop = e.getPropertyName();

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

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

  148. 		    if(f != null) {

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

  150. 		    }

  151.                 }

  152.                     else if (prop.equals(JFileChooser.SELECTED_FILES_CHANGED_PROPERTY)) {

  153.                       File[] files = (File[]) e.getNewValue();

  154.                       JFileChooser fc = getFileChooser();

  155.                       if (files != null && files.length > 0 && (files.length > 1 || fc.isDirectorySelectionEnabled() || !files[0].isDirectory())) {

  156.                           setFileName(fileNameString(files));

  157.                       }

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

  159. 		    directoryList.clearSelection();

  160. 		    fileList.clearSelection();

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

  162. 		    if(currentDirectory != null) {

  163. 			try {

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

  165. 			} catch (IOException ioe) {

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

  167. 			}

  168. 		    }

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

  170. 		    directoryList.clearSelection();

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

  172. 		    if(getFileChooser().isMultiSelectionEnabled()) {

  173. 			fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  174. 		    } else {

  175. 			fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  176. 			fileList.clearSelection();

  177. 			getFileChooser().setSelectedFiles(null);

  178. 		    }

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

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

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

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

  183. 			}

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

  185. 			if(accessory != null) {

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

  187. 			    getAccessoryPanel().setPreferredSize(PREF_ACC_SIZE);

  188. 			    getAccessoryPanel().setMaximumSize(MAX_SIZE);

  189. 			} else {

  190. 			    getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);

  191. 			    getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);

  192. 			}

  193. 		    }

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

  195. 			   prop == JFileChooser.APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY ||

  196. 			   prop == JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY) {

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

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

  199. 		} else if (prop.equals("componentOrientation")) {

  200. 		    ComponentOrientation o = (ComponentOrientation)e.getNewValue();

  201. 		    JFileChooser cc = (JFileChooser)e.getSource();

  202. 		    if (o != (ComponentOrientation)e.getOldValue()) {

  203. 			cc.applyComponentOrientation(o);

  204. 		    }

  205. 		}

  206. 	    }

  207. 	};

  208.     }

  209. 

  210.     //

  211.     // ComponentUI Interface Implementation methods

  212.     //

  213.     public static ComponentUI createUI(JComponent c) {

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

  215.     }

  216. 

  217.     public void installUI(JComponent c) {

  218. 	super.installUI(c);

  219.     }

  220. 

  221.     public void uninstallUI(JComponent c) {

  222. 	getFileChooser().removeAll();

  223. 	super.uninstallUI(c);

  224.     }

  225. 

  226.     public void installComponents(JFileChooser fc) {

  227. 	fc.setLayout(new BorderLayout(10, 10));

  228. 	fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);

  229. 

  230. 	JPanel interior = new JPanel() {

  231. 	    public Insets getInsets() {

  232. 		return insets;

  233. 	    }

  234. 	};

  235. 	align(interior);

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

  237. 

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

  239. 

  240. 	// PENDING(jeff) - I18N

  241. 	JLabel l = new JLabel(pathLabelText);

  242. 	l.setDisplayedMnemonic(pathLabelMnemonic);

  243. 	align(l);

  244. 	interior.add(l);

  245. 

  246. 	File currentDirectory = fc.getCurrentDirectory();

  247. 	String curDirName = null;

  248. 	if(currentDirectory != null) {

  249. 	    curDirName = currentDirectory.getPath();

  250. 	}

  251. 	pathField = new JTextField(curDirName) {

  252. 	    public Dimension getMaximumSize() {

  253. 		Dimension d = super.getMaximumSize();

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

  255. 		return d;

  256. 	    }

  257. 	};

  258. 	l.setLabelFor(pathField);

  259. 	align(pathField);

  260. 

  261. 	// Change to folder on return

  262. 	pathField.addActionListener(getUpdateAction());

  263. 	interior.add(pathField);

  264. 

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

  266. 

  267. 

  268. 	// CENTER: left, right accessory

  269. 	JPanel centerPanel = new JPanel();

  270. 	centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.LINE_AXIS));

  271. 	align(centerPanel);

  272. 

  273. 	// left panel - Filter & folderList

  274. 	JPanel leftPanel = new JPanel();

  275. 	leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.PAGE_AXIS));

  276. 	align(leftPanel);

  277. 

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

  279. 	l = new JLabel(filterLabelText);

  280. 	l.setDisplayedMnemonic(filterLabelMnemonic);

  281. 	align(l);

  282. 	leftPanel.add(l);

  283. 

  284. 	filterComboBox = new JComboBox() {

  285. 	    public Dimension getMaximumSize() {

  286. 		Dimension d = super.getMaximumSize();

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

  288. 		return d;

  289. 	    }

  290. 	};

  291.         l.setLabelFor(filterComboBox);

  292. 	filterComboBoxModel = createFilterComboBoxModel();

  293. 	filterComboBox.setModel(filterComboBoxModel);

  294. 	filterComboBox.setRenderer(createFilterComboBoxRenderer());

  295. 	fc.addPropertyChangeListener(filterComboBoxModel);

  296. 	align(filterComboBox);

  297. 	leftPanel.add(filterComboBox);

  298. 

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

  300. 

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

  302. 	l = new JLabel(foldersLabelText);

  303. 	l.setDisplayedMnemonic(foldersLabelMnemonic);

  304. 	align(l);

  305. 	leftPanel.add(l);

  306. 	JScrollPane sp = createDirectoryList();

  307.         sp.getVerticalScrollBar().setFocusable(false);

  308.         sp.getHorizontalScrollBar().setFocusable(false);

  309. 	l.setLabelFor(sp.getViewport().getView());

  310. 	leftPanel.add(sp);

  311. 

  312. 

  313. 	// create files list

  314. 	JPanel rightPanel = new JPanel();

  315. 	align(rightPanel);

  316. 	rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.PAGE_AXIS));

  317. 

  318. 	l = new JLabel(filesLabelText);

  319. 	l.setDisplayedMnemonic(filesLabelMnemonic);

  320. 	align(l);

  321. 	rightPanel.add(l);

  322. 	sp = createFilesList();

  323. 	l.setLabelFor(sp);

  324. 	rightPanel.add(sp);

  325. 

  326. 	centerPanel.add(leftPanel);

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

  328. 	centerPanel.add(rightPanel);

  329. 

  330. 	JComponent accessoryPanel = getAccessoryPanel();

  331. 	JComponent accessory = fc.getAccessory();

  332. 	if(accessoryPanel != null) {

  333. 	    if(accessory == null) {

  334. 		accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);

  335. 		accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);

  336. 	    } else {

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

  338. 		accessoryPanel.setPreferredSize(PREF_ACC_SIZE);

  339. 		accessoryPanel.setMaximumSize(MAX_SIZE);

  340. 	    }

  341. 	    align(accessoryPanel);

  342. 	    centerPanel.add(accessoryPanel);

  343. 	}

  344. 	interior.add(centerPanel);

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

  346. 

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

  348. 	l = new JLabel(enterFileNameLabelText);

  349. 	l.setDisplayedMnemonic(enterFileNameLabelMnemonic);

  350. 	align(l);

  351. 	interior.add(l);

  352. 

  353. 	filenameTextField = new JTextField() {

  354. 	    public Dimension getMaximumSize() {

  355. 		Dimension d = super.getMaximumSize();

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

  357. 		return d;

  358. 	    }

  359. 	};

  360. 	l.setLabelFor(filenameTextField);

  361. 	filenameTextField.addActionListener(getApproveSelectionAction());

  362. 	align(filenameTextField);

  363. 	filenameTextField.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  364. 	interior.add(filenameTextField);

  365. 

  366. 	JPanel bottomPanel = new JPanel(new BorderLayout(0, 4));

  367. 	bottomPanel.add(new JSeparator(), BorderLayout.NORTH);

  368. 

  369. 	// Add buttons

  370. 	JPanel buttonPanel = new JPanel();

  371. 	align(buttonPanel);

  372. 	buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.LINE_AXIS));

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

  374. 

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

  376. 	    public Dimension getMaximumSize() {

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

  378. 	    }

  379. 	};

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

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

  382. 	align(approveButton);

  383. 	approveButton.setMargin(buttonMargin);

  384. 	approveButton.addActionListener(getApproveSelectionAction());

  385. 	buttonPanel.add(approveButton);

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

  387. 

  388. 	JButton updateButton = new JButton(updateButtonText) {

  389. 	    public Dimension getMaximumSize() {

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

  391. 	    }

  392. 	};

  393. 	updateButton.setMnemonic(updateButtonMnemonic);

  394. 	updateButton.setToolTipText(updateButtonToolTipText);

  395. 	align(updateButton);

  396. 	updateButton.setMargin(buttonMargin);

  397. 	updateButton.addActionListener(getUpdateAction());

  398. 	buttonPanel.add(updateButton);

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

  400. 

  401. 	JButton cancelButton = new JButton(cancelButtonText) {

  402. 	    public Dimension getMaximumSize() {

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

  404. 	    }

  405. 	};

  406. 	cancelButton.setMnemonic(cancelButtonMnemonic);

  407. 	cancelButton.setToolTipText(cancelButtonToolTipText);

  408. 	align(cancelButton);

  409. 	cancelButton.setMargin(buttonMargin);

  410. 	cancelButton.addActionListener(getCancelSelectionAction());

  411. 	buttonPanel.add(cancelButton);

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

  413. 

  414. 	JButton helpButton = new JButton(helpButtonText) {

  415. 	    public Dimension getMaximumSize() {

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

  417. 	    }

  418. 	};

  419. 	helpButton.setMnemonic(helpButtonMnemonic);

  420. 	helpButton.setToolTipText(helpButtonToolTipText);

  421. 	align(helpButton);

  422. 	helpButton.setMargin(buttonMargin);

  423. 	helpButton.setEnabled(false);

  424. 	buttonPanel.add(helpButton);

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

  426. 

  427. 	bottomPanel.add(buttonPanel, BorderLayout.SOUTH);

  428. 	fc.add(bottomPanel, BorderLayout.SOUTH);

  429.     }

  430. 

  431.     public void uninstallComponents(JFileChooser fc) {

  432. 	fc.removeAll();

  433.     }

  434. 

  435.     protected void installStrings(JFileChooser fc) {

  436.         super.installStrings(fc);

  437. 

  438.         Locale l = fc.getLocale();

  439. 

  440. 	enterFileNameLabelText = UIManager.getString("FileChooser.enterFileNameLabelText",l);

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

  442. 	

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

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

  445. 	

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

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

  448. 	

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

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

  451. 	

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

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

  454.     }

  455. 

  456.     protected void installIcons(JFileChooser fc) {

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

  458. 	// which overrides the supertype icon loading

  459.     }

  460. 

  461.     protected void uninstallIcons(JFileChooser fc) {

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

  463. 	// which overrides the supertype icon loading

  464.     }

  465. 

  466.     protected JScrollPane createFilesList() {

  467. 	fileList = new JList();

  468. 

  469. 	if(getFileChooser().isMultiSelectionEnabled()) {

  470. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  471. 	} else {

  472. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  473. 	}

  474. 	

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

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

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

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

  479. 	align(fileList);

  480. 	JScrollPane scrollpane = new JScrollPane(fileList);

  481. 	scrollpane.setPreferredSize(prefListSize);

  482. 	scrollpane.setMaximumSize(MAX_SIZE);

  483. 	align(scrollpane);

  484. 	return scrollpane;

  485.     }

  486. 

  487.     protected JScrollPane createDirectoryList() {

  488. 	directoryList = new JList();

  489. 	align(directoryList);

  490. 

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

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

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

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

  495. 

  496. 	JScrollPane scrollpane = new JScrollPane(directoryList);

  497. 	scrollpane.setMaximumSize(MAX_SIZE);

  498. 	scrollpane.setPreferredSize(prefListSize);

  499. 	align(scrollpane);

  500. 	return scrollpane;

  501.     }

  502. 

  503.     public Dimension getPreferredSize(JComponent c) {

  504. 	Dimension prefSize =

  505. 	    (getFileChooser().getAccessory() != null) ? WITH_ACCELERATOR_PREF_SIZE : PREF_SIZE;

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

  507. 	if (d != null) {

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

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

  510. 	} else {

  511. 	    return prefSize;

  512. 	}

  513.     }

  514. 

  515.     public Dimension getMinimumSize(JComponent x)  {

  516. 	return MIN_SIZE;

  517.     }

  518. 

  519.     public Dimension getMaximumSize(JComponent x) {

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

  521.     }

  522. 

  523.     protected void align(JComponent c) {

  524. 	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  525. 	c.setAlignmentY(JComponent.TOP_ALIGNMENT);

  526.     }

  527. 

  528.     protected class FileCellRenderer extends DefaultListCellRenderer  {

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

  530. 						      boolean isSelected, boolean cellHasFocus) {

  531. 

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

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

  534. 	    return this;

  535. 	}

  536.     }

  537. 

  538.     protected class DirectoryCellRenderer extends DefaultListCellRenderer  {

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

  540. 						      boolean isSelected, boolean cellHasFocus) {

  541. 

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

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

  544. 	    return this;

  545. 	}

  546.     }

  547. 

  548.     protected class MotifDirectoryListModel extends AbstractListModel implements ListDataListener {

  549. 	public MotifDirectoryListModel() {

  550. 	    getModel().addListDataListener(this);

  551. 	}

  552. 

  553. 	public int getSize() {

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

  555. 	}

  556. 

  557. 	public Object getElementAt(int index) {

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

  559. 	}

  560. 

  561. 	public void intervalAdded(ListDataEvent e) {

  562. 	}

  563. 

  564. 	// PENDING(jeff) - implement

  565. 	public void intervalRemoved(ListDataEvent e) {

  566. 	}

  567. 

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

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

  570. 	// whole list has changed.

  571. 	public void fireContentsChanged() {

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

  573. 	}

  574. 

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

  576. 	// out that everything has changed

  577. 	public void contentsChanged(ListDataEvent e) {

  578. 	    fireContentsChanged();

  579. 	}

  580. 

  581.     }

  582. 

  583.     protected class MotifFileListModel extends AbstractListModel implements ListDataListener {

  584. 	public MotifFileListModel() {

  585. 	    getModel().addListDataListener(this);

  586. 	}

  587. 

  588. 	public int getSize() {

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

  590. 	}

  591. 

  592. 	public boolean contains(Object o) {

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

  594. 	}

  595. 

  596. 	public int indexOf(Object o) {

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

  598. 	}

  599. 

  600. 	public Object getElementAt(int index) {

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

  602. 	}

  603. 

  604. 	public void intervalAdded(ListDataEvent e) {

  605. 	}

  606. 

  607. 	// PENDING(jeff) - implement

  608. 	public void intervalRemoved(ListDataEvent e) {

  609. 	}

  610. 

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

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

  613. 	// whole list has changed.

  614. 	public void fireContentsChanged() {

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

  616. 	}

  617. 

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

  619. 	public void contentsChanged(ListDataEvent e) {

  620. 	    fireContentsChanged();

  621. 	}

  622. 

  623.     }

  624. 

  625.     //

  626.     // DataModel for Types Comboxbox

  627.     //

  628.     protected FilterComboBoxModel createFilterComboBoxModel() {

  629. 	return new FilterComboBoxModel();

  630.     }

  631. 

  632.     //

  633.     // Renderer for Types ComboBox

  634.     //

  635.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  636. 	return new FilterComboBoxRenderer();

  637.     }

  638. 

  639. 

  640.     /**

  641.      * Render different type sizes and styles.

  642.      */

  643.     public class FilterComboBoxRenderer extends DefaultListCellRenderer {

  644. 	public Component getListCellRendererComponent(JList list,

  645. 	    Object value, int index, boolean isSelected,

  646. 	    boolean cellHasFocus) {

  647. 

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

  649. 

  650. 	    if (value != null && value instanceof FileFilter) {

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

  652. 	    }

  653. 

  654. 	    return this;

  655. 	}

  656.     }

  657. 

  658.     /**

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

  660.      */

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

  662. 	protected FileFilter[] filters;

  663. 	protected FilterComboBoxModel() {

  664. 	    super();

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

  666. 	}

  667. 

  668. 	public void propertyChange(PropertyChangeEvent e) {

  669. 	    String prop = e.getPropertyName();

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

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

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

  673. 	    }

  674. 	}

  675. 

  676. 	public void setSelectedItem(Object filter) {

  677. 	    if(filter != null) {

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

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

  680. 	    }

  681. 	}

  682. 

  683. 	public Object getSelectedItem() {

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

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

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

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

  688. 	    // setFileFilter in JFileChooser.

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

  690. 	    boolean found = false;

  691. 	    if(currentFilter != null) {

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

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

  694. 			found = true;

  695. 		    }

  696. 		}

  697. 		if(found == false) {

  698. 		    getFileChooser().addChoosableFileFilter(currentFilter);

  699. 		}

  700. 	    }

  701. 	    return getFileChooser().getFileFilter();

  702. 	}

  703. 

  704. 	public int getSize() {

  705. 	    if(filters != null) {

  706. 		return filters.length;

  707. 	    } else {

  708. 		return 0;

  709. 	    }

  710. 	}

  711. 

  712. 	public Object getElementAt(int index) {

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

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

  715. 		return getFileChooser().getFileFilter();

  716. 	    }

  717. 	    if(filters != null) {

  718. 		return filters[index];

  719. 	    } else {

  720. 		return null;

  721. 	    }

  722. 	}

  723.     }

  724. 

  725.     protected JButton getApproveButton(JFileChooser fc) {

  726. 	return approveButton;

  727.     }

  728. 

  729. }