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 java.awt.Color;
  24 import java.util.ArrayDeque;
  25 import java.util.ArrayList;
  26 import java.util.BitSet;
  27 import java.util.Deque;
  28 import java.util.HashMap;
  29 import java.util.Hashtable;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33
  34 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
  35 import jalview.analysis.Conservation;
  36 import jalview.api.AlignCalcManagerI;
  37 import jalview.api.AlignViewportI;
  38 import jalview.api.AlignmentViewPanel;
  39 import jalview.api.FeaturesDisplayedI;
  40 import jalview.api.ViewStyleI;
  41 import jalview.commands.CommandI;
  42 import jalview.datamodel.AlignedCodonFrame;
  43 import jalview.datamodel.AlignmentAnnotation;
  44 import jalview.datamodel.AlignmentI;
  45 import jalview.datamodel.AlignmentView;
  46 import jalview.datamodel.Annotation;
  47 import jalview.datamodel.CigarArray;
  48 import jalview.datamodel.ColumnSelection;
  49 import jalview.datamodel.Sequence;
  50 import jalview.datamodel.SequenceCollectionI;
  51 import jalview.datamodel.SequenceGroup;
  52 import jalview.datamodel.SequenceI;
  53 import jalview.schemes.Blosum62ColourScheme;
  54 import jalview.schemes.ColourSchemeI;
  55 import jalview.schemes.PIDColourScheme;
  56 import jalview.schemes.ResidueProperties;
  57 import jalview.structure.CommandListener;
  58 import jalview.structure.StructureSelectionManager;
  59 import jalview.structure.VamsasSource;
  60 import jalview.viewmodel.styles.ViewStyle;
  61 import jalview.workers.AlignCalcManager;
  62 import jalview.workers.ComplementConsensusThread;
  63 import jalview.workers.ConsensusThread;
  64 import jalview.workers.StrucConsensusThread;
  65
  66 /**
  67  * base class holding visualization and analysis attributes and common logic for
  68  * an active alignment view displayed in the GUI
  69  *
  70  * @author jimp
  71  *
  72  */
  73 public abstract class AlignmentViewport implements AlignViewportI,
  74         ViewStyleI, CommandListener, VamsasSource
  75 {
  76   protected ViewStyleI viewStyle = new ViewStyle();
  77
  78   /**
  79    * A viewport that hosts the cDna view of this (protein), or vice versa (if
  80    * set).
  81    */
  82   AlignViewportI codingComplement = null;
  83
  84   FeaturesDisplayedI featuresDisplayed = null;
  85
  86   protected Deque<CommandI> historyList = new ArrayDeque<CommandI>();
  87
  88   protected Deque<CommandI> redoList = new ArrayDeque<CommandI>();
  89
  90   /**
  91    * @param name
  92    * @see jalview.api.ViewStyleI#setFontName(java.lang.String)
  93    */
  94   public void setFontName(String name)
  95   {
  96     viewStyle.setFontName(name);
  97   }
  98
  99   /**
 100    * @param style
 101    * @see jalview.api.ViewStyleI#setFontStyle(int)
 102    */
 103   public void setFontStyle(int style)
 104   {
 105     viewStyle.setFontStyle(style);
 106   }
 107
 108   /**
 109    * @param size
 110    * @see jalview.api.ViewStyleI#setFontSize(int)
 111    */
 112   public void setFontSize(int size)
 113   {
 114     viewStyle.setFontSize(size);
 115   }
 116
 117   /**
 118    * @return
 119    * @see jalview.api.ViewStyleI#getFontStyle()
 120    */
 121   public int getFontStyle()
 122   {
 123     return viewStyle.getFontStyle();
 124   }
 125
 126   /**
 127    * @return
 128    * @see jalview.api.ViewStyleI#getFontName()
 129    */
 130   public String getFontName()
 131   {
 132     return viewStyle.getFontName();
 133   }
 134
 135   /**
 136    * @return
 137    * @see jalview.api.ViewStyleI#getFontSize()
 138    */
 139   public int getFontSize()
 140   {
 141     return viewStyle.getFontSize();
 142   }
 143
 144   /**
 145    * @param upperCasebold
 146    * @see jalview.api.ViewStyleI#setUpperCasebold(boolean)
 147    */
 148   public void setUpperCasebold(boolean upperCasebold)
 149   {
 150     viewStyle.setUpperCasebold(upperCasebold);
 151   }
 152
 153   /**
 154    * @return
 155    * @see jalview.api.ViewStyleI#isUpperCasebold()
 156    */
 157   public boolean isUpperCasebold()
 158   {
 159     return viewStyle.isUpperCasebold();
 160   }
 161
 162   /**
 163    * @return
 164    * @see jalview.api.ViewStyleI#isSeqNameItalics()
 165    */
 166   public boolean isSeqNameItalics()
 167   {
 168     return viewStyle.isSeqNameItalics();
 169   }
 170
 171   /**
 172    * @param colourByReferenceSeq
 173    * @see jalview.api.ViewStyleI#setColourByReferenceSeq(boolean)
 174    */
 175   public void setColourByReferenceSeq(boolean colourByReferenceSeq)
 176   {
 177     viewStyle.setColourByReferenceSeq(colourByReferenceSeq);
 178   }
 179
 180   /**
 181    * @param b
 182    * @see jalview.api.ViewStyleI#setColourAppliesToAllGroups(boolean)
 183    */
 184   public void setColourAppliesToAllGroups(boolean b)
 185   {
 186     viewStyle.setColourAppliesToAllGroups(b);
 187   }
 188
 189   /**
 190    * @return
 191    * @see jalview.api.ViewStyleI#getColourAppliesToAllGroups()
 192    */
 193   public boolean getColourAppliesToAllGroups()
 194   {
 195     return viewStyle.getColourAppliesToAllGroups();
 196   }
 197
 198   /**
 199    * @return
 200    * @see jalview.api.ViewStyleI#getAbovePIDThreshold()
 201    */
 202   public boolean getAbovePIDThreshold()
 203   {
 204     return viewStyle.getAbovePIDThreshold();
 205   }
 206
 207   /**
 208    * @param inc
 209    * @see jalview.api.ViewStyleI#setIncrement(int)
 210    */
 211   public void setIncrement(int inc)
 212   {
 213     viewStyle.setIncrement(inc);
 214   }
 215
 216   /**
 217    * @return
 218    * @see jalview.api.ViewStyleI#getIncrement()
 219    */
 220   public int getIncrement()
 221   {
 222     return viewStyle.getIncrement();
 223   }
 224
 225   /**
 226    * @param b
 227    * @see jalview.api.ViewStyleI#setConservationSelected(boolean)
 228    */
 229   public void setConservationSelected(boolean b)
 230   {
 231     viewStyle.setConservationSelected(b);
 232   }
 233
 234   /**
 235    * @param show
 236    * @see jalview.api.ViewStyleI#setShowHiddenMarkers(boolean)
 237    */
 238   public void setShowHiddenMarkers(boolean show)
 239   {
 240     viewStyle.setShowHiddenMarkers(show);
 241   }
 242
 243   /**
 244    * @return
 245    * @see jalview.api.ViewStyleI#getShowHiddenMarkers()
 246    */
 247   public boolean getShowHiddenMarkers()
 248   {
 249     return viewStyle.getShowHiddenMarkers();
 250   }
 251
 252   /**
 253    * @param b
 254    * @see jalview.api.ViewStyleI#setScaleRightWrapped(boolean)
 255    */
 256   public void setScaleRightWrapped(boolean b)
 257   {
 258     viewStyle.setScaleRightWrapped(b);
 259   }
 260
 261   /**
 262    * @param b
 263    * @see jalview.api.ViewStyleI#setScaleLeftWrapped(boolean)
 264    */
 265   public void setScaleLeftWrapped(boolean b)
 266   {
 267     viewStyle.setScaleLeftWrapped(b);
 268   }
 269
 270   /**
 271    * @param b
 272    * @see jalview.api.ViewStyleI#setScaleAboveWrapped(boolean)
 273    */
 274   public void setScaleAboveWrapped(boolean b)
 275   {
 276     viewStyle.setScaleAboveWrapped(b);
 277   }
 278
 279   /**
 280    * @return
 281    * @see jalview.api.ViewStyleI#getScaleLeftWrapped()
 282    */
 283   public boolean getScaleLeftWrapped()
 284   {
 285     return viewStyle.getScaleLeftWrapped();
 286   }
 287
 288   /**
 289    * @return
 290    * @see jalview.api.ViewStyleI#getScaleAboveWrapped()
 291    */
 292   public boolean getScaleAboveWrapped()
 293   {
 294     return viewStyle.getScaleAboveWrapped();
 295   }
 296
 297   /**
 298    * @return
 299    * @see jalview.api.ViewStyleI#getScaleRightWrapped()
 300    */
 301   public boolean getScaleRightWrapped()
 302   {
 303     return viewStyle.getScaleRightWrapped();
 304   }
 305
 306   /**
 307    * @param b
 308    * @see jalview.api.ViewStyleI#setAbovePIDThreshold(boolean)
 309    */
 310   public void setAbovePIDThreshold(boolean b)
 311   {
 312     viewStyle.setAbovePIDThreshold(b);
 313   }
 314
 315   /**
 316    * @param thresh
 317    * @see jalview.api.ViewStyleI#setThreshold(int)
 318    */
 319   public void setThreshold(int thresh)
 320   {
 321     viewStyle.setThreshold(thresh);
 322   }
 323
 324   /**
 325    * @return
 326    * @see jalview.api.ViewStyleI#getThreshold()
 327    */
 328   public int getThreshold()
 329   {
 330     return viewStyle.getThreshold();
 331   }
 332
 333   /**
 334    * @return
 335    * @see jalview.api.ViewStyleI#getShowJVSuffix()
 336    */
 337   public boolean getShowJVSuffix()
 338   {
 339     return viewStyle.getShowJVSuffix();
 340   }
 341
 342   /**
 343    * @param b
 344    * @see jalview.api.ViewStyleI#setShowJVSuffix(boolean)
 345    */
 346   public void setShowJVSuffix(boolean b)
 347   {
 348     viewStyle.setShowJVSuffix(b);
 349   }
 350
 351   /**
 352    * @param state
 353    * @see jalview.api.ViewStyleI#setWrapAlignment(boolean)
 354    */
 355   public void setWrapAlignment(boolean state)
 356   {
 357     viewStyle.setWrapAlignment(state);
 358   }
 359
 360   /**
 361    * @param state
 362    * @see jalview.api.ViewStyleI#setShowText(boolean)
 363    */
 364   public void setShowText(boolean state)
 365   {
 366     viewStyle.setShowText(state);
 367   }
 368
 369   /**
 370    * @param state
 371    * @see jalview.api.ViewStyleI#setRenderGaps(boolean)
 372    */
 373   public void setRenderGaps(boolean state)
 374   {
 375     viewStyle.setRenderGaps(state);
 376   }
 377
 378   /**
 379    * @return
 380    * @see jalview.api.ViewStyleI#getColourText()
 381    */
 382   public boolean getColourText()
 383   {
 384     return viewStyle.getColourText();
 385   }
 386
 387   /**
 388    * @param state
 389    * @see jalview.api.ViewStyleI#setColourText(boolean)
 390    */
 391   public void setColourText(boolean state)
 392   {
 393     viewStyle.setColourText(state);
 394   }
 395
 396   /**
 397    * @return
 398    * @see jalview.api.ViewStyleI#getWrapAlignment()
 399    */
 400   public boolean getWrapAlignment()
 401   {
 402     return viewStyle.getWrapAlignment();
 403   }
 404
 405   /**
 406    * @return
 407    * @see jalview.api.ViewStyleI#getShowText()
 408    */
 409   public boolean getShowText()
 410   {
 411     return viewStyle.getShowText();
 412   }
 413
 414   /**
 415    * @return
 416    * @see jalview.api.ViewStyleI#getWrappedWidth()
 417    */
 418   public int getWrappedWidth()
 419   {
 420     return viewStyle.getWrappedWidth();
 421   }
 422
 423   /**
 424    * @param w
 425    * @see jalview.api.ViewStyleI#setWrappedWidth(int)
 426    */
 427   public void setWrappedWidth(int w)
 428   {
 429     viewStyle.setWrappedWidth(w);
 430   }
 431
 432   /**
 433    * @return
 434    * @see jalview.api.ViewStyleI#getCharHeight()
 435    */
 436   public int getCharHeight()
 437   {
 438     return viewStyle.getCharHeight();
 439   }
 440
 441   /**
 442    * @param h
 443    * @see jalview.api.ViewStyleI#setCharHeight(int)
 444    */
 445   public void setCharHeight(int h)
 446   {
 447     viewStyle.setCharHeight(h);
 448   }
 449
 450   /**
 451    * @return
 452    * @see jalview.api.ViewStyleI#getCharWidth()
 453    */
 454   public int getCharWidth()
 455   {
 456     return viewStyle.getCharWidth();
 457   }
 458
 459   /**
 460    * @param w
 461    * @see jalview.api.ViewStyleI#setCharWidth(int)
 462    */
 463   public void setCharWidth(int w)
 464   {
 465     viewStyle.setCharWidth(w);
 466   }
 467
 468   /**
 469    * @return
 470    * @see jalview.api.ViewStyleI#getShowBoxes()
 471    */
 472   public boolean getShowBoxes()
 473   {
 474     return viewStyle.getShowBoxes();
 475   }
 476
 477   /**
 478    * @return
 479    * @see jalview.api.ViewStyleI#getShowUnconserved()
 480    */
 481   public boolean getShowUnconserved()
 482   {
 483     return viewStyle.getShowUnconserved();
 484   }
 485
 486   /**
 487    * @param showunconserved
 488    * @see jalview.api.ViewStyleI#setShowUnconserved(boolean)
 489    */
 490   public void setShowUnconserved(boolean showunconserved)
 491   {
 492     viewStyle.setShowUnconserved(showunconserved);
 493   }
 494
 495   /**
 496    * @param default1
 497    * @see jalview.api.ViewStyleI#setSeqNameItalics(boolean)
 498    */
 499   public void setSeqNameItalics(boolean default1)
 500   {
 501     viewStyle.setSeqNameItalics(default1);
 502   }
 503
 504   /**
 505    * @param selected
 506    * @see jalview.api.ViewStyleI#setShowSeqFeaturesHeight(boolean)
 507    */
 508   public void setShowSeqFeaturesHeight(boolean selected)
 509   {
 510     viewStyle.setShowSeqFeaturesHeight(selected);
 511   }
 512
 513   /**
 514    * alignment displayed in the viewport. Please use get/setter
 515    */
 516   protected AlignmentI alignment;
 517
 518   @Override
 519   public AlignmentI getAlignment()
 520   {
 521     return alignment;
 522   }
 523
 524   @Override
 525   public char getGapCharacter()
 526   {
 527     return alignment.getGapCharacter();
 528   }
 529
 530   protected String sequenceSetID;
 531
 532   /**
 533    * probably unused indicator that view is of a dataset rather than an
 534    * alignment
 535    */
 536   protected boolean isDataset = false;
 537
 538   public void setDataset(boolean b)
 539   {
 540     isDataset = b;
 541   }
 542
 543   public boolean isDataset()
 544   {
 545     return isDataset;
 546   }
 547
 548
 549   private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
 550
 551   protected ColumnSelection colSel = new ColumnSelection();
 552
 553   public boolean autoCalculateConsensus = true;
 554
 555   protected boolean autoCalculateStrucConsensus = true;
 556
 557   protected boolean ignoreGapsInConsensusCalculation = false;
 558
 559   protected ColourSchemeI globalColourScheme = null;
 560
 561
 562   @Override
 563   public void setGlobalColourScheme(ColourSchemeI cs)
 564   {
 565     // TODO: logic refactored from AlignFrame changeColour -
 566     // autorecalc stuff should be changed to rely on the worker system
 567     // check to see if we should implement a changeColour(cs) method rather than
 568     // put th logic in here
 569     // - means that caller decides if they want to just modify state and defer
 570     // calculation till later or to do all calculations in thread.
 571     // via changecolour
 572     globalColourScheme = cs;
 573     boolean recalc = false;
 574     if (cs != null)
 575     {
 576       cs.setConservationApplied(recalc = getConservationSelected());
 577       if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
 578               || cs instanceof Blosum62ColourScheme)
 579       {
 580         recalc = true;
 581         cs.setThreshold(viewStyle.getThreshold(),
 582                 ignoreGapsInConsensusCalculation);
 583       }
 584       else
 585       {
 586         cs.setThreshold(0, ignoreGapsInConsensusCalculation);
 587       }
 588       if (recalc)
 589       {
 590         cs.setConsensus(hconsensus);
 591         cs.setConservation(hconservation);
 592       }
 593       cs.alignmentChanged(alignment, hiddenRepSequences);
 594     }
 595     if (getColourAppliesToAllGroups())
 596     {
 597       for (SequenceGroup sg : getAlignment().getGroups())
 598       {
 599         if (cs == null)
 600         {
 601           sg.cs = null;
 602           continue;
 603         }
 604         sg.cs = cs.applyTo(sg, getHiddenRepSequences());
 605         sg.setConsPercGaps(ConsPercGaps);
 606         if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
 607                 || cs instanceof Blosum62ColourScheme)
 608         {
 609           sg.cs.setThreshold(viewStyle.getThreshold(),
 610                   isIgnoreGapsConsensus());
 611           recalc = true;
 612         }
 613         else
 614         {
 615           sg.cs.setThreshold(0, isIgnoreGapsConsensus());
 616         }
 617
 618         if (getConservationSelected())
 619         {
 620           sg.cs.setConservationApplied(true);
 621           recalc = true;
 622         }
 623         else
 624         {
 625           sg.cs.setConservation(null);
 626           // sg.cs.setThreshold(0, getIgnoreGapsConsensus());
 627         }
 628         if (recalc)
 629         {
 630           sg.recalcConservation();
 631         }
 632         else
 633         {
 634           sg.cs.alignmentChanged(sg, hiddenRepSequences);
 635         }
 636       }
 637     }
 638
 639   }
 640
 641   @Override
 642   public ColourSchemeI getGlobalColourScheme()
 643   {
 644     return globalColourScheme;
 645   }
 646
 647   protected AlignmentAnnotation consensus;
 648
 649   protected AlignmentAnnotation complementConsensus;
 650
 651   protected AlignmentAnnotation strucConsensus;
 652
 653   protected AlignmentAnnotation conservation;
 654
 655   protected AlignmentAnnotation quality;
 656
 657   protected AlignmentAnnotation[] groupConsensus;
 658
 659   protected AlignmentAnnotation[] groupConservation;
 660
 661   /**
 662    * results of alignment consensus analysis for visible portion of view
 663    */
 664   protected Hashtable[] hconsensus = null;
 665
 666   /**
 667    * results of cDNA complement consensus visible portion of view
 668    */
 669   protected Hashtable[] hcomplementConsensus = null;
 670
 671   /**
 672    * results of secondary structure base pair consensus for visible portion of
 673    * view
 674    */
 675   protected Hashtable[] hStrucConsensus = null;
 676
 677   protected Conservation hconservation = null;
 678
 679   @Override
 680   public void setConservation(Conservation cons)
 681   {
 682     hconservation = cons;
 683   }
 684
 685   /**
 686    * percentage gaps allowed in a column before all amino acid properties should
 687    * be considered unconserved
 688    */
 689   int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
 690
 691   @Override
 692   public int getConsPercGaps()
 693   {
 694     return ConsPercGaps;
 695   }
 696
 697   @Override
 698   public void setSequenceConsensusHash(Hashtable[] hconsensus)
 699   {
 700     this.hconsensus = hconsensus;
 701   }
 702
 703   @Override
 704   public void setComplementConsensusHash(Hashtable[] hconsensus)
 705   {
 706     this.hcomplementConsensus = hconsensus;
 707   }
 708
 709   @Override
 710   public Hashtable[] getSequenceConsensusHash()
 711   {
 712     return hconsensus;
 713   }
 714
 715   @Override
 716   public Hashtable[] getComplementConsensusHash()
 717   {
 718     return hcomplementConsensus;
 719   }
 720
 721   @Override
 722   public Hashtable[] getRnaStructureConsensusHash()
 723   {
 724     return hStrucConsensus;
 725   }
 726
 727   @Override
 728   public void setRnaStructureConsensusHash(Hashtable[] hStrucConsensus)
 729   {
 730     this.hStrucConsensus = hStrucConsensus;
 731
 732   }
 733
 734   @Override
 735   public AlignmentAnnotation getAlignmentQualityAnnot()
 736   {
 737     return quality;
 738   }
 739
 740   @Override
 741   public AlignmentAnnotation getAlignmentConservationAnnotation()
 742   {
 743     return conservation;
 744   }
 745
 746   @Override
 747   public AlignmentAnnotation getAlignmentConsensusAnnotation()
 748   {
 749     return consensus;
 750   }
 751
 752   @Override
 753   public AlignmentAnnotation getComplementConsensusAnnotation()
 754   {
 755     return complementConsensus;
 756   }
 757
 758   @Override
 759   public AlignmentAnnotation getAlignmentStrucConsensusAnnotation()
 760   {
 761     return strucConsensus;
 762   }
 763
 764   protected AlignCalcManagerI calculator = new AlignCalcManager();
 765
 766   /**
 767    * trigger update of conservation annotation
 768    */
 769   public void updateConservation(final AlignmentViewPanel ap)
 770   {
 771     // see note in mantis : issue number 8585
 772     if (alignment.isNucleotide() || conservation == null
 773             || !autoCalculateConsensus)
 774     {
 775       return;
 776     }
 777     if (calculator
 778             .getRegisteredWorkersOfClass(jalview.workers.ConservationThread.class) == null)
 779     {
 780       calculator.registerWorker(new jalview.workers.ConservationThread(
 781               this, ap));
 782     }
 783   }
 784
 785   /**
 786    * trigger update of consensus annotation
 787    */
 788   public void updateConsensus(final AlignmentViewPanel ap)
 789   {
 790     // see note in mantis : issue number 8585
 791     if (consensus == null || !autoCalculateConsensus)
 792     {
 793       return;
 794     }
 795     if (calculator.getRegisteredWorkersOfClass(ConsensusThread.class) == null)
 796     {
 797       calculator.registerWorker(new ConsensusThread(this, ap));
 798     }
 799
 800     /*
 801      * A separate thread to compute cDNA consensus for a protein alignment
 802      */
 803     final AlignmentI al = this.getAlignment();
 804     if (!al.isNucleotide() && al.getCodonFrames() != null
 805             && !al.getCodonFrames().isEmpty())
 806     {
 807       if (calculator
 808               .getRegisteredWorkersOfClass(ComplementConsensusThread.class) == null)
 809       {
 810         calculator.registerWorker(new ComplementConsensusThread(this, ap));
 811       }
 812     }
 813   }
 814
 815   // --------START Structure Conservation
 816   public void updateStrucConsensus(final AlignmentViewPanel ap)
 817   {
 818     if (autoCalculateStrucConsensus && strucConsensus == null
 819             && alignment.isNucleotide() && alignment.hasRNAStructure())
 820     {
 821       // secondary structure has been added - so init the consensus line
 822       initRNAStructure();
 823     }
 824
 825     // see note in mantis : issue number 8585
 826     if (strucConsensus == null || !autoCalculateStrucConsensus)
 827     {
 828       return;
 829     }
 830     if (calculator.getRegisteredWorkersOfClass(StrucConsensusThread.class) == null)
 831     {
 832       calculator.registerWorker(new StrucConsensusThread(this, ap));
 833     }
 834   }
 835
 836   public boolean isCalcInProgress()
 837   {
 838     return calculator.isWorking();
 839   }
 840
 841   @Override
 842   public boolean isCalculationInProgress(
 843           AlignmentAnnotation alignmentAnnotation)
 844   {
 845     if (!alignmentAnnotation.autoCalculated)
 846     {
 847       return false;
 848     }
 849     if (calculator.workingInvolvedWith(alignmentAnnotation))
 850     {
 851       // System.err.println("grey out ("+alignmentAnnotation.label+")");
 852       return true;
 853     }
 854     return false;
 855   }
 856
 857   @Override
 858   public boolean isClosed()
 859   {
 860     // TODO: check that this isClosed is only true after panel is closed, not
 861     // before it is fully constructed.
 862     return alignment == null;
 863   }
 864
 865   @Override
 866   public AlignCalcManagerI getCalcManager()
 867   {
 868     return calculator;
 869   }
 870
 871   /**
 872    * should conservation rows be shown for groups
 873    */
 874   protected boolean showGroupConservation = false;
 875
 876   /**
 877    * should consensus rows be shown for groups
 878    */
 879   protected boolean showGroupConsensus = false;
 880
 881   /**
 882    * should consensus profile be rendered by default
 883    */
 884   protected boolean showSequenceLogo = false;
 885
 886   /**
 887    * should consensus profile be rendered normalised to row height
 888    */
 889   protected boolean normaliseSequenceLogo = false;
 890
 891   /**
 892    * should consensus histograms be rendered by default
 893    */
 894   protected boolean showConsensusHistogram = true;
 895
 896   /**
 897    * @return the showConsensusProfile
 898    */
 899   @Override
 900   public boolean isShowSequenceLogo()
 901   {
 902     return showSequenceLogo;
 903   }
 904
 905   /**
 906    * @param showSequenceLogo
 907    *          the new value
 908    */
 909   public void setShowSequenceLogo(boolean showSequenceLogo)
 910   {
 911     if (showSequenceLogo != this.showSequenceLogo)
 912     {
 913       // TODO: decouple settings setting from calculation when refactoring
 914       // annotation update method from alignframe to viewport
 915       this.showSequenceLogo = showSequenceLogo;
 916       calculator.updateAnnotationFor(ConsensusThread.class);
 917       calculator.updateAnnotationFor(ComplementConsensusThread.class);
 918       calculator.updateAnnotationFor(StrucConsensusThread.class);
 919     }
 920     this.showSequenceLogo = showSequenceLogo;
 921   }
 922
 923   /**
 924    * @param showConsensusHistogram
 925    *          the showConsensusHistogram to set
 926    */
 927   public void setShowConsensusHistogram(boolean showConsensusHistogram)
 928   {
 929     this.showConsensusHistogram = showConsensusHistogram;
 930   }
 931
 932   /**
 933    * @return the showGroupConservation
 934    */
 935   public boolean isShowGroupConservation()
 936   {
 937     return showGroupConservation;
 938   }
 939
 940   /**
 941    * @param showGroupConservation
 942    *          the showGroupConservation to set
 943    */
 944   public void setShowGroupConservation(boolean showGroupConservation)
 945   {
 946     this.showGroupConservation = showGroupConservation;
 947   }
 948
 949   /**
 950    * @return the showGroupConsensus
 951    */
 952   public boolean isShowGroupConsensus()
 953   {
 954     return showGroupConsensus;
 955   }
 956
 957   /**
 958    * @param showGroupConsensus
 959    *          the showGroupConsensus to set
 960    */
 961   public void setShowGroupConsensus(boolean showGroupConsensus)
 962   {
 963     this.showGroupConsensus = showGroupConsensus;
 964   }
 965
 966   /**
 967    *
 968    * @return flag to indicate if the consensus histogram should be rendered by
 969    *         default
 970    */
 971   @Override
 972   public boolean isShowConsensusHistogram()
 973   {
 974     return this.showConsensusHistogram;
 975   }
 976
 977   /**
 978    * when set, updateAlignment will always ensure sequences are of equal length
 979    */
 980   private boolean padGaps = false;
 981
 982   /**
 983    * when set, alignment should be reordered according to a newly opened tree
 984    */
 985   public boolean sortByTree = false;
 986
 987
 988   /**
 989    *
 990    *
 991    * @return null or the currently selected sequence region
 992    */
 993   @Override
 994   public SequenceGroup getSelectionGroup()
 995   {
 996     return selectionGroup;
 997   }
 998
 999   /**
1000    * Set the selection group for this window.
1001    *
1002    * @param sg
1003    *          - group holding references to sequences in this alignment view
1004    *
1005    */
1006   @Override
1007   public void setSelectionGroup(SequenceGroup sg)
1008   {
1009     selectionGroup = sg;
1010   }
1011
1012   public void setHiddenColumns(ColumnSelection colsel)
1013   {
1014     this.colSel = colsel;
1015   }
1016
1017   @Override
1018   public ColumnSelection getColumnSelection()
1019   {
1020     return colSel;
1021   }
1022
1023   @Override
1024   public void setColumnSelection(ColumnSelection colSel)
1025   {
1026     this.colSel = colSel;
1027     if (colSel != null)
1028     {
1029       updateHiddenColumns();
1030     }
1031   }
1032
1033   /**
1034    *
1035    * @return
1036    */
1037   @Override
1038   public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
1039   {
1040     return hiddenRepSequences;
1041   }
1042
1043   @Override
1044   public void setHiddenRepSequences(
1045           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
1046   {
1047     this.hiddenRepSequences = hiddenRepSequences;
1048   }
1049
1050   @Override
1051   public boolean hasHiddenColumns()
1052   {
1053     return colSel != null && colSel.hasHiddenColumns();
1054   }
1055
1056   public void updateHiddenColumns()
1057   {
1058     // this method doesn't really do anything now. But - it could, since a
1059     // column Selection could be in the process of modification
1060     // hasHiddenColumns = colSel.hasHiddenColumns();
1061   }
1062
1063   protected boolean hasHiddenRows = false;
1064
1065   @Override
1066   public boolean hasHiddenRows()
1067   {
1068     return hasHiddenRows;
1069   }
1070
1071   protected SequenceGroup selectionGroup;
1072
1073   public void setSequenceSetId(String newid)
1074   {
1075     if (sequenceSetID != null)
1076     {
1077       System.err
1078               .println("Warning - overwriting a sequenceSetId for a viewport!");
1079     }
1080     sequenceSetID = new String(newid);
1081   }
1082
1083   @Override
1084   public String getSequenceSetId()
1085   {
1086     if (sequenceSetID == null)
1087     {
1088       sequenceSetID = alignment.hashCode() + "";
1089     }
1090
1091     return sequenceSetID;
1092   }
1093
1094   /**
1095    * unique viewId for synchronizing state (e.g. with stored Jalview Project)
1096    *
1097    */
1098   protected String viewId = null;
1099
1100   @Override
1101   public String getViewId()
1102   {
1103     if (viewId == null)
1104     {
1105       viewId = this.getSequenceSetId() + "." + this.hashCode() + "";
1106     }
1107     return viewId;
1108   }
1109
1110   public void setIgnoreGapsConsensus(boolean b, AlignmentViewPanel ap)
1111   {
1112     ignoreGapsInConsensusCalculation = b;
1113     if (ap != null)
1114     {
1115       updateConsensus(ap);
1116       if (globalColourScheme != null)
1117       {
1118         globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
1119                 ignoreGapsInConsensusCalculation);
1120       }
1121     }
1122
1123   }
1124
1125   private long sgrouphash = -1, colselhash = -1;
1126
1127   /**
1128    * checks current SelectionGroup against record of last hash value, and
1129    * updates record.
1130    *
1131    * @param b
1132    *          update the record of last hash value
1133    *
1134    * @return true if SelectionGroup changed since last call (when b is true)
1135    */
1136   public boolean isSelectionGroupChanged(boolean b)
1137   {
1138     int hc = (selectionGroup == null || selectionGroup.getSize() == 0) ? -1
1139             : selectionGroup.hashCode();
1140     if (hc != -1 && hc != sgrouphash)
1141     {
1142       if (b)
1143       {
1144         sgrouphash = hc;
1145       }
1146       return true;
1147     }
1148     return false;
1149   }
1150
1151   /**
1152    * checks current colsel against record of last hash value, and optionally
1153    * updates record.
1154    *
1155    * @param b
1156    *          update the record of last hash value
1157    * @return true if colsel changed since last call (when b is true)
1158    */
1159   public boolean isColSelChanged(boolean b)
1160   {
1161     int hc = (colSel == null || colSel.size() == 0) ? -1 : colSel
1162             .hashCode();
1163     if (hc != -1 && hc != colselhash)
1164     {
1165       if (b)
1166       {
1167         colselhash = hc;
1168       }
1169       return true;
1170     }
1171     return false;
1172   }
1173
1174   @Override
1175   public boolean isIgnoreGapsConsensus()
1176   {
1177     return ignoreGapsInConsensusCalculation;
1178   }
1179
1180   // / property change stuff
1181
1182   // JBPNote Prolly only need this in the applet version.
1183   private final java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(
1184           this);
1185
1186   protected boolean showConservation = true;
1187
1188   protected boolean showQuality = true;
1189
1190   protected boolean showConsensus = true;
1191
1192   private Map<SequenceI, Color> sequenceColours = new HashMap<SequenceI, Color>();
1193
1194   protected SequenceAnnotationOrder sortAnnotationsBy = null;
1195
1196   protected boolean showAutocalculatedAbove;
1197
1198   /**
1199    * Property change listener for changes in alignment
1200    *
1201    * @param listener
1202    *          DOCUMENT ME!
1203    */
1204   public void addPropertyChangeListener(
1205           java.beans.PropertyChangeListener listener)
1206   {
1207     changeSupport.addPropertyChangeListener(listener);
1208   }
1209
1210   /**
1211    * DOCUMENT ME!
1212    *
1213    * @param listener
1214    *          DOCUMENT ME!
1215    */
1216   public void removePropertyChangeListener(
1217           java.beans.PropertyChangeListener listener)
1218   {
1219     changeSupport.removePropertyChangeListener(listener);
1220   }
1221
1222   /**
1223    * Property change listener for changes in alignment
1224    *
1225    * @param prop
1226    *          DOCUMENT ME!
1227    * @param oldvalue
1228    *          DOCUMENT ME!
1229    * @param newvalue
1230    *          DOCUMENT ME!
1231    */
1232   public void firePropertyChange(String prop, Object oldvalue,
1233           Object newvalue)
1234   {
1235     changeSupport.firePropertyChange(prop, oldvalue, newvalue);
1236   }
1237
1238   // common hide/show column stuff
1239
1240   public void hideSelectedColumns()
1241   {
1242     if (colSel.size() < 1)
1243     {
1244       return;
1245     }
1246
1247     colSel.hideSelectedColumns();
1248     setSelectionGroup(null);
1249
1250   }
1251
1252   public void hideColumns(int start, int end)
1253   {
1254     if (start == end)
1255     {
1256       colSel.hideColumns(start);
1257     }
1258     else
1259     {
1260       colSel.hideColumns(start, end);
1261     }
1262   }
1263
1264   public void showColumn(int col)
1265   {
1266     colSel.revealHiddenColumns(col);
1267
1268   }
1269
1270   public void showAllHiddenColumns()
1271   {
1272     colSel.revealAllHiddenColumns();
1273   }
1274
1275   // common hide/show seq stuff
1276   public void showAllHiddenSeqs()
1277   {
1278     if (alignment.getHiddenSequences().getSize() > 0)
1279     {
1280       if (selectionGroup == null)
1281       {
1282         selectionGroup = new SequenceGroup();
1283         selectionGroup.setEndRes(alignment.getWidth() - 1);
1284       }
1285       List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
1286               hiddenRepSequences);
1287       for (SequenceI seq : tmp)
1288       {
1289         selectionGroup.addSequence(seq, false);
1290         setSequenceAnnotationsVisible(seq, true);
1291       }
1292
1293       hasHiddenRows = false;
1294       hiddenRepSequences = null;
1295
1296       firePropertyChange("alignment", null, alignment.getSequences());
1297       // used to set hasHiddenRows/hiddenRepSequences here, after the property
1298       // changed event
1299       sendSelection();
1300     }
1301   }
1302
1303   public void showSequence(int index)
1304   {
1305     List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
1306             index,
1307             hiddenRepSequences);
1308     if (tmp.size() > 0)
1309     {
1310       if (selectionGroup == null)
1311       {
1312         selectionGroup = new SequenceGroup();
1313         selectionGroup.setEndRes(alignment.getWidth() - 1);
1314       }
1315
1316       for (SequenceI seq : tmp)
1317       {
1318         selectionGroup.addSequence(seq, false);
1319         setSequenceAnnotationsVisible(seq, true);
1320       }
1321       // JBPNote: refactor: only update flag if we modified visiblity (used to
1322       // do this regardless)
1323       if (alignment.getHiddenSequences().getSize() < 1)
1324       {
1325         hasHiddenRows = false;
1326       }
1327       firePropertyChange("alignment", null, alignment.getSequences());
1328       sendSelection();
1329     }
1330   }
1331
1332   public void hideAllSelectedSeqs()
1333   {
1334     if (selectionGroup == null || selectionGroup.getSize() < 1)
1335     {
1336       return;
1337     }
1338
1339     SequenceI[] seqs = selectionGroup.getSequencesInOrder(alignment);
1340
1341     hideSequence(seqs);
1342
1343     setSelectionGroup(null);
1344   }
1345
1346   public void hideSequence(SequenceI[] seq)
1347   {
1348     if (seq != null)
1349     {
1350       for (int i = 0; i < seq.length; i++)
1351       {
1352         alignment.getHiddenSequences().hideSequence(seq[i]);
1353         setSequenceAnnotationsVisible(seq[i], false);
1354       }
1355       hasHiddenRows = true;
1356       firePropertyChange("alignment", null, alignment.getSequences());
1357     }
1358   }
1359
1360   /**
1361    * Set visibility for any annotations for the given sequence.
1362    *
1363    * @param sequenceI
1364    */
1365   protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
1366           boolean visible)
1367   {
1368     for (AlignmentAnnotation ann : alignment.getAlignmentAnnotation())
1369     {
1370       if (ann.sequenceRef == sequenceI)
1371       {
1372         ann.visible = visible;
1373       }
1374     }
1375   }
1376
1377   public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
1378   {
1379     int sSize = sg.getSize();
1380     if (sSize < 2)
1381     {
1382       return;
1383     }
1384
1385     if (hiddenRepSequences == null)
1386     {
1387       hiddenRepSequences = new Hashtable();
1388     }
1389
1390     hiddenRepSequences.put(repSequence, sg);
1391
1392     // Hide all sequences except the repSequence
1393     SequenceI[] seqs = new SequenceI[sSize - 1];
1394     int index = 0;
1395     for (int i = 0; i < sSize; i++)
1396     {
1397       if (sg.getSequenceAt(i) != repSequence)
1398       {
1399         if (index == sSize - 1)
1400         {
1401           return;
1402         }
1403
1404         seqs[index++] = sg.getSequenceAt(i);
1405       }
1406     }
1407     sg.setSeqrep(repSequence); // note: not done in 2.7applet
1408     sg.setHidereps(true); // note: not done in 2.7applet
1409     hideSequence(seqs);
1410
1411   }
1412
1413   public boolean isHiddenRepSequence(SequenceI seq)
1414   {
1415     return alignment.getSeqrep()==seq || (hiddenRepSequences != null
1416             && hiddenRepSequences.containsKey(seq));
1417   }
1418
1419   public SequenceGroup getRepresentedSequences(SequenceI seq)
1420   {
1421     return (SequenceGroup) (hiddenRepSequences == null ? null
1422             : hiddenRepSequences.get(seq));
1423   }
1424
1425   @Override
1426   public int adjustForHiddenSeqs(int alignmentIndex)
1427   {
1428     return alignment.getHiddenSequences().adjustForHiddenSeqs(
1429             alignmentIndex);
1430   }
1431
1432   @Override
1433   public void invertColumnSelection()
1434   {
1435     colSel.invertColumnSelection(0, alignment.getWidth());
1436   }
1437
1438
1439   @Override
1440   public SequenceI[] getSelectionAsNewSequence()
1441   {
1442     SequenceI[] sequences;
1443     // JBPNote: Need to test jalviewLite.getSelectedSequencesAsAlignmentFrom -
1444     // this was the only caller in the applet for this method
1445     // JBPNote: in applet, this method returned references to the alignment
1446     // sequences, and it did not honour the presence/absence of annotation
1447     // attached to the alignment (probably!)
1448     if (selectionGroup == null || selectionGroup.getSize() == 0)
1449     {
1450       sequences = alignment.getSequencesArray();
1451       AlignmentAnnotation[] annots = alignment.getAlignmentAnnotation();
1452       for (int i = 0; i < sequences.length; i++)
1453       {
1454         // construct new sequence with subset of visible annotation
1455         sequences[i] = new Sequence(sequences[i], annots);
1456       }
1457     }
1458     else
1459     {
1460       sequences = selectionGroup.getSelectionAsNewSequences(alignment);
1461     }
1462
1463     return sequences;
1464   }
1465
1466
1467   @Override
1468   public SequenceI[] getSequenceSelection()
1469   {
1470     SequenceI[] sequences = null;
1471     if (selectionGroup != null)
1472     {
1473       sequences = selectionGroup.getSequencesInOrder(alignment);
1474     }
1475     if (sequences == null)
1476     {
1477       sequences = alignment.getSequencesArray();
1478     }
1479     return sequences;
1480   }
1481
1482
1483   @Override
1484   public CigarArray getViewAsCigars(
1485           boolean selectedRegionOnly)
1486   {
1487     return new CigarArray(alignment, colSel,
1488             (selectedRegionOnly ? selectionGroup : null));
1489   }
1490
1491
1492   @Override
1493   public jalview.datamodel.AlignmentView getAlignmentView(
1494           boolean selectedOnly)
1495   {
1496     return getAlignmentView(selectedOnly, false);
1497   }
1498
1499
1500   @Override
1501   public jalview.datamodel.AlignmentView getAlignmentView(
1502           boolean selectedOnly, boolean markGroups)
1503   {
1504     return new AlignmentView(alignment, colSel, selectionGroup,
1505             colSel != null && colSel.hasHiddenColumns(), selectedOnly,
1506             markGroups);
1507   }
1508
1509
1510   @Override
1511   public String[] getViewAsString(boolean selectedRegionOnly)
1512   {
1513     String[] selection = null;
1514     SequenceI[] seqs = null;
1515     int i, iSize;
1516     int start = 0, end = 0;
1517     if (selectedRegionOnly && selectionGroup != null)
1518     {
1519       iSize = selectionGroup.getSize();
1520       seqs = selectionGroup.getSequencesInOrder(alignment);
1521       start = selectionGroup.getStartRes();
1522       end = selectionGroup.getEndRes() + 1;
1523     }
1524     else
1525     {
1526       iSize = alignment.getHeight();
1527       seqs = alignment.getSequencesArray();
1528       end = alignment.getWidth();
1529     }
1530
1531     selection = new String[iSize];
1532     if (colSel != null && colSel.hasHiddenColumns())
1533     {
1534       selection = colSel.getVisibleSequenceStrings(start, end, seqs);
1535     }
1536     else
1537     {
1538       for (i = 0; i < iSize; i++)
1539       {
1540         selection[i] = seqs[i].getSequenceAsString(start, end);
1541       }
1542
1543     }
1544     return selection;
1545   }
1546
1547
1548   @Override
1549   public List<int[]> getVisibleRegionBoundaries(int min, int max)
1550   {
1551     ArrayList<int[]> regions = new ArrayList<int[]>();
1552     int start = min;
1553     int end = max;
1554
1555     do
1556     {
1557       if (colSel != null && colSel.hasHiddenColumns())
1558       {
1559         if (start == 0)
1560         {
1561           start = colSel.adjustForHiddenColumns(start);
1562         }
1563
1564         end = colSel.getHiddenBoundaryRight(start);
1565         if (start == end)
1566         {
1567           end = max;
1568         }
1569         if (end > max)
1570         {
1571           end = max;
1572         }
1573       }
1574
1575       regions.add(new int[]
1576       { start, end });
1577
1578       if (colSel != null && colSel.hasHiddenColumns())
1579       {
1580         start = colSel.adjustForHiddenColumns(end);
1581         start = colSel.getHiddenBoundaryLeft(start) + 1;
1582       }
1583     } while (end < max);
1584
1585     int[][] startEnd = new int[regions.size()][2];
1586
1587     return regions;
1588   }
1589
1590   @Override
1591   public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(boolean selectedOnly)
1592   {
1593     ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
1594     AlignmentAnnotation[] aa;
1595     if ((aa=alignment.getAlignmentAnnotation())!=null)
1596     {
1597       for (AlignmentAnnotation annot:aa)
1598       {
1599         AlignmentAnnotation clone = new AlignmentAnnotation(annot);
1600         if (selectedOnly && selectionGroup!=null)
1601         {
1602           colSel.makeVisibleAnnotation(selectionGroup.getStartRes(), selectionGroup.getEndRes(),clone);
1603         } else {
1604           colSel.makeVisibleAnnotation(clone);
1605         }
1606         ala.add(clone);
1607       }
1608     }
1609     return ala;
1610   }
1611
1612
1613   @Override
1614   public boolean isPadGaps()
1615   {
1616     return padGaps;
1617   }
1618
1619
1620   @Override
1621   public void setPadGaps(boolean padGaps)
1622   {
1623     this.padGaps = padGaps;
1624   }
1625
1626   /**
1627    * apply any post-edit constraints and trigger any calculations needed after
1628    * an edit has been performed on the alignment
1629    *
1630    * @param ap
1631    */
1632   @Override
1633   public void alignmentChanged(AlignmentViewPanel ap)
1634   {
1635     if (isPadGaps())
1636     {
1637       alignment.padGaps();
1638     }
1639     if (autoCalculateConsensus)
1640     {
1641       updateConsensus(ap);
1642     }
1643     if (hconsensus != null && autoCalculateConsensus)
1644     {
1645       updateConservation(ap);
1646     }
1647     if (autoCalculateStrucConsensus)
1648     {
1649       updateStrucConsensus(ap);
1650     }
1651
1652     // Reset endRes of groups if beyond alignment width
1653     int alWidth = alignment.getWidth();
1654     List<SequenceGroup> groups = alignment.getGroups();
1655     if (groups != null)
1656     {
1657       for (SequenceGroup sg : groups)
1658       {
1659         if (sg.getEndRes() > alWidth)
1660         {
1661           sg.setEndRes(alWidth - 1);
1662         }
1663       }
1664     }
1665
1666     if (selectionGroup != null && selectionGroup.getEndRes() > alWidth)
1667     {
1668       selectionGroup.setEndRes(alWidth - 1);
1669     }
1670
1671     resetAllColourSchemes();
1672     calculator.restartWorkers();
1673     // alignment.adjustSequenceAnnotations();
1674   }
1675
1676   /**
1677    * reset scope and do calculations for all applied colourschemes on alignment
1678    */
1679   void resetAllColourSchemes()
1680   {
1681     ColourSchemeI cs = globalColourScheme;
1682     if (cs != null)
1683     {
1684       cs.alignmentChanged(alignment, hiddenRepSequences);
1685
1686       cs.setConsensus(hconsensus);
1687       if (cs.conservationApplied())
1688       {
1689         cs.setConservation(Conservation.calculateConservation("All",
1690                 ResidueProperties.propHash, 3, alignment.getSequences(), 0,
1691                 alignment.getWidth(), false, getConsPercGaps(), false));
1692       }
1693     }
1694
1695     for (SequenceGroup sg : alignment.getGroups())
1696     {
1697       if (sg.cs != null)
1698       {
1699         sg.cs.alignmentChanged(sg, hiddenRepSequences);
1700       }
1701       sg.recalcConservation();
1702     }
1703   }
1704
1705   protected void initAutoAnnotation()
1706   {
1707     // TODO: add menu option action that nulls or creates consensus object
1708     // depending on if the user wants to see the annotation or not in a
1709     // specific alignment
1710
1711     if (hconsensus == null && !isDataset)
1712     {
1713       if (!alignment.isNucleotide())
1714       {
1715         initConservation();
1716         initQuality();
1717       }
1718       else
1719       {
1720         initRNAStructure();
1721       }
1722       consensus = new AlignmentAnnotation("Consensus", "PID",
1723               new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
1724       initConsensus(consensus);
1725
1726       initComplementConsensus();
1727     }
1728   }
1729
1730   /**
1731    * If this is a protein alignment and there are mappings to cDNA, add the cDNA
1732    * consensus annotation.
1733    */
1734   public void initComplementConsensus()
1735   {
1736     if (!alignment.isNucleotide())
1737     {
1738       final Set<AlignedCodonFrame> codonMappings = alignment
1739               .getCodonFrames();
1740       if (codonMappings != null && !codonMappings.isEmpty())
1741       {
1742         complementConsensus = new AlignmentAnnotation("cDNA Consensus",
1743                 "PID for cDNA", new Annotation[1], 0f, 100f,
1744                 AlignmentAnnotation.BAR_GRAPH);
1745         initConsensus(complementConsensus);
1746       }
1747     }
1748   }
1749
1750   private void initConsensus(AlignmentAnnotation aa)
1751   {
1752     aa.hasText = true;
1753     aa.autoCalculated = true;
1754
1755     if (showConsensus)
1756     {
1757       alignment.addAnnotation(aa);
1758     }
1759   }
1760
1761   private void initConservation()
1762   {
1763     if (showConservation)
1764     {
1765       if (conservation == null)
1766       {
1767         conservation = new AlignmentAnnotation("Conservation",
1768                 "Conservation of total alignment less than "
1769                         + getConsPercGaps() + "% gaps", new Annotation[1],
1770                 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
1771         conservation.hasText = true;
1772         conservation.autoCalculated = true;
1773         alignment.addAnnotation(conservation);
1774       }
1775     }
1776   }
1777
1778   private void initQuality()
1779   {
1780     if (showQuality)
1781     {
1782       if (quality == null)
1783       {
1784         quality = new AlignmentAnnotation("Quality",
1785                 "Alignment Quality based on Blosum62 scores",
1786                 new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
1787         quality.hasText = true;
1788         quality.autoCalculated = true;
1789         alignment.addAnnotation(quality);
1790       }
1791     }
1792   }
1793
1794   private void initRNAStructure()
1795   {
1796     if (alignment.hasRNAStructure() && strucConsensus == null)
1797     {
1798       strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID",
1799               new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
1800       strucConsensus.hasText = true;
1801       strucConsensus.autoCalculated = true;
1802
1803       if (showConsensus)
1804       {
1805         alignment.addAnnotation(strucConsensus);
1806       }
1807     }
1808   }
1809
1810   /*
1811    * (non-Javadoc)
1812    *
1813    * @see jalview.api.AlignViewportI#calcPanelHeight()
1814    */
1815   @Override
1816   public int calcPanelHeight()
1817   {
1818     // setHeight of panels
1819     AlignmentAnnotation[] anns = getAlignment().getAlignmentAnnotation();
1820     int height = 0;
1821     int charHeight = getCharHeight();
1822     if (anns != null)
1823     {
1824       BitSet graphgrp = new BitSet();
1825       for (AlignmentAnnotation aa : anns)
1826       {
1827         if (aa == null)
1828         {
1829           System.err.println("Null annotation row: ignoring.");
1830           continue;
1831         }
1832         if (!aa.visible)
1833         {
1834           continue;
1835         }
1836         if (aa.graphGroup > -1)
1837         {
1838           if (graphgrp.get(aa.graphGroup))
1839           {
1840             continue;
1841           }
1842           else
1843           {
1844             graphgrp.set(aa.graphGroup);
1845           }
1846         }
1847         aa.height = 0;
1848
1849         if (aa.hasText)
1850         {
1851           aa.height += charHeight;
1852         }
1853
1854         if (aa.hasIcons)
1855         {
1856           aa.height += 16;
1857         }
1858
1859         if (aa.graph > 0)
1860         {
1861           aa.height += aa.graphHeight;
1862         }
1863
1864         if (aa.height == 0)
1865         {
1866           aa.height = 20;
1867         }
1868
1869         height += aa.height;
1870       }
1871     }
1872     if (height == 0)
1873     {
1874       // set minimum
1875       height = 20;
1876     }
1877     return height;
1878   }
1879
1880   @Override
1881   public void updateGroupAnnotationSettings(boolean applyGlobalSettings,
1882           boolean preserveNewGroupSettings)
1883   {
1884     boolean updateCalcs = false;
1885     boolean conv = isShowGroupConservation();
1886     boolean cons = isShowGroupConsensus();
1887     boolean showprf = isShowSequenceLogo();
1888     boolean showConsHist = isShowConsensusHistogram();
1889     boolean normLogo = isNormaliseSequenceLogo();
1890
1891     /**
1892      * TODO reorder the annotation rows according to group/sequence ordering on
1893      * alignment
1894      */
1895     boolean sortg = true;
1896
1897     // remove old automatic annotation
1898     // add any new annotation
1899
1900     // intersect alignment annotation with alignment groups
1901
1902     AlignmentAnnotation[] aan = alignment.getAlignmentAnnotation();
1903     List<SequenceGroup> oldrfs = new ArrayList<SequenceGroup>();
1904     if (aan != null)
1905     {
1906       for (int an = 0; an < aan.length; an++)
1907       {
1908         if (aan[an].autoCalculated && aan[an].groupRef != null)
1909         {
1910           oldrfs.add(aan[an].groupRef);
1911           alignment.deleteAnnotation(aan[an], false);
1912         }
1913       }
1914     }
1915     if (alignment.getGroups() != null)
1916     {
1917       for (SequenceGroup sg : alignment.getGroups())
1918       {
1919         updateCalcs = false;
1920         if (applyGlobalSettings
1921                 || (!preserveNewGroupSettings && !oldrfs.contains(sg)))
1922         {
1923           // set defaults for this group's conservation/consensus
1924           sg.setshowSequenceLogo(showprf);
1925           sg.setShowConsensusHistogram(showConsHist);
1926           sg.setNormaliseSequenceLogo(normLogo);
1927         }
1928         if (conv)
1929         {
1930           updateCalcs = true;
1931           alignment.addAnnotation(sg.getConservationRow(), 0);
1932         }
1933         if (cons)
1934         {
1935           updateCalcs = true;
1936           alignment.addAnnotation(sg.getConsensus(), 0);
1937         }
1938         // refresh the annotation rows
1939         if (updateCalcs)
1940         {
1941           sg.recalcConservation();
1942         }
1943       }
1944     }
1945     oldrfs.clear();
1946   }
1947   @Override
1948   public boolean isDisplayReferenceSeq()
1949   {
1950     return alignment.hasSeqrep() && viewStyle.isDisplayReferenceSeq();
1951   }
1952
1953   @Override
1954   public void setDisplayReferenceSeq(boolean displayReferenceSeq)
1955   {
1956     viewStyle.setDisplayReferenceSeq(displayReferenceSeq);
1957   }
1958
1959   @Override
1960   public boolean isColourByReferenceSeq()
1961   {
1962     return alignment.hasSeqrep() && viewStyle.isColourByReferenceSeq();
1963   }
1964
1965   @Override
1966   public Color getSequenceColour(SequenceI seq)
1967   {
1968     Color sqc = sequenceColours.get(seq);
1969     return (sqc == null ? Color.white : sqc);
1970   }
1971
1972   @Override
1973   public void setSequenceColour(SequenceI seq, Color col)
1974   {
1975     if (col == null)
1976     {
1977       sequenceColours.remove(seq);
1978     }
1979     else
1980     {
1981       sequenceColours.put(seq, col);
1982     }
1983   }
1984
1985   @Override
1986   public void updateSequenceIdColours()
1987   {
1988     for (SequenceGroup sg : alignment.getGroups())
1989     {
1990       if (sg.idColour != null)
1991       {
1992         for (SequenceI s : sg.getSequences(getHiddenRepSequences()))
1993         {
1994           sequenceColours.put(s, sg.idColour);
1995         }
1996       }
1997     }
1998   }
1999
2000   @Override
2001   public void clearSequenceColours()
2002   {
2003     sequenceColours.clear();
2004   };
2005
2006   @Override
2007   public AlignViewportI getCodingComplement()
2008   {
2009     return this.codingComplement;
2010   }
2011
2012   /**
2013    * Set this as the (cDna/protein) complement of the given viewport. Also
2014    * ensures the reverse relationship is set on the given viewport.
2015    */
2016   @Override
2017   public void setCodingComplement(AlignViewportI av)
2018   {
2019     if (this == av)
2020     {
2021       System.err.println("Ignoring recursive setCodingComplement request");
2022     }
2023     else
2024     {
2025       this.codingComplement = av;
2026       // avoid infinite recursion!
2027       if (av.getCodingComplement() != this)
2028       {
2029         av.setCodingComplement(this);
2030       }
2031     }
2032   }
2033
2034   @Override
2035   public boolean isNucleotide()
2036   {
2037     return getAlignment() == null ? false : getAlignment().isNucleotide();
2038   }
2039
2040   @Override
2041   public FeaturesDisplayedI getFeaturesDisplayed()
2042   {
2043     return featuresDisplayed;
2044   }
2045
2046   @Override
2047   public void setFeaturesDisplayed(FeaturesDisplayedI featuresDisplayedI)
2048   {
2049     featuresDisplayed = featuresDisplayedI;
2050   }
2051
2052   @Override
2053   public boolean areFeaturesDisplayed()
2054   {
2055     return featuresDisplayed != null && featuresDisplayed.getRegisterdFeaturesCount()>0;
2056   }
2057
2058   /**
2059    * set the flag
2060    *
2061    * @param b
2062    *          features are displayed if true
2063    */
2064   @Override
2065   public void setShowSequenceFeatures(boolean b)
2066   {
2067     viewStyle.setShowSequenceFeatures(b);
2068   }
2069   @Override
2070   public boolean isShowSequenceFeatures()
2071   {
2072     return viewStyle.isShowSequenceFeatures();
2073   }
2074
2075   @Override
2076   public void setShowSequenceFeaturesHeight(boolean selected)
2077   {
2078     viewStyle.setShowSeqFeaturesHeight(selected);
2079   }
2080
2081   @Override
2082   public boolean isShowSequenceFeaturesHeight()
2083   {
2084     return viewStyle.isShowSequenceFeaturesHeight();
2085   }
2086
2087
2088
2089   @Override
2090   public void setShowAnnotation(boolean b)
2091   {
2092     viewStyle.setShowAnnotation(b);
2093   }
2094
2095   @Override
2096   public boolean isShowAnnotation()
2097   {
2098     return viewStyle.isShowAnnotation();
2099   }
2100
2101   @Override
2102   public boolean isRightAlignIds()
2103   {
2104     return viewStyle.isRightAlignIds();
2105   }
2106
2107   @Override
2108   public void setRightAlignIds(boolean rightAlignIds)
2109   {
2110     viewStyle.setRightAlignIds(rightAlignIds);
2111   }
2112
2113   @Override
2114   public boolean getConservationSelected()
2115   {
2116     return viewStyle.getConservationSelected();
2117   }
2118
2119   @Override
2120   public void setShowBoxes(boolean state)
2121   {
2122     viewStyle.setShowBoxes(state);
2123   }
2124
2125   /**
2126    * @return
2127    * @see jalview.api.ViewStyleI#getTextColour()
2128    */
2129   public Color getTextColour()
2130   {
2131     return viewStyle.getTextColour();
2132   }
2133
2134   /**
2135    * @return
2136    * @see jalview.api.ViewStyleI#getTextColour2()
2137    */
2138   public Color getTextColour2()
2139   {
2140     return viewStyle.getTextColour2();
2141   }
2142
2143   /**
2144    * @return
2145    * @see jalview.api.ViewStyleI#getThresholdTextColour()
2146    */
2147   public int getThresholdTextColour()
2148   {
2149     return viewStyle.getThresholdTextColour();
2150   }
2151
2152   /**
2153    * @return
2154    * @see jalview.api.ViewStyleI#isConservationColourSelected()
2155    */
2156   public boolean isConservationColourSelected()
2157   {
2158     return viewStyle.isConservationColourSelected();
2159   }
2160
2161   /**
2162    * @return
2163    * @see jalview.api.ViewStyleI#isRenderGaps()
2164    */
2165   public boolean isRenderGaps()
2166   {
2167     return viewStyle.isRenderGaps();
2168   }
2169
2170   /**
2171    * @return
2172    * @see jalview.api.ViewStyleI#isShowColourText()
2173    */
2174   public boolean isShowColourText()
2175   {
2176     return viewStyle.isShowColourText();
2177   }
2178   /**
2179    * @return
2180    * @see jalview.api.ViewStyleI#isShowSeqFeaturesHeight()
2181    */
2182   public boolean isShowSeqFeaturesHeight()
2183   {
2184     return viewStyle.isShowSeqFeaturesHeight();
2185   }
2186
2187   /**
2188    * @param conservationColourSelected
2189    * @see jalview.api.ViewStyleI#setConservationColourSelected(boolean)
2190    */
2191   public void setConservationColourSelected(
2192           boolean conservationColourSelected)
2193   {
2194     viewStyle.setConservationColourSelected(conservationColourSelected);
2195   }
2196
2197   /**
2198    * @param showColourText
2199    * @see jalview.api.ViewStyleI#setShowColourText(boolean)
2200    */
2201   public void setShowColourText(boolean showColourText)
2202   {
2203     viewStyle.setShowColourText(showColourText);
2204   }
2205
2206   /**
2207    * @param textColour
2208    * @see jalview.api.ViewStyleI#setTextColour(java.awt.Color)
2209    */
2210   public void setTextColour(Color textColour)
2211   {
2212     viewStyle.setTextColour(textColour);
2213   }
2214
2215   /**
2216    * @param thresholdTextColour
2217    * @see jalview.api.ViewStyleI#setThresholdTextColour(int)
2218    */
2219   public void setThresholdTextColour(int thresholdTextColour)
2220   {
2221     viewStyle.setThresholdTextColour(thresholdTextColour);
2222   }
2223
2224   /**
2225    * @param textColour2
2226    * @see jalview.api.ViewStyleI#setTextColour2(java.awt.Color)
2227    */
2228   public void setTextColour2(Color textColour2)
2229   {
2230     viewStyle.setTextColour2(textColour2);
2231   }
2232
2233   @Override
2234   public ViewStyleI getViewStyle()
2235   {
2236     return new ViewStyle(viewStyle);
2237   }
2238
2239   @Override
2240   public void setViewStyle(ViewStyleI settingsForView)
2241   {
2242     viewStyle = new ViewStyle(settingsForView);
2243   }
2244
2245   @Override
2246   public boolean sameStyle(ViewStyleI them)
2247   {
2248     return viewStyle.sameStyle(them);
2249   }
2250
2251   /**
2252    * @return
2253    * @see jalview.api.ViewStyleI#getIdWidth()
2254    */
2255   public int getIdWidth()
2256   {
2257     return viewStyle.getIdWidth();
2258   }
2259
2260   /**
2261    * @param i
2262    * @see jalview.api.ViewStyleI#setIdWidth(int)
2263    */
2264   public void setIdWidth(int i)
2265   {
2266     viewStyle.setIdWidth(i);
2267   }
2268
2269   /**
2270    * @return
2271    * @see jalview.api.ViewStyleI#isCentreColumnLabels()
2272    */
2273   public boolean isCentreColumnLabels()
2274   {
2275     return viewStyle.isCentreColumnLabels();
2276   }
2277
2278   /**
2279    * @param centreColumnLabels
2280    * @see jalview.api.ViewStyleI#setCentreColumnLabels(boolean)
2281    */
2282   public void setCentreColumnLabels(boolean centreColumnLabels)
2283   {
2284     viewStyle.setCentreColumnLabels(centreColumnLabels);
2285   }
2286
2287   /**
2288    * @param showdbrefs
2289    * @see jalview.api.ViewStyleI#setShowDBRefs(boolean)
2290    */
2291   public void setShowDBRefs(boolean showdbrefs)
2292   {
2293     viewStyle.setShowDBRefs(showdbrefs);
2294   }
2295
2296   /**
2297    * @return
2298    * @see jalview.api.ViewStyleI#isShowDBRefs()
2299    */
2300   public boolean isShowDBRefs()
2301   {
2302     return viewStyle.isShowDBRefs();
2303   }
2304
2305   /**
2306    * @return
2307    * @see jalview.api.ViewStyleI#isShowNPFeats()
2308    */
2309   public boolean isShowNPFeats()
2310   {
2311     return viewStyle.isShowNPFeats();
2312   }
2313
2314   /**
2315    * @param shownpfeats
2316    * @see jalview.api.ViewStyleI#setShowNPFeats(boolean)
2317    */
2318   public void setShowNPFeats(boolean shownpfeats)
2319   {
2320     viewStyle.setShowNPFeats(shownpfeats);
2321   }
2322
2323   public abstract StructureSelectionManager getStructureSelectionManager();
2324
2325   /**
2326    * Add one command to the command history list.
2327    *
2328    * @param command
2329    */
2330   public void addToHistoryList(CommandI command)
2331   {
2332     if (this.historyList != null)
2333     {
2334       this.historyList.push(command);
2335       broadcastCommand(command, false);
2336     }
2337   }
2338
2339   protected void broadcastCommand(CommandI command, boolean undo)
2340   {
2341     getStructureSelectionManager().commandPerformed(command, undo, getVamsasSource());
2342   }
2343
2344   /**
2345    * Add one command to the command redo list.
2346    *
2347    * @param command
2348    */
2349   public void addToRedoList(CommandI command)
2350   {
2351     if (this.redoList != null)
2352     {
2353       this.redoList.push(command);
2354     }
2355     broadcastCommand(command, true);
2356   }
2357
2358   /**
2359    * Clear the command redo list.
2360    */
2361   public void clearRedoList()
2362   {
2363     if (this.redoList != null)
2364     {
2365       this.redoList.clear();
2366     }
2367   }
2368
2369   public void setHistoryList(Deque<CommandI> list)
2370   {
2371     this.historyList = list;
2372   }
2373
2374   public Deque<CommandI> getHistoryList()
2375   {
2376     return this.historyList;
2377   }
2378
2379   public void setRedoList(Deque<CommandI> list)
2380   {
2381     this.redoList = list;
2382   }
2383
2384   public Deque<CommandI> getRedoList()
2385   {
2386     return this.redoList;
2387   }
2388
2389   @Override
2390   public VamsasSource getVamsasSource()
2391   {
2392     return this;
2393   }
2394
2395   public SequenceAnnotationOrder getSortAnnotationsBy()
2396   {
2397     return sortAnnotationsBy;
2398   }
2399
2400   public void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
2401   {
2402     this.sortAnnotationsBy = sortAnnotationsBy;
2403   }
2404
2405   public boolean isShowAutocalculatedAbove()
2406   {
2407     return showAutocalculatedAbove;
2408   }
2409
2410   public void setShowAutocalculatedAbove(boolean showAutocalculatedAbove)
2411   {
2412     this.showAutocalculatedAbove = showAutocalculatedAbove;
2413   }
2414
2415   @Override
2416   public boolean isScaleProteinAsCdna()
2417   {
2418     return viewStyle.isScaleProteinAsCdna();
2419   }
2420
2421   @Override
2422   public void setScaleProteinAsCdna(boolean b)
2423   {
2424     viewStyle.setScaleProteinAsCdna(b);
2425   }
2426 }