src/jalview/gui/AlignViewport.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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 /*
  22  * Jalview - A Sequence Alignment Editor and Viewer
  23  * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
  24  *
  25  * This program is free software; you can redistribute it and/or
  26  * modify it under the terms of the GNU General Public License
  27  * as published by the Free Software Foundation; either version 2
  28  * of the License, or (at your option) any later version.
  29  *
  30  * This program is distributed in the hope that it will be useful,
  31  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33  * GNU General Public License for more details.
  34  *
  35  * You should have received a copy of the GNU General Public License
  36  * along with this program; if not, write to the Free Software
  37  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  38  */
  39 package jalview.gui;
  40
  41 import jalview.analysis.AlignmentUtils;
  42 import jalview.analysis.AlignmentUtils.MappingResult;
  43 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
  44 import jalview.analysis.NJTree;
  45 import jalview.api.AlignViewportI;
  46 import jalview.api.ViewStyleI;
  47 import jalview.bin.Cache;
  48 import jalview.commands.CommandI;
  49 import jalview.datamodel.Alignment;
  50 import jalview.datamodel.AlignmentI;
  51 import jalview.datamodel.ColumnSelection;
  52 import jalview.datamodel.PDBEntry;
  53 import jalview.datamodel.Sequence;
  54 import jalview.datamodel.SequenceGroup;
  55 import jalview.datamodel.SequenceI;
  56 import jalview.schemes.ColourSchemeProperty;
  57 import jalview.schemes.UserColourScheme;
  58 import jalview.structure.CommandListener;
  59 import jalview.structure.SelectionSource;
  60 import jalview.structure.StructureSelectionManager;
  61 import jalview.structure.VamsasSource;
  62 import jalview.util.MessageManager;
  63 import jalview.viewmodel.AlignmentViewport;
  64 import jalview.ws.params.AutoCalcSetting;
  65
  66 import java.awt.Container;
  67 import java.awt.Dimension;
  68 import java.awt.Font;
  69 import java.awt.Rectangle;
  70 import java.io.File;
  71 import java.util.ArrayDeque;
  72 import java.util.ArrayList;
  73 import java.util.Deque;
  74 import java.util.Hashtable;
  75 import java.util.Set;
  76 import java.util.Vector;
  77
  78 import javax.swing.JInternalFrame;
  79 import javax.swing.JOptionPane;
  80
  81 /**
  82  * DOCUMENT ME!
  83  *
  84  * @author $author$
  85  * @version $Revision: 1.141 $
  86  */
  87 public class AlignViewport extends AlignmentViewport implements
  88         SelectionSource, VamsasSource, AlignViewportI, CommandListener
  89 {
  90   int startRes;
  91
  92   int endRes;
  93
  94   int startSeq;
  95
  96   int endSeq;
  97
  98
  99   SequenceAnnotationOrder sortAnnotationsBy = null;
 100
 101   Font font;
 102
 103   NJTree currentTree = null;
 104
 105   boolean cursorMode = false;
 106
 107   boolean antiAlias = false;
 108
 109   private Rectangle explodedGeometry;
 110
 111   String viewName;
 112
 113   private boolean gatherViewsHere = false;
 114
 115   private Deque<CommandI> historyList = new ArrayDeque<CommandI>();
 116
 117   private Deque<CommandI> redoList = new ArrayDeque<CommandI>();
 118
 119   private AnnotationColumnChooser annotationColumnSelectionState;
 120   /**
 121    * Creates a new AlignViewport object.
 122    *
 123    * @param al
 124    *          alignment to view
 125    */
 126   public AlignViewport(AlignmentI al)
 127   {
 128     setAlignment(al);
 129     init();
 130   }
 131
 132   /**
 133    * Create a new AlignViewport object with a specific sequence set ID
 134    *
 135    * @param al
 136    * @param seqsetid
 137    *          (may be null - but potential for ambiguous constructor exception)
 138    */
 139   public AlignViewport(AlignmentI al, String seqsetid)
 140   {
 141     this(al, seqsetid, null);
 142   }
 143
 144   public AlignViewport(AlignmentI al, String seqsetid, String viewid)
 145   {
 146     sequenceSetID = seqsetid;
 147     viewId = viewid;
 148     // TODO remove these once 2.4.VAMSAS release finished
 149     if (Cache.log != null && Cache.log.isDebugEnabled() && seqsetid != null)
 150     {
 151       Cache.log.debug("Setting viewport's sequence set id : "
 152               + sequenceSetID);
 153     }
 154     if (Cache.log != null && Cache.log.isDebugEnabled() && viewId != null)
 155     {
 156       Cache.log.debug("Setting viewport's view id : " + viewId);
 157     }
 158     setAlignment(al);
 159     init();
 160   }
 161
 162   /**
 163    * Create a new AlignViewport with hidden regions
 164    *
 165    * @param al
 166    *          AlignmentI
 167    * @param hiddenColumns
 168    *          ColumnSelection
 169    */
 170   public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns)
 171   {
 172     setAlignment(al);
 173     if (hiddenColumns != null)
 174     {
 175       colSel = hiddenColumns;
 176     }
 177     init();
 178   }
 179
 180   /**
 181    * New viewport with hidden columns and an existing sequence set id
 182    *
 183    * @param al
 184    * @param hiddenColumns
 185    * @param seqsetid
 186    *          (may be null)
 187    */
 188   public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns,
 189           String seqsetid)
 190   {
 191     this(al, hiddenColumns, seqsetid, null);
 192   }
 193
 194   /**
 195    * New viewport with hidden columns and an existing sequence set id and viewid
 196    *
 197    * @param al
 198    * @param hiddenColumns
 199    * @param seqsetid
 200    *          (may be null)
 201    * @param viewid
 202    *          (may be null)
 203    */
 204   public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns,
 205           String seqsetid, String viewid)
 206   {
 207     sequenceSetID = seqsetid;
 208     viewId = viewid;
 209     // TODO remove these once 2.4.VAMSAS release finished
 210     if (Cache.log != null && Cache.log.isDebugEnabled() && seqsetid != null)
 211     {
 212       Cache.log.debug("Setting viewport's sequence set id : "
 213               + sequenceSetID);
 214     }
 215     if (Cache.log != null && Cache.log.isDebugEnabled() && viewId != null)
 216     {
 217       Cache.log.debug("Setting viewport's view id : " + viewId);
 218     }
 219     setAlignment(al);
 220     if (hiddenColumns != null)
 221     {
 222       colSel = hiddenColumns;
 223     }
 224     init();
 225   }
 226
 227   private void applyViewProperties()
 228   {
 229     antiAlias = Cache.getDefault("ANTI_ALIAS", false);
 230
 231     viewStyle.setShowJVSuffix(Cache.getDefault("SHOW_JVSUFFIX", true));
 232     setShowAnnotation(Cache.getDefault("SHOW_ANNOTATIONS", true));
 233
 234     setRightAlignIds(Cache.getDefault("RIGHT_ALIGN_IDS", false));
 235     setCentreColumnLabels(Cache.getDefault("CENTRE_COLUMN_LABELS", false));
 236     autoCalculateConsensus = Cache.getDefault("AUTO_CALC_CONSENSUS", true);
 237
 238     setPadGaps(Cache.getDefault("PAD_GAPS", true));
 239     setShowNPFeats(Cache.getDefault("SHOW_NPFEATS_TOOLTIP", true));
 240     setShowDBRefs(Cache.getDefault("SHOW_DBREFS_TOOLTIP", true));
 241     viewStyle.setSeqNameItalics(Cache.getDefault("ID_ITALICS", true));
 242     viewStyle.setWrapAlignment(Cache.getDefault("WRAP_ALIGNMENT", false));
 243     viewStyle.setShowUnconserved(Cache
 244             .getDefault("SHOW_UNCONSERVED", false));
 245     sortByTree = Cache.getDefault("SORT_BY_TREE", false);
 246     followSelection = Cache.getDefault("FOLLOW_SELECTIONS", true);
 247     sortAnnotationsBy = SequenceAnnotationOrder.valueOf(Cache.getDefault(
 248             Preferences.SORT_ANNOTATIONS,
 249             SequenceAnnotationOrder.NONE.name()));
 250     showAutocalculatedAbove = Cache.getDefault(
 251             Preferences.SHOW_AUTOCALC_ABOVE, false);
 252
 253   }
 254
 255   void init()
 256   {
 257     this.startRes = 0;
 258     this.endRes = alignment.getWidth() - 1;
 259     this.startSeq = 0;
 260     this.endSeq = alignment.getHeight() - 1;
 261     applyViewProperties();
 262
 263     String fontName = Cache.getDefault("FONT_NAME", "SansSerif");
 264     String fontStyle = Cache.getDefault("FONT_STYLE", Font.PLAIN + "");
 265     String fontSize = Cache.getDefault("FONT_SIZE", "10");
 266
 267     int style = 0;
 268
 269     if (fontStyle.equals("bold"))
 270     {
 271       style = 1;
 272     }
 273     else if (fontStyle.equals("italic"))
 274     {
 275       style = 2;
 276     }
 277
 278     setFont(new Font(fontName, style, Integer.parseInt(fontSize)), true);
 279
 280     alignment
 281             .setGapCharacter(Cache.getDefault("GAP_SYMBOL", "-").charAt(0));
 282
 283     // We must set conservation and consensus before setting colour,
 284     // as Blosum and Clustal require this to be done
 285     if (hconsensus == null && !isDataset)
 286     {
 287       if (!alignment.isNucleotide())
 288       {
 289         showConservation = Cache.getDefault("SHOW_CONSERVATION", true);
 290         showQuality = Cache.getDefault("SHOW_QUALITY", true);
 291         showGroupConservation = Cache.getDefault("SHOW_GROUP_CONSERVATION",
 292                 false);
 293       }
 294       showConsensusHistogram = Cache.getDefault("SHOW_CONSENSUS_HISTOGRAM",
 295               true);
 296       showSequenceLogo = Cache.getDefault("SHOW_CONSENSUS_LOGO", false);
 297       normaliseSequenceLogo = Cache.getDefault("NORMALISE_CONSENSUS_LOGO",
 298               false);
 299       showGroupConsensus = Cache.getDefault("SHOW_GROUP_CONSENSUS", false);
 300       showConsensus = Cache.getDefault("SHOW_IDENTITY", true);
 301     }
 302     initAutoAnnotation();
 303     if (jalview.bin.Cache.getProperty("DEFAULT_COLOUR") != null)
 304     {
 305       globalColourScheme = ColourSchemeProperty.getColour(alignment,
 306               jalview.bin.Cache.getProperty("DEFAULT_COLOUR"));
 307
 308       if (globalColourScheme instanceof UserColourScheme)
 309       {
 310         globalColourScheme = UserDefinedColours.loadDefaultColours();
 311         ((UserColourScheme) globalColourScheme).setThreshold(0,
 312                 isIgnoreGapsConsensus());
 313       }
 314
 315       if (globalColourScheme != null)
 316       {
 317         globalColourScheme.setConsensus(hconsensus);
 318       }
 319     }
 320   }
 321
 322   /**
 323    * get the consensus sequence as displayed under the PID consensus annotation
 324    * row.
 325    *
 326    * @return consensus sequence as a new sequence object
 327    */
 328   public SequenceI getConsensusSeq()
 329   {
 330     if (consensus == null)
 331     {
 332       updateConsensus(null);
 333     }
 334     if (consensus == null)
 335     {
 336       return null;
 337     }
 338     StringBuffer seqs = new StringBuffer();
 339     for (int i = 0; i < consensus.annotations.length; i++)
 340     {
 341       if (consensus.annotations[i] != null)
 342       {
 343         if (consensus.annotations[i].description.charAt(0) == '[')
 344         {
 345           seqs.append(consensus.annotations[i].description.charAt(1));
 346         }
 347         else
 348         {
 349           seqs.append(consensus.annotations[i].displayCharacter);
 350         }
 351       }
 352     }
 353
 354     SequenceI sq = new Sequence("Consensus", seqs.toString());
 355     sq.setDescription("Percentage Identity Consensus "
 356             + ((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
 357     return sq;
 358   }
 359
 360   /**
 361    * DOCUMENT ME!
 362    *
 363    * @return DOCUMENT ME!
 364    */
 365   public int getStartRes()
 366   {
 367     return startRes;
 368   }
 369
 370   /**
 371    * DOCUMENT ME!
 372    *
 373    * @return DOCUMENT ME!
 374    */
 375   public int getEndRes()
 376   {
 377     return endRes;
 378   }
 379
 380   /**
 381    * DOCUMENT ME!
 382    *
 383    * @return DOCUMENT ME!
 384    */
 385   public int getStartSeq()
 386   {
 387     return startSeq;
 388   }
 389
 390   /**
 391    * DOCUMENT ME!
 392    *
 393    * @param res
 394    *          DOCUMENT ME!
 395    */
 396   public void setStartRes(int res)
 397   {
 398     this.startRes = res;
 399   }
 400
 401   /**
 402    * DOCUMENT ME!
 403    *
 404    * @param seq
 405    *          DOCUMENT ME!
 406    */
 407   public void setStartSeq(int seq)
 408   {
 409     this.startSeq = seq;
 410   }
 411
 412   /**
 413    * DOCUMENT ME!
 414    *
 415    * @param res
 416    *          DOCUMENT ME!
 417    */
 418   public void setEndRes(int res)
 419   {
 420     if (res > (alignment.getWidth() - 1))
 421     {
 422       // log.System.out.println(" Corrected res from " + res + " to maximum " +
 423       // (alignment.getWidth()-1));
 424       res = alignment.getWidth() - 1;
 425     }
 426
 427     if (res < 0)
 428     {
 429       res = 0;
 430     }
 431
 432     this.endRes = res;
 433   }
 434
 435   /**
 436    * DOCUMENT ME!
 437    *
 438    * @param seq
 439    *          DOCUMENT ME!
 440    */
 441   public void setEndSeq(int seq)
 442   {
 443     if (seq > alignment.getHeight())
 444     {
 445       seq = alignment.getHeight();
 446     }
 447
 448     if (seq < 0)
 449     {
 450       seq = 0;
 451     }
 452
 453     this.endSeq = seq;
 454   }
 455
 456   /**
 457    * DOCUMENT ME!
 458    *
 459    * @return DOCUMENT ME!
 460    */
 461   public int getEndSeq()
 462   {
 463     return endSeq;
 464   }
 465
 466   boolean validCharWidth;
 467
 468   /**
 469    * update view settings with the given font. You may need to call
 470    * alignPanel.fontChanged to update the layout geometry
 471    *
 472    * @param setGrid
 473    *          when true, charWidth/height is set according to font mentrics
 474    */
 475   public void setFont(Font f, boolean setGrid)
 476   {
 477     font = f;
 478
 479     Container c = new Container();
 480
 481     java.awt.FontMetrics fm = c.getFontMetrics(font);
 482     int w = viewStyle.getCharWidth(), ww = fm.charWidth('M'), h = viewStyle
 483             .getCharHeight();
 484     if (setGrid)
 485     {
 486       setCharHeight(fm.getHeight());
 487       setCharWidth(ww);
 488     }
 489     viewStyle.setFontName(font.getName());
 490     viewStyle.setFontStyle(font.getStyle());
 491     viewStyle.setFontSize(font.getSize());
 492
 493     validCharWidth = true;
 494   }
 495
 496   @Override
 497   public void setViewStyle(ViewStyleI settingsForView)
 498   {
 499     super.setViewStyle(settingsForView);
 500     setFont(new Font(viewStyle.getFontName(), viewStyle.getFontStyle(),
 501             viewStyle.getFontSize()), false);
 502
 503   }
 504   /**
 505    * DOCUMENT ME!
 506    *
 507    * @return DOCUMENT ME!
 508    */
 509   public Font getFont()
 510   {
 511     return font;
 512   }
 513
 514   /**
 515    * DOCUMENT ME!
 516    *
 517    * @param align
 518    *          DOCUMENT ME!
 519    */
 520   public void setAlignment(AlignmentI align)
 521   {
 522     if (alignment != null && alignment.getCodonFrames() != null)
 523     {
 524       StructureSelectionManager.getStructureSelectionManager(
 525               Desktop.instance).removeMappings(alignment.getCodonFrames());
 526     }
 527     this.alignment = align;
 528     if (alignment != null && alignment.getCodonFrames() != null)
 529     {
 530       StructureSelectionManager.getStructureSelectionManager(
 531               Desktop.instance).addMappings(alignment.getCodonFrames());
 532     }
 533   }
 534
 535   /**
 536    * DOCUMENT ME!
 537    *
 538    * @return DOCUMENT ME!
 539    */
 540   public char getGapCharacter()
 541   {
 542     return getAlignment().getGapCharacter();
 543   }
 544
 545   /**
 546    * DOCUMENT ME!
 547    *
 548    * @param gap
 549    *          DOCUMENT ME!
 550    */
 551   public void setGapCharacter(char gap)
 552   {
 553     if (getAlignment() != null)
 554     {
 555       getAlignment().setGapCharacter(gap);
 556     }
 557   }
 558
 559   /**
 560    * DOCUMENT ME!
 561    *
 562    * @return DOCUMENT ME!
 563    */
 564   public ColumnSelection getColumnSelection()
 565   {
 566     return colSel;
 567   }
 568
 569   /**
 570    * DOCUMENT ME!
 571    *
 572    * @param tree
 573    *          DOCUMENT ME!
 574    */
 575   public void setCurrentTree(NJTree tree)
 576   {
 577     currentTree = tree;
 578   }
 579
 580   /**
 581    * DOCUMENT ME!
 582    *
 583    * @return DOCUMENT ME!
 584    */
 585   public NJTree getCurrentTree()
 586   {
 587     return currentTree;
 588   }
 589
 590   /**
 591    * returns the visible column regions of the alignment
 592    *
 593    * @param selectedRegionOnly
 594    *          true to just return the contigs intersecting with the selected
 595    *          area
 596    * @return
 597    */
 598   public int[] getViewAsVisibleContigs(boolean selectedRegionOnly)
 599   {
 600     int[] viscontigs = null;
 601     int start = 0, end = 0;
 602     if (selectedRegionOnly && selectionGroup != null)
 603     {
 604       start = selectionGroup.getStartRes();
 605       end = selectionGroup.getEndRes() + 1;
 606     }
 607     else
 608     {
 609       end = alignment.getWidth();
 610     }
 611     viscontigs = colSel.getVisibleContigs(start, end);
 612     return viscontigs;
 613   }
 614
 615   /**
 616    * get hash of undo and redo list for the alignment
 617    *
 618    * @return long[] { historyList.hashCode, redoList.hashCode };
 619    */
 620   public long[] getUndoRedoHash()
 621   {
 622     // TODO: JAL-1126
 623     if (historyList == null || redoList == null)
 624     {
 625       return new long[]
 626       { -1, -1 };
 627     }
 628     return new long[]
 629     { historyList.hashCode(), this.redoList.hashCode() };
 630   }
 631
 632   /**
 633    * test if a particular set of hashcodes are different to the hashcodes for
 634    * the undo and redo list.
 635    *
 636    * @param undoredo
 637    *          the stored set of hashcodes as returned by getUndoRedoHash
 638    * @return true if the hashcodes differ (ie the alignment has been edited) or
 639    *         the stored hashcode array differs in size
 640    */
 641   public boolean isUndoRedoHashModified(long[] undoredo)
 642   {
 643     if (undoredo == null)
 644     {
 645       return true;
 646     }
 647     long[] cstate = getUndoRedoHash();
 648     if (cstate.length != undoredo.length)
 649     {
 650       return true;
 651     }
 652
 653     for (int i = 0; i < cstate.length; i++)
 654     {
 655       if (cstate[i] != undoredo[i])
 656       {
 657         return true;
 658       }
 659     }
 660     return false;
 661   }
 662
 663   /**
 664    * when set, view will scroll to show the highlighted position
 665    */
 666   public boolean followHighlight = true;
 667
 668   /**
 669    * @return true if view should scroll to show the highlighted region of a
 670    *         sequence
 671    * @return
 672    */
 673   public boolean getFollowHighlight()
 674   {
 675     return followHighlight;
 676   }
 677
 678   public boolean followSelection = true;
 679
 680   /**
 681    * @return true if view selection should always follow the selections
 682    *         broadcast by other selection sources
 683    */
 684   public boolean getFollowSelection()
 685   {
 686     return followSelection;
 687   }
 688
 689   /**
 690    * Send the current selection to be broadcast to any selection listeners.
 691    */
 692   public void sendSelection()
 693   {
 694     jalview.structure.StructureSelectionManager
 695             .getStructureSelectionManager(Desktop.instance).sendSelection(
 696                     new SequenceGroup(getSelectionGroup()),
 697                     new ColumnSelection(getColumnSelection()), this);
 698   }
 699
 700   /**
 701    * return the alignPanel containing the given viewport. Use this to get the
 702    * components currently handling the given viewport.
 703    *
 704    * @param av
 705    * @return null or an alignPanel guaranteed to have non-null alignFrame
 706    *         reference
 707    */
 708   public AlignmentPanel getAlignPanel()
 709   {
 710     AlignmentPanel[] aps = PaintRefresher.getAssociatedPanels(this
 711             .getSequenceSetId());
 712     for (int p = 0; aps != null && p < aps.length; p++)
 713     {
 714       if (aps[p].av == this)
 715       {
 716         return aps[p];
 717       }
 718     }
 719     return null;
 720   }
 721
 722   public boolean getSortByTree()
 723   {
 724     return sortByTree;
 725   }
 726
 727   public void setSortByTree(boolean sort)
 728   {
 729     sortByTree = sort;
 730   }
 731
 732   /**
 733    * synthesize a column selection if none exists so it covers the given
 734    * selection group. if wholewidth is false, no column selection is made if the
 735    * selection group covers the whole alignment width.
 736    *
 737    * @param sg
 738    * @param wholewidth
 739    */
 740   public void expandColSelection(SequenceGroup sg, boolean wholewidth)
 741   {
 742     int sgs, sge;
 743     if (sg != null
 744             && (sgs = sg.getStartRes()) >= 0
 745             && sg.getStartRes() <= (sge = sg.getEndRes())
 746             && (colSel == null || colSel.getSelected() == null || colSel
 747                     .getSelected().size() == 0))
 748     {
 749       if (!wholewidth && alignment.getWidth() == (1 + sge - sgs))
 750       {
 751         // do nothing
 752         return;
 753       }
 754       if (colSel == null)
 755       {
 756         colSel = new ColumnSelection();
 757       }
 758       for (int cspos = sg.getStartRes(); cspos <= sg.getEndRes(); cspos++)
 759       {
 760         colSel.addElement(cspos);
 761       }
 762     }
 763   }
 764
 765   public StructureSelectionManager getStructureSelectionManager()
 766   {
 767     return StructureSelectionManager
 768             .getStructureSelectionManager(Desktop.instance);
 769   }
 770
 771   /**
 772    *
 773    * @param pdbEntries
 774    * @return a series of SequenceI arrays, one for each PDBEntry, listing which
 775    *         sequence in the alignment holds a reference to it
 776    */
 777   public SequenceI[][] collateForPDB(PDBEntry[] pdbEntries)
 778   {
 779     ArrayList<SequenceI[]> seqvectors = new ArrayList<SequenceI[]>();
 780     for (PDBEntry pdb : pdbEntries)
 781     {
 782       ArrayList<SequenceI> seqs = new ArrayList<SequenceI>();
 783       for (int i = 0; i < alignment.getHeight(); i++)
 784       {
 785         Vector pdbs = alignment.getSequenceAt(i).getDatasetSequence()
 786                 .getPDBId();
 787         if (pdbs == null)
 788         {
 789           continue;
 790         }
 791         SequenceI sq;
 792         for (int p = 0; p < pdbs.size(); p++)
 793         {
 794           PDBEntry p1 = (PDBEntry) pdbs.elementAt(p);
 795           if (p1.getId().equals(pdb.getId()))
 796           {
 797             if (!seqs.contains(sq = alignment.getSequenceAt(i)))
 798             {
 799               seqs.add(sq);
 800             }
 801
 802             continue;
 803           }
 804         }
 805       }
 806       seqvectors.add(seqs.toArray(new SequenceI[seqs.size()]));
 807     }
 808     return seqvectors.toArray(new SequenceI[seqvectors.size()][]);
 809   }
 810
 811   public boolean isNormaliseSequenceLogo()
 812   {
 813     return normaliseSequenceLogo;
 814   }
 815
 816   public void setNormaliseSequenceLogo(boolean state)
 817   {
 818     normaliseSequenceLogo = state;
 819   }
 820
 821   /**
 822    *
 823    * @return true if alignment characters should be displayed
 824    */
 825   public boolean isValidCharWidth()
 826   {
 827     return validCharWidth;
 828   }
 829
 830   private Hashtable<String, AutoCalcSetting> calcIdParams = new Hashtable<String, AutoCalcSetting>();
 831
 832   private boolean showAutocalculatedAbove;
 833
 834   public AutoCalcSetting getCalcIdSettingsFor(String calcId)
 835   {
 836     return calcIdParams.get(calcId);
 837   }
 838
 839   public void setCalcIdSettingsFor(String calcId, AutoCalcSetting settings,
 840           boolean needsUpdate)
 841   {
 842     calcIdParams.put(calcId, settings);
 843     // TODO: create a restart list to trigger any calculations that need to be
 844     // restarted after load
 845     // calculator.getRegisteredWorkersOfClass(settings.getWorkerClass())
 846     if (needsUpdate)
 847     {
 848       Cache.log.debug("trigger update for " + calcId);
 849     }
 850   }
 851
 852   protected SequenceAnnotationOrder getSortAnnotationsBy()
 853   {
 854     return sortAnnotationsBy;
 855   }
 856
 857   protected void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
 858   {
 859     this.sortAnnotationsBy = sortAnnotationsBy;
 860   }
 861
 862   protected boolean isShowAutocalculatedAbove()
 863   {
 864     return showAutocalculatedAbove;
 865   }
 866
 867   protected void setShowAutocalculatedAbove(boolean showAutocalculatedAbove)
 868   {
 869     this.showAutocalculatedAbove = showAutocalculatedAbove;
 870   }
 871
 872   /**
 873    * Method called when another alignment's edit (or possibly other) command is
 874    * broadcast to here.
 875    *
 876    * To allow for sequence mappings (e.g. protein to cDNA), we have to first
 877    * 'unwind' the command on the source sequences (in simulation, not in fact),
 878    * and then for each edit in turn:
 879    * <ul>
 880    * <li>compute the equivalent edit on the mapped sequences</li>
 881    * <li>apply the mapped edit</li>
 882    * <li>'apply' the source edit to the working copy of the source sequences</li>
 883    * </ul>
 884    *
 885    * @param command
 886    * @param undo
 887    * @param ssm
 888    */
 889   @Override
 890   public void mirrorCommand(CommandI command, boolean undo,
 891           StructureSelectionManager ssm, VamsasSource source)
 892   {
 893     /*
 894      * ...work in progress... do nothing unless we are a 'complement' of the
 895      * source May replace this with direct calls not via SSM.
 896      */
 897     if (source instanceof AlignViewportI
 898             && ((AlignViewportI) source).getCodingComplement() == this)
 899     {
 900       // ok to continue;
 901     }
 902     else
 903     {
 904       return;
 905     }
 906
 907     CommandI mappedCommand = ssm.mapCommand(command, undo, getAlignment(),
 908             getGapCharacter());
 909     if (mappedCommand != null)
 910     {
 911       AlignmentI[] views = getAlignPanel().alignFrame.getViewAlignments();
 912       mappedCommand.doCommand(views);
 913       getAlignPanel().alignmentChanged();
 914     }
 915   }
 916
 917   @Override
 918   public VamsasSource getVamsasSource()
 919   {
 920     return this;
 921   }
 922
 923   /**
 924    * Add one command to the command history list.
 925    *
 926    * @param command
 927    */
 928   public void addToHistoryList(CommandI command)
 929   {
 930     if (this.historyList != null)
 931     {
 932       this.historyList.push(command);
 933       broadcastCommand(command, false);
 934     }
 935   }
 936
 937   protected void broadcastCommand(CommandI command, boolean undo)
 938   {
 939     getStructureSelectionManager().commandPerformed(command, undo, getVamsasSource());
 940   }
 941
 942   /**
 943    * Add one command to the command redo list.
 944    *
 945    * @param command
 946    */
 947   public void addToRedoList(CommandI command)
 948   {
 949     if (this.redoList != null)
 950     {
 951       this.redoList.push(command);
 952     }
 953     broadcastCommand(command, true);
 954   }
 955
 956   /**
 957    * Clear the command redo list.
 958    */
 959   public void clearRedoList()
 960   {
 961     if (this.redoList != null)
 962     {
 963       this.redoList.clear();
 964     }
 965   }
 966
 967   public void setHistoryList(Deque<CommandI> list)
 968   {
 969     this.historyList = list;
 970   }
 971
 972   public Deque<CommandI> getHistoryList()
 973   {
 974     return this.historyList;
 975   }
 976
 977   public void setRedoList(Deque<CommandI> list)
 978   {
 979     this.redoList = list;
 980   }
 981
 982   public Deque<CommandI> getRedoList()
 983   {
 984     return this.redoList;
 985   }
 986
 987   /**
 988    * Add the sequences from the given alignment to this viewport. Optionally,
 989    * may give the user the option to open a new frame, or split panel, with cDNA
 990    * and protein linked.
 991    *
 992    * @param al
 993    * @param title
 994    */
 995   public void addAlignment(AlignmentI al, String title)
 996   {
 997     // TODO: promote to AlignViewportI? applet CutAndPasteTransfer is different
 998
 999     // JBPComment: title is a largely redundant parameter at the moment
1000     // JBPComment: this really should be an 'insert/pre/append' controller
1001     // JBPComment: but the DNA/Protein check makes it a bit more complex
1002
1003     // refactored from FileLoader / CutAndPasteTransfer / SequenceFetcher with
1004     // this comment:
1005     // TODO: create undo object for this JAL-1101
1006
1007     /*
1008      * If one alignment is protein and one nucleotide, with at least one
1009      * sequence name in common, offer to open a linked alignment.
1010      */
1011     if (getAlignment().isNucleotide() != al.isNucleotide())
1012     {
1013       // TODO: JAL-845 try a bit harder to link up imported sequences
1014       final Set<String> sequenceNames = getAlignment().getSequenceNames();
1015       sequenceNames.retainAll(al.getSequenceNames());
1016       if (!sequenceNames.isEmpty()) // at least one sequence name in both
1017       {
1018         if (openLinkedAlignment(al, title))
1019         {
1020           return;
1021         }
1022       }
1023     }
1024     // TODO: JAL-407 regardless of above - identical sequences (based on ID and
1025     // provenance) should share the same dataset sequence
1026
1027     for (int i = 0; i < al.getHeight(); i++)
1028     {
1029       getAlignment().addSequence(al.getSequenceAt(i));
1030     }
1031     // TODO this call was done by SequenceFetcher but not FileLoader or
1032     // CutAndPasteTransfer. Is it needed?
1033     // JBPComment: this repositions the view to show the new sequences
1034     // JBPComment: so it is needed for UX
1035     setEndSeq(getAlignment().getHeight());
1036     firePropertyChange("alignment", null, getAlignment().getSequences());
1037   }
1038
1039   /**
1040    * Show a dialog with the option to open and link (cDNA <-> protein) as a new
1041    * alignment. Returns true if the new alignment was opened, false if not,
1042    * because the user declined the offer.
1043    *
1044    * @param title
1045    */
1046   protected boolean openLinkedAlignment(AlignmentI al, String title)
1047   {
1048     String[] options = new String[]
1049     { MessageManager.getString("action.no"),
1050         MessageManager.getString("label.split_window"),
1051         MessageManager.getString("label.new_window"), };
1052     final String question = JvSwingUtils.wrapTooltip(true,
1053             MessageManager.getString("label.open_linked_alignment?"));
1054     int response = JOptionPane.showOptionDialog(Desktop.desktop, question,
1055             MessageManager.getString("label.open_linked_alignment"),
1056             JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null,
1057             options, options[0]);
1058
1059     if (response != 1 && response != 2)
1060     {
1061       return false;
1062     }
1063     final boolean openSplitPane = (response == 1);
1064     final boolean openInNewWindow = (response == 2);
1065
1066     /*
1067      * Create the AlignFrame first (which creates the new alignment's datasets),
1068      * before attempting sequence mapping.
1069      */
1070     AlignFrame newAlignFrame = new AlignFrame(al, AlignFrame.DEFAULT_WIDTH,
1071             AlignFrame.DEFAULT_HEIGHT);
1072     newAlignFrame.setTitle(title);
1073
1074     /*
1075      * Identify protein and dna alignments. Make a copy of this one if opening
1076      * in a new split pane.
1077      */
1078     AlignmentI thisAlignment = openSplitPane ? new Alignment(getAlignment())
1079             : getAlignment();
1080     AlignmentI protein = al.isNucleotide() ? thisAlignment : al;
1081     final AlignmentI cdna = al.isNucleotide() ? al : thisAlignment;
1082
1083     newAlignFrame.statusBar.setText(MessageManager.formatMessage(
1084             "label.successfully_loaded_file", new Object[]
1085             { title }));
1086
1087     // TODO if we want this (e.g. to enable reload of the alignment from file),
1088     // we will need to add parameters to the stack.
1089     // if (!protocol.equals(AppletFormatAdapter.PASTE))
1090     // {
1091     // alignFrame.setFileName(file, format);
1092     // }
1093
1094     if (openInNewWindow)
1095     {
1096       Desktop.addInternalFrame(newAlignFrame, title,
1097               AlignFrame.DEFAULT_WIDTH,
1098               AlignFrame.DEFAULT_HEIGHT);
1099     }
1100
1101     /*
1102      * Try to find mappings for at least one sequence. Any mappings made will be
1103      * added to the protein alignment.
1104      */
1105     MappingResult mapped = AlignmentUtils.mapProteinToCdna(protein, cdna);
1106     final StructureSelectionManager ssm = StructureSelectionManager
1107             .getStructureSelectionManager(Desktop.instance);
1108     if (mapped != MappingResult.Mapped)
1109     {
1110       /*
1111        * No mapping possible - warn the user, but leave window open.
1112        */
1113       final String msg = JvSwingUtils.wrapTooltip(true,
1114               MessageManager.getString("label.mapping_failed"));
1115       JOptionPane.showInternalMessageDialog(Desktop.desktop, msg,
1116               MessageManager.getString("label.no_mappings"),
1117               JOptionPane.WARNING_MESSAGE);
1118     }
1119
1120     try
1121     {
1122       newAlignFrame.setMaximum(jalview.bin.Cache.getDefault(
1123               "SHOW_FULLSCREEN",
1124               false));
1125     } catch (java.beans.PropertyVetoException ex)
1126     {
1127     }
1128
1129     if (openSplitPane)
1130     {
1131       // TODO: move this kind of constructor stuff to a factory/controller
1132       // method ?
1133       /*
1134        * Open in split pane. DNA sequence above, protein below.
1135        */
1136       AlignFrame copyMe = new AlignFrame(thisAlignment,
1137               AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
1138       copyMe.setTitle(getAlignPanel().alignFrame.getTitle());
1139       final AlignFrame proteinFrame = al.isNucleotide() ? copyMe
1140               : newAlignFrame;
1141       final AlignFrame cdnaFrame = al.isNucleotide() ? newAlignFrame
1142               : copyMe;
1143       protein = proteinFrame.viewport.getAlignment();
1144
1145       cdnaFrame.setVisible(true);
1146       proteinFrame.setVisible(true);
1147       String sep = String.valueOf(File.separatorChar);
1148       String proteinShortName = proteinFrame.getTitle().substring(
1149               proteinFrame.getTitle().lastIndexOf(sep) + 1);
1150       String dnaShortName = cdnaFrame.getTitle().substring(
1151               cdnaFrame.getTitle().lastIndexOf(sep) + 1);
1152       String linkedTitle = MessageManager.formatMessage(
1153               "label.linked_view_title", dnaShortName, proteinShortName);
1154       JInternalFrame splitFrame = new SplitFrame(cdnaFrame, proteinFrame);
1155       Desktop.addInternalFrame(splitFrame, linkedTitle, -1, -1);
1156
1157       /*
1158        * Set the frames to listen for each other's edit and sort commands.
1159        */
1160       ssm.addCommandListener(cdnaFrame.getViewport());
1161       ssm.addCommandListener(proteinFrame.getViewport());
1162
1163       /*
1164        * 'Coding complement' (dna/protein) views will mirror each others' edits,
1165        * selections, sorting etc as decided from time to time by the relevant
1166        * authorities.
1167        */
1168       proteinFrame.getViewport().setCodingComplement(cdnaFrame.getViewport());
1169     }
1170
1171     /*
1172      * Register the mappings (held on the protein alignment) with the
1173      * StructureSelectionManager (for mouseover linking).
1174      */
1175     ssm.addMappings(protein.getCodonFrames());
1176
1177     return true;
1178   }
1179
1180   public AnnotationColumnChooser getAnnotationColumnSelectionState()
1181   {
1182     return annotationColumnSelectionState;
1183   }
1184
1185   public void setAnnotationColumnSelectionState(
1186           AnnotationColumnChooser currentAnnotationColumnSelectionState)
1187   {
1188     this.annotationColumnSelectionState = currentAnnotationColumnSelectionState;
1189   }
1190
1191   @Override
1192   public void setIdWidth(int i)
1193   {
1194     super.setIdWidth(i);
1195     AlignmentPanel ap = getAlignPanel();
1196     if (ap != null)
1197     {
1198       // modify GUI elements to reflect geometry change
1199       Dimension idw = getAlignPanel().getIdPanel().getIdCanvas()
1200               .getPreferredSize();
1201       idw.width = i;
1202       getAlignPanel().getIdPanel().getIdCanvas().setPreferredSize(idw);
1203     }
1204   }
1205
1206   public Rectangle getExplodedGeometry()
1207   {
1208     return explodedGeometry;
1209   }
1210
1211   public void setExplodedGeometry(Rectangle explodedPosition)
1212   {
1213     this.explodedGeometry = explodedPosition;
1214   }
1215
1216   public boolean isGatherViewsHere()
1217   {
1218     return gatherViewsHere;
1219   }
1220
1221   public void setGatherViewsHere(boolean gatherViewsHere)
1222   {
1223     this.gatherViewsHere = gatherViewsHere;
1224   }
1225 }