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