1 /*
2 * Copyright (c) 2011, 2018, 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 static 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 @SuppressWarnings("unchecked")
728 final java.util.List<File> fileList = (java.util.List<File>)transferable.getTransferData(DataFlavor.javaFileListFlavor);
729 dropFiles(fileList.toArray(new File[fileList.size()]));
730 dtde.dropComplete(true);
731 } catch (final Exception e) {
732 dtde.dropComplete(false);
733 }
734 }
735
736 protected void handleStringDropEvent(final DropTargetDropEvent dtde) {
737 dtde.acceptDrop(dtde.getDropAction());
738 final Transferable transferable = dtde.getTransferable();
739
740 final String stringData;
741 try {
742 stringData = (String)transferable.getTransferData(DataFlavor.stringFlavor);
743 } catch (final Exception e) {
744 dtde.dropComplete(false);
745 return;
746 }
747
748 try {
749 final File fileAsPath = new File(stringData);
750 if (fileAsPath.exists()) {
751 dropFiles(new File[] {fileAsPath});
752 dtde.dropComplete(true);
753 return;
754 }
755 } catch (final Exception e) {
756 // try again
757 }
758
759 try {
760 final File fileAsURI = new File(new URI(stringData));
761 if (fileAsURI.exists()) {
762 dropFiles(new File[] {fileAsURI});
763 dtde.dropComplete(true);
764 return;
765 }
766 } catch (final Exception e) {
767 // nothing more to do
768 }
769
770 dtde.dropComplete(false);
771 }
772
773 protected void dropFiles(final File[] files) {
774 final JFileChooser jfc = getFileChooser();
775
776 if (files.length == 1) {
777 if (files[0].isDirectory()) {
778 jfc.setCurrentDirectory(files[0]);
779 return;
780 }
781
782 if (!isSelectableForMode(jfc, files[0])) {
783 return;
784 }
785 }
786
787 jfc.setSelectedFiles(files);
788 for (final File file : files) {
789 jfc.ensureFileIsVisible(file);
790 }
791 getModel().runWhenDone(new Runnable() {
792 public void run() {
793 final AquaFileSystemModel fileSystemModel = getModel();
794 for (final File element : files) {
795 final int index = fileSystemModel.indexOf(element);
796 if (index >= 0) fFileList.addRowSelectionInterval(index, index);
797 }
798 }
799 });
800 }
801 }
802
803 // FileChooser UI PLAF methods
804
805 /**
806 * Returns the default accept all file filter
807 */
808 public FileFilter getAcceptAllFileFilter(final JFileChooser fc) {
809 return acceptAllFileFilter;
810 }
811
812 public FileView getFileView(final JFileChooser fc) {
813 return fileView;
814 }
815
816 /**
817 * Returns the title of this dialog
818 */
819 public String getDialogTitle(final JFileChooser fc) {
820 if (fc.getDialogTitle() == null) {
821 if (getFileChooser().getDialogType() == JFileChooser.OPEN_DIALOG) {
822 return openTitleText;
823 } else if (getFileChooser().getDialogType() == JFileChooser.SAVE_DIALOG) { return saveTitleText; }
824 }
825 return fc.getDialogTitle();
826 }
827
828 // Utility to get the first selected item regardless of whether we're single or multi select
829 File getFirstSelectedItem() {
830 // Get the selected item
831 File selectedFile = null;
832 final int index = fFileList.getSelectedRow();
833 if (index >= 0) {
834 selectedFile = (File)((AquaFileSystemModel)fFileList.getModel()).getElementAt(index);
835 }
836 return selectedFile;
837 }
838
839 // Make a file from the filename
840 File makeFile(final JFileChooser fc, final String filename) {
841 File selectedFile = null;
842 // whitespace is legal on Macs, even on beginning and end of filename
843 if (filename != null && !filename.equals("")) {
844 final FileSystemView fs = fc.getFileSystemView();
845 selectedFile = fs.createFileObject(filename);
846 if (!selectedFile.isAbsolute()) {
847 selectedFile = fs.createFileObject(fc.getCurrentDirectory(), filename);
848 }
849 }
850 return selectedFile;
851 }
852
853 // Utility to tell if the textfield has anything in it
854 boolean textfieldIsValid() {
855 final String s = getFileName();
856 return (s != null && !s.equals(""));
857 }
858
859 // Action to attach to the file list so we can override the default action
860 // of the table for the return key, which is to select the next line.
861 @SuppressWarnings("serial") // Superclass is not serializable across versions
862 protected class DefaultButtonAction extends AbstractAction {
863 public void actionPerformed(final ActionEvent e) {
864 final JRootPane root = AquaFileChooserUI.this.getFileChooser().getRootPane();
865 final JFileChooser fc = AquaFileChooserUI.this.getFileChooser();
866 final JButton owner = root.getDefaultButton();
867 if (owner != null && SwingUtilities.getRootPane(owner) == root && owner.isEnabled()) {
868 owner.doClick(20);
869 } else if (!fc.getControlButtonsAreShown()) {
870 final JButton defaultButton = AquaFileChooserUI.this.fSubPanel.getDefaultButton(fc);
871
872 if (defaultButton != null) {
873 defaultButton.doClick(20);
874 }
875 } else {
876 Toolkit.getDefaultToolkit().beep();
877 }
878 }
879
880 public boolean isEnabled() {
881 return true;
882 }
883 }
884
885 /**
886 * Creates a new folder.
887 */
888 @SuppressWarnings("serial") // Superclass is not serializable across versions
889 protected class NewFolderAction extends AbstractAction {
890 protected NewFolderAction() {
891 super(newFolderAccessibleName);
892 }
893
894 // Muchlike showInputDialog, but we give it options instead of selectionValues
895 private Object showNewFolderDialog(final Component parentComponent, final Object message, final String title, final int messageType, final Icon icon, final Object[] options, final Object initialSelectionValue) {
896 final JOptionPane pane = new JOptionPane(message, messageType, JOptionPane.OK_CANCEL_OPTION, icon, options, null);
897
898 pane.setWantsInput(true);
899 pane.setInitialSelectionValue(initialSelectionValue);
900
901 final JDialog dialog = pane.createDialog(parentComponent, title);
902
903 pane.selectInitialValue();
904 dialog.setVisible(true);
905 dialog.dispose();
906
907 final Object value = pane.getValue();
908
909 if (value == null || value.equals(cancelButtonText)) {
910 return null;
911 }
912 return pane.getInputValue();
913 }
914
915 public void actionPerformed(final ActionEvent e) {
916 final JFileChooser fc = getFileChooser();
917 final File currentDirectory = fc.getCurrentDirectory();
918 File newFolder = null;
919 final String[] options = {createButtonText, cancelButtonText};
920 final String filename = (String)showNewFolderDialog(fc, //parentComponent
921 newFolderDialogPrompt, // message
922 newFolderTitleText, // title
923 JOptionPane.PLAIN_MESSAGE, // messageType
924 null, // icon
925 options, // selectionValues
926 newFolderDefaultName); // initialSelectionValue
927
928 if (filename != null) {
929 try {
930 newFolder = fc.getFileSystemView().createFileObject(currentDirectory, filename);
931 if (newFolder.exists()) {
932 JOptionPane.showMessageDialog(fc, newFolderExistsErrorText, "", JOptionPane.ERROR_MESSAGE);
933 return;
934 }
935
936 newFolder.mkdirs();
937 } catch(final Exception exc) {
938 JOptionPane.showMessageDialog(fc, newFolderErrorText, "", JOptionPane.ERROR_MESSAGE);
939 return;
940 }
941
942 openDirectory(newFolder);
943 }
944 }
945 }
946
947 /**
948 * Responds to an Open, Save, or Choose request
949 */
950 @SuppressWarnings("serial") // Superclass is not serializable across versions
951 protected class ApproveSelectionAction extends AbstractAction {
952 public void actionPerformed(final ActionEvent e) {
953 fSubPanel.approveSelection(getFileChooser());
954 }
955 }
956
957 /**
958 * Responds to an OpenDirectory request
959 */
960 @SuppressWarnings("serial") // Superclass is not serializable across versions
961 protected class OpenSelectionAction extends AbstractAction {
962 public void actionPerformed(final ActionEvent e) {
963 final int index = fFileList.getSelectedRow();
964 if (index >= 0) {
965 final File selectedFile = (File)((AquaFileSystemModel)fFileList.getModel()).getElementAt(index);
966 if (selectedFile != null) openDirectory(selectedFile);
967 }
968 }
969 }
970
971 /**
972 * Responds to a cancel request.
973 */
974 @SuppressWarnings("serial") // Superclass is not serializable across versions
975 protected class CancelSelectionAction extends AbstractAction {
976 public void actionPerformed(final ActionEvent e) {
977 getFileChooser().cancelSelection();
978 }
979
980 public boolean isEnabled() {
981 return getFileChooser().isEnabled();
982 }
983 }
984
985 /**
986 * Rescans the files in the current directory
987 */
988 @SuppressWarnings("serial") // Superclass is not serializable across versions
989 protected class UpdateAction extends AbstractAction {
990 public void actionPerformed(final ActionEvent e) {
991 final JFileChooser fc = getFileChooser();
992 fc.setCurrentDirectory(fc.getFileSystemView().createFileObject(getDirectoryName()));
993 fc.rescanCurrentDirectory();
994 }
995 }
996
997 // *****************************************
998 // ***** default AcceptAll file filter *****
999 // *****************************************
1000 private static class AcceptAllFileFilter extends FileFilter {
1001 public AcceptAllFileFilter() {
1002 }
1003
1004 public boolean accept(final File f) {
1005 return true;
1006 }
1007
1008 public String getDescription() {
1009 return UIManager.getString("FileChooser.acceptAllFileFilterText");
1010 }
1011 }
1012
1013 // Penultimate superclass is JLabel
1014 @SuppressWarnings("serial") // Superclass is not serializable across versions
1015 protected class MacFCTableCellRenderer extends DefaultTableCellRenderer {
1016 boolean fIsSelected = false;
1017
1018 public MacFCTableCellRenderer(final Font f) {
1019 super();
1020 setFont(f);
1021 setIconTextGap(10);
1022 }
1023
1024 public Component getTableCellRendererComponent(final JTable list, final Object value, final boolean isSelected, final boolean cellHasFocus, final int index, final int col) {
1025 super.getTableCellRendererComponent(list, value, isSelected, false, index, col); // No focus border, thanks
1026 fIsSelected = isSelected;
1027 return this;
1028 }
1029
1030 public boolean isSelected() {
1031 return fIsSelected && isEnabled();
1032 }
1033
1034 protected String layoutCL(final JLabel label, final FontMetrics fontMetrics, final String text, final Icon icon, final Rectangle viewR, final Rectangle iconR, final Rectangle textR) {
1035 return SwingUtilities.layoutCompoundLabel(label, fontMetrics, text, icon, label.getVerticalAlignment(), label.getHorizontalAlignment(), label.getVerticalTextPosition(), label.getHorizontalTextPosition(), viewR, iconR, textR, label.getIconTextGap());
1036 }
1037
1038 protected void paintComponent(final Graphics g) {
1039 final String text = getText();
1040 Icon icon = getIcon();
1041 if (icon != null && !isEnabled()) {
1042 final Icon disabledIcon = getDisabledIcon();
1043 if (disabledIcon != null) icon = disabledIcon;
1044 }
1045
1046 if ((icon == null) && (text == null)) { return; }
1047
1048 // from ComponentUI update
1049 g.setColor(getBackground());
1050 g.fillRect(0, 0, getWidth(), getHeight());
1051
1052 // from BasicLabelUI paint
1053 final FontMetrics fm = g.getFontMetrics();
1054 Insets paintViewInsets = getInsets(null);
1055 paintViewInsets.left += 10;
1056
1057 Rectangle paintViewR = new Rectangle(paintViewInsets.left, paintViewInsets.top, getWidth() - (paintViewInsets.left + paintViewInsets.right), getHeight() - (paintViewInsets.top + paintViewInsets.bottom));
1058
1059 Rectangle paintIconR = new Rectangle();
1060 Rectangle paintTextR = new Rectangle();
1061
1062 final String clippedText = layoutCL(this, fm, text, icon, paintViewR, paintIconR, paintTextR);
1063
1064 if (icon != null) {
1065 icon.paintIcon(this, g, paintIconR.x + 5, paintIconR.y);
1066 }
1067
1068 if (text != null) {
1069 final int textX = paintTextR.x;
1070 final int textY = paintTextR.y + fm.getAscent() + 1;
1071 if (isEnabled()) {
1072 // Color background = fIsSelected ? getForeground() : getBackground();
1073 final Color background = getBackground();
1074
1075 g.setColor(background);
1076 g.fillRect(textX - 1, paintTextR.y, paintTextR.width + 2, fm.getAscent() + 2);
1077
1078 g.setColor(getForeground());
1079 SwingUtilities2.drawString(filechooser, g, clippedText, textX, textY);
1080 } else {
1081 final Color background = getBackground();
1082 g.setColor(background);
1083 g.fillRect(textX - 1, paintTextR.y, paintTextR.width + 2, fm.getAscent() + 2);
1084
1085 g.setColor(background.brighter());
1086 SwingUtilities2.drawString(filechooser, g, clippedText, textX, textY);
1087 g.setColor(background.darker());
1088 SwingUtilities2.drawString(filechooser, g, clippedText, textX + 1, textY + 1);
1089 }
1090 }
1091 }
1092
1093 }
1094
1095 @SuppressWarnings("serial") // Superclass is not serializable across versions
1096 protected class FileRenderer extends MacFCTableCellRenderer {
1097 public FileRenderer(final Font f) {
1098 super(f);
1099 }
1100
1101 public Component getTableCellRendererComponent(final JTable list,
1102 final Object value,
1103 final boolean isSelected,
1104 final boolean cellHasFocus,
1105 final int index,
1106 final int col) {
1107 super.getTableCellRendererComponent(list, value, isSelected, false,
1108 index,
1109 col); // No focus border, thanks
1110 final File file = (File)value;
1111 final JFileChooser fc = getFileChooser();
1112 setText(fc.getName(file));
1113 setIcon(fc.getIcon(file));
1114 setEnabled(isSelectableInList(file));
1115 return this;
1116 }
1117 }
1118
1119 @SuppressWarnings("serial") // Superclass is not serializable across versions
1120 protected class DateRenderer extends MacFCTableCellRenderer {
1121 public DateRenderer(final Font f) {
1122 super(f);
1123 }
1124
1125 public Component getTableCellRendererComponent(final JTable list,
1126 final Object value,
1127 final boolean isSelected,
1128 final boolean cellHasFocus,
1129 final int index,
1130 final int col) {
1131 super.getTableCellRendererComponent(list, value, isSelected, false,
1132 index, col);
1133 final File file = (File)fFileList.getValueAt(index, 0);
1134 setEnabled(isSelectableInList(file));
1135 final DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT);
1136 final Date date = (Date)value;
1137
1138 if (date != null) {
1139 setText(formatter.format(date));
1140 } else {
1141 setText("");
1142 }
1143
1144 return this;
1145 }
1146 }
1147
1148 @Override
1149 public Dimension getPreferredSize(final JComponent c) {
1150 return new Dimension(PREF_WIDTH, PREF_HEIGHT);
1151 }
1152
1153 @Override
1154 public Dimension getMinimumSize(final JComponent c) {
1155 return new Dimension(MIN_WIDTH, MIN_HEIGHT);
1156 }
1157
1158 @Override
1159 public Dimension getMaximumSize(final JComponent c) {
1160 return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
1161 }
1162
1163 @SuppressWarnings("serial") // anonymous class
1164 protected ListCellRenderer<File> createDirectoryComboBoxRenderer(final JFileChooser fc) {
1165 return new AquaComboBoxRendererInternal<File>(directoryComboBox) {
1166 public Component getListCellRendererComponent(final JList<? extends File> list,
1167 final File directory,
1168 final int index,
1169 final boolean isSelected,
1170 final boolean cellHasFocus) {
1171 super.getListCellRendererComponent(list, directory, index, isSelected, cellHasFocus);
1172 if (directory == null) {
1173 setText("");
1174 return this;
1175 }
1176
1177 final JFileChooser chooser = getFileChooser();
1178 setText(chooser.getName(directory));
1179 setIcon(chooser.getIcon(directory));
1180 return this;
1181 }
1182 };
1183 }
1184
1185 //
1186 // DataModel for DirectoryComboxbox
1187 //
1188 protected DirectoryComboBoxModel createDirectoryComboBoxModel(final JFileChooser fc) {
1189 return new DirectoryComboBoxModel();
1190 }
1191
1192 /**
1193 * Data model for a type-face selection combo-box.
1194 */
1195 @SuppressWarnings("serial") // Superclass is not serializable across versions
1196 protected class DirectoryComboBoxModel extends AbstractListModel<File> implements ComboBoxModel<File> {
1197 Vector<File> fDirectories = new Vector<File>();
1198 int topIndex = -1;
1199 int fPathCount = 0;
1200
1201 File fSelectedDirectory = null;
1202
1203 public DirectoryComboBoxModel() {
1204 super();
1205 // Add the current directory to the model, and make it the
1206 // selectedDirectory
1207 addItem(getFileChooser().getCurrentDirectory());
1208 }
1209
1210 /**
1211 * Removes the selected directory, and clears out the
1212 * path file entries leading up to that directory.
1213 */
1214 private void removeSelectedDirectory() {
1215 fDirectories.removeAllElements();
1216 fPathCount = 0;
1217 fSelectedDirectory = null;
1218 // dump();
1219 }
1220
1221 /**
1222 * Adds the directory to the model and sets it to be selected,
1223 * additionally clears out the previous selected directory and
1224 * the paths leading up to it, if any.
1225 */
1226 void addItem(final File directory) {
1227 if (directory == null) { return; }
1228 if (fSelectedDirectory != null) {
1229 removeSelectedDirectory();
1230 }
1231
1232 // create File instances of each directory leading up to the top
1233 File f = directory.getAbsoluteFile();
1234 final Vector<File> path = new Vector<File>(10);
1235 while (f.getParent() != null) {
1236 path.addElement(f);
1237 f = getFileChooser().getFileSystemView().createFileObject(f.getParent());
1238 };
1239
1240 // Add root file (the desktop) to the model
1241 final File[] roots = getFileChooser().getFileSystemView().getRoots();
1242 for (final File element : roots) {
1243 path.addElement(element);
1244 }
1245 fPathCount = path.size();
1246
1247 // insert all the path fDirectories leading up to the
1248 // selected directory in reverse order (current directory at top)
1249 for (int i = 0; i < path.size(); i++) {
1250 fDirectories.addElement(path.elementAt(i));
1251 }
1252
1253 setSelectedItem(fDirectories.elementAt(0));
1254
1255 // dump();
1256 }
1257
1258 public void setSelectedItem(final Object selectedDirectory) {
1259 this.fSelectedDirectory = (File)selectedDirectory;
1260 fireContentsChanged(this, -1, -1);
1261 }
1262
1263 public Object getSelectedItem() {
1264 return fSelectedDirectory;
1265 }
1266
1267 public int getSize() {
1268 return fDirectories.size();
1269 }
1270
1271 public File getElementAt(final int index) {
1272 return fDirectories.elementAt(index);
1273 }
1274 }
1275
1276 //
1277 // Renderer for Types ComboBox
1278 //
1279 @SuppressWarnings("serial") // anonymous class
1280 protected ListCellRenderer<FileFilter> createFilterComboBoxRenderer() {
1281 return new AquaComboBoxRendererInternal<FileFilter>(filterComboBox) {
1282 public Component getListCellRendererComponent(final JList<? extends FileFilter> list,
1283 final FileFilter filter,
1284 final int index,
1285 final boolean isSelected,
1286 final boolean cellHasFocus) {
1287 super.getListCellRendererComponent(list, filter, index, isSelected, cellHasFocus);
1288 if (filter != null) setText(filter.getDescription());
1289 return this;
1290 }
1291 };
1292 }
1293
1294 //
1295 // DataModel for Types Comboxbox
1296 //
1297 protected FilterComboBoxModel createFilterComboBoxModel() {
1298 return new FilterComboBoxModel();
1299 }
1300
1301 /**
1302 * Data model for a type-face selection combo-box.
1303 */
1304 @SuppressWarnings("serial") // Superclass is not serializable across versions
1305 protected class FilterComboBoxModel extends AbstractListModel<FileFilter> implements ComboBoxModel<FileFilter>,
1306 PropertyChangeListener {
1307 protected FileFilter[] filters;
1308 Object oldFileFilter = getFileChooser().getFileFilter();
1309
1310 protected FilterComboBoxModel() {
1311 super();
1312 filters = getFileChooser().getChoosableFileFilters();
1313 }
1314
1315 public void propertyChange(PropertyChangeEvent e) {
1316 String prop = e.getPropertyName();
1317 if(prop == JFileChooser.CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY) {
1318 filters = (FileFilter[]) e.getNewValue();
1319 fireContentsChanged(this, -1, -1);
1320 } else if (prop == JFileChooser.FILE_FILTER_CHANGED_PROPERTY) {
1321 setSelectedItem(e.getNewValue());
1322 }
1323 }
1324
1325 public void setSelectedItem(Object filter) {
1326 if (filter != null && !isSelectedFileFilterInModel(filter)) {
1327 oldFileFilter = filter;
1328 getFileChooser().setFileFilter((FileFilter) filter);
1329 fireContentsChanged(this, -1, -1);
1330 }
1331 }
1332
1333 private boolean isSelectedFileFilterInModel(Object filter) {
1334 return Objects.equals(filter, oldFileFilter);
1335 }
1336
1337 public Object getSelectedItem() {
1338 // Ensure that the current filter is in the list.
1339 // NOTE: we shouldnt' have to do this, since JFileChooser adds
1340 // the filter to the choosable filters list when the filter
1341 // is set. Lets be paranoid just in case someone overrides
1342 // setFileFilter in JFileChooser.
1343 FileFilter currentFilter = getFileChooser().getFileFilter();
1344 boolean found = false;
1345 if(currentFilter != null) {
1346 for (FileFilter filter : filters) {
1347 if (filter == currentFilter) {
1348 found = true;
1349 }
1350 }
1351 if(found == false) {
1352 getFileChooser().addChoosableFileFilter(currentFilter);
1353 }
1354 }
1355 return getFileChooser().getFileFilter();
1356 }
1357
1358 public int getSize() {
1359 if(filters != null) {
1360 return filters.length;
1361 } else {
1362 return 0;
1363 }
1364 }
1365
1366 public FileFilter getElementAt(int index) {
1367 if(index > getSize() - 1) {
1368 // This shouldn't happen. Try to recover gracefully.
1369 return getFileChooser().getFileFilter();
1370 }
1371 if(filters != null) {
1372 return filters[index];
1373 } else {
1374 return null;
1375 }
1376 }
1377 }
1378
1379 private boolean containsFileFilter(Object fileFilter) {
1380 return Objects.equals(fileFilter, getFileChooser().getFileFilter());
1381 }
1382
1383 /**
1384 * Acts when FilterComboBox has changed the selected item.
1385 */
1386 @SuppressWarnings("serial") // Superclass is not serializable across versions
1387 protected class FilterComboBoxAction extends AbstractAction {
1388 protected FilterComboBoxAction() {
1389 super("FilterComboBoxAction");
1390 }
1391
1392 public void actionPerformed(final ActionEvent e) {
1393 Object selectedFilter = filterComboBox.getSelectedItem();
1394 if (!containsFileFilter(selectedFilter)) {
1395 getFileChooser().setFileFilter((FileFilter) selectedFilter);
1396 }
1397 }
1398 }
1399
1400 /**
1401 * Acts when DirectoryComboBox has changed the selected item.
1402 */
1403 @SuppressWarnings("serial") // Superclass is not serializable across versions
1404 protected class DirectoryComboBoxAction extends AbstractAction {
1405 protected DirectoryComboBoxAction() {
1406 super("DirectoryComboBoxAction");
1407 }
1408
1409 public void actionPerformed(final ActionEvent e) {
1410 getFileChooser().setCurrentDirectory((File)directoryComboBox.getSelectedItem());
1411 }
1412 }
1413
1414 // Sorting Table operations
1415 @SuppressWarnings("serial") // Superclass is not serializable across versions
1416 class JSortingTableHeader extends JTableHeader {
1417 public JSortingTableHeader(final TableColumnModel cm) {
1418 super(cm);
1419 setReorderingAllowed(true); // This causes mousePress to call setDraggedColumn
1420 }
1421
1422 // One sort state for each column. Both are ascending by default
1423 final boolean[] fSortAscending = {true, true};
1424
1425 // Instead of dragging, it selects which one to sort by
1426 public void setDraggedColumn(final TableColumn aColumn) {
1427 if (aColumn != null) {
1428 final int colIndex = aColumn.getModelIndex();
1429 if (colIndex != fSortColumn) {
1430 filechooser.firePropertyChange(AquaFileSystemModel.SORT_BY_CHANGED, fSortColumn, colIndex);
1431 fSortColumn = colIndex;
1432 } else {
1433 fSortAscending[colIndex] = !fSortAscending[colIndex];
1434 filechooser.firePropertyChange(AquaFileSystemModel.SORT_ASCENDING_CHANGED, !fSortAscending[colIndex], fSortAscending[colIndex]);
1435 }
1436 // Need to repaint the highlighted column.
1437 repaint();
1438 }
1439 }
1440
1441 // This stops mouseDrags from moving the column
1442 public TableColumn getDraggedColumn() {
1443 return null;
1444 }
1445
1446 protected TableCellRenderer createDefaultRenderer() {
1447 final DefaultTableCellRenderer label = new AquaTableCellRenderer();
1448 label.setHorizontalAlignment(SwingConstants.LEFT);
1449 return label;
1450 }
1451
1452 @SuppressWarnings("serial") // Superclass is not serializable across versions
1453 class AquaTableCellRenderer extends DefaultTableCellRenderer implements UIResource {
1454 public Component getTableCellRendererComponent(final JTable localTable, final Object value, final boolean isSelected, final boolean hasFocus, final int row, final int column) {
1455 if (localTable != null) {
1456 final JTableHeader header = localTable.getTableHeader();
1457 if (header != null) {
1458 setForeground(header.getForeground());
1459 setBackground(header.getBackground());
1460 setFont(UIManager.getFont("TableHeader.font"));
1461 }
1462 }
1463
1464 setText((value == null) ? "" : value.toString());
1465
1466 // Modify the table "border" to draw smaller, and with the titles in the right position
1467 // and sort indicators, just like an NSSave/Open panel.
1468 final AquaTableHeaderBorder cellBorder = AquaTableHeaderBorder.getListHeaderBorder();
1469 cellBorder.setSelected(column == fSortColumn);
1470 final int horizontalShift = (column == 0 ? 35 : 10);
1471 cellBorder.setHorizontalShift(horizontalShift);
1472
1473 if (column == fSortColumn) {
1474 cellBorder.setSortOrder(fSortAscending[column] ? AquaTableHeaderBorder.SORT_ASCENDING : AquaTableHeaderBorder.SORT_DECENDING);
1475 } else {
1476 cellBorder.setSortOrder(AquaTableHeaderBorder.SORT_NONE);
1477 }
1478 setBorder(cellBorder);
1479 return this;
1480 }
1481 }
1482 }
1483
1484 public void installComponents(final JFileChooser fc) {
1485 JPanel tPanel; // temp panel
1486 // set to a Y BoxLayout. The chooser will be laid out top to bottom.
1487 fc.setLayout(new BoxLayout(fc, BoxLayout.Y_AXIS));
1488 fc.add(Box.createRigidArea(vstrut10));
1489
1490 // construct the top panel
1491
1492 final JPanel topPanel = new JPanel();
1493 topPanel.setLayout(new BoxLayout(topPanel, BoxLayout.Y_AXIS));
1494 fc.add(topPanel);
1495 fc.add(Box.createRigidArea(vstrut10));
1496
1497 // Add the textfield pane
1498
1499 fTextfieldPanel = new JPanel();
1500 fTextfieldPanel.setLayout(new BorderLayout());
1501 // setBottomPanelForMode will make this visible if we need it
1502 fTextfieldPanel.setVisible(false);
1503 topPanel.add(fTextfieldPanel);
1504
1505 tPanel = new JPanel();
1506 tPanel.setLayout(new BoxLayout(tPanel, BoxLayout.Y_AXIS));
1507 final JPanel labelArea = new JPanel();
1508 labelArea.setLayout(new FlowLayout(FlowLayout.CENTER));
1509 fTextFieldLabel = new JLabel(fileNameLabelText);
1510 labelArea.add(fTextFieldLabel);
1511
1512 // text field
1513 filenameTextField = new JTextField();
1514 fTextFieldLabel.setLabelFor(filenameTextField);
1515 filenameTextField.addActionListener(getAction(kOpen));
1516 filenameTextField.addFocusListener(new SaveTextFocusListener());
1517 final Dimension minSize = filenameTextField.getMinimumSize();
1518 Dimension d = new Dimension(250, (int)minSize.getHeight());
1519 filenameTextField.setPreferredSize(d);
1520 filenameTextField.setMaximumSize(d);
1521 labelArea.add(filenameTextField);
1522 final File f = fc.getSelectedFile();
1523 if (f != null) {
1524 setFileName(fc.getName(f));
1525 } else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {
1526 setFileName(newFileDefaultName);
1527 }
1528
1529 tPanel.add(labelArea);
1530 // separator line
1531 @SuppressWarnings("serial") // anonymous class
1532 final JSeparator sep = new JSeparator(){
1533 public Dimension getPreferredSize() {
1534 return new Dimension(((JComponent)getParent()).getWidth(), 3);
1535 }
1536 };
1537 tPanel.add(Box.createRigidArea(new Dimension(1, 8)));
1538 tPanel.add(sep);
1539 tPanel.add(Box.createRigidArea(new Dimension(1, 7)));
1540 fTextfieldPanel.add(tPanel, BorderLayout.CENTER);
1541
1542 // DirectoryComboBox, left-justified, 200x20 not including drop shadow
1543 directoryComboBox = new JComboBox<>();
1544 directoryComboBox.putClientProperty("JComboBox.lightweightKeyboardNavigation", "Lightweight");
1545 fDirectoryComboBoxModel = createDirectoryComboBoxModel(fc);
1546 directoryComboBox.setModel(fDirectoryComboBoxModel);
1547 directoryComboBox.addActionListener(directoryComboBoxAction);
1548 directoryComboBox.setRenderer(createDirectoryComboBoxRenderer(fc));
1549 directoryComboBox.setToolTipText(directoryComboBoxToolTipText);
1550 d = new Dimension(250, (int)directoryComboBox.getMinimumSize().getHeight());
1551 directoryComboBox.setPreferredSize(d);
1552 directoryComboBox.setMaximumSize(d);
1553 topPanel.add(directoryComboBox);
1554
1555 // ************************************** //
1556 // ** Add the directory/Accessory pane ** //
1557 // ************************************** //
1558 final JPanel centerPanel = new JPanel(new BorderLayout());
1559 fc.add(centerPanel);
1560
1561 // Accessory pane (equiv to Preview pane in NavServices)
1562 final JComponent accessory = fc.getAccessory();
1563 if (accessory != null) {
1564 getAccessoryPanel().add(accessory);
1565 }
1566 centerPanel.add(getAccessoryPanel(), BorderLayout.LINE_START);
1567
1568 // Directory list(table), right-justified, resizable
1569 final JPanel p = createList(fc);
1570 p.setMinimumSize(LIST_MIN_SIZE);
1571 centerPanel.add(p, BorderLayout.CENTER);
1572
1573 // ********************************** //
1574 // **** Construct the bottom panel ** //
1575 // ********************************** //
1576 fBottomPanel = new JPanel();
1577 fBottomPanel.setLayout(new BoxLayout(fBottomPanel, BoxLayout.Y_AXIS));
1578 fc.add(fBottomPanel);
1579
1580 // Filter label and combobox.
1581 // I know it's unMaclike, but the filter goes on Directory_only too.
1582 tPanel = new JPanel();
1583 tPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
1584 tPanel.setBorder(AquaGroupBorder.getTitlelessBorder());
1585 final JLabel formatLabel = new JLabel(filesOfTypeLabelText);
1586 tPanel.add(formatLabel);
1587
1588 // Combobox
1589 filterComboBoxModel = createFilterComboBoxModel();
1590 fc.addPropertyChangeListener(filterComboBoxModel);
1591 filterComboBox = new JComboBox<>(filterComboBoxModel);
1592 formatLabel.setLabelFor(filterComboBox);
1593 filterComboBox.setRenderer(createFilterComboBoxRenderer());
1594 d = new Dimension(220, (int)filterComboBox.getMinimumSize().getHeight());
1595 filterComboBox.setPreferredSize(d);
1596 filterComboBox.setMaximumSize(d);
1597 filterComboBox.addActionListener(filterComboBoxAction);
1598 filterComboBox.setOpaque(false);
1599 tPanel.add(filterComboBox);
1600
1601 fBottomPanel.add(tPanel);
1602
1603 // fDirectoryPanel: New, Open, Cancel, Approve buttons, right-justified, 82x22
1604 // (sometimes the NewFolder and OpenFolder buttons are invisible)
1605 fDirectoryPanel = new JPanel();
1606 fDirectoryPanel.setLayout(new BoxLayout(fDirectoryPanel, BoxLayout.PAGE_AXIS));
1607 JPanel directoryPanel = new JPanel(new BorderLayout());
1608 JPanel newFolderButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));
1609 newFolderButtonPanel.add(Box.createHorizontalStrut(20));
1610 fNewFolderButton = createNewFolderButton(); // Because we hide it depending on style
1611 newFolderButtonPanel.add(fNewFolderButton);
1612 directoryPanel.add(newFolderButtonPanel, BorderLayout.LINE_START);
1613 JPanel approveCancelButtonPanel = new JPanel(new FlowLayout(FlowLayout.TRAILING, 0, 0));
1614 fOpenButton = createButton(kOpenDirectory, openButtonText);
1615 approveCancelButtonPanel.add(fOpenButton);
1616 approveCancelButtonPanel.add(Box.createHorizontalStrut(8));
1617 fCancelButton = createButton(kCancel, null);
1618 approveCancelButtonPanel.add(fCancelButton);
1619 approveCancelButtonPanel.add(Box.createHorizontalStrut(8));
1620 // The ApproveSelection button
1621 fApproveButton = new JButton();
1622 fApproveButton.addActionListener(fApproveSelectionAction);
1623 approveCancelButtonPanel.add(fApproveButton);
1624 approveCancelButtonPanel.add(Box.createHorizontalStrut(20));
1625 directoryPanel.add(approveCancelButtonPanel, BorderLayout.LINE_END);
1626 fDirectoryPanel.add(Box.createVerticalStrut(5));
1627 fDirectoryPanel.add(directoryPanel);
1628 fDirectoryPanel.add(Box.createVerticalStrut(12));
1629 fDirectoryPanelSpacer = Box.createRigidArea(hstrut10);
1630
1631 if (fc.getControlButtonsAreShown()) {
1632 fBottomPanel.add(fDirectoryPanelSpacer);
1633 fBottomPanel.add(fDirectoryPanel);
1634 }
1635
1636 setBottomPanelForMode(fc); // updates ApproveButtonText etc
1637
1638 // don't create til after the FCSubpanel and buttons are made
1639 filenameTextField.getDocument().addDocumentListener(new SaveTextDocumentListener());
1640 }
1641
1642 void setDefaultButtonForMode(final JFileChooser fc) {
1643 final JButton defaultButton = fSubPanel.getDefaultButton(fc);
1644 final JRootPane root = defaultButton.getRootPane();
1645 if (root != null) {
1646 root.setDefaultButton(defaultButton);
1647 }
1648 }
1649
1650 // Macs start with their focus in text areas if they have them,
1651 // lists otherwise (the other plafs start with the focus on approveButton)
1652 void setFocusForMode(final JFileChooser fc) {
1653 final JComponent focusComponent = fSubPanel.getFocusComponent(fc);
1654 if (focusComponent != null) {
1655 focusComponent.requestFocus();
1656 }
1657 }
1658
1659 // Enable/disable buttons as needed for the current selection/focus state
1660 void updateButtonState(final JFileChooser fc) {
1661 fSubPanel.updateButtonState(fc, getFirstSelectedItem());
1662 updateApproveButton(fc);
1663 }
1664
1665 void updateApproveButton(final JFileChooser chooser) {
1666 fApproveButton.setText(getApproveButtonText(chooser));
1667 fApproveButton.setToolTipText(getApproveButtonToolTipText(chooser));
1668 fApproveButton.setMnemonic(getApproveButtonMnemonic(chooser));
1669 fCancelButton.setToolTipText(getCancelButtonToolTipText(chooser));
1670 }
1671
1672 // Lazy-init the subpanels
1673 synchronized FCSubpanel getSaveFilePanel() {
1674 if (fSaveFilePanel == null) fSaveFilePanel = new SaveFilePanel();
1675 return fSaveFilePanel;
1676 }
1677
1678 synchronized FCSubpanel getOpenFilePanel() {
1679 if (fOpenFilePanel == null) fOpenFilePanel = new OpenFilePanel();
1680 return fOpenFilePanel;
1681 }
1682
1683 synchronized FCSubpanel getOpenDirOrAnyPanel() {
1684 if (fOpenDirOrAnyPanel == null) fOpenDirOrAnyPanel = new OpenDirOrAnyPanel();
1685 return fOpenDirOrAnyPanel;
1686 }
1687
1688 synchronized FCSubpanel getCustomFilePanel() {
1689 if (fCustomFilePanel == null) fCustomFilePanel = new CustomFilePanel();
1690 return fCustomFilePanel;
1691 }
1692
1693 synchronized FCSubpanel getCustomDirOrAnyPanel() {
1694 if (fCustomDirOrAnyPanel == null) fCustomDirOrAnyPanel = new CustomDirOrAnyPanel();
1695 return fCustomDirOrAnyPanel;
1696 }
1697
1698 void setBottomPanelForMode(final JFileChooser fc) {
1699 if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) fSubPanel = getSaveFilePanel();
1700 else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {
1701 if (fc.getFileSelectionMode() == JFileChooser.FILES_ONLY) fSubPanel = getOpenFilePanel();
1702 else fSubPanel = getOpenDirOrAnyPanel();
1703 } else if (fc.getDialogType() == JFileChooser.CUSTOM_DIALOG) {
1704 if (fc.getFileSelectionMode() == JFileChooser.FILES_ONLY) fSubPanel = getCustomFilePanel();
1705 else fSubPanel = getCustomDirOrAnyPanel();
1706 }
1707
1708 fSubPanel.installPanel(fc, true);
1709 updateApproveButton(fc);
1710 updateButtonState(fc);
1711 setDefaultButtonForMode(fc);
1712 setFocusForMode(fc);
1713 fc.invalidate();
1714 }
1715
1716 // fTextfieldPanel and fDirectoryPanel both have NewFolder buttons; only one should be visible at a time
1717 JButton createNewFolderButton() {
1718 final JButton b = new JButton(newFolderButtonText);
1719 b.setToolTipText(newFolderToolTipText);
1720 b.getAccessibleContext().setAccessibleName(newFolderAccessibleName);
1721 b.setHorizontalTextPosition(SwingConstants.LEFT);
1722 b.setAlignmentX(Component.LEFT_ALIGNMENT);
1723 b.setAlignmentY(Component.CENTER_ALIGNMENT);
1724 b.addActionListener(getAction(kNewFolder));
1725 return b;
1726 }
1727
1728 JButton createButton(final int which, String label) {
1729 if (label == null) label = UIManager.getString(sDataPrefix + sButtonKinds[which] + sButtonData[0]);
1730 final int mnemonic = UIManager.getInt(sDataPrefix + sButtonKinds[which] + sButtonData[1]);
1731 final String tipText = UIManager.getString(sDataPrefix + sButtonKinds[which] + sButtonData[2]);
1732 final JButton b = new JButton(label);
1733 b.setMnemonic(mnemonic);
1734 b.setToolTipText(tipText);
1735 b.addActionListener(getAction(which));
1736 return b;
1737 }
1738
1739 AbstractAction getAction(final int which) {
1740 return fButtonActions[which];
1741 }
1742
1743 public void uninstallComponents(final JFileChooser fc) { //$ Metal (on which this is based) doesn't uninstall its components.
1744 }
1745
1746 // Consistent with the AppKit NSSavePanel, clicks on a file (not a directory) should populate the text field
1747 // with that file's display name.
1748 protected class FileListMouseListener extends MouseAdapter {
1749 public void mouseClicked(final MouseEvent e) {
1750 final Point p = e.getPoint();
1751 final int row = fFileList.rowAtPoint(p);
1752 final int column = fFileList.columnAtPoint(p);
1753
1754 // The autoscroller can generate drag events outside the Table's range.
1755 if ((column == -1) || (row == -1)) { return; }
1756
1757 final File clickedFile = (File)(fFileList.getValueAt(row, 0));
1758
1759 // rdar://problem/3734130 -- don't populate the text field if this file isn't selectable in this mode.
1760 if (isSelectableForMode(getFileChooser(), clickedFile)) {
1761 // [3188387] Populate the file name field with the selected file name
1762 // [3484163] It should also use the display name, not the actual name.
1763 setFileName(fileView.getName(clickedFile));
1764 }
1765 }
1766 }
1767
1768 protected JPanel createList(final JFileChooser fc) {
1769 // The first part is similar to MetalFileChooserUI.createList - same kind of listeners
1770 final JPanel p = new JPanel(new BorderLayout());
1771 fFileList = new JTableExtension();
1772 fFileList.setToolTipText(null); // Workaround for 2487689
1773 fFileList.addMouseListener(new FileListMouseListener());
1774 model = new AquaFileSystemModel(fc, fFileList, fColumnNames);
1775 final MacListSelectionModel listSelectionModel = new MacListSelectionModel(model);
1776
1777 if (getFileChooser().isMultiSelectionEnabled()) {
1778 listSelectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
1779 } else {
1780 listSelectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1781 }
1782
1783 fFileList.setModel(model);
1784 fFileList.setSelectionModel(listSelectionModel);
1785 fFileList.getSelectionModel().addListSelectionListener(createListSelectionListener(fc));
1786
1787 // Now we're different, because we're a table, not a list
1788 fc.addPropertyChangeListener(model);
1789 fFileList.addFocusListener(new SaveTextFocusListener());
1790 final JTableHeader th = new JSortingTableHeader(fFileList.getColumnModel());
1791 fFileList.setTableHeader(th);
1792 fFileList.setRowMargin(0);
1793 fFileList.setIntercellSpacing(new Dimension(0, 1));
1794 fFileList.setShowVerticalLines(false);
1795 fFileList.setShowHorizontalLines(false);
1796 final Font f = fFileList.getFont(); //ThemeFont.GetThemeFont(AppearanceConstants.kThemeViewsFont);
1797 //fc.setFont(f);
1798 //fFileList.setFont(f);
1799 fFileList.setDefaultRenderer(File.class, new FileRenderer(f));
1800 fFileList.setDefaultRenderer(Date.class, new DateRenderer(f));
1801 final FontMetrics fm = fFileList.getFontMetrics(f);
1802
1803 // Row height isn't based on the renderers. It defaults to 16 so we have to set it
1804 fFileList.setRowHeight(Math.max(fm.getHeight(), fileIcon.getIconHeight() + 2));
1805
1806 // Add a binding for the file list that triggers return and escape
1807 fFileList.registerKeyboardAction(new CancelSelectionAction(), KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_FOCUSED);
1808 // Add a binding for the file list that triggers the default button (see DefaultButtonAction)
1809 fFileList.registerKeyboardAction(new DefaultButtonAction(), KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), JComponent.WHEN_FOCUSED);
1810 fFileList.setDropTarget(dragAndDropTarget);
1811
1812 final JScrollPane scrollpane = new JScrollPane(fFileList, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
1813 scrollpane.setComponentOrientation(ComponentOrientation.getOrientation(Locale.getDefault()));
1814 scrollpane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, new ScrollPaneCornerPanel());
1815 p.add(scrollpane, BorderLayout.CENTER);
1816 return p;
1817 }
1818
1819 @SuppressWarnings("serial") // Superclass is not serializable across versions
1820 protected class ScrollPaneCornerPanel extends JPanel {
1821 final Border border = UIManager.getBorder("TableHeader.cellBorder");
1822
1823 protected void paintComponent(final Graphics g) {
1824 border.paintBorder(this, g, 0, 0, getWidth() + 1, getHeight());
1825 }
1826 }
1827
1828 JComboBox<File> directoryComboBox;
1829 DirectoryComboBoxModel fDirectoryComboBoxModel;
1830 private final Action directoryComboBoxAction = new DirectoryComboBoxAction();
1831
1832 JTextField filenameTextField;
1833
1834 JTableExtension fFileList;
1835
1836 private FilterComboBoxModel filterComboBoxModel;
1837 JComboBox<FileFilter> filterComboBox;
1838 private final Action filterComboBoxAction = new FilterComboBoxAction();
1839
1840 private static final Dimension hstrut10 = new Dimension(10, 1);
1841 private static final Dimension vstrut10 = new Dimension(1, 10);
1842
1843 private static final int PREF_WIDTH = 550;
1844 private static final int PREF_HEIGHT = 400;
1845 private static final int MIN_WIDTH = 400;
1846 private static final int MIN_HEIGHT = 250;
1847 private static final int LIST_MIN_WIDTH = 400;
1848 private static final int LIST_MIN_HEIGHT = 100;
1849 private static final Dimension LIST_MIN_SIZE = new Dimension(LIST_MIN_WIDTH, LIST_MIN_HEIGHT);
1850
1851 static String fileNameLabelText = null;
1852 JLabel fTextFieldLabel = null;
1853
1854 private static String filesOfTypeLabelText = null;
1855
1856 private static String newFolderToolTipText = null;
1857 static String newFolderAccessibleName = null;
1858
1859 private static final String[] fColumnNames = new String[2];
1860
1861 JPanel fTextfieldPanel; // Filename textfield for Save or Custom
1862 private JPanel fDirectoryPanel; // NewFolder/OpenFolder/Cancel/Approve buttons
1863 private Component fDirectoryPanelSpacer;
1864 private JPanel fBottomPanel; // The panel that holds fDirectoryPanel and filterComboBox
1865
1866 private FCSubpanel fSaveFilePanel = null;
1867 private FCSubpanel fOpenFilePanel = null;
1868 private FCSubpanel fOpenDirOrAnyPanel = null;
1869 private FCSubpanel fCustomFilePanel = null;
1870 private FCSubpanel fCustomDirOrAnyPanel = null;
1871
1872 FCSubpanel fSubPanel = null; // Current FCSubpanel
1873
1874 JButton fApproveButton; // mode-specific behavior is managed by FCSubpanel.approveSelection
1875 JButton fOpenButton; // for Directories
1876 JButton fNewFolderButton; // for fDirectoryPanel
1877
1878 // ToolTip text varies with type of dialog
1879 private JButton fCancelButton;
1880
1881 private final ApproveSelectionAction fApproveSelectionAction = new ApproveSelectionAction();
1882 protected int fSortColumn = 0;
1883 protected int fPackageIsTraversable = -1;
1884 protected int fApplicationIsTraversable = -1;
1885
1886 protected static final int sGlobalPackageIsTraversable;
1887 protected static final int sGlobalApplicationIsTraversable;
1888
1889 protected static final String PACKAGE_TRAVERSABLE_PROPERTY = "JFileChooser.packageIsTraversable";
1890 protected static final String APPLICATION_TRAVERSABLE_PROPERTY = "JFileChooser.appBundleIsTraversable";
1891 protected static final String[] sTraversableProperties = {"always", // Bundle is always traversable
1892 "never", // Bundle is never traversable
1893 "conditional"}; // Bundle is traversable on command click
1894 protected static final int kOpenAlways = 0, kOpenNever = 1, kOpenConditional = 2;
1895
1896 AbstractAction[] fButtonActions = {fApproveSelectionAction, fApproveSelectionAction, new CancelSelectionAction(), new OpenSelectionAction(), null, new NewFolderAction()};
1897
1898 static int parseTraversableProperty(final String s) {
1899 if (s == null) return -1;
1900 for (int i = 0; i < sTraversableProperties.length; i++) {
1901 if (s.equals(sTraversableProperties[i])) return i;
1902 }
1903 return -1;
1904 }
1905
1906 static {
1907 Object o = UIManager.get(PACKAGE_TRAVERSABLE_PROPERTY);
1908 if (o != null && o instanceof String) sGlobalPackageIsTraversable = parseTraversableProperty((String)o);
1909 else sGlobalPackageIsTraversable = kOpenConditional;
1910
1911 o = UIManager.get(APPLICATION_TRAVERSABLE_PROPERTY);
1912 if (o != null && o instanceof String) sGlobalApplicationIsTraversable = parseTraversableProperty((String)o);
1913 else sGlobalApplicationIsTraversable = kOpenConditional;
1914 }
1915 static final String sDataPrefix = "FileChooser.";
1916 static final String[] sButtonKinds = {"openButton", "saveButton", "cancelButton", "openDirectoryButton", "helpButton", "newFolderButton"};
1917 static final String[] sButtonData = {"Text", "Mnemonic", "ToolTipText"};
1918 static final int kOpen = 0, kSave = 1, kCancel = 2, kOpenDirectory = 3, kHelp = 4, kNewFolder = 5;
1919
1920 /*-------
1921
1922 Possible states: Save, {Open, Custom}x{Files, File and Directory, Directory}
1923 --------- */
1924
1925 // This class returns the values for the Custom type, to avoid duplicating code in the two Custom subclasses
1926 abstract class FCSubpanel {
1927 // Install the appropriate panels for this mode
1928 abstract void installPanel(JFileChooser fc, boolean controlButtonsAreShown);
1929
1930 abstract void updateButtonState(JFileChooser fc, File f);
1931
1932 // Can this item be selected?
1933 // if not, it's disabled in the list
1934 boolean isSelectableInList(final JFileChooser fc, final File f) {
1935 if (f == null) return false;
1936 if (fc.getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) return fc.isTraversable(f);
1937 return fc.accept(f);
1938 }
1939
1940 void approveSelection(final JFileChooser fc) {
1941 fc.approveSelection();
1942 }
1943
1944 JButton getDefaultButton(final JFileChooser fc) {
1945 return fApproveButton;
1946 }
1947
1948 // Default to the textfield, panels without one should subclass
1949 JComponent getFocusComponent(final JFileChooser fc) {
1950 return filenameTextField;
1951 }
1952
1953 String getApproveButtonText(final JFileChooser fc) {
1954 // Fallback to "choose"
1955 return this.getApproveButtonText(fc, chooseButtonText);
1956 }
1957
1958 // Try to get the custom text. If none, use the fallback
1959 String getApproveButtonText(final JFileChooser fc, final String fallbackText) {
1960 final String buttonText = fc.getApproveButtonText();
1961 if (buttonText != null) {
1962 buttonText.trim();
1963 if (!buttonText.equals("")) return buttonText;
1964 }
1965 return fallbackText;
1966 }
1967
1968 int getApproveButtonMnemonic(final JFileChooser fc) {
1969 // Don't use a default
1970 return fc.getApproveButtonMnemonic();
1971 }
1972
1973 // No fallback
1974 String getApproveButtonToolTipText(final JFileChooser fc) {
1975 return getApproveButtonToolTipText(fc, null);
1976 }
1977
1978 String getApproveButtonToolTipText(final JFileChooser fc, final String fallbackText) {
1979 final String tooltipText = fc.getApproveButtonToolTipText();
1980 if (tooltipText != null) {
1981 tooltipText.trim();
1982 if (!tooltipText.equals("")) return tooltipText;
1983 }
1984 return fallbackText;
1985 }
1986
1987 String getCancelButtonToolTipText(final JFileChooser fc) {
1988 return cancelChooseButtonToolTipText;
1989 }
1990 }
1991
1992 // Custom FILES_ONLY dialog
1993 /*
1994 NavServices Save appearance with Open behavior
1995 Approve button label = Open when list has focus and a directory is selected, Custom otherwise
1996 No OpenDirectory button - Approve button is overloaded
1997 Default button / double click = Approve
1998 Has text field
1999 List - everything is enabled
2000 */
2001 class CustomFilePanel extends FCSubpanel {
2002 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2003 fTextfieldPanel.setVisible(true); // do we really want one in multi-select? It's confusing
2004 fOpenButton.setVisible(false);
2005 fNewFolderButton.setVisible(true);
2006 }
2007
2008 // If the list has focus, the mode depends on the selection
2009 // - directory = open, file = approve
2010 // If something else has focus and we have text, it's approve
2011 // otherwise, it depends on selection again.
2012 boolean inOpenDirectoryMode(final JFileChooser fc, final File f) {
2013 final boolean selectionIsDirectory = (f != null && fc.isTraversable(f));
2014 if (fFileList.hasFocus()) return selectionIsDirectory;
2015 else if (textfieldIsValid()) return false;
2016 return selectionIsDirectory;
2017 }
2018
2019 // The approve button is overloaded to mean OpenDirectory or Save
2020 void approveSelection(final JFileChooser fc) {
2021 File f = getFirstSelectedItem();
2022 if (inOpenDirectoryMode(fc, f)) {
2023 openDirectory(f);
2024 } else {
2025 f = makeFile(fc, getFileName());
2026 if (f != null) {
2027 selectionInProgress = true;
2028 getFileChooser().setSelectedFile(f);
2029 selectionInProgress = false;
2030 }
2031 getFileChooser().approveSelection();
2032 }
2033 }
2034
2035 // The approve button should be enabled
2036 // - if something in the list can be opened
2037 // - if the textfield has something in it
2038 void updateButtonState(final JFileChooser fc, final File f) {
2039 boolean enabled = true;
2040 if (!inOpenDirectoryMode(fc, f)) {
2041 enabled = (f != null) || textfieldIsValid();
2042 }
2043 getApproveButton(fc).setEnabled(enabled);
2044
2045 // The OpenDirectory button should be disabled if there's no directory selected
2046 fOpenButton.setEnabled(f != null && fc.isTraversable(f));
2047
2048 // Update the default button, since we may have disabled the current default.
2049 setDefaultButtonForMode(fc);
2050 }
2051
2052 // everything's enabled, because we don't know what they're doing with them
2053 boolean isSelectableInList(final JFileChooser fc, final File f) {
2054 if (f == null) return false;
2055 return fc.accept(f);
2056 }
2057
2058 String getApproveButtonToolTipText(final JFileChooser fc) {
2059 // The approve Button should have openDirectoryButtonToolTipText when the selection is a folder...
2060 if (inOpenDirectoryMode(fc, getFirstSelectedItem())) return openDirectoryButtonToolTipText;
2061 return super.getApproveButtonToolTipText(fc);
2062 }
2063 }
2064
2065 // All Save dialogs
2066 /*
2067 NavServices Save
2068 Approve button label = Open when list has focus and a directory is selected, Save otherwise
2069 No OpenDirectory button - Approve button is overloaded
2070 Default button / double click = Approve
2071 Has text field
2072 Has NewFolder button (by text field)
2073 List - only traversables are enabled
2074 List is always SINGLE_SELECT
2075 */
2076 // Subclasses CustomFilePanel because they look alike and have some common behavior
2077 class SaveFilePanel extends CustomFilePanel {
2078 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2079 fTextfieldPanel.setVisible(true);
2080 fOpenButton.setVisible(false);
2081 fNewFolderButton.setVisible(true);
2082 }
2083
2084 // only traversables are enabled, regardless of mode
2085 // because all you can do is select the next folder to open
2086 boolean isSelectableInList(final JFileChooser fc, final File f) {
2087 return fc.accept(f) && fc.isTraversable(f);
2088 }
2089
2090 // The approve button means 'approve the file name in the text field.'
2091 void approveSelection(final JFileChooser fc) {
2092 final File f = makeFile(fc, getFileName());
2093 if (f != null) {
2094 selectionInProgress = true;
2095 getFileChooser().setSelectedFile(f);
2096 selectionInProgress = false;
2097 getFileChooser().approveSelection();
2098 }
2099 }
2100
2101 // The approve button should be enabled if the textfield has something in it
2102 void updateButtonState(final JFileChooser fc, final File f) {
2103 final boolean enabled = textfieldIsValid();
2104 getApproveButton(fc).setEnabled(enabled);
2105 }
2106
2107 String getApproveButtonText(final JFileChooser fc) {
2108 // Get the custom text, or fallback to "Save"
2109 return this.getApproveButtonText(fc, saveButtonText);
2110 }
2111
2112 int getApproveButtonMnemonic(final JFileChooser fc) {
2113 return saveButtonMnemonic;
2114 }
2115
2116 String getApproveButtonToolTipText(final JFileChooser fc) {
2117 // The approve Button should have openDirectoryButtonToolTipText when the selection is a folder...
2118 if (inOpenDirectoryMode(fc, getFirstSelectedItem())) return openDirectoryButtonToolTipText;
2119 return this.getApproveButtonToolTipText(fc, saveButtonToolTipText);
2120 }
2121
2122 String getCancelButtonToolTipText(final JFileChooser fc) {
2123 return cancelSaveButtonToolTipText;
2124 }
2125 }
2126
2127 // Open FILES_ONLY
2128 /*
2129 NSOpenPanel-style
2130 Approve button label = Open
2131 Default button / double click = Approve
2132 No text field
2133 No NewFolder button
2134 List - all items are enabled
2135 */
2136 class OpenFilePanel extends FCSubpanel {
2137 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2138 fTextfieldPanel.setVisible(false);
2139 fOpenButton.setVisible(false);
2140 fNewFolderButton.setVisible(false);
2141 setDefaultButtonForMode(fc);
2142 }
2143
2144 boolean inOpenDirectoryMode(final JFileChooser fc, final File f) {
2145 return (f != null && fc.isTraversable(f));
2146 }
2147
2148 // Default to the list
2149 JComponent getFocusComponent(final JFileChooser fc) {
2150 return fFileList;
2151 }
2152
2153 void updateButtonState(final JFileChooser fc, final File f) {
2154 // Button is disabled if there's nothing selected
2155 final boolean enabled = (f != null) && !fc.isTraversable(f);
2156 getApproveButton(fc).setEnabled(enabled);
2157 }
2158
2159 // all items are enabled
2160 boolean isSelectableInList(final JFileChooser fc, final File f) {
2161 return f != null && fc.accept(f);
2162 }
2163
2164 String getApproveButtonText(final JFileChooser fc) {
2165 // Get the custom text, or fallback to "Open"
2166 return this.getApproveButtonText(fc, openButtonText);
2167 }
2168
2169 int getApproveButtonMnemonic(final JFileChooser fc) {
2170 return openButtonMnemonic;
2171 }
2172
2173 String getApproveButtonToolTipText(final JFileChooser fc) {
2174 return this.getApproveButtonToolTipText(fc, openButtonToolTipText);
2175 }
2176
2177 String getCancelButtonToolTipText(final JFileChooser fc) {
2178 return cancelOpenButtonToolTipText;
2179 }
2180 }
2181
2182 // used by open and custom panels for Directory only or files and directories
2183 abstract class DirOrAnyPanel extends FCSubpanel {
2184 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2185 fOpenButton.setVisible(false);
2186 }
2187
2188 JButton getDefaultButton(final JFileChooser fc) {
2189 return getApproveButton(fc);
2190 }
2191
2192 void updateButtonState(final JFileChooser fc, final File f) {
2193 // Button is disabled if there's nothing selected
2194 // Approve button is handled by the subclasses
2195 // getApproveButton(fc).setEnabled(f != null);
2196
2197 // The OpenDirectory button should be disabled if there's no directory selected
2198 // - we only check the first item
2199
2200 fOpenButton.setEnabled(false);
2201 setDefaultButtonForMode(fc);
2202 }
2203 }
2204
2205 // Open FILES_AND_DIRECTORIES or DIRECTORIES_ONLY
2206 /*
2207 NavServices Choose
2208 Approve button label = Choose/Custom
2209 Has OpenDirectory button
2210 Default button / double click = OpenDirectory
2211 No text field
2212 List - files are disabled in DIRECTORIES_ONLY
2213 */
2214 class OpenDirOrAnyPanel extends DirOrAnyPanel {
2215 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2216 super.installPanel(fc, controlButtonsAreShown);
2217 fTextfieldPanel.setVisible(false);
2218 fNewFolderButton.setVisible(false);
2219 }
2220
2221 // Default to the list
2222 JComponent getFocusComponent(final JFileChooser fc) {
2223 return fFileList;
2224 }
2225
2226 int getApproveButtonMnemonic(final JFileChooser fc) {
2227 return chooseButtonMnemonic;
2228 }
2229
2230 String getApproveButtonToolTipText(final JFileChooser fc) {
2231 String fallbackText;
2232 if (fc.getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY) fallbackText = chooseFolderButtonToolTipText;
2233 else fallbackText = chooseItemButtonToolTipText;
2234 return this.getApproveButtonToolTipText(fc, fallbackText);
2235 }
2236
2237 void updateButtonState(final JFileChooser fc, final File f) {
2238 // Button is disabled if there's nothing selected
2239 getApproveButton(fc).setEnabled(f != null);
2240 super.updateButtonState(fc, f);
2241 }
2242 }
2243
2244 // Custom FILES_AND_DIRECTORIES or DIRECTORIES_ONLY
2245 /*
2246 No NavServices equivalent
2247 Approve button label = user defined or Choose
2248 Has OpenDirectory button
2249 Default button / double click = OpenDirectory
2250 Has text field
2251 Has NewFolder button (by text field)
2252 List - files are disabled in DIRECTORIES_ONLY
2253 */
2254 class CustomDirOrAnyPanel extends DirOrAnyPanel {
2255 void installPanel(final JFileChooser fc, final boolean controlButtonsAreShown) {
2256 super.installPanel(fc, controlButtonsAreShown);
2257 fTextfieldPanel.setVisible(true);
2258 fNewFolderButton.setVisible(true);
2259 }
2260
2261 // If there's text, make a file and select it
2262 void approveSelection(final JFileChooser fc) {
2263 final File f = makeFile(fc, getFileName());
2264 if (f != null) {
2265 selectionInProgress = true;
2266 getFileChooser().setSelectedFile(f);
2267 selectionInProgress = false;
2268 }
2269 getFileChooser().approveSelection();
2270 }
2271
2272 void updateButtonState(final JFileChooser fc, final File f) {
2273 // Button is disabled if there's nothing selected
2274 getApproveButton(fc).setEnabled(f != null || textfieldIsValid());
2275 super.updateButtonState(fc, f);
2276 }
2277 }
2278
2279 // See FileRenderer - documents in Save dialogs draw disabled, so they shouldn't be selected
2280 @SuppressWarnings("serial") // Superclass is not serializable across versions
2281 class MacListSelectionModel extends DefaultListSelectionModel {
2282 AquaFileSystemModel fModel;
2283
2284 MacListSelectionModel(final AquaFileSystemModel model) {
2285 fModel = model;
2286 }
2287
2288 // Can the file be selected in this mode?
2289 // (files are visible even if they can't be selected)
2290 boolean isSelectableInListIndex(final int index) {
2291 final File file = (File)fModel.getValueAt(index, 0);
2292 return (file != null && isSelectableInList(file));
2293 }
2294
2295 // Make sure everything in the selection interval is valid
2296 void verifySelectionInterval(int index0, int index1, boolean isSetSelection) {
2297 if (index0 > index1) {
2298 final int tmp = index1;
2299 index1 = index0;
2300 index0 = tmp;
2301 }
2302 int start = index0;
2303 int end;
2304 do {
2305 // Find the first selectable file in the range
2306 for (; start <= index1; start++) {
2307 if (isSelectableInListIndex(start)) break;
2308 }
2309 end = -1;
2310 // Find the last selectable file in the range
2311 for (int i = start; i <= index1; i++) {
2312 if (!isSelectableInListIndex(i)) {
2313 break;
2314 }
2315 end = i;
2316 }
2317 // Select the range
2318 if (end >= 0) {
2319 // If setting the selection, do "set" the first time to clear the old one
2320 // after that do "add" to extend it
2321 if (isSetSelection) {
2322 super.setSelectionInterval(start, end);
2323 isSetSelection = false;
2324 } else {
2325 super.addSelectionInterval(start, end);
2326 }
2327 start = end + 1;
2328 } else {
2329 break;
2330 }
2331 } while (start <= index1);
2332 }
2333
2334 public void setAnchorSelectionIndex(final int anchorIndex) {
2335 if (isSelectableInListIndex(anchorIndex)) super.setAnchorSelectionIndex(anchorIndex);
2336 }
2337
2338 public void setLeadSelectionIndex(final int leadIndex) {
2339 if (isSelectableInListIndex(leadIndex)) super.setLeadSelectionIndex(leadIndex);
2340 }
2341
2342 public void setSelectionInterval(final int index0, final int index1) {
2343 if (index0 == -1 || index1 == -1) { return; }
2344
2345 if ((getSelectionMode() == SINGLE_SELECTION) || (index0 == index1)) {
2346 if (isSelectableInListIndex(index1)) super.setSelectionInterval(index1, index1);
2347 } else {
2348 verifySelectionInterval(index0, index1, true);
2349 }
2350 }
2351
2352 public void addSelectionInterval(final int index0, final int index1) {
2353 if (index0 == -1 || index1 == -1) { return; }
2354
2355 if (index0 == index1) {
2356 if (isSelectableInListIndex(index1)) super.addSelectionInterval(index1, index1);
2357 return;
2358 }
2359
2360 if (getSelectionMode() != MULTIPLE_INTERVAL_SELECTION) {
2361 setSelectionInterval(index0, index1);
2362 return;
2363 }
2364
2365 verifySelectionInterval(index0, index1, false);
2366 }
2367 }
2368
2369 // Convenience, to translate from the JList directory view to the Mac-style JTable
2370 // & minimize diffs between this and BasicFileChooserUI
2371 @SuppressWarnings("serial") // Superclass is not serializable across versions
2372 class JTableExtension extends JTable {
2373 public void setSelectedIndex(final int index) {
2374 getSelectionModel().setSelectionInterval(index, index);
2375 }
2376
2377 public void removeSelectedIndex(final int index) {
2378 getSelectionModel().removeSelectionInterval(index, index);
2379 }
2380
2381 public void ensureIndexIsVisible(final int index) {
2382 final Rectangle cellBounds = getCellRect(index, 0, false);
2383 if (cellBounds != null) {
2384 scrollRectToVisible(cellBounds);
2385 }
2386 }
2387
2388 public int locationToIndex(final Point location) {
2389 return rowAtPoint(location);
2390 }
2391 }
2392 }