Merge branch 'patch/JAL-4345_pae_epas1_doubleclick' into develop
[jalview.git] / 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 }