JAL-1753 statusPanel added (for ProgressBar); 'Fit to Window' menu
[jalview.git] / src / jalview / io / FileLoader.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 package jalview.io;
22
23 import jalview.datamodel.AlignmentI;
24 import jalview.datamodel.PDBEntry;
25 import jalview.datamodel.SequenceI;
26 import jalview.gui.AlignFrame;
27 import jalview.gui.AlignViewport;
28 import jalview.gui.Desktop;
29 import jalview.gui.Jalview2XML;
30 import jalview.structure.StructureSelectionManager;
31 import jalview.util.MessageManager;
32
33 import java.util.StringTokenizer;
34 import java.util.Vector;
35
36 import javax.swing.JOptionPane;
37 import javax.swing.SwingUtilities;
38
39 public class FileLoader implements Runnable
40 {
41   String file;
42
43   String protocol;
44
45   String format;
46
47   FileParse source = null; // alternative specification of where data comes
48
49   // from
50
51   AlignViewport viewport;
52
53   AlignFrame alignFrame;
54
55   long loadtime;
56
57   long memused;
58
59   boolean raiseGUI = true;
60
61   /**
62    * default constructor always raised errors in GUI dialog boxes
63    */
64   public FileLoader()
65   {
66     this(true);
67   }
68
69   /**
70    * construct a Fileloader that may raise errors non-interactively
71    * 
72    * @param raiseGUI
73    *          true if errors are to be raised as GUI dialog boxes
74    */
75   public FileLoader(boolean raiseGUI)
76   {
77     this.raiseGUI = raiseGUI;
78   }
79
80   public void LoadFile(AlignViewport viewport, String file,
81           String protocol, String format)
82   {
83     this.viewport = viewport;
84     LoadFile(file, protocol, format);
85   }
86
87   public void LoadFile(String file, String protocol, String format)
88   {
89     this.file = file;
90     this.protocol = protocol;
91     this.format = format;
92
93     final Thread loader = new Thread(this);
94
95     SwingUtilities.invokeLater(new Runnable()
96     {
97       public void run()
98       {
99         loader.start();
100       }
101     });
102   }
103
104   /**
105    * Load a (file, protocol) source of unknown type
106    * 
107    * @param file
108    * @param protocol
109    */
110   public void LoadFile(String file, String protocol)
111   {
112     LoadFile(file, protocol, null);
113   }
114
115   /**
116    * Load alignment from (file, protocol) and wait till loaded
117    * 
118    * @param file
119    * @param protocol
120    * @return alignFrame constructed from file contents
121    */
122   public AlignFrame LoadFileWaitTillLoaded(String file, String protocol)
123   {
124     return LoadFileWaitTillLoaded(file, protocol, null);
125   }
126
127   /**
128    * Load alignment from (file, protocol) of type format and wait till loaded
129    * 
130    * @param file
131    * @param protocol
132    * @param format
133    * @return alignFrame constructed from file contents
134    */
135   public AlignFrame LoadFileWaitTillLoaded(String file, String protocol,
136           String format)
137   {
138     this.file = file;
139     this.protocol = protocol;
140     this.format = format;
141     return _LoadFileWaitTillLoaded();
142   }
143
144   /**
145    * Load alignment from FileParse source of type format and wait till loaded
146    * 
147    * @param source
148    * @param format
149    * @return alignFrame constructed from file contents
150    */
151   public AlignFrame LoadFileWaitTillLoaded(FileParse source, String format)
152   {
153     this.source = source;
154
155     file = source.getInFile();
156     protocol = source.type;
157     this.format = format;
158     return _LoadFileWaitTillLoaded();
159   }
160
161   /**
162    * start thread and wait until finished, then return the alignFrame that's
163    * (hopefully) been read.
164    * 
165    * @return
166    */
167   protected AlignFrame _LoadFileWaitTillLoaded()
168   {
169     Thread loader = new Thread(this);
170     loader.start();
171
172     while (loader.isAlive())
173     {
174       try
175       {
176         Thread.sleep(500);
177       } catch (Exception ex)
178       {
179       }
180     }
181
182     return alignFrame;
183   }
184
185   public void updateRecentlyOpened()
186   {
187     Vector recent = new Vector();
188     if (protocol.equals(FormatAdapter.PASTE))
189     {
190       // do nothing if the file was pasted in as text... there is no filename to
191       // refer to it as.
192       return;
193     }
194     String type = protocol.equals(FormatAdapter.FILE) ? "RECENT_FILE"
195             : "RECENT_URL";
196
197     String historyItems = jalview.bin.Cache.getProperty(type);
198
199     StringTokenizer st;
200
201     if (historyItems != null)
202     {
203       st = new StringTokenizer(historyItems, "\t");
204
205       while (st.hasMoreTokens())
206       {
207         recent.addElement(st.nextElement().toString().trim());
208       }
209     }
210
211     if (recent.contains(file))
212     {
213       recent.remove(file);
214     }
215
216     StringBuffer newHistory = new StringBuffer(file);
217     for (int i = 0; i < recent.size() && i < 10; i++)
218     {
219       newHistory.append("\t");
220       newHistory.append(recent.elementAt(i));
221     }
222
223     jalview.bin.Cache.setProperty(type, newHistory.toString());
224
225     if (protocol.equals(FormatAdapter.FILE))
226     {
227       jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT", format);
228     }
229   }
230
231   public void run()
232   {
233     String title = protocol.equals(AppletFormatAdapter.PASTE) ? "Copied From Clipboard"
234             : file;
235     Runtime rt = Runtime.getRuntime();
236     try
237     {
238       if (Desktop.instance != null)
239       {
240         Desktop.instance.startLoading(file);
241       }
242       if (format == null)
243       {
244         // just in case the caller didn't identify the file for us
245         if (source != null)
246         {
247           format = new IdentifyFile().Identify(source, false); // identify
248           // stream and
249           // rewind rather
250           // than close
251         }
252         else
253         {
254           format = new IdentifyFile().Identify(file, protocol);
255         }
256       }
257       // TODO: cache any stream datasources as a temporary file (eg. PDBs
258       // retrieved via URL)
259       if (Desktop.desktop != null && Desktop.desktop.isShowMemoryUsage())
260       {
261         System.gc();
262         memused = (rt.maxMemory() - rt.totalMemory() + rt.freeMemory()); // free
263         // memory
264         // before
265         // load
266       }
267       loadtime = -System.currentTimeMillis();
268       AlignmentI al = null;
269
270       if (format.equalsIgnoreCase("Jalview"))
271       {
272         if (source != null)
273         {
274           // Tell the user (developer?) that this is going to cause a problem
275           System.err
276                   .println("IMPLEMENTATION ERROR: Cannot read consecutive Jalview XML projects from a stream.");
277           // We read the data anyway - it might make sense.
278         }
279         alignFrame = new Jalview2XML(raiseGUI).loadJalviewAlign(file);
280       }
281       else
282       {
283         String error = AppletFormatAdapter.SUPPORTED_FORMATS;
284         if (FormatAdapter.isValidFormat(format))
285         {
286           try
287           {
288             if (source != null)
289             {
290               // read from the provided source
291               al = new FormatAdapter().readFromFile(source, format);
292             }
293             else
294             {
295
296               // open a new source and read from it
297               FormatAdapter fa = new FormatAdapter();
298               al = fa.readFile(file, protocol, format);
299               source = fa.getAlignFile(); // keep reference for later if necessary.
300             }
301           } catch (java.io.IOException ex)
302           {
303             error = ex.getMessage();
304           }
305         }
306         else
307         {
308           if (format != null && format.length() > 7)
309           {
310             // ad hoc message in format.
311             error = format + "\n" + error;
312           }
313         }
314
315         if ((al != null) && (al.getHeight() > 0))
316         {
317           for (SequenceI sq : al.getSequences())
318           {
319             while (sq.getDatasetSequence() != null)
320             {
321               sq = sq.getDatasetSequence();
322             }
323             if (sq.getPDBId() != null)
324             {
325               for (PDBEntry pdbe : sq.getPDBId())
326               {
327                 StructureSelectionManager.getStructureSelectionManager(
328                         Desktop.instance).registerPDBEntry(pdbe);
329               }
330             }
331           }
332           if (viewport != null)
333           {
334             viewport.addAlignment(al, title);
335           }
336           else
337           {
338             alignFrame = new AlignFrame(al, AlignFrame.DEFAULT_WIDTH,
339                     AlignFrame.DEFAULT_HEIGHT);
340
341             alignFrame.statusBar.setText(MessageManager.formatMessage(
342                     "label.successfully_loaded_file", new String[]
343                     { title }));
344
345             if (!protocol.equals(AppletFormatAdapter.PASTE))
346             {
347               alignFrame.setFileName(file, format);
348             }
349             if (source instanceof HtmlFile)
350             {
351               ((HtmlFile) source).applySettingsToAlignFrame(alignFrame);
352             }
353             else if (source instanceof JSONFile)
354             {
355               ((JSONFile) source).applySettingsToAlignFrame(alignFrame);
356             }
357
358             if (raiseGUI)
359             {
360               // add the window to the GUI
361               // note - this actually should happen regardless of raiseGUI
362               // status in Jalview 3
363               // TODO: define 'virtual desktop' for benefit of headless scripts
364               // that perform queries to find the 'current working alignment'
365               Desktop.addInternalFrame(alignFrame, title,
366                       AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
367             }
368
369             try
370             {
371               alignFrame.setMaximum(jalview.bin.Cache.getDefault(
372                       "SHOW_FULLSCREEN", false));
373             } catch (java.beans.PropertyVetoException ex)
374             {
375             }
376           }
377         }
378         else
379         {
380           if (Desktop.instance != null)
381           {
382             Desktop.instance.stopLoading();
383           }
384
385           final String errorMessage = "Couldn't load file " + title + "\n"
386                   + error;
387           if (raiseGUI)
388           {
389             javax.swing.SwingUtilities.invokeLater(new Runnable()
390             {
391               public void run()
392               {
393                 JOptionPane.showInternalMessageDialog(Desktop.desktop,
394                         errorMessage, MessageManager
395                                 .getString("label.error_loading_file"),
396                         JOptionPane.WARNING_MESSAGE);
397               }
398             });
399           }
400           else
401           {
402             System.err.println(errorMessage);
403           }
404         }
405       }
406
407       updateRecentlyOpened();
408
409     } catch (Exception er)
410     {
411       System.err.println("Exception whilst opening file '" + file);
412       er.printStackTrace();
413       if (raiseGUI)
414       {
415         javax.swing.SwingUtilities.invokeLater(new Runnable()
416         {
417           public void run()
418           {
419             javax.swing.JOptionPane.showInternalMessageDialog(
420                     Desktop.desktop, MessageManager.formatMessage(
421                             "label.problems_opening_file", new String[]
422                             { file }), MessageManager
423                             .getString("label.file_open_error"),
424                     javax.swing.JOptionPane.WARNING_MESSAGE);
425           }
426         });
427       }
428       alignFrame = null;
429     } catch (OutOfMemoryError er)
430     {
431
432       er.printStackTrace();
433       alignFrame = null;
434       if (raiseGUI)
435       {
436         javax.swing.SwingUtilities.invokeLater(new Runnable()
437         {
438           public void run()
439           {
440             javax.swing.JOptionPane
441                     .showInternalMessageDialog(
442                             Desktop.desktop,
443                             MessageManager.formatMessage("warn.out_of_memory_loading_file", new String[]{file}),
444                             MessageManager.getString("label.out_of_memory"),
445                             javax.swing.JOptionPane.WARNING_MESSAGE);
446           }
447         });
448       }
449       System.err.println("Out of memory loading file " + file + "!!");
450
451     }
452     loadtime += System.currentTimeMillis();
453     // TODO: Estimate percentage of memory used by a newly loaded alignment -
454     // warn if more memory will be needed to work with it
455     // System.gc();
456     memused = memused
457             - (rt.maxMemory() - rt.totalMemory() + rt.freeMemory()); // difference
458     // in free
459     // memory
460     // after
461     // load
462     if (Desktop.desktop != null && Desktop.desktop.isShowMemoryUsage())
463     {
464       if (alignFrame != null)
465       {
466         AlignmentI al = alignFrame.getViewport().getAlignment();
467
468         System.out.println("Loaded '" + title + "' in "
469                 + (loadtime / 1000.0) + "s, took an additional "
470                 + (1.0 * memused / (1024.0 * 1024.0)) + " MB ("
471                 + al.getHeight() + " seqs by " + al.getWidth() + " cols)");
472       }
473       else
474       {
475         // report that we didn't load anything probably due to an out of memory
476         // error
477         System.out.println("Failed to load '" + title + "' in "
478                 + (loadtime / 1000.0) + "s, took an additional "
479                 + (1.0 * memused / (1024.0 * 1024.0))
480                 + " MB (alignment is null)");
481       }
482     }
483     // remove the visual delay indicator
484     if (Desktop.instance != null)
485     {
486       Desktop.instance.stopLoading();
487     }
488
489   }
490
491   /*
492    * (non-Javadoc)
493    * 
494    * @see java.lang.Object#finalize()
495    */
496   protected void finalize() throws Throwable
497   {
498     source = null;
499     alignFrame = null;
500     viewport = null;
501     super.finalize();
502   }
503
504 }