Merge branch 'patch/JAL-4345_pae_epas1_doubleclick' into develop
[jalview.git] / src / jalview / gui / AppVarna.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.util.Collection;
26 import java.util.Hashtable;
27 import java.util.LinkedHashMap;
28 import java.util.List;
29 import java.util.Map;
30
31 import javax.swing.JInternalFrame;
32 import javax.swing.JSplitPane;
33 import javax.swing.event.InternalFrameAdapter;
34 import javax.swing.event.InternalFrameEvent;
35
36 import fr.orsay.lri.varna.VARNAPanel;
37 import fr.orsay.lri.varna.exceptions.ExceptionFileFormatOrSyntax;
38 import fr.orsay.lri.varna.exceptions.ExceptionLoadingFailed;
39 import fr.orsay.lri.varna.exceptions.ExceptionUnmatchedClosingParentheses;
40 import fr.orsay.lri.varna.interfaces.InterfaceVARNASelectionListener;
41 import fr.orsay.lri.varna.models.BaseList;
42 import fr.orsay.lri.varna.models.FullBackup;
43 import fr.orsay.lri.varna.models.annotations.HighlightRegionAnnotation;
44 import fr.orsay.lri.varna.models.rna.ModeleBase;
45 import fr.orsay.lri.varna.models.rna.RNA;
46 import jalview.analysis.AlignSeq;
47 import jalview.datamodel.AlignmentAnnotation;
48 import jalview.datamodel.ColumnSelection;
49 import jalview.datamodel.HiddenColumns;
50 import jalview.datamodel.RnaViewerModel;
51 import jalview.datamodel.SequenceGroup;
52 import jalview.datamodel.SequenceI;
53 import jalview.ext.varna.RnaModel;
54 import jalview.structure.SecondaryStructureListener;
55 import jalview.structure.SelectionListener;
56 import jalview.structure.SelectionSource;
57 import jalview.structure.StructureSelectionManager;
58 import jalview.structure.VamsasSource;
59 import jalview.util.Comparison;
60 import jalview.util.MessageManager;
61 import jalview.util.ShiftList;
62
63 public class AppVarna extends JInternalFrame
64         implements SelectionListener, SecondaryStructureListener,
65         InterfaceVARNASelectionListener, VamsasSource
66 {
67   private static final byte[] PAIRS = new byte[] { '(', ')', '[', ']', '{',
68       '}', '<', '>' };
69
70   private AppVarnaBinding vab;
71
72   private AlignmentPanel ap;
73
74   private String viewId;
75
76   private StructureSelectionManager ssm;
77
78   /*
79    * Lookup for sequence and annotation mapped to each RNA in the viewer. Using
80    * a linked hashmap means that order is preserved when saved to the project.
81    */
82   private Map<RNA, RnaModel> models = new LinkedHashMap<RNA, RnaModel>();
83
84   private Map<RNA, ShiftList> offsets = new Hashtable<RNA, ShiftList>();
85
86   private Map<RNA, ShiftList> offsetsInv = new Hashtable<RNA, ShiftList>();
87
88   private JSplitPane split;
89
90   private VarnaHighlighter mouseOverHighlighter = new VarnaHighlighter();
91
92   private VarnaHighlighter selectionHighlighter = new VarnaHighlighter();
93
94   private class VarnaHighlighter
95   {
96     private HighlightRegionAnnotation _lastHighlight;
97
98     private RNA _lastRNAhighlighted = null;
99
100     public VarnaHighlighter()
101     {
102
103     }
104
105     /**
106      * Constructor when restoring from Varna session, including any highlight
107      * state
108      * 
109      * @param rna
110      */
111     public VarnaHighlighter(RNA rna)
112     {
113       // TODO nice try but doesn't work; do we need a highlighter per model?
114       _lastRNAhighlighted = rna;
115       List<HighlightRegionAnnotation> highlights = rna.getHighlightRegion();
116       if (highlights != null && !highlights.isEmpty())
117       {
118         _lastHighlight = highlights.get(0);
119       }
120     }
121
122     /**
123      * highlight a region from start to end (inclusive) on rna
124      * 
125      * @param rna
126      * @param start
127      *          - first base pair index (from 0)
128      * @param end
129      *          - last base pair index (from 0)
130      */
131     public void highlightRegion(RNA rna, int start, int end)
132     {
133       clearLastSelection();
134       HighlightRegionAnnotation highlight = new HighlightRegionAnnotation(
135               rna.getBasesBetween(start, end));
136       rna.addHighlightRegion(highlight);
137       _lastHighlight = highlight;
138       _lastRNAhighlighted = rna;
139     }
140
141     public HighlightRegionAnnotation getLastHighlight()
142     {
143       return _lastHighlight;
144     }
145
146     /**
147      * Clears all structure selection and refreshes the display
148      */
149     public void clearSelection()
150     {
151       if (_lastRNAhighlighted != null)
152       {
153         _lastRNAhighlighted.getHighlightRegion().clear();
154         vab.updateSelectedRNA(_lastRNAhighlighted);
155         _lastRNAhighlighted = null;
156         _lastHighlight = null;
157       }
158     }
159
160     /**
161      * Clear the last structure selection
162      */
163     public void clearLastSelection()
164     {
165       if (_lastRNAhighlighted != null)
166       {
167         _lastRNAhighlighted.removeHighlightRegion(_lastHighlight);
168         _lastRNAhighlighted = null;
169         _lastHighlight = null;
170       }
171     }
172   }
173
174   /**
175    * Constructor
176    * 
177    * @param seq
178    *          the RNA sequence
179    * @param aa
180    *          the annotation with the secondary structure string
181    * @param ap
182    *          the AlignmentPanel creating this object
183    */
184   public AppVarna(SequenceI seq, AlignmentAnnotation aa, AlignmentPanel ap)
185   {
186     this(ap);
187
188     String sname = aa.sequenceRef == null
189             ? "secondary structure (alignment)"
190             : seq.getName() + " structure";
191     String theTitle = sname
192             + (aa.sequenceRef == null ? " trimmed to " + seq.getName()
193                     : "");
194     theTitle = MessageManager.formatMessage("label.varna_params",
195             new String[]
196             { theTitle });
197     setTitle(theTitle);
198
199     String gappedTitle = sname + " (with gaps)";
200     RnaModel gappedModel = new RnaModel(gappedTitle, aa, seq, null, true);
201     addModel(gappedModel, gappedTitle);
202
203     String trimmedTitle = "trimmed " + sname;
204     RnaModel trimmedModel = new RnaModel(trimmedTitle, aa, seq, null,
205             false);
206     addModel(trimmedModel, trimmedTitle);
207     vab.setSelectedIndex(0);
208   }
209
210   /**
211    * Constructor that links the viewer to a parent panel (but has no structures
212    * yet - use addModel to add them)
213    * 
214    * @param ap
215    */
216   protected AppVarna(AlignmentPanel ap)
217   {
218     this.setFrameIcon(null);
219     this.ap = ap;
220     this.viewId = System.currentTimeMillis() + "." + this.hashCode();
221     vab = new AppVarnaBinding();
222     initVarna();
223
224     this.ssm = ap.getStructureSelectionManager();
225     ssm.addStructureViewerListener(this);
226     ssm.addSelectionListener(this);
227     addInternalFrameListener(new InternalFrameAdapter()
228     {
229       @Override
230       public void internalFrameClosed(InternalFrameEvent evt)
231       {
232         close();
233       }
234     });
235   }
236
237   /**
238    * Constructor given viewer data read from a saved project file
239    * 
240    * @param model
241    * @param ap
242    *          the (or a) parent alignment panel
243    */
244   public AppVarna(RnaViewerModel model, AlignmentPanel ap)
245   {
246     this(ap);
247     setTitle(model.title);
248     this.viewId = model.viewId;
249     setBounds(model.x, model.y, model.width, model.height);
250     this.split.setDividerLocation(model.dividerLocation);
251   }
252
253   /**
254    * Constructs a split pane with an empty selection list and display panel, and
255    * adds it to the desktop
256    */
257   public void initVarna()
258   {
259     VARNAPanel varnaPanel = vab.get_varnaPanel();
260     setBackground(Color.white);
261     split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true,
262             vab.getListPanel(), varnaPanel);
263     getContentPane().setLayout(new BorderLayout());
264     getContentPane().add(split, BorderLayout.CENTER);
265
266     varnaPanel.addSelectionListener(this);
267     jalview.gui.Desktop.addInternalFrame(this, "", getBounds().width,
268             getBounds().height);
269     this.pack();
270     showPanel(true);
271   }
272
273   /**
274    * Constructs a new RNA model from the given one, without gaps. Also
275    * calculates and saves a 'shift list'
276    * 
277    * @param rna
278    * @param name
279    * @return
280    */
281   public RNA trimRNA(RNA rna, String name)
282   {
283     ShiftList offset = new ShiftList();
284
285     RNA rnaTrim = new RNA(name);
286     try
287     {
288       String structDBN = rna.getStructDBN(true);
289       rnaTrim.setRNA(rna.getSeq(), replaceOddGaps(structDBN));
290     } catch (ExceptionUnmatchedClosingParentheses e2)
291     {
292       e2.printStackTrace();
293     } catch (ExceptionFileFormatOrSyntax e3)
294     {
295       e3.printStackTrace();
296     }
297
298     String seq = rnaTrim.getSeq();
299     StringBuilder struc = new StringBuilder(256);
300     struc.append(rnaTrim.getStructDBN(true));
301     int ofstart = -1;
302     int sleng = seq.length();
303
304     for (int i = 0; i < sleng; i++)
305     {
306       if (Comparison.isGap(seq.charAt(i)))
307       {
308         if (ofstart == -1)
309         {
310           ofstart = i;
311         }
312         /*
313          * mark base or base & pair in the structure with *
314          */
315         if (!rnaTrim.findPair(i).isEmpty())
316         {
317           int m = rnaTrim.findPair(i).get(1);
318           int l = rnaTrim.findPair(i).get(0);
319
320           struc.replace(m, m + 1, "*");
321           struc.replace(l, l + 1, "*");
322         }
323         else
324         {
325           struc.replace(i, i + 1, "*");
326         }
327       }
328       else
329       {
330         if (ofstart > -1)
331         {
332           offset.addShift(offset.shift(ofstart), ofstart - i);
333           ofstart = -1;
334         }
335       }
336     }
337     // final gap
338     if (ofstart > -1)
339     {
340       offset.addShift(offset.shift(ofstart), ofstart - sleng);
341       ofstart = -1;
342     }
343
344     /*
345      * remove the marked gaps from the structure
346      */
347     String newStruc = struc.toString().replace("*", "");
348
349     /*
350      * remove gaps from the sequence
351      */
352     String newSeq = AlignSeq.extractGaps(Comparison.GapChars, seq);
353
354     try
355     {
356       rnaTrim.setRNA(newSeq, newStruc);
357       registerOffset(rnaTrim, offset);
358     } catch (ExceptionUnmatchedClosingParentheses e)
359     {
360       e.printStackTrace();
361     } catch (ExceptionFileFormatOrSyntax e)
362     {
363       e.printStackTrace();
364     }
365     return rnaTrim;
366   }
367
368   /**
369    * Save the sequence to structure mapping, and also its inverse.
370    * 
371    * @param rnaTrim
372    * @param offset
373    */
374   private void registerOffset(RNA rnaTrim, ShiftList offset)
375   {
376     offsets.put(rnaTrim, offset);
377     offsetsInv.put(rnaTrim, offset.getInverse());
378   }
379
380   public void showPanel(boolean show)
381   {
382     this.setVisible(show);
383   }
384
385   /**
386    * If a mouseOver event from the AlignmentPanel is noticed the currently
387    * selected RNA in the VARNA window is highlighted at the specific position.
388    * To be able to remove it before the next highlight it is saved in
389    * _lastHighlight
390    * 
391    * @param sequence
392    * @param index
393    *          the aligned sequence position (base 0)
394    * @param position
395    *          the dataset sequence position (base 1)
396    */
397   @Override
398   public void mouseOverSequence(SequenceI sequence, final int index,
399           final int position)
400   {
401     RNA rna = vab.getSelectedRNA();
402     if (rna == null)
403     {
404       return;
405     }
406     RnaModel rnaModel = models.get(rna);
407     if (rnaModel.seq == sequence)
408     {
409       int highlightPos = rnaModel.gapped ? index
410               : position - sequence.getStart();
411       mouseOverHighlighter.highlightRegion(rna, highlightPos, highlightPos);
412       vab.updateSelectedRNA(rna);
413     }
414   }
415
416   @Override
417   public void selection(SequenceGroup seqsel, ColumnSelection colsel,
418           HiddenColumns hidden, SelectionSource source)
419   {
420     if (source != ap.av)
421     {
422       // ignore events from anything but our parent alignpanel
423       // TODO - reuse many-one panel-view system in jmol viewer
424       return;
425     }
426     RNA rna = vab.getSelectedRNA();
427     if (rna == null)
428     {
429       return;
430     }
431
432     RnaModel rnaModel = models.get(rna);
433
434     if (seqsel != null && seqsel.getSize() > 0
435             && seqsel.contains(rnaModel.seq))
436     {
437       int start = seqsel.getStartRes(), end = seqsel.getEndRes();
438       if (rnaModel.gapped)
439       {
440         ShiftList shift = offsets.get(rna);
441         if (shift != null)
442         {
443           start = shift.shift(start);
444           end = shift.shift(end);
445         }
446       }
447       else
448       {
449         start = rnaModel.seq.findPosition(start) - rnaModel.seq.getStart();
450         end = rnaModel.seq.findPosition(end) - rnaModel.seq.getStart();
451       }
452
453       selectionHighlighter.highlightRegion(rna, start, end);
454       selectionHighlighter.getLastHighlight()
455               .setOutlineColor(seqsel.getOutlineColour());
456       // TODO - translate column markings to positions on structure if present.
457       vab.updateSelectedRNA(rna);
458     }
459     else
460     {
461       selectionHighlighter.clearSelection();
462     }
463   }
464
465   /**
466    * Respond to a change of the base hovered over in the Varna viewer
467    */
468   @Override
469   public void onHoverChanged(ModeleBase previousBase, ModeleBase newBase)
470   {
471     RNA rna = vab.getSelectedRNA();
472     ShiftList shift = offsetsInv.get(rna);
473     SequenceI seq = models.get(rna).seq;
474     if (newBase != null && seq != null)
475     {
476       if (shift != null)
477       {
478         int i = shift.shift(newBase.getIndex());
479         // jalview.bin.Console.errPrintln("shifted "+(arg1.getIndex())+" to
480         // "+i);
481         ssm.mouseOverVamsasSequence(seq, i, this);
482       }
483       else
484       {
485         ssm.mouseOverVamsasSequence(seq, newBase.getIndex(), this);
486       }
487     }
488   }
489
490   @Override
491   public void onSelectionChanged(BaseList arg0, BaseList arg1,
492           BaseList arg2)
493   {
494     // TODO translate selected regions in VARNA to a selection on the
495     // alignpanel.
496
497   }
498
499   /**
500    * Returns the path to a temporary file containing a representation of the
501    * state of one Varna display
502    * 
503    * @param rna
504    * 
505    * @return
506    */
507   public String getStateInfo(RNA rna)
508   {
509     return vab.getStateInfo(rna);
510   }
511
512   public AlignmentPanel getAlignmentPanel()
513   {
514     return ap;
515   }
516
517   public String getViewId()
518   {
519     return viewId;
520   }
521
522   /**
523    * Returns true if any of the viewer's models (not necessarily the one
524    * currently displayed) is for the given sequence
525    * 
526    * @param seq
527    * @return
528    */
529   public boolean isListeningFor(SequenceI seq)
530   {
531     for (RnaModel model : models.values())
532     {
533       if (model.seq == seq)
534       {
535         return true;
536       }
537     }
538     return false;
539   }
540
541   /**
542    * Returns a value representing the horizontal split divider location
543    * 
544    * @return
545    */
546   public int getDividerLocation()
547   {
548     return split == null ? 0 : split.getDividerLocation();
549   }
550
551   /**
552    * Tidy up as necessary when the viewer panel is closed
553    */
554   protected void close()
555   {
556     /*
557      * Deregister as a listener, to release references to this object
558      */
559     if (ssm != null)
560     {
561       ssm.removeStructureViewerListener(AppVarna.this, null);
562       ssm.removeSelectionListener(AppVarna.this);
563     }
564   }
565
566   /**
567    * Returns the secondary structure annotation that this viewer displays for
568    * the given sequence
569    * 
570    * @return
571    */
572   public AlignmentAnnotation getAnnotation(SequenceI seq)
573   {
574     for (RnaModel model : models.values())
575     {
576       if (model.seq == seq)
577       {
578         return model.ann;
579       }
580     }
581     return null;
582   }
583
584   public int getSelectedIndex()
585   {
586     return this.vab.getSelectedIndex();
587   }
588
589   /**
590    * Returns the set of models shown by the viewer
591    * 
592    * @return
593    */
594   public Collection<RnaModel> getModels()
595   {
596     return models.values();
597   }
598
599   /**
600    * Add a model (e.g. loaded from project file)
601    * 
602    * @param rna
603    * @param modelName
604    */
605   public RNA addModel(RnaModel model, String modelName)
606   {
607     if (!model.ann.isValidStruc())
608     {
609       throw new IllegalArgumentException(
610               "Invalid RNA structure annotation");
611     }
612
613     /*
614      * opened on request in Jalview session
615      */
616     RNA rna = new RNA(modelName);
617     String struc = model.ann.getRNAStruc();
618     struc = replaceOddGaps(struc);
619
620     String strucseq = model.seq.getSequenceAsString();
621     try
622     {
623       rna.setRNA(strucseq, struc);
624     } catch (ExceptionUnmatchedClosingParentheses e2)
625     {
626       e2.printStackTrace();
627     } catch (ExceptionFileFormatOrSyntax e3)
628     {
629       e3.printStackTrace();
630     }
631
632     if (!model.gapped)
633     {
634       rna = trimRNA(rna, modelName);
635     }
636     models.put(rna, new RnaModel(modelName, model.ann, model.seq, rna,
637             model.gapped));
638     vab.addStructure(rna);
639     return rna;
640   }
641
642   /**
643    * Constructs a shift list that describes the gaps in the sequence
644    * 
645    * @param seq
646    * @return
647    */
648   protected ShiftList buildOffset(SequenceI seq)
649   {
650     // TODO refactor to avoid duplication with trimRNA()
651     // TODO JAL-1789 bugs in use of ShiftList here
652     ShiftList offset = new ShiftList();
653     int ofstart = -1;
654     int sleng = seq.getLength();
655
656     for (int i = 0; i < sleng; i++)
657     {
658       if (Comparison.isGap(seq.getCharAt(i)))
659       {
660         if (ofstart == -1)
661         {
662           ofstart = i;
663         }
664       }
665       else
666       {
667         if (ofstart > -1)
668         {
669           offset.addShift(offset.shift(ofstart), ofstart - i);
670           ofstart = -1;
671         }
672       }
673     }
674     // final gap
675     if (ofstart > -1)
676     {
677       offset.addShift(offset.shift(ofstart), ofstart - sleng);
678       ofstart = -1;
679     }
680     return offset;
681   }
682
683   /**
684    * Set the selected index in the model selection list
685    * 
686    * @param selectedIndex
687    */
688   public void setInitialSelection(final int selectedIndex)
689   {
690     /*
691      * empirically it needs a second for Varna/AWT to finish loading/drawing
692      * models for this to work; SwingUtilities.invokeLater _not_ a solution;
693      * explanation and/or better solution welcome!
694      */
695     synchronized (this)
696     {
697       try
698       {
699         wait(1000);
700       } catch (InterruptedException e)
701       {
702         // meh
703       }
704     }
705     vab.setSelectedIndex(selectedIndex);
706   }
707
708   /**
709    * Add a model with associated Varna session file
710    * 
711    * @param rna
712    * @param modelName
713    */
714   public RNA addModelSession(RnaModel model, String modelName,
715           String sessionFile)
716   {
717     if (!model.ann.isValidStruc())
718     {
719       throw new IllegalArgumentException(
720               "Invalid RNA structure annotation");
721     }
722
723     try
724     {
725       FullBackup fromSession = vab.vp.loadSession(sessionFile);
726       vab.addStructure(fromSession.rna, fromSession.config);
727       RNA rna = fromSession.rna;
728       // copy the model, but now including the RNA object
729       RnaModel newModel = new RnaModel(model.title, model.ann, model.seq,
730               rna, model.gapped);
731       if (!model.gapped)
732       {
733         registerOffset(rna, buildOffset(model.seq));
734       }
735       models.put(rna, newModel);
736       // capture rna selection state when saved
737       selectionHighlighter = new VarnaHighlighter(rna);
738       return fromSession.rna;
739     } catch (ExceptionLoadingFailed e)
740     {
741       System.err
742               .println("Error restoring Varna session: " + e.getMessage());
743       return null;
744     }
745   }
746
747   /**
748    * Replace everything except RNA secondary structure characters with a period
749    * 
750    * @param s
751    * @return
752    */
753   public static String replaceOddGaps(String s)
754   {
755     if (s == null)
756     {
757       return null;
758     }
759
760     // this is measured to be 10 times faster than a regex replace
761     boolean changed = false;
762     byte[] bytes = s.getBytes();
763     for (int i = 0; i < bytes.length; i++)
764     {
765       boolean ok = false;
766       // todo check for ((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')) if
767       // wanted also
768       for (int j = 0; !ok && (j < PAIRS.length); j++)
769       {
770         if (bytes[i] == PAIRS[j])
771         {
772           ok = true;
773         }
774       }
775       if (!ok)
776       {
777         bytes[i] = '.';
778         changed = true;
779       }
780     }
781     return changed ? new String(bytes) : s;
782   }
783 }