001 /* JFileChooser.java --
002 Copyright (C) 2002, 2004, 2005, 2006, Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038 package javax.swing;
039
040 import java.awt.Component;
041 import java.awt.Frame;
042 import java.awt.GraphicsEnvironment;
043 import java.awt.HeadlessException;
044 import java.awt.event.ActionEvent;
045 import java.awt.event.ActionListener;
046 import java.awt.event.WindowEvent;
047 import java.awt.event.WindowAdapter;
048 import java.beans.PropertyChangeEvent;
049 import java.io.File;
050 import java.util.ArrayList;
051
052 import javax.accessibility.Accessible;
053 import javax.accessibility.AccessibleContext;
054 import javax.accessibility.AccessibleRole;
055 import javax.swing.filechooser.FileFilter;
056 import javax.swing.filechooser.FileSystemView;
057 import javax.swing.filechooser.FileView;
058 import javax.swing.plaf.FileChooserUI;
059
060
061 /**
062 * A component that provides the user a dialog box to browse through a
063 * filesystem and choose one or more files or directories.
064 *
065 * A JFileChooser can be configured to filter the displayed file list
066 * by adding a {@link FileFilter} instance using
067 * {@link #addChoosableFileFilter(FileFilter)}. Additional components can
068 * be embedded in the file chooser using {@link #setAccessory(JComponent)}.
069 * The JFileChooser properties also provide mechanisms to customize the
070 * behaviour of the file chooser.
071 *
072 * @author Kim Ho (kho@luxsci.net)
073 */
074 public class JFileChooser extends JComponent implements Accessible
075 {
076 private static final long serialVersionUID = 3162921138695327837L;
077
078 /**
079 * A dialog type for selecting a file to open.
080 * @see #setDialogType(int)
081 */
082 public static final int OPEN_DIALOG = 0;
083
084 /**
085 * A dialog type for selecting a file to save.
086 * @see #setDialogType(int)
087 */
088 public static final int SAVE_DIALOG = 1;
089
090 /**
091 * A dialog type for some custom purpose.
092 * @see #setDialogType(int)
093 */
094 public static final int CUSTOM_DIALOG = 2;
095
096 /**
097 * A return value indicating the file chooser has been closed by cancelling.
098 *
099 * @see #showOpenDialog(Component)
100 * @see #showSaveDialog(Component)
101 */
102 public static final int CANCEL_OPTION = 1;
103
104 /**
105 * A return value indicating the file chooser has been closed by approving
106 * the selection.
107 * @see #showOpenDialog(Component)
108 * @see #showSaveDialog(Component)
109 */
110 public static final int APPROVE_OPTION = 0;
111
112 /**
113 * A return value indicating the file chooser has been closed by some error.
114 * @see #showOpenDialog(Component)
115 * @see #showSaveDialog(Component)
116 */
117 public static final int ERROR_OPTION = -1;
118
119 /**
120 * A selection mode constant indicating acceptance of files only.
121 * @see #setFileSelectionMode(int)
122 */
123 public static final int FILES_ONLY = 0;
124
125 /**
126 * A selection mode constant indicating acceptance of directories only.
127 * @see #setFileSelectionMode(int)
128 */
129 public static final int DIRECTORIES_ONLY = 1;
130
131 /**
132 * A selection mode constant indicating acceptance of files and directories.
133 * @see #setFileSelectionMode(int)
134 */
135 public static final int FILES_AND_DIRECTORIES = 2;
136
137 /**
138 * Action command string for cancelling the current selection.
139 * @see #cancelSelection()
140 */
141 public static final String CANCEL_SELECTION = "CancelSelection";
142
143 /**
144 * Action command string for approving the current selection.
145 * @see #cancelSelection()
146 */
147 public static final String APPROVE_SELECTION = "ApproveSelection";
148
149 /**
150 * The name of the property for the approve button text.
151 * @see #setApproveButtonText(String)
152 */
153 public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY =
154 "ApproveButtonTextChangedProperty";
155
156 /**
157 * The name of the property for the approve button tool tip text.
158 * @see #setApproveButtonToolTipText(String)
159 */
160 public static final String APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY =
161 "ApproveButtonToolTipTextChangedProperty";
162
163 /**
164 * The name of the property for the approve button mnemonic.
165 * @see #setApproveButtonMnemonic(int)
166 */
167 public static final String APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY =
168 "ApproveButtonMnemonicChangedProperty";
169
170 /**
171 * The name of the property for control button visibility.
172 * @see #setControlButtonsAreShown(boolean)
173 */
174 public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY =
175 "ControlButtonsAreShownChangedProperty";
176
177 /**
178 * The name of the property for the current directory.
179 * @see #setCurrentDirectory(File)
180 */
181 public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged";
182
183 /**
184 * The name of the property for the selected file.
185 * @see #setSelectedFile(File)
186 */
187 public static final String SELECTED_FILE_CHANGED_PROPERTY =
188 "SelectedFileChangedProperty";
189
190 /**
191 * The name of the property for the selected files.
192 * @see #setSelectedFiles(File[])
193 */
194 public static final String SELECTED_FILES_CHANGED_PROPERTY =
195 "SelectedFilesChangedProperty";
196
197 /**
198 * The name of the property for multi-selection.
199 * @see #setMultiSelectionEnabled(boolean)
200 */
201 public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY =
202 "MultiSelectionEnabledChangedProperty";
203
204 /**
205 * The name of the 'file system view' property.
206 * @see #setFileSystemView(FileSystemView)
207 */
208 public static final String FILE_SYSTEM_VIEW_CHANGED_PROPERTY =
209 "FileSystemViewChanged";
210
211 /**
212 * The name of the 'file view' property.
213 * @see #setFileView(FileView)
214 */
215 public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";
216
217 /**
218 * The name of the 'file hiding enabled' property.
219 * @see #setFileHidingEnabled(boolean)
220 */
221 public static final String FILE_HIDING_CHANGED_PROPERTY =
222 "FileHidingChanged";
223
224 /**
225 * The name of the 'file filter' property.
226 * @see #setFileFilter(FileFilter)
227 */
228 public static final String FILE_FILTER_CHANGED_PROPERTY =
229 "fileFilterChanged";
230
231 /**
232 * The name of the 'file selection mode' property.
233 * @see #setFileSelectionMode(int)
234 */
235 public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY =
236 "fileSelectionChanged";
237
238 /**
239 * The name of the 'accessory' property.
240 * @see #setAccessory(JComponent)
241 */
242 public static final String ACCESSORY_CHANGED_PROPERTY =
243 "AccessoryChangedProperty";
244
245 /**
246 * The name of the 'accept all file filter used' property.
247 * @see #setAcceptAllFileFilterUsed(boolean)
248 */
249 public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY =
250 "acceptAllFileFilterUsedChanged";
251
252 /**
253 * The name of the 'dialog title' property.
254 * @see #setDialogTitle(String)
255 */
256 public static final String DIALOG_TITLE_CHANGED_PROPERTY =
257 "DialogTitleChangedProperty";
258
259 /**
260 * The name of the 'dialog type' property.
261 * @see #setDialogType(int)
262 */
263 public static final String DIALOG_TYPE_CHANGED_PROPERTY =
264 "DialogTypeChangedProperty";
265
266 /**
267 * The name of the 'choosable file filters' property.
268 * @see #addChoosableFileFilter(FileFilter)
269 */
270 public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY =
271 "ChoosableFileFilterChangedProperty";
272
273 /**
274 * The accessible context.
275 * @see #getAccessibleContext()
276 */
277 protected AccessibleContext accessibleContext;
278
279 /**
280 * The file system view.
281 * @see #setFileSystemView(FileSystemView)
282 */
283 private FileSystemView fsv;
284
285 /**
286 * The accessory component.
287 * @see #setAccessory(JComponent)
288 */
289 private JComponent accessory;
290
291 /**
292 * The approve button mnemonic.
293 * @see #setApproveButtonMnemonic(int)
294 */
295 private int approveButtonMnemonic = 0;
296
297 /**
298 * The approve button text.
299 * @see #setApproveButtonText(String)
300 */
301 private String approveButtonText;
302
303 /**
304 * The approve button tool tip text.
305 * @see #setApproveButtonToolTipText(String)
306 */
307 private String approveButtonToolTipText;
308
309 /**
310 * The choosable file filters.
311 * @see #addChoosableFileFilter(FileFilter)
312 */
313 private ArrayList choosableFilters = new ArrayList();
314
315 /**
316 * A flag controlling whether the accept all file filter is used.
317 * @see #setAcceptAllFileFilterUsed(boolean)
318 */
319 private boolean isAcceptAll = true;
320
321 /**
322 * The dialog title.
323 * @see #setDialogTitle(String)
324 */
325 private String dialogTitle;
326
327 /**
328 * The dialog type.
329 * @see #setDialogType(int)
330 */
331 private int dialogType = OPEN_DIALOG;
332
333 /**
334 * The return value for the dialog.
335 * @see #showOpenDialog(Component)
336 * @see #showSaveDialog(Component)
337 */
338 private int retval = ERROR_OPTION;
339
340 /**
341 * A flag indicating whether the file chooser allows multiple selection.
342 * @see #isMultiSelectionEnabled()
343 */
344 private boolean multiSelection = false;
345
346 /**
347 * A flag indicating whether file hiding is enabled.
348 * @see #isFileHidingEnabled()
349 */
350 private boolean fileHiding = true;
351
352 /**
353 * The file selection mode.
354 * @see #setFileSelectionMode(int)
355 */
356 private int fileSelectionMode = FILES_ONLY;
357
358 /**
359 * The file view.
360 * @see #setFileView(FileView)
361 */
362 private FileView fv = null;
363
364 /**
365 * A flag controlling whether or not the control buttons are visible.
366 * @see #setControlButtonsAreShown(boolean)
367 */
368 private boolean controlButtonsShown = true;
369
370 /**
371 * The current directory.
372 * @see #setCurrentDirectory(File)
373 */
374 private File currentDir = null;
375
376 /**
377 * The current file filter.
378 * @see #setFileFilter(FileFilter)
379 */
380 private FileFilter currentFilter = null;
381
382 /**
383 * An array of selected files.
384 * @see #setSelectedFiles(File[])
385 */
386 private File[] selectedFiles;
387
388 /**
389 * The selected file.
390 * @see #setSelectedFile(File)
391 */
392 private File selectedFile;
393
394 /**
395 * The drag enabled property.
396 * @see #setDragEnabled(boolean)
397 * @see #getDragEnabled()
398 */
399 private boolean dragEnabled;
400
401 /**
402 * Creates a new <code>JFileChooser</code> object.
403 */
404 public JFileChooser()
405 {
406 setup(null);
407 setCurrentDirectory(null);
408 }
409
410 /**
411 * Creates a new <code>JFileChooser</code> object.
412 *
413 * @param currentDirectoryPath the directory that should initially be
414 * shown in the filechooser (if <code>null</code>, the user's home
415 * directory is used).
416 */
417 public JFileChooser(String currentDirectoryPath)
418 {
419 this(currentDirectoryPath, null);
420 }
421
422 /**
423 * Creates a new <code>JFileChooser</code> object with the specified
424 * directory and {@link FileSystemView}.
425 *
426 * @param currentDirectoryPath the directory that should initially be
427 * shown in the filechooser (if <code>null</code>, the user's home
428 * directory is used).
429 * @param fsv the file system view (if <code>null</code>, the default file
430 * system view is used).
431 */
432 public JFileChooser(String currentDirectoryPath, FileSystemView fsv)
433 {
434 setup(fsv);
435 File dir = null;
436 if (currentDirectoryPath != null)
437 dir = getFileSystemView().createFileObject(currentDirectoryPath);
438 setCurrentDirectory(dir);
439 }
440
441 /**
442 * Creates a new <code>JFileChooser</code> object.
443 *
444 * @param currentDirectory the directory that should initially be
445 * shown in the filechooser (if <code>null</code>, the user's home
446 * directory is used).
447 */
448 public JFileChooser(File currentDirectory)
449 {
450 setup(null);
451 setCurrentDirectory(currentDirectory);
452 }
453
454 /**
455 * Creates a new <code>JFileChooser</code> object.
456 *
457 * @param fsv the file system view (if <code>null</code>, the default file
458 * system view is used).
459 */
460 public JFileChooser(FileSystemView fsv)
461 {
462 setup(fsv);
463 setCurrentDirectory(null);
464 }
465
466 /**
467 * Creates a new <code>JFileChooser</code> object.
468 *
469 * @param currentDirectory the directory that should initially be
470 * shown in the filechooser (if <code>null</code>, the user's home
471 * directory is used).
472 * @param fsv the file system view (if <code>null</code>, the default file
473 * system view is used).
474 */
475 public JFileChooser(File currentDirectory, FileSystemView fsv)
476 {
477 setup(fsv);
478 setCurrentDirectory(currentDirectory);
479 }
480
481 /**
482 * Sets up the file chooser. This method is called by all the constructors.
483 *
484 * @param view the file system view (if <code>null</code>, the default file
485 * system view is used).
486 *
487 * @see FileSystemView#getFileSystemView()
488 */
489 protected void setup(FileSystemView view)
490 {
491 if (view == null)
492 view = FileSystemView.getFileSystemView();
493 setFileSystemView(view);
494 updateUI();
495 }
496
497 /**
498 * Sets the dragEnabled property, this disables/enables automatic drag
499 * handling (drag and drop) on this component. The default value of the
500 * dragEnabled property is false.
501 *
502 * Some look and feels might not support automatic drag and drop; they
503 * will ignore this property.
504 *
505 * @param b - the new dragEnabled value
506 */
507 public void setDragEnabled(boolean b)
508 {
509 if (b && GraphicsEnvironment.isHeadless())
510 throw new HeadlessException();
511
512 dragEnabled = b;
513 }
514
515 /**
516 * Returns true if dragging is enabled.
517 *
518 * @return true if dragging is enabled.
519 */
520 public boolean getDragEnabled()
521 {
522 return dragEnabled;
523 }
524
525 /**
526 * Returns the selected file, if there is one.
527 *
528 * @return The selected file (possibly <code>null</code>).
529 *
530 * @see #setSelectedFile(File)
531 */
532 public File getSelectedFile()
533 {
534 return selectedFile;
535 }
536
537 /**
538 * Sets the selected file and sends a {@link PropertyChangeEvent} to all
539 * registered listeners. The property name is
540 * {@link #SELECTED_FILE_CHANGED_PROPERTY}.
541 *
542 * @param file the file (<code>null</code> permitted).
543 */
544 public void setSelectedFile(File file)
545 {
546 if (selectedFile == null || !selectedFile.equals(file))
547 {
548 File old = selectedFile;
549 selectedFile = file;
550 firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, old, selectedFile);
551 }
552 }
553
554 /**
555 * Returns the selected file or files in an array. If no files are selected,
556 * an empty array is returned.
557 *
558 * @return An array of the selected files (possibly empty).
559 */
560 public File[] getSelectedFiles()
561 {
562 if (selectedFiles != null)
563 return selectedFiles;
564 if (selectedFile != null)
565 return new File[] { selectedFile };
566 return new File[0];
567 }
568
569 /**
570 * Sets the selected files and sends a {@link PropertyChangeEvent} (with the
571 * name {@link #SELECTED_FILES_CHANGED_PROPERTY}) to all registered
572 * listeners.
573 *
574 * @param selectedFiles the selected files (<code>null</code> permitted).
575 */
576 public void setSelectedFiles(File[] selectedFiles)
577 {
578 if (selectedFiles == null)
579 selectedFiles = new File[0];
580 if (selectedFiles.length > 0)
581 setSelectedFile(selectedFiles[0]);
582 else
583 setSelectedFile(null);
584 if (this.selectedFiles != selectedFiles)
585 {
586 File[] old = this.selectedFiles;
587 this.selectedFiles = selectedFiles;
588 firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, old, selectedFiles);
589 }
590
591 }
592
593 /**
594 * Returns the current directory.
595 *
596 * @return The current directory.
597 */
598 public File getCurrentDirectory()
599 {
600 return currentDir;
601 }
602
603 /**
604 * Sets the current directory and fires a {@link PropertyChangeEvent} (with
605 * the property name {@link #DIRECTORY_CHANGED_PROPERTY}) to all registered
606 * listeners. If <code>dir</code> is <code>null</code>, the current
607 * directory is set to the default directory returned by the file system
608 * view.
609 *
610 * @param dir the new directory (<code>null</code> permitted).
611 *
612 * @see FileSystemView#getDefaultDirectory()
613 */
614 public void setCurrentDirectory(File dir)
615 {
616 if (currentDir != dir || dir == null)
617 {
618 if (dir == null)
619 dir = fsv.getDefaultDirectory();
620
621 File old = currentDir;
622 currentDir = dir;
623 firePropertyChange(DIRECTORY_CHANGED_PROPERTY, old, currentDir);
624 }
625 }
626
627 /**
628 * Called by the UI delegate when the parent directory is changed.
629 */
630 public void changeToParentDirectory()
631 {
632 setCurrentDirectory(fsv.getParentDirectory(currentDir));
633 }
634
635 /**
636 * Rescans the current directory (this is handled by the UI delegate).
637 */
638 public void rescanCurrentDirectory()
639 {
640 getUI().rescanCurrentDirectory(this);
641 }
642
643 /**
644 * Ensures the the specified file is visible (this is handled by the
645 * UI delegate).
646 *
647 * @param f the file.
648 */
649 public void ensureFileIsVisible(File f)
650 {
651 getUI().ensureFileIsVisible(this, f);
652 }
653
654 /**
655 * Displays the file chooser in a modal dialog using the
656 * {@link #OPEN_DIALOG} type.
657 *
658 * @param parent the parent component.
659 *
660 * @return A return value indicating how the dialog was closed (one of
661 * {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and
662 * {@link #ERROR_OPTION}).
663 *
664 * @throws HeadlessException DOCUMENT ME!
665 */
666 public int showOpenDialog(Component parent) throws HeadlessException
667 {
668 JDialog d = createDialog(parent);
669
670 // FIXME: Remove when we get ancestor property
671 d.setTitle("Open");
672 setDialogType(OPEN_DIALOG);
673
674 retval = ERROR_OPTION;
675
676 d.pack();
677 d.show();
678 return retval;
679 }
680
681 /**
682 * Displays the file chooser in a modal dialog using the
683 * {@link #SAVE_DIALOG} type.
684 *
685 * @param parent the parent component.
686 *
687 * @return A return value indicating how the dialog was closed (one of
688 * {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and
689 * {@link #ERROR_OPTION}).
690 *
691 * @throws HeadlessException DOCUMENT ME!
692 */
693 public int showSaveDialog(Component parent) throws HeadlessException
694 {
695 JDialog d = createDialog(parent);
696 setDialogType(SAVE_DIALOG);
697
698 retval = ERROR_OPTION;
699
700 d.pack();
701 d.show();
702 return retval;
703 }
704
705 /**
706 * Displays the file chooser in a modal dialog using the
707 * {@link #CUSTOM_DIALOG} type.
708 *
709 * @param parent the parent component.
710 *
711 * @return A return value indicating how the dialog was closed (one of
712 * {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and
713 * {@link #ERROR_OPTION}).
714 *
715 * @throws HeadlessException DOCUMENT ME!
716 */
717 public int showDialog(Component parent, String approveButtonText)
718 throws HeadlessException
719 {
720 JDialog d = createDialog(parent);
721 setApproveButtonText(approveButtonText);
722 setDialogType(CUSTOM_DIALOG);
723
724 retval = ERROR_OPTION;
725
726 d.pack();
727 d.show();
728 return retval;
729 }
730
731 /**
732 * Creates a modal dialog in which to display the file chooser.
733 *
734 * @param parent the parent component.
735 *
736 * @return The dialog.
737 *
738 * @throws HeadlessException DOCUMENT ME!
739 */
740 protected JDialog createDialog(Component parent) throws HeadlessException
741 {
742 Frame toUse = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);
743 if (toUse == null)
744 toUse = (Frame) SwingUtilities.getOwnerFrame(null);
745
746 JDialog dialog = new JDialog(toUse);
747 setSelectedFile(null);
748 dialog.getContentPane().add(this);
749 dialog.addWindowListener( new WindowAdapter()
750 {
751 public void windowClosing(WindowEvent e)
752 {
753 cancelSelection();
754 }
755 });
756 dialog.setModal(true);
757 dialog.invalidate();
758 dialog.repaint();
759 return dialog;
760 }
761
762 /**
763 * Returns the flag that controls whether or not the control buttons are
764 * shown on the file chooser.
765 *
766 * @return A boolean.
767 *
768 * @see #setControlButtonsAreShown(boolean)
769 */
770 public boolean getControlButtonsAreShown()
771 {
772 return controlButtonsShown;
773 }
774
775 /**
776 * Sets the flag that controls whether or not the control buttons are
777 * shown and, if it changes, sends a {@link PropertyChangeEvent} (with the
778 * property name {@link #CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY}) to
779 * all registered listeners.
780 *
781 * @param b the new value for the flag.
782 */
783 public void setControlButtonsAreShown(boolean b)
784 {
785 if (controlButtonsShown != b)
786 {
787 controlButtonsShown = b;
788 firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY,
789 ! controlButtonsShown, controlButtonsShown);
790 }
791 }
792
793 /**
794 * Returns the type of file chooser.
795 *
796 * @return {@link #OPEN_DIALOG}, {@link #SAVE_DIALOG} or
797 * {@link #CUSTOM_DIALOG}.
798 *
799 * @see #setDialogType(int)
800 */
801 public int getDialogType()
802 {
803 return dialogType;
804 }
805
806 /**
807 * Sets the dialog type and fires a {@link PropertyChangeEvent} (with the
808 * property name {@link #DIALOG_TYPE_CHANGED_PROPERTY}) to all
809 * registered listeners.
810 *
811 * @param dialogType the dialog type (one of: {@link #OPEN_DIALOG},
812 * {@link #SAVE_DIALOG}, {@link #CUSTOM_DIALOG}).
813 *
814 * @throws IllegalArgumentException if <code>dialogType</code> is not valid.
815 */
816 public void setDialogType(int dialogType)
817 {
818 if (dialogType != OPEN_DIALOG && dialogType != SAVE_DIALOG
819 && dialogType != CUSTOM_DIALOG)
820 throw new IllegalArgumentException("Choose allowable dialogType.");
821
822 if (this.dialogType != dialogType)
823 {
824 int old = this.dialogType;
825 this.dialogType = dialogType;
826 firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, old, this.dialogType);
827 }
828 }
829
830 /**
831 * Sets the dialog title and sends a {@link PropertyChangeEvent} (with the
832 * property name {@link #DIALOG_TITLE_CHANGED_PROPERTY}) to all
833 * registered listeners.
834 *
835 * @param dialogTitle the dialog title (<code>null</code> permitted).
836 *
837 * @see #getDialogTitle()
838 */
839 public void setDialogTitle(String dialogTitle)
840 {
841 if (this.dialogTitle != dialogTitle)
842 {
843 String old = this.dialogTitle;
844 this.dialogTitle = dialogTitle;
845 firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, old, this.dialogTitle);
846 }
847 }
848
849 /**
850 * Returns the dialog title.
851 *
852 * @return The dialog title (possibly <code>null</code>).
853 *
854 * @see #setDialogTitle(String)
855 */
856 public String getDialogTitle()
857 {
858 return dialogTitle;
859 }
860
861 /**
862 * Sets the tool tip text for the approve button and sends a
863 * {@link PropertyChangeEvent} (with the property name
864 * {@link #APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY}) to all
865 * registered listeners.
866 *
867 * @param toolTipText the text.
868 */
869 public void setApproveButtonToolTipText(String toolTipText)
870 {
871 if (approveButtonToolTipText != toolTipText)
872 {
873 String oldText = approveButtonToolTipText;
874 approveButtonToolTipText = toolTipText;
875 firePropertyChange(APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY,
876 oldText, approveButtonToolTipText);
877 }
878 }
879
880 /**
881 * Returns the tool tip text for the approve button.
882 *
883 * @return The tool tip text for the approve button.
884 *
885 * @see #setApproveButtonToolTipText(String)
886 */
887 public String getApproveButtonToolTipText()
888 {
889 return approveButtonToolTipText;
890 }
891
892 /**
893 * Returns the approve button mnemonic, or zero if no mnemonic has been set.
894 *
895 * @return The approve button mnemonic.
896 *
897 * @see #setApproveButtonMnemonic(int)
898 */
899 public int getApproveButtonMnemonic()
900 {
901 return approveButtonMnemonic;
902 }
903
904 /**
905 * Sets the mnemonic for the approve button and sends a
906 * {@link PropertyChangeEvent} (with the property name
907 * {@link #APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY}) to all registered
908 * listeners.
909 *
910 * @param mnemonic the mnemonic.
911 *
912 * @see #setApproveButtonMnemonic(char)
913 */
914 public void setApproveButtonMnemonic(int mnemonic)
915 {
916 if (approveButtonMnemonic != mnemonic)
917 {
918 int oldMnemonic = approveButtonMnemonic;
919 approveButtonMnemonic = mnemonic;
920 firePropertyChange(APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY,
921 oldMnemonic, approveButtonMnemonic);
922 }
923 }
924
925 /**
926 * Sets the mnemonic for the approve button and sends a
927 * {@link PropertyChangeEvent} (with the property name
928 * {@link #APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY}) to all registered
929 * listeners.
930 *
931 * @param mnemonic the mnemonic.
932 *
933 * @see #setApproveButtonMnemonic(int)
934 */
935 public void setApproveButtonMnemonic(char mnemonic)
936 {
937 setApproveButtonMnemonic((int) Character.toUpperCase(mnemonic));
938 }
939
940 /**
941 * Sets the approve button text and fires a {@link PropertyChangeEvent}
942 * (with the property name {@link #APPROVE_BUTTON_TEXT_CHANGED_PROPERTY}) to
943 * all registered listeners.
944 *
945 * @param approveButtonText the text (<code>null</code> permitted).
946 *
947 * @see #getApproveButtonText()
948 */
949 public void setApproveButtonText(String approveButtonText)
950 {
951 if (this.approveButtonText != approveButtonText)
952 {
953 String oldText = this.approveButtonText;
954 this.approveButtonText = approveButtonText;
955 firePropertyChange(APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, oldText,
956 this.approveButtonText);
957 }
958 }
959
960 /**
961 * Returns the approve button text.
962 *
963 * @return The approve button text (possibly <code>null</code>).
964 *
965 * @see #setApproveButtonText(String)
966 */
967 public String getApproveButtonText()
968 {
969 return approveButtonText;
970 }
971
972 /**
973 * Returns the available file filters for this file chooser.
974 *
975 * @return The available file filters.
976 */
977 public FileFilter[] getChoosableFileFilters()
978 {
979 return (FileFilter[]) choosableFilters.toArray(new FileFilter[choosableFilters.size()]);
980 }
981
982 /**
983 * Adds a file filter to the list of available filters and sends a
984 * {@link PropertyChangeEvent} (with the property name
985 * {@link #CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY}) to all registered
986 * listeners.
987 *
988 * @param filter the filter (<code>null</code> permitted).
989 */
990 public void addChoosableFileFilter(FileFilter filter)
991 {
992 if (filter != null)
993 {
994 FileFilter[] old = getChoosableFileFilters();
995 choosableFilters.add(filter);
996 FileFilter[] newFilters = getChoosableFileFilters();
997 firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, old,
998 newFilters);
999 }
1000 setFileFilter(filter);
1001 }
1002
1003 /**
1004 * Removes a file filter from the list of available filters and sends a
1005 * {@link PropertyChangeEvent} (with the property name
1006 * {@link #CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY}) to all registered
1007 * listeners.
1008 *
1009 * @param f the file filter.
1010 *
1011 * @return <code>true</code> if the filter was removed and
1012 * <code>false</code> otherwise.
1013 */
1014 public boolean removeChoosableFileFilter(FileFilter f)
1015 {
1016 if (f == currentFilter)
1017 setFileFilter(null);
1018 FileFilter[] old = getChoosableFileFilters();
1019 if (! choosableFilters.remove(f))
1020 return false;
1021 FileFilter[] newFilters = getChoosableFileFilters();
1022 firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, old, newFilters);
1023 return true;
1024 }
1025
1026 /**
1027 * Clears the list of choosable file filters and installs the 'accept all'
1028 * filter from the UI delegate.
1029 */
1030 public void resetChoosableFileFilters()
1031 {
1032 choosableFilters.clear();
1033 choosableFilters.add(getUI().getAcceptAllFileFilter(this));
1034 setFileFilter((FileFilter) choosableFilters.get(0));
1035 }
1036
1037 /**
1038 * Returns the 'accept all' file filter from the UI delegate.
1039 *
1040 * @return The 'accept all' file filter.
1041 */
1042 public FileFilter getAcceptAllFileFilter()
1043 {
1044 return getUI().getAcceptAllFileFilter(this);
1045 }
1046
1047 /**
1048 * Returns the flag that controls whether or not the 'accept all' file
1049 * filter is included in the list of filters.
1050 *
1051 * @return A boolean.
1052 *
1053 * @see #setAcceptAllFileFilterUsed(boolean)
1054 */
1055 public boolean isAcceptAllFileFilterUsed()
1056 {
1057 return isAcceptAll;
1058 }
1059
1060 /**
1061 * Sets the flag that controls whether or not the 'accept all' file filter
1062 * is included in the list of filters, and sends a
1063 * {@link PropertyChangeEvent} (with the property name
1064 * {@link #ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY}) to all registered
1065 * listeners.
1066 *
1067 * @param b the new value of the flag.
1068 */
1069 public void setAcceptAllFileFilterUsed(boolean b)
1070 {
1071 if (isAcceptAll != b)
1072 {
1073 isAcceptAll = b;
1074 if (b)
1075 addChoosableFileFilter(getAcceptAllFileFilter());
1076 else
1077 removeChoosableFileFilter(getAcceptAllFileFilter());
1078 firePropertyChange(ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY,
1079 ! isAcceptAll, isAcceptAll);
1080 }
1081 }
1082
1083 /**
1084 * Returns the accessory component for the file chooser. The default
1085 * value is <code>null</code>.
1086 *
1087 * @return The accessory component (possibly <code>null</code>).
1088 *
1089 * @see #setAccessory(JComponent)
1090 */
1091 public JComponent getAccessory()
1092 {
1093 return accessory;
1094 }
1095
1096 /**
1097 * Sets the accessory component for the file chooser and sends a
1098 * {@link PropertyChangeEvent} to all registered listeners. The property
1099 * name is {@link #ACCESSORY_CHANGED_PROPERTY}.
1100 *
1101 * @param newAccessory the accessory component.
1102 */
1103 public void setAccessory(JComponent newAccessory)
1104 {
1105 if (accessory != newAccessory)
1106 {
1107 JComponent old = accessory;
1108 accessory = newAccessory;
1109 firePropertyChange(ACCESSORY_CHANGED_PROPERTY, old, accessory);
1110 }
1111 }
1112
1113 /**
1114 * Sets the file selection mode and sends a {@link PropertyChangeEvent}
1115 * to all registered listeners. The property name is
1116 * {@link #FILE_SELECTION_MODE_CHANGED_PROPERTY}.
1117 *
1118 * @param mode the mode ({@link #FILES_ONLY}, {@link #DIRECTORIES_ONLY} or
1119 * {@link #FILES_AND_DIRECTORIES}).
1120 *
1121 * @throws IllegalArgumentException if the mode is invalid.
1122 */
1123 public void setFileSelectionMode(int mode)
1124 {
1125 if (mode != FILES_ONLY && mode != DIRECTORIES_ONLY
1126 && mode != FILES_AND_DIRECTORIES)
1127 throw new IllegalArgumentException("Choose a correct file selection mode.");
1128 if (fileSelectionMode != mode)
1129 {
1130 int old = fileSelectionMode;
1131 fileSelectionMode = mode;
1132 firePropertyChange(FILE_SELECTION_MODE_CHANGED_PROPERTY, old,
1133 fileSelectionMode);
1134 }
1135 }
1136
1137 /**
1138 * Returns the file selection mode, one of: {@link #FILES_ONLY},
1139 * {@link #DIRECTORIES_ONLY} or {@link #FILES_AND_DIRECTORIES}. The
1140 * default is {@link #FILES_ONLY}.
1141 *
1142 * @return The file selection mode.
1143 *
1144 * @see #setFileSelectionMode(int)
1145 */
1146 public int getFileSelectionMode()
1147 {
1148 return fileSelectionMode;
1149 }
1150
1151 /**
1152 * Returns <code>true</code> if file selection is enabled, and
1153 * <code>false</code> otherwise. File selection is enabled when the
1154 * file selection mode is {@link #FILES_ONLY} or
1155 * {@link #FILES_AND_DIRECTORIES}.
1156 *
1157 * @return <code>true</code> if file selection is enabled.
1158 *
1159 * @see #getFileSelectionMode()
1160 */
1161 public boolean isFileSelectionEnabled()
1162 {
1163 return (fileSelectionMode == FILES_ONLY
1164 || fileSelectionMode == FILES_AND_DIRECTORIES);
1165 }
1166
1167 /**
1168 * Returns <code>true</code> if directory selection is enabled, and
1169 * <code>false</code> otherwise. Directory selection is enabled when the
1170 * file selection mode is {@link #DIRECTORIES_ONLY} or
1171 * {@link #FILES_AND_DIRECTORIES}.
1172 *
1173 * @return <code>true</code> if file selection is enabled.
1174 *
1175 * @see #getFileSelectionMode()
1176 */
1177 public boolean isDirectorySelectionEnabled()
1178 {
1179 return (fileSelectionMode == DIRECTORIES_ONLY
1180 || fileSelectionMode == FILES_AND_DIRECTORIES);
1181 }
1182
1183 /**
1184 * Sets the flag that controls whether multiple selections are allowed in
1185 * this filechooser and sends a {@link PropertyChangeEvent} (with the
1186 * property name {@link #MULTI_SELECTION_ENABLED_CHANGED_PROPERTY}) to all
1187 * registered listeners.
1188 *
1189 * @param b the new value of the flag.
1190 */
1191 public void setMultiSelectionEnabled(boolean b)
1192 {
1193 if (multiSelection != b)
1194 {
1195 multiSelection = b;
1196 firePropertyChange(MULTI_SELECTION_ENABLED_CHANGED_PROPERTY,
1197 ! multiSelection, multiSelection);
1198 }
1199 }
1200
1201 /**
1202 * Returns <code>true</code> if multiple selections are allowed within this
1203 * file chooser, and <code>false</code> otherwise.
1204 *
1205 * @return A boolean.
1206 *
1207 * @see #setMultiSelectionEnabled(boolean)
1208 */
1209 public boolean isMultiSelectionEnabled()
1210 {
1211 return multiSelection;
1212 }
1213
1214 /**
1215 * Returns <code>true</code> if hidden files are to be hidden, and
1216 * <code>false</code> otherwise.
1217 *
1218 * @return A boolean.
1219 *
1220 * @see #setFileHidingEnabled(boolean)
1221 */
1222 public boolean isFileHidingEnabled()
1223 {
1224 return fileHiding;
1225 }
1226
1227 /**
1228 * Sets the flag that controls whether or not hidden files are displayed,
1229 * and sends a {@link PropertyChangeEvent} (with the property name
1230 * {@link #FILE_HIDING_CHANGED_PROPERTY}) to all registered listeners.
1231 *
1232 * @param b the new value of the flag.
1233 */
1234 public void setFileHidingEnabled(boolean b)
1235 {
1236 if (fileHiding != b)
1237 {
1238 fileHiding = b;
1239 firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, ! fileHiding,
1240 fileHiding);
1241 }
1242 }
1243
1244 /**
1245 * Sets the file filter and sends a {@link PropertyChangeEvent} (with the
1246 * property name {@link #FILE_FILTER_CHANGED_PROPERTY}) to all registered
1247 * listeners.
1248 *
1249 * @param filter the filter (<code>null</code> permitted).
1250 */
1251 public void setFileFilter(FileFilter filter)
1252 {
1253 if (currentFilter != filter)
1254 {
1255 if (filter != null && !choosableFilters.contains(filter))
1256 addChoosableFileFilter(filter);
1257 FileFilter old = currentFilter;
1258 currentFilter = filter;
1259 firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, old, currentFilter);
1260 }
1261 }
1262
1263 /**
1264 * Returns the file filter.
1265 *
1266 * @return The file filter.
1267 *
1268 * @see #setFileFilter(FileFilter)
1269 */
1270 public FileFilter getFileFilter()
1271 {
1272 return currentFilter;
1273 }
1274
1275 /**
1276 * Sets a custom {@link FileView} for the file chooser and sends a
1277 * {@link PropertyChangeEvent} to all registered listeners. The property
1278 * name is {@link #FILE_VIEW_CHANGED_PROPERTY}.
1279 *
1280 * @param fileView the file view (<code>null</code> permitted).
1281 *
1282 * @see #getFileView()
1283 */
1284 public void setFileView(FileView fileView)
1285 {
1286 if (fv != fileView)
1287 {
1288 FileView old = fv;
1289 fv = fileView;
1290 firePropertyChange(FILE_VIEW_CHANGED_PROPERTY, old, fv);
1291 }
1292 }
1293
1294 /**
1295 * Returns the custom {@link FileView} for the file chooser.
1296 *
1297 * @return The file view (possibly <code>null</code>).
1298 */
1299 public FileView getFileView()
1300 {
1301 return fv;
1302 }
1303
1304 /**
1305 * Returns the name of the file, generated by the current (or default)
1306 * {@link FileView}.
1307 *
1308 * @param f the file.
1309 *
1310 * @return The file name.
1311 */
1312 public String getName(File f)
1313 {
1314 String name = null;
1315 if (fv != null)
1316 name = fv.getName(f);
1317 if (name == null)
1318 name = getUI().getFileView(this).getName(f);
1319 return name;
1320 }
1321
1322 /**
1323 * Returns the description of the file, generated by the current (or default)
1324 * {@link FileView}.
1325 *
1326 * @param f the file.
1327 *
1328 * @return The file description.
1329 */
1330 public String getDescription(File f)
1331 {
1332 String result = null;
1333 if (fv != null)
1334 result = fv.getDescription(f);
1335 if (result == null)
1336 result = getUI().getFileView(this).getDescription(f);
1337 return result;
1338 }
1339
1340 /**
1341 * Returns the type description for the file, generated by the current (or
1342 * default) {@link FileView}.
1343 *
1344 * @param f the file.
1345 *
1346 * @return The file type description.
1347 */
1348 public String getTypeDescription(File f)
1349 {
1350 String result = null;
1351 if (fv != null)
1352 result = getFileView().getTypeDescription(f);
1353 if (result == null)
1354 result = getUI().getFileView(this).getTypeDescription(f);
1355 return result;
1356 }
1357
1358 /**
1359 * Returns the icon provided by the current (or default) {@link FileView}.
1360 *
1361 * @param f the file.
1362 *
1363 * @return An icon representing the file.
1364 */
1365 public Icon getIcon(File f)
1366 {
1367 Icon result = null;
1368 if (fv != null)
1369 result = fv.getIcon(f);
1370 if (result == null)
1371 result = getUI().getFileView(this).getIcon(f);
1372 return result;
1373 }
1374
1375 /**
1376 * Returns <code>true</code> if the file is traversable, and
1377 * <code>false</code> otherwise.
1378 *
1379 * @param f the file or directory.
1380 *
1381 * @return A boolean.
1382 */
1383 public boolean isTraversable(File f)
1384 {
1385 return getFileSystemView().isTraversable(f).booleanValue();
1386 }
1387
1388 /**
1389 * Returns <code>true</code> if the file is accepted by the current
1390 * file filter.
1391 *
1392 * @param f the file.
1393 *
1394 * @return A boolean.
1395 */
1396 public boolean accept(File f)
1397 {
1398 if (f == null)
1399 return true;
1400 FileFilter ff = getFileFilter();
1401 if (ff != null)
1402 return ff.accept(f);
1403 else
1404 return true;
1405 }
1406
1407 /**
1408 * Sets the file system view for the file chooser and sends a
1409 * {@link PropertyChangeEvent} to all registered listeners.
1410 *
1411 * @param fsv the file system view.
1412 */
1413 public void setFileSystemView(FileSystemView fsv)
1414 {
1415 if (this.fsv != fsv)
1416 {
1417 FileSystemView old = this.fsv;
1418 this.fsv = fsv;
1419 firePropertyChange(FILE_SYSTEM_VIEW_CHANGED_PROPERTY, old, this.fsv);
1420 }
1421 }
1422
1423 /**
1424 * Returns the file system view being used by this file chooser.
1425 *
1426 * @return The file system view.
1427 *
1428 * @see #setFileSystemView(FileSystemView)
1429 */
1430 public FileSystemView getFileSystemView()
1431 {
1432 return fsv;
1433 }
1434
1435 /**
1436 * Approves the selection. An {@link ActionEvent} is sent to all registered
1437 * listeners.
1438 */
1439 public void approveSelection()
1440 {
1441 retval = APPROVE_OPTION;
1442 fireActionPerformed(APPROVE_SELECTION);
1443 }
1444
1445 /**
1446 * Cancels the selection. An {@link ActionEvent} is sent to all registered
1447 * listeners.
1448 */
1449 public void cancelSelection()
1450 {
1451 retval = CANCEL_OPTION;
1452 fireActionPerformed(CANCEL_SELECTION);
1453 }
1454
1455 /**
1456 * Adds an {@link ActionListener} to the file chooser.
1457 *
1458 * @param l the listener.
1459 */
1460 public void addActionListener(ActionListener l)
1461 {
1462 listenerList.add(ActionListener.class, l);
1463 }
1464
1465 /**
1466 * Removes an {@link ActionListener} from this file chooser.
1467 *
1468 * @param l the listener.
1469 */
1470 public void removeActionListener(ActionListener l)
1471 {
1472 try
1473 {
1474 listenerList.remove(ActionListener.class, l);
1475 }
1476 catch (IllegalArgumentException e)
1477 {
1478 e.printStackTrace();
1479 }
1480 }
1481
1482 /**
1483 * Returns the action listeners registered with this file chooser.
1484 *
1485 * @return An array of listeners.
1486 */
1487 public ActionListener[] getActionListeners()
1488 {
1489 return (ActionListener[]) getListeners(ActionListener.class);
1490 }
1491
1492 /**
1493 * Sends an @link {ActionEvent} to all registered listeners.
1494 *
1495 * @param command the action command.
1496 */
1497 protected void fireActionPerformed(String command)
1498 {
1499 ActionListener[] list = getActionListeners();
1500 ActionEvent event = new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
1501 command);
1502
1503 for (int i = 0; i < list.length; i++)
1504 list[i].actionPerformed(event);
1505 }
1506
1507 /**
1508 * Installs the UI delegate for the current look and feel.
1509 */
1510 public void updateUI()
1511 {
1512 setUI((FileChooserUI) UIManager.getUI(this));
1513 }
1514
1515 /**
1516 * Returns the UI delegate class identifier.
1517 *
1518 * @return <code>FileChooserUI</code>.
1519 */
1520 public String getUIClassID()
1521 {
1522 return "FileChooserUI";
1523 }
1524
1525 /**
1526 * Returns the UI delegate for the component.
1527 *
1528 * @return The UI delegate.
1529 */
1530 public FileChooserUI getUI()
1531 {
1532 return (FileChooserUI) ui;
1533 }
1534
1535 /**
1536 * Returns a string describing the attributes for the
1537 * <code>JFileChooser</code> component, for use in debugging. The return
1538 * value is guaranteed to be non-<code>null</code>, but the format of the
1539 * string may vary between implementations.
1540 *
1541 * @return A string describing the attributes of the
1542 * <code>JFileChooser</code>.
1543 */
1544 protected String paramString()
1545 {
1546 StringBuffer sb = new StringBuffer(super.paramString());
1547 sb.append(",approveButtonText=");
1548 if (approveButtonText != null)
1549 sb.append(approveButtonText);
1550 sb.append(",currentDirectory=");
1551 if (currentDir != null)
1552 sb.append(currentDir);
1553 sb.append(",dialogTitle=");
1554 if (dialogTitle != null)
1555 sb.append(dialogTitle);
1556 sb.append(",dialogType=");
1557 if (dialogType == OPEN_DIALOG)
1558 sb.append("OPEN_DIALOG");
1559 if (dialogType == SAVE_DIALOG)
1560 sb.append("SAVE_DIALOG");
1561 if (dialogType == CUSTOM_DIALOG)
1562 sb.append("CUSTOM_DIALOG");
1563 sb.append(",fileSelectionMode=");
1564 if (fileSelectionMode == FILES_ONLY)
1565 sb.append("FILES_ONLY");
1566 if (fileSelectionMode == DIRECTORIES_ONLY)
1567 sb.append("DIRECTORIES_ONLY");
1568 if (fileSelectionMode == FILES_AND_DIRECTORIES)
1569 sb.append("FILES_AND_DIRECTORIES");
1570 sb.append(",returnValue=");
1571 if (retval == APPROVE_OPTION)
1572 sb.append("APPROVE_OPTION");
1573 if (retval == CANCEL_OPTION)
1574 sb.append("CANCEL_OPTION");
1575 if (retval == ERROR_OPTION)
1576 sb.append("ERROR_OPTION");
1577 sb.append(",selectedFile=");
1578 if (selectedFile != null)
1579 sb.append(selectedFile);
1580 sb.append(",useFileHiding=").append(fileHiding);
1581 return sb.toString();
1582 }
1583
1584 /**
1585 * Returns the object that provides accessibility features for this
1586 * <code>JFileChooser</code> component.
1587 *
1588 * @return The accessible context (an instance of
1589 * {@link AccessibleJFileChooser}).
1590 */
1591 public AccessibleContext getAccessibleContext()
1592 {
1593 if (accessibleContext == null)
1594 accessibleContext = new AccessibleJFileChooser();
1595 return accessibleContext;
1596 }
1597
1598 /**
1599 * Provides the accessibility features for the <code>JFileChooser</code>
1600 * component.
1601 */
1602 protected class AccessibleJFileChooser
1603 extends JComponent.AccessibleJComponent
1604 {
1605 /**
1606 * Creates a new instance of <code>AccessibleJFileChooser</code>.
1607 */
1608 protected AccessibleJFileChooser()
1609 {
1610 // Nothing to do here.
1611 }
1612
1613 /**
1614 * Returns the accessible role for the <code>JFileChooser</code>
1615 * component.
1616 *
1617 * @return {@link AccessibleRole#FILE_CHOOSER}.
1618 */
1619 public AccessibleRole getAccessibleRole()
1620 {
1621 return AccessibleRole.FILE_CHOOSER;
1622 }
1623 }
1624 }