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.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
 156     file = source.getInFile();
 157     protocol = source.type;
 158     this.format = format;
 159     return _LoadFileWaitTillLoaded();
 160   }
 161
 162   /**
 163    * start thread and wait until finished, then return the alignFrame that's
 164    * (hopefully) been read.
 165    *
 166    * @return
 167    */
 168   protected AlignFrame _LoadFileWaitTillLoaded()
 169   {
 170     Thread loader = new Thread(this);
 171     loader.start();
 172
 173     while (loader.isAlive())
 174     {
 175       try
 176       {
 177         Thread.sleep(500);
 178       } catch (Exception ex)
 179       {
 180       }
 181     }
 182
 183     return alignFrame;
 184   }
 185
 186   public void updateRecentlyOpened()
 187   {
 188     Vector recent = new Vector();
 189     if (protocol.equals(FormatAdapter.PASTE))
 190     {
 191       // do nothing if the file was pasted in as text... there is no filename to
 192       // refer to it as.
 193       return;
 194     }
 195     String type = protocol.equals(FormatAdapter.FILE) ? "RECENT_FILE"
 196             : "RECENT_URL";
 197
 198     String historyItems = jalview.bin.Cache.getProperty(type);
 199
 200     StringTokenizer st;
 201
 202     if (historyItems != null)
 203     {
 204       st = new StringTokenizer(historyItems, "\t");
 205
 206       while (st.hasMoreTokens())
 207       {
 208         recent.addElement(st.nextElement().toString().trim());
 209       }
 210     }
 211
 212     if (recent.contains(file))
 213     {
 214       recent.remove(file);
 215     }
 216
 217     StringBuffer newHistory = new StringBuffer(file);
 218     for (int i = 0; i < recent.size() && i < 10; i++)
 219     {
 220       newHistory.append("\t");
 221       newHistory.append(recent.elementAt(i));
 222     }
 223
 224     jalview.bin.Cache.setProperty(type, newHistory.toString());
 225
 226     if (protocol.equals(FormatAdapter.FILE))
 227     {
 228       jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT", format);
 229     }
 230   }
 231
 232   public void run()
 233   {
 234     String title = protocol.equals(AppletFormatAdapter.PASTE) ? "Copied From Clipboard"
 235             : file;
 236     Runtime rt = Runtime.getRuntime();
 237     try
 238     {
 239       if (Desktop.instance != null)
 240       {
 241         Desktop.instance.startLoading(file);
 242       }
 243       if (format == null)
 244       {
 245         // just in case the caller didn't identify the file for us
 246         if (source != null)
 247         {
 248           format = new IdentifyFile().Identify(source, false); // identify
 249           // stream and
 250           // rewind rather
 251           // than close
 252         }
 253         else
 254         {
 255           format = new IdentifyFile().Identify(file, protocol);
 256         }
 257       }
 258       // TODO: cache any stream datasources as a temporary file (eg. PDBs
 259       // retrieved via URL)
 260       if (Desktop.desktop != null && Desktop.desktop.isShowMemoryUsage())
 261       {
 262         System.gc();
 263         memused = (rt.maxMemory() - rt.totalMemory() + rt.freeMemory()); // free
 264         // memory
 265         // before
 266         // load
 267       }
 268       loadtime = -System.currentTimeMillis();
 269       AlignmentI al = null;
 270
 271       if (format.equalsIgnoreCase("Jalview"))
 272       {
 273         if (source != null)
 274         {
 275           // Tell the user (developer?) that this is going to cause a problem
 276           System.err
 277                   .println("IMPLEMENTATION ERROR: Cannot read consecutive Jalview XML projects from a stream.");
 278           // We read the data anyway - it might make sense.
 279         }
 280         alignFrame = new Jalview2XML(raiseGUI).loadJalviewAlign(file);
 281       }
 282       else
 283       {
 284         String error = AppletFormatAdapter.SUPPORTED_FORMATS;
 285         if (FormatAdapter.isValidFormat(format))
 286         {
 287           try
 288           {
 289             if (source != null)
 290             {
 291               // read from the provided source
 292               al = new FormatAdapter().readFromFile(source, format);
 293             }
 294             else
 295             {
 296
 297               // open a new source and read from it
 298               FormatAdapter fa = new FormatAdapter();
 299               al = fa.readFile(file, protocol, format);
 300               source = fa.afile; // keep reference for later if necessary.
 301             }
 302           } catch (java.io.IOException ex)
 303           {
 304             error = ex.getMessage();
 305           }
 306         }
 307         else
 308         {
 309           if (format != null && format.length() > 7)
 310           {
 311             // ad hoc message in format.
 312             error = format + "\n" + error;
 313           }
 314         }
 315
 316         if ((al != null) && (al.getHeight() > 0))
 317         {
 318           for (SequenceI sq : al.getSequences())
 319           {
 320             while (sq.getDatasetSequence() != null)
 321             {
 322               sq = sq.getDatasetSequence();
 323             }
 324             if (sq.getPDBId() != null)
 325             {
 326               for (PDBEntry pdbe : (List<PDBEntry>) sq.getPDBId())
 327               {
 328                 StructureSelectionManager.getStructureSelectionManager(
 329                         Desktop.instance).registerPDBEntry(pdbe);
 330               }
 331             }
 332           }
 333           if (viewport != null)
 334           {
 335             viewport.addAlignment(al, title);
 336           }
 337           else
 338           {
 339             alignFrame = new AlignFrame(al, AlignFrame.DEFAULT_WIDTH,
 340                     AlignFrame.DEFAULT_HEIGHT);
 341
 342             alignFrame.statusBar.setText(MessageManager.formatMessage(
 343                     "label.successfully_loaded_file", new String[]
 344                     { title }));
 345
 346             if (!protocol.equals(AppletFormatAdapter.PASTE))
 347             {
 348               alignFrame.setFileName(file, format);
 349             }
 350             if (source instanceof HtmlFile)
 351             {
 352               ((HtmlFile) source).LoadAlignmentFeatures(alignFrame);
 353
 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 }