JFileChooser.java

/*
 * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

packagejavax.swing;

importjava.awt.AWTEvent;
importjava.awt.BorderLayout;
importjava.awt.Component;
importjava.awt.Container;
importjava.awt.Dialog;
importjava.awt.EventQueue;
importjava.awt.Frame;
importjava.awt.GraphicsEnvironment;
importjava.awt.HeadlessException;
importjava.awt.Toolkit;
importjava.awt.Window;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.HierarchyEvent;
importjava.awt.event.HierarchyListener;
importjava.awt.event.InputEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjava.beans.BeanProperty;
importjava.beans.JavaBean;
importjava.beans.PropertyChangeEvent;
importjava.beans.PropertyChangeListener;
importjava.io.File;
importjava.io.IOException;
importjava.io.InvalidObjectException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.Serial;
importjava.io.Serializable;
importjava.lang.ref.WeakReference;
importjava.util.ArrayList;
importjava.util.Vector;

importjavax.accessibility.Accessible;
importjavax.accessibility.AccessibleContext;
importjavax.accessibility.AccessibleRole;
importjavax.swing.event.EventListenerList;
importjavax.swing.filechooser.FileFilter;
importjavax.swing.filechooser.FileSystemView;
importjavax.swing.filechooser.FileView;
importjavax.swing.plaf.FileChooserUI;

/**
 * <code>JFileChooser</code> provides a simple mechanism for the user to
 * choose a file.
 * For information about using <code>JFileChooser</code>, see
 * <a
 href="https://docs.oracle.com/javase/tutorial/uiswing/components/filechooser.html">How to Use File Choosers</a>,
 * a section in <em>The Java Tutorial</em>.
 *
 * <p>
 *
 * The following code pops up a file chooser for the user's home directory that
 * sees only .jpg and .gif images:
 * <pre>
 * JFileChooser chooser = new JFileChooser();
 * FileNameExtensionFilter filter = new FileNameExtensionFilter(
 * "JPG &amp; GIF Images", "jpg", "gif");
 * chooser.setFileFilter(filter);
 * int returnVal = chooser.showOpenDialog(parent);
 * if(returnVal == JFileChooser.APPROVE_OPTION) {
 * System.out.println("You chose to open this file: " +
 * chooser.getSelectedFile().getName());
 * }
 * </pre>
 * <p>
 * <strong>Warning:</strong> Swing is not thread safe. For more
 * information see <a
 * href="package-summary.html#threading">Swing's Threading
 * Policy</a>.
 *
 * @author Jeff Dinkins
 * @since 1.2
 */
@JavaBean(defaultProperty = "UI", description = "A component which allows for the interactive selection of a file.")
@SwingContainer(false)
@SuppressWarnings("serial") // Superclass is not serializable across versions
publicclassJFileChooserextendsJComponentimplementsAccessible {

/**
 * @see #getUIClassID
 * @see #readObject
 */
privatestaticfinalStringuiClassID = "FileChooserUI";

// ************************
// ***** Dialog Types *****
// ************************

/**
 * Type value indicating that the <code>JFileChooser</code> supports an
 * "Open" file operation.
 */
publicstaticfinalintOPEN_DIALOG = 0;

/**
 * Type value indicating that the <code>JFileChooser</code> supports a
 * "Save" file operation.
 */
publicstaticfinalintSAVE_DIALOG = 1;

/**
 * Type value indicating that the <code>JFileChooser</code> supports a
 * developer-specified file operation.
 */
publicstaticfinalintCUSTOM_DIALOG = 2;


// ********************************
// ***** Dialog Return Values *****
// ********************************

/**
 * Return value if cancel is chosen.
 */
publicstaticfinalintCANCEL_OPTION = 1;

/**
 * Return value if approve (yes, ok) is chosen.
 */
publicstaticfinalintAPPROVE_OPTION = 0;

/**
 * Return value if an error occurred.
 */
publicstaticfinalintERROR_OPTION = -1;


// **********************************
// ***** JFileChooser properties *****
// **********************************


/** Instruction to display only files. */
publicstaticfinalintFILES_ONLY = 0;

/** Instruction to display only directories. */
publicstaticfinalintDIRECTORIES_ONLY = 1;

/** Instruction to display both files and directories. */
publicstaticfinalintFILES_AND_DIRECTORIES = 2;

/** Instruction to cancel the current selection. */
publicstaticfinalStringCANCEL_SELECTION = "CancelSelection";

/**
 * Instruction to approve the current selection
 * (same as pressing yes or ok).
 */
publicstaticfinalStringAPPROVE_SELECTION = "ApproveSelection";

/** Identifies change in the text on the approve (yes, ok) button. */
publicstaticfinalStringAPPROVE_BUTTON_TEXT_CHANGED_PROPERTY = "ApproveButtonTextChangedProperty";

/**
 * Identifies change in the tooltip text for the approve (yes, ok)
 * button.
 */
publicstaticfinalStringAPPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY = "ApproveButtonToolTipTextChangedProperty";

/** Identifies change in the mnemonic for the approve (yes, ok) button. */
publicstaticfinalStringAPPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY = "ApproveButtonMnemonicChangedProperty";

/** Instruction to display the control buttons. */
publicstaticfinalStringCONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY = "ControlButtonsAreShownChangedProperty";

/** Identifies user's directory change. */
publicstaticfinalStringDIRECTORY_CHANGED_PROPERTY = "directoryChanged";

/** Identifies change in user's single-file selection. */
publicstaticfinalStringSELECTED_FILE_CHANGED_PROPERTY = "SelectedFileChangedProperty";

/** Identifies change in user's multiple-file selection. */
publicstaticfinalStringSELECTED_FILES_CHANGED_PROPERTY = "SelectedFilesChangedProperty";

/** Enables multiple-file selections. */
publicstaticfinalStringMULTI_SELECTION_ENABLED_CHANGED_PROPERTY = "MultiSelectionEnabledChangedProperty";

/**
 * Says that a different object is being used to find available drives
 * on the system.
 */
publicstaticfinalStringFILE_SYSTEM_VIEW_CHANGED_PROPERTY = "FileSystemViewChanged";

/**
 * Says that a different object is being used to retrieve file
 * information.
 */
publicstaticfinalStringFILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";

/** Identifies a change in the display-hidden-files property. */
publicstaticfinalStringFILE_HIDING_CHANGED_PROPERTY = "FileHidingChanged";

/** User changed the kind of files to display. */
publicstaticfinalStringFILE_FILTER_CHANGED_PROPERTY = "fileFilterChanged";

/**
 * Identifies a change in the kind of selection (single,
 * multiple, etc.).
 */
publicstaticfinalStringFILE_SELECTION_MODE_CHANGED_PROPERTY = "fileSelectionChanged";

/**
 * Says that a different accessory component is in use
 * (for example, to preview files).
 */
publicstaticfinalStringACCESSORY_CHANGED_PROPERTY = "AccessoryChangedProperty";

/**
 * Identifies whether the AcceptAllFileFilter is used or not.
 */
publicstaticfinalStringACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY = "acceptAllFileFilterUsedChanged";

/** Identifies a change in the dialog title. */
publicstaticfinalStringDIALOG_TITLE_CHANGED_PROPERTY = "DialogTitleChangedProperty";

/**
 * Identifies a change in the type of files displayed (files only,
 * directories only, or both files and directories).
 */
publicstaticfinalStringDIALOG_TYPE_CHANGED_PROPERTY = "DialogTypeChangedProperty";

/**
 * Identifies a change in the list of predefined file filters
 * the user can choose from.
 */
publicstaticfinalStringCHOOSABLE_FILE_FILTER_CHANGED_PROPERTY = "ChoosableFileFilterChangedProperty";

// ******************************
// ***** instance variables *****
// ******************************

privateStringdialogTitle = null;
privateStringapproveButtonText = null;
privateStringapproveButtonToolTipText = null;
privateintapproveButtonMnemonic = 0;

privateVector<FileFilter> filters = newVector<FileFilter>(5);
privateJDialogdialog = null;
privateintdialogType = OPEN_DIALOG;
privateintreturnValue = ERROR_OPTION;
privateJComponentaccessory = null;

privateFileViewfileView = null;

privatebooleancontrolsShown = true;

privatebooleanuseFileHiding = true;
privatestaticfinalStringSHOW_HIDDEN_PROP = "awt.file.showHiddenFiles";

// Listens to changes in the native setting for showing hidden files.
// The Listener is removed and the native setting is ignored if
// setFileHidingEnabled() is ever called.
privatetransientPropertyChangeListenershowFilesListener = null;

privateintfileSelectionMode = FILES_ONLY;

privatebooleanmultiSelectionEnabled = false;

privatebooleanuseAcceptAllFileFilter = true;

privatebooleandragEnabled = false;

privateFileFilterfileFilter = null;

privateFileSystemViewfileSystemView = null;

privateFilecurrentDirectory = null;
privateFileselectedFile = null;
privateFile[] selectedFiles;

// *************************************
// ***** JFileChooser Constructors *****
// *************************************

/**
 * Constructs a <code>JFileChooser</code> pointing to the user's
 * default directory. This default depends on the operating system.
 * It is typically the "Documents" folder on Windows, and the
 * user's home directory on Unix.
 */
publicJFileChooser() {
this((File) null, (FileSystemView) null);
 }

/**
 * Constructs a <code>JFileChooser</code> using the given path.
 * Passing in a <code>null</code>
 * string causes the file chooser to point to the user's default directory.
 * This default depends on the operating system. It is
 * typically the "Documents" folder on Windows, and the user's
 * home directory on Unix.
 *
 * @param currentDirectoryPath a <code>String</code> giving the path
 * to a file or directory
 */
publicJFileChooser(StringcurrentDirectoryPath) {
this(currentDirectoryPath, (FileSystemView) null);
 }

/**
 * Constructs a <code>JFileChooser</code> using the given <code>File</code>
 * as the path. Passing in a <code>null</code> file
 * causes the file chooser to point to the user's default directory.
 * This default depends on the operating system. It is
 * typically the "Documents" folder on Windows, and the user's
 * home directory on Unix.
 *
 * @param currentDirectory a <code>File</code> object specifying
 * the path to a file or directory
 */
publicJFileChooser(FilecurrentDirectory) {
this(currentDirectory, (FileSystemView) null);
 }

/**
 * Constructs a <code>JFileChooser</code> using the given
 * <code>FileSystemView</code>.
 *
 * @param fsv a {@code FileSystemView}
 */
publicJFileChooser(FileSystemViewfsv) {
this((File) null, fsv);
 }


/**
 * Constructs a <code>JFileChooser</code> using the given current directory
 * and <code>FileSystemView</code>.
 *
 * @param currentDirectory a {@code File} object specifying the path to a
 * file or directory
 * @param fsv a {@code FileSystemView}
 */
publicJFileChooser(FilecurrentDirectory, FileSystemViewfsv) {
setup(fsv);
setCurrentDirectory(currentDirectory);
 }

/**
 * Constructs a <code>JFileChooser</code> using the given current directory
 * path and <code>FileSystemView</code>.
 *
 * @param currentDirectoryPath a {@code String} specifying the path to a file
 * or directory
 * @param fsv a {@code FileSystemView}
 */
publicJFileChooser(StringcurrentDirectoryPath, FileSystemViewfsv) {
setup(fsv);
if(currentDirectoryPath == null) {
setCurrentDirectory(null);
 } else {
setCurrentDirectory(fileSystemView.createFileObject(currentDirectoryPath));
 }
 }

/**
 * Performs common constructor initialization and setup.
 *
 * @param view the {@code FileSystemView} used for setup
 */
protectedvoidsetup(FileSystemViewview) {
installShowFilesListener();
installHierarchyListener();

if(view == null) {
view = FileSystemView.getFileSystemView();
 }
setFileSystemView(view);
updateUI();
if(isAcceptAllFileFilterUsed()) {
setFileFilter(getAcceptAllFileFilter());
 }
enableEvents(AWTEvent.MOUSE_EVENT_MASK);
 }

privatevoidinstallHierarchyListener() {
addHierarchyListener(newFCHierarchyListener());
 }

privatevoidinstallShowFilesListener() {
// Track native setting for showing hidden files
Toolkittk = Toolkit.getDefaultToolkit();
ObjectshowHiddenProperty = tk.getDesktopProperty(SHOW_HIDDEN_PROP);
if (showHiddenPropertyinstanceofBoolean) {
useFileHiding = !((Boolean)showHiddenProperty).booleanValue();
showFilesListener = newWeakPCL(this);
tk.addPropertyChangeListener(SHOW_HIDDEN_PROP, showFilesListener);
 }
 }

/**
 * Sets the <code>dragEnabled</code> property,
 * which must be <code>true</code> to enable
 * automatic drag handling (the first part of drag and drop)
 * on this component.
 * The <code>transferHandler</code> property needs to be set
 * to a non-<code>null</code> value for the drag to do
 * anything. The default value of the <code>dragEnabled</code>
 * property
 * is <code>false</code>.
 *
 * <p>
 *
 * When automatic drag handling is enabled,
 * most look and feels begin a drag-and-drop operation
 * whenever the user presses the mouse button over an item
 * and then moves the mouse a few pixels.
 * Setting this property to <code>true</code>
 * can therefore have a subtle effect on
 * how selections behave.
 *
 * <p>
 *
 * Some look and feels might not support automatic drag and drop;
 * they will ignore this property. You can work around such
 * look and feels by modifying the component
 * to directly call the <code>exportAsDrag</code> method of a
 * <code>TransferHandler</code>.
 *
 * @param b the value to set the <code>dragEnabled</code> property to
 * @throws HeadlessException if
 * <code>b</code> is <code>true</code> and
 * <code>GraphicsEnvironment.isHeadless()</code>
 * returns <code>true</code>
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @see #getDragEnabled
 * @see #setTransferHandler
 * @see TransferHandler
 * @since 1.4
 */
@BeanProperty(bound = false, description
 = "determines whether automatic drag handling is enabled")
publicvoidsetDragEnabled(booleanb) {
checkDragEnabled(b);
dragEnabled = b;
 }

privatestaticvoidcheckDragEnabled(booleanb) {
if (b && GraphicsEnvironment.isHeadless()) {
thrownewHeadlessException();
 }
 }

/**
 * Gets the value of the <code>dragEnabled</code> property.
 *
 * @return the value of the <code>dragEnabled</code> property
 * @see #setDragEnabled
 * @since 1.4
 */
publicbooleangetDragEnabled() {
returndragEnabled;
 }

// *****************************
// ****** File Operations ******
// *****************************

/**
 * Returns the selected file. This can be set either by the
 * programmer via <code>setSelectedFile</code> or by a user action, such as
 * either typing the filename into the UI or selecting the
 * file from a list in the UI.
 *
 * @see #setSelectedFile
 * @return the selected file
 */
publicFilegetSelectedFile() {
returnselectedFile;
 }

/**
 * Sets the selected file. If the file's parent directory is
 * not the current directory, changes the current directory
 * to be the file's parent directory.
 *
 * @see #getSelectedFile
 *
 * @param file the selected file
 */
@BeanProperty(preferred = true)
publicvoidsetSelectedFile(Filefile) {
FileoldValue = selectedFile;
selectedFile = file;
if(selectedFile != null) {
if (file.isAbsolute() && !getFileSystemView().isParent(getCurrentDirectory(), selectedFile)) {
setCurrentDirectory(selectedFile.getParentFile());
 }
if (!isMultiSelectionEnabled() || selectedFiles == null || selectedFiles.length == 1) {
ensureFileIsVisible(selectedFile);
 }
 }
firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, oldValue, selectedFile);
 }

/**
 * Returns a list of selected files if the file chooser is
 * set to allow multiple selection.
 *
 * @return an array of selected {@code File}s
 */
publicFile[] getSelectedFiles() {
if(selectedFiles == null) {
returnnewFile[0];
 } else {
returnselectedFiles.clone();
 }
 }

/**
 * Sets the list of selected files if the file chooser is
 * set to allow multiple selection.
 *
 * @param selectedFiles an array {@code File}s to be selected
 */
@BeanProperty(description
 = "The list of selected files if the chooser is in multiple selection mode.")
publicvoidsetSelectedFiles(File[] selectedFiles) {
File[] oldValue = this.selectedFiles;
if (selectedFiles == null || selectedFiles.length == 0) {
selectedFiles = null;
this.selectedFiles = null;
setSelectedFile(null);
 } else {
this.selectedFiles = selectedFiles.clone();
setSelectedFile(this.selectedFiles[0]);
 }
firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, oldValue, selectedFiles);
 }

/**
 * Returns the current directory.
 *
 * @return the current directory
 * @see #setCurrentDirectory
 */
publicFilegetCurrentDirectory() {
returncurrentDirectory;
 }

/**
 * Sets the current directory. Passing in <code>null</code> sets the
 * file chooser to point to the user's default directory.
 * This default depends on the operating system. It is
 * typically the "Documents" folder on Windows, and the user's
 * home directory on Unix.
 *
 * If the file passed in as <code>currentDirectory</code> is not a
 * directory, the parent of the file will be used as the currentDirectory.
 * If the parent is not traversable, then it will walk up the parent tree
 * until it finds a traversable directory, or hits the root of the
 * file system.
 *
 * @param dir the current directory to point to
 * @see #getCurrentDirectory
 */
@BeanProperty(preferred = true, description
 = "The directory that the JFileChooser is showing files of.")
publicvoidsetCurrentDirectory(Filedir) {
FileoldValue = currentDirectory;

if (dir != null && !dir.exists()) {
dir = currentDirectory;
 }
if (dir == null) {
dir = getFileSystemView().getDefaultDirectory();
 }
if (currentDirectory != null) {
/* Verify the toString of object */
if (this.currentDirectory.equals(dir)) {
return;
 }
 }

Fileprev = null;
while (!isTraversable(dir) && prev != dir) {
prev = dir;
dir = getFileSystemView().getParentDirectory(dir);
 }
currentDirectory = dir;

firePropertyChange(DIRECTORY_CHANGED_PROPERTY, oldValue, currentDirectory);
 }

/**
 * Changes the directory to be set to the parent of the
 * current directory.
 *
 * @see #getCurrentDirectory
 */
publicvoidchangeToParentDirectory() {
selectedFile = null;
FileoldValue = getCurrentDirectory();
setCurrentDirectory(getFileSystemView().getParentDirectory(oldValue));
 }

/**
 * Tells the UI to rescan its files list from the current directory.
 */
publicvoidrescanCurrentDirectory() {
getUI().rescanCurrentDirectory(this);
 }

/**
 * Makes sure that the specified file is viewable, and
 * not hidden.
 *
 * @param f a File object
 */
publicvoidensureFileIsVisible(Filef) {
getUI().ensureFileIsVisible(this, f);
 }

// **************************************
// ***** JFileChooser Dialog methods *****
// **************************************

/**
 * Pops up an "Open File" file chooser dialog. Note that the
 * text that appears in the approve button is determined by
 * the L&amp;F.
 *
 * @param parent the parent component of the dialog,
 * can be <code>null</code>;
 * see <code>showDialog</code> for details
 * @return the return state of the file chooser on popdown:
 * <ul>
 * <li>JFileChooser.CANCEL_OPTION
 * <li>JFileChooser.APPROVE_OPTION
 * <li>JFileChooser.ERROR_OPTION if an error occurs or the
 * dialog is dismissed
 * </ul>
 * @throws HeadlessException if GraphicsEnvironment.isHeadless()
 * returns true.
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @see #showDialog
 */
publicintshowOpenDialog(Componentparent) throwsHeadlessException {
setDialogType(OPEN_DIALOG);
returnshowDialog(parent, null);
 }

/**
 * Pops up a "Save File" file chooser dialog. Note that the
 * text that appears in the approve button is determined by
 * the L&amp;F.
 *
 * @param parent the parent component of the dialog,
 * can be <code>null</code>;
 * see <code>showDialog</code> for details
 * @return the return state of the file chooser on popdown:
 * <ul>
 * <li>JFileChooser.CANCEL_OPTION
 * <li>JFileChooser.APPROVE_OPTION
 * <li>JFileChooser.ERROR_OPTION if an error occurs or the
 * dialog is dismissed
 * </ul>
 * @throws HeadlessException if GraphicsEnvironment.isHeadless()
 * returns true.
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @see #showDialog
 */
publicintshowSaveDialog(Componentparent) throwsHeadlessException {
setDialogType(SAVE_DIALOG);
returnshowDialog(parent, null);
 }

/**
 * Pops a custom file chooser dialog with a custom approve button.
 * For example, the following code
 * pops up a file chooser with a "Run Application" button
 * (instead of the normal "Save" or "Open" button):
 * <pre>
 * filechooser.showDialog(parentFrame, "Run Application");
 * </pre>
 *
 * Alternatively, the following code does the same thing:
 * <pre>
 * JFileChooser chooser = new JFileChooser(null);
 * chooser.setApproveButtonText("Run Application");
 * chooser.showDialog(parentFrame, null);
 * </pre>
 *
 * <!--PENDING(jeff) - the following method should be added to the api:
 * showDialog(Component parent);-->
 * <!--PENDING(kwalrath) - should specify modality and what
 * "depends" means.-->
 *
 * <p>
 *
 * The <code>parent</code> argument determines two things:
 * the frame on which the open dialog depends and
 * the component whose position the look and feel
 * should consider when placing the dialog. If the parent
 * is a <code>Frame</code> object (such as a <code>JFrame</code>)
 * then the dialog depends on the frame and
 * the look and feel positions the dialog
 * relative to the frame (for example, centered over the frame).
 * If the parent is a component, then the dialog
 * depends on the frame containing the component,
 * and is positioned relative to the component
 * (for example, centered over the component).
 * If the parent is <code>null</code>, then the dialog depends on
 * no visible window, and it's placed in a
 * look-and-feel-dependent position
 * such as the center of the screen.
 *
 * @param parent the parent component of the dialog;
 * can be <code>null</code>
 * @param approveButtonText the text of the <code>ApproveButton</code>
 * @return the return state of the file chooser on popdown:
 * <ul>
 * <li>JFileChooser.CANCEL_OPTION
 * <li>JFileChooser.APPROVE_OPTION
 * <li>JFileChooser.ERROR_OPTION if an error occurs or the
 * dialog is dismissed
 * </ul>
 * @throws HeadlessException if GraphicsEnvironment.isHeadless()
 * returns true.
 * @see java.awt.GraphicsEnvironment#isHeadless
 */
@SuppressWarnings("deprecation")
publicintshowDialog(Componentparent, StringapproveButtonText)
throwsHeadlessException {
if (dialog != null) {
// Prevent to show second instance of dialog if the previous one still exists
returnJFileChooser.ERROR_OPTION;
 }

if(approveButtonText != null) {
setApproveButtonText(approveButtonText);
setDialogType(CUSTOM_DIALOG);
 }
dialog = createDialog(parent);
dialog.addWindowListener(newWindowAdapter() {
publicvoidwindowClosing(WindowEvente) {
returnValue = CANCEL_OPTION;
 }
 });
returnValue = ERROR_OPTION;
rescanCurrentDirectory();

dialog.show();
firePropertyChange("JFileChooserDialogIsClosingProperty", dialog, null);

// Remove all components from dialog. The MetalFileChooserUI.installUI() method (and other LAFs)
// registers AWT listener for dialogs and produces memory leaks. It happens when
// installUI invoked after the showDialog method.
dialog.getContentPane().removeAll();
dialog.dispose();
dialog = null;
returnreturnValue;
 }

/**
 * Creates and returns a new <code>JDialog</code> wrapping
 * <code>this</code> centered on the <code>parent</code>
 * in the <code>parent</code>'s frame.
 * This method can be overridden to further manipulate the dialog,
 * to disable resizing, set the location, etc. Example:
 * <pre>
 * class MyFileChooser extends JFileChooser {
 * protected JDialog createDialog(Component parent) throws HeadlessException {
 * JDialog dialog = super.createDialog(parent);
 * dialog.setLocation(300, 200);
 * dialog.setResizable(false);
 * return dialog;
 * }
 * }
 * </pre>
 *
 * @param parent the parent component of the dialog;
 * can be <code>null</code>
 * @return a new <code>JDialog</code> containing this instance
 * @throws HeadlessException if GraphicsEnvironment.isHeadless()
 * returns true.
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @since 1.4
 */
protectedJDialogcreateDialog(Componentparent) throwsHeadlessException {
FileChooserUIui = getUI();
Stringtitle = ui.getDialogTitle(this);
putClientProperty(AccessibleContext.ACCESSIBLE_DESCRIPTION_PROPERTY,
title);

JDialogdialog;
Windowwindow = JOptionPane.getWindowForComponent(parent);
if (windowinstanceofFrame) {
dialog = newJDialog((Frame)window, title, true);
 } else {
dialog = newJDialog((Dialog)window, title, true);
 }
dialog.setComponentOrientation(this.getComponentOrientation());

ContainercontentPane = dialog.getContentPane();
contentPane.setLayout(newBorderLayout());
contentPane.add(this, BorderLayout.CENTER);

if (JDialog.isDefaultLookAndFeelDecorated()) {
booleansupportsWindowDecorations =
UIManager.getLookAndFeel().getSupportsWindowDecorations();
if (supportsWindowDecorations) {
dialog.getRootPane().setWindowDecorationStyle(JRootPane.FILE_CHOOSER_DIALOG);
 }
 }
dialog.pack();
dialog.setLocationRelativeTo(parent);

returndialog;
 }

// **************************
// ***** Dialog Options *****
// **************************

/**
 * Returns the value of the <code>controlButtonsAreShown</code>
 * property.
 *
 * @return the value of the <code>controlButtonsAreShown</code>
 * property
 *
 * @see #setControlButtonsAreShown
 * @since 1.3
 */
publicbooleangetControlButtonsAreShown() {
returncontrolsShown;
 }


/**
 * Sets the property
 * that indicates whether the <i>approve</i> and <i>cancel</i>
 * buttons are shown in the file chooser. This property
 * is <code>true</code> by default. Look and feels
 * that always show these buttons will ignore the value
 * of this property.
 * This method fires a property-changed event,
 * using the string value of
 * <code>CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY</code>
 * as the name of the property.
 *
 * @param b <code>false</code> if control buttons should not be
 * shown; otherwise, <code>true</code>
 *
 * @see #getControlButtonsAreShown
 * @see #CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY
 * @since 1.3
 */
@BeanProperty(preferred = true, description
 = "Sets whether the approve & cancel buttons are shown.")
publicvoidsetControlButtonsAreShown(booleanb) {
if(controlsShown == b) {
return;
 }
booleanoldValue = controlsShown;
controlsShown = b;
firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY, oldValue, controlsShown);
 }

/**
 * Returns the type of this dialog. The default is
 * <code>JFileChooser.OPEN_DIALOG</code>.
 *
 * @return the type of dialog to be displayed:
 * <ul>
 * <li>JFileChooser.OPEN_DIALOG
 * <li>JFileChooser.SAVE_DIALOG
 * <li>JFileChooser.CUSTOM_DIALOG
 * </ul>
 *
 * @see #setDialogType
 */
publicintgetDialogType() {
returndialogType;
 }

/**
 * Sets the type of this dialog. Use <code>OPEN_DIALOG</code> when you
 * want to bring up a file chooser that the user can use to open a file.
 * Likewise, use <code>SAVE_DIALOG</code> for letting the user choose
 * a file for saving.
 * Use <code>CUSTOM_DIALOG</code> when you want to use the file
 * chooser in a context other than "Open" or "Save".
 * For instance, you might want to bring up a file chooser that allows
 * the user to choose a file to execute. Note that you normally would not
 * need to set the <code>JFileChooser</code> to use
 * <code>CUSTOM_DIALOG</code>
 * since a call to <code>setApproveButtonText</code> does this for you.
 * The default dialog type is <code>JFileChooser.OPEN_DIALOG</code>.
 *
 * @param dialogType the type of dialog to be displayed:
 * <ul>
 * <li>JFileChooser.OPEN_DIALOG
 * <li>JFileChooser.SAVE_DIALOG
 * <li>JFileChooser.CUSTOM_DIALOG
 * </ul>
 *
 * @throws IllegalArgumentException if <code>dialogType</code> is
 * not legal
 *
 * @see #getDialogType
 * @see #setApproveButtonText
 */
// PENDING(jeff) - fire button text change property
@BeanProperty(preferred = true, enumerationValues = {
"JFileChooser.OPEN_DIALOG",
"JFileChooser.SAVE_DIALOG",
"JFileChooser.CUSTOM_DIALOG"}, description
 = "The type (open, save, custom) of the JFileChooser.")
publicvoidsetDialogType(intdialogType) {
if(this.dialogType == dialogType) {
return;
 }
checkDialogType(dialogType);
intoldValue = this.dialogType;
this.dialogType = dialogType;
if(dialogType == OPEN_DIALOG || dialogType == SAVE_DIALOG) {
setApproveButtonText(null);
 }
firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, oldValue, dialogType);
 }

privatestaticvoidcheckDialogType(intdialogType) {
if (!(dialogType == OPEN_DIALOG || dialogType == SAVE_DIALOG
 || dialogType == CUSTOM_DIALOG)) {
thrownewIllegalArgumentException(
"Incorrect Dialog Type: " + dialogType);
 }
 }

/**
 * Sets the string that goes in the <code>JFileChooser</code> window's
 * title bar.
 *
 * @param dialogTitle the new <code>String</code> for the title bar
 *
 * @see #getDialogTitle
 *
 */
@BeanProperty(preferred = true, description
 = "The title of the JFileChooser dialog window.")
publicvoidsetDialogTitle(StringdialogTitle) {
StringoldValue = this.dialogTitle;
this.dialogTitle = dialogTitle;
if(dialog != null) {
dialog.setTitle(dialogTitle);
 }
firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, oldValue, dialogTitle);
 }

/**
 * Gets the string that goes in the <code>JFileChooser</code>'s titlebar.
 *
 * @return the string from the {@code JFileChooser} window's title bar
 * @see #setDialogTitle
 */
publicStringgetDialogTitle() {
returndialogTitle;
 }

// ************************************
// ***** JFileChooser View Options *****
// ************************************



/**
 * Sets the tooltip text used in the <code>ApproveButton</code>.
 * If <code>null</code>, the UI object will determine the button's text.
 *
 * @param toolTipText the tooltip text for the approve button