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).LoadAlignmentFeatures(alignFrame);
 352             }
 353             else if (source instanceof JSONFile)
 354             {
 355               ((JSONFile) source).LoadAlignmentFeatures(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 }