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.plaf.basic.BasicFileChooserUI;
  52
  53 /**
  54  * Enhanced file chooser dialog box.
  55  *
  56  * NOTE: bug on Windows systems when filechooser opened on directory to view
  57  * files with colons in title.
  58  *
  59  * @author AMW
  60  *
  61  */
  62 public class JalviewFileChooser extends JFileChooser
  63 {
  64   /**
  65    * backupfilesCheckBox = "Include backup files" checkbox includeBackupfiles =
  66    * flag set by checkbox
  67    */
  68   private JCheckBox backupfilesCheckBox = null;
  69
  70   protected boolean includeBackupFiles = false;
  71
  72   /**
  73    * Factory method to return a file chooser that offers readable alignment file
  74    * formats
  75    *
  76    * @param directory
  77    * @param selected
  78    * @return
  79    */
  80   public static JalviewFileChooser forRead(String directory,
  81           String selected)
  82   {
  83     List<String> extensions = new ArrayList<>();
  84     List<String> descs = new ArrayList<>();
  85     for (FileFormatI format : FileFormats.getInstance().getFormats())
  86     {
  87       if (format.isReadable())
  88       {
  89         extensions.add(format.getExtensions());
  90         descs.add(format.getName());
  91       }
  92     }
  93     return new JalviewFileChooser(directory,
  94             extensions.toArray(new String[extensions.size()]),
  95             descs.toArray(new String[descs.size()]), selected, true);
  96   }
  97
  98   /**
  99    * Factory method to return a file chooser that offers writable alignment file
 100    * formats
 101    *
 102    * @param directory
 103    * @param selected
 104    * @return
 105    */
 106   public static JalviewFileChooser forWrite(String directory,
 107           String selected)
 108   {
 109     // TODO in Java 8, forRead and forWrite can be a single method
 110     // with a lambda expression parameter for isReadable/isWritable
 111     List<String> extensions = new ArrayList<>();
 112     List<String> descs = new ArrayList<>();
 113     for (FileFormatI format : FileFormats.getInstance().getFormats())
 114     {
 115       if (format.isWritable())
 116       {
 117         extensions.add(format.getExtensions());
 118         descs.add(format.getName());
 119       }
 120     }
 121     return new JalviewFileChooser(directory,
 122             extensions.toArray(new String[extensions.size()]),
 123             descs.toArray(new String[descs.size()]), selected, false);
 124   }
 125
 126   public JalviewFileChooser(String dir)
 127   {
 128     super(safePath(dir));
 129     setAccessory(new RecentlyOpened());
 130   }
 131
 132   public JalviewFileChooser(String dir, String[] suffix, String[] desc,
 133           String selected)
 134   {
 135     this(dir, suffix, desc, selected, true);
 136   }
 137
 138   /**
 139    * Constructor for a single choice of file extension and description
 140    *
 141    * @param extension
 142    * @param desc
 143    */
 144   public JalviewFileChooser(String extension, String desc)
 145   {
 146     this(Cache.getProperty("LAST_DIRECTORY"), new String[] { extension },
 147             new String[]
 148             { desc }, desc, true);
 149   }
 150
 151   JalviewFileChooser(String dir, String[] extensions, String[] descs,
 152           String selected, boolean allFiles)
 153   {
 154     this(dir, extensions, descs, selected, allFiles, false);
 155   }
 156
 157   public JalviewFileChooser(String dir, String[] extensions, String[] descs,
 158           String selected, boolean allFiles, boolean allowBackupFiles)
 159   {
 160     super(safePath(dir));
 161     if (extensions.length == descs.length)
 162     {
 163       List<String[]> formats = new ArrayList<>();
 164       for (int i = 0; i < extensions.length; i++)
 165       {
 166         formats.add(new String[] { extensions[i], descs[i] });
 167       }
 168       init(formats, selected, allFiles, allowBackupFiles);
 169     }
 170     else
 171     {
 172       System.err.println("JalviewFileChooser arguments mismatch: "
 173               + extensions + ", " + descs);
 174     }
 175   }
 176
 177   private static File safePath(String dir)
 178   {
 179     if (dir == null)
 180     {
 181       return null;
 182     }
 183
 184     File f = new File(dir);
 185     if (f.getName().indexOf(':') > -1)
 186     {
 187       return null;
 188     }
 189     return f;
 190   }
 191
 192   /**
 193    *
 194    * @param formats
 195    *          a list of {extensions, description} for each file format
 196    * @param selected
 197    * @param allFiles
 198    *          if true, 'any format' option is included
 199    */
 200   void init(List<String[]> formats, String selected, boolean allFiles)
 201   {
 202     init(formats, selected, allFiles, false);
 203   }
 204
 205   void init(List<String[]> formats, String selected, boolean allFiles,
 206           boolean allowBackupFiles)
 207   {
 208
 209     JalviewFileFilter chosen = null;
 210
 211     // SelectAllFilter needs to be set first before adding further
 212     // file filters to fix bug on Mac OSX
 213     setAcceptAllFileFilterUsed(allFiles);
 214
 215     for (String[] format : formats)
 216     {
 217       JalviewFileFilter jvf = new JalviewFileFilter(format[0], format[1]);
 218       if (allowBackupFiles)
 219       {
 220         jvf.setParentJFC(this);
 221       }
 222       addChoosableFileFilter(jvf);
 223       if ((selected != null) && selected.equalsIgnoreCase(format[1]))
 224       {
 225         chosen = jvf;
 226       }
 227     }
 228
 229     if (chosen != null)
 230     {
 231       setFileFilter(chosen);
 232     }
 233
 234     if (allowBackupFiles)
 235     {
 236       JPanel multi = new JPanel();
 237       multi.setLayout(new BoxLayout(multi, BoxLayout.PAGE_AXIS));
 238       if (backupfilesCheckBox == null)
 239       {
 240         try {
 241           includeBackupFiles = Boolean.parseBoolean(
 242                   Cache.getProperty(BackupFiles.NS + "_FC_INCLUDE"));
 243         } catch (Exception e)
 244         {
 245           includeBackupFiles = false;
 246         }
 247         backupfilesCheckBox = new JCheckBox(
 248                 MessageManager.getString("label.include_backup_files"),
 249                 includeBackupFiles);
 250         backupfilesCheckBox.setAlignmentX(Component.CENTER_ALIGNMENT);
 251         JalviewFileChooser jfc = this;
 252         backupfilesCheckBox.addActionListener(new ActionListener()
 253         {
 254           @Override
 255           public void actionPerformed(ActionEvent e)
 256           {
 257             includeBackupFiles = backupfilesCheckBox.isSelected();
 258             Cache.setProperty(BackupFiles.NS + "_FC_INCLUDE",
 259                     String.valueOf(includeBackupFiles));
 260             jfc.rescanCurrentDirectory();
 261             jfc.revalidate();
 262             jfc.repaint();
 263             // This is a kludge. Cannot find out how to get the file list to
 264             // refresh!
 265             /*
 266             Object o = jfc.getClientProperty(
 267                     CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY);
 268             jfc.firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY,
 269                     o, o);
 270             */
 271           }
 272         });
 273       }
 274       multi.add(new RecentlyOpened());
 275       multi.add(backupfilesCheckBox);
 276       setAccessory(multi);
 277     }
 278     else
 279     {
 280       // set includeBackupFiles=false to avoid other file choosers from picking
 281       // up backup files (Just In Case)
 282       includeBackupFiles = false;
 283       setAccessory(new RecentlyOpened());
 284     }
 285   }
 286
 287   @Override
 288   public void setFileFilter(javax.swing.filechooser.FileFilter filter)
 289   {
 290     super.setFileFilter(filter);
 291
 292     try
 293     {
 294       if (getUI() instanceof BasicFileChooserUI)
 295       {
 296         final BasicFileChooserUI fcui = (BasicFileChooserUI) getUI();
 297         final String name = fcui.getFileName().trim();
 298
 299         if ((name == null) || (name.length() == 0))
 300         {
 301           return;
 302         }
 303
 304         EventQueue.invokeLater(new Thread()
 305         {
 306           @Override
 307           public void run()
 308           {
 309             String currentName = fcui.getFileName();
 310             if ((currentName == null) || (currentName.length() == 0))
 311             {
 312               fcui.setFileName(name);
 313             }
 314           }
 315         });
 316       }
 317     } catch (Exception ex)
 318     {
 319       ex.printStackTrace();
 320       // Some platforms do not have BasicFileChooserUI
 321     }
 322   }
 323
 324   /**
 325    * Returns the selected file format, or null if none selected
 326    *
 327    * @return
 328    */
 329   public FileFormatI getSelectedFormat()
 330   {
 331     if (getFileFilter() == null)
 332     {
 333       return null;
 334     }
 335
 336     /*
 337      * logic here depends on option description being formatted as
 338      * formatName (extension, extension...)
 339      * or the 'no option selected' value
 340      * All Files
 341      * @see JalviewFileFilter.getDescription
 342      */
 343     String format = getFileFilter().getDescription();
 344     int parenPos = format.indexOf("(");
 345     if (parenPos > 0)
 346     {
 347       format = format.substring(0, parenPos).trim();
 348       try
 349       {
 350         return FileFormats.getInstance().forName(format);
 351       } catch (IllegalArgumentException e)
 352       {
 353         System.err.println("Unexpected format: " + format);
 354       }
 355     }
 356     return null;
 357   }
 358
 359   File ourselectedFile = null;
 360
 361   @Override
 362   public File getSelectedFile()
 363   {
 364     File selfile = super.getSelectedFile();
 365     if (selfile == null && ourselectedFile != null)
 366     {
 367       return ourselectedFile;
 368     }
 369     return selfile;
 370   }
 371
 372   @Override
 373   public int showSaveDialog(Component parent) throws HeadlessException
 374   {
 375     this.setAccessory(null);
 376
 377     setDialogType(SAVE_DIALOG);
 378
 379     this.setSelectedFile(null);
 380     int ret = showDialog(parent, MessageManager.getString("action.save"));
 381     ourselectedFile = getSelectedFile();
 382
 383     if (getSelectedFile() == null)
 384     {
 385       // Workaround for Java 9,10 on OSX - no selected file, but there is a
 386       // filename typed in
 387       try
 388       {
 389         String filename = ((BasicFileChooserUI) getUI()).getFileName();
 390         if (filename != null && filename.length() > 0)
 391         {
 392           ourselectedFile = new File(getCurrentDirectory(), filename);
 393         }
 394       } catch (Throwable x)
 395       {
 396         System.err.println(
 397                 "Unexpected exception when trying to get filename.");
 398         x.printStackTrace();
 399       }
 400     }
 401     if (ourselectedFile == null)
 402     {
 403       return JalviewFileChooser.CANCEL_OPTION;
 404     }
 405     if (getFileFilter() instanceof JalviewFileFilter)
 406     {
 407       JalviewFileFilter jvf = (JalviewFileFilter) getFileFilter();
 408
 409       if (!jvf.accept(ourselectedFile))
 410       {
 411         String withExtension = getSelectedFile().getName() + "."
 412                 + jvf.getAcceptableExtension();
 413         ourselectedFile = (new File(getCurrentDirectory(), withExtension));
 414         setSelectedFile(ourselectedFile);
 415       }
 416     }
 417
 418     // TODO: ENSURE THAT FILES SAVED WITH A ':' IN THE NAME ARE REFUSED AND THE
 419     // USER PROMPTED FOR A NEW FILENAME.
 420     // DO NOT need to confirm file overwrite if using backup files (the files
 421     // aren't being overwritten!)
 422     if ((ret == JalviewFileChooser.APPROVE_OPTION)
 423             && ourselectedFile.exists() && (!BackupFiles.getEnabled()))
 424     {
 425       int confirm = JvOptionPane.showConfirmDialog(parent,
 426               MessageManager.getString("label.overwrite_existing_file"),
 427               MessageManager.getString("label.file_already_exists"),
 428               JvOptionPane.YES_NO_OPTION);
 429
 430       if (confirm != JvOptionPane.YES_OPTION)
 431       {
 432         ret = JalviewFileChooser.CANCEL_OPTION;
 433       }
 434
 435     }
 436
 437     return ret;
 438   }
 439
 440   void recentListSelectionChanged(Object selection)
 441   {
 442     setSelectedFile(null);
 443     if (selection != null)
 444     {
 445       File file = new File((String) selection);
 446       if (getFileFilter() instanceof JalviewFileFilter)
 447       {
 448         JalviewFileFilter jvf = (JalviewFileFilter) this.getFileFilter();
 449
 450         if (!jvf.accept(file))
 451         {
 452           setFileFilter(getChoosableFileFilters()[0]);
 453         }
 454       }
 455
 456       setSelectedFile(file);
 457     }
 458   }
 459
 460   class RecentlyOpened extends JPanel
 461   {
 462     JList list;
 463
 464     public RecentlyOpened()
 465     {
 466
 467       String historyItems = jalview.bin.Cache.getProperty("RECENT_FILE");
 468       StringTokenizer st;
 469       Vector recent = new Vector();
 470
 471       if (historyItems != null)
 472       {
 473         st = new StringTokenizer(historyItems, "\t");
 474
 475         while (st.hasMoreTokens())
 476         {
 477           recent.addElement(st.nextElement());
 478         }
 479       }
 480
 481       list = new JList(recent);
 482
 483       DefaultListCellRenderer dlcr = new DefaultListCellRenderer();
 484       dlcr.setHorizontalAlignment(DefaultListCellRenderer.RIGHT);
 485       list.setCellRenderer(dlcr);
 486
 487       list.addMouseListener(new MouseAdapter()
 488       {
 489         @Override
 490         public void mousePressed(MouseEvent evt)
 491         {
 492           recentListSelectionChanged(list.getSelectedValue());
 493         }
 494       });
 495
 496       this.setBorder(new javax.swing.border.TitledBorder(
 497               MessageManager.getString("label.recently_opened")));
 498
 499       final JScrollPane scroller = new JScrollPane(list);
 500
 501       SpringLayout layout = new SpringLayout();
 502       layout.putConstraint(SpringLayout.WEST, scroller, 5,
 503               SpringLayout.WEST, this);
 504       layout.putConstraint(SpringLayout.NORTH, scroller, 5,
 505               SpringLayout.NORTH, this);
 506
 507       if (new Platform().isAMac())
 508       {
 509         scroller.setPreferredSize(new Dimension(500, 100));
 510       }
 511       else
 512       {
 513         scroller.setPreferredSize(new Dimension(130, 200));
 514       }
 515
 516       this.add(scroller);
 517
 518       javax.swing.SwingUtilities.invokeLater(new Runnable()
 519       {
 520         @Override
 521         public void run()
 522         {
 523           scroller.getHorizontalScrollBar()
 524                   .setValue(scroller.getHorizontalScrollBar().getMaximum());
 525         }
 526       });
 527
 528     }
 529
 530   }
 531 }