src/jalview/gui/AlignViewport.java

   1  /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.gui;\r
  20 \r
  21 import jalview.analysis.*;\r
  22 \r
  23 import jalview.bin.*;\r
  24 \r
  25 import jalview.datamodel.*;\r
  26 \r
  27 import jalview.schemes.*;\r
  28 \r
  29 import java.awt.*;\r
  30 \r
  31 import java.util.*;\r
  32 \r
  33 \r
  34 /**\r
  35  * DOCUMENT ME!\r
  36  *\r
  37  * @author $author$\r
  38  * @version $Revision$\r
  39  */\r
  40 public class AlignViewport\r
  41 {\r
  42     int startRes;\r
  43     int endRes;\r
  44     int startSeq;\r
  45     int endSeq;\r
  46     boolean showJVSuffix = true;\r
  47     boolean showText = true;\r
  48     boolean showColourText = false;\r
  49     boolean showBoxes = true;\r
  50     boolean wrapAlignment = false;\r
  51     boolean renderGaps = true;\r
  52     boolean showSequenceFeatures = false;\r
  53     boolean showAnnotation = true;\r
  54     boolean showConservation = true;\r
  55     boolean showQuality = true;\r
  56     boolean showIdentity = true;\r
  57     boolean colourAppliesToAllGroups = true;\r
  58     ColourSchemeI globalColourScheme = null;\r
  59     boolean conservationColourSelected = false;\r
  60     boolean abovePIDThreshold = false;\r
  61     SequenceGroup selectionGroup;\r
  62     int charHeight;\r
  63     int charWidth;\r
  64     boolean validCharWidth;\r
  65     int wrappedWidth;\r
  66     Font font;\r
  67     AlignmentI alignment;\r
  68     ColumnSelection colSel = new ColumnSelection();\r
  69     int threshold;\r
  70     int increment;\r
  71     NJTree currentTree = null;\r
  72     boolean scaleAboveWrapped = false;\r
  73     boolean scaleLeftWrapped = true;\r
  74     boolean scaleRightWrapped = true;\r
  75     boolean hasHiddenColumns = false;\r
  76     boolean hasHiddenRows = false;\r
  77     boolean showHiddenMarkers = true;\r
  78 \r
  79     boolean cursorMode = false;\r
  80 \r
  81     // The following vector holds the features which are\r
  82     // currently visible, in the correct order or rendering\r
  83     Hashtable featuresDisplayed = null;\r
  84 \r
  85 \r
  86     /** DOCUMENT ME!! */\r
  87     public Vector vconsensus;\r
  88     AlignmentAnnotation consensus;\r
  89     AlignmentAnnotation conservation;\r
  90     AlignmentAnnotation quality;\r
  91     boolean autoCalculateConsensus = true;\r
  92 \r
  93     /** DOCUMENT ME!! */\r
  94     public int ConsPercGaps = 25; // JBPNote : This should be a scalable property!\r
  95 \r
  96     // JBPNote Prolly only need this in the applet version.\r
  97     private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(this);\r
  98 \r
  99     boolean ignoreGapsInConsensusCalculation = false;\r
 100 \r
 101     boolean isDataset = false;\r
 102 \r
 103     boolean antiAlias = false;\r
 104 \r
 105     boolean padGaps = false;\r
 106 \r
 107 \r
 108     public AlignViewport(AlignmentI al, boolean dataset)\r
 109     {\r
 110       isDataset = dataset;\r
 111       setAlignment(al);\r
 112       init();\r
 113     }\r
 114     /**\r
 115      * Creates a new AlignViewport object.\r
 116      *\r
 117      * @param al DOCUMENT ME!\r
 118      */\r
 119     public AlignViewport(AlignmentI al)\r
 120     {\r
 121         setAlignment(al);\r
 122         init();\r
 123     }\r
 124 \r
 125     void init()\r
 126     {\r
 127         this.startRes = 0;\r
 128         this.endRes = alignment.getWidth() - 1;\r
 129         this.startSeq = 0;\r
 130         this.endSeq = alignment.getHeight() - 1;\r
 131 \r
 132       antiAlias = Cache.getDefault("ANTI_ALIAS", false);\r
 133 \r
 134       showJVSuffix = Cache.getDefault("SHOW_JVSUFFIX", true);\r
 135       showAnnotation = Cache.getDefault("SHOW_ANNOTATIONS", true);\r
 136       showConservation = Cache.getDefault("SHOW_CONSERVATION", true);\r
 137 \r
 138       showQuality = Cache.getDefault("SHOW_QUALITY", true);\r
 139       showIdentity = Cache.getDefault("SHOW_IDENTITY", true);\r
 140 \r
 141       autoCalculateConsensus = Cache.getDefault("AUTO_CALC_CONSENSUS", true);\r
 142 \r
 143       padGaps = Cache.getDefault("PAD_GAPS", false);\r
 144 \r
 145        String fontName = Cache.getDefault("FONT_NAME", "SansSerif");\r
 146        String fontStyle = Cache.getDefault("FONT_STYLE", Font.PLAIN + "") ;\r
 147        String fontSize = Cache.getDefault("FONT_SIZE", "10");\r
 148 \r
 149        int style = 0;\r
 150 \r
 151        if (fontStyle.equals("bold"))\r
 152        {\r
 153          style = 1;\r
 154        }\r
 155        else if (fontStyle.equals("italic"))\r
 156        {\r
 157          style = 2;\r
 158        }\r
 159 \r
 160        setFont(new Font(fontName, style, Integer.parseInt(fontSize)));\r
 161 \r
 162 \r
 163        alignment.setGapCharacter( Cache.getDefault("GAP_SYMBOL", "-").charAt(0) );\r
 164 \r
 165 \r
 166         // We must set conservation and consensus before setting colour,\r
 167         // as Blosum and Clustal require this to be done\r
 168         if(vconsensus==null && !isDataset)\r
 169         {\r
 170           updateConservation();\r
 171           updateConsensus();\r
 172         }\r
 173 \r
 174         if (jalview.bin.Cache.getProperty("DEFAULT_COLOUR") != null)\r
 175         {\r
 176           globalColourScheme = ColourSchemeProperty.getColour(alignment,\r
 177               jalview.bin.Cache.getProperty("DEFAULT_COLOUR"));\r
 178 \r
 179             if (globalColourScheme instanceof UserColourScheme)\r
 180             {\r
 181                 globalColourScheme = UserDefinedColours.loadDefaultColours();\r
 182                 ((UserColourScheme)globalColourScheme).setThreshold(0, getIgnoreGapsConsensus());\r
 183             }\r
 184 \r
 185             if (globalColourScheme != null)\r
 186             {\r
 187                 globalColourScheme.setConsensus(vconsensus);\r
 188             }\r
 189         }\r
 190     }\r
 191 \r
 192 \r
 193 \r
 194     /**\r
 195      * DOCUMENT ME!\r
 196      *\r
 197      * @param b DOCUMENT ME!\r
 198      */\r
 199     public void setShowSequenceFeatures(boolean b)\r
 200     {\r
 201         showSequenceFeatures = b;\r
 202     }\r
 203 \r
 204     public boolean getShowSequenceFeatures()\r
 205     {\r
 206       return showSequenceFeatures;\r
 207     }\r
 208 \r
 209     /**\r
 210      * DOCUMENT ME!\r
 211      */\r
 212     public void updateConservation()\r
 213     {\r
 214       if(alignment.isNucleotide())\r
 215           return;\r
 216 \r
 217       try{\r
 218         Conservation cons = new jalview.analysis.Conservation("All",\r
 219             jalview.schemes.ResidueProperties.propHash, 3,\r
 220             alignment.getSequences(), 0, alignment.getWidth() - 1);\r
 221         cons.calculate();\r
 222         cons.verdict(false, ConsPercGaps);\r
 223         cons.findQuality();\r
 224 \r
 225         int alWidth = alignment.getWidth();\r
 226         Annotation[] annotations = new Annotation[alWidth];\r
 227         Annotation[] qannotations = new Annotation[alWidth];\r
 228         String sequence = cons.getConsSequence().getSequence();\r
 229         float minR;\r
 230         float minG;\r
 231         float minB;\r
 232         float maxR;\r
 233         float maxG;\r
 234         float maxB;\r
 235         minR = 0.3f;\r
 236         minG = 0.0f;\r
 237         minB = 0f;\r
 238         maxR = 1.0f - minR;\r
 239         maxG = 0.9f - minG;\r
 240         maxB = 0f - minB; // scalable range for colouring both Conservation and Quality\r
 241 \r
 242         float min = 0f;\r
 243         float max = 11f;\r
 244         float qmin = cons.qualityRange[0].floatValue();\r
 245         float qmax = cons.qualityRange[1].floatValue();\r
 246 \r
 247         for (int i = 0; i < alWidth; i++)\r
 248         {\r
 249           float value = 0;\r
 250 \r
 251           try\r
 252           {\r
 253             value = Integer.parseInt(sequence.charAt(i) + "");\r
 254           }\r
 255           catch (Exception ex)\r
 256           {\r
 257             if (sequence.charAt(i) == '*')\r
 258             {\r
 259               value = 11;\r
 260             }\r
 261 \r
 262             if (sequence.charAt(i) == '+')\r
 263             {\r
 264               value = 10;\r
 265             }\r
 266           }\r
 267 \r
 268           float vprop = value - min;\r
 269           vprop /= max;\r
 270           annotations[i] = new Annotation(sequence.charAt(i) + "",\r
 271                                           String.valueOf(value), ' ', value,\r
 272                                           new Color(minR + (maxR * vprop),\r
 273               minG + (maxG * vprop),\r
 274               minB + (maxB * vprop)));\r
 275 \r
 276           // Quality calc\r
 277           value = ( (Double) cons.quality.get(i)).floatValue();\r
 278           vprop = value - qmin;\r
 279           vprop /= qmax;\r
 280           qannotations[i] = new Annotation(" ", String.valueOf(value), ' ',\r
 281                                            value,\r
 282                                            new Color(minR + (maxR * vprop),\r
 283               minG + (maxG * vprop),\r
 284               minB + (maxB * vprop)));\r
 285         }\r
 286 \r
 287         if (conservation == null)\r
 288         {\r
 289           conservation = new AlignmentAnnotation("Conservation",\r
 290                                                  "Conservation of total alignment less than " +\r
 291                                                  ConsPercGaps + "% gaps",\r
 292                                                  annotations, 0f, // cons.qualityRange[0].floatValue(),\r
 293                                                  11f, // cons.qualityRange[1].floatValue()\r
 294                                                  AlignmentAnnotation.BAR_GRAPH);\r
 295 \r
 296           if (showConservation)\r
 297           {\r
 298             alignment.addAnnotation(conservation);\r
 299           }\r
 300 \r
 301           quality = new AlignmentAnnotation("Quality",\r
 302                                             "Alignment Quality based on Blosum62 scores",\r
 303                                             qannotations,\r
 304                                             cons.qualityRange[0].floatValue(),\r
 305                                             cons.qualityRange[1].floatValue(),\r
 306                                             AlignmentAnnotation.BAR_GRAPH);\r
 307 \r
 308           if (showQuality)\r
 309           {\r
 310             alignment.addAnnotation(quality);\r
 311           }\r
 312         }\r
 313         else\r
 314         {\r
 315           conservation.annotations = annotations;\r
 316           quality.annotations = qannotations;\r
 317           quality.graphMax = cons.qualityRange[1].floatValue();\r
 318         }\r
 319       }\r
 320       catch (OutOfMemoryError error)\r
 321       {\r
 322         javax.swing.SwingUtilities.invokeLater(new Runnable()\r
 323         {\r
 324           public void run()\r
 325           {\r
 326             javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,\r
 327                 "Out of memory calculating conservation!!"\r
 328                 +\r
 329                 "\nSee help files for increasing Java Virtual Machine memory."\r
 330                 , "Out of memory",\r
 331                 javax.swing.JOptionPane.WARNING_MESSAGE);\r
 332           }\r
 333         });\r
 334 \r
 335         System.out.println("Conservation calculation: " + error);\r
 336         System.gc();\r
 337 \r
 338       }\r
 339     }\r
 340 \r
 341     /**\r
 342      * DOCUMENT ME!\r
 343      */\r
 344     public void updateConsensus()\r
 345     {\r
 346       try{\r
 347         Annotation[] annotations = new Annotation[alignment.getWidth()];\r
 348 \r
 349         // this routine prevents vconsensus becoming a new object each time\r
 350         // consenus is calculated. Important for speed of Blosum62\r
 351         // and PID colouring of alignment\r
 352         if (vconsensus == null)\r
 353         {\r
 354           vconsensus = alignment.getAAFrequency();\r
 355         }\r
 356         else\r
 357         {\r
 358           Vector temp = alignment.getAAFrequency();\r
 359           vconsensus.clear();\r
 360 \r
 361           Enumeration e = temp.elements();\r
 362 \r
 363           while (e.hasMoreElements())\r
 364           {\r
 365             vconsensus.add(e.nextElement());\r
 366           }\r
 367         }\r
 368 \r
 369         Hashtable hash = null;\r
 370 \r
 371         for (int i = 0; i < alignment.getWidth(); i++)\r
 372         {\r
 373           hash = (Hashtable) vconsensus.elementAt(i);\r
 374 \r
 375           float value = 0;\r
 376           if (ignoreGapsInConsensusCalculation)\r
 377             value = ( (Float) hash.get("pid_nogaps")).floatValue();\r
 378           else\r
 379             value = ( (Float) hash.get("pid_gaps")).floatValue();\r
 380 \r
 381           String maxRes = hash.get("maxResidue").toString();\r
 382           String mouseOver = hash.get("maxResidue") + " ";\r
 383 \r
 384           if (maxRes.length() > 1)\r
 385           {\r
 386             mouseOver = "[" + maxRes + "] ";\r
 387             maxRes = "+";\r
 388           }\r
 389 \r
 390           mouseOver += ( (int) value + "%");\r
 391           annotations[i] = new Annotation(maxRes, mouseOver, ' ', value);\r
 392         }\r
 393 \r
 394         if (consensus == null)\r
 395         {\r
 396           consensus = new AlignmentAnnotation("Consensus", "PID",\r
 397                                               annotations, 0f, 100f,AlignmentAnnotation.BAR_GRAPH);\r
 398 \r
 399           if (showIdentity)\r
 400           {\r
 401             alignment.addAnnotation(consensus);\r
 402           }\r
 403         }\r
 404         else\r
 405         {\r
 406           consensus.annotations = annotations;\r
 407         }\r
 408 \r
 409         if (globalColourScheme != null)\r
 410           globalColourScheme.setConsensus(vconsensus);\r
 411 \r
 412       }catch(OutOfMemoryError error)\r
 413       {\r
 414         javax.swing.SwingUtilities.invokeLater(new Runnable()\r
 415         {\r
 416           public void run()\r
 417           {\r
 418             javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,\r
 419                 "Out of memory calc45ulating consensus!!"\r
 420                 +\r
 421                 "\nSee help files for increasing Java Virtual Machine memory."\r
 422                 , "Out of memory",\r
 423                 javax.swing.JOptionPane.WARNING_MESSAGE);\r
 424           }\r
 425         });\r
 426 \r
 427 \r
 428         System.out.println("Consensus calculation: " + error);\r
 429         System.gc();\r
 430       }\r
 431 \r
 432     }\r
 433 \r
 434     /**\r
 435      * DOCUMENT ME!\r
 436      *\r
 437      * @return DOCUMENT ME!\r
 438      */\r
 439     public SequenceGroup getSelectionGroup()\r
 440     {\r
 441         return selectionGroup;\r
 442     }\r
 443 \r
 444     /**\r
 445      * DOCUMENT ME!\r
 446      *\r
 447      * @param sg DOCUMENT ME!\r
 448      */\r
 449     public void setSelectionGroup(SequenceGroup sg)\r
 450     {\r
 451         selectionGroup = sg;\r
 452     }\r
 453 \r
 454     /**\r
 455      * DOCUMENT ME!\r
 456      *\r
 457      * @return DOCUMENT ME!\r
 458      */\r
 459     public boolean getConservationSelected()\r
 460     {\r
 461         return conservationColourSelected;\r
 462     }\r
 463 \r
 464     /**\r
 465      * DOCUMENT ME!\r
 466      *\r
 467      * @param b DOCUMENT ME!\r
 468      */\r
 469     public void setConservationSelected(boolean b)\r
 470     {\r
 471         conservationColourSelected = b;\r
 472     }\r
 473 \r
 474     /**\r
 475      * DOCUMENT ME!\r
 476      *\r
 477      * @return DOCUMENT ME!\r
 478      */\r
 479     public boolean getAbovePIDThreshold()\r
 480     {\r
 481         return abovePIDThreshold;\r
 482     }\r
 483 \r
 484     /**\r
 485      * DOCUMENT ME!\r
 486      *\r
 487      * @param b DOCUMENT ME!\r
 488      */\r
 489     public void setAbovePIDThreshold(boolean b)\r
 490     {\r
 491         abovePIDThreshold = b;\r
 492     }\r
 493 \r
 494     /**\r
 495      * DOCUMENT ME!\r
 496      *\r
 497      * @return DOCUMENT ME!\r
 498      */\r
 499     public int getStartRes()\r
 500     {\r
 501         return startRes;\r
 502     }\r
 503 \r
 504     /**\r
 505      * DOCUMENT ME!\r
 506      *\r
 507      * @return DOCUMENT ME!\r
 508      */\r
 509     public int getEndRes()\r
 510     {\r
 511         return endRes;\r
 512     }\r
 513 \r
 514     /**\r
 515      * DOCUMENT ME!\r
 516      *\r
 517      * @return DOCUMENT ME!\r
 518      */\r
 519     public int getStartSeq()\r
 520     {\r
 521         return startSeq;\r
 522     }\r
 523 \r
 524     /**\r
 525      * DOCUMENT ME!\r
 526      *\r
 527      * @param cs DOCUMENT ME!\r
 528      */\r
 529     public void setGlobalColourScheme(ColourSchemeI cs)\r
 530     {\r
 531         globalColourScheme = cs;\r
 532     }\r
 533 \r
 534     /**\r
 535      * DOCUMENT ME!\r
 536      *\r
 537      * @return DOCUMENT ME!\r
 538      */\r
 539     public ColourSchemeI getGlobalColourScheme()\r
 540     {\r
 541         return globalColourScheme;\r
 542     }\r
 543 \r
 544     /**\r
 545      * DOCUMENT ME!\r
 546      *\r
 547      * @param res DOCUMENT ME!\r
 548      */\r
 549     public void setStartRes(int res)\r
 550     {\r
 551         this.startRes = res;\r
 552     }\r
 553 \r
 554     /**\r
 555      * DOCUMENT ME!\r
 556      *\r
 557      * @param seq DOCUMENT ME!\r
 558      */\r
 559     public void setStartSeq(int seq)\r
 560     {\r
 561         this.startSeq = seq;\r
 562     }\r
 563 \r
 564     /**\r
 565      * DOCUMENT ME!\r
 566      *\r
 567      * @param res DOCUMENT ME!\r
 568      */\r
 569     public void setEndRes(int res)\r
 570     {\r
 571         if (res > (alignment.getWidth() - 1))\r
 572         {\r
 573             // log.System.out.println(" Corrected res from " + res + " to maximum " + (alignment.getWidth()-1));\r
 574             res = alignment.getWidth() - 1;\r
 575         }\r
 576 \r
 577         if (res < 0)\r
 578         {\r
 579             res = 0;\r
 580         }\r
 581 \r
 582         this.endRes = res;\r
 583     }\r
 584 \r
 585     /**\r
 586      * DOCUMENT ME!\r
 587      *\r
 588      * @param seq DOCUMENT ME!\r
 589      */\r
 590     public void setEndSeq(int seq)\r
 591     {\r
 592         if (seq > alignment.getHeight())\r
 593         {\r
 594             seq = alignment.getHeight();\r
 595         }\r
 596 \r
 597         if (seq < 0)\r
 598         {\r
 599             seq = 0;\r
 600         }\r
 601 \r
 602         this.endSeq = seq;\r
 603     }\r
 604 \r
 605     /**\r
 606      * DOCUMENT ME!\r
 607      *\r
 608      * @return DOCUMENT ME!\r
 609      */\r
 610     public int getEndSeq()\r
 611     {\r
 612         return endSeq;\r
 613     }\r
 614 \r
 615     /**\r
 616      * DOCUMENT ME!\r
 617      *\r
 618      * @param f DOCUMENT ME!\r
 619      */\r
 620     public void setFont(Font f)\r
 621     {\r
 622         font = f;\r
 623 \r
 624         Container c = new Container();\r
 625 \r
 626         java.awt.FontMetrics fm = c.getFontMetrics(font);\r
 627         setCharHeight(fm.getHeight());\r
 628         setCharWidth(fm.charWidth('M'));\r
 629         validCharWidth = true;\r
 630     }\r
 631 \r
 632     /**\r
 633      * DOCUMENT ME!\r
 634      *\r
 635      * @return DOCUMENT ME!\r
 636      */\r
 637     public Font getFont()\r
 638     {\r
 639         return font;\r
 640     }\r
 641 \r
 642     /**\r
 643      * DOCUMENT ME!\r
 644      *\r
 645      * @param w DOCUMENT ME!\r
 646      */\r
 647     public void setCharWidth(int w)\r
 648     {\r
 649         this.charWidth = w;\r
 650     }\r
 651 \r
 652     /**\r
 653      * DOCUMENT ME!\r
 654      *\r
 655      * @return DOCUMENT ME!\r
 656      */\r
 657     public int getCharWidth()\r
 658     {\r
 659         return charWidth;\r
 660     }\r
 661 \r
 662     /**\r
 663      * DOCUMENT ME!\r
 664      *\r
 665      * @param h DOCUMENT ME!\r
 666      */\r
 667     public void setCharHeight(int h)\r
 668     {\r
 669         this.charHeight = h;\r
 670     }\r
 671 \r
 672     /**\r
 673      * DOCUMENT ME!\r
 674      *\r
 675      * @return DOCUMENT ME!\r
 676      */\r
 677     public int getCharHeight()\r
 678     {\r
 679         return charHeight;\r
 680     }\r
 681 \r
 682     /**\r
 683      * DOCUMENT ME!\r
 684      *\r
 685      * @param w DOCUMENT ME!\r
 686      */\r
 687     public void setWrappedWidth(int w)\r
 688     {\r
 689         this.wrappedWidth = w;\r
 690     }\r
 691 \r
 692     /**\r
 693      * DOCUMENT ME!\r
 694      *\r
 695      * @return DOCUMENT ME!\r
 696      */\r
 697     public int getWrappedWidth()\r
 698     {\r
 699         return wrappedWidth;\r
 700     }\r
 701 \r
 702 \r
 703     /**\r
 704      * DOCUMENT ME!\r
 705      *\r
 706      * @return DOCUMENT ME!\r
 707      */\r
 708     public AlignmentI getAlignment()\r
 709     {\r
 710         return alignment;\r
 711     }\r
 712 \r
 713     /**\r
 714      * DOCUMENT ME!\r
 715      *\r
 716      * @param align DOCUMENT ME!\r
 717      */\r
 718     public void setAlignment(AlignmentI align)\r
 719     {\r
 720         this.alignment = align;\r
 721     }\r
 722 \r
 723     /**\r
 724      * DOCUMENT ME!\r
 725      *\r
 726      * @param state DOCUMENT ME!\r
 727      */\r
 728     public void setWrapAlignment(boolean state)\r
 729     {\r
 730         wrapAlignment = state;\r
 731     }\r
 732 \r
 733     /**\r
 734      * DOCUMENT ME!\r
 735      *\r
 736      * @param state DOCUMENT ME!\r
 737      */\r
 738     public void setShowText(boolean state)\r
 739     {\r
 740         showText = state;\r
 741     }\r
 742 \r
 743     /**\r
 744      * DOCUMENT ME!\r
 745      *\r
 746      * @param state DOCUMENT ME!\r
 747      */\r
 748     public void setRenderGaps(boolean state)\r
 749     {\r
 750         renderGaps = state;\r
 751     }\r
 752 \r
 753     /**\r
 754      * DOCUMENT ME!\r
 755      *\r
 756      * @return DOCUMENT ME!\r
 757      */\r
 758     public boolean getColourText()\r
 759     {\r
 760         return showColourText;\r
 761     }\r
 762 \r
 763     /**\r
 764      * DOCUMENT ME!\r
 765      *\r
 766      * @param state DOCUMENT ME!\r
 767      */\r
 768     public void setColourText(boolean state)\r
 769     {\r
 770         showColourText = state;\r
 771     }\r
 772 \r
 773     /**\r
 774      * DOCUMENT ME!\r
 775      *\r
 776      * @param state DOCUMENT ME!\r
 777      */\r
 778     public void setShowBoxes(boolean state)\r
 779     {\r
 780         showBoxes = state;\r
 781     }\r
 782 \r
 783     /**\r
 784      * DOCUMENT ME!\r
 785      *\r
 786      * @return DOCUMENT ME!\r
 787      */\r
 788     public boolean getWrapAlignment()\r
 789     {\r
 790         return wrapAlignment;\r
 791     }\r
 792 \r
 793     /**\r
 794      * DOCUMENT ME!\r
 795      *\r
 796      * @return DOCUMENT ME!\r
 797      */\r
 798     public boolean getShowText()\r
 799     {\r
 800         return showText;\r
 801     }\r
 802 \r
 803     /**\r
 804      * DOCUMENT ME!\r
 805      *\r
 806      * @return DOCUMENT ME!\r
 807      */\r
 808     public boolean getShowBoxes()\r
 809     {\r
 810         return showBoxes;\r
 811     }\r
 812 \r
 813     /**\r
 814      * DOCUMENT ME!\r
 815      *\r
 816      * @return DOCUMENT ME!\r
 817      */\r
 818     public char getGapCharacter()\r
 819     {\r
 820         return getAlignment().getGapCharacter();\r
 821     }\r
 822 \r
 823     /**\r
 824      * DOCUMENT ME!\r
 825      *\r
 826      * @param gap DOCUMENT ME!\r
 827      */\r
 828     public void setGapCharacter(char gap)\r
 829     {\r
 830         if (getAlignment() != null)\r
 831         {\r
 832             getAlignment().setGapCharacter(gap);\r
 833         }\r
 834     }\r
 835 \r
 836     /**\r
 837      * DOCUMENT ME!\r
 838      *\r
 839      * @param thresh DOCUMENT ME!\r
 840      */\r
 841     public void setThreshold(int thresh)\r
 842     {\r
 843         threshold = thresh;\r
 844     }\r
 845 \r
 846     /**\r
 847      * DOCUMENT ME!\r
 848      *\r
 849      * @return DOCUMENT ME!\r
 850      */\r
 851     public int getThreshold()\r
 852     {\r
 853         return threshold;\r
 854     }\r
 855 \r
 856     /**\r
 857      * DOCUMENT ME!\r
 858      *\r
 859      * @param inc DOCUMENT ME!\r
 860      */\r
 861     public void setIncrement(int inc)\r
 862     {\r
 863         increment = inc;\r
 864     }\r
 865 \r
 866     /**\r
 867      * DOCUMENT ME!\r
 868      *\r
 869      * @return DOCUMENT ME!\r
 870      */\r
 871     public int getIncrement()\r
 872     {\r
 873         return increment;\r
 874     }\r
 875 \r
 876 \r
 877     /**\r
 878      * DOCUMENT ME!\r
 879      *\r
 880      * @return DOCUMENT ME!\r
 881      */\r
 882     public ColumnSelection getColumnSelection()\r
 883     {\r
 884         return colSel;\r
 885     }\r
 886 \r
 887 \r
 888     /**\r
 889      * DOCUMENT ME!\r
 890      *\r
 891      * @param tree DOCUMENT ME!\r
 892      */\r
 893     public void setCurrentTree(NJTree tree)\r
 894     {\r
 895         currentTree = tree;\r
 896     }\r
 897 \r
 898     /**\r
 899      * DOCUMENT ME!\r
 900      *\r
 901      * @return DOCUMENT ME!\r
 902      */\r
 903     public NJTree getCurrentTree()\r
 904     {\r
 905         return currentTree;\r
 906     }\r
 907 \r
 908     /**\r
 909      * DOCUMENT ME!\r
 910      *\r
 911      * @param b DOCUMENT ME!\r
 912      */\r
 913     public void setColourAppliesToAllGroups(boolean b)\r
 914     {\r
 915         colourAppliesToAllGroups = b;\r
 916     }\r
 917 \r
 918     /**\r
 919      * DOCUMENT ME!\r
 920      *\r
 921      * @return DOCUMENT ME!\r
 922      */\r
 923     public boolean getColourAppliesToAllGroups()\r
 924     {\r
 925         return colourAppliesToAllGroups;\r
 926     }\r
 927 \r
 928     /**\r
 929      * DOCUMENT ME!\r
 930      *\r
 931      * @return DOCUMENT ME!\r
 932      */\r
 933     public boolean getShowJVSuffix()\r
 934     {\r
 935         return showJVSuffix;\r
 936     }\r
 937 \r
 938     /**\r
 939      * DOCUMENT ME!\r
 940      *\r
 941      * @param b DOCUMENT ME!\r
 942      */\r
 943     public void setShowJVSuffix(boolean b)\r
 944     {\r
 945         showJVSuffix = b;\r
 946     }\r
 947 \r
 948 \r
 949     /**\r
 950      * DOCUMENT ME!\r
 951      *\r
 952      * @return DOCUMENT ME!\r
 953      */\r
 954     public boolean getShowAnnotation()\r
 955     {\r
 956         return showAnnotation;\r
 957     }\r
 958 \r
 959     /**\r
 960      * DOCUMENT ME!\r
 961      *\r
 962      * @param b DOCUMENT ME!\r
 963      */\r
 964     public void setShowAnnotation(boolean b)\r
 965     {\r
 966         showAnnotation = b;\r
 967     }\r
 968 \r
 969     /**\r
 970      * DOCUMENT ME!\r
 971      *\r
 972      * @return DOCUMENT ME!\r
 973      */\r
 974     public boolean getScaleAboveWrapped()\r
 975     {\r
 976         return scaleAboveWrapped;\r
 977     }\r
 978 \r
 979     /**\r
 980      * DOCUMENT ME!\r
 981      *\r
 982      * @return DOCUMENT ME!\r
 983      */\r
 984     public boolean getScaleLeftWrapped()\r
 985     {\r
 986         return scaleLeftWrapped;\r
 987     }\r
 988 \r
 989     /**\r
 990      * DOCUMENT ME!\r
 991      *\r
 992      * @return DOCUMENT ME!\r
 993      */\r
 994     public boolean getScaleRightWrapped()\r
 995     {\r
 996         return scaleRightWrapped;\r
 997     }\r
 998 \r
 999     /**\r
1000      * DOCUMENT ME!\r
1001      *\r
1002      * @param b DOCUMENT ME!\r
1003      */\r
1004     public void setScaleAboveWrapped(boolean b)\r
1005     {\r
1006         scaleAboveWrapped = b;\r
1007     }\r
1008 \r
1009     /**\r
1010      * DOCUMENT ME!\r
1011      *\r
1012      * @param b DOCUMENT ME!\r
1013      */\r
1014     public void setScaleLeftWrapped(boolean b)\r
1015     {\r
1016         scaleLeftWrapped = b;\r
1017     }\r
1018 \r
1019     /**\r
1020      * DOCUMENT ME!\r
1021      *\r
1022      * @param b DOCUMENT ME!\r
1023      */\r
1024     public void setScaleRightWrapped(boolean b)\r
1025     {\r
1026         scaleRightWrapped = b;\r
1027     }\r
1028 \r
1029     /**\r
1030      * Property change listener for changes in alignment\r
1031      *\r
1032      * @param listener DOCUMENT ME!\r
1033      */\r
1034     public void addPropertyChangeListener(\r
1035         java.beans.PropertyChangeListener listener)\r
1036     {\r
1037         changeSupport.addPropertyChangeListener(listener);\r
1038     }\r
1039 \r
1040     /**\r
1041      * DOCUMENT ME!\r
1042      *\r
1043      * @param listener DOCUMENT ME!\r
1044      */\r
1045     public void removePropertyChangeListener(\r
1046         java.beans.PropertyChangeListener listener)\r
1047     {\r
1048         changeSupport.removePropertyChangeListener(listener);\r
1049     }\r
1050 \r
1051     /**\r
1052      * Property change listener for changes in alignment\r
1053      *\r
1054      * @param prop DOCUMENT ME!\r
1055      * @param oldvalue DOCUMENT ME!\r
1056      * @param newvalue DOCUMENT ME!\r
1057      */\r
1058     public void firePropertyChange(String prop, Object oldvalue, Object newvalue)\r
1059     {\r
1060         changeSupport.firePropertyChange(prop, oldvalue, newvalue);\r
1061     }\r
1062 \r
1063     public void setIgnoreGapsConsensus(boolean b)\r
1064     {\r
1065       ignoreGapsInConsensusCalculation = b;\r
1066       updateConsensus();\r
1067       if(globalColourScheme!=null)\r
1068       {\r
1069         globalColourScheme.setThreshold(globalColourScheme.getThreshold(), ignoreGapsInConsensusCalculation);\r
1070       }\r
1071     }\r
1072 \r
1073     public boolean getIgnoreGapsConsensus()\r
1074     {\r
1075      return ignoreGapsInConsensusCalculation;\r
1076     }\r
1077 \r
1078     public void setDataset(boolean b)\r
1079     {\r
1080       isDataset = b;\r
1081     }\r
1082 \r
1083     public boolean isDataset()\r
1084     {\r
1085       return isDataset;\r
1086     }\r
1087 \r
1088 \r
1089     public void hideSelectedColumns()\r
1090     {\r
1091       if (colSel.size() < 1)\r
1092         return;\r
1093 \r
1094       colSel.hideSelectedColumns();\r
1095       setSelectionGroup(null);\r
1096 \r
1097       hasHiddenColumns = true;\r
1098     }\r
1099 \r
1100 \r
1101     public void hideColumns(int start, int end)\r
1102     {\r
1103       if(start==end)\r
1104         colSel.hideColumns(start);\r
1105       else\r
1106         colSel.hideColumns(start, end);\r
1107       setSelectionGroup(null);\r
1108       hasHiddenColumns = true;\r
1109     }\r
1110 \r
1111     public void hideSequence(SequenceI seq)\r
1112     {\r
1113       if(seq!=null)\r
1114       {\r
1115         alignment.getHiddenSequences().hideSequence(seq);\r
1116         hasHiddenRows = true;\r
1117       }\r
1118     }\r
1119 \r
1120     public void showSequence(int index)\r
1121     {\r
1122       alignment.getHiddenSequences().showSequence(index);\r
1123 \r
1124       if(alignment.getHiddenSequences().getSize()<1)\r
1125         hasHiddenRows = false;\r
1126     }\r
1127 \r
1128     public void showColumn(int col)\r
1129     {\r
1130       colSel.revealHiddenColumns(col);\r
1131       if(colSel.getHiddenColumns()==null)\r
1132         hasHiddenColumns = false;\r
1133     }\r
1134 \r
1135     public void showAllHiddenColumns()\r
1136     {\r
1137       colSel.revealAllHiddenColumns();\r
1138       hasHiddenColumns = false;\r
1139     }\r
1140 \r
1141     public void showAllHiddenSeqs()\r
1142     {\r
1143       if(alignment.getHiddenSequences().getSize()>0)\r
1144       {\r
1145         alignment.getHiddenSequences().showAll();\r
1146         hasHiddenRows = false;\r
1147       }\r
1148     }\r
1149 \r
1150     public int adjustForHiddenSeqs(int alignmentIndex)\r
1151     {\r
1152       return alignment.getHiddenSequences().adjustForHiddenSeqs(alignmentIndex);\r
1153     }\r
1154 \r
1155     /**\r
1156      * This method returns the a new SequenceI [] with\r
1157      * the selection sequence and start and end points adjusted\r
1158      * @return String[]\r
1159      */\r
1160     public SequenceI[] getSelectionAsNewSequence()\r
1161     {\r
1162       SequenceI[] sequences;\r
1163 \r
1164       if (selectionGroup == null)\r
1165         sequences = alignment.getSequencesArray();\r
1166       else\r
1167         sequences = selectionGroup.getSelectionAsNewSequences(alignment);\r
1168 \r
1169       return sequences;\r
1170     }\r
1171 \r
1172     /**\r
1173      * This method returns the visible alignment as text, as\r
1174      * seen on the GUI, ie if columns are hidden they will not\r
1175      * be returned in the result.\r
1176      * Use this for calculating trees, PCA, redundancy etc on views\r
1177      * which contain hidden columns.\r
1178      * @return String[]\r
1179      */\r
1180     public jalview.datamodel.CigarArray getViewAsCigars(boolean selectedRegionOnly)\r
1181     {\r
1182       CigarArray selection=null;\r
1183       SequenceI [] seqs= null;\r
1184       int i, iSize;\r
1185       int start = 0, end = 0;\r
1186       if(selectedRegionOnly && selectionGroup!=null)\r
1187       {\r
1188         iSize = selectionGroup.getSize(false);\r
1189         seqs = selectionGroup.getSequencesInOrder(alignment);\r
1190         start = selectionGroup.getStartRes();\r
1191         end = selectionGroup.getEndRes()+1;\r
1192       }\r
1193       else\r
1194       {\r
1195         iSize = alignment.getHeight();\r
1196         seqs = alignment.getSequencesArray();\r
1197         end = alignment.getWidth();\r
1198       }\r
1199       SeqCigar[] selseqs = new SeqCigar[iSize];\r
1200       for(i=0; i<iSize; i++)\r
1201       {\r
1202         selseqs[i] = new SeqCigar(seqs[i], start, end);\r
1203       }\r
1204       selection=new CigarArray(selseqs);\r
1205 \r
1206       int[] hiddenregions = null;\r
1207       char[] hr_ops = null;\r
1208       if (hasHiddenColumns) {\r
1209         Vector _hiddenregions = new Vector();\r
1210         Vector regions = colSel.getHiddenColumns();\r
1211         int blockStart = start, blockEnd=end;\r
1212         int [] region;\r
1213         int hideStart, hideEnd;\r
1214         int last=start;\r
1215         for (int j = 0; last<end & j < regions.size(); j++)\r
1216         {\r
1217           region = (int[]) regions.elementAt(j);\r
1218           hideStart = region[0];\r
1219           hideEnd = region[1];\r
1220           // edit hidden regions to selection range\r
1221           if(hideStart<last) {\r
1222             if (hideEnd > last)\r
1223             {\r
1224               hideStart = last;\r
1225             } else\r
1226               continue;\r
1227           }\r
1228 \r
1229           if (hideStart>end)\r
1230             break;\r
1231 \r
1232           if (hideEnd>end)\r
1233             hideEnd=end;\r
1234 \r
1235           if (hideStart>hideEnd)\r
1236             break;\r
1237           /**\r
1238            * form operations...\r
1239            */\r
1240           if (last<hideStart)\r
1241             selection.addOperation(CigarArray.M, hideStart-last);\r
1242           selection.addOperation(CigarArray.D, 1+hideEnd-hideStart);\r
1243           last = hideEnd+1;\r
1244         }\r
1245         // Final match if necessary.\r
1246         if (last<end)\r
1247           selection.addOperation(CigarArray.M, end-last);\r
1248       } else {\r
1249         selection.addOperation(CigarArray.M, end-start);\r
1250       }\r
1251       return selection;\r
1252     }\r
1253 \r
1254     /**\r
1255      * This method returns the visible alignment as text, as\r
1256      * seen on the GUI, ie if columns are hidden they will not\r
1257      * be returned in the result.\r
1258      * Use this for calculating trees, PCA, redundancy etc on views\r
1259      * which contain hidden columns.\r
1260      * @return String[]\r
1261      */\r
1262     public String [] getViewAsString(boolean selectedRegionOnly)\r
1263     {\r
1264       String [] selection = null;\r
1265       SequenceI [] seqs= null;\r
1266       int i, iSize;\r
1267       int start = 0, end = 0;\r
1268       if(selectedRegionOnly && selectionGroup!=null)\r
1269       {\r
1270         iSize = selectionGroup.getSize(false);\r
1271         seqs = selectionGroup.getSequencesInOrder(alignment);\r
1272         start = selectionGroup.getStartRes();\r
1273         end = selectionGroup.getEndRes()+1;\r
1274       }\r
1275       else\r
1276       {\r
1277         iSize = alignment.getHeight();\r
1278         seqs = alignment.getSequencesArray();\r
1279         end = alignment.getWidth();\r
1280       }\r
1281 \r
1282       selection = new String[iSize];\r
1283 \r
1284 \r
1285       for(i=0; i<iSize; i++)\r
1286       {\r
1287         if (hasHiddenColumns)\r
1288         {\r
1289              StringBuffer visibleSeq = new StringBuffer();\r
1290              Vector regions = colSel.getHiddenColumns();\r
1291 \r
1292              int blockStart = start, blockEnd=end;\r
1293              int [] region;\r
1294              int hideStart, hideEnd;\r
1295 \r
1296              for (int j = 0; j < regions.size(); j++)\r
1297              {\r
1298                region = (int[]) regions.elementAt(j);\r
1299                hideStart = region[0];\r
1300                hideEnd = region[1];\r
1301 \r
1302                if(hideStart < start)\r
1303                {\r
1304                  continue;\r
1305                }\r
1306 \r
1307                blockStart = Math.min(blockStart, hideEnd+1);\r
1308                blockEnd = Math.min(blockEnd, hideStart);\r
1309 \r
1310                if(blockStart>blockEnd)\r
1311                {\r
1312                   break;\r
1313                }\r
1314 \r
1315 \r
1316                visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd));\r
1317 \r
1318                blockStart = hideEnd+1;\r
1319                blockEnd = end;\r
1320              }\r
1321 \r
1322              if(end>blockStart)\r
1323                visibleSeq.append(seqs[i].getSequence(blockStart, end));\r
1324 \r
1325              selection[i] = visibleSeq.toString();\r
1326         }\r
1327         else\r
1328         {\r
1329           selection[i] = seqs[i].getSequence(start, end);\r
1330         }\r
1331       }\r
1332 \r
1333       return selection;\r
1334     }\r
1335 \r
1336     public boolean getShowHiddenMarkers()\r
1337     {\r
1338       return showHiddenMarkers;\r
1339     }\r
1340 \r
1341     public void setShowHiddenMarkers(boolean show)\r
1342     {\r
1343       showHiddenMarkers = show;\r
1344     }\r
1345 }\r