home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / JFC.bin / MotifFileChooserUI.java < prev    next >
Encoding:
Java Source  |  1998-06-30  |  17.8 KB  |  618 lines
  1. /*
  2.  * @(#)MotifFileChooserUI.java    1.9 98/04/14
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing.plaf.motif;
  22.  
  23. import com.sun.java.swing.*;
  24. import com.sun.java.swing.preview.*;
  25. import com.sun.java.swing.preview.filechooser.*;
  26. import com.sun.java.swing.event.*;
  27. import com.sun.java.swing.plaf.*;
  28. import com.sun.java.swing.plaf.basic.*;
  29. import java.awt.*;
  30. import java.awt.event.*;
  31. import java.beans.*;
  32. import java.io.File;
  33. import java.io.IOException;
  34. import java.util.*;
  35.  
  36. /**
  37.  * Motif FileChooserUI.  
  38.  *
  39.  * @version 1.9 04/14/98
  40.  * @author Jeff Dinkins
  41.  */
  42. public class MotifFileChooserUI extends BasicFileChooserUI {
  43.  
  44.     private FilterComboBoxModel filterComboBoxModel;
  45.  
  46.     protected JList directoryList = null;
  47.     protected JList fileList = null;
  48.  
  49.     protected JTextField pathField = null;
  50.     protected JComboBox filterComboBox = null;
  51.     protected JTextField filenameTextField = null;
  52.  
  53.     private static final Dimension hstrut10 = new Dimension(10, 1);
  54.     private static final Dimension vstrut10 = new Dimension(1, 10);
  55.  
  56.     private static final Insets insets = new Insets(10, 10, 10, 10);
  57.  
  58.     private static Dimension prefListSize = new Dimension(75, 150);
  59.  
  60.     private static Dimension WITH_ACC_PREF_SIZE = new Dimension(650, 450);
  61.     private static Dimension PREF_SIZE = new Dimension(350, 450);
  62.     private static Dimension MIN_SIZE = new Dimension(200, 300);
  63.  
  64.     private static Dimension PREF_ACC_SIZE = new Dimension(10, 10);
  65.     private static Dimension ZERO_ACC_SIZE = new Dimension(1, 1);
  66.  
  67.     private static Dimension MAX_SIZE = new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
  68.  
  69.     private static final Insets buttonMargin = new Insets(3, 3, 3, 3);
  70.  
  71.     private JPanel directoryPanel = new JPanel();
  72.  
  73.     protected JButton approveButton;
  74.  
  75.     public MotifFileChooserUI(JFileChooser filechooser) {
  76.     super(filechooser);
  77.     }
  78.  
  79.     public String getFileName() {
  80.     if(filenameTextField != null) {
  81.         return filenameTextField.getText();
  82.     } else {
  83.         return null;
  84.     }
  85.     }
  86.  
  87.     public void setFileName(String filename) {
  88.     if(filenameTextField != null) {
  89.         filenameTextField.setText(filename);
  90.     }
  91.     }
  92.  
  93.     public String getDirectoryName() {
  94.     return pathField.getText();
  95.     }
  96.  
  97.     public void setDirectoryName(String dirname) {
  98.     pathField.setText(dirname);
  99.     }
  100.  
  101.     public void ensureFileIsVisible(File f) {
  102.     // PENDING(jeff)
  103.     }
  104.  
  105.     public void rescanCurrentDirectory() {
  106.     // PENDING(jeff) 
  107.     }
  108.  
  109.     public void propertyChange(PropertyChangeEvent e) {
  110.     String prop = e.getPropertyName();
  111.     if(prop.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)) {
  112.         File f = (File) e.getNewValue();
  113.         if(f != null) {
  114.         setFileName(getFileChooser().getName(f));
  115.         /*
  116.         if(model.contains(f)) {
  117.             list.setSelectedIndex(model.indexOf(e.getNewValue()));
  118.             list.ensureIndexIsVisible(list.getSelectedIndex());
  119.         }
  120.         */
  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.ACCESSORY_CHANGED_PROPERTY) {
  135.         if(getAccessoryPanel() != null) {
  136.         if(e.getOldValue() != null) {
  137.             getAccessoryPanel().remove((JComponent) e.getOldValue());
  138.         }
  139.         JComponent accessory = (JComponent) e.getNewValue();
  140.         if(accessory != null) {
  141.             getAccessoryPanel().add(accessory, BorderLayout.CENTER);
  142.             getAccessoryPanel().setPreferredSize(PREF_ACC_SIZE);
  143.             getAccessoryPanel().setMaximumSize(MAX_SIZE);
  144.         } else {
  145.             getAccessoryPanel().setPreferredSize(ZERO_ACC_SIZE);
  146.             getAccessoryPanel().setMaximumSize(ZERO_ACC_SIZE);
  147.         }
  148.         }
  149.     } else if(prop == JFileChooser.APPROVE_BUTTON_TEXT_CHANGED_PROPERTY ||
  150.        prop == JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY) {
  151.         approveButton.setText(getApproveButtonText());
  152.         approveButton.setToolTipText(getApproveButtonToolTipText());
  153.     }
  154.     }
  155.  
  156.     //
  157.     // ComponentUI Interface Implementation methods
  158.     //
  159.     public static ComponentUI createUI(JComponent c) {
  160.         return new MotifFileChooserUI((JFileChooser)c);
  161.     }
  162.  
  163.     public void installUI(JComponent c) {
  164.     super.installUI(c);
  165.     }
  166.  
  167.     public void installComponents() {
  168.  
  169.     getFileChooser().setLayout(new BoxLayout(getFileChooser(), BoxLayout.Y_AXIS));
  170.     getFileChooser().add(Box.createRigidArea(vstrut10));
  171.  
  172.     JPanel interior = new JPanel() {
  173.         public Insets getInsets() {
  174.         return insets;
  175.         }
  176.     };
  177.     align(interior);
  178.     interior.setLayout(new BoxLayout(interior, BoxLayout.Y_AXIS));
  179.  
  180.     getFileChooser().add(interior);
  181.  
  182.     // PENDING(jeff) - I18N
  183.     JLabel l = new JLabel("Enter path or folder name:");
  184.     align(l);
  185.     interior.add(l);
  186.  
  187.     File currentDirectory = getFileChooser().getCurrentDirectory();
  188.     String curDirName = null;
  189.     if(currentDirectory != null) {
  190.         curDirName = currentDirectory.getPath();
  191.     }
  192.     pathField = new JTextField(curDirName);
  193.     align(pathField);
  194.  
  195.     // Change to folder on return
  196.     pathField.addActionListener(getUpdateAction());
  197.     interior.add(pathField);
  198.  
  199.     interior.add(Box.createRigidArea(vstrut10));
  200.     
  201.  
  202.     // CENTER: left, right accessory
  203.     JPanel centerPanel = new JPanel();
  204.     centerPanel.setPreferredSize(MAX_SIZE);
  205.     centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));
  206.     align(centerPanel);
  207.  
  208.     // left panel - Filter & folderList
  209.     JPanel leftPanel = new JPanel();
  210.     leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.Y_AXIS));
  211.     align(leftPanel);
  212.  
  213.     // add the filter PENDING(jeff) - I18N
  214.     l = new JLabel("Filter");
  215.     align(l);
  216.     leftPanel.add(l);
  217.  
  218.     filterComboBox = new JComboBox();
  219.     filterComboBoxModel = createFilterComboBoxModel();
  220.     filterComboBox.setModel(filterComboBoxModel);
  221.     filterComboBox.setRenderer(createFilterComboBoxRenderer());
  222.     getFileChooser().addPropertyChangeListener(filterComboBoxModel);
  223.     align(filterComboBox);
  224.     leftPanel.add(filterComboBox);
  225.  
  226.     /*
  227.     JTextField tmp = new JTextField("*") {
  228.         public Dimension getMinimuSize() {
  229.         return new Dimension(prefListSize.width, super.getMinimumSize().height);
  230.         }
  231.         public Dimension getPreferredSize() {
  232.         return new Dimension(prefListSize.width, super.getPreferredSize().height);
  233.         }
  234.         public Dimension getMaximumSize() {
  235.         return new Dimension(MAX_SIZE.width, super.getMaximumSize().height);
  236.         }
  237.     };
  238.     tmp.setEnabled(false);
  239.     align(tmp);
  240.     leftPanel.add(tmp);
  241.     */
  242.  
  243.     // leftPanel.add(Box.createRigidArea(vstrut10));
  244.  
  245.     // Add the Folder List PENDING(jeff) - I18N
  246.     l = new JLabel("Folders");
  247.     align(l);
  248.     leftPanel.add(l);
  249.     leftPanel.add(createDirectoryList());
  250.  
  251.  
  252.     // create files list
  253.     JPanel rightPanel = new JPanel();
  254.     align(rightPanel);
  255.     rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));
  256.  
  257.     l = new JLabel("Files");
  258.     align(l);
  259.     rightPanel.add(l);
  260.     rightPanel.add(createFilesList());
  261.  
  262.     centerPanel.add(leftPanel);
  263.     centerPanel.add(Box.createRigidArea(hstrut10));
  264.     centerPanel.add(rightPanel);
  265.     
  266.     JComponent accessoryPanel = getAccessoryPanel();
  267.     JComponent accessory = getFileChooser().getAccessory();
  268.     if(accessoryPanel != null) {
  269.         if(accessory == null) {
  270.         accessoryPanel.setPreferredSize(ZERO_ACC_SIZE);
  271.         accessoryPanel.setMaximumSize(ZERO_ACC_SIZE);
  272.         } else {
  273.         getAccessoryPanel().add(accessory, BorderLayout.CENTER);
  274.         accessoryPanel.setPreferredSize(PREF_ACC_SIZE);
  275.         accessoryPanel.setMaximumSize(MAX_SIZE);
  276.         }
  277.         align(accessoryPanel);
  278.         centerPanel.add(accessoryPanel);
  279.     }
  280.     interior.add(centerPanel);
  281.     interior.add(Box.createRigidArea(vstrut10));
  282.  
  283.     // add the filename field PENDING(jeff) - I18N
  284.     l = new JLabel("Enter file name:");
  285.     align(l);
  286.     interior.add(l);
  287.  
  288.     filenameTextField = new JTextField();
  289.     filenameTextField.addActionListener(getApproveSelectionAction());
  290.     align(filenameTextField);
  291.     filenameTextField.setAlignmentX(JComponent.LEFT_ALIGNMENT);
  292.     interior.add(filenameTextField);
  293.  
  294.     interior.add(Box.createRigidArea(vstrut10));
  295.  
  296.     getFileChooser().add(new JSeparator());
  297.     getFileChooser().add(Box.createRigidArea(vstrut10));
  298.  
  299.     // Add buttons
  300.     JPanel buttonPanel = new JPanel();
  301.     align(buttonPanel);
  302.     buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
  303.     buttonPanel.add(Box.createGlue());
  304.  
  305.     approveButton = new JButton(getApproveButtonText()) {
  306.         public Dimension getMaximumSize() {
  307.         return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
  308.         }
  309.     };
  310.     approveButton.setToolTipText(getApproveButtonToolTipText());
  311.     align(approveButton);
  312.     approveButton.setMargin(buttonMargin);
  313.     approveButton.addActionListener(getApproveSelectionAction());
  314.     buttonPanel.add(approveButton);
  315.     buttonPanel.add(Box.createGlue());
  316.  
  317.     JButton updateButton = new JButton(updateButtonText) {
  318.         public Dimension getMaximumSize() {
  319.         return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
  320.         }
  321.     };
  322.     updateButton.setToolTipText(updateButtonToolTipText);
  323.     align(updateButton);
  324.     updateButton.setMargin(buttonMargin);
  325.     updateButton.addActionListener(getUpdateAction());
  326.     buttonPanel.add(updateButton);
  327.     buttonPanel.add(Box.createGlue());
  328.  
  329.     JButton cancelButton = new JButton(cancelButtonText) {
  330.         public Dimension getMaximumSize() {
  331.         return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
  332.         }
  333.     };
  334.     cancelButton.setToolTipText(cancelButtonToolTipText);
  335.     align(cancelButton);
  336.     cancelButton.setMargin(buttonMargin);
  337.     cancelButton.addActionListener(getCancelSelectionAction());
  338.     buttonPanel.add(cancelButton);
  339.     buttonPanel.add(Box.createGlue());
  340.  
  341.     JButton helpButton = new JButton(helpButtonText) {
  342.         public Dimension getMaximumSize() {
  343.         return new Dimension(MAX_SIZE.width, this.getPreferredSize().height);
  344.         }
  345.     };
  346.     helpButton.setToolTipText(helpButtonToolTipText);
  347.     align(helpButton);
  348.     helpButton.setMargin(buttonMargin);
  349.     helpButton.setEnabled(false);
  350.     buttonPanel.add(helpButton);
  351.     buttonPanel.add(Box.createGlue());
  352.  
  353.     getFileChooser().add(buttonPanel);
  354.     getFileChooser().add(Box.createRigidArea(vstrut10));
  355.     getFileChooser().add(Box.createGlue());
  356.     }   
  357.  
  358.  
  359.     public void uninstallUI(JComponent c) {
  360.     getFileChooser().removeAll();
  361.     super.uninstallUI(c);
  362.     }
  363.  
  364.     protected void loadIcons() {
  365.     }
  366.  
  367.     protected JScrollPane createFilesList() {
  368.     fileList = new JList();
  369.     fileList.setModel(new MotifFileListModel());
  370.     fileList.setCellRenderer(new FileCellRenderer());
  371.     fileList.addListSelectionListener(createListSelectionListener());
  372.     fileList.addMouseListener(createDoubleClickListener(fileList));
  373.     align(fileList);
  374.     JScrollPane scrollpane = new JScrollPane(fileList);
  375.     scrollpane.setPreferredSize(prefListSize);
  376.     scrollpane.setMaximumSize(MAX_SIZE);
  377.     align(scrollpane);
  378.     return scrollpane;
  379.     }
  380.  
  381.     protected JScrollPane createDirectoryList() {
  382.     directoryList = new JList();
  383.     align(directoryList);
  384.  
  385.     directoryList.setCellRenderer(new DirectoryCellRenderer());
  386.     directoryList.setModel(new MotifDirectoryListModel());
  387.     directoryList.addMouseListener(createDoubleClickListener(directoryList));
  388.     directoryList.addListSelectionListener(createListSelectionListener());
  389.  
  390.     JScrollPane scrollpane = new JScrollPane(directoryList);
  391.     scrollpane.setMaximumSize(MAX_SIZE);
  392.     scrollpane.setPreferredSize(prefListSize);
  393.     align(scrollpane);
  394.     return scrollpane;
  395.     }
  396.  
  397.     public Dimension getPreferredSize(JComponent x) {
  398.     if(getFileChooser().getAccessory() != null) {
  399.         return WITH_ACC_PREF_SIZE;
  400.     } else {
  401.         return PREF_SIZE;
  402.     }
  403.     }
  404.  
  405.     public Dimension getMinimumSize(JComponent x)  {
  406.     return MIN_SIZE;
  407.     }
  408.     
  409.     public Dimension getMaximumSize(JComponent x) {
  410.     return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  411.     }
  412.  
  413.     protected void align(JComponent c) {
  414.     c.setAlignmentX(JComponent.LEFT_ALIGNMENT);
  415.     c.setAlignmentY(JComponent.TOP_ALIGNMENT);
  416.     }
  417.  
  418.     protected class FileCellRenderer extends BasicListCellRenderer  {
  419.     public Component getListCellRendererComponent(JList list, Object value, int index,
  420.                               boolean isSelected, boolean cellHasFocus) {
  421.  
  422.         super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
  423.         setText(getFileChooser().getName((File) value));
  424.         return this;
  425.     }
  426.     }
  427.  
  428.     protected class DirectoryCellRenderer extends BasicListCellRenderer  {
  429.     public Component getListCellRendererComponent(JList list, Object value, int index,
  430.                               boolean isSelected, boolean cellHasFocus) {
  431.  
  432.         super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
  433.         setText(getFileChooser().getName((File) value));
  434.         return this;
  435.     }
  436.     }
  437.  
  438.     protected class MotifDirectoryListModel extends AbstractListModel implements ListDataListener {
  439.     public MotifDirectoryListModel() {
  440.         getModel().addListDataListener(this);
  441.     }
  442.  
  443.     public int getSize() {
  444.         return getModel().getDirectories().size();
  445.     }
  446.  
  447.     public Object getElementAt(int index) {
  448.         return getModel().getDirectories().elementAt(index);
  449.     }
  450.  
  451.     public void intervalAdded(ListDataEvent e) {
  452.     }
  453.     
  454.     // PENDING(jeff) - implement
  455.     public void intervalRemoved(ListDataEvent e) {
  456.     }
  457.     
  458.     // PENDING(jeff) - this is inefficient - should sent out
  459.     // incremental adjustment values instead of saying that the
  460.     // whole list has changed.
  461.     public void fireContentsChanged() {
  462.         // System.out.println("MotifDirectoryPane: -- firing contents changed");
  463.         fireContentsChanged(this, 0, getModel().getDirectories().size()-1);
  464.     }
  465.  
  466.     // PENDING(jeff) - fire the interval changed
  467.     public void contentsChanged(ListDataEvent e) {
  468.         // System.out.println("MotifDirectoryListModel -- received contents changed");
  469.         fireContentsChanged();
  470.     }
  471.     
  472.     }
  473.  
  474.     protected class MotifFileListModel extends AbstractListModel implements ListDataListener {
  475.     public MotifFileListModel() {
  476.         getModel().addListDataListener(this);
  477.     }
  478.  
  479.     public int getSize() {
  480.         return getModel().getFiles().size();
  481.     }
  482.  
  483.     public boolean contains(Object o) {
  484.         return getModel().getFiles().contains(o);
  485.     }
  486.  
  487.     public int indexOf(Object o) {
  488.         return getModel().getFiles().indexOf(o);
  489.     }
  490.  
  491.     public Object getElementAt(int index) {
  492.         return getModel().getFiles().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().getFiles().size()-1);
  507.     }
  508.  
  509.     // PENDING(jeff) - fire the interval changed
  510.     public void contentsChanged(ListDataEvent e) {
  511.         fireContentsChanged();
  512.     }
  513.     
  514.     }
  515.  
  516.     //
  517.     // DataModel for Types Comboxbox
  518.     //
  519.     protected FilterComboBoxModel createFilterComboBoxModel() {
  520.     return new FilterComboBoxModel();
  521.     }
  522.  
  523.     //
  524.     // Renderer for Types ComboBox
  525.     //
  526.     protected FilterComboBoxRenderer createFilterComboBoxRenderer() {
  527.     return new FilterComboBoxRenderer();
  528.     }
  529.     
  530.  
  531.     /**
  532.      * Render different type sizes and styles.
  533.      */
  534.     public class FilterComboBoxRenderer extends BasicListCellRenderer {
  535.     public Component getListCellRendererComponent(JList list,
  536.         Object value, int index, boolean isSelected, 
  537.         boolean cellHasFocus) {
  538.  
  539.         super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
  540.  
  541.         FileFilter filter = (FileFilter) value;
  542.         if(filter != null) {
  543.         setText(filter.getDescription());
  544.         } 
  545.         
  546.         return this;
  547.     }
  548.     }
  549.  
  550.     /**
  551.      * Data model for a type-face selection combo-box. 
  552.      */
  553.     protected class FilterComboBoxModel extends AbstractListModel implements ComboBoxModel, PropertyChangeListener {
  554.     protected FileFilter[] filters;
  555.     protected FilterComboBoxModel() {
  556.         super();
  557.         filters = getFileChooser().getChoosableFileFilters();
  558.     }
  559.     
  560.     public void propertyChange(PropertyChangeEvent e) {
  561.         String prop = e.getPropertyName();
  562.         if(prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {
  563.         filters = (FileFilter[]) e.getNewValue();
  564.         fireContentsChanged(this, -1, -1);
  565.         }
  566.     }
  567.  
  568.     public void setSelectedItem(Object filter) {
  569.         if(filter != null) {
  570.         getFileChooser().setFileFilter((FileFilter) filter);
  571.         fireContentsChanged(this, -1, -1);
  572.         }
  573.     }
  574.  
  575.     public Object getSelectedItem() {
  576.         // Ensure that the current filter is in the list.
  577.         // NOTE: we shouldnt' have to do this, since JFileChooser adds
  578.         // the filter to the choosable filters list when the filter
  579.         // is set. Lets be paranoid just in case someone overrides
  580.         // setFileFilter in JFileChooser.
  581.         FileFilter currentFilter = getFileChooser().getFileFilter();
  582.         boolean found = false;
  583.         if(currentFilter != null) {
  584.         for(int i=0; i < filters.length; i++) {
  585.             if(filters[i] == currentFilter) {
  586.             found = true;
  587.             }
  588.         }
  589.         if(found == false) {
  590.             getFileChooser().addChoosableFileFilter(currentFilter);
  591.         }
  592.         }
  593.         return getFileChooser().getFileFilter();
  594.     }
  595.     
  596.     public int getSize() {
  597.         if(filters != null) {
  598.         return filters.length;
  599.         } else {
  600.         return 0;
  601.         }
  602.     }
  603.  
  604.     public Object getElementAt(int index) {
  605.         if(index > getSize() - 1) {
  606.         // This shouldn't happen. Try to recover gracefully.
  607.         return getFileChooser().getFileFilter();
  608.         }
  609.         if(filters != null) {
  610.         return filters[index];
  611.         } else {
  612.         return null;
  613.         }
  614.     }
  615.     }
  616.                     
  617. }
  618.