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