src/jalview/io/FileLoader.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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.List;
  34 import java.util.StringTokenizer;
  35 import java.util.Vector;
  36
  37 import javax.swing.JOptionPane;
  38 import javax.swing.SwingUtilities;
  39
  40 public class FileLoader implements Runnable
  41 {
  42   String file;
  43
  44   String protocol;
  45
  46   String format;
  47
  48   FileParse source = null; // alternative specification of where data comes
  49
  50   // from
  51
  52   AlignViewport viewport;
  53
  54   AlignFrame alignFrame;
  55
  56   long loadtime;
  57
  58   long memused;
  59
  60   boolean raiseGUI = true;
  61
  62   /**
  63    * default constructor always raised errors in GUI dialog boxes
  64    */
  65   public FileLoader()
  66   {
  67     this(true);
  68   }
  69
  70   /**
  71    * construct a Fileloader that may raise errors non-interactively
  72    *
  73    * @param raiseGUI
  74    *          true if errors are to be raised as GUI dialog boxes
  75    */
  76   public FileLoader(boolean raiseGUI)
  77   {
  78     this.raiseGUI = raiseGUI;
  79   }
  80
  81   public void LoadFile(AlignViewport viewport, String file,
  82           String protocol, String format)
  83   {
  84     this.viewport = viewport;
  85     LoadFile(file, protocol, format);
  86   }
  87
  88   public void LoadFile(String file, String protocol, String format)
  89   {
  90     this.file = file;
  91     this.protocol = protocol;
  92     this.format = format;
  93
  94     final Thread loader = new Thread(this);
  95
  96     SwingUtilities.invokeLater(new Runnable()
  97     {
  98       public void run()
  99       {
 100         loader.start();
 101       }
 102     });
 103   }
 104
 105   /**
 106    * Load a (file, protocol) source of unknown type
 107    *
 108    * @param file
 109    * @param protocol
 110    */
 111   public void LoadFile(String file, String protocol)
 112   {
 113     LoadFile(file, protocol, null);
 114   }
 115
 116   /**
 117    * Load alignment from (file, protocol) and wait till loaded
 118    *
 119    * @param file
 120    * @param protocol
 121    * @return alignFrame constructed from file contents
 122    */
 123   public AlignFrame LoadFileWaitTillLoaded(String file, String protocol)
 124   {
 125     return LoadFileWaitTillLoaded(file, protocol, null);
 126   }
 127
 128   /**
 129    * Load alignment from (file, protocol) of type format and wait till loaded
 130    *
 131    * @param file
 132    * @param protocol
 133    * @param format
 134    * @return alignFrame constructed from file contents
 135    */
 136   public AlignFrame LoadFileWaitTillLoaded(String file, String protocol,
 137           String format)
 138   {
 139     this.file = file;
 140     this.protocol = protocol;
 141     this.format = format;
 142     return _LoadFileWaitTillLoaded();
 143   }
 144
 145   /**
 146    * Load alignment from FileParse source of type format and wait till loaded
 147    *
 148    * @param source
 149    * @param format
 150    * @return alignFrame constructed from file contents
 151    */
 152   public AlignFrame LoadFileWaitTillLoaded(FileParse source, String format)
 153   {
 154     this.source = source;
 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.afile; // 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 : (List<PDBEntry>) sq.getPDBId())
 326               {
 327                 StructureSelectionManager.getStructureSelectionManager(
 328                         Desktop.instance).registerPDBEntry(pdbe);
 329               }
 330             }
 331           }
 332           if (viewport != null)
 333           {
 334             // TODO: create undo object for this JAL-1101
 335             for (int i = 0; i < al.getHeight(); i++)
 336             {
 337               viewport.getAlignment().addSequence(al.getSequenceAt(i));
 338             }
 339             viewport.firePropertyChange("alignment", null, viewport
 340                     .getAlignment().getSequences());
 341           }
 342           else
 343           {
 344             alignFrame = new AlignFrame(al, AlignFrame.DEFAULT_WIDTH,
 345                     AlignFrame.DEFAULT_HEIGHT);
 346
 347             alignFrame.statusBar.setText(MessageManager.formatMessage(
 348                     "label.successfully_loaded_file", new String[]
 349                     { title }));
 350
 351             if (!protocol.equals(AppletFormatAdapter.PASTE))
 352             {
 353               alignFrame.setFileName(file, format);
 354             }
 355             if (raiseGUI)
 356             {
 357               // add the window to the GUI
 358               // note - this actually should happen regardless of raiseGUI
 359               // status in Jalview 3
 360               // TODO: define 'virtual desktop' for benefit of headless scripts
 361               // that perform queries to find the 'current working alignment'
 362               Desktop.addInternalFrame(alignFrame, title,
 363                       AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
 364             }
 365
 366             try
 367             {
 368               alignFrame.setMaximum(jalview.bin.Cache.getDefault(
 369                       "SHOW_FULLSCREEN", false));
 370             } catch (java.beans.PropertyVetoException ex)
 371             {
 372             }
 373           }
 374         }
 375         else
 376         {
 377           if (Desktop.instance != null)
 378           {
 379             Desktop.instance.stopLoading();
 380           }
 381
 382           final String errorMessage = "Couldn't load file " + title + "\n"
 383                   + error;
 384           if (raiseGUI)
 385           {
 386             javax.swing.SwingUtilities.invokeLater(new Runnable()
 387             {
 388               public void run()
 389               {
 390                 JOptionPane.showInternalMessageDialog(Desktop.desktop,
 391                         errorMessage, MessageManager
 392                                 .getString("label.error_loading_file"),
 393                         JOptionPane.WARNING_MESSAGE);
 394               }
 395             });
 396           }
 397           else
 398           {
 399             System.err.println(errorMessage);
 400           }
 401         }
 402       }
 403
 404       updateRecentlyOpened();
 405
 406     } catch (Exception er)
 407     {
 408       System.err.println("Exception whilst opening file '" + file);
 409       er.printStackTrace();
 410       if (raiseGUI)
 411       {
 412         javax.swing.SwingUtilities.invokeLater(new Runnable()
 413         {
 414           public void run()
 415           {
 416             javax.swing.JOptionPane.showInternalMessageDialog(
 417                     Desktop.desktop, MessageManager.formatMessage(
 418                             "label.problems_opening_file", new String[]
 419                             { file }), MessageManager
 420                             .getString("label.file_open_error"),
 421                     javax.swing.JOptionPane.WARNING_MESSAGE);
 422           }
 423         });
 424       }
 425       alignFrame = null;
 426     } catch (OutOfMemoryError er)
 427     {
 428
 429       er.printStackTrace();
 430       alignFrame = null;
 431       if (raiseGUI)
 432       {
 433         javax.swing.SwingUtilities.invokeLater(new Runnable()
 434         {
 435           public void run()
 436           {
 437             javax.swing.JOptionPane
 438                     .showInternalMessageDialog(
 439                             Desktop.desktop,
 440                             MessageManager.formatMessage("warn.out_of_memory_loading_file", new String[]{file}),
 441                             MessageManager.getString("label.out_of_memory"),
 442                             javax.swing.JOptionPane.WARNING_MESSAGE);
 443           }
 444         });
 445       }
 446       System.err.println("Out of memory loading file " + file + "!!");
 447
 448     }
 449     loadtime += System.currentTimeMillis();
 450     // TODO: Estimate percentage of memory used by a newly loaded alignment -
 451     // warn if more memory will be needed to work with it
 452     // System.gc();
 453     memused = memused
 454             - (rt.maxMemory() - rt.totalMemory() + rt.freeMemory()); // difference
 455     // in free
 456     // memory
 457     // after
 458     // load
 459     if (Desktop.desktop != null && Desktop.desktop.isShowMemoryUsage())
 460     {
 461       if (alignFrame != null)
 462       {
 463         AlignmentI al = alignFrame.getViewport().getAlignment();
 464
 465         System.out.println("Loaded '" + title + "' in "
 466                 + (loadtime / 1000.0) + "s, took an additional "
 467                 + (1.0 * memused / (1024.0 * 1024.0)) + " MB ("
 468                 + al.getHeight() + " seqs by " + al.getWidth() + " cols)");
 469       }
 470       else
 471       {
 472         // report that we didn't load anything probably due to an out of memory
 473         // error
 474         System.out.println("Failed to load '" + title + "' in "
 475                 + (loadtime / 1000.0) + "s, took an additional "
 476                 + (1.0 * memused / (1024.0 * 1024.0))
 477                 + " MB (alignment is null)");
 478       }
 479     }
 480     // remove the visual delay indicator
 481     if (Desktop.instance != null)
 482     {
 483       Desktop.instance.stopLoading();
 484     }
 485
 486   }
 487
 488   /*
 489    * (non-Javadoc)
 490    *
 491    * @see java.lang.Object#finalize()
 492    */
 493   protected void finalize() throws Throwable
 494   {
 495     source = null;
 496     alignFrame = null;
 497     viewport = null;
 498     super.finalize();
 499   }
 500
 501 }