src/jalview/viewmodel/AlignmentViewport.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.viewmodel;
  22
  23 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
  24 import jalview.analysis.Conservation;
  25 import jalview.analysis.TreeModel;
  26 import jalview.api.AlignCalcManagerI;
  27 import jalview.api.AlignExportSettingsI;
  28 import jalview.api.AlignViewportI;
  29 import jalview.api.AlignmentViewPanel;
  30 import jalview.api.FeaturesDisplayedI;
  31 import jalview.api.ViewStyleI;
  32 import jalview.commands.CommandI;
  33 import jalview.datamodel.AlignedCodonFrame;
  34 import jalview.datamodel.AlignmentAnnotation;
  35 import jalview.datamodel.AlignmentExportData;
  36 import jalview.datamodel.AlignmentI;
  37 import jalview.datamodel.AlignmentView;
  38 import jalview.datamodel.Annotation;
  39 import jalview.datamodel.ColumnSelection;
  40 import jalview.datamodel.HiddenColumns;
  41 import jalview.datamodel.HiddenSequences;
  42 import jalview.datamodel.ProfilesI;
  43 import jalview.datamodel.SearchResultsI;
  44 import jalview.datamodel.Sequence;
  45 import jalview.datamodel.SequenceCollectionI;
  46 import jalview.datamodel.SequenceGroup;
  47 import jalview.datamodel.SequenceI;
  48 import jalview.renderer.ResidueShader;
  49 import jalview.renderer.ResidueShaderI;
  50 import jalview.schemes.ColourSchemeI;
  51 import jalview.structure.CommandListener;
  52 import jalview.structure.StructureSelectionManager;
  53 import jalview.structure.VamsasSource;
  54 import jalview.util.Comparison;
  55 import jalview.util.MapList;
  56 import jalview.util.MappingUtils;
  57 import jalview.util.MessageManager;
  58 import jalview.viewmodel.styles.ViewStyle;
  59 import jalview.workers.AlignCalcManager;
  60 import jalview.workers.ComplementConsensusThread;
  61 import jalview.workers.ConsensusThread;
  62 import jalview.workers.StrucConsensusThread;
  63
  64 import java.awt.Color;
  65 import java.beans.PropertyChangeSupport;
  66 import java.util.ArrayDeque;
  67 import java.util.ArrayList;
  68 import java.util.BitSet;
  69 import java.util.Deque;
  70 import java.util.HashMap;
  71 import java.util.Hashtable;
  72 import java.util.Iterator;
  73 import java.util.List;
  74 import java.util.Map;
  75
  76 /**
  77  * base class holding visualization and analysis attributes and common logic for
  78  * an active alignment view displayed in the GUI
  79  *
  80  * @author jimp
  81  *
  82  */
  83 public abstract class AlignmentViewport
  84         implements AlignViewportI, CommandListener, VamsasSource
  85 {
  86   protected ViewportRanges ranges;
  87
  88   protected ViewStyleI viewStyle = new ViewStyle();
  89
  90   /**
  91    * A viewport that hosts the cDna view of this (protein), or vice versa (if
  92    * set).
  93    */
  94   AlignViewportI codingComplement = null;
  95
  96   FeaturesDisplayedI featuresDisplayed = null;
  97
  98   protected Deque<CommandI> historyList = new ArrayDeque<>();
  99
 100   protected Deque<CommandI> redoList = new ArrayDeque<>();
 101
 102   /**
 103    * alignment displayed in the viewport. Please use get/setter
 104    */
 105   protected AlignmentI alignment;
 106
 107   public AlignmentViewport(AlignmentI al)
 108   {
 109     setAlignment(al);
 110     ranges = new ViewportRanges(al);
 111   }
 112
 113   /**
 114    * @param name
 115    * @see jalview.api.ViewStyleI#setFontName(java.lang.String)
 116    */
 117   @Override
 118   public void setFontName(String name)
 119   {
 120     viewStyle.setFontName(name);
 121   }
 122
 123   /**
 124    * @param style
 125    * @see jalview.api.ViewStyleI#setFontStyle(int)
 126    */
 127   @Override
 128   public void setFontStyle(int style)
 129   {
 130     viewStyle.setFontStyle(style);
 131   }
 132
 133   /**
 134    * @param size
 135    * @see jalview.api.ViewStyleI#setFontSize(int)
 136    */
 137   @Override
 138   public void setFontSize(int size)
 139   {
 140     viewStyle.setFontSize(size);
 141   }
 142
 143   /**
 144    * @return
 145    * @see jalview.api.ViewStyleI#getFontStyle()
 146    */
 147   @Override
 148   public int getFontStyle()
 149   {
 150     return viewStyle.getFontStyle();
 151   }
 152
 153   /**
 154    * @return
 155    * @see jalview.api.ViewStyleI#getFontName()
 156    */
 157   @Override
 158   public String getFontName()
 159   {
 160     return viewStyle.getFontName();
 161   }
 162
 163   /**
 164    * @return
 165    * @see jalview.api.ViewStyleI#getFontSize()
 166    */
 167   @Override
 168   public int getFontSize()
 169   {
 170     return viewStyle.getFontSize();
 171   }
 172
 173   /**
 174    * @param upperCasebold
 175    * @see jalview.api.ViewStyleI#setUpperCasebold(boolean)
 176    */
 177   @Override
 178   public void setUpperCasebold(boolean upperCasebold)
 179   {
 180     viewStyle.setUpperCasebold(upperCasebold);
 181   }
 182
 183   /**
 184    * @return
 185    * @see jalview.api.ViewStyleI#isUpperCasebold()
 186    */
 187   @Override
 188   public boolean isUpperCasebold()
 189   {
 190     return viewStyle.isUpperCasebold();
 191   }
 192
 193   /**
 194    * @return
 195    * @see jalview.api.ViewStyleI#isSeqNameItalics()
 196    */
 197   @Override
 198   public boolean isSeqNameItalics()
 199   {
 200     return viewStyle.isSeqNameItalics();
 201   }
 202
 203   /**
 204    * @param colourByReferenceSeq
 205    * @see jalview.api.ViewStyleI#setColourByReferenceSeq(boolean)
 206    */
 207   @Override
 208   public void setColourByReferenceSeq(boolean colourByReferenceSeq)
 209   {
 210     viewStyle.setColourByReferenceSeq(colourByReferenceSeq);
 211   }
 212
 213   /**
 214    * @param b
 215    * @see jalview.api.ViewStyleI#setColourAppliesToAllGroups(boolean)
 216    */
 217   @Override
 218   public void setColourAppliesToAllGroups(boolean b)
 219   {
 220     viewStyle.setColourAppliesToAllGroups(b);
 221   }
 222
 223   /**
 224    * @return
 225    * @see jalview.api.ViewStyleI#getColourAppliesToAllGroups()
 226    */
 227   @Override
 228   public boolean getColourAppliesToAllGroups()
 229   {
 230     return viewStyle.getColourAppliesToAllGroups();
 231   }
 232
 233   /**
 234    * @return
 235    * @see jalview.api.ViewStyleI#getAbovePIDThreshold()
 236    */
 237   @Override
 238   public boolean getAbovePIDThreshold()
 239   {
 240     return viewStyle.getAbovePIDThreshold();
 241   }
 242
 243   /**
 244    * @param inc
 245    * @see jalview.api.ViewStyleI#setIncrement(int)
 246    */
 247   @Override
 248   public void setIncrement(int inc)
 249   {
 250     viewStyle.setIncrement(inc);
 251   }
 252
 253   /**
 254    * @return
 255    * @see jalview.api.ViewStyleI#getIncrement()
 256    */
 257   @Override
 258   public int getIncrement()
 259   {
 260     return viewStyle.getIncrement();
 261   }
 262
 263   /**
 264    * @param b
 265    * @see jalview.api.ViewStyleI#setConservationSelected(boolean)
 266    */
 267   @Override
 268   public void setConservationSelected(boolean b)
 269   {
 270     viewStyle.setConservationSelected(b);
 271   }
 272
 273   /**
 274    * @param show
 275    * @see jalview.api.ViewStyleI#setShowHiddenMarkers(boolean)
 276    */
 277   @Override
 278   public void setShowHiddenMarkers(boolean show)
 279   {
 280     viewStyle.setShowHiddenMarkers(show);
 281   }
 282
 283   /**
 284    * @return
 285    * @see jalview.api.ViewStyleI#getShowHiddenMarkers()
 286    */
 287   @Override
 288   public boolean getShowHiddenMarkers()
 289   {
 290     return viewStyle.getShowHiddenMarkers();
 291   }
 292
 293   /**
 294    * @param b
 295    * @see jalview.api.ViewStyleI#setScaleRightWrapped(boolean)
 296    */
 297   @Override
 298   public void setScaleRightWrapped(boolean b)
 299   {
 300     viewStyle.setScaleRightWrapped(b);
 301   }
 302
 303   /**
 304    * @param b
 305    * @see jalview.api.ViewStyleI#setScaleLeftWrapped(boolean)
 306    */
 307   @Override
 308   public void setScaleLeftWrapped(boolean b)
 309   {
 310     viewStyle.setScaleLeftWrapped(b);
 311   }
 312
 313   /**
 314    * @param b
 315    * @see jalview.api.ViewStyleI#setScaleAboveWrapped(boolean)
 316    */
 317   @Override
 318   public void setScaleAboveWrapped(boolean b)
 319   {
 320     viewStyle.setScaleAboveWrapped(b);
 321   }
 322
 323   /**
 324    * @return
 325    * @see jalview.api.ViewStyleI#getScaleLeftWrapped()
 326    */
 327   @Override
 328   public boolean getScaleLeftWrapped()
 329   {
 330     return viewStyle.getScaleLeftWrapped();
 331   }
 332
 333   /**
 334    * @return
 335    * @see jalview.api.ViewStyleI#getScaleAboveWrapped()
 336    */
 337   @Override
 338   public boolean getScaleAboveWrapped()
 339   {
 340     return viewStyle.getScaleAboveWrapped();
 341   }
 342
 343   /**
 344    * @return
 345    * @see jalview.api.ViewStyleI#getScaleRightWrapped()
 346    */
 347   @Override
 348   public boolean getScaleRightWrapped()
 349   {
 350     return viewStyle.getScaleRightWrapped();
 351   }
 352
 353   /**
 354    * @param b
 355    * @see jalview.api.ViewStyleI#setAbovePIDThreshold(boolean)
 356    */
 357   @Override
 358   public void setAbovePIDThreshold(boolean b)
 359   {
 360     viewStyle.setAbovePIDThreshold(b);
 361   }
 362
 363   /**
 364    * @param thresh
 365    * @see jalview.api.ViewStyleI#setThreshold(int)
 366    */
 367   @Override
 368   public void setThreshold(int thresh)
 369   {
 370     viewStyle.setThreshold(thresh);
 371   }
 372
 373   /**
 374    * @return
 375    * @see jalview.api.ViewStyleI#getThreshold()
 376    */
 377   @Override
 378   public int getThreshold()
 379   {
 380     return viewStyle.getThreshold();
 381   }
 382
 383   /**
 384    * @return
 385    * @see jalview.api.ViewStyleI#getShowJVSuffix()
 386    */
 387   @Override
 388   public boolean getShowJVSuffix()
 389   {
 390     return viewStyle.getShowJVSuffix();
 391   }
 392
 393   /**
 394    * @param b
 395    * @see jalview.api.ViewStyleI#setShowJVSuffix(boolean)
 396    */
 397   @Override
 398   public void setShowJVSuffix(boolean b)
 399   {
 400     viewStyle.setShowJVSuffix(b);
 401   }
 402
 403   /**
 404    * @param state
 405    * @see jalview.api.ViewStyleI#setWrapAlignment(boolean)
 406    */
 407   @Override
 408   public void setWrapAlignment(boolean state)
 409   {
 410     viewStyle.setWrapAlignment(state);
 411     ranges.setWrappedMode(state);
 412   }
 413
 414   /**
 415    * @param state
 416    * @see jalview.api.ViewStyleI#setShowText(boolean)
 417    */
 418   @Override
 419   public void setShowText(boolean state)
 420   {
 421     viewStyle.setShowText(state);
 422   }
 423
 424   /**
 425    * @param state
 426    * @see jalview.api.ViewStyleI#setRenderGaps(boolean)
 427    */
 428   @Override
 429   public void setRenderGaps(boolean state)
 430   {
 431     viewStyle.setRenderGaps(state);
 432   }
 433
 434   /**
 435    * @return
 436    * @see jalview.api.ViewStyleI#getColourText()
 437    */
 438   @Override
 439   public boolean getColourText()
 440   {
 441     return viewStyle.getColourText();
 442   }
 443
 444   /**
 445    * @param state
 446    * @see jalview.api.ViewStyleI#setColourText(boolean)
 447    */
 448   @Override
 449   public void setColourText(boolean state)
 450   {
 451     viewStyle.setColourText(state);
 452   }
 453
 454   /**
 455    * @return
 456    * @see jalview.api.ViewStyleI#getWrapAlignment()
 457    */
 458   @Override
 459   public boolean getWrapAlignment()
 460   {
 461     return viewStyle.getWrapAlignment();
 462   }
 463
 464   /**
 465    * @return
 466    * @see jalview.api.ViewStyleI#getShowText()
 467    */
 468   @Override
 469   public boolean getShowText()
 470   {
 471     return viewStyle.getShowText();
 472   }
 473
 474   /**
 475    * @return
 476    * @see jalview.api.ViewStyleI#getWrappedWidth()
 477    */
 478   @Override
 479   public int getWrappedWidth()
 480   {
 481     return viewStyle.getWrappedWidth();
 482   }
 483
 484   /**
 485    * @param w
 486    * @see jalview.api.ViewStyleI#setWrappedWidth(int)
 487    */
 488   @Override
 489   public void setWrappedWidth(int w)
 490   {
 491     viewStyle.setWrappedWidth(w);
 492   }
 493
 494   /**
 495    * @return
 496    * @see jalview.api.ViewStyleI#getCharHeight()
 497    */
 498   @Override
 499   public int getCharHeight()
 500   {
 501     return viewStyle.getCharHeight();
 502   }
 503
 504   /**
 505    * @param h
 506    * @see jalview.api.ViewStyleI#setCharHeight(int)
 507    */
 508   @Override
 509   public void setCharHeight(int h)
 510   {
 511     viewStyle.setCharHeight(h);
 512   }
 513
 514   /**
 515    * @return
 516    * @see jalview.api.ViewStyleI#getCharWidth()
 517    */
 518   @Override
 519   public int getCharWidth()
 520   {
 521     return viewStyle.getCharWidth();
 522   }
 523
 524   /**
 525    * @param w
 526    * @see jalview.api.ViewStyleI#setCharWidth(int)
 527    */
 528   @Override
 529   public void setCharWidth(int w)
 530   {
 531     viewStyle.setCharWidth(w);
 532   }
 533
 534   /**
 535    * @return
 536    * @see jalview.api.ViewStyleI#getShowBoxes()
 537    */
 538   @Override
 539   public boolean getShowBoxes()
 540   {
 541     return viewStyle.getShowBoxes();
 542   }
 543
 544   /**
 545    * @return
 546    * @see jalview.api.ViewStyleI#getShowUnconserved()
 547    */
 548   @Override
 549   public boolean getShowUnconserved()
 550   {
 551     return viewStyle.getShowUnconserved();
 552   }
 553
 554   /**
 555    * @param showunconserved
 556    * @see jalview.api.ViewStyleI#setShowUnconserved(boolean)
 557    */
 558   @Override
 559   public void setShowUnconserved(boolean showunconserved)
 560   {
 561     viewStyle.setShowUnconserved(showunconserved);
 562   }
 563
 564   /**
 565    * @param default1
 566    * @see jalview.api.ViewStyleI#setSeqNameItalics(boolean)
 567    */
 568   @Override
 569   public void setSeqNameItalics(boolean default1)
 570   {
 571     viewStyle.setSeqNameItalics(default1);
 572   }
 573
 574   @Override
 575   public AlignmentI getAlignment()
 576   {
 577     return alignment;
 578   }
 579
 580   @Override
 581   public char getGapCharacter()
 582   {
 583     return alignment.getGapCharacter();
 584   }
 585
 586   protected String sequenceSetID;
 587
 588   /**
 589    * probably unused indicator that view is of a dataset rather than an
 590    * alignment
 591    */
 592   protected boolean isDataset = false;
 593
 594   public void setDataset(boolean b)
 595   {
 596     isDataset = b;
 597   }
 598
 599   public boolean isDataset()
 600   {
 601     return isDataset;
 602   }
 603
 604   private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
 605
 606   protected ColumnSelection colSel = new ColumnSelection();
 607
 608   public boolean autoCalculateConsensus = true;
 609
 610   protected boolean autoCalculateStrucConsensus = true;
 611
 612   protected boolean ignoreGapsInConsensusCalculation = false;
 613
 614   protected ResidueShaderI residueShading = new ResidueShader();
 615
 616   @Override
 617   public void setGlobalColourScheme(ColourSchemeI cs)
 618   {
 619     // TODO: logic refactored from AlignFrame changeColour -
 620     // TODO: autorecalc stuff should be changed to rely on the worker system
 621     // check to see if we should implement a changeColour(cs) method rather than
 622     // put the logic in here
 623     // - means that caller decides if they want to just modify state and defer
 624     // calculation till later or to do all calculations in thread.
 625     // via changecolour
 626
 627     /*
 628      * only instantiate alignment colouring once, thereafter update it;
 629      * this means that any conservation or PID threshold settings
 630      * persist when the alignment colour scheme is changed
 631      */
 632     if (residueShading == null)
 633     {
 634       residueShading = new ResidueShader(viewStyle);
 635     }
 636     residueShading.setColourScheme(cs);
 637
 638     // TODO: do threshold and increment belong in ViewStyle or ResidueShader?
 639     // ...problem: groups need these, but do not currently have a ViewStyle
 640
 641     if (cs != null)
 642     {
 643       if (getConservationSelected())
 644       {
 645         residueShading.setConservation(hconservation);
 646       }
 647       /*
 648        * reset conservation flag in case just set to false if
 649        * Conservation was null (calculation still in progress)
 650        */
 651       residueShading.setConservationApplied(getConservationSelected());
 652       residueShading.alignmentChanged(alignment, hiddenRepSequences);
 653     }
 654
 655     /*
 656      * if 'apply colour to all groups' is selected... do so
 657      * (but don't transfer any colour threshold settings to groups)
 658      */
 659     if (getColourAppliesToAllGroups())
 660     {
 661       for (SequenceGroup sg : getAlignment().getGroups())
 662       {
 663         /*
 664          * retain any colour thresholds per group while
 665          * changing choice of colour scheme (JAL-2386)
 666          */
 667         sg.setColourScheme(
 668                 cs == null ? null : cs.getInstance(this, sg));
 669         if (cs != null)
 670         {
 671           sg.getGroupColourScheme().alignmentChanged(sg,
 672                   hiddenRepSequences);
 673         }
 674       }
 675     }
 676   }
 677
 678   @Override
 679   public ColourSchemeI getGlobalColourScheme()
 680   {
 681     return residueShading == null ? null : residueShading.getColourScheme();
 682   }
 683
 684   @Override
 685   public ResidueShaderI getResidueShading()
 686   {
 687     return residueShading;
 688   }
 689
 690   protected AlignmentAnnotation consensus;
 691
 692   protected AlignmentAnnotation complementConsensus;
 693
 694   protected AlignmentAnnotation gapcounts;
 695
 696   protected AlignmentAnnotation strucConsensus;
 697
 698   protected AlignmentAnnotation conservation;
 699
 700   protected AlignmentAnnotation quality;
 701
 702   protected AlignmentAnnotation[] groupConsensus;
 703
 704   protected AlignmentAnnotation[] groupConservation;
 705
 706   /**
 707    * results of alignment consensus analysis for visible portion of view
 708    */
 709   protected ProfilesI hconsensus = null;
 710
 711   /**
 712    * results of cDNA complement consensus visible portion of view
 713    */
 714   protected Hashtable<String, Object>[] hcomplementConsensus = null;
 715
 716   /**
 717    * results of secondary structure base pair consensus for visible portion of
 718    * view
 719    */
 720   protected Hashtable<String, Object>[] hStrucConsensus = null;
 721
 722   protected Conservation hconservation = null;
 723
 724   @Override
 725   public void setConservation(Conservation cons)
 726   {
 727     hconservation = cons;
 728   }
 729
 730   /**
 731    * percentage gaps allowed in a column before all amino acid properties should
 732    * be considered unconserved
 733    */
 734   int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
 735
 736   @Override
 737   public int getConsPercGaps()
 738   {
 739     return ConsPercGaps;
 740   }
 741
 742   @Override
 743   public void setSequenceConsensusHash(ProfilesI hconsensus)
 744   {
 745     this.hconsensus = hconsensus;
 746   }
 747
 748   @Override
 749   public void setComplementConsensusHash(
 750           Hashtable<String, Object>[] hconsensus)
 751   {
 752     this.hcomplementConsensus = hconsensus;
 753   }
 754
 755   @Override
 756   public ProfilesI getSequenceConsensusHash()
 757   {
 758     return hconsensus;
 759   }
 760
 761   @Override
 762   public Hashtable<String, Object>[] getComplementConsensusHash()
 763   {
 764     return hcomplementConsensus;
 765   }
 766
 767   @Override
 768   public Hashtable<String, Object>[] getRnaStructureConsensusHash()
 769   {
 770     return hStrucConsensus;
 771   }
 772
 773   @Override
 774   public void setRnaStructureConsensusHash(
 775           Hashtable<String, Object>[] hStrucConsensus)
 776   {
 777     this.hStrucConsensus = hStrucConsensus;
 778
 779   }
 780
 781   @Override
 782   public AlignmentAnnotation getAlignmentQualityAnnot()
 783   {
 784     return quality;
 785   }
 786
 787   @Override
 788   public AlignmentAnnotation getAlignmentConservationAnnotation()
 789   {
 790     return conservation;
 791   }
 792
 793   @Override
 794   public AlignmentAnnotation getAlignmentConsensusAnnotation()
 795   {
 796     return consensus;
 797   }
 798
 799   @Override
 800   public AlignmentAnnotation getAlignmentGapAnnotation()
 801   {
 802     return gapcounts;
 803   }
 804
 805   @Override
 806   public AlignmentAnnotation getComplementConsensusAnnotation()
 807   {
 808     return complementConsensus;
 809   }
 810
 811   @Override
 812   public AlignmentAnnotation getAlignmentStrucConsensusAnnotation()
 813   {
 814     return strucConsensus;
 815   }
 816
 817   protected AlignCalcManagerI calculator = new AlignCalcManager();
 818
 819   /**
 820    * trigger update of conservation annotation
 821    */
 822   public void updateConservation(final AlignmentViewPanel ap)
 823   {
 824     // see note in mantis : issue number 8585
 825     if (alignment.isNucleotide()
 826             || (conservation == null && quality == null)
 827             || !autoCalculateConsensus)
 828     {
 829       return;
 830     }
 831     if (calculator.getRegisteredWorkersOfClass(
 832             jalview.workers.ConservationThread.class) == null)
 833     {
 834       calculator.registerWorker(
 835               new jalview.workers.ConservationThread(this, ap));
 836     }
 837   }
 838
 839   /**
 840    * trigger update of consensus annotation
 841    */
 842   public void updateConsensus(final AlignmentViewPanel ap)
 843   {
 844     // see note in mantis : issue number 8585
 845     if (consensus == null || !autoCalculateConsensus)
 846     {
 847       return;
 848     }
 849     if (calculator
 850             .getRegisteredWorkersOfClass(ConsensusThread.class) == null)
 851     {
 852       calculator.registerWorker(new ConsensusThread(this, ap));
 853     }
 854
 855     /*
 856      * A separate thread to compute cDNA consensus for a protein alignment
 857      * which has mapping to cDNA
 858      */
 859     final AlignmentI al = this.getAlignment();
 860     if (!al.isNucleotide() && al.getCodonFrames() != null
 861             && !al.getCodonFrames().isEmpty())
 862     {
 863       /*
 864        * fudge - check first for protein-to-nucleotide mappings
 865        * (we don't want to do this for protein-to-protein)
 866        */
 867       boolean doConsensus = false;
 868       for (AlignedCodonFrame mapping : al.getCodonFrames())
 869       {
 870         // TODO hold mapping type e.g. dna-to-protein in AlignedCodonFrame?
 871         MapList[] mapLists = mapping.getdnaToProt();
 872         // mapLists can be empty if project load has not finished resolving seqs
 873         if (mapLists.length > 0 && mapLists[0].getFromRatio() == 3)
 874         {
 875           doConsensus = true;
 876           break;
 877         }
 878       }
 879       if (doConsensus)
 880       {
 881         if (calculator.getRegisteredWorkersOfClass(
 882                 ComplementConsensusThread.class) == null)
 883         {
 884           calculator
 885                   .registerWorker(new ComplementConsensusThread(this, ap));
 886         }
 887       }
 888     }
 889   }
 890
 891   // --------START Structure Conservation
 892   public void updateStrucConsensus(final AlignmentViewPanel ap)
 893   {
 894     if (autoCalculateStrucConsensus && strucConsensus == null
 895             && alignment.isNucleotide() && alignment.hasRNAStructure())
 896     {
 897       // secondary structure has been added - so init the consensus line
 898       initRNAStructure();
 899     }
 900
 901     // see note in mantis : issue number 8585
 902     if (strucConsensus == null || !autoCalculateStrucConsensus)
 903     {
 904       return;
 905     }
 906     if (calculator.getRegisteredWorkersOfClass(
 907             StrucConsensusThread.class) == null)
 908     {
 909       calculator.registerWorker(new StrucConsensusThread(this, ap));
 910     }
 911   }
 912
 913   public boolean isCalcInProgress()
 914   {
 915     return calculator.isWorking();
 916   }
 917
 918   @Override
 919   public boolean isCalculationInProgress(
 920           AlignmentAnnotation alignmentAnnotation)
 921   {
 922     if (!alignmentAnnotation.autoCalculated)
 923     {
 924       return false;
 925     }
 926     if (calculator.workingInvolvedWith(alignmentAnnotation))
 927     {
 928       // System.err.println("grey out ("+alignmentAnnotation.label+")");
 929       return true;
 930     }
 931     return false;
 932   }
 933
 934   public void setAlignment(AlignmentI align)
 935   {
 936     this.alignment = align;
 937   }
 938
 939   /**
 940    * Clean up references when this viewport is closed
 941    */
 942   @Override
 943   public void dispose()
 944   {
 945     /*
 946      * defensively null out references to large objects in case
 947      * this object is not garbage collected (as if!)
 948      */
 949     consensus = null;
 950     complementConsensus = null;
 951     strucConsensus = null;
 952     conservation = null;
 953     quality = null;
 954     groupConsensus = null;
 955     groupConservation = null;
 956     hconsensus = null;
 957     hconservation = null;
 958     hcomplementConsensus = null;
 959     gapcounts = null;
 960     calculator = null;
 961     residueShading = null; // may hold a reference to Consensus
 962     changeSupport = null;
 963     ranges = null;
 964     currentTree = null;
 965     selectionGroup = null;
 966     colSel = null;
 967     setAlignment(null);
 968   }
 969
 970   @Override
 971   public boolean isClosed()
 972   {
 973     // TODO: check that this isClosed is only true after panel is closed, not
 974     // before it is fully constructed.
 975     return alignment == null;
 976   }
 977
 978   @Override
 979   public AlignCalcManagerI getCalcManager()
 980   {
 981     return calculator;
 982   }
 983
 984   /**
 985    * should conservation rows be shown for groups
 986    */
 987   protected boolean showGroupConservation = false;
 988
 989   /**
 990    * should consensus rows be shown for groups
 991    */
 992   protected boolean showGroupConsensus = false;
 993
 994   /**
 995    * should consensus profile be rendered by default
 996    */
 997   protected boolean showSequenceLogo = false;
 998
 999   /**
1000    * should consensus profile be rendered normalised to row height
1001    */
1002   protected boolean normaliseSequenceLogo = false;
1003
1004   /**
1005    * should consensus histograms be rendered by default
1006    */
1007   protected boolean showConsensusHistogram = true;
1008
1009   /**
1010    * @return the showConsensusProfile
1011    */
1012   @Override
1013   public boolean isShowSequenceLogo()
1014   {
1015     return showSequenceLogo;
1016   }
1017
1018   /**
1019    * @param showSequenceLogo
1020    *          the new value
1021    */
1022   public void setShowSequenceLogo(boolean showSequenceLogo)
1023   {
1024     if (showSequenceLogo != this.showSequenceLogo)
1025     {
1026       // TODO: decouple settings setting from calculation when refactoring
1027       // annotation update method from alignframe to viewport
1028       this.showSequenceLogo = showSequenceLogo;
1029       calculator.updateAnnotationFor(ConsensusThread.class);
1030       calculator.updateAnnotationFor(ComplementConsensusThread.class);
1031       calculator.updateAnnotationFor(StrucConsensusThread.class);
1032     }
1033     this.showSequenceLogo = showSequenceLogo;
1034   }
1035
1036   /**
1037    * @param showConsensusHistogram
1038    *          the showConsensusHistogram to set
1039    */
1040   public void setShowConsensusHistogram(boolean showConsensusHistogram)
1041   {
1042     this.showConsensusHistogram = showConsensusHistogram;
1043   }
1044
1045   /**
1046    * @return the showGroupConservation
1047    */
1048   public boolean isShowGroupConservation()
1049   {
1050     return showGroupConservation;
1051   }
1052
1053   /**
1054    * @param showGroupConservation
1055    *          the showGroupConservation to set
1056    */
1057   public void setShowGroupConservation(boolean showGroupConservation)
1058   {
1059     this.showGroupConservation = showGroupConservation;
1060   }
1061
1062   /**
1063    * @return the showGroupConsensus
1064    */
1065   public boolean isShowGroupConsensus()
1066   {
1067     return showGroupConsensus;
1068   }
1069
1070   /**
1071    * @param showGroupConsensus
1072    *          the showGroupConsensus to set
1073    */
1074   public void setShowGroupConsensus(boolean showGroupConsensus)
1075   {
1076     this.showGroupConsensus = showGroupConsensus;
1077   }
1078
1079   /**
1080    *
1081    * @return flag to indicate if the consensus histogram should be rendered by
1082    *         default
1083    */
1084   @Override
1085   public boolean isShowConsensusHistogram()
1086   {
1087     return this.showConsensusHistogram;
1088   }
1089
1090   /**
1091    * when set, updateAlignment will always ensure sequences are of equal length
1092    */
1093   private boolean padGaps = false;
1094
1095   /**
1096    * when set, alignment should be reordered according to a newly opened tree
1097    */
1098   public boolean sortByTree = false;
1099
1100   /**
1101    *
1102    *
1103    * @return null or the currently selected sequence region
1104    */
1105   @Override
1106   public SequenceGroup getSelectionGroup()
1107   {
1108     return selectionGroup;
1109   }
1110
1111   /**
1112    * Set the selection group for this window. Also sets the current alignment as
1113    * the context for the group, if it does not already have one.
1114    *
1115    * @param sg
1116    *          - group holding references to sequences in this alignment view
1117    *
1118    */
1119   @Override
1120   public void setSelectionGroup(SequenceGroup sg)
1121   {
1122     selectionGroup = sg;
1123     if (sg != null && sg.getContext() == null)
1124     {
1125       sg.setContext(alignment);
1126     }
1127   }
1128
1129   public void setHiddenColumns(HiddenColumns hidden)
1130   {
1131     this.alignment.setHiddenColumns(hidden);
1132   }
1133
1134   @Override
1135   public ColumnSelection getColumnSelection()
1136   {
1137     return colSel;
1138   }
1139
1140   @Override
1141   public void setColumnSelection(ColumnSelection colSel)
1142   {
1143     this.colSel = colSel;
1144     if (colSel != null)
1145     {
1146       updateHiddenColumns();
1147     }
1148     isColSelChanged(true);
1149   }
1150
1151   /**
1152    *
1153    * @return
1154    */
1155   @Override
1156   public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
1157   {
1158     return hiddenRepSequences;
1159   }
1160
1161   @Override
1162   public void setHiddenRepSequences(
1163           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
1164   {
1165     this.hiddenRepSequences = hiddenRepSequences;
1166   }
1167
1168   @Override
1169   public boolean hasSelectedColumns()
1170   {
1171     ColumnSelection columnSelection = getColumnSelection();
1172     return columnSelection != null && columnSelection.hasSelectedColumns();
1173   }
1174
1175   @Override
1176   public boolean hasHiddenColumns()
1177   {
1178     return alignment.getHiddenColumns() != null
1179             && alignment.getHiddenColumns().hasHiddenColumns();
1180   }
1181
1182   public void updateHiddenColumns()
1183   {
1184     // this method doesn't really do anything now. But - it could, since a
1185     // column Selection could be in the process of modification
1186     // hasHiddenColumns = colSel.hasHiddenColumns();
1187   }
1188
1189   @Override
1190   public boolean hasHiddenRows()
1191   {
1192     return alignment.getHiddenSequences().getSize() > 0;
1193   }
1194
1195   protected SequenceGroup selectionGroup;
1196
1197   public void setSequenceSetId(String newid)
1198   {
1199     if (sequenceSetID != null)
1200     {
1201       System.err.println(
1202               "Warning - overwriting a sequenceSetId for a viewport!");
1203     }
1204     sequenceSetID = new String(newid);
1205   }
1206
1207   @Override
1208   public String getSequenceSetId()
1209   {
1210     if (sequenceSetID == null)
1211     {
1212       sequenceSetID = alignment.hashCode() + "";
1213     }
1214
1215     return sequenceSetID;
1216   }
1217
1218   /**
1219    * unique viewId for synchronizing state (e.g. with stored Jalview Project)
1220    *
1221    */
1222   protected String viewId = null;
1223
1224   @Override
1225   public String getViewId()
1226   {
1227     if (viewId == null)
1228     {
1229       viewId = this.getSequenceSetId() + "." + this.hashCode() + "";
1230     }
1231     return viewId;
1232   }
1233
1234   public void setIgnoreGapsConsensus(boolean b, AlignmentViewPanel ap)
1235   {
1236     ignoreGapsInConsensusCalculation = b;
1237     if (ap != null)
1238     {
1239       updateConsensus(ap);
1240       if (residueShading != null)
1241       {
1242         residueShading.setThreshold(residueShading.getThreshold(),
1243                 ignoreGapsInConsensusCalculation);
1244       }
1245     }
1246
1247   }
1248
1249   private long sgrouphash = -1, colselhash = -1;
1250
1251   /**
1252    * checks current SelectionGroup against record of last hash value, and
1253    * updates record.
1254    *
1255    * @param b
1256    *          update the record of last hash value
1257    *
1258    * @return true if SelectionGroup changed since last call (when b is true)
1259    */
1260   public boolean isSelectionGroupChanged(boolean b)
1261   {
1262     int hc = (selectionGroup == null || selectionGroup.getSize() == 0) ? -1
1263             : selectionGroup.hashCode();
1264     if (hc != -1 && hc != sgrouphash)
1265     {
1266       if (b)
1267       {
1268         sgrouphash = hc;
1269       }
1270       return true;
1271     }
1272     return false;
1273   }
1274
1275   /**
1276    * checks current colsel against record of last hash value, and optionally
1277    * updates record.
1278    *
1279    * @param b
1280    *          update the record of last hash value
1281    * @return true if colsel changed since last call (when b is true)
1282    */
1283   public boolean isColSelChanged(boolean b)
1284   {
1285     int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
1286     if (hc != -1 && hc != colselhash)
1287     {
1288       if (b)
1289       {
1290         colselhash = hc;
1291       }
1292       return true;
1293     }
1294     return false;
1295   }
1296
1297   @Override
1298   public boolean isIgnoreGapsConsensus()
1299   {
1300     return ignoreGapsInConsensusCalculation;
1301   }
1302
1303   // property change stuff
1304   // JBPNote Prolly only need this in the applet version.
1305   private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
1306           this);
1307
1308   protected boolean showConservation = true;
1309
1310   protected boolean showQuality = true;
1311
1312   protected boolean showConsensus = true;
1313
1314   protected boolean showOccupancy = true;
1315
1316   private Map<SequenceI, Color> sequenceColours = new HashMap<>();
1317
1318   protected SequenceAnnotationOrder sortAnnotationsBy = null;
1319
1320   protected boolean showAutocalculatedAbove;
1321
1322   /**
1323    * when set, view will scroll to show the highlighted position
1324    */
1325   private boolean followHighlight = true;
1326
1327   /**
1328    * Property change listener for changes in alignment
1329    *
1330    * @param listener
1331    *          DOCUMENT ME!
1332    */
1333   public void addPropertyChangeListener(
1334           java.beans.PropertyChangeListener listener)
1335   {
1336     changeSupport.addPropertyChangeListener(listener);
1337   }
1338
1339   /**
1340    * DOCUMENT ME!
1341    *
1342    * @param listener
1343    *          DOCUMENT ME!
1344    */
1345   public void removePropertyChangeListener(
1346           java.beans.PropertyChangeListener listener)
1347   {
1348     if (changeSupport != null)
1349     {
1350       changeSupport.removePropertyChangeListener(listener);
1351     }
1352   }
1353
1354   /**
1355    * Property change listener for changes in alignment
1356    *
1357    * @param prop
1358    *          DOCUMENT ME!
1359    * @param oldvalue
1360    *          DOCUMENT ME!
1361    * @param newvalue
1362    *          DOCUMENT ME!
1363    */
1364   public void firePropertyChange(String prop, Object oldvalue,
1365           Object newvalue)
1366   {
1367     changeSupport.firePropertyChange(prop, oldvalue, newvalue);
1368   }
1369
1370   // common hide/show column stuff
1371
1372   public void hideSelectedColumns()
1373   {
1374     if (colSel.isEmpty())
1375     {
1376       return;
1377     }
1378
1379     colSel.hideSelectedColumns(alignment);
1380     setSelectionGroup(null);
1381     isColSelChanged(true);
1382   }
1383
1384   public void hideColumns(int start, int end)
1385   {
1386     if (start == end)
1387     {
1388       colSel.hideSelectedColumns(start, alignment.getHiddenColumns());
1389     }
1390     else
1391     {
1392       alignment.getHiddenColumns().hideColumns(start, end);
1393     }
1394     isColSelChanged(true);
1395   }
1396
1397   public void showColumn(int col)
1398   {
1399     alignment.getHiddenColumns().revealHiddenColumns(col, colSel);
1400     isColSelChanged(true);
1401   }
1402
1403   public void showAllHiddenColumns()
1404   {
1405     alignment.getHiddenColumns().revealAllHiddenColumns(colSel);
1406     isColSelChanged(true);
1407   }
1408
1409   // common hide/show seq stuff
1410   public void showAllHiddenSeqs()
1411   {
1412     int startSeq = ranges.getStartSeq();
1413     int endSeq = ranges.getEndSeq();
1414
1415     if (alignment.getHiddenSequences().getSize() > 0)
1416     {
1417       if (selectionGroup == null)
1418       {
1419         selectionGroup = new SequenceGroup();
1420         selectionGroup.setEndRes(alignment.getWidth() - 1);
1421       }
1422       List<SequenceI> tmp = alignment.getHiddenSequences()
1423               .showAll(hiddenRepSequences);
1424       for (SequenceI seq : tmp)
1425       {
1426         selectionGroup.addSequence(seq, false);
1427         setSequenceAnnotationsVisible(seq, true);
1428       }
1429
1430       hiddenRepSequences = null;
1431
1432       ranges.setStartEndSeq(startSeq, endSeq + tmp.size());
1433
1434       firePropertyChange("alignment", null, alignment.getSequences());
1435       // used to set hasHiddenRows/hiddenRepSequences here, after the property
1436       // changed event
1437       sendSelection();
1438     }
1439   }
1440
1441   public void showSequence(int index)
1442   {
1443     int startSeq = ranges.getStartSeq();
1444     int endSeq = ranges.getEndSeq();
1445
1446     List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(index,
1447             hiddenRepSequences);
1448     if (tmp.size() > 0)
1449     {
1450       if (selectionGroup == null)
1451       {
1452         selectionGroup = new SequenceGroup();
1453         selectionGroup.setEndRes(alignment.getWidth() - 1);
1454       }
1455
1456       for (SequenceI seq : tmp)
1457       {
1458         selectionGroup.addSequence(seq, false);
1459         setSequenceAnnotationsVisible(seq, true);
1460       }
1461
1462       ranges.setStartEndSeq(startSeq, endSeq + tmp.size());
1463
1464       firePropertyChange("alignment", null, alignment.getSequences());
1465       sendSelection();
1466     }
1467   }
1468
1469   public void hideAllSelectedSeqs()
1470   {
1471     if (selectionGroup == null || selectionGroup.getSize() < 1)
1472     {
1473       return;
1474     }
1475
1476     SequenceI[] seqs = selectionGroup.getSequencesInOrder(alignment);
1477
1478     hideSequence(seqs);
1479
1480     setSelectionGroup(null);
1481   }
1482
1483   public void hideSequence(SequenceI[] seq)
1484   {
1485     /*
1486      * cache offset to first visible sequence
1487      */
1488     int startSeq = ranges.getStartSeq();
1489
1490     if (seq != null)
1491     {
1492       for (int i = 0; i < seq.length; i++)
1493       {
1494         alignment.getHiddenSequences().hideSequence(seq[i]);
1495         setSequenceAnnotationsVisible(seq[i], false);
1496       }
1497       ranges.setStartSeq(startSeq);
1498       firePropertyChange("alignment", null, alignment.getSequences());
1499     }
1500   }
1501
1502   /**
1503    * Hides the specified sequence, or the sequences it represents
1504    *
1505    * @param sequence
1506    *          the sequence to hide, or keep as representative
1507    * @param representGroup
1508    *          if true, hide the current selection group except for the
1509    *          representative sequence
1510    */
1511   public void hideSequences(SequenceI sequence, boolean representGroup)
1512   {
1513     if (selectionGroup == null || selectionGroup.getSize() < 1)
1514     {
1515       hideSequence(new SequenceI[] { sequence });
1516       return;
1517     }
1518
1519     if (representGroup)
1520     {
1521       hideRepSequences(sequence, selectionGroup);
1522       setSelectionGroup(null);
1523       return;
1524     }
1525
1526     int gsize = selectionGroup.getSize();
1527     SequenceI[] hseqs = selectionGroup.getSequences()
1528             .toArray(new SequenceI[gsize]);
1529
1530     hideSequence(hseqs);
1531     setSelectionGroup(null);
1532     sendSelection();
1533   }
1534
1535   /**
1536    * Set visibility for any annotations for the given sequence.
1537    *
1538    * @param sequenceI
1539    */
1540   protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
1541           boolean visible)
1542   {
1543     AlignmentAnnotation[] anns = alignment.getAlignmentAnnotation();
1544     if (anns != null)
1545     {
1546       for (AlignmentAnnotation ann : anns)
1547       {
1548         if (ann.sequenceRef == sequenceI)
1549         {
1550           ann.visible = visible;
1551         }
1552       }
1553     }
1554   }
1555
1556   public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
1557   {
1558     int sSize = sg.getSize();
1559     if (sSize < 2)
1560     {
1561       return;
1562     }
1563
1564     if (hiddenRepSequences == null)
1565     {
1566       hiddenRepSequences = new Hashtable<>();
1567     }
1568
1569     hiddenRepSequences.put(repSequence, sg);
1570
1571     // Hide all sequences except the repSequence
1572     SequenceI[] seqs = new SequenceI[sSize - 1];
1573     int index = 0;
1574     for (int i = 0; i < sSize; i++)
1575     {
1576       if (sg.getSequenceAt(i) != repSequence)
1577       {
1578         if (index == sSize - 1)
1579         {
1580           return;
1581         }
1582
1583         seqs[index++] = sg.getSequenceAt(i);
1584       }
1585     }
1586     sg.setSeqrep(repSequence); // note: not done in 2.7applet
1587     sg.setHidereps(true); // note: not done in 2.7applet
1588     hideSequence(seqs);
1589
1590   }
1591
1592   /**
1593    *
1594    * @return null or the current reference sequence
1595    */
1596   public SequenceI getReferenceSeq()
1597   {
1598     return alignment.getSeqrep();
1599   }
1600
1601   /**
1602    * @param seq
1603    * @return true iff seq is the reference for the alignment
1604    */
1605   public boolean isReferenceSeq(SequenceI seq)
1606   {
1607     return alignment.getSeqrep() == seq;
1608   }
1609
1610   /**
1611    *
1612    * @param seq
1613    * @return true if there are sequences represented by this sequence that are
1614    *         currently hidden
1615    */
1616   public boolean isHiddenRepSequence(SequenceI seq)
1617   {
1618     return (hiddenRepSequences != null
1619             && hiddenRepSequences.containsKey(seq));
1620   }
1621
1622   /**
1623    *
1624    * @param seq
1625    * @return null or a sequence group containing the sequences that seq
1626    *         represents
1627    */
1628   public SequenceGroup getRepresentedSequences(SequenceI seq)
1629   {
1630     return (SequenceGroup) (hiddenRepSequences == null ? null
1631             : hiddenRepSequences.get(seq));
1632   }
1633
1634   @Override
1635   public int adjustForHiddenSeqs(int alignmentIndex)
1636   {
1637     return alignment.getHiddenSequences()
1638             .adjustForHiddenSeqs(alignmentIndex);
1639   }
1640
1641   @Override
1642   public void invertColumnSelection()
1643   {
1644     colSel.invertColumnSelection(0, alignment.getWidth(), alignment);
1645     isColSelChanged(true);
1646   }
1647
1648   @Override
1649   public SequenceI[] getSelectionAsNewSequence()
1650   {
1651     SequenceI[] sequences;
1652     // JBPNote: Need to test jalviewLite.getSelectedSequencesAsAlignmentFrom -
1653     // this was the only caller in the applet for this method
1654     // JBPNote: in applet, this method returned references to the alignment
1655     // sequences, and it did not honour the presence/absence of annotation
1656     // attached to the alignment (probably!)
1657     if (selectionGroup == null || selectionGroup.getSize() == 0)
1658     {
1659       sequences = alignment.getSequencesArray();
1660       AlignmentAnnotation[] annots = alignment.getAlignmentAnnotation();
1661       for (int i = 0; i < sequences.length; i++)
1662       {
1663         // construct new sequence with subset of visible annotation
1664         sequences[i] = new Sequence(sequences[i], annots);
1665       }
1666     }
1667     else
1668     {
1669       sequences = selectionGroup.getSelectionAsNewSequences(alignment);
1670     }
1671
1672     return sequences;
1673   }
1674
1675   @Override
1676   public SequenceI[] getSequenceSelection()
1677   {
1678     SequenceI[] sequences = null;
1679     if (selectionGroup != null)
1680     {
1681       sequences = selectionGroup.getSequencesInOrder(alignment);
1682     }
1683     if (sequences == null)
1684     {
1685       sequences = alignment.getSequencesArray();
1686     }
1687     return sequences;
1688   }
1689
1690   @Override
1691   public jalview.datamodel.AlignmentView getAlignmentView(
1692           boolean selectedOnly)
1693   {
1694     return getAlignmentView(selectedOnly, false);
1695   }
1696
1697   @Override
1698   public jalview.datamodel.AlignmentView getAlignmentView(
1699           boolean selectedOnly, boolean markGroups)
1700   {
1701     return new AlignmentView(alignment, alignment.getHiddenColumns(),
1702             selectionGroup,
1703             alignment.getHiddenColumns() != null
1704                     && alignment.getHiddenColumns().hasHiddenColumns(),
1705             selectedOnly, markGroups);
1706   }
1707
1708   @Override
1709   public String[] getViewAsString(boolean selectedRegionOnly)
1710   {
1711     return getViewAsString(selectedRegionOnly, true);
1712   }
1713
1714   @Override
1715   public String[] getViewAsString(boolean selectedRegionOnly,
1716           boolean exportHiddenSeqs)
1717   {
1718     String[] selection = null;
1719     SequenceI[] seqs = null;
1720     int i, iSize;
1721     int start = 0, end = 0;
1722     if (selectedRegionOnly && selectionGroup != null)
1723     {
1724       iSize = selectionGroup.getSize();
1725       seqs = selectionGroup.getSequencesInOrder(alignment);
1726       start = selectionGroup.getStartRes();
1727       end = selectionGroup.getEndRes() + 1;
1728     }
1729     else
1730     {
1731       if (hasHiddenRows() && exportHiddenSeqs)
1732       {
1733         AlignmentI fullAlignment = alignment.getHiddenSequences()
1734                 .getFullAlignment();
1735         iSize = fullAlignment.getHeight();
1736         seqs = fullAlignment.getSequencesArray();
1737         end = fullAlignment.getWidth();
1738       }
1739       else
1740       {
1741         iSize = alignment.getHeight();
1742         seqs = alignment.getSequencesArray();
1743         end = alignment.getWidth();
1744       }
1745     }
1746
1747     selection = new String[iSize];
1748     if (alignment.getHiddenColumns() != null
1749             && alignment.getHiddenColumns().hasHiddenColumns())
1750     {
1751       for (i = 0; i < iSize; i++)
1752       {
1753         Iterator<int[]> blocks = alignment.getHiddenColumns()
1754                 .getVisContigsIterator(start, end + 1, false);
1755         selection[i] = seqs[i].getSequenceStringFromIterator(blocks);
1756       }
1757     }
1758     else
1759     {
1760       for (i = 0; i < iSize; i++)
1761       {
1762         selection[i] = seqs[i].getSequenceAsString(start, end);
1763       }
1764
1765     }
1766     return selection;
1767   }
1768
1769   @Override
1770   public List<int[]> getVisibleRegionBoundaries(int min, int max)
1771   {
1772     ArrayList<int[]> regions = new ArrayList<>();
1773     int start = min;
1774     int end = max;
1775
1776     do
1777     {
1778       HiddenColumns hidden = alignment.getHiddenColumns();
1779       if (hidden != null && hidden.hasHiddenColumns())
1780       {
1781         if (start == 0)
1782         {
1783           start = hidden.visibleToAbsoluteColumn(start);
1784         }
1785
1786         end = hidden.getNextHiddenBoundary(false, start);
1787         if (start == end)
1788         {
1789           end = max;
1790         }
1791         if (end > max)
1792         {
1793           end = max;
1794         }
1795       }
1796
1797       regions.add(new int[] { start, end });
1798
1799       if (hidden != null && hidden.hasHiddenColumns())
1800       {
1801         start = hidden.visibleToAbsoluteColumn(end);
1802         start = hidden.getNextHiddenBoundary(true, start) + 1;
1803       }
1804     } while (end < max);
1805
1806     // int[][] startEnd = new int[regions.size()][2];
1807
1808     return regions;
1809   }
1810
1811   @Override
1812   public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(
1813           boolean selectedOnly)
1814   {
1815     ArrayList<AlignmentAnnotation> ala = new ArrayList<>();
1816     AlignmentAnnotation[] aa;
1817     if ((aa = alignment.getAlignmentAnnotation()) != null)
1818     {
1819       for (AlignmentAnnotation annot : aa)
1820       {
1821         AlignmentAnnotation clone = new AlignmentAnnotation(annot);
1822         if (selectedOnly && selectionGroup != null)
1823         {
1824           clone.makeVisibleAnnotation(
1825                   selectionGroup.getStartRes(), selectionGroup.getEndRes(),
1826                   alignment.getHiddenColumns());
1827         }
1828         else
1829         {
1830           clone.makeVisibleAnnotation(alignment.getHiddenColumns());
1831         }
1832         ala.add(clone);
1833       }
1834     }
1835     return ala;
1836   }
1837
1838   @Override
1839   public boolean isPadGaps()
1840   {
1841     return padGaps;
1842   }
1843
1844   @Override
1845   public void setPadGaps(boolean padGaps)
1846   {
1847     this.padGaps = padGaps;
1848   }
1849
1850   /**
1851    * apply any post-edit constraints and trigger any calculations needed after
1852    * an edit has been performed on the alignment
1853    *
1854    * @param ap
1855    */
1856   @Override
1857   public void alignmentChanged(AlignmentViewPanel ap)
1858   {
1859     if (isPadGaps())
1860     {
1861       alignment.padGaps();
1862     }
1863     if (autoCalculateConsensus)
1864     {
1865       updateConsensus(ap);
1866     }
1867     if (hconsensus != null && autoCalculateConsensus)
1868     {
1869       updateConservation(ap);
1870     }
1871     if (autoCalculateStrucConsensus)
1872     {
1873       updateStrucConsensus(ap);
1874     }
1875
1876     // Reset endRes of groups if beyond alignment width
1877     int alWidth = alignment.getWidth();
1878     List<SequenceGroup> groups = alignment.getGroups();
1879     if (groups != null)
1880     {
1881       for (SequenceGroup sg : groups)
1882       {
1883         if (sg.getEndRes() > alWidth)
1884         {
1885           sg.setEndRes(alWidth - 1);
1886         }
1887       }
1888     }
1889
1890     if (selectionGroup != null && selectionGroup.getEndRes() > alWidth)
1891     {
1892       selectionGroup.setEndRes(alWidth - 1);
1893     }
1894
1895     updateAllColourSchemes();
1896     calculator.restartWorkers();
1897     // alignment.adjustSequenceAnnotations();
1898   }
1899
1900   /**
1901    * reset scope and do calculations for all applied colourschemes on alignment
1902    */
1903   void updateAllColourSchemes()
1904   {
1905     ResidueShaderI rs = residueShading;
1906     if (rs != null)
1907     {
1908       rs.alignmentChanged(alignment, hiddenRepSequences);
1909
1910       rs.setConsensus(hconsensus);
1911       if (rs.conservationApplied())
1912       {
1913         rs.setConservation(Conservation.calculateConservation("All",
1914                 alignment.getSequences(), 0, alignment.getWidth(), false,
1915                 getConsPercGaps(), false));
1916       }
1917     }
1918
1919     for (SequenceGroup sg : alignment.getGroups())
1920     {
1921       if (sg.cs != null)
1922       {
1923         sg.cs.alignmentChanged(sg, hiddenRepSequences);
1924       }
1925       sg.recalcConservation();
1926     }
1927   }
1928
1929   protected void initAutoAnnotation()
1930   {
1931     // TODO: add menu option action that nulls or creates consensus object
1932     // depending on if the user wants to see the annotation or not in a
1933     // specific alignment
1934
1935     if (hconsensus == null && !isDataset)
1936     {
1937       if (!alignment.isNucleotide())
1938       {
1939         initConservation();
1940         initQuality();
1941       }
1942       else
1943       {
1944         initRNAStructure();
1945       }
1946       consensus = new AlignmentAnnotation("Consensus",
1947               MessageManager.getString("label.consensus_descr"),
1948               new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
1949       initConsensus(consensus);
1950       initGapCounts();
1951
1952       initComplementConsensus();
1953     }
1954   }
1955
1956   /**
1957    * If this is a protein alignment and there are mappings to cDNA, adds the
1958    * cDNA consensus annotation and returns true, else returns false.
1959    */
1960   public boolean initComplementConsensus()
1961   {
1962     if (!alignment.isNucleotide())
1963     {
1964       final List<AlignedCodonFrame> codonMappings = alignment
1965               .getCodonFrames();
1966       if (codonMappings != null && !codonMappings.isEmpty())
1967       {
1968         boolean doConsensus = false;
1969         for (AlignedCodonFrame mapping : codonMappings)
1970         {
1971           // TODO hold mapping type e.g. dna-to-protein in AlignedCodonFrame?
1972           MapList[] mapLists = mapping.getdnaToProt();
1973           // mapLists can be empty if project load has not finished resolving
1974           // seqs
1975           if (mapLists.length > 0 && mapLists[0].getFromRatio() == 3)
1976           {
1977             doConsensus = true;
1978             break;
1979           }
1980         }
1981         if (doConsensus)
1982         {
1983           complementConsensus = new AlignmentAnnotation("cDNA Consensus",
1984                   MessageManager
1985                           .getString("label.complement_consensus_descr"),
1986                   new Annotation[1], 0f, 100f,
1987                   AlignmentAnnotation.BAR_GRAPH);
1988           initConsensus(complementConsensus);
1989           return true;
1990         }
1991       }
1992     }
1993     return false;
1994   }
1995
1996   private void initConsensus(AlignmentAnnotation aa)
1997   {
1998     aa.hasText = true;
1999     aa.autoCalculated = true;
2000
2001     if (showConsensus)
2002     {
2003       alignment.addAnnotation(aa);
2004     }
2005   }
2006
2007   // these should be extracted from the view model - style and settings for
2008   // derived annotation
2009   private void initGapCounts()
2010   {
2011     if (showOccupancy)
2012     {
2013       gapcounts = new AlignmentAnnotation("Occupancy",
2014               MessageManager.getString("label.occupancy_descr"),
2015               new Annotation[1], 0f, alignment.getHeight(),
2016               AlignmentAnnotation.BAR_GRAPH);
2017       gapcounts.hasText = true;
2018       gapcounts.autoCalculated = true;
2019       gapcounts.scaleColLabel = true;
2020       gapcounts.graph = AlignmentAnnotation.BAR_GRAPH;
2021
2022       alignment.addAnnotation(gapcounts);
2023     }
2024   }
2025
2026   private void initConservation()
2027   {
2028     if (showConservation)
2029     {
2030       if (conservation == null)
2031       {
2032         conservation = new AlignmentAnnotation("Conservation",
2033                 MessageManager.formatMessage("label.conservation_descr",
2034                         getConsPercGaps()),
2035                 new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
2036         conservation.hasText = true;
2037         conservation.autoCalculated = true;
2038         alignment.addAnnotation(conservation);
2039       }
2040     }
2041   }
2042
2043   private void initQuality()
2044   {
2045     if (showQuality)
2046     {
2047       if (quality == null)
2048       {
2049         quality = new AlignmentAnnotation("Quality",
2050                 MessageManager.getString("label.quality_descr"),
2051                 new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
2052         quality.hasText = true;
2053         quality.autoCalculated = true;
2054         alignment.addAnnotation(quality);
2055       }
2056     }
2057   }
2058
2059   private void initRNAStructure()
2060   {
2061     if (alignment.hasRNAStructure() && strucConsensus == null)
2062     {
2063       strucConsensus = new AlignmentAnnotation("StrucConsensus",
2064               MessageManager.getString("label.strucconsensus_descr"),
2065               new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
2066       strucConsensus.hasText = true;
2067       strucConsensus.autoCalculated = true;
2068
2069       if (showConsensus)
2070       {
2071         alignment.addAnnotation(strucConsensus);
2072       }
2073     }
2074   }
2075
2076   /*
2077    * (non-Javadoc)
2078    *
2079    * @see jalview.api.AlignViewportI#calcPanelHeight()
2080    */
2081   @Override
2082   public int calcPanelHeight()
2083   {
2084     // setHeight of panels
2085     AlignmentAnnotation[] anns = getAlignment().getAlignmentAnnotation();
2086     int height = 0;
2087     int charHeight = getCharHeight();
2088     if (anns != null)
2089     {
2090       BitSet graphgrp = new BitSet();
2091       for (AlignmentAnnotation aa : anns)
2092       {
2093         if (aa == null)
2094         {
2095           System.err.println("Null annotation row: ignoring.");
2096           continue;
2097         }
2098         if (!aa.visible)
2099         {
2100           continue;
2101         }
2102         if (aa.graphGroup > -1)
2103         {
2104           if (graphgrp.get(aa.graphGroup))
2105           {
2106             continue;
2107           }
2108           else
2109           {
2110             graphgrp.set(aa.graphGroup);
2111           }
2112         }
2113         aa.height = 0;
2114
2115         if (aa.hasText)
2116         {
2117           aa.height += charHeight;
2118         }
2119
2120         if (aa.hasIcons)
2121         {
2122           aa.height += 16;
2123         }
2124
2125         if (aa.graph > 0)
2126         {
2127           aa.height += aa.graphHeight;
2128         }
2129
2130         if (aa.height == 0)
2131         {
2132           aa.height = 20;
2133         }
2134
2135         height += aa.height;
2136       }
2137     }
2138     if (height == 0)
2139     {
2140       // set minimum
2141       height = 20;
2142     }
2143     return height;
2144   }
2145
2146   @Override
2147   public void updateGroupAnnotationSettings(boolean applyGlobalSettings,
2148           boolean preserveNewGroupSettings)
2149   {
2150     boolean updateCalcs = false;
2151     boolean conv = isShowGroupConservation();
2152     boolean cons = isShowGroupConsensus();
2153     boolean showprf = isShowSequenceLogo();
2154     boolean showConsHist = isShowConsensusHistogram();
2155     boolean normLogo = isNormaliseSequenceLogo();
2156
2157     /**
2158      * TODO reorder the annotation rows according to group/sequence ordering on
2159      * alignment
2160      */
2161     // boolean sortg = true;
2162
2163     // remove old automatic annotation
2164     // add any new annotation
2165
2166     // intersect alignment annotation with alignment groups
2167
2168     AlignmentAnnotation[] aan = alignment.getAlignmentAnnotation();
2169     List<SequenceGroup> oldrfs = new ArrayList<>();
2170     if (aan != null)
2171     {
2172       for (int an = 0; an < aan.length; an++)
2173       {
2174         if (aan[an].autoCalculated && aan[an].groupRef != null)
2175         {
2176           oldrfs.add(aan[an].groupRef);
2177           alignment.deleteAnnotation(aan[an], false);
2178         }
2179       }
2180     }
2181     if (alignment.getGroups() != null)
2182     {
2183       for (SequenceGroup sg : alignment.getGroups())
2184       {
2185         updateCalcs = false;
2186         if (applyGlobalSettings
2187                 || (!preserveNewGroupSettings && !oldrfs.contains(sg)))
2188         {
2189           // set defaults for this group's conservation/consensus
2190           sg.setshowSequenceLogo(showprf);
2191           sg.setShowConsensusHistogram(showConsHist);
2192           sg.setNormaliseSequenceLogo(normLogo);
2193         }
2194         if (conv)
2195         {
2196           updateCalcs = true;
2197           alignment.addAnnotation(sg.getConservationRow(), 0);
2198         }
2199         if (cons)
2200         {
2201           updateCalcs = true;
2202           alignment.addAnnotation(sg.getConsensus(), 0);
2203         }
2204         // refresh the annotation rows
2205         if (updateCalcs)
2206         {
2207           sg.recalcConservation();
2208         }
2209       }
2210     }
2211     oldrfs.clear();
2212   }
2213
2214   @Override
2215   public boolean isDisplayReferenceSeq()
2216   {
2217     return alignment.hasSeqrep() && viewStyle.isDisplayReferenceSeq();
2218   }
2219
2220   @Override
2221   public void setDisplayReferenceSeq(boolean displayReferenceSeq)
2222   {
2223     viewStyle.setDisplayReferenceSeq(displayReferenceSeq);
2224   }
2225
2226   @Override
2227   public boolean isColourByReferenceSeq()
2228   {
2229     return alignment.hasSeqrep() && viewStyle.isColourByReferenceSeq();
2230   }
2231
2232   @Override
2233   public Color getSequenceColour(SequenceI seq)
2234   {
2235     Color sqc = sequenceColours.get(seq);
2236     return (sqc == null ? Color.white : sqc);
2237   }
2238
2239   @Override
2240   public void setSequenceColour(SequenceI seq, Color col)
2241   {
2242     if (col == null)
2243     {
2244       sequenceColours.remove(seq);
2245     }
2246     else
2247     {
2248       sequenceColours.put(seq, col);
2249     }
2250   }
2251
2252   @Override
2253   public void updateSequenceIdColours()
2254   {
2255     for (SequenceGroup sg : alignment.getGroups())
2256     {
2257       if (sg.idColour != null)
2258       {
2259         for (SequenceI s : sg.getSequences(getHiddenRepSequences()))
2260         {
2261           sequenceColours.put(s, sg.idColour);
2262         }
2263       }
2264     }
2265   }
2266
2267   @Override
2268   public void clearSequenceColours()
2269   {
2270     sequenceColours.clear();
2271   }
2272
2273   @Override
2274   public AlignViewportI getCodingComplement()
2275   {
2276     return this.codingComplement;
2277   }
2278
2279   /**
2280    * Set this as the (cDna/protein) complement of the given viewport. Also
2281    * ensures the reverse relationship is set on the given viewport.
2282    */
2283   @Override
2284   public void setCodingComplement(AlignViewportI av)
2285   {
2286     if (this == av)
2287     {
2288       System.err.println("Ignoring recursive setCodingComplement request");
2289     }
2290     else
2291     {
2292       this.codingComplement = av;
2293       // avoid infinite recursion!
2294       if (av.getCodingComplement() != this)
2295       {
2296         av.setCodingComplement(this);
2297       }
2298     }
2299   }
2300
2301   @Override
2302   public boolean isNucleotide()
2303   {
2304     return getAlignment() == null ? false : getAlignment().isNucleotide();
2305   }
2306
2307   @Override
2308   public FeaturesDisplayedI getFeaturesDisplayed()
2309   {
2310     return featuresDisplayed;
2311   }
2312
2313   @Override
2314   public void setFeaturesDisplayed(FeaturesDisplayedI featuresDisplayedI)
2315   {
2316     featuresDisplayed = featuresDisplayedI;
2317   }
2318
2319   @Override
2320   public boolean areFeaturesDisplayed()
2321   {
2322     return featuresDisplayed != null
2323             && featuresDisplayed.getRegisteredFeaturesCount() > 0;
2324   }
2325
2326   /**
2327    * set the flag
2328    *
2329    * @param b
2330    *          features are displayed if true
2331    */
2332   @Override
2333   public void setShowSequenceFeatures(boolean b)
2334   {
2335     viewStyle.setShowSequenceFeatures(b);
2336   }
2337
2338   @Override
2339   public boolean isShowSequenceFeatures()
2340   {
2341     return viewStyle.isShowSequenceFeatures();
2342   }
2343
2344   @Override
2345   public void setShowSequenceFeaturesHeight(boolean selected)
2346   {
2347     viewStyle.setShowSequenceFeaturesHeight(selected);
2348   }
2349
2350   @Override
2351   public boolean isShowSequenceFeaturesHeight()
2352   {
2353     return viewStyle.isShowSequenceFeaturesHeight();
2354   }
2355
2356   @Override
2357   public void setShowAnnotation(boolean b)
2358   {
2359     viewStyle.setShowAnnotation(b);
2360   }
2361
2362   @Override
2363   public boolean isShowAnnotation()
2364   {
2365     return viewStyle.isShowAnnotation();
2366   }
2367
2368   @Override
2369   public boolean isRightAlignIds()
2370   {
2371     return viewStyle.isRightAlignIds();
2372   }
2373
2374   @Override
2375   public void setRightAlignIds(boolean rightAlignIds)
2376   {
2377     viewStyle.setRightAlignIds(rightAlignIds);
2378   }
2379
2380   @Override
2381   public boolean getConservationSelected()
2382   {
2383     return viewStyle.getConservationSelected();
2384   }
2385
2386   @Override
2387   public void setShowBoxes(boolean state)
2388   {
2389     viewStyle.setShowBoxes(state);
2390   }
2391
2392   /**
2393    * @return
2394    * @see jalview.api.ViewStyleI#getTextColour()
2395    */
2396   @Override
2397   public Color getTextColour()
2398   {
2399     return viewStyle.getTextColour();
2400   }
2401
2402   /**
2403    * @return
2404    * @see jalview.api.ViewStyleI#getTextColour2()
2405    */
2406   @Override
2407   public Color getTextColour2()
2408   {
2409     return viewStyle.getTextColour2();
2410   }
2411
2412   /**
2413    * @return
2414    * @see jalview.api.ViewStyleI#getThresholdTextColour()
2415    */
2416   @Override
2417   public int getThresholdTextColour()
2418   {
2419     return viewStyle.getThresholdTextColour();
2420   }
2421
2422   /**
2423    * @return
2424    * @see jalview.api.ViewStyleI#isConservationColourSelected()
2425    */
2426   @Override
2427   public boolean isConservationColourSelected()
2428   {
2429     return viewStyle.isConservationColourSelected();
2430   }
2431
2432   /**
2433    * @return
2434    * @see jalview.api.ViewStyleI#isRenderGaps()
2435    */
2436   @Override
2437   public boolean isRenderGaps()
2438   {
2439     return viewStyle.isRenderGaps();
2440   }
2441
2442   /**
2443    * @return
2444    * @see jalview.api.ViewStyleI#isShowColourText()
2445    */
2446   @Override
2447   public boolean isShowColourText()
2448   {
2449     return viewStyle.isShowColourText();
2450   }
2451
2452   /**
2453    * @param conservationColourSelected
2454    * @see jalview.api.ViewStyleI#setConservationColourSelected(boolean)
2455    */
2456   @Override
2457   public void setConservationColourSelected(
2458           boolean conservationColourSelected)
2459   {
2460     viewStyle.setConservationColourSelected(conservationColourSelected);
2461   }
2462
2463   /**
2464    * @param showColourText
2465    * @see jalview.api.ViewStyleI#setShowColourText(boolean)
2466    */
2467   @Override
2468   public void setShowColourText(boolean showColourText)
2469   {
2470     viewStyle.setShowColourText(showColourText);
2471   }
2472
2473   /**
2474    * @param textColour
2475    * @see jalview.api.ViewStyleI#setTextColour(java.awt.Color)
2476    */
2477   @Override
2478   public void setTextColour(Color textColour)
2479   {
2480     viewStyle.setTextColour(textColour);
2481   }
2482
2483   /**
2484    * @param thresholdTextColour
2485    * @see jalview.api.ViewStyleI#setThresholdTextColour(int)
2486    */
2487   @Override
2488   public void setThresholdTextColour(int thresholdTextColour)
2489   {
2490     viewStyle.setThresholdTextColour(thresholdTextColour);
2491   }
2492
2493   /**
2494    * @param textColour2
2495    * @see jalview.api.ViewStyleI#setTextColour2(java.awt.Color)
2496    */
2497   @Override
2498   public void setTextColour2(Color textColour2)
2499   {
2500     viewStyle.setTextColour2(textColour2);
2501   }
2502
2503   @Override
2504   public ViewStyleI getViewStyle()
2505   {
2506     return new ViewStyle(viewStyle);
2507   }
2508
2509   @Override
2510   public void setViewStyle(ViewStyleI settingsForView)
2511   {
2512     viewStyle = new ViewStyle(settingsForView);
2513     if (residueShading != null)
2514     {
2515       residueShading.setConservationApplied(
2516               settingsForView.isConservationColourSelected());
2517     }
2518   }
2519
2520   @Override
2521   public boolean sameStyle(ViewStyleI them)
2522   {
2523     return viewStyle.sameStyle(them);
2524   }
2525
2526   /**
2527    * @return
2528    * @see jalview.api.ViewStyleI#getIdWidth()
2529    */
2530   @Override
2531   public int getIdWidth()
2532   {
2533     return viewStyle.getIdWidth();
2534   }
2535
2536   /**
2537    * @param i
2538    * @see jalview.api.ViewStyleI#setIdWidth(int)
2539    */
2540   @Override
2541   public void setIdWidth(int i)
2542   {
2543     viewStyle.setIdWidth(i);
2544   }
2545
2546   /**
2547    * @return
2548    * @see jalview.api.ViewStyleI#isCentreColumnLabels()
2549    */
2550   @Override
2551   public boolean isCentreColumnLabels()
2552   {
2553     return viewStyle.isCentreColumnLabels();
2554   }
2555
2556   /**
2557    * @param centreColumnLabels
2558    * @see jalview.api.ViewStyleI#setCentreColumnLabels(boolean)
2559    */
2560   @Override
2561   public void setCentreColumnLabels(boolean centreColumnLabels)
2562   {
2563     viewStyle.setCentreColumnLabels(centreColumnLabels);
2564   }
2565
2566   /**
2567    * @param showdbrefs
2568    * @see jalview.api.ViewStyleI#setShowDBRefs(boolean)
2569    */
2570   @Override
2571   public void setShowDBRefs(boolean showdbrefs)
2572   {
2573     viewStyle.setShowDBRefs(showdbrefs);
2574   }
2575
2576   /**
2577    * @return
2578    * @see jalview.api.ViewStyleI#isShowDBRefs()
2579    */
2580   @Override
2581   public boolean isShowDBRefs()
2582   {
2583     return viewStyle.isShowDBRefs();
2584   }
2585
2586   /**
2587    * @return
2588    * @see jalview.api.ViewStyleI#isShowNPFeats()
2589    */
2590   @Override
2591   public boolean isShowNPFeats()
2592   {
2593     return viewStyle.isShowNPFeats();
2594   }
2595
2596   /**
2597    * @param shownpfeats
2598    * @see jalview.api.ViewStyleI#setShowNPFeats(boolean)
2599    */
2600   @Override
2601   public void setShowNPFeats(boolean shownpfeats)
2602   {
2603     viewStyle.setShowNPFeats(shownpfeats);
2604   }
2605
2606   public abstract StructureSelectionManager getStructureSelectionManager();
2607
2608   /**
2609    * Add one command to the command history list.
2610    *
2611    * @param command
2612    */
2613   public void addToHistoryList(CommandI command)
2614   {
2615     if (this.historyList != null)
2616     {
2617       this.historyList.push(command);
2618       broadcastCommand(command, false);
2619     }
2620   }
2621
2622   protected void broadcastCommand(CommandI command, boolean undo)
2623   {
2624     getStructureSelectionManager().commandPerformed(command, undo,
2625             getVamsasSource());
2626   }
2627
2628   /**
2629    * Add one command to the command redo list.
2630    *
2631    * @param command
2632    */
2633   public void addToRedoList(CommandI command)
2634   {
2635     if (this.redoList != null)
2636     {
2637       this.redoList.push(command);
2638     }
2639     broadcastCommand(command, true);
2640   }
2641
2642   /**
2643    * Clear the command redo list.
2644    */
2645   public void clearRedoList()
2646   {
2647     if (this.redoList != null)
2648     {
2649       this.redoList.clear();
2650     }
2651   }
2652
2653   public void setHistoryList(Deque<CommandI> list)
2654   {
2655     this.historyList = list;
2656   }
2657
2658   public Deque<CommandI> getHistoryList()
2659   {
2660     return this.historyList;
2661   }
2662
2663   public void setRedoList(Deque<CommandI> list)
2664   {
2665     this.redoList = list;
2666   }
2667
2668   public Deque<CommandI> getRedoList()
2669   {
2670     return this.redoList;
2671   }
2672
2673   @Override
2674   public VamsasSource getVamsasSource()
2675   {
2676     return this;
2677   }
2678
2679   public SequenceAnnotationOrder getSortAnnotationsBy()
2680   {
2681     return sortAnnotationsBy;
2682   }
2683
2684   public void setSortAnnotationsBy(
2685           SequenceAnnotationOrder sortAnnotationsBy)
2686   {
2687     this.sortAnnotationsBy = sortAnnotationsBy;
2688   }
2689
2690   public boolean isShowAutocalculatedAbove()
2691   {
2692     return showAutocalculatedAbove;
2693   }
2694
2695   public void setShowAutocalculatedAbove(boolean showAutocalculatedAbove)
2696   {
2697     this.showAutocalculatedAbove = showAutocalculatedAbove;
2698   }
2699
2700   @Override
2701   public boolean isScaleProteinAsCdna()
2702   {
2703     return viewStyle.isScaleProteinAsCdna();
2704   }
2705
2706   @Override
2707   public void setScaleProteinAsCdna(boolean b)
2708   {
2709     viewStyle.setScaleProteinAsCdna(b);
2710   }
2711
2712   @Override
2713   public boolean isProteinFontAsCdna()
2714   {
2715     return viewStyle.isProteinFontAsCdna();
2716   }
2717
2718   @Override
2719   public void setProteinFontAsCdna(boolean b)
2720   {
2721     viewStyle.setProteinFontAsCdna(b);
2722   }
2723
2724   @Override
2725   public void setShowComplementFeatures(boolean b)
2726   {
2727     viewStyle.setShowComplementFeatures(b);
2728   }
2729
2730   @Override
2731   public boolean isShowComplementFeatures()
2732   {
2733     return viewStyle.isShowComplementFeatures();
2734   }
2735
2736   @Override
2737   public void setShowComplementFeaturesOnTop(boolean b)
2738   {
2739     viewStyle.setShowComplementFeaturesOnTop(b);
2740   }
2741
2742   @Override
2743   public boolean isShowComplementFeaturesOnTop()
2744   {
2745     return viewStyle.isShowComplementFeaturesOnTop();
2746   }
2747
2748   /**
2749    * @return true if view should scroll to show the highlighted region of a
2750    *         sequence
2751    * @return
2752    */
2753   @Override
2754   public final boolean isFollowHighlight()
2755   {
2756     return followHighlight;
2757   }
2758
2759   @Override
2760   public final void setFollowHighlight(boolean b)
2761   {
2762     this.followHighlight = b;
2763   }
2764
2765   @Override
2766   public ViewportRanges getRanges()
2767   {
2768     return ranges;
2769   }
2770
2771   /**
2772    * Helper method to populate the SearchResults with the location in the
2773    * complementary alignment to scroll to, in order to match this one.
2774    *
2775    * @param sr
2776    *          the SearchResults to add to
2777    * @return the offset (below top of visible region) of the matched sequence
2778    */
2779   protected int findComplementScrollTarget(SearchResultsI sr)
2780   {
2781     final AlignViewportI complement = getCodingComplement();
2782     if (complement == null || !complement.isFollowHighlight())
2783     {
2784       return 0;
2785     }
2786     boolean iAmProtein = !getAlignment().isNucleotide();
2787     AlignmentI proteinAlignment = iAmProtein ? getAlignment()
2788             : complement.getAlignment();
2789     if (proteinAlignment == null)
2790     {
2791       return 0;
2792     }
2793     final List<AlignedCodonFrame> mappings = proteinAlignment
2794             .getCodonFrames();
2795
2796     /*
2797      * Heuristic: find the first mapped sequence (if any) with a non-gapped
2798      * residue in the middle column of the visible region. Scroll the
2799      * complementary alignment to line up the corresponding residue.
2800      */
2801     int seqOffset = 0;
2802     SequenceI sequence = null;
2803
2804     /*
2805      * locate 'middle' column (true middle if an odd number visible, left of
2806      * middle if an even number visible)
2807      */
2808     int middleColumn = ranges.getStartRes()
2809             + (ranges.getEndRes() - ranges.getStartRes()) / 2;
2810     final HiddenSequences hiddenSequences = getAlignment()
2811             .getHiddenSequences();
2812
2813     /*
2814      * searching to the bottom of the alignment gives smoother scrolling across
2815      * all gapped visible regions
2816      */
2817     int lastSeq = alignment.getHeight() - 1;
2818     List<AlignedCodonFrame> seqMappings = null;
2819     for (int seqNo = ranges
2820             .getStartSeq(); seqNo <= lastSeq; seqNo++, seqOffset++)
2821     {
2822       sequence = getAlignment().getSequenceAt(seqNo);
2823       if (hiddenSequences != null && hiddenSequences.isHidden(sequence))
2824       {
2825         continue;
2826       }
2827       if (Comparison.isGap(sequence.getCharAt(middleColumn)))
2828       {
2829         continue;
2830       }
2831       seqMappings = MappingUtils.findMappingsForSequenceAndOthers(sequence,
2832               mappings,
2833               getCodingComplement().getAlignment().getSequences());
2834       if (!seqMappings.isEmpty())
2835       {
2836         break;
2837       }
2838     }
2839
2840     if (sequence == null || seqMappings == null || seqMappings.isEmpty())
2841     {
2842       /*
2843        * No ungapped mapped sequence in middle column - do nothing
2844        */
2845       return 0;
2846     }
2847     MappingUtils.addSearchResults(sr, sequence,
2848             sequence.findPosition(middleColumn), seqMappings);
2849     return seqOffset;
2850   }
2851
2852   /**
2853    * synthesize a column selection if none exists so it covers the given
2854    * selection group. if wholewidth is false, no column selection is made if the
2855    * selection group covers the whole alignment width.
2856    *
2857    * @param sg
2858    * @param wholewidth
2859    */
2860   public void expandColSelection(SequenceGroup sg, boolean wholewidth)
2861   {
2862     int sgs, sge;
2863     if (sg != null && (sgs = sg.getStartRes()) >= 0
2864             && sg.getStartRes() <= (sge = sg.getEndRes())
2865             && !this.hasSelectedColumns())
2866     {
2867       if (!wholewidth && alignment.getWidth() == (1 + sge - sgs))
2868       {
2869         // do nothing
2870         return;
2871       }
2872       if (colSel == null)
2873       {
2874         colSel = new ColumnSelection();
2875       }
2876       for (int cspos = sg.getStartRes(); cspos <= sg.getEndRes(); cspos++)
2877       {
2878         colSel.addElement(cspos);
2879       }
2880     }
2881   }
2882
2883   /**
2884    * hold status of current selection group - defined on alignment or not.
2885    */
2886   private boolean selectionIsDefinedGroup = false;
2887
2888   @Override
2889   public boolean isSelectionDefinedGroup()
2890   {
2891     if (selectionGroup == null)
2892     {
2893       return false;
2894     }
2895     if (isSelectionGroupChanged(true))
2896     {
2897       selectionIsDefinedGroup = false;
2898       List<SequenceGroup> gps = alignment.getGroups();
2899       if (gps == null || gps.size() == 0)
2900       {
2901         selectionIsDefinedGroup = false;
2902       }
2903       else
2904       {
2905         selectionIsDefinedGroup = gps.contains(selectionGroup);
2906       }
2907     }
2908     return selectionGroup.isDefined() || selectionIsDefinedGroup;
2909   }
2910
2911   /**
2912    * null, or currently highlighted results on this view
2913    */
2914   private SearchResultsI searchResults = null;
2915
2916   protected TreeModel currentTree = null;
2917
2918   @Override
2919   public boolean hasSearchResults()
2920   {
2921     return searchResults != null;
2922   }
2923
2924   @Override
2925   public void setSearchResults(SearchResultsI results)
2926   {
2927     searchResults = results;
2928   }
2929
2930   @Override
2931   public SearchResultsI getSearchResults()
2932   {
2933     return searchResults;
2934   }
2935
2936   /**
2937    * get the consensus sequence as displayed under the PID consensus annotation
2938    * row.
2939    *
2940    * @return consensus sequence as a new sequence object
2941    */
2942   public SequenceI getConsensusSeq()
2943   {
2944     if (consensus == null)
2945     {
2946       updateConsensus(null);
2947     }
2948     if (consensus == null)
2949     {
2950       return null;
2951     }
2952     StringBuffer seqs = new StringBuffer();
2953     for (int i = 0; i < consensus.annotations.length; i++)
2954     {
2955       Annotation annotation = consensus.annotations[i];
2956       if (annotation != null)
2957       {
2958         String description = annotation.description;
2959         if (description != null && description.startsWith("["))
2960         {
2961           // consensus is a tie - just pick the first one
2962           seqs.append(description.charAt(1));
2963         }
2964         else
2965         {
2966           seqs.append(annotation.displayCharacter);
2967         }
2968       }
2969     }
2970
2971     SequenceI sq = new Sequence("Consensus", seqs.toString());
2972     sq.setDescription("Percentage Identity Consensus "
2973             + ((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
2974     return sq;
2975   }
2976
2977   @Override
2978   public void setCurrentTree(TreeModel tree)
2979   {
2980     currentTree = tree;
2981   }
2982
2983   @Override
2984   public TreeModel getCurrentTree()
2985   {
2986     return currentTree;
2987   }
2988
2989   @Override
2990   public AlignmentExportData getAlignExportData(AlignExportSettingsI options)
2991   {
2992     AlignmentI alignmentToExport = null;
2993     String[] omitHidden = null;
2994     alignmentToExport = null;
2995
2996     if (hasHiddenColumns() && !options.isExportHiddenColumns())
2997     {
2998       omitHidden = getViewAsString(false,
2999               options.isExportHiddenSequences());
3000     }
3001
3002     int[] alignmentStartEnd = new int[2];
3003     if (hasHiddenRows() && options.isExportHiddenSequences())
3004     {
3005       alignmentToExport = getAlignment().getHiddenSequences()
3006               .getFullAlignment();
3007     }
3008     else
3009     {
3010       alignmentToExport = getAlignment();
3011     }
3012     alignmentStartEnd = getAlignment().getHiddenColumns()
3013             .getVisibleStartAndEndIndex(alignmentToExport.getWidth());
3014     AlignmentExportData ed = new AlignmentExportData(alignmentToExport,
3015             omitHidden, alignmentStartEnd);
3016     return ed;
3017   }
3018
3019   /**
3020    * flag set to indicate if structure views might be out of sync with sequences
3021    * in the alignment
3022    */
3023
3024   private boolean needToUpdateStructureViews = false;
3025
3026   @Override
3027   public boolean isUpdateStructures()
3028   {
3029     return needToUpdateStructureViews;
3030   }
3031
3032   @Override
3033   public void setUpdateStructures(boolean update)
3034   {
3035     needToUpdateStructureViews = update;
3036   }
3037
3038   @Override
3039   public boolean needToUpdateStructureViews()
3040   {
3041     boolean update = needToUpdateStructureViews;
3042     needToUpdateStructureViews = false;
3043     return update;
3044   }
3045
3046   @Override
3047   public void addSequenceGroup(SequenceGroup sequenceGroup)
3048   {
3049     alignment.addGroup(sequenceGroup);
3050
3051     Color col = sequenceGroup.idColour;
3052     if (col != null)
3053     {
3054       col = col.brighter();
3055
3056       for (SequenceI sq : sequenceGroup.getSequences())
3057       {
3058         setSequenceColour(sq, col);
3059       }
3060     }
3061
3062     if (codingComplement != null)
3063     {
3064       SequenceGroup mappedGroup = MappingUtils
3065               .mapSequenceGroup(sequenceGroup, this, codingComplement);
3066       if (mappedGroup.getSequences().size() > 0)
3067       {
3068         codingComplement.getAlignment().addGroup(mappedGroup);
3069
3070         if (col != null)
3071         {
3072           for (SequenceI seq : mappedGroup.getSequences())
3073           {
3074             codingComplement.setSequenceColour(seq, col);
3075           }
3076         }
3077       }
3078       // propagate the structure view update flag according to our own setting
3079       codingComplement.setUpdateStructures(needToUpdateStructureViews);
3080     }
3081   }
3082
3083   @Override
3084   public Iterator<int[]> getViewAsVisibleContigs(boolean selectedRegionOnly)
3085   {
3086     int start = 0;
3087     int end = 0;
3088     if (selectedRegionOnly && selectionGroup != null)
3089     {
3090       start = selectionGroup.getStartRes();
3091       end = selectionGroup.getEndRes() + 1;
3092     }
3093     else
3094     {
3095       end = alignment.getWidth();
3096     }
3097     return (alignment.getHiddenColumns().getVisContigsIterator(start, end,
3098             false));
3099   }
3100 }