1. /*

  2.  * @(#)MotifFileChooserUI.java	1.42 04/03/11

  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.42 03/11/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.     private JPanel bottomPanel;

  59. 

  60.     protected JButton approveButton;

  61. 

  62.     private String enterFileNameLabelText = null;

  63.     private int enterFileNameLabelMnemonic = 0;

  64. 

  65.     private String filesLabelText = null;

  66.     private int filesLabelMnemonic = 0;

  67. 

  68.     private String foldersLabelText = null;

  69.     private int foldersLabelMnemonic = 0;

  70. 

  71.     private String pathLabelText = null;

  72.     private int pathLabelMnemonic = 0;

  73. 

  74.     private String filterLabelText = null;

  75.     private int filterLabelMnemonic = 0;

  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.     public MotifFileChooserUI(JFileChooser filechooser) {

  108. 	super(filechooser);

  109.     }

  110. 

  111.     public String getFileName() {

  112. 	if(filenameTextField != null) {

  113. 	    return filenameTextField.getText();

  114. 	} else {

  115. 	    return null;

  116. 	}

  117.     }

  118. 

  119.     public void setFileName(String filename) {

  120. 	if(filenameTextField != null) {

  121. 	    filenameTextField.setText(filename);

  122. 	}

  123.     }

  124. 

  125.     public String getDirectoryName() {

  126. 	return pathField.getText();

  127.     }

  128. 

  129.     public void setDirectoryName(String dirname) {

  130. 	pathField.setText(dirname);

  131.     }

  132. 

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

  134. 	// PENDING(jeff)

  135.     }

  136. 

  137.     public void rescanCurrentDirectory(JFileChooser fc) {

  138.         getModel().validateFileCache();

  139.     }

  140. 

  141.     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

  142. 	return new PropertyChangeListener() {

  143. 	    public void propertyChange(PropertyChangeEvent e) {

  144. 		String prop = e.getPropertyName();

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

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

  147. 		    if(f != null) {

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

  149. 		    }

  150.         } 

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

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

  153.             JFileChooser fc = getFileChooser();

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

  155.                setFileName(fileNameString(files)); 

  156.             }

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

  158. 		    directoryList.clearSelection();

  159. 		    fileList.clearSelection();

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

  161. 		    if(currentDirectory != null) {

  162. 			try {

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

  164. 			} catch (IOException ioe) {

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

  166. 			}

  167. 		    }

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

  169. 		    directoryList.clearSelection();

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

  171. 		    if(getFileChooser().isMultiSelectionEnabled()) {

  172. 			fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  173. 		    } else {

  174. 			fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  175. 			fileList.clearSelection();

  176. 			getFileChooser().setSelectedFiles(null);

  177. 		    }

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

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

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

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

  182. 			}

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

  184. 			if(accessory != null) {

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

  186. 			    getAccessoryPanel().setPreferredSize(PREF_ACC_SIZE);

  187. 			    getAccessoryPanel().setMaximumSize(MAX_SIZE);

  188. 			} else {

  189. 			    getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);

  190. 			    getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);

  191. 			}

  192. 		    }

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

  194. 			   prop == JFileChooser.APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY ||

  195. 			   prop == JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY) {

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

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

  198. 		} else if (prop.equals(JFileChooser.CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY)) {

  199.                     doControlButtonsChanged(e);

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

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

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

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

  204. 			cc.applyComponentOrientation(o);

  205. 		    }

  206. 		}

  207. 	    }

  208. 	};

  209.     }

  210. 

  211.     //

  212.     // ComponentUI Interface Implementation methods

  213.     //

  214.     public static ComponentUI createUI(JComponent c) {

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

  216.     }

  217. 

  218.     public void installUI(JComponent c) {

  219. 	super.installUI(c);

  220.     }

  221. 

  222.     public void uninstallUI(JComponent c) {

  223. 	getFileChooser().removeAll();

  224. 	super.uninstallUI(c);

  225.     }

  226. 

  227.     public void installComponents(JFileChooser fc) {

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

  229. 	fc.setAlignmentX(JComponent.CENTER_ALIGNMENT);

  230. 

  231. 	JPanel interior = new JPanel() {

  232. 	    public Insets getInsets() {

  233. 		return insets;

  234. 	    }

  235. 	};

  236. 	align(interior);

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

  238. 

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

  240. 

  241. 	// PENDING(jeff) - I18N

  242. 	JLabel l = new JLabel(pathLabelText);

  243. 	l.setDisplayedMnemonic(pathLabelMnemonic);

  244. 	align(l);

  245. 	interior.add(l);

  246. 

  247. 	File currentDirectory = fc.getCurrentDirectory();

  248. 	String curDirName = null;

  249. 	if(currentDirectory != null) {

  250. 	    curDirName = currentDirectory.getPath();

  251. 	}

  252. 	pathField = new JTextField(curDirName) {

  253. 	    public Dimension getMaximumSize() {

  254. 		Dimension d = super.getMaximumSize();

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

  256. 		return d;

  257. 	    }

  258. 	};

  259. 	l.setLabelFor(pathField);

  260. 	align(pathField);

  261. 

  262. 	// Change to folder on return

  263. 	pathField.addActionListener(getUpdateAction());

  264. 	interior.add(pathField);

  265. 

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

  267. 

  268. 

  269. 	// CENTER: left, right accessory

  270. 	JPanel centerPanel = new JPanel();

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

  272. 	align(centerPanel);

  273. 

  274. 	// left panel - Filter & folderList

  275. 	JPanel leftPanel = new JPanel();

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

  277. 	align(leftPanel);

  278. 

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

  280. 	l = new JLabel(filterLabelText);

  281. 	l.setDisplayedMnemonic(filterLabelMnemonic);

  282. 	align(l);

  283. 	leftPanel.add(l);

  284. 

  285. 	filterComboBox = new JComboBox() {

  286. 	    public Dimension getMaximumSize() {

  287. 		Dimension d = super.getMaximumSize();

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

  289. 		return d;

  290. 	    }

  291. 	};

  292.         l.setLabelFor(filterComboBox);

  293. 	filterComboBoxModel = createFilterComboBoxModel();

  294. 	filterComboBox.setModel(filterComboBoxModel);

  295. 	filterComboBox.setRenderer(createFilterComboBoxRenderer());

  296. 	fc.addPropertyChangeListener(filterComboBoxModel);

  297. 	align(filterComboBox);

  298. 	leftPanel.add(filterComboBox);

  299. 

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

  301. 

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

  303. 	l = new JLabel(foldersLabelText);

  304. 	l.setDisplayedMnemonic(foldersLabelMnemonic);

  305. 	align(l);

  306. 	leftPanel.add(l);

  307. 	JScrollPane sp = createDirectoryList();

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

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

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

  311. 	leftPanel.add(sp);

  312. 

  313. 

  314. 	// create files list

  315. 	JPanel rightPanel = new JPanel();

  316. 	align(rightPanel);

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

  318. 

  319. 	l = new JLabel(filesLabelText);

  320. 	l.setDisplayedMnemonic(filesLabelMnemonic);

  321. 	align(l);

  322. 	rightPanel.add(l);

  323. 	sp = createFilesList();

  324. 	l.setLabelFor(sp);

  325. 	rightPanel.add(sp);

  326. 

  327. 	centerPanel.add(leftPanel);

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

  329. 	centerPanel.add(rightPanel);

  330. 

  331. 	JComponent accessoryPanel = getAccessoryPanel();

  332. 	JComponent accessory = fc.getAccessory();

  333. 	if(accessoryPanel != null) {

  334. 	    if(accessory == null) {

  335. 		accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);

  336. 		accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);

  337. 	    } else {

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

  339. 		accessoryPanel.setPreferredSize(PREF_ACC_SIZE);

  340. 		accessoryPanel.setMaximumSize(MAX_SIZE);

  341. 	    }

  342. 	    align(accessoryPanel);

  343. 	    centerPanel.add(accessoryPanel);

  344. 	}

  345. 	interior.add(centerPanel);

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

  347. 

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

  349. 	l = new JLabel(enterFileNameLabelText);

  350. 	l.setDisplayedMnemonic(enterFileNameLabelMnemonic);

  351. 	align(l);

  352. 	interior.add(l);

  353. 

  354. 	filenameTextField = new JTextField() {

  355. 	    public Dimension getMaximumSize() {

  356. 		Dimension d = super.getMaximumSize();

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

  358. 		return d;

  359. 	    }

  360. 	};

  361. 	l.setLabelFor(filenameTextField);

  362. 	filenameTextField.addActionListener(getApproveSelectionAction());

  363. 	align(filenameTextField);

  364. 	filenameTextField.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  365. 	interior.add(filenameTextField);

  366. 

  367. 	bottomPanel = getBottomPanel();

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

  369. 

  370. 	// Add buttons

  371. 	JPanel buttonPanel = new JPanel();

  372. 	align(buttonPanel);

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

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

  375. 

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

  377. 	    public Dimension getMaximumSize() {

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

  379. 	    }

  380. 	};

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

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

  383. 	align(approveButton);

  384. 	approveButton.setMargin(buttonMargin);

  385. 	approveButton.addActionListener(getApproveSelectionAction());

  386. 	buttonPanel.add(approveButton);

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

  388. 

  389. 	JButton updateButton = new JButton(updateButtonText) {

  390. 	    public Dimension getMaximumSize() {

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

  392. 	    }

  393. 	};

  394. 	updateButton.setMnemonic(updateButtonMnemonic);

  395. 	updateButton.setToolTipText(updateButtonToolTipText);

  396. 	align(updateButton);

  397. 	updateButton.setMargin(buttonMargin);

  398. 	updateButton.addActionListener(getUpdateAction());

  399. 	buttonPanel.add(updateButton);

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

  401. 

  402. 	JButton cancelButton = new JButton(cancelButtonText) {

  403. 	    public Dimension getMaximumSize() {

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

  405. 	    }

  406. 	};

  407. 	cancelButton.setMnemonic(cancelButtonMnemonic);

  408. 	cancelButton.setToolTipText(cancelButtonToolTipText);

  409. 	align(cancelButton);

  410. 	cancelButton.setMargin(buttonMargin);

  411. 	cancelButton.addActionListener(getCancelSelectionAction());

  412. 	buttonPanel.add(cancelButton);

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

  414. 

  415. 	JButton helpButton = new JButton(helpButtonText) {

  416. 	    public Dimension getMaximumSize() {

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

  418. 	    }

  419. 	};

  420. 	helpButton.setMnemonic(helpButtonMnemonic);

  421. 	helpButton.setToolTipText(helpButtonToolTipText);

  422. 	align(helpButton);

  423. 	helpButton.setMargin(buttonMargin);

  424. 	helpButton.setEnabled(false);

  425. 	buttonPanel.add(helpButton);

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

  427. 

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

  429. 	if (fc.getControlButtonsAreShown()) {

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

  431.         }

  432.     }

  433. 

  434.     protected JPanel getBottomPanel() {

  435.         if (bottomPanel == null) {

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

  437.         }

  438.         return bottomPanel;

  439.     }

  440. 

  441.     private void doControlButtonsChanged(PropertyChangeEvent e) {

  442.         if (getFileChooser().getControlButtonsAreShown()) {

  443.             getFileChooser().add(bottomPanel,BorderLayout.SOUTH);

  444.         } else {

  445.             getFileChooser().remove(getBottomPanel());

  446.         }

  447.     }

  448. 

  449.     public void uninstallComponents(JFileChooser fc) {

  450. 	fc.removeAll();

  451.     }

  452. 

  453.     protected void installStrings(JFileChooser fc) {

  454.         super.installStrings(fc);

  455. 

  456.         Locale l = fc.getLocale();

  457. 

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

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

  460. 	

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

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

  463. 	

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

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

  466. 	

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

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

  469. 	

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

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

  472.     }

  473. 

  474.     protected void installIcons(JFileChooser fc) {

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

  476. 	// which overrides the supertype icon loading

  477.     }

  478. 

  479.     protected void uninstallIcons(JFileChooser fc) {

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

  481. 	// which overrides the supertype icon loading

  482.     }

  483. 

  484.     protected JScrollPane createFilesList() {

  485. 	fileList = new JList();

  486. 

  487. 	if(getFileChooser().isMultiSelectionEnabled()) {

  488. 	    fileList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

  489. 	} else {

  490. 	    fileList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

  491. 	}

  492. 	

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

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

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

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

  497. 	align(fileList);

  498. 	JScrollPane scrollpane = new JScrollPane(fileList);

  499. 	scrollpane.setPreferredSize(prefListSize);

  500. 	scrollpane.setMaximumSize(MAX_SIZE);

  501. 	align(scrollpane);

  502. 	return scrollpane;

  503.     }

  504. 

  505.     protected JScrollPane createDirectoryList() {

  506. 	directoryList = new JList();

  507. 	align(directoryList);

  508. 

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

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

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

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

  513. 

  514. 	JScrollPane scrollpane = new JScrollPane(directoryList);

  515. 	scrollpane.setMaximumSize(MAX_SIZE);

  516. 	scrollpane.setPreferredSize(prefListSize);

  517. 	align(scrollpane);

  518. 	return scrollpane;

  519.     }

  520. 

  521.     public Dimension getPreferredSize(JComponent c) {

  522. 	Dimension prefSize =

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

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

  525. 	if (d != null) {

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

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

  528. 	} else {

  529. 	    return prefSize;

  530. 	}

  531.     }

  532. 

  533.     public Dimension getMinimumSize(JComponent x)  {

  534. 	return MIN_SIZE;

  535.     }

  536. 

  537.     public Dimension getMaximumSize(JComponent x) {

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

  539.     }

  540. 

  541.     protected void align(JComponent c) {

  542. 	c.setAlignmentX(JComponent.LEFT_ALIGNMENT);

  543. 	c.setAlignmentY(JComponent.TOP_ALIGNMENT);

  544.     }

  545. 

  546.     protected class FileCellRenderer extends DefaultListCellRenderer  {

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

  548. 						      boolean isSelected, boolean cellHasFocus) {

  549. 

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

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

  552. 	    return this;

  553. 	}

  554.     }

  555. 

  556.     protected class DirectoryCellRenderer extends DefaultListCellRenderer  {

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

  558. 						      boolean isSelected, boolean cellHasFocus) {

  559. 

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

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

  562. 	    return this;

  563. 	}

  564.     }

  565. 

  566.     protected class MotifDirectoryListModel extends AbstractListModel implements ListDataListener {

  567. 	public MotifDirectoryListModel() {

  568. 	    getModel().addListDataListener(this);

  569. 	}

  570. 

  571. 	public int getSize() {

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

  573. 	}

  574. 

  575. 	public Object getElementAt(int index) {

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

  577. 	}

  578. 

  579. 	public void intervalAdded(ListDataEvent e) {

  580.             fireIntervalAdded(this, e.getIndex0(), e.getIndex1());

  581. 	}

  582. 

  583. 	public void intervalRemoved(ListDataEvent e) {

  584.             fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());

  585. 	}

  586. 

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

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

  589. 	// whole list has changed.

  590. 	public void fireContentsChanged() {

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

  592. 	}

  593. 

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

  595. 	// out that everything has changed

  596. 	public void contentsChanged(ListDataEvent e) {

  597. 	    fireContentsChanged();

  598. 	}

  599. 

  600.     }

  601. 

  602.     protected class MotifFileListModel extends AbstractListModel implements ListDataListener {

  603. 	public MotifFileListModel() {

  604. 	    getModel().addListDataListener(this);

  605. 	}

  606. 

  607. 	public int getSize() {

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

  609. 	}

  610. 

  611. 	public boolean contains(Object o) {

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

  613. 	}

  614. 

  615. 	public int indexOf(Object o) {

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

  617. 	}

  618. 

  619. 	public Object getElementAt(int index) {

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

  621. 	}

  622. 

  623. 	public void intervalAdded(ListDataEvent e) {

  624.             fireIntervalAdded(this, e.getIndex0(), e.getIndex1());

  625. 	}

  626. 

  627. 	public void intervalRemoved(ListDataEvent e) {

  628.             fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());

  629. 	}

  630. 

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

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

  633. 	// whole list has changed.

  634. 	public void fireContentsChanged() {

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

  636. 	}

  637. 

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

  639. 	public void contentsChanged(ListDataEvent e) {

  640. 	    fireContentsChanged();

  641. 	}

  642. 

  643.     }

  644. 

  645.     //

  646.     // DataModel for Types Comboxbox

  647.     //

  648.     protected FilterComboBoxModel createFilterComboBoxModel() {

  649. 	return new FilterComboBoxModel();

  650.     }

  651. 

  652.     //

  653.     // Renderer for Types ComboBox

  654.     //

  655.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {

  656. 	return new FilterComboBoxRenderer();

  657.     }

  658. 

  659. 

  660.     /**

  661.      * Render different type sizes and styles.

  662.      */

  663.     public class FilterComboBoxRenderer extends DefaultListCellRenderer {

  664. 	public Component getListCellRendererComponent(JList list,

  665. 	    Object value, int index, boolean isSelected,

  666. 	    boolean cellHasFocus) {

  667. 

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

  669. 

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

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

  672. 	    }

  673. 

  674. 	    return this;

  675. 	}

  676.     }

  677. 

  678.     /**

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

  680.      */

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

  682. 	protected FileFilter[] filters;

  683. 	protected FilterComboBoxModel() {

  684. 	    super();

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

  686. 	}

  687. 

  688. 	public void propertyChange(PropertyChangeEvent e) {

  689. 	    String prop = e.getPropertyName();

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

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

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

  693. 	    } else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {

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

  695. 	    }

  696. 	}

  697. 

  698. 	public void setSelectedItem(Object filter) {

  699. 	    if(filter != null) {

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

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

  702. 	    }

  703. 	}

  704. 

  705. 	public Object getSelectedItem() {

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

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

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

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

  710. 	    // setFileFilter in JFileChooser.

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

  712. 	    boolean found = false;

  713. 	    if(currentFilter != null) {

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

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

  716. 			found = true;

  717. 		    }

  718. 		}

  719. 		if(found == false) {

  720. 		    getFileChooser().addChoosableFileFilter(currentFilter);

  721. 		}

  722. 	    }

  723. 	    return getFileChooser().getFileFilter();

  724. 	}

  725. 

  726. 	public int getSize() {

  727. 	    if(filters != null) {

  728. 		return filters.length;

  729. 	    } else {

  730. 		return 0;

  731. 	    }

  732. 	}

  733. 

  734. 	public Object getElementAt(int index) {

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

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

  737. 		return getFileChooser().getFileFilter();

  738. 	    }

  739. 	    if(filters != null) {

  740. 		return filters[index];

  741. 	    } else {

  742. 		return null;

  743. 	    }

  744. 	}

  745.     }

  746. 

  747.     protected JButton getApproveButton(JFileChooser fc) {

  748. 	return approveButton;

  749.     }

  750. 

  751. }