JAL-3933 remove obsolete Castor logging configuration
[jalview.git] / 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 }