diff options
Diffstat (limited to 'libjava/classpath/javax/swing/JFileChooser.java')
| -rw-r--r-- | libjava/classpath/javax/swing/JFileChooser.java | 1626 |
1 files changed, 1626 insertions, 0 deletions
diff --git a/libjava/classpath/javax/swing/JFileChooser.java b/libjava/classpath/javax/swing/JFileChooser.java new file mode 100644 index 000000000..61b2fde73 --- /dev/null +++ b/libjava/classpath/javax/swing/JFileChooser.java @@ -0,0 +1,1626 @@ +/* JFileChooser.java -- + Copyright (C) 2002, 2004, 2005, 2006, Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.swing; + +import gnu.java.lang.CPStringBuilder; + +import java.awt.Component; +import java.awt.Frame; +import java.awt.GraphicsEnvironment; +import java.awt.HeadlessException; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.WindowEvent; +import java.awt.event.WindowAdapter; +import java.beans.PropertyChangeEvent; +import java.io.File; +import java.util.ArrayList; + +import javax.accessibility.Accessible; +import javax.accessibility.AccessibleContext; +import javax.accessibility.AccessibleRole; +import javax.swing.filechooser.FileFilter; +import javax.swing.filechooser.FileSystemView; +import javax.swing.filechooser.FileView; +import javax.swing.plaf.FileChooserUI; + + +/** + * A component that provides the user a dialog box to browse through a + * filesystem and choose one or more files or directories. + * + * A JFileChooser can be configured to filter the displayed file list + * by adding a {@link FileFilter} instance using + * {@link #addChoosableFileFilter(FileFilter)}. Additional components can + * be embedded in the file chooser using {@link #setAccessory(JComponent)}. + * The JFileChooser properties also provide mechanisms to customize the + * behaviour of the file chooser. + * + * @author Kim Ho (kho@luxsci.net) + */ +public class JFileChooser extends JComponent implements Accessible +{ + private static final long serialVersionUID = 3162921138695327837L; + + /** + * A dialog type for selecting a file to open. + * @see #setDialogType(int) + */ + public static final int OPEN_DIALOG = 0; + + /** + * A dialog type for selecting a file to save. + * @see #setDialogType(int) + */ + public static final int SAVE_DIALOG = 1; + + /** + * A dialog type for some custom purpose. + * @see #setDialogType(int) + */ + public static final int CUSTOM_DIALOG = 2; + + /** + * A return value indicating the file chooser has been closed by cancelling. + * + * @see #showOpenDialog(Component) + * @see #showSaveDialog(Component) + */ + public static final int CANCEL_OPTION = 1; + + /** + * A return value indicating the file chooser has been closed by approving + * the selection. + * @see #showOpenDialog(Component) + * @see #showSaveDialog(Component) + */ + public static final int APPROVE_OPTION = 0; + + /** + * A return value indicating the file chooser has been closed by some error. + * @see #showOpenDialog(Component) + * @see #showSaveDialog(Component) + */ + public static final int ERROR_OPTION = -1; + + /** + * A selection mode constant indicating acceptance of files only. + * @see #setFileSelectionMode(int) + */ + public static final int FILES_ONLY = 0; + + /** + * A selection mode constant indicating acceptance of directories only. + * @see #setFileSelectionMode(int) + */ + public static final int DIRECTORIES_ONLY = 1; + + /** + * A selection mode constant indicating acceptance of files and directories. + * @see #setFileSelectionMode(int) + */ + public static final int FILES_AND_DIRECTORIES = 2; + + /** + * Action command string for cancelling the current selection. + * @see #cancelSelection() + */ + public static final String CANCEL_SELECTION = "CancelSelection"; + + /** + * Action command string for approving the current selection. + * @see #cancelSelection() + */ + public static final String APPROVE_SELECTION = "ApproveSelection"; + + /** + * The name of the property for the approve button text. + * @see #setApproveButtonText(String) + */ + public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY = + "ApproveButtonTextChangedProperty"; + + /** + * The name of the property for the approve button tool tip text. + * @see #setApproveButtonToolTipText(String) + */ + public static final String APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY = + "ApproveButtonToolTipTextChangedProperty"; + + /** + * The name of the property for the approve button mnemonic. + * @see #setApproveButtonMnemonic(int) + */ + public static final String APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY = + "ApproveButtonMnemonicChangedProperty"; + + /** + * The name of the property for control button visibility. + * @see #setControlButtonsAreShown(boolean) + */ + public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY = + "ControlButtonsAreShownChangedProperty"; + + /** + * The name of the property for the current directory. + * @see #setCurrentDirectory(File) + */ + public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged"; + + /** + * The name of the property for the selected file. + * @see #setSelectedFile(File) + */ + public static final String SELECTED_FILE_CHANGED_PROPERTY = + "SelectedFileChangedProperty"; + + /** + * The name of the property for the selected files. + * @see #setSelectedFiles(File[]) + */ + public static final String SELECTED_FILES_CHANGED_PROPERTY = + "SelectedFilesChangedProperty"; + + /** + * The name of the property for multi-selection. + * @see #setMultiSelectionEnabled(boolean) + */ + public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY = + "MultiSelectionEnabledChangedProperty"; + + /** + * The name of the 'file system view' property. + * @see #setFileSystemView(FileSystemView) + */ + public static final String FILE_SYSTEM_VIEW_CHANGED_PROPERTY = + "FileSystemViewChanged"; + + /** + * The name of the 'file view' property. + * @see #setFileView(FileView) + */ + public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged"; + + /** + * The name of the 'file hiding enabled' property. + * @see #setFileHidingEnabled(boolean) + */ + public static final String FILE_HIDING_CHANGED_PROPERTY = + "FileHidingChanged"; + + /** + * The name of the 'file filter' property. + * @see #setFileFilter(FileFilter) + */ + public static final String FILE_FILTER_CHANGED_PROPERTY = + "fileFilterChanged"; + + /** + * The name of the 'file selection mode' property. + * @see #setFileSelectionMode(int) + */ + public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY = + "fileSelectionChanged"; + + /** + * The name of the 'accessory' property. + * @see #setAccessory(JComponent) + */ + public static final String ACCESSORY_CHANGED_PROPERTY = + "AccessoryChangedProperty"; + + /** + * The name of the 'accept all file filter used' property. + * @see #setAcceptAllFileFilterUsed(boolean) + */ + public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY = + "acceptAllFileFilterUsedChanged"; + + /** + * The name of the 'dialog title' property. + * @see #setDialogTitle(String) + */ + public static final String DIALOG_TITLE_CHANGED_PROPERTY = + "DialogTitleChangedProperty"; + + /** + * The name of the 'dialog type' property. + * @see #setDialogType(int) + */ + public static final String DIALOG_TYPE_CHANGED_PROPERTY = + "DialogTypeChangedProperty"; + + /** + * The name of the 'choosable file filters' property. + * @see #addChoosableFileFilter(FileFilter) + */ + public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY = + "ChoosableFileFilterChangedProperty"; + + /** + * The accessible context. + * @see #getAccessibleContext() + */ + protected AccessibleContext accessibleContext; + + /** + * The file system view. + * @see #setFileSystemView(FileSystemView) + */ + private FileSystemView fsv; + + /** + * The accessory component. + * @see #setAccessory(JComponent) + */ + private JComponent accessory; + + /** + * The approve button mnemonic. + * @see #setApproveButtonMnemonic(int) + */ + private int approveButtonMnemonic = 0; + + /** + * The approve button text. + * @see #setApproveButtonText(String) + */ + private String approveButtonText; + + /** + * The approve button tool tip text. + * @see #setApproveButtonToolTipText(String) + */ + private String approveButtonToolTipText; + + /** + * The choosable file filters. + * @see #addChoosableFileFilter(FileFilter) + */ + private ArrayList choosableFilters = new ArrayList(); + + /** + * A flag controlling whether the accept all file filter is used. + * @see #setAcceptAllFileFilterUsed(boolean) + */ + private boolean isAcceptAll = true; + + /** + * The dialog title. + * @see #setDialogTitle(String) + */ + private String dialogTitle; + + /** + * The dialog type. + * @see #setDialogType(int) + */ + private int dialogType = OPEN_DIALOG; + + /** + * The return value for the dialog. + * @see #showOpenDialog(Component) + * @see #showSaveDialog(Component) + */ + private int retval = ERROR_OPTION; + + /** + * A flag indicating whether the file chooser allows multiple selection. + * @see #isMultiSelectionEnabled() + */ + private boolean multiSelection = false; + + /** + * A flag indicating whether file hiding is enabled. + * @see #isFileHidingEnabled() + */ + private boolean fileHiding = true; + + /** + * The file selection mode. + * @see #setFileSelectionMode(int) + */ + private int fileSelectionMode = FILES_ONLY; + + /** + * The file view. + * @see #setFileView(FileView) + */ + private FileView fv = null; + + /** + * A flag controlling whether or not the control buttons are visible. + * @see #setControlButtonsAreShown(boolean) + */ + private boolean controlButtonsShown = true; + + /** + * The current directory. + * @see #setCurrentDirectory(File) + */ + private File currentDir = null; + + /** + * The current file filter. + * @see #setFileFilter(FileFilter) + */ + private FileFilter currentFilter = null; + + /** + * An array of selected files. + * @see #setSelectedFiles(File[]) + */ + private File[] selectedFiles; + + /** + * The selected file. + * @see #setSelectedFile(File) + */ + private File selectedFile; + + /** + * The drag enabled property. + * @see #setDragEnabled(boolean) + * @see #getDragEnabled() + */ + private boolean dragEnabled; + + /** + * Creates a new <code>JFileChooser</code> object. + */ + public JFileChooser() + { + setup(null); + setCurrentDirectory(null); + } + + /** + * Creates a new <code>JFileChooser</code> object. + * + * @param currentDirectoryPath the directory that should initially be + * shown in the filechooser (if <code>null</code>, the user's home + * directory is used). + */ + public JFileChooser(String currentDirectoryPath) + { + this(currentDirectoryPath, null); + } + + /** + * Creates a new <code>JFileChooser</code> object with the specified + * directory and {@link FileSystemView}. + * + * @param currentDirectoryPath the directory that should initially be + * shown in the filechooser (if <code>null</code>, the user's home + * directory is used). + * @param fsv the file system view (if <code>null</code>, the default file + * system view is used). + */ + public JFileChooser(String currentDirectoryPath, FileSystemView fsv) + { + setup(fsv); + File dir = null; + if (currentDirectoryPath != null) + dir = getFileSystemView().createFileObject(currentDirectoryPath); + setCurrentDirectory(dir); + } + + /** + * Creates a new <code>JFileChooser</code> object. + * + * @param currentDirectory the directory that should initially be + * shown in the filechooser (if <code>null</code>, the user's home + * directory is used). + */ + public JFileChooser(File currentDirectory) + { + setup(null); + setCurrentDirectory(currentDirectory); + } + + /** + * Creates a new <code>JFileChooser</code> object. + * + * @param fsv the file system view (if <code>null</code>, the default file + * system view is used). + */ + public JFileChooser(FileSystemView fsv) + { + setup(fsv); + setCurrentDirectory(null); + } + + /** + * Creates a new <code>JFileChooser</code> object. + * + * @param currentDirectory the directory that should initially be + * shown in the filechooser (if <code>null</code>, the user's home + * directory is used). + * @param fsv the file system view (if <code>null</code>, the default file + * system view is used). + */ + public JFileChooser(File currentDirectory, FileSystemView fsv) + { + setup(fsv); + setCurrentDirectory(currentDirectory); + } + + /** + * Sets up the file chooser. This method is called by all the constructors. + * + * @param view the file system view (if <code>null</code>, the default file + * system view is used). + * + * @see FileSystemView#getFileSystemView() + */ + protected void setup(FileSystemView view) + { + if (view == null) + view = FileSystemView.getFileSystemView(); + setFileSystemView(view); + updateUI(); + } + + /** + * Sets the dragEnabled property, this disables/enables automatic drag + * handling (drag and drop) on this component. The default value of the + * dragEnabled property is false. + * + * Some look and feels might not support automatic drag and drop; they + * will ignore this property. + * + * @param b - the new dragEnabled value + */ + public void setDragEnabled(boolean b) + { + if (b && GraphicsEnvironment.isHeadless()) + throw new HeadlessException(); + + dragEnabled = b; + } + + /** + * Returns true if dragging is enabled. + * + * @return true if dragging is enabled. + */ + public boolean getDragEnabled() + { + return dragEnabled; + } + + /** + * Returns the selected file, if there is one. + * + * @return The selected file (possibly <code>null</code>). + * + * @see #setSelectedFile(File) + */ + public File getSelectedFile() + { + return selectedFile; + } + + /** + * Sets the selected file and sends a {@link PropertyChangeEvent} to all + * registered listeners. The property name is + * {@link #SELECTED_FILE_CHANGED_PROPERTY}. + * + * @param file the file (<code>null</code> permitted). + */ + public void setSelectedFile(File file) + { + if (selectedFile == null || !selectedFile.equals(file)) + { + File old = selectedFile; + selectedFile = file; + firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, old, selectedFile); + } + } + + /** + * Returns the selected file or files in an array. If no files are selected, + * an empty array is returned. + * + * @return An array of the selected files (possibly empty). + */ + public File[] getSelectedFiles() + { + if (selectedFiles != null) + return selectedFiles; + if (selectedFile != null) + return new File[] { selectedFile }; + return new File[0]; + } + + /** + * Sets the selected files and sends a {@link PropertyChangeEvent} (with the + * name {@link #SELECTED_FILES_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param selectedFiles the selected files (<code>null</code> permitted). + */ + public void setSelectedFiles(File[] selectedFiles) + { + if (selectedFiles == null) + selectedFiles = new File[0]; + if (selectedFiles.length > 0) + setSelectedFile(selectedFiles[0]); + else + setSelectedFile(null); + if (this.selectedFiles != selectedFiles) + { + File[] old = this.selectedFiles; + this.selectedFiles = selectedFiles; + firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, old, selectedFiles); + } + + } + + /** + * Returns the current directory. + * + * @return The current directory. + */ + public File getCurrentDirectory() + { + return currentDir; + } + + /** + * Sets the current directory and fires a {@link PropertyChangeEvent} (with + * the property name {@link #DIRECTORY_CHANGED_PROPERTY}) to all registered + * listeners. If <code>dir</code> is <code>null</code>, the current + * directory is set to the default directory returned by the file system + * view. + * + * @param dir the new directory (<code>null</code> permitted). + * + * @see FileSystemView#getDefaultDirectory() + */ + public void setCurrentDirectory(File dir) + { + if (currentDir != dir || dir == null) + { + if (dir == null) + dir = fsv.getDefaultDirectory(); + + File old = currentDir; + currentDir = dir; + firePropertyChange(DIRECTORY_CHANGED_PROPERTY, old, currentDir); + } + } + + /** + * Called by the UI delegate when the parent directory is changed. + */ + public void changeToParentDirectory() + { + setCurrentDirectory(fsv.getParentDirectory(currentDir)); + } + + /** + * Rescans the current directory (this is handled by the UI delegate). + */ + public void rescanCurrentDirectory() + { + getUI().rescanCurrentDirectory(this); + } + + /** + * Ensures the the specified file is visible (this is handled by the + * UI delegate). + * + * @param f the file. + */ + public void ensureFileIsVisible(File f) + { + getUI().ensureFileIsVisible(this, f); + } + + /** + * Displays the file chooser in a modal dialog using the + * {@link #OPEN_DIALOG} type. + * + * @param parent the parent component. + * + * @return A return value indicating how the dialog was closed (one of + * {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and + * {@link #ERROR_OPTION}). + * + * @throws HeadlessException DOCUMENT ME! + */ + public int showOpenDialog(Component parent) throws HeadlessException + { + JDialog d = createDialog(parent); + + // FIXME: Remove when we get ancestor property + d.setTitle("Open"); + setDialogType(OPEN_DIALOG); + + retval = ERROR_OPTION; + + d.pack(); + d.show(); + return retval; + } + + /** + * Displays the file chooser in a modal dialog using the + * {@link #SAVE_DIALOG} type. + * + * @param parent the parent component. + * + * @return A return value indicating how the dialog was closed (one of + * {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and + * {@link #ERROR_OPTION}). + * + * @throws HeadlessException DOCUMENT ME! + */ + public int showSaveDialog(Component parent) throws HeadlessException + { + JDialog d = createDialog(parent); + setDialogType(SAVE_DIALOG); + + retval = ERROR_OPTION; + + d.pack(); + d.show(); + return retval; + } + + /** + * Displays the file chooser in a modal dialog using the + * {@link #CUSTOM_DIALOG} type. + * + * @param parent the parent component. + * + * @return A return value indicating how the dialog was closed (one of + * {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and + * {@link #ERROR_OPTION}). + * + * @throws HeadlessException DOCUMENT ME! + */ + public int showDialog(Component parent, String approveButtonText) + throws HeadlessException + { + JDialog d = createDialog(parent); + setApproveButtonText(approveButtonText); + setDialogType(CUSTOM_DIALOG); + + retval = ERROR_OPTION; + + d.pack(); + d.show(); + return retval; + } + + /** + * Creates a modal dialog in which to display the file chooser. + * + * @param parent the parent component. + * + * @return The dialog. + * + * @throws HeadlessException DOCUMENT ME! + */ + protected JDialog createDialog(Component parent) throws HeadlessException + { + Frame toUse = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent); + if (toUse == null) + toUse = (Frame) SwingUtilities.getOwnerFrame(null); + + JDialog dialog = new JDialog(toUse); + setSelectedFile(null); + dialog.getContentPane().add(this); + dialog.addWindowListener( new WindowAdapter() + { + public void windowClosing(WindowEvent e) + { + cancelSelection(); + } + }); + dialog.setModal(true); + dialog.invalidate(); + dialog.repaint(); + return dialog; + } + + /** + * Returns the flag that controls whether or not the control buttons are + * shown on the file chooser. + * + * @return A boolean. + * + * @see #setControlButtonsAreShown(boolean) + */ + public boolean getControlButtonsAreShown() + { + return controlButtonsShown; + } + + /** + * Sets the flag that controls whether or not the control buttons are + * shown and, if it changes, sends a {@link PropertyChangeEvent} (with the + * property name {@link #CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY}) to + * all registered listeners. + * + * @param b the new value for the flag. + */ + public void setControlButtonsAreShown(boolean b) + { + if (controlButtonsShown != b) + { + controlButtonsShown = b; + firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY, + ! controlButtonsShown, controlButtonsShown); + } + } + + /** + * Returns the type of file chooser. + * + * @return {@link #OPEN_DIALOG}, {@link #SAVE_DIALOG} or + * {@link #CUSTOM_DIALOG}. + * + * @see #setDialogType(int) + */ + public int getDialogType() + { + return dialogType; + } + + /** + * Sets the dialog type and fires a {@link PropertyChangeEvent} (with the + * property name {@link #DIALOG_TYPE_CHANGED_PROPERTY}) to all + * registered listeners. + * + * @param dialogType the dialog type (one of: {@link #OPEN_DIALOG}, + * {@link #SAVE_DIALOG}, {@link #CUSTOM_DIALOG}). + * + * @throws IllegalArgumentException if <code>dialogType</code> is not valid. + */ + public void setDialogType(int dialogType) + { + if (dialogType != OPEN_DIALOG && dialogType != SAVE_DIALOG + && dialogType != CUSTOM_DIALOG) + throw new IllegalArgumentException("Choose allowable dialogType."); + + if (this.dialogType != dialogType) + { + int old = this.dialogType; + this.dialogType = dialogType; + firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, old, this.dialogType); + } + } + + /** + * Sets the dialog title and sends a {@link PropertyChangeEvent} (with the + * property name {@link #DIALOG_TITLE_CHANGED_PROPERTY}) to all + * registered listeners. + * + * @param dialogTitle the dialog title (<code>null</code> permitted). + * + * @see #getDialogTitle() + */ + public void setDialogTitle(String dialogTitle) + { + if (this.dialogTitle != dialogTitle) + { + String old = this.dialogTitle; + this.dialogTitle = dialogTitle; + firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, old, this.dialogTitle); + } + } + + /** + * Returns the dialog title. + * + * @return The dialog title (possibly <code>null</code>). + * + * @see #setDialogTitle(String) + */ + public String getDialogTitle() + { + return dialogTitle; + } + + /** + * Sets the tool tip text for the approve button and sends a + * {@link PropertyChangeEvent} (with the property name + * {@link #APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY}) to all + * registered listeners. + * + * @param toolTipText the text. + */ + public void setApproveButtonToolTipText(String toolTipText) + { + if (approveButtonToolTipText != toolTipText) + { + String oldText = approveButtonToolTipText; + approveButtonToolTipText = toolTipText; + firePropertyChange(APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY, + oldText, approveButtonToolTipText); + } + } + + /** + * Returns the tool tip text for the approve button. + * + * @return The tool tip text for the approve button. + * + * @see #setApproveButtonToolTipText(String) + */ + public String getApproveButtonToolTipText() + { + return approveButtonToolTipText; + } + + /** + * Returns the approve button mnemonic, or zero if no mnemonic has been set. + * + * @return The approve button mnemonic. + * + * @see #setApproveButtonMnemonic(int) + */ + public int getApproveButtonMnemonic() + { + return approveButtonMnemonic; + } + + /** + * Sets the mnemonic for the approve button and sends a + * {@link PropertyChangeEvent} (with the property name + * {@link #APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param mnemonic the mnemonic. + * + * @see #setApproveButtonMnemonic(char) + */ + public void setApproveButtonMnemonic(int mnemonic) + { + if (approveButtonMnemonic != mnemonic) + { + int oldMnemonic = approveButtonMnemonic; + approveButtonMnemonic = mnemonic; + firePropertyChange(APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY, + oldMnemonic, approveButtonMnemonic); + } + } + + /** + * Sets the mnemonic for the approve button and sends a + * {@link PropertyChangeEvent} (with the property name + * {@link #APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param mnemonic the mnemonic. + * + * @see #setApproveButtonMnemonic(int) + */ + public void setApproveButtonMnemonic(char mnemonic) + { + setApproveButtonMnemonic((int) Character.toUpperCase(mnemonic)); + } + + /** + * Sets the approve button text and fires a {@link PropertyChangeEvent} + * (with the property name {@link #APPROVE_BUTTON_TEXT_CHANGED_PROPERTY}) to + * all registered listeners. + * + * @param approveButtonText the text (<code>null</code> permitted). + * + * @see #getApproveButtonText() + */ + public void setApproveButtonText(String approveButtonText) + { + if (this.approveButtonText != approveButtonText) + { + String oldText = this.approveButtonText; + this.approveButtonText = approveButtonText; + firePropertyChange(APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, oldText, + this.approveButtonText); + } + } + + /** + * Returns the approve button text. + * + * @return The approve button text (possibly <code>null</code>). + * + * @see #setApproveButtonText(String) + */ + public String getApproveButtonText() + { + return approveButtonText; + } + + /** + * Returns the available file filters for this file chooser. + * + * @return The available file filters. + */ + public FileFilter[] getChoosableFileFilters() + { + return (FileFilter[]) choosableFilters.toArray(new FileFilter[choosableFilters.size()]); + } + + /** + * Adds a file filter to the list of available filters and sends a + * {@link PropertyChangeEvent} (with the property name + * {@link #CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param filter the filter (<code>null</code> permitted). + */ + public void addChoosableFileFilter(FileFilter filter) + { + if (filter != null) + { + FileFilter[] old = getChoosableFileFilters(); + choosableFilters.add(filter); + FileFilter[] newFilters = getChoosableFileFilters(); + firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, old, + newFilters); + } + setFileFilter(filter); + } + + /** + * Removes a file filter from the list of available filters and sends a + * {@link PropertyChangeEvent} (with the property name + * {@link #CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param f the file filter. + * + * @return <code>true</code> if the filter was removed and + * <code>false</code> otherwise. + */ + public boolean removeChoosableFileFilter(FileFilter f) + { + if (f == currentFilter) + setFileFilter(null); + FileFilter[] old = getChoosableFileFilters(); + if (! choosableFilters.remove(f)) + return false; + FileFilter[] newFilters = getChoosableFileFilters(); + firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, old, newFilters); + return true; + } + + /** + * Clears the list of choosable file filters and installs the 'accept all' + * filter from the UI delegate. + */ + public void resetChoosableFileFilters() + { + choosableFilters.clear(); + choosableFilters.add(getUI().getAcceptAllFileFilter(this)); + setFileFilter((FileFilter) choosableFilters.get(0)); + } + + /** + * Returns the 'accept all' file filter from the UI delegate. + * + * @return The 'accept all' file filter. + */ + public FileFilter getAcceptAllFileFilter() + { + return getUI().getAcceptAllFileFilter(this); + } + + /** + * Returns the flag that controls whether or not the 'accept all' file + * filter is included in the list of filters. + * + * @return A boolean. + * + * @see #setAcceptAllFileFilterUsed(boolean) + */ + public boolean isAcceptAllFileFilterUsed() + { + return isAcceptAll; + } + + /** + * Sets the flag that controls whether or not the 'accept all' file filter + * is included in the list of filters, and sends a + * {@link PropertyChangeEvent} (with the property name + * {@link #ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param b the new value of the flag. + */ + public void setAcceptAllFileFilterUsed(boolean b) + { + if (isAcceptAll != b) + { + isAcceptAll = b; + if (b) + addChoosableFileFilter(getAcceptAllFileFilter()); + else + removeChoosableFileFilter(getAcceptAllFileFilter()); + firePropertyChange(ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY, + ! isAcceptAll, isAcceptAll); + } + } + + /** + * Returns the accessory component for the file chooser. The default + * value is <code>null</code>. + * + * @return The accessory component (possibly <code>null</code>). + * + * @see #setAccessory(JComponent) + */ + public JComponent getAccessory() + { + return accessory; + } + + /** + * Sets the accessory component for the file chooser and sends a + * {@link PropertyChangeEvent} to all registered listeners. The property + * name is {@link #ACCESSORY_CHANGED_PROPERTY}. + * + * @param newAccessory the accessory component. + */ + public void setAccessory(JComponent newAccessory) + { + if (accessory != newAccessory) + { + JComponent old = accessory; + accessory = newAccessory; + firePropertyChange(ACCESSORY_CHANGED_PROPERTY, old, accessory); + } + } + + /** + * Sets the file selection mode and sends a {@link PropertyChangeEvent} + * to all registered listeners. The property name is + * {@link #FILE_SELECTION_MODE_CHANGED_PROPERTY}. + * + * @param mode the mode ({@link #FILES_ONLY}, {@link #DIRECTORIES_ONLY} or + * {@link #FILES_AND_DIRECTORIES}). + * + * @throws IllegalArgumentException if the mode is invalid. + */ + public void setFileSelectionMode(int mode) + { + if (mode != FILES_ONLY && mode != DIRECTORIES_ONLY + && mode != FILES_AND_DIRECTORIES) + throw new IllegalArgumentException("Choose a correct file selection mode."); + if (fileSelectionMode != mode) + { + int old = fileSelectionMode; + fileSelectionMode = mode; + firePropertyChange(FILE_SELECTION_MODE_CHANGED_PROPERTY, old, + fileSelectionMode); + } + } + + /** + * Returns the file selection mode, one of: {@link #FILES_ONLY}, + * {@link #DIRECTORIES_ONLY} or {@link #FILES_AND_DIRECTORIES}. The + * default is {@link #FILES_ONLY}. + * + * @return The file selection mode. + * + * @see #setFileSelectionMode(int) + */ + public int getFileSelectionMode() + { + return fileSelectionMode; + } + + /** + * Returns <code>true</code> if file selection is enabled, and + * <code>false</code> otherwise. File selection is enabled when the + * file selection mode is {@link #FILES_ONLY} or + * {@link #FILES_AND_DIRECTORIES}. + * + * @return <code>true</code> if file selection is enabled. + * + * @see #getFileSelectionMode() + */ + public boolean isFileSelectionEnabled() + { + return (fileSelectionMode == FILES_ONLY + || fileSelectionMode == FILES_AND_DIRECTORIES); + } + + /** + * Returns <code>true</code> if directory selection is enabled, and + * <code>false</code> otherwise. Directory selection is enabled when the + * file selection mode is {@link #DIRECTORIES_ONLY} or + * {@link #FILES_AND_DIRECTORIES}. + * + * @return <code>true</code> if file selection is enabled. + * + * @see #getFileSelectionMode() + */ + public boolean isDirectorySelectionEnabled() + { + return (fileSelectionMode == DIRECTORIES_ONLY + || fileSelectionMode == FILES_AND_DIRECTORIES); + } + + /** + * Sets the flag that controls whether multiple selections are allowed in + * this filechooser and sends a {@link PropertyChangeEvent} (with the + * property name {@link #MULTI_SELECTION_ENABLED_CHANGED_PROPERTY}) to all + * registered listeners. + * + * @param b the new value of the flag. + */ + public void setMultiSelectionEnabled(boolean b) + { + if (multiSelection != b) + { + multiSelection = b; + firePropertyChange(MULTI_SELECTION_ENABLED_CHANGED_PROPERTY, + ! multiSelection, multiSelection); + } + } + + /** + * Returns <code>true</code> if multiple selections are allowed within this + * file chooser, and <code>false</code> otherwise. + * + * @return A boolean. + * + * @see #setMultiSelectionEnabled(boolean) + */ + public boolean isMultiSelectionEnabled() + { + return multiSelection; + } + + /** + * Returns <code>true</code> if hidden files are to be hidden, and + * <code>false</code> otherwise. + * + * @return A boolean. + * + * @see #setFileHidingEnabled(boolean) + */ + public boolean isFileHidingEnabled() + { + return fileHiding; + } + + /** + * Sets the flag that controls whether or not hidden files are displayed, + * and sends a {@link PropertyChangeEvent} (with the property name + * {@link #FILE_HIDING_CHANGED_PROPERTY}) to all registered listeners. + * + * @param b the new value of the flag. + */ + public void setFileHidingEnabled(boolean b) + { + if (fileHiding != b) + { + fileHiding = b; + firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, ! fileHiding, + fileHiding); + } + } + + /** + * Sets the file filter and sends a {@link PropertyChangeEvent} (with the + * property name {@link #FILE_FILTER_CHANGED_PROPERTY}) to all registered + * listeners. + * + * @param filter the filter (<code>null</code> permitted). + */ + public void setFileFilter(FileFilter filter) + { + if (currentFilter != filter) + { + if (filter != null && !choosableFilters.contains(filter)) + addChoosableFileFilter(filter); + FileFilter old = currentFilter; + currentFilter = filter; + firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, old, currentFilter); + } + } + + /** + * Returns the file filter. + * + * @return The file filter. + * + * @see #setFileFilter(FileFilter) + */ + public FileFilter getFileFilter() + { + return currentFilter; + } + + /** + * Sets a custom {@link FileView} for the file chooser and sends a + * {@link PropertyChangeEvent} to all registered listeners. The property + * name is {@link #FILE_VIEW_CHANGED_PROPERTY}. + * + * @param fileView the file view (<code>null</code> permitted). + * + * @see #getFileView() + */ + public void setFileView(FileView fileView) + { + if (fv != fileView) + { + FileView old = fv; + fv = fileView; + firePropertyChange(FILE_VIEW_CHANGED_PROPERTY, old, fv); + } + } + + /** + * Returns the custom {@link FileView} for the file chooser. + * + * @return The file view (possibly <code>null</code>). + */ + public FileView getFileView() + { + return fv; + } + + /** + * Returns the name of the file, generated by the current (or default) + * {@link FileView}. + * + * @param f the file. + * + * @return The file name. + */ + public String getName(File f) + { + String name = null; + if (fv != null) + name = fv.getName(f); + if (name == null) + name = getUI().getFileView(this).getName(f); + return name; + } + + /** + * Returns the description of the file, generated by the current (or default) + * {@link FileView}. + * + * @param f the file. + * + * @return The file description. + */ + public String getDescription(File f) + { + String result = null; + if (fv != null) + result = fv.getDescription(f); + if (result == null) + result = getUI().getFileView(this).getDescription(f); + return result; + } + + /** + * Returns the type description for the file, generated by the current (or + * default) {@link FileView}. + * + * @param f the file. + * + * @return The file type description. + */ + public String getTypeDescription(File f) + { + String result = null; + if (fv != null) + result = getFileView().getTypeDescription(f); + if (result == null) + result = getUI().getFileView(this).getTypeDescription(f); + return result; + } + + /** + * Returns the icon provided by the current (or default) {@link FileView}. + * + * @param f the file. + * + * @return An icon representing the file. + */ + public Icon getIcon(File f) + { + Icon result = null; + if (fv != null) + result = fv.getIcon(f); + if (result == null) + result = getUI().getFileView(this).getIcon(f); + return result; + } + + /** + * Returns <code>true</code> if the file is traversable, and + * <code>false</code> otherwise. + * + * @param f the file or directory. + * + * @return A boolean. + */ + public boolean isTraversable(File f) + { + return getFileSystemView().isTraversable(f).booleanValue(); + } + + /** + * Returns <code>true</code> if the file is accepted by the current + * file filter. + * + * @param f the file. + * + * @return A boolean. + */ + public boolean accept(File f) + { + if (f == null) + return true; + FileFilter ff = getFileFilter(); + if (ff != null) + return ff.accept(f); + else + return true; + } + + /** + * Sets the file system view for the file chooser and sends a + * {@link PropertyChangeEvent} to all registered listeners. + * + * @param fsv the file system view. + */ + public void setFileSystemView(FileSystemView fsv) + { + if (this.fsv != fsv) + { + FileSystemView old = this.fsv; + this.fsv = fsv; + firePropertyChange(FILE_SYSTEM_VIEW_CHANGED_PROPERTY, old, this.fsv); + } + } + + /** + * Returns the file system view being used by this file chooser. + * + * @return The file system view. + * + * @see #setFileSystemView(FileSystemView) + */ + public FileSystemView getFileSystemView() + { + return fsv; + } + + /** + * Approves the selection. An {@link ActionEvent} is sent to all registered + * listeners. + */ + public void approveSelection() + { + retval = APPROVE_OPTION; + fireActionPerformed(APPROVE_SELECTION); + } + + /** + * Cancels the selection. An {@link ActionEvent} is sent to all registered + * listeners. + */ + public void cancelSelection() + { + retval = CANCEL_OPTION; + fireActionPerformed(CANCEL_SELECTION); + } + + /** + * Adds an {@link ActionListener} to the file chooser. + * + * @param l the listener. + */ + public void addActionListener(ActionListener l) + { + listenerList.add(ActionListener.class, l); + } + + /** + * Removes an {@link ActionListener} from this file chooser. + * + * @param l the listener. + */ + public void removeActionListener(ActionListener l) + { + try + { + listenerList.remove(ActionListener.class, l); + } + catch (IllegalArgumentException e) + { + e.printStackTrace(); + } + } + + /** + * Returns the action listeners registered with this file chooser. + * + * @return An array of listeners. + */ + public ActionListener[] getActionListeners() + { + return (ActionListener[]) getListeners(ActionListener.class); + } + + /** + * Sends an @link {ActionEvent} to all registered listeners. + * + * @param command the action command. + */ + protected void fireActionPerformed(String command) + { + ActionListener[] list = getActionListeners(); + ActionEvent event = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, + command); + + for (int i = 0; i < list.length; i++) + list[i].actionPerformed(event); + } + + /** + * Installs the UI delegate for the current look and feel. + */ + public void updateUI() + { + setUI((FileChooserUI) UIManager.getUI(this)); + } + + /** + * Returns the UI delegate class identifier. + * + * @return <code>FileChooserUI</code>. + */ + public String getUIClassID() + { + return "FileChooserUI"; + } + + /** + * Returns the UI delegate for the component. + * + * @return The UI delegate. + */ + public FileChooserUI getUI() + { + return (FileChooserUI) ui; + } + + /** + * Returns a string describing the attributes for the + * <code>JFileChooser</code> component, for use in debugging. The return + * value is guaranteed to be non-<code>null</code>, but the format of the + * string may vary between implementations. + * + * @return A string describing the attributes of the + * <code>JFileChooser</code>. + */ + protected String paramString() + { + CPStringBuilder sb = new CPStringBuilder(super.paramString()); + sb.append(",approveButtonText="); + if (approveButtonText != null) + sb.append(approveButtonText); + sb.append(",currentDirectory="); + if (currentDir != null) + sb.append(currentDir); + sb.append(",dialogTitle="); + if (dialogTitle != null) + sb.append(dialogTitle); + sb.append(",dialogType="); + if (dialogType == OPEN_DIALOG) + sb.append("OPEN_DIALOG"); + if (dialogType == SAVE_DIALOG) + sb.append("SAVE_DIALOG"); + if (dialogType == CUSTOM_DIALOG) + sb.append("CUSTOM_DIALOG"); + sb.append(",fileSelectionMode="); + if (fileSelectionMode == FILES_ONLY) + sb.append("FILES_ONLY"); + if (fileSelectionMode == DIRECTORIES_ONLY) + sb.append("DIRECTORIES_ONLY"); + if (fileSelectionMode == FILES_AND_DIRECTORIES) + sb.append("FILES_AND_DIRECTORIES"); + sb.append(",returnValue="); + if (retval == APPROVE_OPTION) + sb.append("APPROVE_OPTION"); + if (retval == CANCEL_OPTION) + sb.append("CANCEL_OPTION"); + if (retval == ERROR_OPTION) + sb.append("ERROR_OPTION"); + sb.append(",selectedFile="); + if (selectedFile != null) + sb.append(selectedFile); + sb.append(",useFileHiding=").append(fileHiding); + return sb.toString(); + } + + /** + * Returns the object that provides accessibility features for this + * <code>JFileChooser</code> component. + * + * @return The accessible context (an instance of + * {@link AccessibleJFileChooser}). + */ + public AccessibleContext getAccessibleContext() + { + if (accessibleContext == null) + accessibleContext = new AccessibleJFileChooser(); + return accessibleContext; + } + + /** + * Provides the accessibility features for the <code>JFileChooser</code> + * component. + */ + protected class AccessibleJFileChooser + extends JComponent.AccessibleJComponent + { + /** + * Creates a new instance of <code>AccessibleJFileChooser</code>. + */ + protected AccessibleJFileChooser() + { + // Nothing to do here. + } + + /** + * Returns the accessible role for the <code>JFileChooser</code> + * component. + * + * @return {@link AccessibleRole#FILE_CHOOSER}. + */ + public AccessibleRole getAccessibleRole() + { + return AccessibleRole.FILE_CHOOSER; + } + } +} |