src/jalview/gui/AppJmol.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.gui;
  22
  23 import java.awt.BorderLayout;
  24 import java.awt.Color;
  25 import java.awt.Dimension;
  26 import java.awt.Font;
  27 import java.awt.Graphics;
  28 import java.awt.Graphics2D;
  29 import java.awt.RenderingHints;
  30 import java.io.File;
  31 import java.util.List;
  32 import java.util.Locale;
  33 import java.util.Map;
  34 import java.util.concurrent.Executors;
  35
  36 import javax.swing.JPanel;
  37 import javax.swing.JSplitPane;
  38 import javax.swing.SwingUtilities;
  39 import javax.swing.event.InternalFrameAdapter;
  40 import javax.swing.event.InternalFrameEvent;
  41
  42 import jalview.api.AlignmentViewPanel;
  43 import jalview.bin.Console;
  44 import jalview.datamodel.PDBEntry;
  45 import jalview.datamodel.SequenceI;
  46 import jalview.datamodel.StructureViewerModel;
  47 import jalview.datamodel.StructureViewerModel.StructureData;
  48 import jalview.gui.ImageExporter.ImageWriterI;
  49 import jalview.gui.StructureViewer.ViewerType;
  50 import jalview.io.exceptions.ImageOutputException;
  51 import jalview.structure.StructureCommand;
  52 import jalview.structures.models.AAStructureBindingModel;
  53 import jalview.util.BrowserLauncher;
  54 import jalview.util.ImageMaker;
  55 import jalview.util.ImageMaker.TYPE;
  56 import jalview.util.MessageManager;
  57 import jalview.util.Platform;
  58 import jalview.util.imagemaker.BitmapImageSizing;
  59
  60 public class AppJmol extends StructureViewerBase
  61 {
  62   // ms to wait for Jmol to load files
  63   private static final int JMOL_LOAD_TIMEOUT = 20000;
  64
  65   private static final String SPACE = " ";
  66
  67   private static final String QUOTE = "\"";
  68
  69   AppJmolBinding jmb;
  70
  71   JPanel scriptWindow;
  72
  73   JSplitPane splitPane;
  74
  75   RenderPanel renderPanel;
  76
  77   /**
  78    *
  79    * @param files
  80    * @param ids
  81    * @param seqs
  82    * @param ap
  83    * @param usetoColour
  84    *          - add the alignment panel to the list used for colouring these
  85    *          structures
  86    * @param useToAlign
  87    *          - add the alignment panel to the list used for aligning these
  88    *          structures
  89    * @param leaveColouringToJmol
  90    *          - do not update the colours from any other source. Jmol is
  91    *          handling them
  92    * @param loadStatus
  93    * @param bounds
  94    * @param viewid
  95    */
  96   public AppJmol(StructureViewerModel viewerModel, AlignmentPanel ap,
  97           String sessionFile, String viewid)
  98   {
  99     Map<File, StructureData> pdbData = viewerModel.getFileData();
 100     PDBEntry[] pdbentrys = new PDBEntry[pdbData.size()];
 101     SequenceI[][] seqs = new SequenceI[pdbData.size()][];
 102     int i = 0;
 103     for (StructureData data : pdbData.values())
 104     {
 105       PDBEntry pdbentry = new PDBEntry(data.getPdbId(), null,
 106               PDBEntry.Type.PDB, data.getFilePath());
 107       pdbentrys[i] = pdbentry;
 108       List<SequenceI> sequencesForPdb = data.getSeqList();
 109       seqs[i] = sequencesForPdb
 110               .toArray(new SequenceI[sequencesForPdb.size()]);
 111       i++;
 112     }
 113
 114     // TODO: check if protocol is needed to be set, and if chains are
 115     // autodiscovered.
 116     jmb = new AppJmolBinding(this, ap.getStructureSelectionManager(),
 117             pdbentrys, seqs, null);
 118
 119     jmb.setLoadingFromArchive(true);
 120     addAlignmentPanel(ap);
 121     if (viewerModel.isAlignWithPanel())
 122     {
 123       useAlignmentPanelForSuperposition(ap);
 124     }
 125     initMenus();
 126     boolean useToColour = viewerModel.isColourWithAlignPanel();
 127     boolean leaveColouringToJmol = viewerModel.isColourByViewer();
 128     if (leaveColouringToJmol || !useToColour)
 129     {
 130       jmb.setColourBySequence(false);
 131       seqColour.setSelected(false);
 132       viewerColour.setSelected(true);
 133     }
 134     else if (useToColour)
 135     {
 136       useAlignmentPanelForColourbyseq(ap);
 137       jmb.setColourBySequence(true);
 138       seqColour.setSelected(true);
 139       viewerColour.setSelected(false);
 140     }
 141
 142     this.setBounds(viewerModel.getX(), viewerModel.getY(),
 143             viewerModel.getWidth(), viewerModel.getHeight());
 144     setViewId(viewid);
 145
 146     this.addInternalFrameListener(new InternalFrameAdapter()
 147     {
 148       @Override
 149       public void internalFrameClosing(
 150               InternalFrameEvent internalFrameEvent)
 151       {
 152         closeViewer(false);
 153       }
 154     });
 155     StringBuilder cmd = new StringBuilder();
 156     cmd.append("load FILES ").append(QUOTE)
 157             .append(Platform.escapeBackslashes(sessionFile)).append(QUOTE);
 158     initJmol(cmd.toString());
 159   }
 160
 161   @Override
 162   protected void initMenus()
 163   {
 164     super.initMenus();
 165
 166     viewerColour
 167             .setText(MessageManager.getString("label.colour_with_jmol"));
 168     viewerColour.setToolTipText(MessageManager
 169             .getString("label.let_jmol_manage_structure_colours"));
 170   }
 171
 172   /**
 173    * display a single PDB structure in a new Jmol view
 174    *
 175    * @param pdbentry
 176    * @param seq
 177    * @param chains
 178    * @param ap
 179    */
 180   public AppJmol(PDBEntry pdbentry, SequenceI[] seq, String[] chains,
 181           final AlignmentPanel ap)
 182   {
 183     setProgressIndicator(ap.alignFrame);
 184
 185     openNewJmol(ap, alignAddedStructures, new PDBEntry[] { pdbentry },
 186             new SequenceI[][]
 187             { seq });
 188   }
 189
 190   private void openNewJmol(AlignmentPanel ap, boolean alignAdded,
 191           PDBEntry[] pdbentrys, SequenceI[][] seqs)
 192   {
 193     setProgressIndicator(ap.alignFrame);
 194     jmb = new AppJmolBinding(this, ap.getStructureSelectionManager(),
 195             pdbentrys, seqs, null);
 196     addAlignmentPanel(ap);
 197     useAlignmentPanelForColourbyseq(ap);
 198
 199     alignAddedStructures = alignAdded;
 200     if (pdbentrys.length > 1)
 201     {
 202       useAlignmentPanelForSuperposition(ap);
 203     }
 204
 205     jmb.setColourBySequence(true);
 206     setSize(400, 400); // probably should be a configurable/dynamic default here
 207     initMenus();
 208     addingStructures = false;
 209     worker = new Thread(this);
 210     worker.start();
 211
 212     this.addInternalFrameListener(new InternalFrameAdapter()
 213     {
 214       @Override
 215       public void internalFrameClosing(
 216               InternalFrameEvent internalFrameEvent)
 217       {
 218         closeViewer(false);
 219       }
 220     });
 221
 222   }
 223
 224   /**
 225    * create a new Jmol containing several structures optionally superimposed
 226    * using the given alignPanel.
 227    *
 228    * @param ap
 229    * @param alignAdded
 230    *          - true to superimpose
 231    * @param pe
 232    * @param seqs
 233    */
 234   public AppJmol(AlignmentPanel ap, boolean alignAdded, PDBEntry[] pe,
 235           SequenceI[][] seqs)
 236   {
 237     openNewJmol(ap, alignAdded, pe, seqs);
 238   }
 239
 240   void initJmol(String command)
 241   {
 242     jmb.setFinishedInit(false);
 243     renderPanel = new RenderPanel();
 244     // TODO: consider waiting until the structure/view is fully loaded before
 245     // displaying
 246     this.getContentPane().add(renderPanel, java.awt.BorderLayout.CENTER);
 247     jalview.gui.Desktop.addInternalFrame(this, jmb.getViewerTitle(),
 248             getBounds().width, getBounds().height);
 249     if (scriptWindow == null)
 250     {
 251       BorderLayout bl = new BorderLayout();
 252       bl.setHgap(0);
 253       bl.setVgap(0);
 254       scriptWindow = new JPanel(bl);
 255       scriptWindow.setVisible(false);
 256     }
 257
 258     jmb.allocateViewer(renderPanel, true, "", null, null, "", scriptWindow,
 259             null);
 260     // jmb.newJmolPopup("Jmol");
 261     if (command == null)
 262     {
 263       command = "";
 264     }
 265     jmb.executeCommand(new StructureCommand(command), false);
 266     jmb.executeCommand(new StructureCommand("set hoverDelay=0.1"), false);
 267     jmb.executeCommand(new StructureCommand("set antialiasdisplay on"),
 268             false);
 269     jmb.setFinishedInit(true);
 270   }
 271
 272   @Override
 273   public void run()
 274   {
 275     _started = true;
 276     try
 277     {
 278       List<String> files = jmb.fetchPdbFiles(this);
 279       if (files.size() > 0)
 280       {
 281         showFilesInViewer(files);
 282       }
 283     } finally
 284     {
 285       _started = false;
 286       worker = null;
 287     }
 288   }
 289
 290   /**
 291    * Either adds the given files to a structure viewer or opens a new viewer to
 292    * show them
 293    *
 294    * @param files
 295    *          list of absolute paths to structure files
 296    */
 297   void showFilesInViewer(List<String> files)
 298   {
 299     long lastnotify = jmb.getLoadNotifiesHandled();
 300     StringBuilder fileList = new StringBuilder();
 301     for (String s : files)
 302     {
 303       fileList.append(SPACE).append(QUOTE)
 304               .append(Platform.escapeBackslashes(s)).append(QUOTE);
 305     }
 306     String filesString = fileList.toString();
 307
 308     if (!addingStructures)
 309     {
 310       try
 311       {
 312         initJmol("load FILES " + filesString);
 313       } catch (OutOfMemoryError oomerror)
 314       {
 315         new OOMWarning("When trying to open the Jmol viewer!", oomerror);
 316         Console.debug("File locations are " + filesString);
 317       } catch (Exception ex)
 318       {
 319         Console.error("Couldn't open Jmol viewer!", ex);
 320         ex.printStackTrace();
 321         return;
 322       }
 323     }
 324     else
 325     {
 326       StringBuilder cmd = new StringBuilder();
 327       cmd.append("loadingJalviewdata=true\nload APPEND ");
 328       cmd.append(filesString);
 329       cmd.append("\nloadingJalviewdata=null");
 330       final StructureCommand command = new StructureCommand(cmd.toString());
 331       lastnotify = jmb.getLoadNotifiesHandled();
 332
 333       try
 334       {
 335         jmb.executeCommand(command, false);
 336       } catch (OutOfMemoryError oomerror)
 337       {
 338         new OOMWarning("When trying to add structures to the Jmol viewer!",
 339                 oomerror);
 340         Console.debug("File locations are " + filesString);
 341         return;
 342       } catch (Exception ex)
 343       {
 344         Console.error("Couldn't add files to Jmol viewer!", ex);
 345         ex.printStackTrace();
 346         return;
 347       }
 348     }
 349
 350     // need to wait around until script has finished
 351     int waitMax = JMOL_LOAD_TIMEOUT;
 352     int waitFor = 35;
 353     int waitTotal = 0;
 354     while (addingStructures ? lastnotify >= jmb.getLoadNotifiesHandled()
 355             : !(jmb.isFinishedInit() && jmb.getStructureFiles() != null
 356                     && jmb.getStructureFiles().length == files.size()))
 357     {
 358       try
 359       {
 360         Console.debug("Waiting around for jmb notify.");
 361         waitTotal += waitFor;
 362
 363         // Thread.sleep() throws an exception in JS
 364         Thread.sleep(waitFor);
 365       } catch (Exception e)
 366       {
 367       }
 368       if (waitTotal > waitMax)
 369       {
 370         jalview.bin.Console.errPrintln(
 371                 "Timed out waiting for Jmol to load files after "
 372                         + waitTotal + "ms");
 373         // jalview.bin.Console.errPrintln("finished: " + jmb.isFinishedInit()
 374         // + "; loaded: " + Arrays.toString(jmb.getPdbFile())
 375         // + "; files: " + files.toString());
 376         jmb.getStructureFiles();
 377         break;
 378       }
 379     }
 380
 381     // refresh the sequence colours for the new structure(s)
 382     for (AlignmentViewPanel ap : _colourwith)
 383     {
 384       jmb.updateColours(ap);
 385     }
 386     // do superposition if asked to
 387     if (alignAddedStructures)
 388     {
 389       alignAddedStructures();
 390     }
 391     addingStructures = false;
 392   }
 393
 394   /**
 395    * Queues a thread to align structures with Jalview alignments
 396    */
 397   void alignAddedStructures()
 398   {
 399     javax.swing.SwingUtilities.invokeLater(new Runnable()
 400     {
 401       @Override
 402       public void run()
 403       {
 404         if (jmb.jmolViewer.isScriptExecuting())
 405         {
 406           SwingUtilities.invokeLater(this);
 407           try
 408           {
 409             Thread.sleep(5);
 410           } catch (InterruptedException q)
 411           {
 412           }
 413           return;
 414         }
 415         else
 416         {
 417           alignStructsWithAllAlignPanels();
 418         }
 419       }
 420     });
 421
 422   }
 423
 424   /**
 425    * Outputs the Jmol viewer image as an image file, after prompting the user to
 426    * choose a file and (for EPS) choice of Text or Lineart character rendering
 427    * (unless a preference for this is set)
 428    *
 429    * @param type
 430    */
 431   @Override
 432   public void makePDBImage(ImageMaker.TYPE type)
 433   {
 434     try
 435     {
 436       makePDBImage(null, type, null,
 437               BitmapImageSizing.defaultBitmapImageSizing());
 438     } catch (ImageOutputException ioex)
 439     {
 440       Console.error("Unexpected error whilst writing " + type.toString(),
 441               ioex);
 442     }
 443   }
 444
 445   public void makePDBImage(File file, ImageMaker.TYPE type, String renderer,
 446           BitmapImageSizing userBis) throws ImageOutputException
 447   {
 448     int width = getWidth();
 449     int height = getHeight();
 450
 451     BitmapImageSizing bis = ImageMaker.getScaleWidthHeight(width, height,
 452             userBis);
 453     float usescale = bis.scale();
 454     int usewidth = bis.width();
 455     int useheight = bis.height();
 456
 457     ImageWriterI writer = new ImageWriterI()
 458     {
 459       @Override
 460       public void exportImage(Graphics g) throws Exception
 461       {
 462         Graphics2D ig2 = (Graphics2D) g;
 463         ig2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 464                 RenderingHints.VALUE_ANTIALIAS_ON);
 465         if (type == TYPE.PNG && usescale > 0.0f)
 466         {
 467           // for a scaled image, this scales down a bigger image to give the
 468           // right resolution
 469           if (usescale > 0.0f)
 470           {
 471             ig2.scale(1 / usescale, 1 / usescale);
 472           }
 473         }
 474
 475         jmb.jmolViewer.requestRepaintAndWait("image export");
 476         jmb.jmolViewer.renderScreenImage(ig2, usewidth, useheight);
 477       }
 478     };
 479     String view = MessageManager.getString("action.view")
 480             .toLowerCase(Locale.ROOT);
 481     final ImageExporter exporter = new ImageExporter(writer,
 482             getProgressIndicator(), type, getTitle());
 483
 484     final Throwable[] exceptions = new Throwable[1];
 485     exceptions[0] = null;
 486     final AppJmol us = this;
 487     try
 488     {
 489       Thread runner = Executors.defaultThreadFactory()
 490               .newThread(new Runnable()
 491               {
 492                 @Override
 493                 public void run()
 494                 {
 495                   try
 496                   {
 497                     exporter.doExport(file, us, width, height, view,
 498                             renderer, userBis);
 499                   } catch (Throwable t)
 500                   {
 501                     exceptions[0] = t;
 502                   }
 503                 }
 504               });
 505       runner.start();
 506       long time = 0;
 507       do
 508       {
 509         Thread.sleep(25);
 510       } while (runner.isAlive() && time++ < 4000);
 511       if (time >= 4000)
 512       {
 513         runner.interrupt();
 514         throw new ImageOutputException(
 515                 "Jmol took too long to export. Waited for 100 seconds.");
 516       }
 517     } catch (Throwable e)
 518     {
 519       throw new ImageOutputException(
 520               "Unexpected error when generating image", e);
 521     }
 522     if (exceptions[0] != null)
 523     {
 524       if (exceptions[0] instanceof ImageOutputException)
 525       {
 526         throw ((ImageOutputException) exceptions[0]);
 527       }
 528       else
 529       {
 530         throw new ImageOutputException(
 531                 "Unexpected error when generating image", exceptions[0]);
 532       }
 533     }
 534   }
 535
 536   @Override
 537   public void showHelp_actionPerformed()
 538   {
 539     try
 540     {
 541       BrowserLauncher // BH 2018
 542               .openURL("http://wiki.jmol.org");// http://jmol.sourceforge.net/docs/JmolUserGuide/");
 543     } catch (Exception ex)
 544     {
 545       jalview.bin.Console
 546               .errPrintln("Show Jmol help failed with: " + ex.getMessage());
 547     }
 548   }
 549
 550   @Override
 551   public void showConsole(boolean showConsole)
 552   {
 553     if (showConsole)
 554     {
 555       if (splitPane == null)
 556       {
 557         splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
 558         splitPane.setTopComponent(renderPanel);
 559         splitPane.setBottomComponent(scriptWindow);
 560         this.getContentPane().add(splitPane, BorderLayout.CENTER);
 561         splitPane.setDividerLocation(getHeight() - 200);
 562         scriptWindow.setVisible(true);
 563         scriptWindow.validate();
 564         splitPane.validate();
 565       }
 566
 567     }
 568     else
 569     {
 570       if (splitPane != null)
 571       {
 572         splitPane.setVisible(false);
 573       }
 574
 575       splitPane = null;
 576
 577       this.getContentPane().add(renderPanel, BorderLayout.CENTER);
 578     }
 579
 580     validate();
 581   }
 582
 583   class RenderPanel extends JPanel
 584   {
 585     final Dimension currentSize = new Dimension();
 586
 587     @Override
 588     public void paintComponent(Graphics g)
 589     {
 590       getSize(currentSize);
 591
 592       if (jmb != null && jmb.hasFileLoadingError())
 593       {
 594         g.setColor(Color.black);
 595         g.fillRect(0, 0, currentSize.width, currentSize.height);
 596         g.setColor(Color.white);
 597         g.setFont(new Font("Verdana", Font.BOLD, 14));
 598         g.drawString(MessageManager.getString("label.error_loading_file")
 599                 + "...", 20, currentSize.height / 2);
 600         StringBuffer sb = new StringBuffer();
 601         int lines = 0;
 602         for (int e = 0; e < jmb.getPdbCount(); e++)
 603         {
 604           sb.append(jmb.getPdbEntry(e).getId());
 605           if (e < jmb.getPdbCount() - 1)
 606           {
 607             sb.append(",");
 608           }
 609
 610           if (e == jmb.getPdbCount() - 1 || sb.length() > 20)
 611           {
 612             lines++;
 613             g.drawString(sb.toString(), 20, currentSize.height / 2
 614                     - lines * g.getFontMetrics().getHeight());
 615           }
 616         }
 617       }
 618       else if (jmb == null || jmb.jmolViewer == null
 619               || !jmb.isFinishedInit())
 620       {
 621         g.setColor(Color.black);
 622         g.fillRect(0, 0, currentSize.width, currentSize.height);
 623         g.setColor(Color.white);
 624         g.setFont(new Font("Verdana", Font.BOLD, 14));
 625         g.drawString(MessageManager.getString("label.retrieving_pdb_data"),
 626                 20, currentSize.height / 2);
 627       }
 628       else
 629       {
 630         jmb.jmolViewer.renderScreenImage(g, currentSize.width,
 631                 currentSize.height);
 632       }
 633     }
 634   }
 635
 636   @Override
 637   public AAStructureBindingModel getBinding()
 638   {
 639     return this.jmb;
 640   }
 641
 642   @Override
 643   public ViewerType getViewerType()
 644   {
 645     return ViewerType.JMOL;
 646   }
 647
 648   @Override
 649   protected String getViewerName()
 650   {
 651     return "Jmol";
 652   }
 653 }