1 /*
2 * Copyright (c) 2011, 2013, 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 com.apple.laf;
27
28 import java.awt.*;
29 import java.awt.datatransfer.*;
30 import java.awt.dnd.*;
31 import java.awt.event.*;
32 import java.beans.*;
33 import java.io.File;
34 import java.net.URI;
35 import java.text.DateFormat;
36 import java.util.*;
37
38 import javax.swing.*;
39 import javax.swing.border.Border;
40 import javax.swing.event.*;
41 import javax.swing.filechooser.*;
42 import javax.swing.plaf.*;
43 import javax.swing.table.*;
44
45 import sun.swing.SwingUtilities2;
46
47 public class AquaFileChooserUI extends FileChooserUI {
48 /* FileView icons */
49 protected Icon directoryIcon = null;
50 protected Icon fileIcon = null;
51 protected Icon computerIcon = null;
52 protected Icon hardDriveIcon = null;
53 protected Icon floppyDriveIcon = null;
54
55 protected Icon upFolderIcon = null;
56 protected Icon homeFolderIcon = null;
57 protected Icon listViewIcon = null;
58 protected Icon detailsViewIcon = null;
59
60 protected int saveButtonMnemonic = 0;
61 protected int openButtonMnemonic = 0;
62 protected int cancelButtonMnemonic = 0;
63 protected int updateButtonMnemonic = 0;
64 protected int helpButtonMnemonic = 0;
65 protected int chooseButtonMnemonic = 0;
66
67 private String saveTitleText = null;
68 private String openTitleText = null;
69 String newFolderTitleText = null;
70
71 protected String saveButtonText = null;
72 protected String openButtonText = null;
73 protected String cancelButtonText = null;
74 protected String updateButtonText = null;
75 protected String helpButtonText = null;
76 protected String newFolderButtonText = null;
77 protected String chooseButtonText = null;
78
79 //private String newFolderErrorSeparator = null;
80 String newFolderErrorText = null;
81 String newFolderExistsErrorText = null;
82 protected String fileDescriptionText = null;
83 protected String directoryDescriptionText = null;
84
85 protected String saveButtonToolTipText = null;
86 protected String openButtonToolTipText = null;
87 protected String cancelButtonToolTipText = null;
88 protected String updateButtonToolTipText = null;
89 protected String helpButtonToolTipText = null;
90 protected String chooseItemButtonToolTipText = null; // Choose anything
91 protected String chooseFolderButtonToolTipText = null; // Choose folder
92 protected String directoryComboBoxToolTipText = null;
93 protected String filenameTextFieldToolTipText = null;
94 protected String filterComboBoxToolTipText = null;
95 protected String openDirectoryButtonToolTipText = null;
96
97 protected String cancelOpenButtonToolTipText = null;
98 protected String cancelSaveButtonToolTipText = null;
99 protected String cancelChooseButtonToolTipText = null;
100 protected String cancelNewFolderButtonToolTipText = null;
101
102 protected String desktopName = null;
103 String newFolderDialogPrompt = null;
104 String newFolderDefaultName = null;
105 private String newFileDefaultName = null;
106 String createButtonText = null;
107
108 JFileChooser filechooser = null;
109
110 private MouseListener doubleClickListener = null;
111 private PropertyChangeListener propertyChangeListener = null;
112 private AncestorListener ancestorListener = null;
113 private DropTarget dragAndDropTarget = null;
114
115 private final AcceptAllFileFilter acceptAllFileFilter = new AcceptAllFileFilter();
116
117 private AquaFileSystemModel model;
118
119 final AquaFileView fileView = new AquaFileView(this);
120
121 boolean selectionInProgress = false;
122
123 // The accessoryPanel is a container to place the JFileChooser accessory component
124 private JPanel accessoryPanel = null;
125
126 //
127 // ComponentUI Interface Implementation methods
128 //
129 public static ComponentUI createUI(final JComponent c) {
130 return new AquaFileChooserUI((JFileChooser)c);
131 }
132
133 public AquaFileChooserUI(final JFileChooser filechooser) {
134 super();
135 }
136
137 public void installUI(final JComponent c) {
138 accessoryPanel = new JPanel(new BorderLayout());
139 filechooser = (JFileChooser)c;
140
141 createModel();
142
143 installDefaults(filechooser);
144 installComponents(filechooser);
145 installListeners(filechooser);
146
147 AquaUtils.enforceComponentOrientation(filechooser, ComponentOrientation.getOrientation(Locale.getDefault()));
148 }
149
150 public void uninstallUI(final JComponent c) {
151 uninstallListeners(filechooser);
152 uninstallComponents(filechooser);
153 uninstallDefaults(filechooser);
154
155 if (accessoryPanel != null) {
156 accessoryPanel.removeAll();
157 }
158
159 accessoryPanel = null;
160 getFileChooser().removeAll();
161 }
162
163 protected void installListeners(final JFileChooser fc) {
164 doubleClickListener = createDoubleClickListener(fc, fFileList);
165 fFileList.addMouseListener(doubleClickListener);
166
167 propertyChangeListener = createPropertyChangeListener(fc);
168 if (propertyChangeListener != null) {
169 fc.addPropertyChangeListener(propertyChangeListener);
170 }
171 if (model != null) fc.addPropertyChangeListener(model);
172
173 ancestorListener = new AncestorListener(){
174 public void ancestorAdded(final AncestorEvent e) {
175 // Request defaultness for the appropriate button based on mode
176 setFocusForMode(getFileChooser());
177 // Request defaultness for the appropriate button based on mode
178 setDefaultButtonForMode(getFileChooser());
179 }
180
181 public void ancestorRemoved(final AncestorEvent e) {
182 }
183
184 public void ancestorMoved(final AncestorEvent e) {
185 }
186 };
187 fc.addAncestorListener(ancestorListener);
188
189 fc.registerKeyboardAction(new CancelSelectionAction(), KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
190 dragAndDropTarget = new DropTarget(fc, DnDConstants.ACTION_COPY, new DnDHandler(), true);
191 fc.setDropTarget(dragAndDropTarget);
192 }
193
194 protected void uninstallListeners(final JFileChooser fc) {
195 if (propertyChangeListener != null) {
196 fc.removePropertyChangeListener(propertyChangeListener);
197 }
198 fFileList.removeMouseListener(doubleClickListener);
199 fc.removePropertyChangeListener(model);
200 fc.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0));
201 fc.removeAncestorListener(ancestorListener);
202 fc.setDropTarget(null);
203 ancestorListener = null;
204 }
205
206 protected void installDefaults(final JFileChooser fc) {
207 installIcons(fc);
208 installStrings(fc);
209 setPackageIsTraversable(fc.getClientProperty(PACKAGE_TRAVERSABLE_PROPERTY));
210 setApplicationIsTraversable(fc.getClientProperty(APPLICATION_TRAVERSABLE_PROPERTY));
211 }
212
213 protected void installIcons(final JFileChooser fc) {
214 directoryIcon = UIManager.getIcon("FileView.directoryIcon");
215 fileIcon = UIManager.getIcon("FileView.fileIcon");
216 computerIcon = UIManager.getIcon("FileView.computerIcon");
217 hardDriveIcon = UIManager.getIcon("FileView.hardDriveIcon");
218 }
219
220 String getString(final String uiKey, final String fallback) {
221 final String result = UIManager.getString(uiKey);
222 return (result == null ? fallback : result);
223 }
224
225 protected void installStrings(final JFileChooser fc) {
226 // Exist in basic.properties (though we might want to override)
227 fileDescriptionText = UIManager.getString("FileChooser.fileDescriptionText");
228 directoryDescriptionText = UIManager.getString("FileChooser.directoryDescriptionText");
229 newFolderErrorText = getString("FileChooser.newFolderErrorText", "Error occurred during folder creation");
230
231 saveButtonText = UIManager.getString("FileChooser.saveButtonText");
232 openButtonText = UIManager.getString("FileChooser.openButtonText");
233 cancelButtonText = UIManager.getString("FileChooser.cancelButtonText");
234 updateButtonText = UIManager.getString("FileChooser.updateButtonText");
235 helpButtonText = UIManager.getString("FileChooser.helpButtonText");
236
237 saveButtonMnemonic = UIManager.getInt("FileChooser.saveButtonMnemonic");
238 openButtonMnemonic = UIManager.getInt("FileChooser.openButtonMnemonic");
239 cancelButtonMnemonic = UIManager.getInt("FileChooser.cancelButtonMnemonic");
240 updateButtonMnemonic = UIManager.getInt("FileChooser.updateButtonMnemonic");
241 helpButtonMnemonic = UIManager.getInt("FileChooser.helpButtonMnemonic");
242 chooseButtonMnemonic = UIManager.getInt("FileChooser.chooseButtonMnemonic");
243
244 saveButtonToolTipText = UIManager.getString("FileChooser.saveButtonToolTipText");
245 openButtonToolTipText = UIManager.getString("FileChooser.openButtonToolTipText");
246 cancelButtonToolTipText = UIManager.getString("FileChooser.cancelButtonToolTipText");
247 updateButtonToolTipText = UIManager.getString("FileChooser.updateButtonToolTipText");
248 helpButtonToolTipText = UIManager.getString("FileChooser.helpButtonToolTipText");
249
250 // Mac-specific, but fallback to basic if it's missing
251 saveTitleText = getString("FileChooser.saveTitleText", saveButtonText);
252 openTitleText = getString("FileChooser.openTitleText", openButtonText);
253
254 // Mac-specific, required
255 newFolderExistsErrorText = getString("FileChooser.newFolderExistsErrorText", "That name is already taken");
256 chooseButtonText = getString("FileChooser.chooseButtonText", "Choose");
257 newFolderButtonText = getString("FileChooser.newFolderButtonText", "New");
258 newFolderTitleText = getString("FileChooser.newFolderTitleText", "New Folder");
259
260 if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {
261 fileNameLabelText = getString("FileChooser.saveDialogFileNameLabelText", "Save As:");
262 } else {
263 fileNameLabelText = getString("FileChooser.fileNameLabelText", "Name:");
264 }
265
266 filesOfTypeLabelText = getString("FileChooser.filesOfTypeLabelText", "Format:");
267
268 desktopName = getString("FileChooser.desktopName", "Desktop");
269 newFolderDialogPrompt = getString("FileChooser.newFolderPromptText", "Name of new folder:");
270 newFolderDefaultName = getString("FileChooser.untitledFolderName", "untitled folder");
271 newFileDefaultName = getString("FileChooser.untitledFileName", "untitled");
272 createButtonText = getString("FileChooser.createButtonText", "Create");
273
274 fColumnNames[1] = getString("FileChooser.byDateText", "Date Modified");
275 fColumnNames[0] = getString("FileChooser.byNameText", "Name");
276
277 // Mac-specific, optional
278 chooseItemButtonToolTipText = UIManager.getString("FileChooser.chooseItemButtonToolTipText");
279 chooseFolderButtonToolTipText = UIManager.getString("FileChooser.chooseFolderButtonToolTipText");
280 openDirectoryButtonToolTipText = UIManager.getString("FileChooser.openDirectoryButtonToolTipText");
281
282 directoryComboBoxToolTipText = UIManager.getString("FileChooser.directoryComboBoxToolTipText");
283 filenameTextFieldToolTipText = UIManager.getString("FileChooser.filenameTextFieldToolTipText");
284 filterComboBoxToolTipText = UIManager.getString("FileChooser.filterComboBoxToolTipText");
285
286 cancelOpenButtonToolTipText = UIManager.getString("FileChooser.cancelOpenButtonToolTipText");
287 cancelSaveButtonToolTipText = UIManager.getString("FileChooser.cancelSaveButtonToolTipText");
288 cancelChooseButtonToolTipText = UIManager.getString("FileChooser.cancelChooseButtonToolTipText");
289 cancelNewFolderButtonToolTipText = UIManager.getString("FileChooser.cancelNewFolderButtonToolTipText");
290
291 newFolderTitleText = UIManager.getString("FileChooser.newFolderTitleText");
292 newFolderToolTipText = UIManager.getString("FileChooser.newFolderToolTipText");
293 newFolderAccessibleName = getString("FileChooser.newFolderAccessibleName", newFolderTitleText);
294 }
295
296 protected void uninstallDefaults(final JFileChooser fc) {
297 uninstallIcons(fc);
298 uninstallStrings(fc);
299 }
300
301 protected void uninstallIcons(final JFileChooser fc) {
302 directoryIcon = null;
303 fileIcon = null;
304 computerIcon = null;
305 hardDriveIcon = null;
306 floppyDriveIcon = null;
307
308 upFolderIcon = null;
309 homeFolderIcon = null;
310 detailsViewIcon = null;
311 listViewIcon = null;
312 }
313
314 protected void uninstallStrings(final JFileChooser fc) {
315 saveTitleText = null;
316 openTitleText = null;
317 newFolderTitleText = null;
318
319 saveButtonText = null;
320 openButtonText = null;
321 cancelButtonText = null;
322 updateButtonText = null;
323 helpButtonText = null;
324 newFolderButtonText = null;
325 chooseButtonText = null;
326
327 cancelOpenButtonToolTipText = null;
328 cancelSaveButtonToolTipText = null;
329 cancelChooseButtonToolTipText = null;
330 cancelNewFolderButtonToolTipText = null;
331
332 saveButtonToolTipText = null;
333 openButtonToolTipText = null;
334 cancelButtonToolTipText = null;
335 updateButtonToolTipText = null;
336 helpButtonToolTipText = null;
337 chooseItemButtonToolTipText = null;
338 chooseFolderButtonToolTipText = null;
339 openDirectoryButtonToolTipText = null;
340 directoryComboBoxToolTipText = null;
341 filenameTextFieldToolTipText = null;
342 filterComboBoxToolTipText = null;
343
344 newFolderDefaultName = null;
345 newFileDefaultName = null;
346
347 desktopName = null;
348 }
349
350 protected void createModel() {
351 }
352
353 AquaFileSystemModel getModel() {
354 return model;
355 }
356
357 /*
358 * Listen for filechooser property changes, such as
359 * the selected file changing, or the type of the dialog changing.
360 */
361 // Taken almost verbatim from Metal
362 protected PropertyChangeListener createPropertyChangeListener(final JFileChooser fc) {
363 return new PropertyChangeListener(){
364 public void propertyChange(final PropertyChangeEvent e) {
365 final String prop = e.getPropertyName();
366 if (prop.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)) {
367 final File f = (File)e.getNewValue();
368 if (f != null) {
369 // Select the file in the list if the selected file didn't change as
370 // a result of a list click.
371 if (!selectionInProgress && getModel().contains(f)) {
372 fFileList.setSelectedIndex(getModel().indexOf(f));
373 }
374
375 // [3643835] Need to populate the text field here. No-op on Open dialogs
376 // Note that this was removed for 3514735, but should not have been.
377 if (!f.isDirectory()) {
378 setFileName(getFileChooser().getName(f));
379 }
380 }
381 updateButtonState(getFileChooser());
382 } else if (prop.equals(JFileChooser.SELECTED_FILES_CHANGED_PROPERTY)) {
383 JFileChooser fileChooser = getFileChooser();
384 if (!fileChooser.isDirectorySelectionEnabled()) {
385 final File[] files = (File[]) e.getNewValue();
386 if (files != null) {
387 for (int selectedRow : fFileList.getSelectedRows()) {
388 File file = (File) fFileList.getValueAt(selectedRow, 0);
389 if (fileChooser.isTraversable(file)) {
390 fFileList.removeSelectedIndex(selectedRow);
391 }
392 }
393 }
394 }
395 } else if (prop.equals(JFileChooser.DIRECTORY_CHANGED_PROPERTY)) {
396 fFileList.clearSelection();
397 final File currentDirectory = getFileChooser().getCurrentDirectory();
398 if (currentDirectory != null) {
399 fDirectoryComboBoxModel.addItem(currentDirectory);
400 // Enable the newFolder action if the current directory
401 // is writable.
402 // PENDING(jeff) - broken - fix
403 getAction(kNewFolder).setEnabled(currentDirectory.canWrite());
404 }
405 updateButtonState(getFileChooser());
406 } else if (prop.equals(JFileChooser.FILE_SELECTION_MODE_CHANGED_PROPERTY)) {
407 fFileList.clearSelection();
408 setBottomPanelForMode(getFileChooser()); // Also updates approve button
409 } else if (prop == JFileChooser.ACCESSORY_CHANGED_PROPERTY) {
410 if (getAccessoryPanel() != null) {
411 if (e.getOldValue() != null) {
412 getAccessoryPanel().remove((JComponent)e.getOldValue());
413 }
414 final JComponent accessory = (JComponent)e.getNewValue();
415 if (accessory != null) {
416 getAccessoryPanel().add(accessory, BorderLayout.CENTER);
417 }
418 }
419 } else if (prop == JFileChooser.APPROVE_BUTTON_TEXT_CHANGED_PROPERTY) {
420 updateApproveButton(getFileChooser());
421 getFileChooser().invalidate();
422 } else if (prop == JFileChooser.DIALOG_TYPE_CHANGED_PROPERTY) {
423 if (getFileChooser().getDialogType() == JFileChooser.SAVE_DIALOG) {
424 fileNameLabelText = getString("FileChooser.saveDialogFileNameLabelText", "Save As:");
425 } else {
426 fileNameLabelText = getString("FileChooser.fileNameLabelText", "Name:");
427 }
428 fTextFieldLabel.setText(fileNameLabelText);
429
430 // Mac doesn't show the text field or "new folder" button in 'Open' dialogs
431 setBottomPanelForMode(getFileChooser()); // Also updates approve button
432 } else if (prop.equals(JFileChooser.APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY)) {
433 getApproveButton(getFileChooser()).setMnemonic(getApproveButtonMnemonic(getFileChooser()));
434 } else if (prop.equals(PACKAGE_TRAVERSABLE_PROPERTY)) {
435 setPackageIsTraversable(e.getNewValue());
436 } else if (prop.equals(APPLICATION_TRAVERSABLE_PROPERTY)) {
437 setApplicationIsTraversable(e.getNewValue());
438 } else if (prop.equals(JFileChooser.MULTI_SELECTION_ENABLED_CHANGED_PROPERTY)) {
439 if (getFileChooser().isMultiSelectionEnabled()) {
440 fFileList.getSelectionModel().setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
441 } else {
442 fFileList.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
443 }
444 } else if (prop.equals(JFileChooser.CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY)) {
445 doControlButtonsChanged(e);
446 }
447 }
448 };
449 }
450
451 void setPackageIsTraversable(final Object o) {
452 int newProp = -1;
453 if (o != null && o instanceof String) newProp = parseTraversableProperty((String)o);
454 if (newProp != -1) fPackageIsTraversable = newProp;
455 else fPackageIsTraversable = sGlobalPackageIsTraversable;
456 }
457
458 void setApplicationIsTraversable(final Object o) {
459 int newProp = -1;
460 if (o != null && o instanceof String) newProp = parseTraversableProperty((String)o);
461 if (newProp != -1) fApplicationIsTraversable = newProp;
462 else fApplicationIsTraversable = sGlobalApplicationIsTraversable;
463 }
464
465 void doControlButtonsChanged(final PropertyChangeEvent e) {
466 if (getFileChooser().getControlButtonsAreShown()) {
467 fBottomPanel.add(fDirectoryPanelSpacer);
468 fBottomPanel.add(fDirectoryPanel);
469 } else {
470 fBottomPanel.remove(fDirectoryPanelSpacer);
471 fBottomPanel.remove(fDirectoryPanel);
472 }
473 }
474
475 public String getFileName() {
476 if (filenameTextField != null) { return filenameTextField.getText(); }
477 return null;
478 }
479
480 public String getDirectoryName() {
481 // PENDING(jeff) - get the name from the directory combobox
482 return null;
483 }
484
485 public void setFileName(final String filename) {
486 if (filenameTextField != null) {
487 filenameTextField.setText(filename);
488 }
489 }
490
491 public void setDirectoryName(final String dirname) {
492 // PENDING(jeff) - set the name in the directory combobox
493 }
494
495 public void rescanCurrentDirectory(final JFileChooser fc) {
496 getModel().invalidateFileCache();
497 getModel().validateFileCache();
498 }
499
500 public void ensureFileIsVisible(final JFileChooser fc, final File f) {
501 if (f == null) {
502 fFileList.requestFocusInWindow();
503 fFileList.ensureIndexIsVisible(-1);
504 return;
505 }
506
507 getModel().runWhenDone(new Runnable() {
508 public void run() {
509 fFileList.requestFocusInWindow();
510 fFileList.ensureIndexIsVisible(getModel().indexOf(f));
511 }
512 });
513 }
514
515 public JFileChooser getFileChooser() {
516 return filechooser;
517 }
518
519 public JPanel getAccessoryPanel() {
520 return accessoryPanel;
521 }
522
523 protected JButton getApproveButton(final JFileChooser fc) {
524 return fApproveButton;
525 }
526
527 public int getApproveButtonMnemonic(final JFileChooser fc) {
528 return fSubPanel.getApproveButtonMnemonic(fc);
529 }
530
531 public String getApproveButtonToolTipText(final JFileChooser fc) {
532 return fSubPanel.getApproveButtonToolTipText(fc);
533 }
534
535 public String getApproveButtonText(final JFileChooser fc) {
536 return fSubPanel.getApproveButtonText(fc);
537 }
538
539 protected String getCancelButtonToolTipText(final JFileChooser fc) {
540 return fSubPanel.getCancelButtonToolTipText(fc);
541 }
542
543 // If the item's not selectable, it'll be visible but disabled in the list
544 boolean isSelectableInList(final File f) {
545 return fSubPanel.isSelectableInList(getFileChooser(), f);
546 }
547
548 // Is this a file that the JFileChooser wants?
549 // Directories can be selected in the list regardless of mode
550 boolean isSelectableForMode(final JFileChooser fc, final File f) {
551 if (f == null) return false;
552 final int mode = fc.getFileSelectionMode();
553 if (mode == JFileChooser.FILES_AND_DIRECTORIES) return true;
554 boolean traversable = fc.isTraversable(f);
555 if (mode == JFileChooser.DIRECTORIES_ONLY) return traversable;
556 return !traversable;
557 }
558
559 // ********************************************
560 // ************ Create Listeners **************
561 // ********************************************
562
563 // From Basic
564 public ListSelectionListener createListSelectionListener(final JFileChooser fc) {
565 return new SelectionListener();
566 }
567
568 protected class SelectionListener implements ListSelectionListener {
569 public void valueChanged(final ListSelectionEvent e) {
570 if (e.getValueIsAdjusting()) return;
571
572 File f = null;
573 final int selectedRow = fFileList.getSelectedRow();
574 final JFileChooser chooser = getFileChooser();
575 boolean isSave = (chooser.getDialogType() == JFileChooser.SAVE_DIALOG);
576 if (selectedRow >= 0) {
577 f = (File)fFileList.getValueAt(selectedRow, 0);
578 }
579
580 // Save dialog lists can't be multi select, because all we're selecting is the next folder to open
581 selectionInProgress = true;
582 if (!isSave && chooser.isMultiSelectionEnabled()) {
583 final int[] rows = fFileList.getSelectedRows();
584 int selectableCount = 0;
585 // Double-check that all the list selections are valid for this mode
586 // Directories can be selected in the list regardless of mode
587 if (rows.length > 0) {
588 for (final int element : rows) {
589 if (isSelectableForMode(chooser, (File)fFileList.getValueAt(element, 0))) selectableCount++;
590 }
591 }
592 if (selectableCount > 0) {
593 final File[] files = new File[selectableCount];
594 for (int i = 0, si = 0; i < rows.length; i++) {
595 f = (File)fFileList.getValueAt(rows[i], 0);
596 if (isSelectableForMode(chooser, f)) {
597 if (fileView.isAlias(f)) {
598 f = fileView.resolveAlias(f);
599 }
600 files[si++] = f;
601 }
602 }
603 chooser.setSelectedFiles(files);
604 } else {
605 chooser.setSelectedFiles(null);
606 }
607 } else {
608 chooser.setSelectedFiles(null);
609 chooser.setSelectedFile(f);
610 }
611 selectionInProgress = false;
612 }
613 }
614
615 // When the Save textfield has the focus, the button should say "Save"
616 // Otherwise, it depends on the list selection
617 protected class SaveTextFocusListener implements FocusListener {
618 public void focusGained(final FocusEvent e) {
619 updateButtonState(getFileChooser());
620 }
621
622 // Do nothing, we might be losing focus due to window deactivation
623 public void focusLost(final FocusEvent e) {
624
625 }
626 }
627
628 // When the Save textfield is empty and the button says "Save", it should be disabled
629 // Otherwise, it depends on the list selection
630 protected class SaveTextDocumentListener implements DocumentListener {
631 public void insertUpdate(final DocumentEvent e) {
632 textChanged();
633 }
634
635 public void removeUpdate(final DocumentEvent e) {
636 textChanged();
637 }
638
639 public void changedUpdate(final DocumentEvent e) {
640
641 }
642
643 void textChanged() {
644 updateButtonState(getFileChooser());
645 }
646 }
647
648 // Opens the File object if it's a traversable directory
649 protected boolean openDirectory(final File f) {
650 if (getFileChooser().isTraversable(f)) {
651 fFileList.clearSelection();
652 // Resolve any aliases
653 final File original = fileView.resolveAlias(f);
654 getFileChooser().setCurrentDirectory(original);
655 updateButtonState(getFileChooser());
656 return true;
657 }
658 return false;
659 }
660
661 // From Basic
662 protected class DoubleClickListener extends MouseAdapter {
663 JTableExtension list;
664
665 public DoubleClickListener(final JTableExtension list) {
666 this.list = list;
667 }
668
669 public void mouseClicked(final MouseEvent e) {
670 if (e.getClickCount() != 2) return;
671
672 final int index = list.locationToIndex(e.getPoint());
673 if (index < 0) return;
674
675 final File f = (File)((AquaFileSystemModel)list.getModel()).getElementAt(index);
676 if (openDirectory(f)) return;
677
678 if (!isSelectableInList(f)) return;
679 getFileChooser().approveSelection();
680 }
681 }
682
683 protected MouseListener createDoubleClickListener(final JFileChooser fc, final JTableExtension list) {
684 return new DoubleClickListener(list);
685 }
686
687 // listens for drag events onto the JFileChooser and sets the selected file or directory
688 class DnDHandler extends DropTargetAdapter {
689 public void dragEnter(final DropTargetDragEvent dtde) {
690 tryToAcceptDrag(dtde);
691 }
692
693 public void dragOver(final DropTargetDragEvent dtde) {
694 tryToAcceptDrag(dtde);
695 }
696
697 public void dropActionChanged(final DropTargetDragEvent dtde) {
698 tryToAcceptDrag(dtde);
699 }
700
701 public void drop(final DropTargetDropEvent dtde) {
702 if (dtde.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
703 handleFileDropEvent(dtde);
704 return;
705 }
706
707 if (dtde.isDataFlavorSupported(DataFlavor.stringFlavor)) {
708 handleStringDropEvent(dtde);
709 return;
710 }
711 }
712
713 protected void tryToAcceptDrag(final DropTargetDragEvent dtde) {
714 if (dtde.isDataFlavorSupported(DataFlavor.javaFileListFlavor) || dtde.isDataFlavorSupported(DataFlavor.stringFlavor)) {
715 dtde.acceptDrag(DnDConstants.ACTION_COPY);
716 return;
717 }
718
719 dtde.rejectDrag();
720 }
721
722 protected void handleFileDropEvent(final DropTargetDropEvent dtde) {
723 dtde.acceptDrop(dtde.getDropAction());
724 final Transferable transferable = dtde.getTransferable();
725
726 try {
727 final java.util.List<File> fileList = (java.util.List<File>)transferable.getTransferData(DataFlavor.javaFileListFlavor);
728 dropFiles(fileList.toArray(new File[fileList.size()]));
729 dtde.dropComplete(true);
730 } catch (final Exception e) {
731 dtde.dropComplete(false);
732 }
733 }
734
735 protected void handleStringDropEvent(final DropTargetDropEvent dtde) {
736 dtde.acceptDrop(dtde.getDropAction());
737 final Transferable transferable = dtde.getTransferable();
738
739 final String stringData;
740 try {
741 stringData = (String)transferable.getTransferData(DataFlavor.stringFlavor);
742 } catch (final Exception e) {
743 dtde.dropComplete(false);
744 return;
745 }
746
747 try {
748 final File fileAsPath = new File(stringData);
749 if (fileAsPath.exists()) {
750 dropFiles(new File[] {fileAsPath});
751 dtde.dropComplete(true);
752 return;
753 }
754 } catch (final Exception e) {
755 // try again
756 }
757
758 try {
759 final File fileAsURI = new File(new URI(stringData));
760 if (fileAsURI.exists()) {
761 dropFiles(new File[] {fileAsURI});
762 dtde.dropComplete(true);
763 return;
764 }
765 } catch (final Exception e) {
766 // nothing more to do
767 }
768
769 dtde.dropComplete(false);
770 }
771
772 protected void dropFiles(final File[] files) {
773 final JFileChooser jfc = getFileChooser();
774
775 if (files.length == 1) {
776 if (files[0].isDirectory()) {
777 jfc.setCurrentDirectory(files[0]);
778 return;
779 }
780
781 if (!isSelectableForMode(jfc, files[0])) {
782 return;
783 }
784 }
785
786 jfc.setSelectedFiles(files);
787 for (final File file : files) {
788 jfc.ensureFileIsVisible(file);
789 }
790 getModel().runWhenDone(new Runnable() {
791 public void run() {
792 final AquaFileSystemModel fileSystemModel = getModel();
793 for (final File element : files) {
794 final int index = fileSystemModel.indexOf(element);
795 if (index >= 0) fFileList.addRowSelectionInterval(index, index);
796 }
797 }
798 });
799 }
800 }
801
802 // FileChooser UI PLAF methods
803
804 /**
805 * Returns the default accept all file filter
806 */
807 public FileFilter getAcceptAllFileFilter(final JFileChooser fc) {
808 return acceptAllFileFilter;
809 }
810
811 public FileView getFileView(final JFileChooser fc) {
812 return fileView;
813 }
814
815 /**
816 * Returns the title of this dialog
817 */
818 public String getDialogTitle(final JFileChooser fc) {
819 if (fc.getDialogTitle() == null) {
820 if (getFileChooser().getDialogType() == JFileChooser.OPEN_DIALOG) {
821 return openTitleText;
822 } else if (getFileChooser().getDialogType() == JFileChooser.SAVE_DIALOG) { return saveTitleText; }
823 }
824 return fc.getDialogTitle();
825 }
826
827 // Utility to get the first selected item regardless of whether we're single or multi select
828 File getFirstSelectedItem() {
829 // Get the selected item
830 File selectedFile = null;
831 final int index = fFileList.getSelectedRow();
832 if (index >= 0) {
833 selectedFile = (File)((AquaFileSystemModel)fFileList.getModel()).getElementAt(index);
834 }
835 return selectedFile;
836 }
837
838 // Make a file from the filename
839 File makeFile(final JFileChooser fc, final String filename) {
840 File selectedFile = null;
841 // whitespace is legal on Macs, even on beginning and end of filename
842 if (filename != null && !filename.equals("")) {
843 final FileSystemView fs = fc.getFileSystemView();
844 selectedFile = fs.createFileObject(filename);
845 if (!selectedFile.isAbsolute()) {
846 selectedFile = fs.createFileObject(fc.getCurrentDirectory(), filename);
847 }
848 }
849 return selectedFile;
850 }
851
852 // Utility to tell if the textfield has anything in it
853 boolean textfieldIsValid() {
854 final String s = getFileName();
855 return (s != null && !s.equals(""));
856 }
857
858 // Action to attach to the file list so we can override the default action
859 // of the table for the return key, which is to select the next line.
860 protected class DefaultButtonAction extends AbstractAction {
861 public void actionPerformed(final ActionEvent e) {
862 final JRootPane root = AquaFileChooserUI.this.getFileChooser().getRootPane();
863 final JFileChooser fc = AquaFileChooserUI.this.getFileChooser();
864 final JButton owner = root.getDefaultButton();
865 if (owner != null && SwingUtilities.getRootPane(owner) == root && owner.isEnabled()) {
866 owner.doClick(20);
867 } else if (!fc.getControlButtonsAreShown()) {
868 final JButton defaultButton = AquaFileChooserUI.this.fSubPanel.getDefaultButton(fc);
869
870 if (defaultButton != null) {
871 defaultButton.doClick(20);
872 }
873 } else {
874 Toolkit.getDefaultToolkit().beep();
875 }
876 }
877
878 public boolean isEnabled() {
879 return true;
880 }
881 }
882
883 /**
884 * Creates a new folder.
885 */
886 protected class NewFolderAction extends AbstractAction {
887 protected NewFolderAction() {
888 super(newFolderAccessibleName);
889 }
890
891 // Muchlike showInputDialog, but we give it options instead of selectionValues
892 private Object showNewFolderDialog(final Component parentComponent, final Object message, final String title, final int messageType, final Icon icon, final Object[] options, final Object initialSelectionValue) {
893 final JOptionPane pane = new JOptionPane(message, messageType, JOptionPane.OK_CANCEL_OPTION, icon, options, null);
894
895 pane.setWantsInput(true);
896 pane.setInitialSelectionValue(initialSelectionValue);
897
898 final JDialog dialog = pane.createDialog(parentComponent, title);
899
900 pane.selectInitialValue();
901 dialog.setVisible(true);
902 dialog.dispose();
903
904 final Object value = pane.getValue();
905
906 if (value == null || value.equals(cancelButtonText)) {
907 return null;
908 }
909 return pane.getInputValue();
910 }
911
912 public void actionPerformed(final ActionEvent e) {
913 final JFileChooser fc = getFileChooser();
914 final File currentDirectory = fc.getCurrentDirectory();
915 File newFolder = null;
916 final String[] options = {createButtonText, cancelButtonText};
917 final String filename = (String)showNewFolderDialog(fc, //parentComponent
918 newFolderDialogPrompt, // message
919 newFolderTitleText, // title
920 JOptionPane.PLAIN_MESSAGE, // messageType
921 null, // icon
922 options, // selectionValues
923 newFolderDefaultName); // initialSelectionValue
924
925 if (filename != null) {
926 try {
927 newFolder = fc.getFileSystemView().createFileObject(currentDirectory, filename);
928 if (newFolder.exists()) {
929 JOptionPane.showMessageDialog(fc, newFolderExistsErrorText, "", JOptionPane.ERROR_MESSAGE);
930 return;
931 }
932
933 newFolder.mkdirs();
934 } catch(final Exception exc) {
935 JOptionPane.showMessageDialog(fc, newFolderErrorText, "", JOptionPane.ERROR_MESSAGE);
936 return;
937 }
938
939 openDirectory(newFolder);
940 }
941 }
942 }
943
944 /**
945 * Responds to an Open, Save, or Choose request
946 */
947 protected class ApproveSelectionAction extends AbstractAction {
948 public void actionPerformed(final ActionEvent e) {
949 fSubPanel.approveSelection(getFileChooser());
950 }
951 }
952
953 /**
954 * Responds to an OpenDirectory request
955 */
956 protected class OpenSelectionAction extends AbstractAction {
957 public void actionPerformed(final ActionEvent e) {
958 final int index = fFileList.getSelectedRow();
959 if (index >= 0) {
960 final File selectedFile = (File)((AquaFileSystemModel)fFileList.getModel()).getElementAt(index);
961 if (selectedFile != null) openDirectory(selectedFile);
962 }
963 }
964 }
965
966 /**
967 * Responds to a cancel request.
968 */
969 protected class CancelSelectionAction extends AbstractAction {
970 public void actionPerformed(final ActionEvent e) {
971 getFileChooser().cancelSelection();
972 }
973
974 public boolean isEnabled() {
975 return getFileChooser().isEnabled();
976 }
977 }
978
979 /**
980 * Rescans the files in the current directory
981 */
982 protected class UpdateAction extends AbstractAction {
983 public void actionPerformed(final ActionEvent e) {
984 final JFileChooser fc = getFileChooser();
985 fc.setCurrentDirectory(fc.getFileSystemView().createFileObject(getDirectoryName()));
986 fc.rescanCurrentDirectory();
987 }
988 }
989
990 // *****************************************
991 // ***** default AcceptAll file filter *****
992 // *****************************************
993 protected class AcceptAllFileFilter extends FileFilter {
994 public AcceptAllFileFilter() {
995 }
996
997 public boolean accept(final File f) {
998 return true;
999 }
1000
1001 public String getDescription() {
1002 return UIManager.getString("FileChooser.acceptAllFileFilterText");
1003 }
1004 }
1005
1006 // Penultimate superclass is JLabel
1007 protected class MacFCTableCellRenderer extends DefaultTableCellRenderer {
1008 boolean fIsSelected = false;
1009
1010 public MacFCTableCellRenderer(final Font f) {
1011 super();
1012 setFont(f);
1013 setIconTextGap(10);
1014 }
1015
1016 public Component getTableCellRendererComponent(final JTable list, final Object value, final boolean isSelected, final boolean cellHasFocus, final int index, final int col) {
1017 super.getTableCellRendererComponent(list, value, isSelected, false, index, col); // No focus border, thanks
1018 fIsSelected = isSelected;
1019 return this;
1020 }
1021
1022 public boolean isSelected() {
1023 return fIsSelected && isEnabled();
1024 }
1025
1026 protected String layoutCL(final JLabel label, final FontMetrics fontMetrics, final String text, final Icon icon, final Rectangle viewR, final Rectangle iconR, final Rectangle textR) {
1027 return SwingUtilities.layoutCompoundLabel(label, fontMetrics, text, icon, label.getVerticalAlignment(), label.getHorizontalAlignment(), label.getVerticalTextPosition(), label.getHorizontalTextPosition(), viewR, iconR, textR, label.getIconTextGap());
1028 }
1029
1030 protected void paintComponent(final Graphics g) {
1031 final String text = getText();
1032 Icon icon = getIcon();
1033 if (icon != null && !isEnabled()) {
1034 final Icon disabledIcon = getDisabledIcon();
1035 if (disabledIcon != null) icon = disabledIcon;
1036 }
1037
1038 if ((icon == null) && (text == null)) { return; }
1039
1040 // from ComponentUI update
1041 g.setColor(getBackground());
1042 g.fillRect(0, 0, getWidth(), getHeight());
1043
1044 // from BasicLabelUI paint
1045 final FontMetrics fm = g.getFontMetrics();
1046 Insets paintViewInsets = getInsets(null);
1047 paintViewInsets.left += 10;
1048
1049 Rectangle paintViewR = new Rectangle(paintViewInsets.left, paintViewInsets.top, getWidth() - (paintViewInsets.left + paintViewInsets.right), getHeight() - (paintViewInsets.top + paintViewInsets.bottom));
1050
1051 Rectangle paintIconR = new Rectangle();
1052 Rectangle paintTextR = new Rectangle();
1053
1054 final String clippedText = layoutCL(this, fm, text, icon, paintViewR, paintIconR, paintTextR);
1055
1056 if (icon != null) {
1057 icon.paintIcon(this, g, paintIconR.x + 5, paintIconR.y);
1058 }
1059
1060 if (text != null) {
1061 final int textX = paintTextR.x;
1062 final int textY = paintTextR.y + fm.getAscent() + 1;
1063 if (isEnabled()) {
1064 // Color background = fIsSelected ? getForeground() : getBackground();
1065 final Color background = getBackground();
1066
1067 g.setColor(background);
1068 g.fillRect(textX - 1, paintTextR.y, paintTextR.width + 2, fm.getAscent() + 2);
1069
1070 g.setColor(getForeground());
1071 SwingUtilities2.drawString(filechooser, g, clippedText, textX, textY);
1072 } else {
1073 final Color background = getBackground();
1074 g.setColor(background);
1075 g.fillRect(textX - 1, paintTextR.y, paintTextR.width + 2, fm.getAscent() + 2);
1076
1077 g.setColor(background.brighter());
1078 SwingUtilities2.drawString(filechooser, g, clippedText, textX, textY);
1079 g.setColor(background.darker());
1080 SwingUtilities2.drawString(filechooser, g, clippedText, textX + 1, textY + 1);
1081 }
1082 }
1083 }
1084
1085 }
1086
1087 protected class FileRenderer extends MacFCTableCellRenderer {
1088 public FileRenderer(final Font f) {
1089 super(f);
1090 }
1091
1092 public Component getTableCellRendererComponent(final JTable list, final Object value, final boolean isSelected, final boolean cellHasFocus, final int index, final int col) {
1093 super.getTableCellRendererComponent(list, value, isSelected, false, index, col); // No focus border, thanks
1094 final File file = (File)value;
1095 final JFileChooser fc = getFileChooser();
1096 setText(fc.getName(file));
1097 setIcon(fc.getIcon(file));
1098 setEnabled(isSelectableInList(file));
1099 return this;
1100 }
1101 }
1102
1103 protected class DateRenderer extends MacFCTableCellRenderer {
1104 public DateRenderer(final Font f) {
1105 super(f);
1106 }
1107
1108 public Component getTableCellRendererComponent(final JTable list, final Object value, final boolean isSelected, final boolean cellHasFocus, final int index, final int col) {
1109 super.getTableCellRendererComponent(list, value, isSelected, false, index, col);
1110 final File file = (File)fFileList.getValueAt(index, 0);
1111 setEnabled(isSelectableInList(file));
1112 final DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT);
1113 final Date date = (Date)value;
1114
1115 if (date != null) {
1116 setText(formatter.format(date));
1117 } else {
1118 setText("");
1119 }
1120
1121 return this;
1122 }
1123 }
1124
1125 public Dimension getPreferredSize(final JComponent c) {
1126 return PREF_SIZE;
1127 }
1128
1129 public Dimension getMinimumSize(final JComponent c) {
1130 return MIN_SIZE;
1131 }
1132
1133 public Dimension getMaximumSize(final JComponent c) {
1134 return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
1135 }
1136
1137 protected ListCellRenderer createDirectoryComboBoxRenderer(final JFileChooser fc) {
1138 return new AquaComboBoxRendererInternal(directoryComboBox) {
1139 public Component getListCellRendererComponent(final JList list, final Object value, final int index, final boolean isSelected, final boolean cellHasFocus) {
1140 super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
1141 final File directory = (File)value;
1142 if (directory == null) {
1143 setText("");
1144 return this;
1145 }
1146
1147 final JFileChooser chooser = getFileChooser();
1148 setText(chooser.getName(directory));
1149 setIcon(chooser.getIcon(directory));
1150 return this;
1151 }
1152 };
1153 }
1154
1155 //
1156 // DataModel for DirectoryComboxbox
1157 //
1158 protected DirectoryComboBoxModel createDirectoryComboBoxModel(final JFileChooser fc) {
1159 return new DirectoryComboBoxModel();
1160 }
1161
1162 /**
1163 * Data model for a type-face selection combo-box.
1164 */
1165 protected class DirectoryComboBoxModel extends AbstractListModel implements ComboBoxModel {
1166 Vector<File> fDirectories = new Vector<File>();
1167 int topIndex = -1;
1168 int fPathCount = 0;
1169
1170 File fSelectedDirectory = null;
1171
1172 public DirectoryComboBoxModel() {
1173 super();
1174 // Add the current directory to the model, and make it the
1175 // selectedDirectory
1176 addItem(getFileChooser().getCurrentDirectory());
1177 }
1178
1179 /**
1180 * Removes the selected directory, and clears out the
1181 * path file entries leading up to that directory.
1182 */
1183 private void removeSelectedDirectory() {
1184 fDirectories.removeAllElements();
1185 fPathCount = 0;
1186 fSelectedDirectory = null;
1187 // dump();
1188 }
1189
1190 /**
1191 * Adds the directory to the model and sets it to be selected,
1192 * additionally clears out the previous selected directory and
1193 * the paths leading up to it, if any.
1194 */
1195 void addItem(final File directory) {
1196 if (directory == null) { return; }
1197 if (fSelectedDirectory != null) {
1198 removeSelectedDirectory();
1199 }
1200
1201 // create File instances of each directory leading up to the top
1202 File f = directory.getAbsoluteFile();
1203 final Vector<File> path = new Vector<File>(10);
1204 while (f.getParent() != null) {
1205 path.addElement(f);
1206 f = getFileChooser().getFileSystemView().createFileObject(f.getParent());
1207 };
1208
1209 // Add root file (the desktop) to the model
1210 final File[] roots = getFileChooser().getFileSystemView().getRoots();
1211 for (final File element : roots) {
1212 path.addElement(element);
1213 }
1214 fPathCount = path.size();
1215
1216 // insert all the path fDirectories leading up to the
1217 // selected directory in reverse order (current directory at top)
1218 for (int i = 0; i < path.size(); i++) {
1219 fDirectories.addElement(path.elementAt(i));
1220 }
1221
1222 setSelectedItem(fDirectories.elementAt(0));
1223
1224 // dump();
1225 }
1226
1227 public void setSelectedItem(final Object selectedDirectory) {
1228 this.fSelectedDirectory = (File)selectedDirectory;
1229 fireContentsChanged(this, -1, -1);
1230 }
1231
1232 public Object getSelectedItem() {
1233 return fSelectedDirectory;
1234 }
1235
1236 public int getSize() {
1237 return fDirectories.size();
1238 }
1239
1240 public Object getElementAt(final int index) {
1241 return fDirectories.elementAt(index);
1242 }
1243 }
1244
1245 //
1246 // Renderer for Types ComboBox
1247 //
1248 protected ListCellRenderer createFilterComboBoxRenderer() {
1249 return new AquaComboBoxRendererInternal(filterComboBox) {
1250 public Component getListCellRendererComponent(final JList list, final Object value, final int index, final boolean isSelected, final boolean cellHasFocus) {
1251 super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
1252 final FileFilter filter = (FileFilter)value;
1253 if (filter != null) setText(filter.getDescription());
1254 return this;
1255 }
1256 };
1257 }
1258
1259 //
1260 // DataModel for Types Comboxbox
1261 //
1262 protected FilterComboBoxModel createFilterComboBoxModel() {
1263 return new FilterComboBoxModel();
1264 }
1265
1266 /**
1267 * Data model for a type-face selection combo-box.
1268 */
1269 protected class FilterComboBoxModel extends AbstractListModel<FileFilter> implements ComboBoxModel<FileFilter>,
1270 PropertyChangeListener {
1271 protected FileFilter[] filters;
1272 protected FilterComboBoxModel() {
1273 super();
1274 filters = getFileChooser().getChoosableFileFilters();
1275 }
1276
1277 public void propertyChange(PropertyChangeEvent e) {
1278 String prop = e.getPropertyName();
1279 if(prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {
1280 filters = (FileFilter[]) e.getNewValue();
1281 fireContentsChanged(this, -1, -1);
1282 } else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {
1283 fireContentsChanged(this, -1, -1);
1284 }
1285 }
1286
1287 public void setSelectedItem(Object filter) {
1288 if(filter != null) {
1289 getFileChooser().setFileFilter((FileFilter) filter);
1290 fireContentsChanged(this, -1, -1);
1291 }
1292 }
1293
1294 public Object getSelectedItem() {
1295 // Ensure that the current filter is in the list.
1296 // NOTE: we shouldnt' have to do this, since JFileChooser adds
1297 // the filter to the choosable filters list when the filter
1298 // is set. Lets be paranoid just in case someone overrides
1299 // setFileFilter in JFileChooser.
1300 FileFilter currentFilter = getFileChooser().getFileFilter();
1301 boolean found = false;
1302 if(currentFilter != null) {
1303 for (FileFilter filter : filters) {
1304 if (filter == currentFilter) {
1305 found = true;
1306 }
1307 }
1308 if(found == false) {
1309 getFileChooser().addChoosableFileFilter(currentFilter);
1310 }
1311 }
1312 return getFileChooser().getFileFilter();
1313 }
1314
1315 public int getSize() {
1316 if(filters != null) {
1317 return filters.length;
1318 } else {
1319 return 0;
1320 }
1321 }
1322
1323 public FileFilter getElementAt(int index) {
1324 if(index > getSize() - 1) {
1325 // This shouldn't happen. Try to recover gracefully.
1326 return getFileChooser().getFileFilter();
1327 }
1328 if(filters != null) {
1329 return filters[index];
1330 } else {
1331 return null;
1332 }
1333 }
1334 }
1335
1336 /**
1337 * Acts when FilterComboBox has changed the selected item.
1338 */
1339 protected class FilterComboBoxAction extends AbstractAction {
1340 protected FilterComboBoxAction() {
1341 super("FilterComboBoxAction");
1342 }
1343
1344 public void actionPerformed(final ActionEvent e) {
1345 getFileChooser().setFileFilter((FileFilter)filterComboBox.getSelectedItem());
1346 }
1347 }
1348
1349 /**
1350 * Acts when DirectoryComboBox has changed the selected item.
1351 */
1352 protected class DirectoryComboBoxAction extends AbstractAction {
1353 protected DirectoryComboBoxAction() {
1354 super("DirectoryComboBoxAction");
1355 }
1356
1357 public void actionPerformed(final ActionEvent e) {
1358 getFileChooser().setCurrentDirectory((File)directoryComboBox.getSelectedItem());
1359 }
1360 }
1361
1362 // Sorting Table operations
1363 class JSortingTableHeader extends JTableHeader {
1364 public JSortingTableHeader(final TableColumnModel cm) {
1365 super(cm);
1366 setReorderingAllowed(true); // This causes mousePress to call setDraggedColumn
1367 }
1368
1369 // One sort state for each column. Both are ascending by default
1370 final boolean fSortAscending[] = {true, true};
1371
1372 // Instead of dragging, it selects which one to sort by
1373 public void setDraggedColumn(final TableColumn aColumn) {
1374 if (aColumn != null) {
1375 final int colIndex = aColumn.getModelIndex();
1376 if (colIndex != fSortColumn) {
1377 filechooser.firePropertyChange(AquaFileSystemModel.SORT_BY_CHANGED, fSortColumn, colIndex);
1378 fSortColumn = colIndex;
1379 } else {
1380 fSortAscending[colIndex] = !fSortAscending[colIndex];
1381 filechooser.firePropertyChange(AquaFileSystemModel.SORT_ASCENDING_CHANGED, !fSortAscending[colIndex], fSortAscending[colIndex]);
1382 }
1383 // Need to repaint the highlighted column.
1384 repaint();
1385 }
1386 }
1387
1388 // This stops mouseDrags from moving the column
1389 public TableColumn getDraggedColumn() {
1390 return null;
1391 }
1392
1393 protected TableCellRenderer createDefaultRenderer() {
1394 final DefaultTableCellRenderer label = new AquaTableCellRenderer();
1395 label.setHorizontalAlignment(SwingConstants.LEFT);
1396 return label;
1397 }
1398
1399 class AquaTableCellRenderer extends DefaultTableCellRenderer implements UIResource {
1400 public Component getTableCellRendererComponent(final JTable localTable, final Object value, final boolean isSelected, final boolean hasFocus, final int row, final int column) {
1401 if (localTable != null) {
1402 final JTableHeader header = localTable.getTableHeader();
1403 if (header != null) {
1404 setForeground(header.getForeground());
1405 setBackground(header.getBackground());
1406 setFont(UIManager.getFont("TableHeader.font"));
1407 }
1408 }
1409
1410 setText((value == null) ? "" : value.toString());
1411
1412 // Modify the table "border" to draw smaller, and with the titles in the right position
1413 // and sort indicators, just like an NSSave/Open panel.
1414 final AquaTableHeaderBorder cellBorder = AquaTableHeaderBorder.getListHeaderBorder();
1415 cellBorder.setSelected(column == fSortColumn);
1416 final int horizontalShift = (column == 0 ? 35 : 10);
1417 cellBorder.setHorizontalShift(horizontalShift);
1418
1419 if (column == fSortColumn) {
1420 cellBorder.setSortOrder(fSortAscending[column] ? AquaTableHeaderBorder.SORT_ASCENDING : AquaTableHeaderBorder.SORT_DECENDING);
1421 } else {
1422 cellBorder.setSortOrder(AquaTableHeaderBorder.SORT_NONE);
1423 }
1424 setBorder(cellBorder);
1425 return this;
1426 }
1427 }
1428 }
1429
1430 public void installComponents(final JFileChooser fc) {
1431 JPanel tPanel; // temp panel
1432 // set to a Y BoxLayout. The chooser will be laid out top to bottom.
1433 fc.setLayout(new BoxLayout(fc, BoxLayout.Y_AXIS));
1434 fc.add(Box.createRigidArea(vstrut10));
1435
1436 // construct the top panel
1437
1438 final JPanel topPanel = new JPanel();
1439 topPanel.setLayout(new BoxLayout(topPanel, BoxLayout.Y_AXIS));
1440 fc.add(topPanel);
1441 fc.add(Box.createRigidArea(vstrut10));
1442
1443 // Add the textfield pane
1444
1445 fTextfieldPanel = new JPanel();
1446 fTextfieldPanel.setLayout(new BorderLayout());
1447 // setBottomPanelForMode will make this visible if we need it
1448 fTextfieldPanel.setVisible(false);
1449 topPanel.add(fTextfieldPanel);
1450
1451 tPanel = new JPanel();
1452 tPanel.setLayout(new BoxLayout(tPanel, BoxLayout.Y_AXIS));
1453 final JPanel labelArea = new JPanel();
1454 labelArea.setLayout(new FlowLayout(FlowLayout.CENTER));
1455 fTextFieldLabel = new JLabel(fileNameLabelText);
1456 labelArea.add(fTextFieldLabel);
1457
1458 // text field
1459 filenameTextField = new JTextField();
1460 fTextFieldLabel.setLabelFor(filenameTextField);
1461 filenameTextField.addActionListener(getAction(kOpen));
1462 filenameTextField.addFocusListener(new SaveTextFocusListener());
1463 final Dimension minSize = filenameTextField.getMinimumSize();
1464 Dimension d = new Dimension(250, (int)minSize.getHeight());
1465 filenameTextField.setPreferredSize(d);
1466 filenameTextField.setMaximumSize(d);
1467 labelArea.add(filenameTextField);
1468 final File f = fc.getSelectedFile();
1469 if (f != null) {
1470 setFileName(fc.getName(f));
1471 } else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {
1472 setFileName(newFileDefaultName);
1473 }
1474
1475 tPanel.add(labelArea);
1476 // separator line
1477 final JSeparator sep = new JSeparator(){
1478 public Dimension getPreferredSize() {
1479 return new Dimension(((JComponent)getParent()).getWidth(), 3);
1480 }
1481 };
1482 tPanel.add(Box.createRigidArea(new Dimension(1, 8)));
1483 tPanel.add(sep);
1484 tPanel.add(Box.createRigidArea(new Dimension(1, 7)));
1485 fTextfieldPanel.add(tPanel, BorderLayout.CENTER);
1486
1487 // DirectoryComboBox, left-justified, 200x20 not including drop shadow
1488 directoryComboBox = new JComboBox();
1489 directoryComboBox.putClientProperty("JComboBox.lightweightKeyboardNavigation", "Lightweight");
1490 fDirectoryComboBoxModel = createDirectoryComboBoxModel(fc);
1491 directoryComboBox.setModel(fDirectoryComboBoxModel);
1492 directoryComboBox.addActionListener(directoryComboBoxAction);
1493 directoryComboBox.setRenderer(createDirectoryComboBoxRenderer(fc));
1494 directoryComboBox.setToolTipText(directoryComboBoxToolTipText);
1495 d = new Dimension(250, (int)directoryComboBox.getMinimumSize().getHeight());
1496 directoryComboBox.setPreferredSize(d);
1497 directoryComboBox.setMaximumSize(d);
1498 topPanel.add(directoryComboBox);
1499
1500 // ************************************** //
1501 // ** Add the directory/Accessory pane ** //
1502 // ************************************** //
1503 final JPanel centerPanel = new JPanel(new BorderLayout());
1504 fc.add(centerPanel);
1505
1506 // Accessory pane (equiv to Preview pane in NavServices)
1507 final JComponent accessory = fc.getAccessory();
1508 if (accessory != null) {
1509 getAccessoryPanel().add(accessory);
1510 }
1511 centerPanel.add(getAccessoryPanel(), BorderLayout.LINE_START);
1512
1513 // Directory list(table), right-justified, resizable
1514 final JPanel p = createList(fc);
1515 p.setMinimumSize(LIST_MIN_SIZE);
1516 centerPanel.add(p, BorderLayout.CENTER);
1517
1518 // ********************************** //
1519 // **** Construct the bottom panel ** //
1520 // ********************************** //
1521 fBottomPanel = new JPanel();
1522 fBottomPanel.setLayout(new BoxLayout(fBottomPanel, BoxLayout.Y_AXIS));
1523 fc.add(fBottomPanel);
1524
1525 // Filter label and combobox.
1526 // I know it's unMaclike, but the filter goes on Directory_only too.
1527 tPanel = new JPanel();
1528 tPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
1529 tPanel.setBorder(AquaGroupBorder.getTitlelessBorder());
1530 final JLabel formatLabel = new JLabel(filesOfTypeLabelText);
1531 tPanel.add(formatLabel);
1532
1533 // Combobox
1534 filterComboBoxModel = createFilterComboBoxModel();
1535 fc.addPropertyChangeListener(filterComboBoxModel);
1536 filterComboBox = new JComboBox(filterComboBoxModel);
1537 formatLabel.setLabelFor(filterComboBox);
1538 filterComboBox.setRenderer(createFilterComboBoxRenderer());
1539 d = new Dimension(220, (int)filterComboBox.getMinimumSize().getHeight());
1540 filterComboBox.setPreferredSize(d);
1541 filterComboBox.setMaximumSize(d);
1542 filterComboBox.addActionListener(filterComboBoxAction);
1543 filterComboBox.setOpaque(false);
1544 tPanel.add(filterComboBox);
1545
1546 fBottomPanel.add(tPanel);
1547
1548 // fDirectoryPanel: New, Open, Cancel, Approve buttons, right-justified, 82x22
1549 // (sometimes the NewFolder and OpenFolder buttons are invisible)
1550 fDirectoryPanel = new JPanel();
1551 fDirectoryPanel.setLayout(new BoxLayout(fDirectoryPanel, BoxLayout.PAGE_AXIS));
1552 JPanel directoryPanel = new JPanel(new BorderLayout());
1553 JPanel newFolderButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));
1554 newFolderButtonPanel.add(Box.createHorizontalStrut(20));
1555 fNewFolderButton = createNewFolderButton(); // Because we hide it depending on style
1556 newFolderButtonPanel.add(fNewFolderButton);
1557 directoryPanel.add(newFolderButtonPanel, BorderLayout.LINE_START);
1558 JPanel approveCancelButtonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING, 0, 0));
1559 fOpenButton = createButton(kOpenDirectory, openButtonText);
1560 approveCancelButtonPanel.add(fOpenButton);
1561 approveCancelButtonPanel.add(Box.createHorizontalStrut(8));
1562 fCancelButton = createButton(kCancel, null);
1563 approveCancelButtonPanel.add(fCancelButton);
1564 approveCancelButtonPanel.add(Box.createHorizontalStrut(8));
1565 // The ApproveSelection button
1566 fApproveButton = new JButton();
1567 fApproveButton.addActionListener(fApproveSelectionAction);
1568 approveCancelButtonPanel.add(fApproveButton);
1569 approveCancelButtonPanel.add(Box.createHorizontalStrut(20));
1570 directoryPanel.add(approveCancelButtonPanel, BorderLayout.LINE_END);
1571 fDirectoryPanel.add(Box.createVerticalStrut(5));
1572 fDirectoryPanel.add(directoryPanel);
1573 fDirectoryPanel.add(Box.createVerticalStrut(12));
1574 fDirectoryPanelSpacer = Box.createRigidArea(hstrut10);
1575
1576 if (fc.getControlButtonsAreShown()) {
1577 fBottomPanel.add(fDirectoryPanelSpacer);
1578 fBottomPanel.add(fDirectoryPanel);
1579 }
1580
1581 setBottomPanelForMode(fc); // updates ApproveButtonText etc
1582
1583 // don't create til after the FCSubpanel and buttons are made
1584 filenameTextField.getDocument().addDocumentListener(new SaveTextDocumentListener());
1585 }
1586
1587 void setDefaultButtonForMode(final JFileChooser fc) {
1588 final JButton defaultButton = fSubPanel.getDefaultButton(fc);
1589 final JRootPane root = defaultButton.getRootPane();
1590 if (root != null) {
1591 root.setDefaultButton(defaultButton);
1592 }
1593 }
1594
1595 // Macs start with their focus in text areas if they have them,
1596 // lists otherwise (the other plafs start with the focus on approveButton)
1597 void setFocusForMode(final JFileChooser fc) {
1598 final JComponent focusComponent = fSubPanel.getFocusComponent(fc);
1599 if (focusComponent != null) {
1600 focusComponent.requestFocus();
1601 }
1602 }
1603
1604 // Enable/disable buttons as needed for the current selection/focus state
1605 void updateButtonState(final JFileChooser fc) {
1606 fSubPanel.updateButtonState(fc, getFirstSelectedItem());
1607 updateApproveButton(fc);
1608 }
1609
1610 void updateApproveButton(final JFileChooser chooser) {
1611 fApproveButton.setText(getApproveButtonText(chooser));
1612 fApproveButton.setToolTipText(getApproveButtonToolTipText(chooser));
1613 fApproveButton.setMnemonic(getApproveButtonMnemonic(chooser));
1614 fCancelButton.setToolTipText(getCancelButtonToolTipText(chooser));
1615 }
1616
1617 // Lazy-init the subpanels
1618 synchronized FCSubpanel getSaveFilePanel() {
1619 if (fSaveFilePanel == null) fSaveFilePanel = new SaveFilePanel();
1620 return fSaveFilePanel;
1621 }
1622
1623 synchronized FCSubpanel getOpenFilePanel() {
1624 if (fOpenFilePanel == null) fOpenFilePanel = new OpenFilePanel();
1625 return fOpenFilePanel;
1626 }
1627
1628 synchronized FCSubpanel getOpenDirOrAnyPanel() {
1629 if (fOpenDirOrAnyPanel == null) fOpenDirOrAnyPanel = new OpenDirOrAnyPanel();
1630 return fOpenDirOrAnyPanel;
1631 }
1632
1633 synchronized FCSubpanel getCustomFilePanel() {
1634 if (fCustomFilePanel == null) fCustomFilePanel = new CustomFilePanel();
1635 return fCustomFilePanel;
1636 }
1637
1638 synchronized FCSubpanel getCustomDirOrAnyPanel() {
1639 if (fCustomDirOrAnyPanel == null) fCustomDirOrAnyPanel = new CustomDirOrAnyPanel();
1640 return fCustomDirOrAnyPanel;
1641 }
1642
1643 void setBottomPanelForMode(final JFileChooser fc) {
1644 if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) fSubPanel = getSaveFilePanel();
1645 else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {
1646 if (fc.getFileSelectionMode() == JFileChooser.FILES_ONLY) fSubPanel = getOpenFilePanel();
1647 else fSubPanel = getOpenDirOrAnyPanel();
1648 } else if (fc.getDialogType() == JFileChooser.CUSTOM_DIALOG) {
1649 if (fc.getFileSelectionMode() == JFileChooser.FILES_ONLY) fSubPanel = getCustomFilePanel();
1650 else fSubPanel = getCustomDirOrAnyPanel();
1651 }
1652
1653 fSubPanel.installPanel(fc, true);
1654 updateApproveButton(fc);
1655 updateButtonState(fc);
1656 setDefaultButtonForMode(fc);
1657 setFocusForMode(fc);
1658 fc.invalidate();
1659 }
1660
1661 // fTextfieldPanel and fDirectoryPanel both have NewFolder buttons; only one should be visible at a time
1662 JButton createNewFolderButton() {
1663 final JButton b = new JButton(newFolderButtonText);
1664 b.setToolTipText(newFolderToolTipText);
1665 b.getAccessibleContext().setAccessibleName(newFolderAccessibleName);
1666 b.setHorizontalTextPosition(SwingConstants.LEFT);
1667 b.setAlignmentX(Component.LEFT_ALIGNMENT);
1668 b.setAlignmentY(Component.CENTER_ALIGNMENT);
1669 b.addActionListener(getAction(kNewFolder));
1670 return b;
1671 }
1672
1673 JButton createButton(final int which, String label) {
1674 if (label == null) label = UIManager.getString(sDataPrefix + sButtonKinds[which] + sButtonData[0]);
1675 final int mnemonic = UIManager.getInt(sDataPrefix + sButtonKinds[which] + sButtonData[1]);
1676 final String tipText = UIManager.getString(sDataPrefix + sButtonKinds[which] + sButtonData[2]);
1677 final JButton b = new JButton(label);
1678 b.setMnemonic(mnemonic);
1679 b.setToolTipText(tipText);
1680 b.addActionListener(getAction(which));
1681 return b;
1682 }
1683
1684 AbstractAction getAction(final int which) {
1685 return fButtonActions[which];
1686 }
1687
1688 public void uninstallComponents(final JFileChooser fc) { //$ Metal (on which this is based) doesn't uninstall its components.
1689 }
1690
1691 // Consistent with the AppKit NSSavePanel, clicks on a file (not a directory) should populate the text field
1692 // with that file's display name.
1693 protected class FileListMouseListener extends MouseAdapter {
1694 public void mouseClicked(final MouseEvent e) {
1695 final Point p = e.getPoint();
1696 final int row = fFileList.rowAtPoint(p);
1697 final int column = fFileList.columnAtPoint(p);
1698
1699 // The autoscroller can generate drag events outside the Table's range.
1700 if ((column == -1) || (row == -1)) { return; }
1701
1702 final File clickedFile = (File)(fFileList.getValueAt(row, 0));
1703
1704 // rdar://problem/3734130 -- don't populate the text field if this file isn't selectable in this mode.
1705 if (isSelectableForMode(getFileChooser(), clickedFile)) {
1706 // [3188387] Populate the file name field with the selected file name
1707 // [3484163] It should also use the display name, not the actual name.
1708 setFileName(fileView.getName(clickedFile));
1709 }
1710 }
1711 }
1712
1713 protected JPanel createList(final JFileChooser fc) {
1714 // The first part is similar to MetalFileChooserUI.createList - same kind of listeners
1715 final JPanel p = new JPanel(new BorderLayout());
1716 fFileList = new JTableExtension();
1717 fFileList.setToolTipText(null); // Workaround for 2487689
1718 fFileList.addMouseListener(new FileListMouseListener());
1719 model = new AquaFileSystemModel(fc, fFileList, fColumnNames);
1720 final MacListSelectionModel listSelectionModel = new MacListSelectionModel(model);
1721
1722 if (getFileChooser().isMultiSelectionEnabled()) {
1723 listSelectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
1724 } else {
1725 listSelectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1726 }
1727
1728 fFileList.setModel(model);
1729 fFileList.setSelectionModel(listSelectionModel);
1730 fFileList.getSelectionModel().addListSelectionListener(createListSelectionListener(fc));
1731
1732 // Now we're different, because we're a table, not a list
1733 fc.addPropertyChangeListener(model);
1734 fFileList.addFocusListener(new SaveTextFocusListener());
1735 final JTableHeader th = new JSortingTableHeader(fFileList.getColumnModel());
1736 fFileList.setTableHeader(th);
1737 fFileList.setRowMargin(0);
1738 fFileList.setIntercellSpacing(new Dimension(0, 1));
1739 fFileList.setShowVerticalLines(false);
1740 fFileList.setShowHorizontalLines(false);
1741 final Font f = fFileList.getFont(); //ThemeFont.GetThemeFont(AppearanceConstants.kThemeViewsFont);
1742 //fc.setFont(f);
1743 //fFileList.setFont(f);
1744 fFileList.setDefaultRenderer(File.class, new FileRenderer(f));
1745 fFileList.setDefaultRenderer(Date.class, new DateRenderer(f));
1746 final FontMetrics fm = fFileList.getFontMetrics(f);
1747
1748 // Row height isn't based on the renderers. It defaults to 16 so we have to set it
1749 fFileList.setRowHeight(Math.max(fm.getHeight(), fileIcon.getIconHeight() + 2));
1750
1751 // Add a binding for the file list that triggers return and escape
1752 fFileList.registerKeyboardAction(new CancelSelectionAction(), KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_FOCUSED);
1753 // Add a binding for the file list that triggers the default button (see DefaultButtonAction)
1754 fFileList.registerKeyboardAction(new DefaultButtonAction(), KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), JComponent.WHEN_FOCUSED);
1755 fFileList.setDropTarget(dragAndDropTarget);
1756
1757 final JScrollPane scrollpane = new JScrollPane(fFileList, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
1758 scrollpane.setComponentOrientation(ComponentOrientation.getOrientation(Locale.getDefault()));
1759 scrollpane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, new ScrollPaneCornerPanel());
1760 p.add(scrollpane, BorderLayout.CENTER);
1761 return p;
1762 }
1763
1764 protected class ScrollPaneCornerPanel extends JPanel {
1765 final Border border = UIManager.getBorder("TableHeader.cellBorder");
1766
1767 protected void paintComponent(final Graphics g) {
1768 border.paintBorder(this, g, 0, 0, getWidth() + 1, getHeight());
1769 }
1770 }
1771
1772 JComboBox directoryComboBox;
1773 DirectoryComboBoxModel fDirectoryComboBoxModel;
1774 private final Action directoryComboBoxAction = new DirectoryComboBoxAction();
1775
1776 JTextField filenameTextField;
1777
1778 JTableExtension fFileList;
1779
1780 private FilterComboBoxModel filterComboBoxModel;
1781 JComboBox filterComboBox;
1782 private final Action filterComboBoxAction = new FilterComboBoxAction();
1783
1784 private static final Dimension hstrut10 = new Dimension(10, 1);
1785 private static final Dimension vstrut10 = new Dimension(1, 10);
1786
1787 private static final int PREF_WIDTH = 550;
1788 private static final int PREF_HEIGHT = 400;
1789 private static final Dimension PREF_SIZE = new Dimension(PREF_WIDTH, PREF_HEIGHT);
1790
1791 private static final int MIN_WIDTH = 400;
1792 private static final int MIN_HEIGHT = 250;
1793 private static final Dimension MIN_SIZE = new Dimension(MIN_WIDTH, MIN_HEIGHT);
1794
1795 private static final int LIST_MIN_WIDTH = 400;
1796 private static final int LIST_MIN_HEIGHT = 100;
1797 private static final Dimension LIST_MIN_SIZE = new Dimension(LIST_MIN_WIDTH, LIST_MIN_HEIGHT);
1798
1799 static String fileNameLabelText = null;
1800 JLabel fTextFieldLabel = null;
1801
1802 private static String filesOfTypeLabelText = null;
1803
1804 private static String newFolderToolTipText = null;
1805 static String newFolderAccessibleName = null;
1806
1807 private static final String[] fColumnNames = new String[2];
1808
1809 JPanel fTextfieldPanel; // Filename textfield for Save or Custom
1810 private JPanel fDirectoryPanel; // NewFolder/OpenFolder/Cancel/Approve buttons
1811 private Component fDirectoryPanelSpacer;
1812 private JPanel fBottomPanel; // The panel that holds fDirectoryPanel and filterComboBox
1813
1814 private FCSubpanel fSaveFilePanel = null;
1815 private FCSubpanel fOpenFilePanel = null;
1816 private FCSubpanel fOpenDirOrAnyPanel = null;
1817 private FCSubpanel fCustomFilePanel = null;
1818 private FCSubpanel fCustomDirOrAnyPanel = null;
1819
1820 FCSubpanel fSubPanel = null; // Current FCSubpanel
1821
1822 JButton fApproveButton; // mode-specific behavior is managed by FCSubpanel.approveSelection
1823 JButton fOpenButton; // for Directories
1824 JButton fNewFolderButton; // for fDirectoryPanel
1825
1826 // ToolTip text varies with type of dialog
1827 private JButton fCancelButton;
1828
1829 private final ApproveSelectionAction fApproveSelectionAction = new ApproveSelectionAction();
1830 protected int fSortColumn = 0;
1831 protected int fPackageIsTraversable = -1;
1832 protected int fApplicationIsTraversable = -1;
1833
1834 protected static final int sGlobalPackageIsTraversable;
1835 protected static final int sGlobalApplicationIsTraversable;
1836
1837 protected static final String PACKAGE_TRAVERSABLE_PROPERTY = "JFileChooser.packageIsTraversable";
1838 protected static final String APPLICATION_TRAVERSABLE_PROPERTY = "JFileChooser.appBundleIsTraversable";
1839 protected static final String[] sTraversableProperties = {"always", // Bundle is always traversable
1840 "never", // Bundle is never traversable
1841 "conditional"}; // Bundle is traversable on command click
1842 protected static final int kOpenAlways = 0, kOpenNever = 1, kOpenConditional = 2;
1843
1844 AbstractAction[] fButtonActions = {fApproveSelectionAction, fApproveSelectionAction, new CancelSelectionAction(), new OpenSelectionAction(), null, new NewFolderAction()};
1845
1846 static int parseTraversableProperty(final String s) {
1847 if (s == null) return -1;
1848 for (int i = 0; i < sTraversableProperties.length; i++) {
1849 if (s.equals(sTraversableProperties[i])) return i;
1850 }
1851 return -1;
1852 }
1853
1854 static {
1855 Object o = UIManager.get(PACKAGE_TRAVERSABLE_PROPERTY);
1856 if (o != null && o instanceof String) sGlobalPackageIsTraversable = parseTraversableProperty((String)o);
1857 else sGlobalPackageIsTraversable = kOpenConditional;
1858
1859 o = UIManager.get(APPLICATION_TRAVERSABLE_PROPERTY);
1860 if (o != null && o instanceof String) sGlobalApplicationIsTraversable = parseTraversableProperty((String)o);
1861 else sGlobalApplicationIsTraversable = kOpenConditional;
1862 }
1863 static final String sDataPrefix = "FileChooser.";
1864 static final String[] sButtonKinds = {"openButton", "saveButton", "cancelButton", "openDirectoryButton", "helpButton", "newFolderButton"};
1865 static final String[] sButtonData = {"Text", "Mnemonic", "ToolTipText"};
1866 static final int kOpen = 0, kSave = 1, kCancel = 2, kOpenDirectory = 3, kHelp = 4, kNewFolder = 5;
1867
1868 /*-------
1869
1870 Possible states: Save, {Open, Custom}x{Files, File and Directory, Directory}
1871 --------- */
1872
1873 // This class returns the values for the Custom type, to avoid duplicating code in the two Custom subclasses
1874 abstract class FCSubpanel {
1875 // Install the appropriate panels for this mode
1876 abstract void installPanel(JFileChooser fc, boolean controlButtonsAreShown);
1877
1878 abstract void updateButtonState(JFileChooser fc, File f);
1879
1880 // Can this item be selected?
1881 // if not, it's disabled in the list
1882 boolean isSelectableInList(final JFileChooser fc, final File f) {
1883 if (f == null) return false;
1884 if (fc.getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) return fc.isTraversable(f);
1885 return fc.accept(f);
1886 }
1887
1888 void approveSelection(final JFileChooser fc) {
1889 fc.approveSelection();
1890 }
1891
1892 JButton getDefaultButton(final JFileChooser fc) {
1893 return fApproveButton;
1894 }
1895
1896 // Default to the textfield, panels without one should subclass
1897 JComponent getFocusComponent(final JFileChooser fc) {
1898 return filenameTextField;
1899 }
1900
1901 String getApproveButtonText(final JFileChooser fc) {
1902 // Fallback to "choose"
1903 return this.getApproveButtonText(fc, chooseButtonText);
1904 }
1905
1906 // Try to get the custom text. If none, use the fallback
1907 String getApproveButtonText(final JFileChooser fc, final String fallbackText) {
1908 final String buttonText = fc.getApproveButtonText();
1909 if (buttonText != null) {
1910 buttonText.trim();
1911 if (!buttonText.equals("")) return buttonText;
1912 }
1913 return fallbackText;
1914 }
1915
1916 int getApproveButtonMnemonic(final JFileChooser fc) {
1917 // Don't use a default
1918 return fc.getApproveButtonMnemonic();
1919 }
1920
1921 // No fallback
1922 String getApproveButtonToolTipText(final JFileChooser fc) {
1923 return getApproveButtonToolTipText(fc, null);
1924 }
1925
1926 String getApproveButtonToolTipText(final JFileChooser fc, final String fallbackText) {
1927 final String tooltipText = fc.getApproveButtonToolTipText();
1928 if (tooltipText != null) {
1929 tooltipText.trim();
1930 if (!tooltipText.equals("")) return tooltipText;
1931 }
1932 return fallbackText;
1933 }
1934
1935 String getCancelButtonToolTipText(final JFileChooser fc) {
1936 return cancelChooseButtonToolTipText;
1937 }
1938 }
1939
1940 // Custom FILES_ONLY dialog
1941 /*
1942 NavServices Save appearance with Open behavior
1943 Approve button label = Open when list has focus and a directory is selected, Custom otherwise
1944 No OpenDirectory button - Approve button is overloaded
1945 Default button / double click = Approve
1946 Has text field
1947 List - everything is enabled
1948 */
1949 class CustomFilePanel extends FCSubpanel {
1950 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
1951 fTextfieldPanel.setVisible(true); // do we really want one in multi-select? It's confusing
1952 fOpenButton.setVisible(false);
1953 fNewFolderButton.setVisible(true);
1954 }
1955
1956 // If the list has focus, the mode depends on the selection
1957 // - directory = open, file = approve
1958 // If something else has focus and we have text, it's approve
1959 // otherwise, it depends on selection again.
1960 boolean inOpenDirectoryMode(final JFileChooser fc, final File f) {
1961 final boolean selectionIsDirectory = (f != null && fc.isTraversable(f));
1962 if (fFileList.hasFocus()) return selectionIsDirectory;
1963 else if (textfieldIsValid()) return false;
1964 return selectionIsDirectory;
1965 }
1966
1967 // The approve button is overloaded to mean OpenDirectory or Save
1968 void approveSelection(final JFileChooser fc) {
1969 File f = getFirstSelectedItem();
1970 if (inOpenDirectoryMode(fc, f)) {
1971 openDirectory(f);
1972 } else {
1973 f = makeFile(fc, getFileName());
1974 if (f != null) {
1975 selectionInProgress = true;
1976 getFileChooser().setSelectedFile(f);
1977 selectionInProgress = false;
1978 }
1979 getFileChooser().approveSelection();
1980 }
1981 }
1982
1983 // The approve button should be enabled
1984 // - if something in the list can be opened
1985 // - if the textfield has something in it
1986 void updateButtonState(final JFileChooser fc, final File f) {
1987 boolean enabled = true;
1988 if (!inOpenDirectoryMode(fc, f)) {
1989 enabled = (f != null) || textfieldIsValid();
1990 }
1991 getApproveButton(fc).setEnabled(enabled);
1992
1993 // The OpenDirectory button should be disabled if there's no directory selected
1994 fOpenButton.setEnabled(f != null && fc.isTraversable(f));
1995
1996 // Update the default button, since we may have disabled the current default.
1997 setDefaultButtonForMode(fc);
1998 }
1999
2000 // everything's enabled, because we don't know what they're doing with them
2001 boolean isSelectableInList(final JFileChooser fc, final File f) {
2002 if (f == null) return false;
2003 return fc.accept(f);
2004 }
2005
2006 String getApproveButtonToolTipText(final JFileChooser fc) {
2007 // The approve Button should have openDirectoryButtonToolTipText when the selection is a folder...
2008 if (inOpenDirectoryMode(fc, getFirstSelectedItem())) return openDirectoryButtonToolTipText;
2009 return super.getApproveButtonToolTipText(fc);
2010 }
2011 }
2012
2013 // All Save dialogs
2014 /*
2015 NavServices Save
2016 Approve button label = Open when list has focus and a directory is selected, Save otherwise
2017 No OpenDirectory button - Approve button is overloaded
2018 Default button / double click = Approve
2019 Has text field
2020 Has NewFolder button (by text field)
2021 List - only traversables are enabled
2022 List is always SINGLE_SELECT
2023 */
2024 // Subclasses CustomFilePanel because they look alike and have some common behavior
2025 class SaveFilePanel extends CustomFilePanel {
2026 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2027 fTextfieldPanel.setVisible(true);
2028 fOpenButton.setVisible(false);
2029 fNewFolderButton.setVisible(true);
2030 }
2031
2032 // only traversables are enabled, regardless of mode
2033 // because all you can do is select the next folder to open
2034 boolean isSelectableInList(final JFileChooser fc, final File f) {
2035 return fc.accept(f) && fc.isTraversable(f);
2036 }
2037
2038 // The approve button means 'approve the file name in the text field.'
2039 void approveSelection(final JFileChooser fc) {
2040 final File f = makeFile(fc, getFileName());
2041 if (f != null) {
2042 selectionInProgress = true;
2043 getFileChooser().setSelectedFile(f);
2044 selectionInProgress = false;
2045 getFileChooser().approveSelection();
2046 }
2047 }
2048
2049 // The approve button should be enabled if the textfield has something in it
2050 void updateButtonState(final JFileChooser fc, final File f) {
2051 final boolean enabled = textfieldIsValid();
2052 getApproveButton(fc).setEnabled(enabled);
2053 }
2054
2055 String getApproveButtonText(final JFileChooser fc) {
2056 // Get the custom text, or fallback to "Save"
2057 return this.getApproveButtonText(fc, saveButtonText);
2058 }
2059
2060 int getApproveButtonMnemonic(final JFileChooser fc) {
2061 return saveButtonMnemonic;
2062 }
2063
2064 String getApproveButtonToolTipText(final JFileChooser fc) {
2065 // The approve Button should have openDirectoryButtonToolTipText when the selection is a folder...
2066 if (inOpenDirectoryMode(fc, getFirstSelectedItem())) return openDirectoryButtonToolTipText;
2067 return this.getApproveButtonToolTipText(fc, saveButtonToolTipText);
2068 }
2069
2070 String getCancelButtonToolTipText(final JFileChooser fc) {
2071 return cancelSaveButtonToolTipText;
2072 }
2073 }
2074
2075 // Open FILES_ONLY
2076 /*
2077 NSOpenPanel-style
2078 Approve button label = Open
2079 Default button / double click = Approve
2080 No text field
2081 No NewFolder button
2082 List - all items are enabled
2083 */
2084 class OpenFilePanel extends FCSubpanel {
2085 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2086 fTextfieldPanel.setVisible(false);
2087 fOpenButton.setVisible(false);
2088 fNewFolderButton.setVisible(false);
2089 setDefaultButtonForMode(fc);
2090 }
2091
2092 boolean inOpenDirectoryMode(final JFileChooser fc, final File f) {
2093 return (f != null && fc.isTraversable(f));
2094 }
2095
2096 // Default to the list
2097 JComponent getFocusComponent(final JFileChooser fc) {
2098 return fFileList;
2099 }
2100
2101 void updateButtonState(final JFileChooser fc, final File f) {
2102 // Button is disabled if there's nothing selected
2103 final boolean enabled = (f != null) && !fc.isTraversable(f);
2104 getApproveButton(fc).setEnabled(enabled);
2105 }
2106
2107 // all items are enabled
2108 boolean isSelectableInList(final JFileChooser fc, final File f) {
2109 return f != null && fc.accept(f);
2110 }
2111
2112 String getApproveButtonText(final JFileChooser fc) {
2113 // Get the custom text, or fallback to "Open"
2114 return this.getApproveButtonText(fc, openButtonText);
2115 }
2116
2117 int getApproveButtonMnemonic(final JFileChooser fc) {
2118 return openButtonMnemonic;
2119 }
2120
2121 String getApproveButtonToolTipText(final JFileChooser fc) {
2122 return this.getApproveButtonToolTipText(fc, openButtonToolTipText);
2123 }
2124
2125 String getCancelButtonToolTipText(final JFileChooser fc) {
2126 return cancelOpenButtonToolTipText;
2127 }
2128 }
2129
2130 // used by open and custom panels for Directory only or files and directories
2131 abstract class DirOrAnyPanel extends FCSubpanel {
2132 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2133 fOpenButton.setVisible(false);
2134 }
2135
2136 JButton getDefaultButton(final JFileChooser fc) {
2137 return getApproveButton(fc);
2138 }
2139
2140 void updateButtonState(final JFileChooser fc, final File f) {
2141 // Button is disabled if there's nothing selected
2142 // Approve button is handled by the subclasses
2143 // getApproveButton(fc).setEnabled(f != null);
2144
2145 // The OpenDirectory button should be disabled if there's no directory selected
2146 // - we only check the first item
2147
2148 fOpenButton.setEnabled(false);
2149 setDefaultButtonForMode(fc);
2150 }
2151 }
2152
2153 // Open FILES_AND_DIRECTORIES or DIRECTORIES_ONLY
2154 /*
2155 NavServices Choose
2156 Approve button label = Choose/Custom
2157 Has OpenDirectory button
2158 Default button / double click = OpenDirectory
2159 No text field
2160 List - files are disabled in DIRECTORIES_ONLY
2161 */
2162 class OpenDirOrAnyPanel extends DirOrAnyPanel {
2163 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2164 super.installPanel(fc, controlButtonsAreShown);
2165 fTextfieldPanel.setVisible(false);
2166 fNewFolderButton.setVisible(false);
2167 }
2168
2169 // Default to the list
2170 JComponent getFocusComponent(final JFileChooser fc) {
2171 return fFileList;
2172 }
2173
2174 int getApproveButtonMnemonic(final JFileChooser fc) {
2175 return chooseButtonMnemonic;
2176 }
2177
2178 String getApproveButtonToolTipText(final JFileChooser fc) {
2179 String fallbackText;
2180 if (fc.getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) fallbackText = chooseFolderButtonToolTipText;
2181 else fallbackText = chooseItemButtonToolTipText;
2182 return this.getApproveButtonToolTipText(fc, fallbackText);
2183 }
2184
2185 void updateButtonState(final JFileChooser fc, final File f) {
2186 // Button is disabled if there's nothing selected
2187 getApproveButton(fc).setEnabled(f != null);
2188 super.updateButtonState(fc, f);
2189 }
2190 }
2191
2192 // Custom FILES_AND_DIRECTORIES or DIRECTORIES_ONLY
2193 /*
2194 No NavServices equivalent
2195 Approve button label = user defined or Choose
2196 Has OpenDirectory button
2197 Default button / double click = OpenDirectory
2198 Has text field
2199 Has NewFolder button (by text field)
2200 List - files are disabled in DIRECTORIES_ONLY
2201 */
2202 class CustomDirOrAnyPanel extends DirOrAnyPanel {
2203 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2204 super.installPanel(fc, controlButtonsAreShown);
2205 fTextfieldPanel.setVisible(true);
2206 fNewFolderButton.setVisible(true);
2207 }
2208
2209 // If there's text, make a file and select it
2210 void approveSelection(final JFileChooser fc) {
2211 final File f = makeFile(fc, getFileName());
2212 if (f != null) {
2213 selectionInProgress = true;
2214 getFileChooser().setSelectedFile(f);
2215 selectionInProgress = false;
2216 }
2217 getFileChooser().approveSelection();
2218 }
2219
2220 void updateButtonState(final JFileChooser fc, final File f) {
2221 // Button is disabled if there's nothing selected
2222 getApproveButton(fc).setEnabled(f != null || textfieldIsValid());
2223 super.updateButtonState(fc, f);
2224 }
2225 }
2226
2227 // See FileRenderer - documents in Save dialogs draw disabled, so they shouldn't be selected
2228 class MacListSelectionModel extends DefaultListSelectionModel {
2229 AquaFileSystemModel fModel;
2230
2231 MacListSelectionModel(final AquaFileSystemModel model) {
2232 fModel = model;
2233 }
2234
2235 // Can the file be selected in this mode?
2236 // (files are visible even if they can't be selected)
2237 boolean isSelectableInListIndex(final int index) {
2238 final File file = (File)fModel.getValueAt(index, 0);
2239 return (file != null && isSelectableInList(file));
2240 }
2241
2242 // Make sure everything in the selection interval is valid
2243 void verifySelectionInterval(int index0, int index1, boolean isSetSelection) {
2244 if (index0 > index1) {
2245 final int tmp = index1;
2246 index1 = index0;
2247 index0 = tmp;
2248 }
2249 int start = index0;
2250 int end;
2251 do {
2252 // Find the first selectable file in the range
2253 for (; start <= index1; start++) {
2254 if (isSelectableInListIndex(start)) break;
2255 }
2256 end = -1;
2257 // Find the last selectable file in the range
2258 for (int i = start; i <= index1; i++) {
2259 if (!isSelectableInListIndex(i)) {
2260 break;
2261 }
2262 end = i;
2263 }
2264 // Select the range
2265 if (end >= 0) {
2266 // If setting the selection, do "set" the first time to clear the old one
2267 // after that do "add" to extend it
2268 if (isSetSelection) {
2269 super.setSelectionInterval(start, end);
2270 isSetSelection = false;
2271 } else {
2272 super.addSelectionInterval(start, end);
2273 }
2274 start = end + 1;
2275 } else {
2276 break;
2277 }
2278 } while (start <= index1);
2279 }
2280
2281 public void setAnchorSelectionIndex(final int anchorIndex) {
2282 if (isSelectableInListIndex(anchorIndex)) super.setAnchorSelectionIndex(anchorIndex);
2283 }
2284
2285 public void setLeadSelectionIndex(final int leadIndex) {
2286 if (isSelectableInListIndex(leadIndex)) super.setLeadSelectionIndex(leadIndex);
2287 }
2288
2289 public void setSelectionInterval(final int index0, final int index1) {
2290 if (index0 == -1 || index1 == -1) { return; }
2291
2292 if ((getSelectionMode() == SINGLE_SELECTION) || (index0 == index1)) {
2293 if (isSelectableInListIndex(index1)) super.setSelectionInterval(index1, index1);
2294 } else {
2295 verifySelectionInterval(index0, index1, true);
2296 }
2297 }
2298
2299 public void addSelectionInterval(final int index0, final int index1) {
2300 if (index0 == -1 || index1 == -1) { return; }
2301
2302 if (index0 == index1) {
2303 if (isSelectableInListIndex(index1)) super.addSelectionInterval(index1, index1);
2304 return;
2305 }
2306
2307 if (getSelectionMode() != MULTIPLE_INTERVAL_SELECTION) {
2308 setSelectionInterval(index0, index1);
2309 return;
2310 }
2311
2312 verifySelectionInterval(index0, index1, false);
2313 }
2314 }
2315
2316 // Convenience, to translate from the JList directory view to the Mac-style JTable
2317 // & minimize diffs between this and BasicFileChooserUI
2318 class JTableExtension extends JTable {
2319 public void setSelectedIndex(final int index) {
2320 getSelectionModel().setSelectionInterval(index, index);
2321 }
2322
2323 public void removeSelectedIndex(final int index) {
2324 getSelectionModel().removeSelectionInterval(index, index);
2325 }
2326
2327 public void ensureIndexIsVisible(final int index) {
2328 final Rectangle cellBounds = getCellRect(index, 0, false);
2329 if (cellBounds != null) {
2330 scrollRectToVisible(cellBounds);
2331 }
2332 }
2333
2334 public int locationToIndex(final Point location) {
2335 return rowAtPoint(location);
2336 }
2337 }
2338 }