mirror of git://gcc.gnu.org/git/gcc.git
1627 lines
43 KiB
Java
1627 lines
43 KiB
Java
/* 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;
|
|
}
|
|
}
|
|
}
|