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   Rectangle explodedPosition;
 110
 111   String viewName;
 112
 113   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)));
 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   public void setFont(Font f)
 473   {
 474     font = f;
 475
 476     Container c = new Container();
 477
 478     java.awt.FontMetrics fm = c.getFontMetrics(font);
 479     int w = viewStyle.getCharWidth(), ww = fm.charWidth('M'), h = viewStyle
 480             .getCharHeight();
 481     setCharHeight(fm.getHeight());
 482     setCharWidth(ww);
 483     viewStyle.setFontName(font.getName());
 484     viewStyle.setFontStyle(font.getStyle());
 485     viewStyle.setFontSize(font.getSize());
 486
 487     validCharWidth = true;
 488   }
 489
 490   @Override
 491   public void setViewStyle(ViewStyleI settingsForView)
 492   {
 493     super.setViewStyle(settingsForView);
 494     setFont(new Font(viewStyle.getFontName(), viewStyle.getFontStyle(),
 495             viewStyle.getFontSize()));
 496
 497   }
 498   /**
 499    * DOCUMENT ME!
 500    *
 501    * @return DOCUMENT ME!
 502    */
 503   public Font getFont()
 504   {
 505     return font;
 506   }
 507
 508   /**
 509    * DOCUMENT ME!
 510    *
 511    * @param align
 512    *          DOCUMENT ME!
 513    */
 514   public void setAlignment(AlignmentI align)
 515   {
 516     if (alignment != null && alignment.getCodonFrames() != null)
 517     {
 518       StructureSelectionManager.getStructureSelectionManager(
 519               Desktop.instance).removeMappings(alignment.getCodonFrames());
 520     }
 521     this.alignment = align;
 522     if (alignment != null && alignment.getCodonFrames() != null)
 523     {
 524       StructureSelectionManager.getStructureSelectionManager(
 525               Desktop.instance).addMappings(alignment.getCodonFrames());
 526     }
 527   }
 528
 529   /**
 530    * DOCUMENT ME!
 531    *
 532    * @return DOCUMENT ME!
 533    */
 534   public char getGapCharacter()
 535   {
 536     return getAlignment().getGapCharacter();
 537   }
 538
 539   /**
 540    * DOCUMENT ME!
 541    *
 542    * @param gap
 543    *          DOCUMENT ME!
 544    */
 545   public void setGapCharacter(char gap)
 546   {
 547     if (getAlignment() != null)
 548     {
 549       getAlignment().setGapCharacter(gap);
 550     }
 551   }
 552
 553   /**
 554    * DOCUMENT ME!
 555    *
 556    * @return DOCUMENT ME!
 557    */
 558   public ColumnSelection getColumnSelection()
 559   {
 560     return colSel;
 561   }
 562
 563   /**
 564    * DOCUMENT ME!
 565    *
 566    * @param tree
 567    *          DOCUMENT ME!
 568    */
 569   public void setCurrentTree(NJTree tree)
 570   {
 571     currentTree = tree;
 572   }
 573
 574   /**
 575    * DOCUMENT ME!
 576    *
 577    * @return DOCUMENT ME!
 578    */
 579   public NJTree getCurrentTree()
 580   {
 581     return currentTree;
 582   }
 583
 584   /**
 585    * returns the visible column regions of the alignment
 586    *
 587    * @param selectedRegionOnly
 588    *          true to just return the contigs intersecting with the selected
 589    *          area
 590    * @return
 591    */
 592   public int[] getViewAsVisibleContigs(boolean selectedRegionOnly)
 593   {
 594     int[] viscontigs = null;
 595     int start = 0, end = 0;
 596     if (selectedRegionOnly && selectionGroup != null)
 597     {
 598       start = selectionGroup.getStartRes();
 599       end = selectionGroup.getEndRes() + 1;
 600     }
 601     else
 602     {
 603       end = alignment.getWidth();
 604     }
 605     viscontigs = colSel.getVisibleContigs(start, end);
 606     return viscontigs;
 607   }
 608
 609   /**
 610    * get hash of undo and redo list for the alignment
 611    *
 612    * @return long[] { historyList.hashCode, redoList.hashCode };
 613    */
 614   public long[] getUndoRedoHash()
 615   {
 616     // TODO: JAL-1126
 617     if (historyList == null || redoList == null)
 618     {
 619       return new long[]
 620       { -1, -1 };
 621     }
 622     return new long[]
 623     { historyList.hashCode(), this.redoList.hashCode() };
 624   }
 625
 626   /**
 627    * test if a particular set of hashcodes are different to the hashcodes for
 628    * the undo and redo list.
 629    *
 630    * @param undoredo
 631    *          the stored set of hashcodes as returned by getUndoRedoHash
 632    * @return true if the hashcodes differ (ie the alignment has been edited) or
 633    *         the stored hashcode array differs in size
 634    */
 635   public boolean isUndoRedoHashModified(long[] undoredo)
 636   {
 637     if (undoredo == null)
 638     {
 639       return true;
 640     }
 641     long[] cstate = getUndoRedoHash();
 642     if (cstate.length != undoredo.length)
 643     {
 644       return true;
 645     }
 646
 647     for (int i = 0; i < cstate.length; i++)
 648     {
 649       if (cstate[i] != undoredo[i])
 650       {
 651         return true;
 652       }
 653     }
 654     return false;
 655   }
 656
 657   /**
 658    * when set, view will scroll to show the highlighted position
 659    */
 660   public boolean followHighlight = true;
 661
 662   /**
 663    * @return true if view should scroll to show the highlighted region of a
 664    *         sequence
 665    * @return
 666    */
 667   public boolean getFollowHighlight()
 668   {
 669     return followHighlight;
 670   }
 671
 672   public boolean followSelection = true;
 673
 674   /**
 675    * @return true if view selection should always follow the selections
 676    *         broadcast by other selection sources
 677    */
 678   public boolean getFollowSelection()
 679   {
 680     return followSelection;
 681   }
 682
 683   /**
 684    * Send the current selection to be broadcast to any selection listeners.
 685    */
 686   public void sendSelection()
 687   {
 688     jalview.structure.StructureSelectionManager
 689             .getStructureSelectionManager(Desktop.instance).sendSelection(
 690                     new SequenceGroup(getSelectionGroup()),
 691                     new ColumnSelection(getColumnSelection()), this);
 692   }
 693
 694   /**
 695    * return the alignPanel containing the given viewport. Use this to get the
 696    * components currently handling the given viewport.
 697    *
 698    * @param av
 699    * @return null or an alignPanel guaranteed to have non-null alignFrame
 700    *         reference
 701    */
 702   public AlignmentPanel getAlignPanel()
 703   {
 704     AlignmentPanel[] aps = PaintRefresher.getAssociatedPanels(this
 705             .getSequenceSetId());
 706     for (int p = 0; aps != null && p < aps.length; p++)
 707     {
 708       if (aps[p].av == this)
 709       {
 710         return aps[p];
 711       }
 712     }
 713     return null;
 714   }
 715
 716   public boolean getSortByTree()
 717   {
 718     return sortByTree;
 719   }
 720
 721   public void setSortByTree(boolean sort)
 722   {
 723     sortByTree = sort;
 724   }
 725
 726   /**
 727    * synthesize a column selection if none exists so it covers the given
 728    * selection group. if wholewidth is false, no column selection is made if the
 729    * selection group covers the whole alignment width.
 730    *
 731    * @param sg
 732    * @param wholewidth
 733    */
 734   public void expandColSelection(SequenceGroup sg, boolean wholewidth)
 735   {
 736     int sgs, sge;
 737     if (sg != null
 738             && (sgs = sg.getStartRes()) >= 0
 739             && sg.getStartRes() <= (sge = sg.getEndRes())
 740             && (colSel == null || colSel.getSelected() == null || colSel
 741                     .getSelected().size() == 0))
 742     {
 743       if (!wholewidth && alignment.getWidth() == (1 + sge - sgs))
 744       {
 745         // do nothing
 746         return;
 747       }
 748       if (colSel == null)
 749       {
 750         colSel = new ColumnSelection();
 751       }
 752       for (int cspos = sg.getStartRes(); cspos <= sg.getEndRes(); cspos++)
 753       {
 754         colSel.addElement(cspos);
 755       }
 756     }
 757   }
 758
 759   public StructureSelectionManager getStructureSelectionManager()
 760   {
 761     return StructureSelectionManager
 762             .getStructureSelectionManager(Desktop.instance);
 763   }
 764
 765   /**
 766    *
 767    * @param pdbEntries
 768    * @return a series of SequenceI arrays, one for each PDBEntry, listing which
 769    *         sequence in the alignment holds a reference to it
 770    */
 771   public SequenceI[][] collateForPDB(PDBEntry[] pdbEntries)
 772   {
 773     ArrayList<SequenceI[]> seqvectors = new ArrayList<SequenceI[]>();
 774     for (PDBEntry pdb : pdbEntries)
 775     {
 776       ArrayList<SequenceI> seqs = new ArrayList<SequenceI>();
 777       for (int i = 0; i < alignment.getHeight(); i++)
 778       {
 779         Vector pdbs = alignment.getSequenceAt(i).getDatasetSequence()
 780                 .getPDBId();
 781         if (pdbs == null)
 782         {
 783           continue;
 784         }
 785         SequenceI sq;
 786         for (int p = 0; p < pdbs.size(); p++)
 787         {
 788           PDBEntry p1 = (PDBEntry) pdbs.elementAt(p);
 789           if (p1.getId().equals(pdb.getId()))
 790           {
 791             if (!seqs.contains(sq = alignment.getSequenceAt(i)))
 792             {
 793               seqs.add(sq);
 794             }
 795
 796             continue;
 797           }
 798         }
 799       }
 800       seqvectors.add(seqs.toArray(new SequenceI[seqs.size()]));
 801     }
 802     return seqvectors.toArray(new SequenceI[seqvectors.size()][]);
 803   }
 804
 805   public boolean isNormaliseSequenceLogo()
 806   {
 807     return normaliseSequenceLogo;
 808   }
 809
 810   public void setNormaliseSequenceLogo(boolean state)
 811   {
 812     normaliseSequenceLogo = state;
 813   }
 814
 815   /**
 816    *
 817    * @return true if alignment characters should be displayed
 818    */
 819   public boolean isValidCharWidth()
 820   {
 821     return validCharWidth;
 822   }
 823
 824   private Hashtable<String, AutoCalcSetting> calcIdParams = new Hashtable<String, AutoCalcSetting>();
 825
 826   private boolean showAutocalculatedAbove;
 827
 828   public AutoCalcSetting getCalcIdSettingsFor(String calcId)
 829   {
 830     return calcIdParams.get(calcId);
 831   }
 832
 833   public void setCalcIdSettingsFor(String calcId, AutoCalcSetting settings,
 834           boolean needsUpdate)
 835   {
 836     calcIdParams.put(calcId, settings);
 837     // TODO: create a restart list to trigger any calculations that need to be
 838     // restarted after load
 839     // calculator.getRegisteredWorkersOfClass(settings.getWorkerClass())
 840     if (needsUpdate)
 841     {
 842       Cache.log.debug("trigger update for " + calcId);
 843     }
 844   }
 845
 846   protected SequenceAnnotationOrder getSortAnnotationsBy()
 847   {
 848     return sortAnnotationsBy;
 849   }
 850
 851   protected void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
 852   {
 853     this.sortAnnotationsBy = sortAnnotationsBy;
 854   }
 855
 856   protected boolean isShowAutocalculatedAbove()
 857   {
 858     return showAutocalculatedAbove;
 859   }
 860
 861   protected void setShowAutocalculatedAbove(boolean showAutocalculatedAbove)
 862   {
 863     this.showAutocalculatedAbove = showAutocalculatedAbove;
 864   }
 865
 866   /**
 867    * Method called when another alignment's edit (or possibly other) command is
 868    * broadcast to here.
 869    *
 870    * To allow for sequence mappings (e.g. protein to cDNA), we have to first
 871    * 'unwind' the command on the source sequences (in simulation, not in fact),
 872    * and then for each edit in turn:
 873    * <ul>
 874    * <li>compute the equivalent edit on the mapped sequences</li>
 875    * <li>apply the mapped edit</li>
 876    * <li>'apply' the source edit to the working copy of the source sequences</li>
 877    * </ul>
 878    *
 879    * @param command
 880    * @param undo
 881    * @param ssm
 882    */
 883   @Override
 884   public void mirrorCommand(CommandI command, boolean undo,
 885           StructureSelectionManager ssm, VamsasSource source)
 886   {
 887     /*
 888      * ...work in progress... do nothing unless we are a 'complement' of the
 889      * source May replace this with direct calls not via SSM.
 890      */
 891     if (source instanceof AlignViewportI
 892             && ((AlignViewportI) source).getCodingComplement() == this)
 893     {
 894       // ok to continue;
 895     }
 896     else
 897     {
 898       return;
 899     }
 900
 901     CommandI mappedCommand = ssm.mapCommand(command, undo, getAlignment(),
 902             getGapCharacter());
 903     if (mappedCommand != null)
 904     {
 905       AlignmentI[] views = getAlignPanel().alignFrame.getViewAlignments();
 906       mappedCommand.doCommand(views);
 907       getAlignPanel().alignmentChanged();
 908     }
 909   }
 910
 911   @Override
 912   public VamsasSource getVamsasSource()
 913   {
 914     return this;
 915   }
 916
 917   /**
 918    * Add one command to the command history list.
 919    *
 920    * @param command
 921    */
 922   public void addToHistoryList(CommandI command)
 923   {
 924     if (this.historyList != null)
 925     {
 926       this.historyList.push(command);
 927       broadcastCommand(command, false);
 928     }
 929   }
 930
 931   protected void broadcastCommand(CommandI command, boolean undo)
 932   {
 933     getStructureSelectionManager().commandPerformed(command, undo, getVamsasSource());
 934   }
 935
 936   /**
 937    * Add one command to the command redo list.
 938    *
 939    * @param command
 940    */
 941   public void addToRedoList(CommandI command)
 942   {
 943     if (this.redoList != null)
 944     {
 945       this.redoList.push(command);
 946     }
 947     broadcastCommand(command, true);
 948   }
 949
 950   /**
 951    * Clear the command redo list.
 952    */
 953   public void clearRedoList()
 954   {
 955     if (this.redoList != null)
 956     {
 957       this.redoList.clear();
 958     }
 959   }
 960
 961   public void setHistoryList(Deque<CommandI> list)
 962   {
 963     this.historyList = list;
 964   }
 965
 966   public Deque<CommandI> getHistoryList()
 967   {
 968     return this.historyList;
 969   }
 970
 971   public void setRedoList(Deque<CommandI> list)
 972   {
 973     this.redoList = list;
 974   }
 975
 976   public Deque<CommandI> getRedoList()
 977   {
 978     return this.redoList;
 979   }
 980
 981   /**
 982    * Add the sequences from the given alignment to this viewport. Optionally,
 983    * may give the user the option to open a new frame, or split panel, with cDNA
 984    * and protein linked.
 985    *
 986    * @param al
 987    * @param title
 988    */
 989   public void addAlignment(AlignmentI al, String title)
 990   {
 991     // TODO: promote to AlignViewportI? applet CutAndPasteTransfer is different
 992
 993     // JBPComment: title is a largely redundant parameter at the moment
 994     // JBPComment: this really should be an 'insert/pre/append' controller
 995     // JBPComment: but the DNA/Protein check makes it a bit more complex
 996
 997     // refactored from FileLoader / CutAndPasteTransfer / SequenceFetcher with
 998     // this comment:
 999     // TODO: create undo object for this JAL-1101
1000
1001     /*
1002      * If one alignment is protein and one nucleotide, with at least one
1003      * sequence name in common, offer to open a linked alignment.
1004      */
1005     if (getAlignment().isNucleotide() != al.isNucleotide())
1006     {
1007       // TODO: JAL-845 try a bit harder to link up imported sequences
1008       final Set<String> sequenceNames = getAlignment().getSequenceNames();
1009       sequenceNames.retainAll(al.getSequenceNames());
1010       if (!sequenceNames.isEmpty()) // at least one sequence name in both
1011       {
1012         if (openLinkedAlignment(al, title))
1013         {
1014           return;
1015         }
1016       }
1017     }
1018     // TODO: JAL-407 regardless of above - identical sequences (based on ID and
1019     // provenance) should share the same dataset sequence
1020
1021     for (int i = 0; i < al.getHeight(); i++)
1022     {
1023       getAlignment().addSequence(al.getSequenceAt(i));
1024     }
1025     // TODO this call was done by SequenceFetcher but not FileLoader or
1026     // CutAndPasteTransfer. Is it needed?
1027     // JBPComment: this repositions the view to show the new sequences
1028     // JBPComment: so it is needed for UX
1029     setEndSeq(getAlignment().getHeight());
1030     firePropertyChange("alignment", null, getAlignment().getSequences());
1031   }
1032
1033   /**
1034    * Show a dialog with the option to open and link (cDNA <-> protein) as a new
1035    * alignment. Returns true if the new alignment was opened, false if not,
1036    * because the user declined the offer.
1037    *
1038    * @param title
1039    */
1040   protected boolean openLinkedAlignment(AlignmentI al, String title)
1041   {
1042     String[] options = new String[]
1043     { MessageManager.getString("action.no"),
1044         MessageManager.getString("label.split_window"),
1045         MessageManager.getString("label.new_window"), };
1046     final String question = JvSwingUtils.wrapTooltip(true,
1047             MessageManager.getString("label.open_linked_alignment?"));
1048     int response = JOptionPane.showOptionDialog(Desktop.desktop, question,
1049             MessageManager.getString("label.open_linked_alignment"),
1050             JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null,
1051             options, options[0]);
1052
1053     if (response != 1 && response != 2)
1054     {
1055       return false;
1056     }
1057     final boolean openSplitPane = (response == 1);
1058     final boolean openInNewWindow = (response == 2);
1059
1060     /*
1061      * Create the AlignFrame first (which creates the new alignment's datasets),
1062      * before attempting sequence mapping.
1063      */
1064     AlignFrame newAlignFrame = new AlignFrame(al, AlignFrame.DEFAULT_WIDTH,
1065             AlignFrame.DEFAULT_HEIGHT);
1066     newAlignFrame.setTitle(title);
1067
1068     /*
1069      * Identify protein and dna alignments. Make a copy of this one if opening
1070      * in a new split pane.
1071      */
1072     AlignmentI thisAlignment = openSplitPane ? new Alignment(getAlignment())
1073             : getAlignment();
1074     AlignmentI protein = al.isNucleotide() ? thisAlignment : al;
1075     final AlignmentI cdna = al.isNucleotide() ? al : thisAlignment;
1076
1077     newAlignFrame.statusBar.setText(MessageManager.formatMessage(
1078             "label.successfully_loaded_file", new Object[]
1079             { title }));
1080
1081     // TODO if we want this (e.g. to enable reload of the alignment from file),
1082     // we will need to add parameters to the stack.
1083     // if (!protocol.equals(AppletFormatAdapter.PASTE))
1084     // {
1085     // alignFrame.setFileName(file, format);
1086     // }
1087
1088     if (openInNewWindow)
1089     {
1090       Desktop.addInternalFrame(newAlignFrame, title,
1091               AlignFrame.DEFAULT_WIDTH,
1092               AlignFrame.DEFAULT_HEIGHT);
1093     }
1094
1095     /*
1096      * Try to find mappings for at least one sequence. Any mappings made will be
1097      * added to the protein alignment.
1098      */
1099     MappingResult mapped = AlignmentUtils.mapProteinToCdna(protein, cdna);
1100     final StructureSelectionManager ssm = StructureSelectionManager
1101             .getStructureSelectionManager(Desktop.instance);
1102     if (mapped != MappingResult.Mapped)
1103     {
1104       /*
1105        * No mapping possible - warn the user, but leave window open.
1106        */
1107       final String msg = JvSwingUtils.wrapTooltip(true,
1108               MessageManager.getString("label.mapping_failed"));
1109       JOptionPane.showInternalMessageDialog(Desktop.desktop, msg,
1110               MessageManager.getString("label.no_mappings"),
1111               JOptionPane.WARNING_MESSAGE);
1112     }
1113
1114     try
1115     {
1116       newAlignFrame.setMaximum(jalview.bin.Cache.getDefault(
1117               "SHOW_FULLSCREEN",
1118               false));
1119     } catch (java.beans.PropertyVetoException ex)
1120     {
1121     }
1122
1123     if (openSplitPane)
1124     {
1125       // TODO: move this kind of constructor stuff to a factory/controller
1126       // method ?
1127       /*
1128        * Open in split pane. DNA sequence above, protein below.
1129        */
1130       AlignFrame copyMe = new AlignFrame(thisAlignment,
1131               AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
1132       copyMe.setTitle(getAlignPanel().alignFrame.getTitle());
1133       final AlignFrame proteinFrame = al.isNucleotide() ? copyMe
1134               : newAlignFrame;
1135       final AlignFrame cdnaFrame = al.isNucleotide() ? newAlignFrame
1136               : copyMe;
1137       protein = proteinFrame.viewport.getAlignment();
1138
1139       cdnaFrame.setVisible(true);
1140       proteinFrame.setVisible(true);
1141       String sep = String.valueOf(File.separatorChar);
1142       String proteinShortName = proteinFrame.getTitle().substring(
1143               proteinFrame.getTitle().lastIndexOf(sep) + 1);
1144       String dnaShortName = cdnaFrame.getTitle().substring(
1145               cdnaFrame.getTitle().lastIndexOf(sep) + 1);
1146       String linkedTitle = MessageManager.formatMessage(
1147               "label.linked_view_title", dnaShortName, proteinShortName);
1148       JInternalFrame splitFrame = new SplitFrame(cdnaFrame, proteinFrame);
1149       Desktop.addInternalFrame(splitFrame, linkedTitle,
1150               AlignFrame.DEFAULT_WIDTH,
1151               AlignFrame.DEFAULT_HEIGHT);
1152
1153       /*
1154        * Set the frames to listen for each other's edit and sort commands.
1155        */
1156       ssm.addCommandListener(cdnaFrame.getViewport());
1157       ssm.addCommandListener(proteinFrame.getViewport());
1158
1159       /*
1160        * 'Coding complement' (dna/protein) views will mirror each others' edits,
1161        * selections, sorting etc as decided from time to time by the relevant
1162        * authorities.
1163        */
1164       proteinFrame.getViewport().setCodingComplement(cdnaFrame.getViewport());
1165     }
1166
1167     /*
1168      * Register the mappings (held on the protein alignment) with the
1169      * StructureSelectionManager (for mouseover linking).
1170      */
1171     ssm.addMappings(protein.getCodonFrames());
1172
1173     return true;
1174   }
1175
1176   public AnnotationColumnChooser getAnnotationColumnSelectionState()
1177   {
1178     return annotationColumnSelectionState;
1179   }
1180
1181   public void setAnnotationColumnSelectionState(
1182           AnnotationColumnChooser currentAnnotationColumnSelectionState)
1183   {
1184     this.annotationColumnSelectionState = currentAnnotationColumnSelectionState;
1185   }
1186
1187   @Override
1188   public void setIdWidth(int i)
1189   {
1190     super.setIdWidth(i);
1191     AlignmentPanel ap = getAlignPanel();
1192     if (ap != null)
1193     {
1194       // modify GUI elements to reflect geometry change
1195       Dimension idw = getAlignPanel().getIdPanel().getIdCanvas()
1196               .getPreferredSize();
1197       idw.width = i;
1198       getAlignPanel().getIdPanel().getIdCanvas().setPreferredSize(idw);
1199     }
1200   }
1201 }