1 /*

     2  * Copyright 1998-2006 Sun Microsystems, Inc.  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.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.swing.plaf.basic;

    27 

    28 import javax.swing.*;

    29 import javax.swing.filechooser.*;

    30 import javax.swing.filechooser.FileFilter;

    31 import javax.swing.event.*;

    32 import javax.swing.plaf.*;

    33 import java.awt.*;

    34 import java.awt.event.*;

    35 import java.awt.datatransfer.*;

    36 import java.beans.*;

    37 import java.io.*;

    38 import java.util.*;

    39 import java.util.regex.*;

    40 import sun.awt.shell.ShellFolder;

    41 import sun.swing.*;

    42 import sun.swing.SwingUtilities2;

    43 

    44 /**

    45  * Basic L&F implementation of a FileChooser.

    46  *

    47  * @author Jeff Dinkins

    48  */

    49 public class BasicFileChooserUI extends FileChooserUI {

    50 

    51     /* FileView icons */

    52     protected Icon directoryIcon = null;

    53     protected Icon fileIcon = null;

    54     protected Icon computerIcon = null;

    55     protected Icon hardDriveIcon = null;

    56     protected Icon floppyDriveIcon = null;

    57 

    58     protected Icon newFolderIcon = null;

    59     protected Icon upFolderIcon = null;

    60     protected Icon homeFolderIcon = null;

    61     protected Icon listViewIcon = null;

    62     protected Icon detailsViewIcon = null;

    63     protected Icon viewMenuIcon = null;

    64 

    65     protected int saveButtonMnemonic = 0;

    66     protected int openButtonMnemonic = 0;

    67     protected int cancelButtonMnemonic = 0;

    68     protected int updateButtonMnemonic = 0;

    69     protected int helpButtonMnemonic = 0;

    70 

    71     /**

    72      * The mnemonic keycode used for the approve button when a directory

    73      * is selected and the current selection mode is FILES_ONLY.

    74      *

    75      * @since 1.4

    76      */

    77     protected int directoryOpenButtonMnemonic = 0;

    78 

    79     protected String saveButtonText = null;

    80     protected String openButtonText = null;

    81     protected String cancelButtonText = null;

    82     protected String updateButtonText = null;

    83     protected String helpButtonText = null;

    84 

    85     /**

    86      * The label text displayed on the approve button when a directory

    87      * is selected and the current selection mode is FILES_ONLY.

    88      *

    89      * @since 1.4

    90      */

    91     protected String directoryOpenButtonText = null;

    92 

    93     private String openDialogTitleText = null;

    94     private String saveDialogTitleText = null;

    95 

    96     protected String saveButtonToolTipText = null;

    97     protected String openButtonToolTipText = null;

    98     protected String cancelButtonToolTipText = null;

    99     protected String updateButtonToolTipText = null;

   100     protected String helpButtonToolTipText = null;

   101 

   102     /**

   103      * The tooltip text displayed on the approve button when a directory

   104      * is selected and the current selection mode is FILES_ONLY.

   105      *

   106      * @since 1.4

   107      */

   108     protected String directoryOpenButtonToolTipText = null;

   109 

   110     // Some generic FileChooser functions

   111     private Action approveSelectionAction = new ApproveSelectionAction();

   112     private Action cancelSelectionAction = new CancelSelectionAction();

   113     private Action updateAction = new UpdateAction();

   114     private Action newFolderAction;

   115     private Action goHomeAction = new GoHomeAction();

   116     private Action changeToParentDirectoryAction = new ChangeToParentDirectoryAction();

   117 

   118     private String newFolderErrorSeparator = null;

   119     private String newFolderErrorText = null;

   120     private String newFolderParentDoesntExistTitleText = null;

   121     private String newFolderParentDoesntExistText = null;

   122     private String fileDescriptionText = null;

   123     private String directoryDescriptionText = null;

   124 

   125     private JFileChooser filechooser = null;

   126 

   127     private boolean directorySelected = false;

   128     private File directory = null;

   129 

   130     private PropertyChangeListener propertyChangeListener = null;

   131     private AcceptAllFileFilter acceptAllFileFilter = new AcceptAllFileFilter();

   132     private FileFilter actualFileFilter = null;

   133     private GlobFilter globFilter = null;

   134     private BasicDirectoryModel model = null;

   135     private BasicFileView fileView = new BasicFileView();

   136     private boolean usesSingleFilePane;

   137     private boolean readOnly;

   138 

   139     // The accessoryPanel is a container to place the JFileChooser accessory component

   140     private JPanel accessoryPanel = null;

   141     private Handler handler;

   142 

   143 

   144     public BasicFileChooserUI(JFileChooser b) {

   145     }

   146 

   147     public void installUI(JComponent c) {

   148         accessoryPanel = new JPanel(new BorderLayout());

   149         filechooser = (JFileChooser) c;

   150 

   151         createModel();

   152 

   153         clearIconCache();

   154 

   155         installDefaults(filechooser);

   156         installComponents(filechooser);

   157         installListeners(filechooser);

   158         filechooser.applyComponentOrientation(filechooser.getComponentOrientation());

   159     }

   160 

   161     public void uninstallUI(JComponent c) {

   162         uninstallListeners((JFileChooser) filechooser);

   163         uninstallComponents((JFileChooser) filechooser);

   164         uninstallDefaults((JFileChooser) filechooser);

   165 

   166         if(accessoryPanel != null) {

   167             accessoryPanel.removeAll();

   168         }

   169 

   170         accessoryPanel = null;

   171         getFileChooser().removeAll();

   172 

   173         handler = null;

   174     }

   175 

   176     public void installComponents(JFileChooser fc) {

   177     }

   178 

   179     public void uninstallComponents(JFileChooser fc) {

   180     }

   181 

   182     protected void installListeners(JFileChooser fc) {

   183         propertyChangeListener = createPropertyChangeListener(fc);

   184         if(propertyChangeListener != null) {

   185             fc.addPropertyChangeListener(propertyChangeListener);

   186         }

   187         fc.addPropertyChangeListener(getModel());

   188 

   189         InputMap inputMap = getInputMap(JComponent.

   190                                         WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

   191         SwingUtilities.replaceUIInputMap(fc, JComponent.

   192                                          WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap);

   193         ActionMap actionMap = getActionMap();

   194         SwingUtilities.replaceUIActionMap(fc, actionMap);

   195     }

   196 

   197     InputMap getInputMap(int condition) {

   198         if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

   199             return (InputMap)DefaultLookup.get(getFileChooser(), this,

   200                     "FileChooser.ancestorInputMap");

   201         }

   202         return null;

   203     }

   204 

   205     ActionMap getActionMap() {

   206         return createActionMap();

   207     }

   208 

   209     ActionMap createActionMap() {

   210         ActionMap map = new ActionMapUIResource();

   211 

   212         Action refreshAction = new UIAction(FilePane.ACTION_REFRESH) {

   213             public void actionPerformed(ActionEvent evt) {

   214                 getFileChooser().rescanCurrentDirectory();

   215             }

   216         };

   217 

   218         map.put(FilePane.ACTION_APPROVE_SELECTION, getApproveSelectionAction());

   219         map.put(FilePane.ACTION_CANCEL, getCancelSelectionAction());

   220         map.put(FilePane.ACTION_REFRESH, refreshAction);

   221         map.put(FilePane.ACTION_CHANGE_TO_PARENT_DIRECTORY,

   222                 getChangeToParentDirectoryAction());

   223         return map;

   224     }

   225 

   226 

   227     protected void uninstallListeners(JFileChooser fc) {

   228         if(propertyChangeListener != null) {

   229             fc.removePropertyChangeListener(propertyChangeListener);

   230         }

   231         fc.removePropertyChangeListener(getModel());

   232         SwingUtilities.replaceUIInputMap(fc, JComponent.

   233                                          WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);

   234         SwingUtilities.replaceUIActionMap(fc, null);

   235     }

   236 

   237 

   238     protected void installDefaults(JFileChooser fc) {

   239         installIcons(fc);

   240         installStrings(fc);

   241         usesSingleFilePane = UIManager.getBoolean("FileChooser.usesSingleFilePane");

   242         readOnly           = UIManager.getBoolean("FileChooser.readOnly");

   243         TransferHandler th = fc.getTransferHandler();

   244         if (th == null || th instanceof UIResource) {

   245             fc.setTransferHandler(defaultTransferHandler);

   246         }

   247         LookAndFeel.installProperty(fc, "opaque", Boolean.FALSE);

   248     }

   249 

   250     protected void installIcons(JFileChooser fc) {

   251         directoryIcon    = UIManager.getIcon("FileView.directoryIcon");

   252         fileIcon         = UIManager.getIcon("FileView.fileIcon");

   253         computerIcon     = UIManager.getIcon("FileView.computerIcon");

   254         hardDriveIcon    = UIManager.getIcon("FileView.hardDriveIcon");

   255         floppyDriveIcon  = UIManager.getIcon("FileView.floppyDriveIcon");

   256 

   257         newFolderIcon    = UIManager.getIcon("FileChooser.newFolderIcon");

   258         upFolderIcon     = UIManager.getIcon("FileChooser.upFolderIcon");

   259         homeFolderIcon   = UIManager.getIcon("FileChooser.homeFolderIcon");

   260         detailsViewIcon  = UIManager.getIcon("FileChooser.detailsViewIcon");

   261         listViewIcon     = UIManager.getIcon("FileChooser.listViewIcon");

   262         viewMenuIcon     = UIManager.getIcon("FileChooser.viewMenuIcon");

   263     }

   264 

   265     protected void installStrings(JFileChooser fc) {

   266 

   267         Locale l = fc.getLocale();

   268         newFolderErrorText = UIManager.getString("FileChooser.newFolderErrorText",l);

   269         newFolderErrorSeparator = UIManager.getString("FileChooser.newFolderErrorSeparator",l);

   270 

   271         newFolderParentDoesntExistTitleText = UIManager.getString("FileChooser.newFolderParentDoesntExistTitleText", l);

   272         newFolderParentDoesntExistText = UIManager.getString("FileChooser.newFolderParentDoesntExistText", l);

   273 

   274         fileDescriptionText = UIManager.getString("FileChooser.fileDescriptionText",l);

   275         directoryDescriptionText = UIManager.getString("FileChooser.directoryDescriptionText",l);

   276 

   277         saveButtonText   = UIManager.getString("FileChooser.saveButtonText",l);

   278         openButtonText   = UIManager.getString("FileChooser.openButtonText",l);

   279         saveDialogTitleText = UIManager.getString("FileChooser.saveDialogTitleText",l);

   280         openDialogTitleText = UIManager.getString("FileChooser.openDialogTitleText",l);

   281         cancelButtonText = UIManager.getString("FileChooser.cancelButtonText",l);

   282         updateButtonText = UIManager.getString("FileChooser.updateButtonText",l);

   283         helpButtonText   = UIManager.getString("FileChooser.helpButtonText",l);

   284         directoryOpenButtonText = UIManager.getString("FileChooser.directoryOpenButtonText",l);

   285 

   286         saveButtonMnemonic   = getMnemonic("FileChooser.saveButtonMnemonic", l);

   287         openButtonMnemonic   = getMnemonic("FileChooser.openButtonMnemonic", l);

   288         cancelButtonMnemonic = getMnemonic("FileChooser.cancelButtonMnemonic", l);

   289         updateButtonMnemonic = getMnemonic("FileChooser.updateButtonMnemonic", l);

   290         helpButtonMnemonic   = getMnemonic("FileChooser.helpButtonMnemonic", l);

   291         directoryOpenButtonMnemonic = getMnemonic("FileChooser.directoryOpenButtonMnemonic", l);

   292 

   293         saveButtonToolTipText   = UIManager.getString("FileChooser.saveButtonToolTipText",l);

   294         openButtonToolTipText   = UIManager.getString("FileChooser.openButtonToolTipText",l);

   295         cancelButtonToolTipText = UIManager.getString("FileChooser.cancelButtonToolTipText",l);

   296         updateButtonToolTipText = UIManager.getString("FileChooser.updateButtonToolTipText",l);

   297         helpButtonToolTipText   = UIManager.getString("FileChooser.helpButtonToolTipText",l);

   298         directoryOpenButtonToolTipText = UIManager.getString("FileChooser.directoryOpenButtonToolTipText",l);

   299     }

   300 

   301     protected void uninstallDefaults(JFileChooser fc) {

   302         uninstallIcons(fc);

   303         uninstallStrings(fc);

   304         if (fc.getTransferHandler() instanceof UIResource) {

   305             fc.setTransferHandler(null);

   306         }

   307     }

   308 

   309     protected void uninstallIcons(JFileChooser fc) {

   310         directoryIcon    = null;

   311         fileIcon         = null;

   312         computerIcon     = null;

   313         hardDriveIcon    = null;

   314         floppyDriveIcon  = null;

   315 

   316         newFolderIcon    = null;

   317         upFolderIcon     = null;

   318         homeFolderIcon   = null;

   319         detailsViewIcon  = null;

   320         listViewIcon     = null;

   321         viewMenuIcon     = null;

   322     }

   323 

   324     protected void uninstallStrings(JFileChooser fc) {

   325         saveButtonText   = null;

   326         openButtonText   = null;

   327         cancelButtonText = null;

   328         updateButtonText = null;

   329         helpButtonText   = null;

   330         directoryOpenButtonText = null;

   331 

   332         saveButtonToolTipText = null;

   333         openButtonToolTipText = null;

   334         cancelButtonToolTipText = null;

   335         updateButtonToolTipText = null;

   336         helpButtonToolTipText = null;

   337         directoryOpenButtonToolTipText = null;

   338     }

   339 

   340     protected void createModel() {

   341         if (model != null) {

   342             model.invalidateFileCache();

   343         }

   344         model = new BasicDirectoryModel(getFileChooser());

   345     }

   346 

   347     public BasicDirectoryModel getModel() {

   348         return model;

   349     }

   350 

   351     public PropertyChangeListener createPropertyChangeListener(JFileChooser fc) {

   352         return null;

   353     }

   354 

   355     public String getFileName() {

   356         return null;

   357     }

   358 

   359     public String getDirectoryName() {

   360         return null;

   361     }

   362 

   363     public void setFileName(String filename) {

   364     }

   365 

   366     public void setDirectoryName(String dirname) {

   367     }

   368 

   369     public void rescanCurrentDirectory(JFileChooser fc) {

   370     }

   371 

   372     public void ensureFileIsVisible(JFileChooser fc, File f) {

   373     }

   374 

   375     public JFileChooser getFileChooser() {

   376         return filechooser;

   377     }

   378 

   379     public JPanel getAccessoryPanel() {

   380         return accessoryPanel;

   381     }

   382 

   383     protected JButton getApproveButton(JFileChooser fc) {

   384         return null;

   385     }

   386 

   387     public String getApproveButtonToolTipText(JFileChooser fc) {

   388         String tooltipText = fc.getApproveButtonToolTipText();

   389         if(tooltipText != null) {

   390             return tooltipText;

   391         }

   392 

   393         if(fc.getDialogType() == JFileChooser.OPEN_DIALOG) {

   394             return openButtonToolTipText;

   395         } else if(fc.getDialogType() == JFileChooser.SAVE_DIALOG) {

   396             return saveButtonToolTipText;

   397         }

   398         return null;

   399     }

   400 

   401     public void clearIconCache() {

   402         fileView.clearIconCache();

   403     }

   404 

   405 

   406     // ********************************************

   407     // ************ Create Listeners **************

   408     // ********************************************

   409 

   410     private Handler getHandler() {

   411         if (handler == null) {

   412             handler = new Handler();

   413         }

   414         return handler;

   415     }

   416 

   417     protected MouseListener createDoubleClickListener(JFileChooser fc,

   418                                                       JList list) {

   419         return new Handler(list);

   420     }

   421 

   422     public ListSelectionListener createListSelectionListener(JFileChooser fc) {

   423         return getHandler();

   424     }

   425 

   426     private class Handler implements MouseListener, ListSelectionListener {

   427         JList list;

   428 

   429         Handler() {

   430         }

   431 

   432         Handler(JList list) {

   433             this.list = list;

   434         }

   435 

   436         public void mouseClicked(MouseEvent evt) {

   437             // Note: we can't depend on evt.getSource() because of backward

   438             // compatability

   439             if (list != null &&

   440                 SwingUtilities.isLeftMouseButton(evt) &&

   441                 (evt.getClickCount()%2 == 0)) {

   442 

   443                 int index = SwingUtilities2.loc2IndexFileList(list, evt.getPoint());

   444                 if (index >= 0) {

   445                     File f = (File)list.getModel().getElementAt(index);

   446                     try {

   447                         // Strip trailing ".."

   448                         f = ShellFolder.getNormalizedFile(f);

   449                     } catch (IOException ex) {

   450                         // That's ok, we'll use f as is

   451                     }

   452                     if(getFileChooser().isTraversable(f)) {

   453                         list.clearSelection();

   454                         changeDirectory(f);

   455                     } else {

   456                         getFileChooser().approveSelection();

   457                     }

   458                 }

   459             }

   460         }

   461 

   462         public void mouseEntered(MouseEvent evt) {

   463             if (list != null) {

   464                 TransferHandler th1 = getFileChooser().getTransferHandler();

   465                 TransferHandler th2 = list.getTransferHandler();

   466                 if (th1 != th2) {

   467                     list.setTransferHandler(th1);

   468                 }

   469                 if (getFileChooser().getDragEnabled() != list.getDragEnabled()) {

   470                     list.setDragEnabled(getFileChooser().getDragEnabled());

   471                 }

   472             }

   473         }

   474 

   475         public void mouseExited(MouseEvent evt) {

   476         }

   477 

   478         public void mousePressed(MouseEvent evt) {

   479         }

   480 

   481         public void mouseReleased(MouseEvent evt) {

   482         }

   483 

   484         public void valueChanged(ListSelectionEvent evt) {

   485             if(!evt.getValueIsAdjusting()) {

   486                 JFileChooser chooser = getFileChooser();

   487                 FileSystemView fsv = chooser.getFileSystemView();

   488                 JList list = (JList)evt.getSource();

   489 

   490                 int fsm = chooser.getFileSelectionMode();

   491                 boolean useSetDirectory = usesSingleFilePane &&

   492                                           (fsm == JFileChooser.FILES_ONLY);

   493 

   494                 if (chooser.isMultiSelectionEnabled()) {

   495                     File[] files = null;

   496                     Object[] objects = list.getSelectedValues();

   497                     if (objects != null) {

   498                         if (objects.length == 1

   499                             && ((File)objects[0]).isDirectory()

   500                             && chooser.isTraversable(((File)objects[0]))

   501                             && (useSetDirectory || !fsv.isFileSystem(((File)objects[0])))) {

   502                             setDirectorySelected(true);

   503                             setDirectory(((File)objects[0]));

   504                         } else {

   505                             ArrayList fList = new ArrayList(objects.length);

   506                             for (int i = 0; i < objects.length; i++) {

   507                                 File f = (File)objects[i];

   508                                 boolean isDir = f.isDirectory();

   509                                 if ((chooser.isFileSelectionEnabled() && !isDir)

   510                                     || (chooser.isDirectorySelectionEnabled()

   511                                         && fsv.isFileSystem(f)

   512                                         && isDir)) {

   513                                     fList.add(f);

   514                                 }

   515                             }

   516                             if (fList.size() > 0) {

   517                                 files = (File[])fList.toArray(new File[fList.size()]);

   518                             }

   519                             setDirectorySelected(false);

   520                         }

   521                     }

   522                     chooser.setSelectedFiles(files);

   523                 } else {

   524                     File file = (File)list.getSelectedValue();

   525                     if (file != null

   526                         && file.isDirectory()

   527                         && chooser.isTraversable(file)

   528                         && (useSetDirectory || !fsv.isFileSystem(file))) {

   529 

   530                         setDirectorySelected(true);

   531                         setDirectory(file);

   532                         if (usesSingleFilePane) {

   533                             chooser.setSelectedFile(null);

   534                         }

   535                     } else {

   536                         setDirectorySelected(false);

   537                         if (file != null) {

   538                             chooser.setSelectedFile(file);

   539                         }

   540                     }

   541                 }

   542             }

   543         }

   544     }

   545 

   546     protected class DoubleClickListener extends MouseAdapter {

   547         // NOTE: This class exists only for backward compatability. All

   548         // its functionality has been moved into Handler. If you need to add

   549         // new functionality add it to the Handler, but make sure this

   550         // class calls into the Handler.

   551         Handler handler;

   552         public  DoubleClickListener(JList list) {

   553             handler = new Handler(list);

   554         }

   555 

   556         /**

   557          * The JList used for representing the files is created by subclasses, but the

   558          * selection is monitored in this class.  The TransferHandler installed in the

   559          * JFileChooser is also installed in the file list as it is used as the actual

   560          * transfer source.  The list is updated on a mouse enter to reflect the current

   561          * data transfer state of the file chooser.

   562          */

   563         public void mouseEntered(MouseEvent e) {

   564             handler.mouseEntered(e);

   565         }

   566 

   567         public void mouseClicked(MouseEvent e) {

   568             handler.mouseClicked(e);

   569         }

   570     }

   571 

   572     protected class SelectionListener implements ListSelectionListener {

   573         // NOTE: This class exists only for backward compatability. All

   574         // its functionality has been moved into Handler. If you need to add

   575         // new functionality add it to the Handler, but make sure this

   576         // class calls into the Handler.

   577         public void valueChanged(ListSelectionEvent e) {

   578             getHandler().valueChanged(e);

   579         }

   580     }

   581 

   582     /**

   583      * Property to remember whether a directory is currently selected in the UI.

   584      *

   585      * @return <code>true</code> iff a directory is currently selected.

   586      * @since 1.4

   587      */

   588     protected boolean isDirectorySelected() {

   589         return directorySelected;

   590     }

   591 

   592     /**

   593      * Property to remember whether a directory is currently selected in the UI.

   594      * This is normally called by the UI on a selection event.

   595      *

   596      * @param b iff a directory is currently selected.

   597      * @since 1.4

   598      */

   599     protected void setDirectorySelected(boolean b) {

   600         directorySelected = b;

   601     }

   602 

   603     /**

   604      * Property to remember the directory that is currently selected in the UI.

   605      *

   606      * @return the value of the <code>directory</code> property

   607      * @see #setDirectory

   608      * @since 1.4

   609      */

   610     protected File getDirectory() {

   611         return directory;

   612     }

   613 

   614     /**

   615      * Property to remember the directory that is currently selected in the UI.

   616      * This is normally called by the UI on a selection event.

   617      *

   618      * @param f the <code>File</code> object representing the directory that is

   619      *          currently selected

   620      * @since 1.4

   621      */

   622     protected void setDirectory(File f) {

   623         directory = f;

   624     }

   625 

   626     /**

   627      * Returns the mnemonic for the given key.

   628      */

   629     private int getMnemonic(String key, Locale l) {

   630         return SwingUtilities2.getUIDefaultsInt(key, l);

   631     }

   632 

   633     // *******************************************************

   634     // ************ FileChooser UI PLAF methods **************

   635     // *******************************************************

   636 

   637     /**

   638      * Returns the default accept all file filter

   639      */

   640     public FileFilter getAcceptAllFileFilter(JFileChooser fc) {

   641         return acceptAllFileFilter;

   642     }

   643 

   644 

   645     public FileView getFileView(JFileChooser fc) {

   646         return fileView;

   647     }

   648 

   649 

   650     /**

   651      * Returns the title of this dialog

   652      */

   653     public String getDialogTitle(JFileChooser fc) {

   654         String dialogTitle = fc.getDialogTitle();

   655         if (dialogTitle != null) {

   656             return dialogTitle;

   657         } else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {

   658             return openDialogTitleText;

   659         } else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {

   660             return saveDialogTitleText;

   661         } else {

   662             return getApproveButtonText(fc);

   663         }

   664     }

   665 

   666 

   667     public int getApproveButtonMnemonic(JFileChooser fc) {

   668         int mnemonic = fc.getApproveButtonMnemonic();

   669         if (mnemonic > 0) {

   670             return mnemonic;

   671         } else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {

   672             return openButtonMnemonic;

   673         } else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {

   674             return saveButtonMnemonic;

   675         } else {

   676             return mnemonic;

   677         }

   678     }

   679 

   680     public String getApproveButtonText(JFileChooser fc) {

   681         String buttonText = fc.getApproveButtonText();

   682         if (buttonText != null) {

   683             return buttonText;

   684         } else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {

   685             return openButtonText;

   686         } else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {

   687             return saveButtonText;

   688         } else {

   689             return null;

   690         }

   691     }

   692 

   693 

   694     // *****************************

   695     // ***** Directory Actions *****

   696     // *****************************

   697 

   698     public Action getNewFolderAction() {

   699         if (newFolderAction == null) {

   700             newFolderAction = new NewFolderAction();

   701             // Note: Don't return null for readOnly, it might

   702             // break older apps.

   703             if (readOnly) {

   704                 newFolderAction.setEnabled(false);

   705             }

   706         }

   707         return newFolderAction;

   708     }

   709 

   710     public Action getGoHomeAction() {

   711         return goHomeAction;

   712     }

   713 

   714     public Action getChangeToParentDirectoryAction() {

   715         return changeToParentDirectoryAction;

   716     }

   717 

   718     public Action getApproveSelectionAction() {

   719         return approveSelectionAction;

   720     }

   721 

   722     public Action getCancelSelectionAction() {

   723         return cancelSelectionAction;

   724     }

   725 

   726     public Action getUpdateAction() {

   727         return updateAction;

   728     }

   729 

   730 

   731     /**

   732      * Creates a new folder.

   733      */

   734     protected class NewFolderAction extends AbstractAction {

   735         protected NewFolderAction() {

   736             super(FilePane.ACTION_NEW_FOLDER);

   737         }

   738         public void actionPerformed(ActionEvent e) {

   739             if (readOnly) {

   740                 return;

   741             }

   742             JFileChooser fc = getFileChooser();

   743             File currentDirectory = fc.getCurrentDirectory();

   744 

   745             if (!currentDirectory.exists()) {

   746                 JOptionPane.showMessageDialog(

   747                     fc,

   748                     newFolderParentDoesntExistText,

   749                     newFolderParentDoesntExistTitleText, JOptionPane.WARNING_MESSAGE);

   750                 return;

   751             }

   752 

   753             File newFolder;

   754             try {

   755                 newFolder = fc.getFileSystemView().createNewFolder(currentDirectory);

   756                 if (fc.isMultiSelectionEnabled()) {

   757                     fc.setSelectedFiles(new File[] { newFolder });

   758                 } else {

   759                     fc.setSelectedFile(newFolder);

   760                 }

   761             } catch (IOException exc) {

   762                 JOptionPane.showMessageDialog(

   763                     fc,

   764                     newFolderErrorText + newFolderErrorSeparator + exc,

   765                     newFolderErrorText, JOptionPane.ERROR_MESSAGE);

   766                 return;

   767             }

   768 

   769             fc.rescanCurrentDirectory();

   770         }

   771     }

   772 

   773     /**

   774      * Acts on the "home" key event or equivalent event.

   775      */

   776     protected class GoHomeAction extends AbstractAction {

   777         protected GoHomeAction() {

   778             super("Go Home");

   779         }

   780         public void actionPerformed(ActionEvent e) {

   781             JFileChooser fc = getFileChooser();

   782             changeDirectory(fc.getFileSystemView().getHomeDirectory());

   783         }

   784     }

   785 

   786     protected class ChangeToParentDirectoryAction extends AbstractAction {

   787         protected ChangeToParentDirectoryAction() {

   788             super("Go Up");

   789             putValue(Action.ACTION_COMMAND_KEY, FilePane.ACTION_CHANGE_TO_PARENT_DIRECTORY);

   790         }

   791         public void actionPerformed(ActionEvent e) {

   792             Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();

   793             if (focusOwner == null || !(focusOwner instanceof javax.swing.text.JTextComponent)) {

   794                 getFileChooser().changeToParentDirectory();

   795             }

   796         }

   797     }

   798 

   799     /**

   800      * Responds to an Open or Save request

   801      */

   802     protected class ApproveSelectionAction extends AbstractAction {

   803         protected ApproveSelectionAction() {

   804             super(FilePane.ACTION_APPROVE_SELECTION);

   805         }

   806         public void actionPerformed(ActionEvent e) {

   807             if (isDirectorySelected()) {

   808                 File dir = getDirectory();

   809                 if (dir != null) {

   810                     try {

   811                         // Strip trailing ".."

   812                         dir = ShellFolder.getNormalizedFile(dir);

   813                     } catch (IOException ex) {

   814                         // Ok, use f as is

   815                     }

   816                     changeDirectory(dir);

   817                     return;

   818                 }

   819             }

   820 

   821             JFileChooser chooser = getFileChooser();

   822 

   823             String filename = getFileName();

   824             FileSystemView fs = chooser.getFileSystemView();

   825             File dir = chooser.getCurrentDirectory();

   826 

   827             if (filename != null) {

   828                 // Remove whitespace from beginning and end of filename

   829                 filename = filename.trim();

   830             }

   831 

   832             if (filename == null || filename.equals("")) {

   833                 // no file selected, multiple selection off, therefore cancel the approve action

   834                 resetGlobFilter();

   835                 return;

   836             }

   837 

   838             File selectedFile = null;

   839             File[] selectedFiles = null;

   840 

   841             if (filename != null && !filename.equals("")) {

   842                 // Unix: Resolve '~' to user's home directory

   843                 if (File.separatorChar == '/') {

   844                     if (filename.startsWith("~/")) {

   845                         filename = System.getProperty("user.home") + filename.substring(1);

   846                     } else if (filename.equals("~")) {

   847                         filename = System.getProperty("user.home");

   848                     }

   849                 }

   850 

   851                 if (chooser.isMultiSelectionEnabled() && filename.startsWith("\"")) {

   852                     ArrayList fList = new ArrayList();

   853 

   854                     filename = filename.substring(1);

   855                     if (filename.endsWith("\"")) {

   856                         filename = filename.substring(0, filename.length()-1);

   857                     }

   858                     File[] children = null;

   859                     int childIndex = 0;

   860                     do {

   861                         String str;

   862                         int i = filename.indexOf("\" \"");

   863                         if (i > 0) {

   864                             str = filename.substring(0, i);

   865                             filename = filename.substring(i+3);

   866                         } else {

   867                             str = filename;

   868                             filename = "";

   869                         }

   870                         File file = fs.createFileObject(str);

   871                         if (!file.isAbsolute()) {

   872                             if (children == null) {

   873                                 children = fs.getFiles(dir, false);

   874                                 Arrays.sort(children);

   875                             }

   876                             for (int k = 0; k < children.length; k++) {

   877                                 int l = (childIndex + k) % children.length;

   878                                 if (children[l].getName().equals(str)) {

   879                                     file = children[l];

   880                                     childIndex = l + 1;

   881                                     break;

   882                                 }

   883                             }

   884                         }

   885                         fList.add(file);

   886                     } while (filename.length() > 0);

   887                     if (fList.size() > 0) {

   888                         selectedFiles = (File[])fList.toArray(new File[fList.size()]);

   889                     }

   890                     resetGlobFilter();

   891                 } else {

   892                     selectedFile = fs.createFileObject(filename);

   893                     if(!selectedFile.isAbsolute()) {

   894                        selectedFile = fs.getChild(dir, filename);

   895                     }

   896                     // check for wildcard pattern

   897                     FileFilter currentFilter = chooser.getFileFilter();

   898                     if (!selectedFile.exists() && isGlobPattern(filename)) {

   899                         changeDirectory(selectedFile.getParentFile());

   900                         if (globFilter == null) {

   901                             globFilter = new GlobFilter();

   902                         }

   903                         try {

   904                             globFilter.setPattern(selectedFile.getName());

   905                             if (!(currentFilter instanceof GlobFilter)) {

   906                                 actualFileFilter = currentFilter;

   907                             }

   908                             chooser.setFileFilter(null);

   909                             chooser.setFileFilter(globFilter);

   910                             return;

   911                         } catch (PatternSyntaxException pse) {

   912                             // Not a valid glob pattern. Abandon filter.

   913                         }

   914                     }

   915 

   916                     resetGlobFilter();

   917 

   918                     // Check for directory change action

   919                     boolean isDir = (selectedFile != null && selectedFile.isDirectory());

   920                     boolean isTrav = (selectedFile != null && chooser.isTraversable(selectedFile));

   921                     boolean isDirSelEnabled = chooser.isDirectorySelectionEnabled();

   922                     boolean isFileSelEnabled = chooser.isFileSelectionEnabled();

   923                     boolean isCtrl = (e != null && (e.getModifiers() & ActionEvent.CTRL_MASK) != 0);

   924 

   925                     if (isDir && isTrav && (isCtrl || !isDirSelEnabled)) {

   926                         changeDirectory(selectedFile);

   927                         return;

   928                     } else if ((isDir || !isFileSelEnabled)

   929                                && (!isDir || !isDirSelEnabled)

   930                                && (!isDirSelEnabled || selectedFile.exists())) {

   931                         selectedFile = null;

   932                     }

   933                 }

   934             }

   935             if (selectedFiles != null || selectedFile != null) {

   936                 if (selectedFiles != null || chooser.isMultiSelectionEnabled()) {

   937                     if (selectedFiles == null) {

   938                         selectedFiles = new File[] { selectedFile };

   939                     }

   940                     chooser.setSelectedFiles(selectedFiles);

   941                     // Do it again. This is a fix for bug 4949273 to force the

   942                     // selected value in case the ListSelectionModel clears it

   943                     // for non-existing file names.

   944                     chooser.setSelectedFiles(selectedFiles);

   945                 } else {

   946                     chooser.setSelectedFile(selectedFile);

   947                 }

   948                 chooser.approveSelection();

   949             } else {

   950                 if (chooser.isMultiSelectionEnabled()) {

   951                     chooser.setSelectedFiles(null);

   952                 } else {

   953                     chooser.setSelectedFile(null);

   954                 }

   955                 chooser.cancelSelection();

   956             }

   957         }

   958     }

   959 

   960 

   961     private void resetGlobFilter() {

   962         if (actualFileFilter != null) {

   963             JFileChooser chooser = getFileChooser();

   964             FileFilter currentFilter = chooser.getFileFilter();

   965             if (currentFilter != null && currentFilter.equals(globFilter)) {

   966                 chooser.setFileFilter(actualFileFilter);

   967                 chooser.removeChoosableFileFilter(globFilter);

   968             }

   969             actualFileFilter = null;

   970         }

   971     }

   972 

   973     private static boolean isGlobPattern(String filename) {

   974         return ((File.separatorChar == '\\' && (filename.indexOf('*') >= 0

   975                                                   || filename.indexOf('?') >= 0))

   976                 || (File.separatorChar == '/' && (filename.indexOf('*') >= 0

   977                                                   || filename.indexOf('?') >= 0

   978                                                   || filename.indexOf('[') >= 0)));

   979     }

   980 

   981 

   982     /* A file filter which accepts file patterns containing

   983      * the special wildcards *? on Windows and *?[] on Unix.

   984      */

   985     class GlobFilter extends FileFilter {

   986         Pattern pattern;

   987         String globPattern;

   988 

   989         public void setPattern(String globPattern) {

   990             char[] gPat = globPattern.toCharArray();

   991             char[] rPat = new char[gPat.length * 2];

   992             boolean isWin32 = (File.separatorChar == '\\');

   993             boolean inBrackets = false;

   994             int j = 0;

   995 

   996             this.globPattern = globPattern;

   997 

   998             if (isWin32) {

   999                 // On windows, a pattern ending with *.* is equal to ending with *

  1000                 int len = gPat.length;

  1001                 if (globPattern.endsWith("*.*")) {

  1002                     len -= 2;

  1003                 }

  1004                 for (int i = 0; i < len; i++) {

  1005                     switch(gPat[i]) {

  1006                       case '*':

  1007                         rPat[j++] = '.';

  1008                         rPat[j++] = '*';

  1009                         break;

  1010 

  1011                       case '?':

  1012                         rPat[j++] = '.';

  1013                         break;

  1014 

  1015                       case '\\':

  1016                         rPat[j++] = '\\';

  1017                         rPat[j++] = '\\';

  1018                         break;

  1019 

  1020                       default:

  1021                         if ("+()^$.{}[]".indexOf(gPat[i]) >= 0) {

  1022                             rPat[j++] = '\\';

  1023                         }

  1024                         rPat[j++] = gPat[i];

  1025                         break;

  1026                     }

  1027                 }

  1028             } else {

  1029                 for (int i = 0; i < gPat.length; i++) {

  1030                     switch(gPat[i]) {

  1031                       case '*':

  1032                         if (!inBrackets) {

  1033                             rPat[j++] = '.';

  1034                         }

  1035                         rPat[j++] = '*';

  1036                         break;

  1037 

  1038                       case '?':

  1039                         rPat[j++] = inBrackets ? '?' : '.';

  1040                         break;

  1041 

  1042                       case '[':

  1043                         inBrackets = true;

  1044                         rPat[j++] = gPat[i];

  1045 

  1046                         if (i < gPat.length - 1) {

  1047                             switch (gPat[i+1]) {

  1048                               case '!':

  1049                               case '^':

  1050                                 rPat[j++] = '^';

  1051                                 i++;

  1052                                 break;

  1053 

  1054                               case ']':

  1055                                 rPat[j++] = gPat[++i];

  1056                                 break;

  1057                             }

  1058                         }

  1059                         break;

  1060 

  1061                       case ']':

  1062                         rPat[j++] = gPat[i];

  1063                         inBrackets = false;

  1064                         break;

  1065 

  1066                       case '\\':

  1067                         if (i == 0 && gPat.length > 1 && gPat[1] == '~') {

  1068                             rPat[j++] = gPat[++i];

  1069                         } else {

  1070                             rPat[j++] = '\\';

  1071                             if (i < gPat.length - 1 && "*?[]".indexOf(gPat[i+1]) >= 0) {

  1072                                 rPat[j++] = gPat[++i];

  1073                             } else {

  1074                                 rPat[j++] = '\\';

  1075                             }

  1076                         }

  1077                         break;

  1078 

  1079                       default:

  1080                         //if ("+()|^$.{}<>".indexOf(gPat[i]) >= 0) {

  1081                         if (!Character.isLetterOrDigit(gPat[i])) {

  1082                             rPat[j++] = '\\';

  1083                         }

  1084                         rPat[j++] = gPat[i];

  1085                         break;

  1086                     }

  1087                 }

  1088             }

  1089             this.pattern = Pattern.compile(new String(rPat, 0, j), Pattern.CASE_INSENSITIVE);

  1090         }

  1091 

  1092         public boolean accept(File f) {

  1093             if (f == null) {

  1094                 return false;

  1095             }

  1096             if (f.isDirectory()) {

  1097                 return true;

  1098             }

  1099             return pattern.matcher(f.getName()).matches();

  1100         }

  1101 

  1102         public String getDescription() {

  1103             return globPattern;

  1104         }

  1105     }

  1106 

  1107     /**

  1108      * Responds to a cancel request.

  1109      */

  1110     protected class CancelSelectionAction extends AbstractAction {

  1111         public void actionPerformed(ActionEvent e) {

  1112             getFileChooser().cancelSelection();

  1113         }

  1114     }

  1115 

  1116     /**

  1117      * Rescans the files in the current directory

  1118      */

  1119     protected class UpdateAction extends AbstractAction {

  1120         public void actionPerformed(ActionEvent e) {

  1121             JFileChooser fc = getFileChooser();

  1122             fc.setCurrentDirectory(fc.getFileSystemView().createFileObject(getDirectoryName()));

  1123             fc.rescanCurrentDirectory();

  1124         }

  1125     }

  1126 

  1127 

  1128     private void changeDirectory(File dir) {

  1129         JFileChooser fc = getFileChooser();

  1130         // Traverse shortcuts on Windows

  1131         if (dir != null && File.separatorChar == '\\' && dir.getPath().endsWith(".lnk")) {

  1132             try {

  1133                 File linkedTo = ShellFolder.getShellFolder(dir).getLinkLocation();

  1134                 if (linkedTo != null && fc.isTraversable(linkedTo)) {

  1135                     dir = linkedTo;