src/jalview/io/JalviewFileChooser.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 //////////////////////////////////////////////////////////////////
  22 package jalview.io;
  23
  24 import jalview.bin.Cache;
  25 import jalview.gui.JvOptionPane;
  26 import jalview.util.MessageManager;
  27 import jalview.util.Platform;
  28
  29 import java.awt.Component;
  30 import java.awt.Dimension;
  31 import java.awt.EventQueue;
  32 import java.awt.HeadlessException;
  33 import java.awt.event.ActionEvent;
  34 import java.awt.event.ActionListener;
  35 import java.awt.event.MouseAdapter;
  36 import java.awt.event.MouseEvent;
  37 import java.io.File;
  38 import java.util.ArrayList;
  39 import java.util.List;
  40 import java.util.StringTokenizer;
  41 import java.util.Vector;
  42
  43 import javax.swing.BoxLayout;
  44 import javax.swing.DefaultListCellRenderer;
  45 import javax.swing.JCheckBox;
  46 import javax.swing.JFileChooser;
  47 import javax.swing.JList;
  48 import javax.swing.JPanel;
  49 import javax.swing.JScrollPane;
  50 import javax.swing.SpringLayout;
  51 import javax.swing.SwingUtilities;
  52 import javax.swing.border.TitledBorder;
  53 import javax.swing.filechooser.FileFilter;
  54 import javax.swing.plaf.basic.BasicFileChooserUI;
  55
  56 /**
  57  * Enhanced file chooser dialog box.
  58  *
  59  * NOTE: bug on Windows systems when filechooser opened on directory to view
  60  * files with colons in title.
  61  *
  62  * @author AMW
  63  *
  64  */
  65 public class JalviewFileChooser extends JFileChooser
  66 {
  67   /**
  68    * backupfilesCheckBox = "Include backup files" checkbox includeBackupfiles =
  69    * flag set by checkbox
  70    */
  71   private JCheckBox backupfilesCheckBox = null;
  72
  73   protected boolean includeBackupFiles = false;
  74
  75   /**
  76    * Factory method to return a file chooser that offers readable alignment file
  77    * formats
  78    *
  79    * @param directory
  80    * @param selected
  81    * @return
  82    */
  83   public static JalviewFileChooser forRead(String directory,
  84           String selected)
  85   {
  86     return JalviewFileChooser.forRead(directory, selected, false);
  87   }
  88
  89   public static JalviewFileChooser forRead(String directory,
  90           String selected, boolean allowBackupFiles)
  91   {
  92     List<String> extensions = new ArrayList<>();
  93     List<String> descs = new ArrayList<>();
  94     for (FileFormatI format : FileFormats.getInstance().getFormats())
  95     {
  96       if (format.isReadable())
  97       {
  98         extensions.add(format.getExtensions());
  99         descs.add(format.getName());
 100       }
 101     }
 102
 103     return new JalviewFileChooser(directory,
 104             extensions.toArray(new String[extensions.size()]),
 105             descs.toArray(new String[descs.size()]), selected, true,
 106             allowBackupFiles);
 107   }
 108
 109   /**
 110    * Factory method to return a file chooser that offers writable alignment file
 111    * formats
 112    *
 113    * @param directory
 114    * @param selected
 115    * @return
 116    */
 117   public static JalviewFileChooser forWrite(String directory,
 118           String selected)
 119   {
 120     // TODO in Java 8, forRead and forWrite can be a single method
 121     // with a lambda expression parameter for isReadable/isWritable
 122     List<String> extensions = new ArrayList<>();
 123     List<String> descs = new ArrayList<>();
 124     for (FileFormatI format : FileFormats.getInstance().getFormats())
 125     {
 126       if (format.isWritable())
 127       {
 128         extensions.add(format.getExtensions());
 129         descs.add(format.getName());
 130       }
 131     }
 132     return new JalviewFileChooser(directory,
 133             extensions.toArray(new String[extensions.size()]),
 134             descs.toArray(new String[descs.size()]), selected, false);
 135   }
 136
 137   public JalviewFileChooser(String dir)
 138   {
 139     super(safePath(dir));
 140     setAccessory(new RecentlyOpened());
 141   }
 142
 143   public JalviewFileChooser(String dir, String[] suffix, String[] desc,
 144           String selected)
 145   {
 146     this(dir, suffix, desc, selected, true);
 147   }
 148
 149   /**
 150    * Constructor for a single choice of file extension and description
 151    *
 152    * @param extension
 153    * @param desc
 154    */
 155   public JalviewFileChooser(String extension, String desc)
 156   {
 157     this(Cache.getProperty("LAST_DIRECTORY"), new String[] { extension },
 158             new String[]
 159             { desc }, desc, true);
 160   }
 161
 162   JalviewFileChooser(String dir, String[] extensions, String[] descs,
 163           String selected, boolean allFiles)
 164   {
 165     this(dir, extensions, descs, selected, allFiles, false);
 166   }
 167
 168   public JalviewFileChooser(String dir, String[] extensions, String[] descs,
 169           String selected, boolean allFiles, boolean allowBackupFiles)
 170   {
 171     super(safePath(dir));
 172     if (extensions.length == descs.length)
 173     {
 174       List<String[]> formats = new ArrayList<>();
 175       for (int i = 0; i < extensions.length; i++)
 176       {
 177         formats.add(new String[] { extensions[i], descs[i] });
 178       }
 179       init(formats, selected, allFiles, allowBackupFiles);
 180     }
 181     else
 182     {
 183       System.err.println("JalviewFileChooser arguments mismatch: "
 184               + extensions + ", " + descs);
 185     }
 186   }
 187
 188   private static File safePath(String dir)
 189   {
 190     if (dir == null)
 191     {
 192       return null;
 193     }
 194
 195     File f = new File(dir);
 196     if (f.getName().indexOf(':') > -1)
 197     {
 198       return null;
 199     }
 200     return f;
 201   }
 202
 203   /**
 204    *
 205    * @param formats
 206    *          a list of {extensions, description} for each file format
 207    * @param selected
 208    * @param allFiles
 209    *          if true, 'any format' option is included
 210    */
 211   void init(List<String[]> formats, String selected, boolean allFiles)
 212   {
 213     init(formats, selected, allFiles, false);
 214   }
 215
 216   void init(List<String[]> formats, String selected, boolean allFiles,
 217           boolean allowBackupFiles)
 218   {
 219
 220     JalviewFileFilter chosen = null;
 221
 222     // SelectAllFilter needs to be set first before adding further
 223     // file filters to fix bug on Mac OSX
 224     setAcceptAllFileFilterUsed(allFiles);
 225
 226     for (String[] format : formats)
 227     {
 228       JalviewFileFilter jvf = new JalviewFileFilter(format[0], format[1]);
 229       if (allowBackupFiles)
 230       {
 231         jvf.setParentJFC(this);
 232       }
 233       addChoosableFileFilter(jvf);
 234       if ((selected != null) && selected.equalsIgnoreCase(format[1]))
 235       {
 236         chosen = jvf;
 237       }
 238     }
 239
 240     if (chosen != null)
 241     {
 242       setFileFilter(chosen);
 243     }
 244
 245     if (allowBackupFiles)
 246     {
 247       JPanel multi = new JPanel();
 248       multi.setLayout(new BoxLayout(multi, BoxLayout.PAGE_AXIS));
 249       if (backupfilesCheckBox == null)
 250       {
 251         try {
 252           includeBackupFiles = Boolean.parseBoolean(
 253                   Cache.getProperty(BackupFiles.NS + "_FC_INCLUDE"));
 254         } catch (Exception e)
 255         {
 256           includeBackupFiles = false;
 257         }
 258         backupfilesCheckBox = new JCheckBox(
 259                 MessageManager.getString("label.include_backup_files"),
 260                 includeBackupFiles);
 261         backupfilesCheckBox.setAlignmentX(Component.CENTER_ALIGNMENT);
 262         JalviewFileChooser jfc = this;
 263         backupfilesCheckBox.addActionListener(new ActionListener()
 264         {
 265           @Override
 266           public void actionPerformed(ActionEvent e)
 267           {
 268             includeBackupFiles = backupfilesCheckBox.isSelected();
 269             Cache.setProperty(BackupFiles.NS + "_FC_INCLUDE",
 270                     String.valueOf(includeBackupFiles));
 271
 272             FileFilter f = jfc.getFileFilter();
 273             // deselect the selected file if it's no longer choosable
 274             File selectedFile = jfc.getSelectedFile();
 275             if (selectedFile != null && !f.accept(selectedFile))
 276             {
 277               jfc.setSelectedFile(null);
 278             }
 279             // fake the OK button changing (to force it to upate)
 280             String s = jfc.getApproveButtonText();
 281             jfc.firePropertyChange(
 282                     APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, null, s);
 283             // fake the file filter changing (its behaviour actually has)
 284             jfc.firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, null, f);
 285
 286             jfc.rescanCurrentDirectory();
 287             jfc.revalidate();
 288             jfc.repaint();
 289           }
 290         });
 291       }
 292       multi.add(new RecentlyOpened());
 293       multi.add(backupfilesCheckBox);
 294       setAccessory(multi);
 295     }
 296     else
 297     {
 298       // set includeBackupFiles=false to avoid other file choosers from picking
 299       // up backup files (Just In Case)
 300       includeBackupFiles = false;
 301       setAccessory(new RecentlyOpened());
 302     }
 303   }
 304
 305   @Override
 306   public void setFileFilter(javax.swing.filechooser.FileFilter filter)
 307   {
 308     super.setFileFilter(filter);
 309
 310     try
 311     {
 312       if (getUI() instanceof BasicFileChooserUI)
 313       {
 314         final BasicFileChooserUI fcui = (BasicFileChooserUI) getUI();
 315         final String name = fcui.getFileName().trim();
 316
 317         if ((name == null) || (name.length() == 0))
 318         {
 319           return;
 320         }
 321
 322         EventQueue.invokeLater(new Thread()
 323         {
 324           @Override
 325           public void run()
 326           {
 327             String currentName = fcui.getFileName();
 328             if ((currentName == null) || (currentName.length() == 0))
 329             {
 330               fcui.setFileName(name);
 331             }
 332           }
 333         });
 334       }
 335     } catch (Exception ex)
 336     {
 337       ex.printStackTrace();
 338       // Some platforms do not have BasicFileChooserUI
 339     }
 340   }
 341
 342   /**
 343    * Returns the selected file format, or null if none selected
 344    *
 345    * @return
 346    */
 347   public FileFormatI getSelectedFormat()
 348   {
 349     if (getFileFilter() == null)
 350     {
 351       return null;
 352     }
 353
 354     /*
 355      * logic here depends on option description being formatted as
 356      * formatName (extension, extension...)
 357      * or the 'no option selected' value
 358      * All Files
 359      * @see JalviewFileFilter.getDescription
 360      */
 361     String format = getFileFilter().getDescription();
 362     int parenPos = format.indexOf("(");
 363     if (parenPos > 0)
 364     {
 365       format = format.substring(0, parenPos).trim();
 366       try
 367       {
 368         return FileFormats.getInstance().forName(format);
 369       } catch (IllegalArgumentException e)
 370       {
 371         System.err.println("Unexpected format: " + format);
 372       }
 373     }
 374     return null;
 375   }
 376
 377   File ourselectedFile = null;
 378
 379   @Override
 380   public File getSelectedFile()
 381   {
 382     File selfile = super.getSelectedFile();
 383     if (selfile == null && ourselectedFile != null)
 384     {
 385       return ourselectedFile;
 386     }
 387     return selfile;
 388   }
 389
 390   @Override
 391   public int showSaveDialog(Component parent) throws HeadlessException
 392   {
 393     this.setAccessory(null);
 394     this.setSelectedFile(null);
 395     return super.showSaveDialog(parent);
 396   }
 397
 398   /**
 399    * If doing a Save, and an existing file is chosen or entered, prompt for
 400    * confirmation of overwrite. Proceed if Yes, else leave the file chooser
 401    * open.
 402    *
 403    * @see https://stackoverflow.com/questions/8581215/jfilechooser-and-checking-for-overwrite
 404    */
 405   @Override
 406   public void approveSelection()
 407   {
 408     if (getDialogType() != SAVE_DIALOG)
 409     {
 410       super.approveSelection();
 411       return;
 412     }
 413
 414     ourselectedFile = getSelectedFile();
 415
 416     if (ourselectedFile == null)
 417     {
 418       // Workaround for Java 9,10 on OSX - no selected file, but there is a
 419       // filename typed in
 420       try
 421       {
 422         String filename = ((BasicFileChooserUI) getUI()).getFileName();
 423         if (filename != null && filename.length() > 0)
 424         {
 425           ourselectedFile = new File(getCurrentDirectory(), filename);
 426         }
 427       } catch (Throwable x)
 428       {
 429         System.err.println(
 430                 "Unexpected exception when trying to get filename.");
 431         x.printStackTrace();
 432       }
 433       // TODO: ENSURE THAT FILES SAVED WITH A ':' IN THE NAME ARE REFUSED AND
 434       // THE
 435       // USER PROMPTED FOR A NEW FILENAME
 436     }
 437     if (ourselectedFile == null)
 438     {
 439       return;
 440     }
 441
 442     if (getFileFilter() instanceof JalviewFileFilter)
 443     {
 444       JalviewFileFilter jvf = (JalviewFileFilter) getFileFilter();
 445
 446       if (!jvf.accept(ourselectedFile))
 447       {
 448         String withExtension = getSelectedFile().getName() + "."
 449                 + jvf.getAcceptableExtension();
 450         ourselectedFile = (new File(getCurrentDirectory(), withExtension));
 451         setSelectedFile(ourselectedFile);
 452       }
 453     }
 454
 455     if (ourselectedFile.exists())
 456     {
 457       int confirm = JvOptionPane.showConfirmDialog(this,
 458               MessageManager.getString("label.overwrite_existing_file"),
 459               MessageManager.getString("label.file_already_exists"),
 460               JvOptionPane.YES_NO_OPTION);
 461
 462       if (confirm != JvOptionPane.YES_OPTION)
 463       {
 464         return;
 465       }
 466     }
 467
 468     super.approveSelection();
 469   }
 470
 471   void recentListSelectionChanged(Object selection)
 472   {
 473     setSelectedFile(null);
 474     if (selection != null)
 475     {
 476       File file = new File((String) selection);
 477       if (getFileFilter() instanceof JalviewFileFilter)
 478       {
 479         JalviewFileFilter jvf = (JalviewFileFilter) this.getFileFilter();
 480
 481         if (!jvf.accept(file))
 482         {
 483           setFileFilter(getChoosableFileFilters()[0]);
 484         }
 485       }
 486
 487       setSelectedFile(file);
 488     }
 489   }
 490
 491   /**
 492    * A panel to set as the 'accessory' component to the file chooser dialog,
 493    * holding a list of recently opened files (if any). These are held as a
 494    * tab-separated list of file paths under key <code>RECENT_FILE</code> in
 495    * <code>.jalview_properties</code>. A click in the list calls a method in
 496    * JalviewFileChooser to set the chosen file as the selection.
 497    */
 498   class RecentlyOpened extends JPanel
 499   {
 500     private static final long serialVersionUID = 1L;
 501
 502     private JList<String> list;
 503
 504     RecentlyOpened()
 505     {
 506       String historyItems = Cache.getProperty("RECENT_FILE");
 507       StringTokenizer st;
 508       Vector<String> recent = new Vector<>();
 509
 510       if (historyItems != null)
 511       {
 512         st = new StringTokenizer(historyItems, "\t");
 513         while (st.hasMoreTokens())
 514         {
 515           recent.addElement(st.nextToken());
 516         }
 517       }
 518
 519       list = new JList<>(recent);
 520
 521       DefaultListCellRenderer dlcr = new DefaultListCellRenderer();
 522       dlcr.setHorizontalAlignment(DefaultListCellRenderer.RIGHT);
 523       list.setCellRenderer(dlcr);
 524
 525       list.addMouseListener(new MouseAdapter()
 526       {
 527         @Override
 528         public void mousePressed(MouseEvent evt)
 529         {
 530           recentListSelectionChanged(list.getSelectedValue());
 531         }
 532       });
 533
 534       this.setBorder(new TitledBorder(
 535               MessageManager.getString("label.recently_opened")));
 536
 537       final JScrollPane scroller = new JScrollPane(list);
 538
 539       SpringLayout layout = new SpringLayout();
 540       layout.putConstraint(SpringLayout.WEST, scroller, 5,
 541               SpringLayout.WEST, this);
 542       layout.putConstraint(SpringLayout.NORTH, scroller, 5,
 543               SpringLayout.NORTH, this);
 544
 545       if (Platform.isAMac())
 546       {
 547         scroller.setPreferredSize(new Dimension(500, 100));
 548       }
 549       else
 550       {
 551         scroller.setPreferredSize(new Dimension(130, 200));
 552       }
 553
 554       this.add(scroller);
 555
 556       SwingUtilities.invokeLater(new Runnable()
 557       {
 558         @Override
 559         public void run()
 560         {
 561           scroller.getHorizontalScrollBar()
 562                   .setValue(scroller.getHorizontalScrollBar().getMaximum());
 563         }
 564       });
 565     }
 566   }
 567 }