1 /*
2 * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javax.swing;
27
28 import javax.swing.event.*;
29 import javax.swing.filechooser.*;
30 import javax.swing.plaf.FileChooserUI;
31
32 import javax.accessibility.*;
33
34 import java.io.File;
35 import java.io.ObjectOutputStream;
36 import java.io.IOException;
37
38 import java.util.Vector;
39 import java.awt.AWTEvent;
40 import java.awt.Component;
41 import java.awt.Container;
42 import java.awt.BorderLayout;
43 import java.awt.Window;
44 import java.awt.Dialog;
45 import java.awt.Frame;
46 import java.awt.GraphicsEnvironment;
47 import java.awt.HeadlessException;
48 import java.awt.EventQueue;
49 import java.awt.Toolkit;
50 import java.awt.event.*;
51 import java.beans.PropertyChangeListener;
52 import java.beans.PropertyChangeEvent;
53 import java.lang.ref.WeakReference;
54
55 /**
56 * <code>JFileChooser</code> provides a simple mechanism for the user to
57 * choose a file.
58 * For information about using <code>JFileChooser</code>, see
59 * <a
60 href="http://java.sun.com/docs/books/tutorial/uiswing/components/filechooser.html">How to Use File Choosers</a>,
61 * a section in <em>The Java Tutorial</em>.
62 *
63 * <p>
64 *
65 * The following code pops up a file chooser for the user's home directory that
66 * sees only .jpg and .gif images:
67 * <pre>
68 * JFileChooser chooser = new JFileChooser();
69 * FileNameExtensionFilter filter = new FileNameExtensionFilter(
70 * "JPG & GIF Images", "jpg", "gif");
71 * chooser.setFileFilter(filter);
72 * int returnVal = chooser.showOpenDialog(parent);
73 * if(returnVal == JFileChooser.APPROVE_OPTION) {
74 * System.out.println("You chose to open this file: " +
75 * chooser.getSelectedFile().getName());
76 * }
77 * </pre>
78 * <p>
79 * <strong>Warning:</strong> Swing is not thread safe. For more
80 * information see <a
81 * href="package-summary.html#threading">Swing's Threading
82 * Policy</a>.
83 *
84 * @beaninfo
85 * attribute: isContainer false
86 * description: A component which allows for the interactive selection of a file.
87 *
88 * @author Jeff Dinkins
89 *
90 */
91 public class JFileChooser extends JComponent implements Accessible {
92
93 /**
94 * @see #getUIClassID
95 * @see #readObject
96 */
97 private static final String uiClassID = "FileChooserUI";
98
99 // ************************
100 // ***** Dialog Types *****
101 // ************************
102
103 /**
104 * Type value indicating that the <code>JFileChooser</code> supports an
105 * "Open" file operation.
106 */
107 public static final int OPEN_DIALOG = 0;
108
109 /**
110 * Type value indicating that the <code>JFileChooser</code> supports a
111 * "Save" file operation.
112 */
113 public static final int SAVE_DIALOG = 1;
114
115 /**
116 * Type value indicating that the <code>JFileChooser</code> supports a
117 * developer-specified file operation.
118 */
119 public static final int CUSTOM_DIALOG = 2;
120
121
122 // ********************************
123 // ***** Dialog Return Values *****
124 // ********************************
125
126 /**
127 * Return value if cancel is chosen.
128 */
129 public static final int CANCEL_OPTION = 1;
130
131 /**
132 * Return value if approve (yes, ok) is chosen.
133 */
134 public static final int APPROVE_OPTION = 0;
135
136 /**
137 * Return value if an error occured.
138 */
139 public static final int ERROR_OPTION = -1;
140
141
142 // **********************************
143 // ***** JFileChooser properties *****
144 // **********************************
145
146
147 /** Instruction to display only files. */
148 public static final int FILES_ONLY = 0;
149
150 /** Instruction to display only directories. */
151 public static final int DIRECTORIES_ONLY = 1;
152
153 /** Instruction to display both files and directories. */
154 public static final int FILES_AND_DIRECTORIES = 2;
155
156 /** Instruction to cancel the current selection. */
157 public static final String CANCEL_SELECTION = "CancelSelection";
158
159 /**
160 * Instruction to approve the current selection
161 * (same as pressing yes or ok).
162 */
163 public static final String APPROVE_SELECTION = "ApproveSelection";
164
165 /** Identifies change in the text on the approve (yes, ok) button. */
166 public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY = "ApproveButtonTextChangedProperty";
167
168 /**
169 * Identifies change in the tooltip text for the approve (yes, ok)
170 * button.
171 */
172 public static final String APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY = "ApproveButtonToolTipTextChangedProperty";
173
174 /** Identifies change in the mnemonic for the approve (yes, ok) button. */
175 public static final String APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY = "ApproveButtonMnemonicChangedProperty";
176
177 /** Instruction to display the control buttons. */
178 public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY = "ControlButtonsAreShownChangedProperty";
179
180 /** Identifies user's directory change. */
181 public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged";
182
183 /** Identifies change in user's single-file selection. */
184 public static final String SELECTED_FILE_CHANGED_PROPERTY = "SelectedFileChangedProperty";
185
186 /** Identifies change in user's multiple-file selection. */
187 public static final String SELECTED_FILES_CHANGED_PROPERTY = "SelectedFilesChangedProperty";
188
189 /** Enables multiple-file selections. */
190 public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY = "MultiSelectionEnabledChangedProperty";
191
192 /**
193 * Says that a different object is being used to find available drives
194 * on the system.
195 */
196 public static final String FILE_SYSTEM_VIEW_CHANGED_PROPERTY = "FileSystemViewChanged";
197
198 /**
199 * Says that a different object is being used to retrieve file
200 * information.
201 */
202 public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";
203
204 /** Identifies a change in the display-hidden-files property. */
205 public static final String FILE_HIDING_CHANGED_PROPERTY = "FileHidingChanged";
206
207 /** User changed the kind of files to display. */
208 public static final String FILE_FILTER_CHANGED_PROPERTY = "fileFilterChanged";
209
210 /**
211 * Identifies a change in the kind of selection (single,
212 * multiple, etc.).
213 */
214 public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY = "fileSelectionChanged";
215
216 /**
217 * Says that a different accessory component is in use
218 * (for example, to preview files).
219 */
220 public static final String ACCESSORY_CHANGED_PROPERTY = "AccessoryChangedProperty";
221
222 /**
223 * Identifies whether a the AcceptAllFileFilter is used or not.
224 */
225 public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY = "acceptAllFileFilterUsedChanged";
226
227 /** Identifies a change in the dialog title. */
228 public static final String DIALOG_TITLE_CHANGED_PROPERTY = "DialogTitleChangedProperty";
229
230 /**
231 * Identifies a change in the type of files displayed (files only,
232 * directories only, or both files and directories).
233 */
234 public static final String DIALOG_TYPE_CHANGED_PROPERTY = "DialogTypeChangedProperty";
235
236 /**
237 * Identifies a change in the list of predefined file filters
238 * the user can choose from.
239 */
240 public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY = "ChoosableFileFilterChangedProperty";
241
242 // ******************************
243 // ***** instance variables *****
244 // ******************************
245
246 private String dialogTitle = null;
247 private String approveButtonText = null;
248 private String approveButtonToolTipText = null;
249 private int approveButtonMnemonic = 0;
250
251 private Vector<FileFilter> filters = new Vector<FileFilter>(5);
252 private JDialog dialog = null;
253 private int dialogType = OPEN_DIALOG;
254 private int returnValue = ERROR_OPTION;
255 private JComponent accessory = null;
256
257 private FileView fileView = null;
258
259 private boolean controlsShown = true;
260
261 private boolean useFileHiding = true;
262 private static final String SHOW_HIDDEN_PROP = "awt.file.showHiddenFiles";
263
264 // Listens to changes in the native setting for showing hidden files.
265 // The Listener is removed and the native setting is ignored if
266 // setFileHidingEnabled() is ever called.
267 private transient PropertyChangeListener showFilesListener = null;
268
269 private int fileSelectionMode = FILES_ONLY;
270
271 private boolean multiSelectionEnabled = false;
272
273 private boolean useAcceptAllFileFilter = true;
274
275 private boolean dragEnabled = false;
276
277 private FileFilter fileFilter = null;
278
279 private FileSystemView fileSystemView = null;
280
281 private File currentDirectory = null;
282 private File selectedFile = null;
283 private File[] selectedFiles;
284
285 // *************************************
286 // ***** JFileChooser Constructors *****
287 // *************************************
288
289 /**
290 * Constructs a <code>JFileChooser</code> pointing to the user's
291 * default directory. This default depends on the operating system.
292 * It is typically the "My Documents" folder on Windows, and the
293 * user's home directory on Unix.
294 */
295 public JFileChooser() {
296 this((File) null, (FileSystemView) null);
297 }
298
299 /**
300 * Constructs a <code>JFileChooser</code> using the given path.
301 * Passing in a <code>null</code>
302 * string causes the file chooser to point to the user's default directory.
303 * This default depends on the operating system. It is
304 * typically the "My Documents" folder on Windows, and the user's
305 * home directory on Unix.
306 *
307 * @param currentDirectoryPath a <code>String</code> giving the path
308 * to a file or directory
309 */
310 public JFileChooser(String currentDirectoryPath) {
311 this(currentDirectoryPath, (FileSystemView) null);
312 }
313
314 /**
315 * Constructs a <code>JFileChooser</code> using the given <code>File</code>
316 * as the path. Passing in a <code>null</code> file
317 * causes the file chooser to point to the user's default directory.
318 * This default depends on the operating system. It is
319 * typically the "My Documents" folder on Windows, and the user's
320 * home directory on Unix.
321 *
322 * @param currentDirectory a <code>File</code> object specifying
323 * the path to a file or directory
324 */
325 public JFileChooser(File currentDirectory) {
326 this(currentDirectory, (FileSystemView) null);
327 }
328
329 /**
330 * Constructs a <code>JFileChooser</code> using the given
331 * <code>FileSystemView</code>.
332 */
333 public JFileChooser(FileSystemView fsv) {
334 this((File) null, fsv);
335 }
336
337
338 /**
339 * Constructs a <code>JFileChooser</code> using the given current directory
340 * and <code>FileSystemView</code>.
341 */
342 public JFileChooser(File currentDirectory, FileSystemView fsv) {
343 setup(fsv);
344 setCurrentDirectory(currentDirectory);
345 }
346
347 /**
348 * Constructs a <code>JFileChooser</code> using the given current directory
349 * path and <code>FileSystemView</code>.
350 */
351 public JFileChooser(String currentDirectoryPath, FileSystemView fsv) {
352 setup(fsv);
353 if(currentDirectoryPath == null) {
354 setCurrentDirectory(null);
355 } else {
356 setCurrentDirectory(fileSystemView.createFileObject(currentDirectoryPath));
357 }
358 }
359
360 /**
361 * Performs common constructor initialization and setup.
362 */
363 protected void setup(FileSystemView view) {
364 installShowFilesListener();
365
366 if(view == null) {
367 view = FileSystemView.getFileSystemView();
368 }
369 setFileSystemView(view);
370 updateUI();
371 if(isAcceptAllFileFilterUsed()) {
372 setFileFilter(getAcceptAllFileFilter());
373 }
374 enableEvents(AWTEvent.MOUSE_EVENT_MASK);
375 }
376
377 private void installShowFilesListener() {
378 // Track native setting for showing hidden files
379 Toolkit tk = Toolkit.getDefaultToolkit();
380 Object showHiddenProperty = tk.getDesktopProperty(SHOW_HIDDEN_PROP);
381 if (showHiddenProperty instanceof Boolean) {
382 useFileHiding = !((Boolean)showHiddenProperty).booleanValue();
383 showFilesListener = new WeakPCL(this);
384 tk.addPropertyChangeListener(SHOW_HIDDEN_PROP, showFilesListener);
385 }
386 }
387
388 /**
389 * Sets the <code>dragEnabled</code> property,
390 * which must be <code>true</code> to enable
391 * automatic drag handling (the first part of drag and drop)
392 * on this component.
393 * The <code>transferHandler</code> property needs to be set
394 * to a non-<code>null</code> value for the drag to do
395 * anything. The default value of the <code>dragEnabled</code>
396 * property
397 * is <code>false</code>.
398 *
399 * <p>
400 *
401 * When automatic drag handling is enabled,
402 * most look and feels begin a drag-and-drop operation
403 * whenever the user presses the mouse button over an item
404 * and then moves the mouse a few pixels.
405 * Setting this property to <code>true</code>
406 * can therefore have a subtle effect on
407 * how selections behave.
408 *
409 * <p>
410 *
411 * Some look and feels might not support automatic drag and drop;
412 * they will ignore this property. You can work around such
413 * look and feels by modifying the component
414 * to directly call the <code>exportAsDrag</code> method of a
415 * <code>TransferHandler</code>.
416 *
417 * @param b the value to set the <code>dragEnabled</code> property to
418 * @exception HeadlessException if
419 * <code>b</code> is <code>true</code> and
420 * <code>GraphicsEnvironment.isHeadless()</code>
421 * returns <code>true</code>
422 * @see java.awt.GraphicsEnvironment#isHeadless
423 * @see #getDragEnabled
424 * @see #setTransferHandler
425 * @see TransferHandler
426 * @since 1.4
427 *
428 * @beaninfo
429 * description: determines whether automatic drag handling is enabled
430 * bound: false
431 */
432 public void setDragEnabled(boolean b) {
433 if (b && GraphicsEnvironment.isHeadless()) {
434 throw new HeadlessException();
435 }
436 dragEnabled = b;
437 }
438
439 /**
440 * Gets the value of the <code>dragEnabled</code> property.
441 *
442 * @return the value of the <code>dragEnabled</code> property
443 * @see #setDragEnabled
444 * @since 1.4
445 */
446 public boolean getDragEnabled() {
447 return dragEnabled;
448 }
449
450 // *****************************
451 // ****** File Operations ******
452 // *****************************
453
454 /**
455 * Returns the selected file. This can be set either by the
456 * programmer via <code>setSelectedFile</code> or by a user action, such as
457 * either typing the filename into the UI or selecting the
458 * file from a list in the UI.
459 *
460 * @see #setSelectedFile
461 * @return the selected file
462 */
463 public File getSelectedFile() {
464 return selectedFile;
465 }
466
467 /**
468 * Sets the selected file. If the file's parent directory is
469 * not the current directory, changes the current directory
470 * to be the file's parent directory.
471 *
472 * @beaninfo
473 * preferred: true
474 * bound: true
475 *
476 * @see #getSelectedFile
477 *
478 * @param file the selected file
479 */
480 public void setSelectedFile(File file) {
481 File oldValue = selectedFile;
482 selectedFile = file;
483 if(selectedFile != null) {
484 if (file.isAbsolute() && !getFileSystemView().isParent(getCurrentDirectory(), selectedFile)) {
485 setCurrentDirectory(selectedFile.getParentFile());
486 }
487 if (!isMultiSelectionEnabled() || selectedFiles == null || selectedFiles.length == 1) {
488 ensureFileIsVisible(selectedFile);
489 }
490 }
491 firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, oldValue, selectedFile);
492 }
493
494 /**
495 * Returns a list of selected files if the file chooser is
496 * set to allow multiple selection.
497 */
498 public File[] getSelectedFiles() {
499 if(selectedFiles == null) {
500 return new File[0];
501 } else {
502 return selectedFiles.clone();
503 }
504 }
505
506 /**
507 * Sets the list of selected files if the file chooser is
508 * set to allow multiple selection.
509 *
510 * @beaninfo
511 * bound: true
512 * description: The list of selected files if the chooser is in multiple selection mode.
513 */
514 public void setSelectedFiles(File[] selectedFiles) {
515 File[] oldValue = this.selectedFiles;
516 if (selectedFiles == null || selectedFiles.length == 0) {
517 selectedFiles = null;
518 this.selectedFiles = null;
519 setSelectedFile(null);
520 } else {
521 this.selectedFiles = selectedFiles.clone();
522 setSelectedFile(this.selectedFiles[0]);
523 }
524 firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, oldValue, selectedFiles);
525 }
526
527 /**
528 * Returns the current directory.
529 *
530 * @return the current directory
531 * @see #setCurrentDirectory
532 */
533 public File getCurrentDirectory() {
534 return currentDirectory;
535 }
536
537 /**
538 * Sets the current directory. Passing in <code>null</code> sets the
539 * file chooser to point to the user's default directory.
540 * This default depends on the operating system. It is
541 * typically the "My Documents" folder on Windows, and the user's
542 * home directory on Unix.
543 *
544 * If the file passed in as <code>currentDirectory</code> is not a
545 * directory, the parent of the file will be used as the currentDirectory.
546 * If the parent is not traversable, then it will walk up the parent tree
547 * until it finds a traversable directory, or hits the root of the
548 * file system.
549 *
550 * @beaninfo
551 * preferred: true
552 * bound: true
553 * description: The directory that the JFileChooser is showing files of.
554 *
555 * @param dir the current directory to point to
556 * @see #getCurrentDirectory
557 */
558 public void setCurrentDirectory(File dir) {
559 File oldValue = currentDirectory;
560
561 if (dir != null && !dir.exists()) {
562 dir = currentDirectory;
563 }
564 if (dir == null) {
565 dir = getFileSystemView().getDefaultDirectory();
566 }
567 if (currentDirectory != null) {
568 /* Verify the toString of object */
569 if (this.currentDirectory.equals(dir)) {
570 return;
571 }
572 }
573
574 File prev = null;
575 while (!isTraversable(dir) && prev != dir) {
576 prev = dir;
577 dir = getFileSystemView().getParentDirectory(dir);
578 }
579 currentDirectory = dir;
580
581 firePropertyChange(DIRECTORY_CHANGED_PROPERTY, oldValue, currentDirectory);
582 }
583
584 /**
585 * Changes the directory to be set to the parent of the
586 * current directory.
587 *
588 * @see #getCurrentDirectory
589 */
590 public void changeToParentDirectory() {
591 selectedFile = null;
592 File oldValue = getCurrentDirectory();
593 setCurrentDirectory(getFileSystemView().getParentDirectory(oldValue));
594 }
595
596 /**
597 * Tells the UI to rescan its files list from the current directory.
598 */
599 public void rescanCurrentDirectory() {
600 getUI().rescanCurrentDirectory(this);
601 }
602
603 /**
604 * Makes sure that the specified file is viewable, and
605 * not hidden.
606 *
607 * @param f a File object
608 */
609 public void ensureFileIsVisible(File f) {
610 getUI().ensureFileIsVisible(this, f);
611 }
612
613 // **************************************
614 // ***** JFileChooser Dialog methods *****
615 // **************************************
616
617 /**
618 * Pops up an "Open File" file chooser dialog. Note that the
619 * text that appears in the approve button is determined by
620 * the L&F.
621 *
622 * @param parent the parent component of the dialog,
623 * can be <code>null</code>;
624 * see <code>showDialog</code> for details
625 * @return the return state of the file chooser on popdown:
626 * <ul>
627 * <li>JFileChooser.CANCEL_OPTION
628 * <li>JFileChooser.APPROVE_OPTION
629 * <li>JFileChooser.ERROR_OPTION if an error occurs or the
630 * dialog is dismissed
631 * </ul>
632 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
633 * returns true.
634 * @see java.awt.GraphicsEnvironment#isHeadless
635 * @see #showDialog
636 */
637 public int showOpenDialog(Component parent) throws HeadlessException {
638 setDialogType(OPEN_DIALOG);
639 return showDialog(parent, null);
640 }
641
642 /**
643 * Pops up a "Save File" file chooser dialog. Note that the
644 * text that appears in the approve button is determined by
645 * the L&F.
646 *
647 * @param parent the parent component of the dialog,
648 * can be <code>null</code>;
649 * see <code>showDialog</code> for details
650 * @return the return state of the file chooser on popdown:
651 * <ul>
652 * <li>JFileChooser.CANCEL_OPTION
653 * <li>JFileChooser.APPROVE_OPTION
654 * <li>JFileChooser.ERROR_OPTION if an error occurs or the
655 * dialog is dismissed
656 * </ul>
657 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
658 * returns true.
659 * @see java.awt.GraphicsEnvironment#isHeadless
660 * @see #showDialog
661 */
662 public int showSaveDialog(Component parent) throws HeadlessException {
663 setDialogType(SAVE_DIALOG);
664 return showDialog(parent, null);
665 }
666
667 /**
668 * Pops a custom file chooser dialog with a custom approve button.
669 * For example, the following code
670 * pops up a file chooser with a "Run Application" button
671 * (instead of the normal "Save" or "Open" button):
672 * <pre>
673 * filechooser.showDialog(parentFrame, "Run Application");
674 * </pre>
675 *
676 * Alternatively, the following code does the same thing:
677 * <pre>
678 * JFileChooser chooser = new JFileChooser(null);
679 * chooser.setApproveButtonText("Run Application");
680 * chooser.showDialog(parentFrame, null);
681 * </pre>
682 *
683 * <!--PENDING(jeff) - the following method should be added to the api:
684 * showDialog(Component parent);-->
685 * <!--PENDING(kwalrath) - should specify modality and what
686 * "depends" means.-->
687 *
688 * <p>
689 *
690 * The <code>parent</code> argument determines two things:
691 * the frame on which the open dialog depends and
692 * the component whose position the look and feel
693 * should consider when placing the dialog. If the parent
694 * is a <code>Frame</code> object (such as a <code>JFrame</code>)
695 * then the dialog depends on the frame and
696 * the look and feel positions the dialog
697 * relative to the frame (for example, centered over the frame).
698 * If the parent is a component, then the dialog
699 * depends on the frame containing the component,
700 * and is positioned relative to the component
701 * (for example, centered over the component).
702 * If the parent is <code>null</code>, then the dialog depends on
703 * no visible window, and it's placed in a
704 * look-and-feel-dependent position
705 * such as the center of the screen.
706 *
707 * @param parent the parent component of the dialog;
708 * can be <code>null</code>
709 * @param approveButtonText the text of the <code>ApproveButton</code>
710 * @return the return state of the file chooser on popdown:
711 * <ul>
712 * <li>JFileChooser.CANCEL_OPTION
713 * <li>JFileChooser.APPROVE_OPTION
714 * <li>JFileChooser.ERROR_OPTION if an error occurs or the
715 * dialog is dismissed
716 * </ul>
717 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
718 * returns true.
719 * @see java.awt.GraphicsEnvironment#isHeadless
720 */
721 public int showDialog(Component parent, String approveButtonText)
722 throws HeadlessException {
723 if (dialog != null) {
724 // Prevent to show second instance of dialog if the previous one still exists
725 return JFileChooser.ERROR_OPTION;
726 }
727
728 if(approveButtonText != null) {
729 setApproveButtonText(approveButtonText);
730 setDialogType(CUSTOM_DIALOG);
731 }
732 dialog = createDialog(parent);
733 dialog.addWindowListener(new WindowAdapter() {
734 public void windowClosing(WindowEvent e) {
735 returnValue = CANCEL_OPTION;
736 }
737 });
738 returnValue = ERROR_OPTION;
739 rescanCurrentDirectory();
740
741 dialog.show();
742 firePropertyChange("JFileChooserDialogIsClosingProperty", dialog, null);
743
744 // Remove all components from dialog. The MetalFileChooserUI.installUI() method (and other LAFs)
745 // registers AWT listener for dialogs and produces memory leaks. It happens when
746 // installUI invoked after the showDialog method.
747 dialog.getContentPane().removeAll();
748 dialog.dispose();
749 dialog = null;
750 return returnValue;
751 }
752
753 /**
754 * Creates and returns a new <code>JDialog</code> wrapping
755 * <code>this</code> centered on the <code>parent</code>
756 * in the <code>parent</code>'s frame.
757 * This method can be overriden to further manipulate the dialog,
758 * to disable resizing, set the location, etc. Example:
759 * <pre>
760 * class MyFileChooser extends JFileChooser {
761 * protected JDialog createDialog(Component parent) throws HeadlessException {
762 * JDialog dialog = super.createDialog(parent);
763 * dialog.setLocation(300, 200);
764 * dialog.setResizable(false);
765 * return dialog;
766 * }
767 * }
768 * </pre>
769 *
770 * @param parent the parent component of the dialog;
771 * can be <code>null</code>
772 * @return a new <code>JDialog</code> containing this instance
773 * @exception HeadlessException if GraphicsEnvironment.isHeadless()
774 * returns true.
775 * @see java.awt.GraphicsEnvironment#isHeadless
776 * @since 1.4
777 */
778 protected JDialog createDialog(Component parent) throws HeadlessException {
779 FileChooserUI ui = getUI();
780 String title = ui.getDialogTitle(this);
781 putClientProperty(AccessibleContext.ACCESSIBLE_DESCRIPTION_PROPERTY,
782 title);
783
784 JDialog dialog;
785 Window window = JOptionPane.getWindowForComponent(parent);
786 if (window instanceof Frame) {
787 dialog = new JDialog((Frame)window, title, true);
788 } else {
789 dialog = new JDialog((Dialog)window, title, true);
790 }
791 dialog.setComponentOrientation(this.getComponentOrientation());
792
793 Container contentPane = dialog.getContentPane();
794 contentPane.setLayout(new BorderLayout());
795 contentPane.add(this, BorderLayout.CENTER);
796
797 if (JDialog.isDefaultLookAndFeelDecorated()) {
798 boolean supportsWindowDecorations =
799 UIManager.getLookAndFeel().getSupportsWindowDecorations();
800 if (supportsWindowDecorations) {
801 dialog.getRootPane().setWindowDecorationStyle(JRootPane.FILE_CHOOSER_DIALOG);
802 }
803 }
804 dialog.getRootPane().setDefaultButton(ui.getDefaultButton(this));
805 dialog.pack();
806 dialog.setLocationRelativeTo(parent);
807
808 return dialog;
809 }
810
811 // **************************
812 // ***** Dialog Options *****
813 // **************************
814
815 /**
816 * Returns the value of the <code>controlButtonsAreShown</code>
817 * property.
818 *
819 * @return the value of the <code>controlButtonsAreShown</code>
820 * property
821 *
822 * @see #setControlButtonsAreShown
823 * @since 1.3
824 */
825 public boolean getControlButtonsAreShown() {
826 return controlsShown;
827 }
828
829
830 /**
831 * Sets the property
832 * that indicates whether the <i>approve</i> and <i>cancel</i>
833 * buttons are shown in the file chooser. This property
834 * is <code>true</code> by default. Look and feels
835 * that always show these buttons will ignore the value
836 * of this property.
837 * This method fires a property-changed event,
838 * using the string value of
839 * <code>CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY</code>
840 * as the name of the property.
841 *
842 * @param b <code>false</code> if control buttons should not be
843 * shown; otherwise, <code>true</code>
844 *
845 * @beaninfo
846 * preferred: true
847 * bound: true
848 * description: Sets whether the approve & cancel buttons are shown.
849 *
850 * @see #getControlButtonsAreShown
851 * @see #CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY
852 * @since 1.3
853 */
854 public void setControlButtonsAreShown(boolean b) {
855 if(controlsShown == b) {
856 return;
857 }
858 boolean oldValue = controlsShown;
859 controlsShown = b;
860 firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY, oldValue, controlsShown);
861 }
862
863 /**
864 * Returns the type of this dialog. The default is
865 * <code>JFileChooser.OPEN_DIALOG</code>.
866 *
867 * @return the type of dialog to be displayed:
868 * <ul>
869 * <li>JFileChooser.OPEN_DIALOG
870 * <li>JFileChooser.SAVE_DIALOG
871 * <li>JFileChooser.CUSTOM_DIALOG
872 * </ul>
873 *
874 * @see #setDialogType
875 */
876 public int getDialogType() {
877 return dialogType;
878 }
879
880 /**
881 * Sets the type of this dialog. Use <code>OPEN_DIALOG</code> when you
882 * want to bring up a file chooser that the user can use to open a file.
883 * Likewise, use <code>SAVE_DIALOG</code> for letting the user choose
884 * a file for saving.
885 * Use <code>CUSTOM_DIALOG</code> when you want to use the file
886 * chooser in a context other than "Open" or "Save".
887 * For instance, you might want to bring up a file chooser that allows
888 * the user to choose a file to execute. Note that you normally would not
889 * need to set the <code>JFileChooser</code> to use
890 * <code>CUSTOM_DIALOG</code>
891 * since a call to <code>setApproveButtonText</code> does this for you.
892 * The default dialog type is <code>JFileChooser.OPEN_DIALOG</code>.
893 *
894 * @param dialogType the type of dialog to be displayed:
895 * <ul>
896 * <li>JFileChooser.OPEN_DIALOG
897 * <li>JFileChooser.SAVE_DIALOG
898 * <li>JFileChooser.CUSTOM_DIALOG
899 * </ul>
900 *
901 * @exception IllegalArgumentException if <code>dialogType</code> is
902 * not legal
903 * @beaninfo
904 * preferred: true
905 * bound: true
906 * description: The type (open, save, custom) of the JFileChooser.
907 * enum:
908 * OPEN_DIALOG JFileChooser.OPEN_DIALOG
909 * SAVE_DIALOG JFileChooser.SAVE_DIALOG
910 * CUSTOM_DIALOG JFileChooser.CUSTOM_DIALOG
911 *
912 * @see #getDialogType
913 * @see #setApproveButtonText
914 */
915 // PENDING(jeff) - fire button text change property
916 public void setDialogType(int dialogType) {
917 if(this.dialogType == dialogType) {
918 return;
919 }
920 if(!(dialogType == OPEN_DIALOG || dialogType == SAVE_DIALOG || dialogType == CUSTOM_DIALOG)) {
921 throw new IllegalArgumentException("Incorrect Dialog Type: " + dialogType);
922 }
923 int oldValue = this.dialogType;
924 this.dialogType = dialogType;
925 if(dialogType == OPEN_DIALOG || dialogType == SAVE_DIALOG) {
926 setApproveButtonText(null);
927 }
928 firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, oldValue, dialogType);
929 }
930
931 /**
932 * Sets the string that goes in the <code>JFileChooser</code> window's
933 * title bar.
934 *
935 * @param dialogTitle the new <code>String</code> for the title bar
936 *
937 * @beaninfo
938 * preferred: true
939 * bound: true
940 * description: The title of the JFileChooser dialog window.
941 *
942 * @see #getDialogTitle
943 *
944 */
945 public void setDialogTitle(String dialogTitle) {
946 String oldValue = this.dialogTitle;
947 this.dialogTitle = dialogTitle;
948 if(dialog != null) {
949 dialog.setTitle(dialogTitle);
950 }
951 firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, oldValue, dialogTitle);
952 }
953
954 /**
955 * Gets the string that goes in the <code>JFileChooser</code>'s titlebar.
956 *
957 * @see #setDialogTitle
958 */
959 public String getDialogTitle() {
960 return dialogTitle;
961 }
962
963 // ************************************
964 // ***** JFileChooser View Options *****
965 // ************************************
966
967
968
969 /**
970 * Sets the tooltip text used in the <code>ApproveButton</code>.
971 * If <code>null</code>, the UI object will determine the button's text.
972 *
973 * @beaninfo
974 * preferred: true
975 * bound: true
976 * description: The tooltip text for the ApproveButton.
977 *
978 * @param toolTipText the tooltip text for the approve button
979 * @see #setApproveButtonText
980 * @see #setDialogType
981 * @see #showDialog
982 */
983 public void setApproveButtonToolTipText(String toolTipText) {
984 if(approveButtonToolTipText == toolTipText) {
985 return;
986 }
987 String oldValue = approveButtonToolTipText;
988 approveButtonToolTipText = toolTipText;
989 firePropertyChange(APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY, oldValue, approveButtonToolTipText);
990 }
991
992
993 /**
994 * Returns the tooltip text used in the <code>ApproveButton</code>.
995 * If <code>null</code>, the UI object will determine the button's text.
996 *
997 * @return the tooltip text used for the approve button
998 *
999 * @see #setApproveButtonText
1000 * @see #setDialogType
1001 * @see #showDialog
1002 */
1003 public String getApproveButtonToolTipText() {
1004 return approveButtonToolTipText;
1005 }
1006
1007 /**
1008 * Returns the approve button's mnemonic.
1009 * @return an integer value for the mnemonic key
1010 *
1011 * @see #setApproveButtonMnemonic
1012 */
1013 public int getApproveButtonMnemonic() {
1014 return approveButtonMnemonic;
1015 }
1016
1017 /**
1018 * Sets the approve button's mnemonic using a numeric keycode.
1019 *
1020 * @param mnemonic an integer value for the mnemonic key
1021 *
1022 * @beaninfo
1023 * preferred: true
1024 * bound: true
1025 * description: The mnemonic key accelerator for the ApproveButton.
1026 *
1027 * @see #getApproveButtonMnemonic
1028 */
1029 public void setApproveButtonMnemonic(int mnemonic) {
1030 if(approveButtonMnemonic == mnemonic) {
1031 return;
1032 }
1033 int oldValue = approveButtonMnemonic;
1034 approveButtonMnemonic = mnemonic;
1035 firePropertyChange(APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY, oldValue, approveButtonMnemonic);
1036 }
1037
1038 /**
1039 * Sets the approve button's mnemonic using a character.
1040 * @param mnemonic a character value for the mnemonic key
1041 *
1042 * @see #getApproveButtonMnemonic
1043 */
1044 public void setApproveButtonMnemonic(char mnemonic) {
1045 int vk = (int) mnemonic;
1046 if(vk >= 'a' && vk <='z') {
1047 vk -= ('a' - 'A');
1048 }
1049 setApproveButtonMnemonic(vk);
1050 }
1051
1052
1053 /**
1054 * Sets the text used in the <code>ApproveButton</code> in the
1055 * <code>FileChooserUI</code>.
1056 *
1057 * @beaninfo
1058 * preferred: true
1059 * bound: true
1060 * description: The text that goes in the ApproveButton.
1061 *
1062 * @param approveButtonText the text used in the <code>ApproveButton</code>
1063 *
1064 * @see #getApproveButtonText
1065 * @see #setDialogType
1066 * @see #showDialog
1067 */
1068 // PENDING(jeff) - have ui set this on dialog type change
1069 public void setApproveButtonText(String approveButtonText) {
1070 if(this.approveButtonText == approveButtonText) {
1071 return;
1072 }
1073 String oldValue = this.approveButtonText;
1074 this.approveButtonText = approveButtonText;
1075 firePropertyChange(APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, oldValue, approveButtonText);
1076 }
1077
1078 /**
1079 * Returns the text used in the <code>ApproveButton</code> in the
1080 * <code>FileChooserUI</code>.
1081 * If <code>null</code>, the UI object will determine the button's text.
1082 *
1083 * Typically, this would be "Open" or "Save".
1084 *
1085 * @return the text used in the <code>ApproveButton</code>
1086 *
1087 * @see #setApproveButtonText
1088 * @see #setDialogType
1089 * @see #showDialog
1090 */
1091 public String getApproveButtonText() {
1092 return approveButtonText;
1093 }
1094
1095 /**
1096 * Gets the list of user choosable file filters.
1097 *
1098 * @return a <code>FileFilter</code> array containing all the choosable
1099 * file filters
1100 *
1101 * @see #addChoosableFileFilter
1102 * @see #removeChoosableFileFilter
1103 * @see #resetChoosableFileFilters
1104 */
1105 public FileFilter[] getChoosableFileFilters() {
1106 FileFilter[] filterArray = new FileFilter[filters.size()];
1107 filters.copyInto(filterArray);
1108 return filterArray;
1109 }
1110
1111 /**
1112 * Adds a filter to the list of user choosable file filters.
1113 * For information on setting the file selection mode, see
1114 * {@link #setFileSelectionMode setFileSelectionMode}.
1115 *
1116 * @param filter the <code>FileFilter</code> to add to the choosable file
1117 * filter list
1118 *
1119 * @beaninfo
1120 * preferred: true
1121 * bound: true
1122 * description: Adds a filter to the list of user choosable file filters.
1123 *
1124 * @see #getChoosableFileFilters
1125 * @see #removeChoosableFileFilter
1126 * @see #resetChoosableFileFilters
1127 * @see #setFileSelectionMode
1128 */
1129 public void addChoosableFileFilter(FileFilter filter) {
1130 if(filter != null && !filters.contains(filter)) {
1131 FileFilter[] oldValue = getChoosableFileFilters();
1132 filters.addElement(filter);
1133 firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, oldValue, getChoosableFileFilters());
1134 if (fileFilter == null && filters.size() == 1) {
1135 setFileFilter(filter);
1136 }
1137 }
1138 }
1139
1140 /**
1141 * Removes a filter from the list of user choosable file filters. Returns
1142 * true if the file filter was removed.
1143 *
1144 * @see #addChoosableFileFilter
1145 * @see #getChoosableFileFilters
1146 * @see #resetChoosableFileFilters
1147 */
1148 public boolean removeChoosableFileFilter(FileFilter f) {
1149 if(filters.contains(f)) {
1150 if(getFileFilter() == f) {
1151 setFileFilter(null);
1152 }
1153 FileFilter[] oldValue = getChoosableFileFilters();
1154 filters.removeElement(f);
1155 firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, oldValue, getChoosableFileFilters());
1156 return true;
1157 } else {
1158 return false;
1159 }
1160 }
1161
1162 /**
1163 * Resets the choosable file filter list to its starting state. Normally,
1164 * this removes all added file filters while leaving the
1165 * <code>AcceptAll</code> file filter.
1166 *
1167 * @see #addChoosableFileFilter
1168 * @see #getChoosableFileFilters
1169 * @see #removeChoosableFileFilter
1170 */
1171 public void resetChoosableFileFilters() {
1172 FileFilter[] oldValue = getChoosableFileFilters();
1173 setFileFilter(null);
1174 filters.removeAllElements();
1175 if(isAcceptAllFileFilterUsed()) {
1176 addChoosableFileFilter(getAcceptAllFileFilter());
1177 }
1178 firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, oldValue, getChoosableFileFilters());
1179 }
1180
1181 /**
1182 * Returns the <code>AcceptAll</code> file filter.
1183 * For example, on Microsoft Windows this would be All Files (*.*).
1184 */
1185 public FileFilter getAcceptAllFileFilter() {
1186 FileFilter filter = null;
1187 if(getUI() != null) {
1188 filter = getUI().getAcceptAllFileFilter(this);
1189 }
1190 return filter;
1191 }
1192
1193 /**
1194 * Returns whether the <code>AcceptAll FileFilter</code> is used.
1195 * @return true if the <code>AcceptAll FileFilter</code> is used
1196 * @see #setAcceptAllFileFilterUsed
1197 * @since 1.3
1198 */
1199 public boolean isAcceptAllFileFilterUsed() {
1200 return useAcceptAllFileFilter;
1201 }
1202
1203 /**
1204 * Determines whether the <code>AcceptAll FileFilter</code> is used
1205 * as an available choice in the choosable filter list.
1206 * If false, the <code>AcceptAll</code> file filter is removed from
1207 * the list of available file filters.
1208 * If true, the <code>AcceptAll</code> file filter will become the
1209 * the actively used file filter.
1210 *
1211 * @beaninfo
1212 * preferred: true
1213 * bound: true
1214 * description: Sets whether the AcceptAll FileFilter is used as an available choice in the choosable filter list.
1215 *
1216 * @see #isAcceptAllFileFilterUsed
1217 * @see #getAcceptAllFileFilter
1218 * @see #setFileFilter
1219 * @since 1.3
1220 */
1221 public void setAcceptAllFileFilterUsed(boolean b) {
1222 boolean oldValue = useAcceptAllFileFilter;
1223 useAcceptAllFileFilter = b;
1224 if(!b) {
1225 removeChoosableFileFilter(getAcceptAllFileFilter());
1226 } else {
1227 removeChoosableFileFilter(getAcceptAllFileFilter());
1228 addChoosableFileFilter(getAcceptAllFileFilter());
1229 }
1230 firePropertyChange(ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY, oldValue, useAcceptAllFileFilter);
1231 }
1232
1233 /**
1234 * Returns the accessory component.
1235 *
1236 * @return this JFileChooser's accessory component, or null
1237 * @see #setAccessory
1238 */
1239 public JComponent getAccessory() {
1240 return accessory;
1241 }
1242
1243 /**
1244 * Sets the accessory component. An accessory is often used to show a
1245 * preview image of the selected file; however, it can be used for anything
1246 * that the programmer wishes, such as extra custom file chooser controls.
1247 *
1248 * <p>
1249 * Note: if there was a previous accessory, you should unregister
1250 * any listeners that the accessory might have registered with the
1251 * file chooser.
1252 *
1253 * @beaninfo
1254 * preferred: true
1255 * bound: true
1256 * description: Sets the accessory component on the JFileChooser.
1257 */
1258 public void setAccessory(JComponent newAccessory) {
1259 JComponent oldValue = accessory;
1260 accessory = newAccessory;
1261 firePropertyChange(ACCESSORY_CHANGED_PROPERTY, oldValue, accessory);
1262 }
1263
1264 /**
1265 * Sets the <code>JFileChooser</code> to allow the user to just
1266 * select files, just select
1267 * directories, or select both files and directories. The default is
1268 * <code>JFilesChooser.FILES_ONLY</code>.
1269 *
1270 * @param mode the type of files to be displayed:
1271 * <ul>
1272 * <li>JFileChooser.FILES_ONLY
1273 * <li>JFileChooser.DIRECTORIES_ONLY
1274 * <li>JFileChooser.FILES_AND_DIRECTORIES
1275 * </ul>
1276 *
1277 * @exception IllegalArgumentException if <code>mode</code> is an
1278 * illegal file selection mode
1279 * @beaninfo
1280 * preferred: true
1281 * bound: true
1282 * description: Sets the types of files that the JFileChooser can choose.
1283 * enum: FILES_ONLY JFileChooser.FILES_ONLY
1284 * DIRECTORIES_ONLY JFileChooser.DIRECTORIES_ONLY
1285 * FILES_AND_DIRECTORIES JFileChooser.FILES_AND_DIRECTORIES
1286 *
1287 *
1288 * @see #getFileSelectionMode
1289 */
1290 public void setFileSelectionMode(int mode) {
1291 if(fileSelectionMode == mode) {
1292 return;
1293 }
1294
1295 if ((mode == FILES_ONLY) || (mode == DIRECTORIES_ONLY) || (mode == FILES_AND_DIRECTORIES)) {
1296 int oldValue = fileSelectionMode;
1297 fileSelectionMode = mode;
1298 firePropertyChange(FILE_SELECTION_MODE_CHANGED_PROPERTY, oldValue, fileSelectionMode);
1299 } else {
1300 throw new IllegalArgumentException("Incorrect Mode for file selection: " + mode);
1301 }
1302 }
1303
1304 /**
1305 * Returns the current file-selection mode. The default is
1306 * <code>JFilesChooser.FILES_ONLY</code>.
1307 *
1308 * @return the type of files to be displayed, one of the following:
1309 * <ul>
1310 * <li>JFileChooser.FILES_ONLY
1311 * <li>JFileChooser.DIRECTORIES_ONLY
1312 * <li>JFileChooser.FILES_AND_DIRECTORIES
1313 * </ul>
1314 * @see #setFileSelectionMode
1315 */
1316 public int getFileSelectionMode() {
1317 return fileSelectionMode;
1318 }
1319
1320 /**
1321 * Convenience call that determines if files are selectable based on the
1322 * current file selection mode.
1323 *
1324 * @see #setFileSelectionMode
1325 * @see #getFileSelectionMode
1326 */
1327 public boolean isFileSelectionEnabled() {
1328 return ((fileSelectionMode == FILES_ONLY) || (fileSelectionMode == FILES_AND_DIRECTORIES));
1329 }
1330
1331 /**
1332 * Convenience call that determines if directories are selectable based
1333 * on the current file selection mode.
1334 *
1335 * @see #setFileSelectionMode
1336 * @see #getFileSelectionMode
1337 */
1338 public boolean isDirectorySelectionEnabled() {
1339 return ((fileSelectionMode == DIRECTORIES_ONLY) || (fileSelectionMode == FILES_AND_DIRECTORIES));
1340 }
1341
1342 /**
1343 * Sets the file chooser to allow multiple file selections.
1344 *
1345 * @param b true if multiple files may be selected
1346 * @beaninfo
1347 * bound: true
1348 * description: Sets multiple file selection mode.
1349 *
1350 * @see #isMultiSelectionEnabled
1351 */
1352 public void setMultiSelectionEnabled(boolean b) {
1353 if(multiSelectionEnabled == b) {
1354 return;
1355 }
1356 boolean oldValue = multiSelectionEnabled;
1357 multiSelectionEnabled = b;
1358 firePropertyChange(MULTI_SELECTION_ENABLED_CHANGED_PROPERTY, oldValue, multiSelectionEnabled);
1359 }
1360
1361 /**
1362 * Returns true if multiple files can be selected.
1363 * @return true if multiple files can be selected
1364 * @see #setMultiSelectionEnabled
1365 */
1366 public boolean isMultiSelectionEnabled() {
1367 return multiSelectionEnabled;
1368 }
1369
1370
1371 /**
1372 * Returns true if hidden files are not shown in the file chooser;
1373 * otherwise, returns false.
1374 *
1375 * @return the status of the file hiding property
1376 * @see #setFileHidingEnabled
1377 */
1378 public boolean isFileHidingEnabled() {
1379 return useFileHiding;
1380 }
1381
1382 /**
1383 * Sets file hiding on or off. If true, hidden files are not shown
1384 * in the file chooser. The job of determining which files are
1385 * shown is done by the <code>FileView</code>.
1386 *
1387 * @beaninfo
1388 * preferred: true
1389 * bound: true
1390 * description: Sets file hiding on or off.
1391 *
1392 * @param b the boolean value that determines whether file hiding is
1393 * turned on
1394 * @see #isFileHidingEnabled
1395 */
1396 public void setFileHidingEnabled(boolean b) {
1397 // Dump showFilesListener since we'll ignore it from now on
1398 if (showFilesListener != null) {
1399 Toolkit.getDefaultToolkit().removePropertyChangeListener(SHOW_HIDDEN_PROP, showFilesListener);
1400 showFilesListener = null;
1401 }
1402 boolean oldValue = useFileHiding;
1403 useFileHiding = b;
1404 firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, oldValue, useFileHiding);
1405 }
1406
1407 /**
1408 * Sets the current file filter. The file filter is used by the
1409 * file chooser to filter out files from the user's view.
1410 *
1411 * @beaninfo
1412 * preferred: true
1413 * bound: true
1414 * description: Sets the File Filter used to filter out files of type.
1415 *
1416 * @param filter the new current file filter to use
1417 * @see #getFileFilter
1418 */
1419 public void setFileFilter(FileFilter filter) {
1420 FileFilter oldValue = fileFilter;
1421 fileFilter = filter;
1422 if (filter != null) {
1423 if (isMultiSelectionEnabled() && selectedFiles != null && selectedFiles.length > 0) {
1424 Vector<File> fList = new Vector<File>();
1425 boolean failed = false;
1426 for (File file : selectedFiles) {
1427 if (filter.accept(file)) {
1428 fList.add(file);
1429 } else {
1430 failed = true;
1431 }
1432 }
1433 if (failed) {
1434 setSelectedFiles((fList.size() == 0) ? null : fList.toArray(new File[fList.size()]));
1435 }
1436 } else if (selectedFile != null && !filter.accept(selectedFile)) {
1437 setSelectedFile(null);
1438 }
1439 }
1440 firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, oldValue, fileFilter);
1441 }
1442
1443
1444 /**
1445 * Returns the currently selected file filter.
1446 *
1447 * @return the current file filter
1448 * @see #setFileFilter
1449 * @see #addChoosableFileFilter
1450 */
1451 public FileFilter getFileFilter() {
1452 return fileFilter;
1453 }
1454
1455 /**
1456 * Sets the file view to used to retrieve UI information, such as
1457 * the icon that represents a file or the type description of a file.
1458 *
1459 * @beaninfo
1460 * preferred: true
1461 * bound: true
1462 * description: Sets the File View used to get file type information.
1463 *
1464 * @see #getFileView
1465 */
1466 public void setFileView(FileView fileView) {
1467 FileView oldValue = this.fileView;
1468 this.fileView = fileView;
1469 firePropertyChange(FILE_VIEW_CHANGED_PROPERTY, oldValue, fileView);
1470 }
1471
1472 /**
1473 * Returns the current file view.
1474 *
1475 * @see #setFileView
1476 */
1477 public FileView getFileView() {
1478 return fileView;
1479 }
1480
1481 // ******************************
1482 // *****FileView delegation *****
1483 // ******************************
1484
1485 // NOTE: all of the following methods attempt to delegate
1486 // first to the client set fileView, and if <code>null</code> is returned
1487 // (or there is now client defined fileView) then calls the
1488 // UI's default fileView.
1489
1490 /**
1491 * Returns the filename.
1492 * @param f the <code>File</code>
1493 * @return the <code>String</code> containing the filename for
1494 * <code>f</code>
1495 * @see FileView#getName
1496 */
1497 public String getName(File f) {
1498 String filename = null;
1499 if(f != null) {
1500 if(getFileView() != null) {
1501 filename = getFileView().getName(f);
1502 }
1503
1504 FileView uiFileView = getUI().getFileView(this);
1505
1506 if(filename == null && uiFileView != null) {
1507 filename = uiFileView.getName(f);
1508 }
1509 }
1510 return filename;
1511 }
1512
1513 /**
1514 * Returns the file description.
1515 * @param f the <code>File</code>
1516 * @return the <code>String</code> containing the file description for
1517 * <code>f</code>
1518 * @see FileView#getDescription
1519 */
1520 public String getDescription(File f) {
1521 String description = null;
1522 if(f != null) {
1523 if(getFileView() != null) {
1524 description = getFileView().getDescription(f);
1525 }
1526
1527 FileView uiFileView = getUI().getFileView(this);
1528
1529 if(description == null && uiFileView != null) {
1530 description = uiFileView.getDescription(f);
1531 }
1532 }
1533 return description;
1534 }
1535
1536 /**
1537 * Returns the file type.
1538 * @param f the <code>File</code>
1539 * @return the <code>String</code> containing the file type description for
1540 * <code>f</code>
1541 * @see FileView#getTypeDescription
1542 */
1543 public String getTypeDescription(File f) {
1544 String typeDescription = null;
1545 if(f != null) {
1546 if(getFileView() != null) {
1547 typeDescription = getFileView().getTypeDescription(f);
1548 }
1549
1550 FileView uiFileView = getUI().getFileView(this);
1551
1552 if(typeDescription == null && uiFileView != null) {
1553 typeDescription = uiFileView.getTypeDescription(f);
1554 }
1555 }
1556 return typeDescription;
1557 }
1558
1559 /**
1560 * Returns the icon for this file or type of file, depending
1561 * on the system.
1562 * @param f the <code>File</code>
1563 * @return the <code>Icon</code> for this file, or type of file
1564 * @see FileView#getIcon
1565 */
1566 public Icon getIcon(File f) {
1567 Icon icon = null;
1568 if (f != null) {
1569 if(getFileView() != null) {
1570 icon = getFileView().getIcon(f);
1571 }
1572
1573 FileView uiFileView = getUI().getFileView(this);
1574
1575 if(icon == null && uiFileView != null) {
1576 icon = uiFileView.getIcon(f);
1577 }
1578 }
1579 return icon;
1580 }
1581
1582 /**
1583 * Returns true if the file (directory) can be visited.
1584 * Returns false if the directory cannot be traversed.
1585 * @param f the <code>File</code>
1586 * @return true if the file/directory can be traversed, otherwise false
1587 * @see FileView#isTraversable
1588 */
1589 public boolean isTraversable(File f) {
1590 Boolean traversable = null;
1591 if (f != null) {
1592 if (getFileView() != null) {
1593 traversable = getFileView().isTraversable(f);
1594 }
1595
1596 FileView uiFileView = getUI().getFileView(this);
1597
1598 if (traversable == null && uiFileView != null) {
1599 traversable = uiFileView.isTraversable(f);
1600 }
1601 if (traversable == null) {
1602 traversable = getFileSystemView().isTraversable(f);
1603 }
1604 }
1605 return (traversable != null && traversable.booleanValue());
1606 }
1607
1608 /**
1609 * Returns true if the file should be displayed.
1610 * @param f the <code>File</code>
1611 * @return true if the file should be displayed, otherwise false
1612 * @see FileFilter#accept
1613 */
1614 public boolean accept(File f) {
1615 boolean shown = true;
1616 if(f != null && fileFilter != null) {
1617 shown = fileFilter.accept(f);
1618 }
1619 return shown;
1620 }
1621
1622 /**
1623 * Sets the file system view that the <code>JFileChooser</code> uses for
1624 * accessing and creating file system resources, such as finding
1625 * the floppy drive and getting a list of root drives.
1626 * @param fsv the new <code>FileSystemView</code>
1627 *
1628 * @beaninfo
1629 * expert: true
1630 * bound: true
1631 * description: Sets the FileSytemView used to get filesystem information.
1632 *
1633 * @see FileSystemView
1634 */
1635 public void setFileSystemView(FileSystemView fsv) {
1636 FileSystemView oldValue = fileSystemView;
1637 fileSystemView = fsv;
1638 firePropertyChange(FILE_SYSTEM_VIEW_CHANGED_PROPERTY, oldValue, fileSystemView);
1639 }
1640
1641 /**
1642 * Returns the file system view.
1643 * @return the <code>FileSystemView</code> object
1644 * @see #setFileSystemView
1645 */
1646 public FileSystemView getFileSystemView() {
1647 return fileSystemView;
1648 }
1649
1650 // **************************
1651 // ***** Event Handling *****
1652 // **************************
1653
1654 /**
1655 * Called by the UI when the user hits the Approve button
1656 * (labeled "Open" or "Save", by default). This can also be
1657 * called by the programmer.
1658 * This method causes an action event to fire
1659 * with the command string equal to
1660 * <code>APPROVE_SELECTION</code>.
1661 *
1662 * @see #APPROVE_SELECTION
1663 */
1664 public void approveSelection() {
1665 returnValue = APPROVE_OPTION;
1666 if(dialog != null) {
1667 dialog.setVisible(false);
1668 }
1669 fireActionPerformed(APPROVE_SELECTION);
1670 }
1671
1672 /**
1673 * Called by the UI when the user chooses the Cancel button.
1674 * This can also be called by the programmer.
1675 * This method causes an action event to fire
1676 * with the command string equal to
1677 * <code>CANCEL_SELECTION</code>.
1678 *
1679 * @see #CANCEL_SELECTION
1680 */
1681 public void cancelSelection() {
1682 returnValue = CANCEL_OPTION;
1683 if(dialog != null) {
1684 dialog.setVisible(false);
1685 }
1686 fireActionPerformed(CANCEL_SELECTION);
1687 }
1688
1689 /**
1690 * Adds an <code>ActionListener</code> to the file chooser.
1691 *
1692 * @param l the listener to be added
1693 *
1694 * @see #approveSelection
1695 * @see #cancelSelection
1696 */
1697 public void addActionListener(ActionListener l) {
1698 listenerList.add(ActionListener.class, l);
1699 }
1700
1701 /**
1702 * Removes an <code>ActionListener</code> from the file chooser.
1703 *
1704 * @param l the listener to be removed
1705 *
1706 * @see #addActionListener
1707 */
1708 public void removeActionListener(ActionListener l) {
1709 listenerList.remove(ActionListener.class, l);
1710 }
1711
1712 /**
1713 * Returns an array of all the action listeners
1714 * registered on this file chooser.
1715 *
1716 * @return all of this file chooser's <code>ActionListener</code>s
1717 * or an empty
1718 * array if no action listeners are currently registered
1719 *
1720 * @see #addActionListener
1721 * @see #removeActionListener
1722 *
1723 * @since 1.4
1724 */
1725 public ActionListener[] getActionListeners() {
1726 return listenerList.getListeners(ActionListener.class);
1727 }
1728
1729 /**
1730 * Notifies all listeners that have registered interest for
1731 * notification on this event type. The event instance
1732 * is lazily created using the <code>command</code> parameter.
1733 *
1734 * @see EventListenerList
1735 */
1736 protected void fireActionPerformed(String command) {
1737 // Guaranteed to return a non-null array
1738 Object[] listeners = listenerList.getListenerList();
1739 long mostRecentEventTime = EventQueue.getMostRecentEventTime();
1740 int modifiers = 0;
1741 AWTEvent currentEvent = EventQueue.getCurrentEvent();
1742 if (currentEvent instanceof InputEvent) {
1743 modifiers = ((InputEvent)currentEvent).getModifiers();
1744 } else if (currentEvent instanceof ActionEvent) {
1745 modifiers = ((ActionEvent)currentEvent).getModifiers();
1746 }
1747 ActionEvent e = null;
1748 // Process the listeners last to first, notifying
1749 // those that are interested in this event
1750 for (int i = listeners.length-2; i>=0; i-=2) {
1751 if (listeners[i]==ActionListener.class) {
1752 // Lazily create the event:
1753 if (e == null) {
1754 e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
1755 command, mostRecentEventTime,
1756 modifiers);
1757 }
1758 ((ActionListener)listeners[i+1]).actionPerformed(e);
1759 }
1760 }
1761 }
1762
1763 private static class WeakPCL implements PropertyChangeListener {
1764 WeakReference<JFileChooser> jfcRef;
1765
1766 public WeakPCL(JFileChooser jfc) {
1767 jfcRef = new WeakReference<JFileChooser>(jfc);
1768 }
1769 public void propertyChange(PropertyChangeEvent ev) {
1770 assert ev.getPropertyName().equals(SHOW_HIDDEN_PROP);
1771 JFileChooser jfc = jfcRef.get();
1772 if (jfc == null) {
1773 // Our JFileChooser is no longer around, so we no longer need to
1774 // listen for PropertyChangeEvents.
1775 Toolkit.getDefaultToolkit().removePropertyChangeListener(SHOW_HIDDEN_PROP, this);
1776 }
1777 else {
1778 boolean oldValue = jfc.useFileHiding;
1779 jfc.useFileHiding = !((Boolean)ev.getNewValue()).booleanValue();
1780 jfc.firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, oldValue, jfc.useFileHiding);
1781 }
1782 }
1783 }
1784
1785 // *********************************
1786 // ***** Pluggable L&F methods *****
1787 // *********************************
1788
1789 /**
1790 * Resets the UI property to a value from the current look and feel.
1791 *
1792 * @see JComponent#updateUI
1793 */
1794 public void updateUI() {
1795 if (isAcceptAllFileFilterUsed()) {
1796 removeChoosableFileFilter(getAcceptAllFileFilter());
1797 }
1798 FileChooserUI ui = ((FileChooserUI)UIManager.getUI(this));
1799 if (fileSystemView == null) {
1800 // We were probably deserialized
1801 setFileSystemView(FileSystemView.getFileSystemView());
1802 }
1803 setUI(ui);
1804
1805 if(isAcceptAllFileFilterUsed()) {
1806 addChoosableFileFilter(getAcceptAllFileFilter());
1807 }
1808 }
1809
1810 /**
1811 * Returns a string that specifies the name of the L&F class
1812 * that renders this component.
1813 *
1814 * @return the string "FileChooserUI"
1815 * @see JComponent#getUIClassID
1816 * @see UIDefaults#getUI
1817 * @beaninfo
1818 * expert: true
1819 * description: A string that specifies the name of the L&F class.
1820 */
1821 public String getUIClassID() {
1822 return uiClassID;
1823 }
1824
1825 /**
1826 * Gets the UI object which implements the L&F for this component.
1827 *
1828 * @return the FileChooserUI object that implements the FileChooserUI L&F
1829 */
1830 public FileChooserUI getUI() {
1831 return (FileChooserUI) ui;
1832 }
1833
1834 /**
1835 * See <code>readObject</code> and <code>writeObject</code> in
1836 * <code>JComponent</code> for more
1837 * information about serialization in Swing.
1838 */
1839 private void readObject(java.io.ObjectInputStream in)
1840 throws IOException, ClassNotFoundException {
1841 in.defaultReadObject();
1842 installShowFilesListener();
1843 }
1844
1845 /**
1846 * See <code>readObject</code> and <code>writeObject</code> in
1847 * <code>JComponent</code> for more
1848 * information about serialization in Swing.
1849 */
1850 private void writeObject(ObjectOutputStream s) throws IOException {
1851 FileSystemView fsv = null;
1852
1853 if (isAcceptAllFileFilterUsed()) {
1854 //The AcceptAllFileFilter is UI specific, it will be reset by
1855 //updateUI() after deserialization
1856 removeChoosableFileFilter(getAcceptAllFileFilter());
1857 }
1858 if (fileSystemView.equals(FileSystemView.getFileSystemView())) {
1859 //The default FileSystemView is platform specific, it will be
1860 //reset by updateUI() after deserialization
1861 fsv = fileSystemView;
1862 fileSystemView = null;
1863 }
1864 s.defaultWriteObject();
1865 if (fsv != null) {
1866 fileSystemView = fsv;
1867 }
1868 if (isAcceptAllFileFilterUsed()) {
1869 addChoosableFileFilter(getAcceptAllFileFilter());
1870 }
1871 if (getUIClassID().equals(uiClassID)) {
1872 byte count = JComponent.getWriteObjCounter(this);
1873 JComponent.setWriteObjCounter(this, --count);
1874 if (count == 0 && ui != null) {
1875 ui.installUI(this);
1876 }
1877 }
1878 }
1879
1880
1881 /**
1882 * Returns a string representation of this <code>JFileChooser</code>.
1883 * This method
1884 * is intended to be used only for debugging purposes, and the
1885 * content and format of the returned string may vary between
1886 * implementations. The returned string may be empty but may not
1887 * be <code>null</code>.
1888 *
1889 * @return a string representation of this <code>JFileChooser</code>
1890 */
1891 protected String paramString() {
1892 String approveButtonTextString = (approveButtonText != null ?
1893 approveButtonText: "");
1894 String dialogTitleString = (dialogTitle != null ?
1895 dialogTitle: "");
1896 String dialogTypeString;
1897 if (dialogType == OPEN_DIALOG) {
1898 dialogTypeString = "OPEN_DIALOG";
1899 } else if (dialogType == SAVE_DIALOG) {
1900 dialogTypeString = "SAVE_DIALOG";
1901 } else if (dialogType == CUSTOM_DIALOG) {
1902 dialogTypeString = "CUSTOM_DIALOG";
1903 } else dialogTypeString = "";
1904 String returnValueString;
1905 if (returnValue == CANCEL_OPTION) {
1906 returnValueString = "CANCEL_OPTION";
1907 } else if (returnValue == APPROVE_OPTION) {
1908 returnValueString = "APPROVE_OPTION";
1909 } else if (returnValue == ERROR_OPTION) {
1910 returnValueString = "ERROR_OPTION";
1911 } else returnValueString = "";
1912 String useFileHidingString = (useFileHiding ?
1913 "true" : "false");
1914 String fileSelectionModeString;
1915 if (fileSelectionMode == FILES_ONLY) {
1916 fileSelectionModeString = "FILES_ONLY";
1917 } else if (fileSelectionMode == DIRECTORIES_ONLY) {
1918 fileSelectionModeString = "DIRECTORIES_ONLY";
1919 } else if (fileSelectionMode == FILES_AND_DIRECTORIES) {
1920 fileSelectionModeString = "FILES_AND_DIRECTORIES";
1921 } else fileSelectionModeString = "";
1922 String currentDirectoryString = (currentDirectory != null ?
1923 currentDirectory.toString() : "");
1924 String selectedFileString = (selectedFile != null ?
1925 selectedFile.toString() : "");
1926
1927 return super.paramString() +
1928 ",approveButtonText=" + approveButtonTextString +
1929 ",currentDirectory=" + currentDirectoryString +
1930 ",dialogTitle=" + dialogTitleString +
1931 ",dialogType=" + dialogTypeString +
1932 ",fileSelectionMode=" + fileSelectionModeString +
1933 ",returnValue=" + returnValueString +
1934 ",selectedFile=" + selectedFileString +
1935 ",useFileHiding=" + useFileHidingString;
1936 }
1937
1938 /////////////////
1939 // Accessibility support
1940 ////////////////
1941
1942 protected AccessibleContext accessibleContext = null;
1943
1944 /**
1945 * Gets the AccessibleContext associated with this JFileChooser.
1946 * For file choosers, the AccessibleContext takes the form of an
1947 * AccessibleJFileChooser.
1948 * A new AccessibleJFileChooser instance is created if necessary.
1949 *
1950 * @return an AccessibleJFileChooser that serves as the
1951 * AccessibleContext of this JFileChooser
1952 */
1953 public AccessibleContext getAccessibleContext() {
1954 if (accessibleContext == null) {
1955 accessibleContext = new AccessibleJFileChooser();
1956 }
1957 return accessibleContext;
1958 }
1959
1960 /**
1961 * This class implements accessibility support for the
1962 * <code>JFileChooser</code> class. It provides an implementation of the
1963 * Java Accessibility API appropriate to file chooser user-interface
1964 * elements.
1965 */
1966 protected class AccessibleJFileChooser extends AccessibleJComponent {
1967
1968 /**
1969 * Gets the role of this object.
1970 *
1971 * @return an instance of AccessibleRole describing the role of the
1972 * object
1973 * @see AccessibleRole
1974 */
1975 public AccessibleRole getAccessibleRole() {
1976 return AccessibleRole.FILE_CHOOSER;
1977 }
1978
1979 } // inner class AccessibleJFileChooser
1980
1981 }