src/jalview/renderer/AnnotationRenderer.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.renderer;
  22
  23 import jalview.analysis.AAFrequency;
  24 import jalview.analysis.CodingUtils;
  25 import jalview.analysis.Rna;
  26 import jalview.analysis.StructureFrequency;
  27 import jalview.api.AlignViewportI;
  28 import jalview.datamodel.AlignmentAnnotation;
  29 import jalview.datamodel.Annotation;
  30 import jalview.datamodel.ColumnSelection;
  31 import jalview.datamodel.HiddenColumns;
  32 import jalview.datamodel.ProfilesI;
  33 import jalview.schemes.ColourSchemeI;
  34 import jalview.schemes.NucleotideColourScheme;
  35 import jalview.schemes.ResidueProperties;
  36 import jalview.schemes.ZappoColourScheme;
  37 import jalview.util.Platform;
  38
  39 import java.awt.BasicStroke;
  40 import java.awt.Color;
  41 import java.awt.Font;
  42 import java.awt.FontMetrics;
  43 import java.awt.Graphics;
  44 import java.awt.Graphics2D;
  45 import java.awt.Image;
  46 import java.awt.font.LineMetrics;
  47 import java.awt.geom.AffineTransform;
  48 import java.awt.image.ImageObserver;
  49 import java.util.BitSet;
  50 import java.util.Hashtable;
  51
  52 public class AnnotationRenderer
  53 {
  54   private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32
  55
  56   private static final int CHAR_A = 'A'; // 65
  57
  58   private static final int CHAR_Z = 'Z'; // 90
  59
  60   /**
  61    * flag indicating if timing and redraw parameter info should be output
  62    */
  63   private final boolean debugRedraw;
  64
  65   private int charWidth, endRes, charHeight;
  66
  67   private boolean validCharWidth, hasHiddenColumns;
  68
  69   private FontMetrics fm;
  70
  71   private final boolean MAC = Platform.isAMac();
  72
  73   boolean av_renderHistogram = true, av_renderProfile = true,
  74           av_normaliseProfile = false;
  75
  76   ResidueShaderI profcolour = null;
  77
  78   private ColumnSelection columnSelection;
  79
  80   private HiddenColumns hiddenColumns;
  81
  82   private ProfilesI hconsensus;
  83
  84   private Hashtable[] complementConsensus;
  85
  86   private Hashtable[] hStrucConsensus;
  87
  88   private boolean av_ignoreGapsConsensus;
  89
  90   /**
  91    * attributes set from AwtRenderPanelI
  92    */
  93   /**
  94    * old image used when data is currently being calculated and cannot be
  95    * rendered
  96    */
  97   private Image fadedImage;
  98
  99   /**
 100    * panel being rendered into
 101    */
 102   private ImageObserver annotationPanel;
 103
 104   /**
 105    * width of image to render in panel
 106    */
 107   private int imgWidth;
 108
 109   /**
 110    * offset to beginning of visible area
 111    */
 112   private int sOffset;
 113
 114   /**
 115    * offset to end of visible area
 116    */
 117   private int visHeight;
 118
 119   /**
 120    * indicate if the renderer should only render the visible portion of the
 121    * annotation given the current view settings
 122    */
 123   private boolean useClip = true;
 124
 125   /**
 126    * master flag indicating if renderer should ever try to clip. not enabled for
 127    * jalview 2.8.1
 128    */
 129   private boolean canClip = false;
 130
 131   public AnnotationRenderer()
 132   {
 133     this(false);
 134   }
 135
 136   /**
 137    * Create a new annotation Renderer
 138    *
 139    * @param debugRedraw
 140    *          flag indicating if timing and redraw parameter info should be
 141    *          output
 142    */
 143   public AnnotationRenderer(boolean debugRedraw)
 144   {
 145     this.debugRedraw = debugRedraw;
 146   }
 147
 148   /**
 149    * Remove any references and resources when this object is no longer required
 150    */
 151   public void dispose()
 152   {
 153     hconsensus = null;
 154     complementConsensus = null;
 155     hStrucConsensus = null;
 156     fadedImage = null;
 157     annotationPanel = null;
 158   }
 159
 160   void drawStemAnnot(Graphics g, Annotation[] row_annotations, int lastSSX,
 161           int x, int y, int iconOffset, int startRes, int column,
 162           boolean validRes, boolean validEnd)
 163   {
 164     g.setColor(STEM_COLOUR);
 165     int sCol = (lastSSX / charWidth)
 166             + hiddenColumns.visibleToAbsoluteColumn(startRes);
 167     int x1 = lastSSX;
 168     int x2 = (x * charWidth);
 169
 170     char dc = (column == 0 || row_annotations[column - 1] == null) ? ' '
 171             : row_annotations[column - 1].secondaryStructure;
 172
 173     boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
 174             || dc != row_annotations[sCol - 1].secondaryStructure;
 175     boolean diffdownstream = !validRes || !validEnd
 176             || row_annotations[column] == null
 177             || dc != row_annotations[column].secondaryStructure;
 178
 179     if (column > 0 && Rna.isClosingParenthesis(dc))
 180     {
 181       if (diffupstream)
 182       // if (validRes && column>1 && row_annotations[column-2]!=null &&
 183       // dc.equals(row_annotations[column-2].displayCharacter))
 184       {
 185         /*
 186          * if new annotation with a closing base pair half of the stem,
 187          * display a backward arrow
 188          */
 189         g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
 190                 new int[]
 191                 { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
 192                 3);
 193         x1 += 5;
 194       }
 195       if (diffdownstream)
 196       {
 197         x2 -= 1;
 198       }
 199     }
 200     else
 201     {
 202       // display a forward arrow
 203       if (diffdownstream)
 204       {
 205         /*
 206          * if annotation ending with an opeing base pair half of the stem,
 207          * display a forward arrow
 208          */
 209         g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 },
 210                 new int[]
 211                 { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
 212                 3);
 213         x2 -= 5;
 214       }
 215       if (diffupstream)
 216       {
 217         x1 += 1;
 218       }
 219     }
 220     // draw arrow body
 221     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
 222   }
 223
 224   void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
 225           Annotation[] row_annotations, int lastSSX, int x, int y,
 226           int iconOffset, int startRes, int column, boolean validRes,
 227           boolean validEnd)
 228   {
 229     // System.out.println(nonCanColor);
 230
 231     g.setColor(nonCanColor);
 232     int sCol = (lastSSX / charWidth)
 233             + hiddenColumns.visibleToAbsoluteColumn(startRes);
 234     int x1 = lastSSX;
 235     int x2 = (x * charWidth);
 236
 237     String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
 238             : row_annotations[column - 1].displayCharacter;
 239
 240     boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
 241             || !dc.equals(row_annotations[sCol - 1].displayCharacter);
 242     boolean diffdownstream = !validRes || !validEnd
 243             || row_annotations[column] == null
 244             || !dc.equals(row_annotations[column].displayCharacter);
 245     // System.out.println("Column "+column+" diff up: "+diffupstream+"
 246     // down:"+diffdownstream);
 247     // If a closing base pair half of the stem, display a backward arrow
 248     if (column > 0 && Rna.isClosingParenthesis(dc))
 249     {
 250
 251       if (diffupstream)
 252       // if (validRes && column>1 && row_annotations[column-2]!=null &&
 253       // dc.equals(row_annotations[column-2].displayCharacter))
 254       {
 255         g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
 256                 new int[]
 257                 { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
 258                 3);
 259         x1 += 5;
 260       }
 261       if (diffdownstream)
 262       {
 263         x2 -= 1;
 264       }
 265     }
 266     else
 267     {
 268
 269       // display a forward arrow
 270       if (diffdownstream)
 271       {
 272         g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 },
 273                 new int[]
 274                 { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
 275                 3);
 276         x2 -= 5;
 277       }
 278       if (diffupstream)
 279       {
 280         x1 += 1;
 281       }
 282     }
 283     // draw arrow body
 284     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
 285   }
 286
 287   // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
 288   // av)
 289   public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel,
 290           AlignViewportI av)
 291   {
 292     fm = annotPanel.getFontMetrics();
 293     annotationPanel = annotPanel;
 294     fadedImage = annotPanel.getFadedImage();
 295     imgWidth = annotPanel.getFadedImageWidth();
 296     // visible area for rendering
 297     int[] bounds = annotPanel.getVisibleVRange();
 298     if (bounds != null)
 299     {
 300       sOffset = bounds[0];
 301       visHeight = bounds[1];
 302       if (visHeight == 0)
 303       {
 304         useClip = false;
 305       }
 306       else
 307       {
 308         useClip = canClip;
 309       }
 310     }
 311     else
 312     {
 313       useClip = false;
 314     }
 315
 316     updateFromAlignViewport(av);
 317   }
 318
 319   public void updateFromAlignViewport(AlignViewportI av)
 320   {
 321     charWidth = av.getCharWidth();
 322     endRes = av.getRanges().getEndRes();
 323     charHeight = av.getCharHeight();
 324     hasHiddenColumns = av.hasHiddenColumns();
 325     validCharWidth = av.isValidCharWidth();
 326     av_renderHistogram = av.isShowConsensusHistogram();
 327     av_renderProfile = av.isShowSequenceLogo();
 328     av_normaliseProfile = av.isNormaliseSequenceLogo();
 329     profcolour = av.getResidueShading();
 330     if (profcolour == null || profcolour.getColourScheme() == null)
 331     {
 332       /*
 333        * Use default colour for sequence logo if
 334        * the alignment has no colourscheme set
 335        * (would like to use user preference but n/a for applet)
 336        */
 337       ColourSchemeI col = av.getAlignment().isNucleotide()
 338               ? new NucleotideColourScheme()
 339               : new ZappoColourScheme();
 340       profcolour = new ResidueShader(col);
 341     }
 342     columnSelection = av.getColumnSelection();
 343     hiddenColumns = av.getAlignment().getHiddenColumns();
 344     hconsensus = av.getSequenceConsensusHash();
 345     complementConsensus = av.getComplementConsensusHash();
 346     hStrucConsensus = av.getRnaStructureConsensusHash();
 347     av_ignoreGapsConsensus = av.isIgnoreGapsConsensus();
 348   }
 349
 350   /**
 351    * Returns profile data; the first element is the profile type, the second is
 352    * the number of distinct values, the third the total count, and the remainder
 353    * depend on the profile type.
 354    *
 355    * @param aa
 356    * @param column
 357    * @return
 358    */
 359   int[] getProfileFor(AlignmentAnnotation aa, int column)
 360   {
 361     // TODO : consider refactoring the global alignment calculation
 362     // properties/rendering attributes as a global 'alignment group' which holds
 363     // all vis settings for the alignment as a whole rather than a subset
 364     //
 365     if (aa.autoCalculated && (aa.label.startsWith("Consensus")
 366             || aa.label.startsWith("cDNA Consensus")))
 367     {
 368       boolean forComplement = aa.label.startsWith("cDNA Consensus");
 369       if (aa.groupRef != null && aa.groupRef.consensusData != null
 370               && aa.groupRef.isShowSequenceLogo())
 371       {
 372         // TODO? group consensus for cDNA complement
 373         return AAFrequency.extractProfile(
 374                 aa.groupRef.consensusData.get(column),
 375                 aa.groupRef.getIgnoreGapsConsensus());
 376       }
 377       // TODO extend annotation row to enable dynamic and static profile data to
 378       // be stored
 379       if (aa.groupRef == null && aa.sequenceRef == null)
 380       {
 381         if (forComplement)
 382         {
 383           return AAFrequency.extractCdnaProfile(complementConsensus[column],
 384                   av_ignoreGapsConsensus);
 385         }
 386         else
 387         {
 388           return AAFrequency.extractProfile(hconsensus.get(column),
 389                   av_ignoreGapsConsensus);
 390         }
 391       }
 392     }
 393     else
 394     {
 395       if (aa.autoCalculated && aa.label.startsWith("StrucConsensus"))
 396       {
 397         // TODO implement group structure consensus
 398         /*
 399          * if (aa.groupRef != null && aa.groupRef.consensusData != null &&
 400          * aa.groupRef.isShowSequenceLogo()) { //TODO check what happens for
 401          * group selections return StructureFrequency.extractProfile(
 402          * aa.groupRef.consensusData[column], aa.groupRef
 403          * .getIgnoreGapsConsensus()); }
 404          */
 405         // TODO extend annotation row to enable dynamic and static profile data
 406         // to
 407         // be stored
 408         if (aa.groupRef == null && aa.sequenceRef == null
 409                 && hStrucConsensus != null
 410                 && hStrucConsensus.length > column)
 411         {
 412           return StructureFrequency.extractProfile(hStrucConsensus[column],
 413                   av_ignoreGapsConsensus);
 414         }
 415       }
 416     }
 417     return null;
 418   }
 419
 420   boolean rna = false;
 421
 422   private int lastDrawnHeight;
 423
 424   /**
 425    * Render the annotation rows associated with an alignment.
 426    *
 427    * @param annotPanel
 428    *          container frame
 429    * @param av
 430    *          data and view settings to render
 431    * @param g
 432    *          destination for graphics
 433    * @param activeRow
 434    *          row where a mouse event occured (or -1)
 435    * @param startRes
 436    *          first column that will be drawn
 437    * @param endRes
 438    *          last column that will be drawn
 439    * @return true if the fadedImage was used for any alignment annotation rows
 440    *         currently being calculated
 441    */
 442   public boolean drawComponent(AwtRenderPanelI annotPanel,
 443           AlignViewportI av, Graphics g, int activeRow, int startRes,
 444           int endRes)
 445   {
 446     long stime = System.currentTimeMillis();
 447     boolean usedFaded = false;
 448     // NOTES:
 449     // AnnotationPanel needs to implement: ImageObserver, access to
 450     // AlignViewport
 451     updateFromAwtRenderPanel(annotPanel, av);
 452     fm = g.getFontMetrics();
 453     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 454     int temp = 0;
 455     if (aa == null)
 456     {
 457       return false;
 458     }
 459     int x = 0, y = 0;
 460     int column = 0;
 461     char lastSS;
 462     int lastSSX;
 463     int iconOffset = 0;
 464     boolean validRes = false;
 465     boolean validEnd = false;
 466     boolean labelAllCols = false;
 467     boolean centreColLabels;
 468     boolean centreColLabelsDef = av.isCentreColumnLabels();
 469     boolean scaleColLabel = false;
 470     final AlignmentAnnotation consensusAnnot = av
 471             .getAlignmentConsensusAnnotation();
 472     final AlignmentAnnotation structConsensusAnnot = av
 473             .getAlignmentStrucConsensusAnnotation();
 474     final AlignmentAnnotation complementConsensusAnnot = av
 475             .getComplementConsensusAnnotation();
 476     boolean renderHistogram = true, renderProfile = true,
 477             normaliseProfile = false, isRNA = rna;
 478
 479     BitSet graphGroupDrawn = new BitSet();
 480     int charOffset = 0; // offset for a label
 481     float fmWidth, fmScaling = 1f; // scaling for a label to fit it into a
 482     // column.
 483     Font ofont = g.getFont();
 484     // \u03B2 \u03B1
 485     // debug ints
 486     int yfrom = 0, f_i = 0, yto = 0, f_to = 0;
 487     boolean clipst = false, clipend = false;
 488     for (int i = 0; i < aa.length; i++)
 489     {
 490       AlignmentAnnotation row = aa[i];
 491       isRNA = row.isRNA();
 492       {
 493         // check if this is a consensus annotation row and set the display
 494         // settings appropriately
 495         // TODO: generalise this to have render styles for consensus/profile
 496         // data
 497         if (row.groupRef != null && row == row.groupRef.getConsensus())
 498         {
 499           renderHistogram = row.groupRef.isShowConsensusHistogram();
 500           renderProfile = row.groupRef.isShowSequenceLogo();
 501           normaliseProfile = row.groupRef.isNormaliseSequenceLogo();
 502         }
 503         else if (row == consensusAnnot || row == structConsensusAnnot
 504                 || row == complementConsensusAnnot)
 505         {
 506           renderHistogram = av_renderHistogram;
 507           renderProfile = av_renderProfile;
 508           normaliseProfile = av_normaliseProfile;
 509         }
 510         else
 511         {
 512           renderHistogram = true;
 513           // don't need to set render/normaliseProfile since they are not
 514           // currently used in any other annotation track renderer
 515         }
 516       }
 517       Annotation[] row_annotations = row.annotations;
 518       if (!row.visible)
 519       {
 520         continue;
 521       }
 522       centreColLabels = row.centreColLabels || centreColLabelsDef;
 523       labelAllCols = row.showAllColLabels;
 524       scaleColLabel = row.scaleColLabel;
 525       lastSS = ' ';
 526       lastSSX = 0;
 527
 528       if (!useClip || ((y - charHeight) < visHeight
 529               && (y + row.height + charHeight * 2) >= sOffset))
 530       {// if_in_visible_region
 531         if (!clipst)
 532         {
 533           clipst = true;
 534           yfrom = y;
 535           f_i = i;
 536         }
 537         yto = y;
 538         f_to = i;
 539         if (row.graph > 0)
 540         {
 541           if (row.graphGroup > -1 && graphGroupDrawn.get(row.graphGroup))
 542           {
 543             continue;
 544           }
 545
 546           // this is so that we draw the characters below the graph
 547           y += row.height;
 548
 549           if (row.hasText)
 550           {
 551             iconOffset = charHeight - fm.getDescent();
 552             y -= charHeight;
 553           }
 554         }
 555         else if (row.hasText)
 556         {
 557           iconOffset = charHeight - fm.getDescent();
 558
 559         }
 560         else
 561         {
 562           iconOffset = 0;
 563         }
 564
 565         if (row.autoCalculated && av.isCalculationInProgress(row))
 566         {
 567           y += charHeight;
 568           usedFaded = true;
 569           g.drawImage(fadedImage, 0, y - row.height, imgWidth, y, 0,
 570                   y - row.height, imgWidth, y, annotationPanel);
 571           g.setColor(Color.black);
 572           // g.drawString("Calculating "+aa[i].label+"....",20, y-row.height/2);
 573
 574           continue;
 575         }
 576
 577         /*
 578          * else if (annotationPanel.av.updatingConservation &&
 579          * aa[i].label.equals("Conservation")) {
 580          *
 581          * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y -
 582          * row.height, annotationPanel.imgWidth, y, 0, y - row.height,
 583          * annotationPanel.imgWidth, y, annotationPanel);
 584          *
 585          * g.setColor(Color.black); //
 586          * g.drawString("Calculating Conservation.....",20, y-row.height/2);
 587          *
 588          * continue; } else if (annotationPanel.av.updatingConservation &&
 589          * aa[i].label.equals("Quality")) {
 590          *
 591          * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y -
 592          * row.height, annotationPanel.imgWidth, y, 0, y - row.height,
 593          * annotationPanel.imgWidth, y, annotationPanel);
 594          * g.setColor(Color.black); // /
 595          * g.drawString("Calculating Quality....",20, y-row.height/2);
 596          *
 597          * continue; }
 598          */
 599         // first pass sets up state for drawing continuation from left-hand
 600         // column
 601         // of startRes
 602         x = (startRes == 0) ? 0 : -1;
 603         while (x < endRes - startRes)
 604         {
 605           if (hasHiddenColumns)
 606           {
 607             column = hiddenColumns.visibleToAbsoluteColumn(startRes + x);
 608             if (column > row_annotations.length - 1)
 609             {
 610               break;
 611             }
 612           }
 613           else
 614           {
 615             column = startRes + x;
 616           }
 617
 618           if ((row_annotations == null)
 619                   || (row_annotations.length <= column)
 620                   || (row_annotations[column] == null))
 621           {
 622             validRes = false;
 623           }
 624           else
 625           {
 626             validRes = true;
 627           }
 628           final String displayChar = validRes
 629                   ? row_annotations[column].displayCharacter
 630                   : null;
 631           if (x > -1)
 632           {
 633             if (activeRow == i)
 634             {
 635               g.setColor(Color.red);
 636
 637               if (columnSelection != null)
 638               {
 639                 if (columnSelection.contains(column))
 640                 {
 641                   g.fillRect(x * charWidth, y, charWidth, charHeight);
 642                 }
 643               }
 644             }
 645             if (row.getInvalidStrucPos() > x)
 646             {
 647               g.setColor(Color.orange);
 648               g.fillRect(x * charWidth, y, charWidth, charHeight);
 649             }
 650             else if (row.getInvalidStrucPos() == x)
 651             {
 652               g.setColor(Color.orange.darker());
 653               g.fillRect(x * charWidth, y, charWidth, charHeight);
 654             }
 655             if (validCharWidth && validRes && displayChar != null
 656                     && (displayChar.length() > 0))
 657             {
 658
 659               fmWidth = fm.charsWidth(displayChar.toCharArray(), 0,
 660                       displayChar.length());
 661               if (/* centreColLabels || */scaleColLabel)
 662               {
 663                 // fmWidth = fm.charsWidth(displayChar.toCharArray(), 0,
 664                 // displayChar.length());
 665                 //
 666                 // if (scaleColLabel)
 667                 // {
 668                 // justify the label and scale to fit in column
 669                 if (fmWidth > charWidth)
 670                 {
 671                   // scale only if the current font isn't already small enough
 672                   fmScaling = charWidth;
 673                   fmScaling /= fmWidth;
 674                   g.setFont(ofont.deriveFont(AffineTransform
 675                           .getScaleInstance(fmScaling, 1.0)));
 676                   // and update the label's width to reflect the scaling.
 677                   fmWidth = charWidth;
 678                 }
 679                 // }
 680               }
 681               // TODO is it ok to use width of / show all characters here?
 682               // else
 683               // {
 684               // fmWidth = fm.charWidth(displayChar.charAt(0));
 685               // }
 686               charOffset = (int) ((charWidth - fmWidth) / 2f);
 687
 688               if (row_annotations[column].colour == null)
 689               {
 690                 g.setColor(Color.black);
 691               }
 692               else
 693               {
 694                 g.setColor(row_annotations[column].colour);
 695               }
 696
 697               if (column == 0 || row.graph > 0)
 698               {
 699                 g.drawString(displayChar, (x * charWidth) + charOffset,
 700                         y + iconOffset);
 701               }
 702               else if (row_annotations[column - 1] == null || (labelAllCols
 703                       || !displayChar.equals(
 704                               row_annotations[column - 1].displayCharacter)
 705                       || (displayChar.length() < 2
 706                               && row_annotations[column].secondaryStructure == ' ')))
 707               {
 708                 g.drawString(displayChar, x * charWidth + charOffset,
 709                         y + iconOffset);
 710               }
 711               g.setFont(ofont);
 712             }
 713           }
 714           if (row.hasIcons)
 715           {
 716             char ss = validRes ? row_annotations[column].secondaryStructure
 717                     : '-';
 718
 719             if (ss == '(')
 720             {
 721               // distinguish between forward/backward base-pairing
 722               if (displayChar.indexOf(')') > -1)
 723               {
 724
 725                 ss = ')';
 726
 727               }
 728             }
 729             if (ss == '[')
 730             {
 731               if ((displayChar.indexOf(']') > -1))
 732               {
 733                 ss = ']';
 734
 735               }
 736             }
 737             if (ss == '{')
 738             {
 739               // distinguish between forward/backward base-pairing
 740               if (displayChar.indexOf('}') > -1)
 741               {
 742                 ss = '}';
 743
 744               }
 745             }
 746             if (ss == '<')
 747             {
 748               // distinguish between forward/backward base-pairing
 749               if (displayChar.indexOf('<') > -1)
 750               {
 751                 ss = '>';
 752
 753               }
 754             }
 755             if (isRNA && (ss >= CHAR_A) && (ss <= CHAR_Z))
 756             {
 757               // distinguish between forward/backward base-pairing
 758               int ssLowerCase = ss + UPPER_TO_LOWER;
 759               // TODO would .equals() be safer here? or charAt(0)?
 760               if (displayChar.indexOf(ssLowerCase) > -1)
 761               {
 762                 ss = (char) ssLowerCase;
 763               }
 764             }
 765
 766             if (!validRes || (ss != lastSS))
 767             {
 768
 769               if (x > -1)
 770               {
 771
 772                 int nb_annot = x - temp;
 773                 // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre
 774                 // annot :"+nb_annot);
 775                 switch (lastSS)
 776                 {
 777                 case '(': // Stem case for RNA secondary structure
 778                 case ')': // and opposite direction
 779                   drawStemAnnot(g, row_annotations, lastSSX, x, y,
 780                           iconOffset, startRes, column, validRes, validEnd);
 781                   temp = x;
 782                   break;
 783
 784                 case 'H':
 785                   if (!isRNA)
 786                   {
 787                     drawHelixAnnot(g, row_annotations, lastSSX, x, y,
 788                             iconOffset, startRes, column, validRes,
 789                             validEnd);
 790                     break;
 791                   }
 792                   // no break if isRNA - falls through to drawNotCanonicalAnnot!
 793                 case 'E':
 794                   if (!isRNA)
 795                   {
 796                     drawSheetAnnot(g, row_annotations, lastSSX, x, y,
 797                             iconOffset, startRes, column, validRes,
 798                             validEnd);
 799                     break;
 800                   }
 801                   // no break if isRNA - fall through to drawNotCanonicalAnnot!
 802
 803                 case '{':
 804                 case '}':
 805                 case '[':
 806                 case ']':
 807                 case '>':
 808                 case '<':
 809                 case 'A':
 810                 case 'a':
 811                 case 'B':
 812                 case 'b':
 813                 case 'C':
 814                 case 'c':
 815                 case 'D':
 816                 case 'd':
 817                 case 'e':
 818                 case 'F':
 819                 case 'f':
 820                 case 'G':
 821                 case 'g':
 822                 case 'h':
 823                 case 'I':
 824                 case 'i':
 825                 case 'J':
 826                 case 'j':
 827                 case 'K':
 828                 case 'k':
 829                 case 'L':
 830                 case 'l':
 831                 case 'M':
 832                 case 'm':
 833                 case 'N':
 834                 case 'n':
 835                 case 'O':
 836                 case 'o':
 837                 case 'P':
 838                 case 'p':
 839                 case 'Q':
 840                 case 'q':
 841                 case 'R':
 842                 case 'r':
 843                 case 'S':
 844                 case 's':
 845                 case 'T':
 846                 case 't':
 847                 case 'U':
 848                 case 'u':
 849                 case 'V':
 850                 case 'v':
 851                 case 'W':
 852                 case 'w':
 853                 case 'X':
 854                 case 'x':
 855                 case 'Y':
 856                 case 'y':
 857                 case 'Z':
 858                 case 'z':
 859
 860                   Color nonCanColor = getNotCanonicalColor(lastSS);
 861                   drawNotCanonicalAnnot(g, nonCanColor, row_annotations,
 862                           lastSSX, x, y, iconOffset, startRes, column,
 863                           validRes, validEnd);
 864                   temp = x;
 865                   break;
 866                 default:
 867                   g.setColor(Color.gray);
 868                   g.fillRect(lastSSX, y + 6 + iconOffset,
 869                           (x * charWidth) - lastSSX, 2);
 870                   temp = x;
 871                   break;
 872                 }
 873               }
 874               if (validRes)
 875               {
 876                 lastSS = ss;
 877               }
 878               else
 879               {
 880                 lastSS = ' ';
 881               }
 882               if (x > -1)
 883               {
 884                 lastSSX = (x * charWidth);
 885               }
 886             }
 887           }
 888           column++;
 889           x++;
 890         }
 891         if (column >= row_annotations.length)
 892         {
 893           column = row_annotations.length - 1;
 894           validEnd = false;
 895         }
 896         else
 897         {
 898           validEnd = true;
 899         }
 900         if ((row_annotations == null) || (row_annotations.length <= column)
 901                 || (row_annotations[column] == null))
 902         {
 903           validRes = false;
 904         }
 905         else
 906         {
 907           validRes = true;
 908         }
 909         // x ++;
 910
 911         if (row.hasIcons)
 912         {
 913           switch (lastSS)
 914           {
 915
 916           case 'H':
 917             if (!isRNA)
 918             {
 919               drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
 920                       startRes, column, validRes, validEnd);
 921               break;
 922             }
 923             // no break if isRNA - fall through to drawNotCanonicalAnnot!
 924
 925           case 'E':
 926             if (!isRNA)
 927             {
 928               drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
 929                       startRes, column, validRes, validEnd);
 930               break;
 931             }
 932             // no break if isRNA - fall through to drawNotCanonicalAnnot!
 933
 934           case '(':
 935           case ')': // Stem case for RNA secondary structure
 936
 937             drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
 938                     startRes, column, validRes, validEnd);
 939
 940             break;
 941           case '{':
 942           case '}':
 943           case '[':
 944           case ']':
 945           case '>':
 946           case '<':
 947           case 'A':
 948           case 'a':
 949           case 'B':
 950           case 'b':
 951           case 'C':
 952           case 'c':
 953           case 'D':
 954           case 'd':
 955           case 'e':
 956           case 'F':
 957           case 'f':
 958           case 'G':
 959           case 'g':
 960           case 'h':
 961           case 'I':
 962           case 'i':
 963           case 'J':
 964           case 'j':
 965           case 'K':
 966           case 'k':
 967           case 'L':
 968           case 'l':
 969           case 'M':
 970           case 'm':
 971           case 'N':
 972           case 'n':
 973           case 'O':
 974           case 'o':
 975           case 'P':
 976           case 'p':
 977           case 'Q':
 978           case 'q':
 979           case 'R':
 980           case 'r':
 981           case 'T':
 982           case 't':
 983           case 'U':
 984           case 'u':
 985           case 'V':
 986           case 'v':
 987           case 'W':
 988           case 'w':
 989           case 'X':
 990           case 'x':
 991           case 'Y':
 992           case 'y':
 993           case 'Z':
 994           case 'z':
 995             // System.out.println(lastSS);
 996             Color nonCanColor = getNotCanonicalColor(lastSS);
 997             drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX,
 998                     x, y, iconOffset, startRes, column, validRes, validEnd);
 999             break;
1000           default:
1001             drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset,
1002                     startRes, column, validRes, validEnd);
1003             break;
1004           }
1005         }
1006
1007         if (row.graph > 0 && row.graphHeight > 0)
1008         {
1009           if (row.graph == AlignmentAnnotation.LINE_GRAPH)
1010           {
1011             if (row.graphGroup > -1 && !graphGroupDrawn.get(row.graphGroup))
1012             {
1013               // TODO: JAL-1291 revise rendering model so the graphGroup map is
1014               // computed efficiently for all visible labels
1015               float groupmax = -999999, groupmin = 9999999;
1016               for (int gg = 0; gg < aa.length; gg++)
1017               {
1018                 if (aa[gg].graphGroup != row.graphGroup)
1019                 {
1020                   continue;
1021                 }
1022
1023                 if (aa[gg] != row)
1024                 {
1025                   aa[gg].visible = false;
1026                 }
1027                 if (aa[gg].graphMax > groupmax)
1028                 {
1029                   groupmax = aa[gg].graphMax;
1030                 }
1031                 if (aa[gg].graphMin < groupmin)
1032                 {
1033                   groupmin = aa[gg].graphMin;
1034                 }
1035               }
1036
1037               for (int gg = 0; gg < aa.length; gg++)
1038               {
1039                 if (aa[gg].graphGroup == row.graphGroup)
1040                 {
1041                   drawLineGraph(g, aa[gg], aa[gg].annotations, startRes,
1042                           endRes, y, groupmin, groupmax, row.graphHeight);
1043                 }
1044               }
1045
1046               graphGroupDrawn.set(row.graphGroup);
1047             }
1048             else
1049             {
1050               drawLineGraph(g, row, row_annotations, startRes, endRes, y,
1051                       row.graphMin, row.graphMax, row.graphHeight);
1052             }
1053           }
1054           else if (row.graph == AlignmentAnnotation.BAR_GRAPH)
1055           {
1056             drawBarGraph(g, row, row_annotations, startRes, endRes,
1057                     row.graphMin, row.graphMax, y, renderHistogram,
1058                     renderProfile, normaliseProfile);
1059           }
1060         }
1061       }
1062       else
1063       {
1064         if (clipst && !clipend)
1065         {
1066           clipend = true;
1067         }
1068       } // end if_in_visible_region
1069       if (row.graph > 0 && row.hasText)
1070       {
1071         y += charHeight;
1072       }
1073
1074       if (row.graph == 0)
1075       {
1076         y += aa[i].height;
1077       }
1078     }
1079     if (debugRedraw)
1080     {
1081       if (canClip)
1082       {
1083         if (clipst)
1084         {
1085           System.err.println(
1086                   "Start clip at : " + yfrom + " (index " + f_i + ")");
1087         }
1088         if (clipend)
1089         {
1090           System.err.println(
1091                   "End clip at : " + yto + " (index " + f_to + ")");
1092         }
1093       }
1094       ;
1095       System.err.println("Annotation Rendering time:"
1096               + (System.currentTimeMillis() - stime));
1097     }
1098     lastDrawnHeight = y;
1099
1100     return !usedFaded;
1101   }
1102
1103   /**
1104    * Answers the height in pixels of what was drawn on the graphics in the last
1105    * call to {@code drawComponent}
1106    *
1107    * @return
1108    */
1109   public int getLastDrawnHeight()
1110   {
1111     return lastDrawnHeight;
1112   }
1113
1114   public static final Color GLYPHLINE_COLOR = Color.gray;
1115
1116   public static final Color SHEET_COLOUR = Color.green;
1117
1118   public static final Color HELIX_COLOUR = Color.red;
1119
1120   public static final Color STEM_COLOUR = Color.blue;
1121
1122   private Color sdNOTCANONICAL_COLOUR;
1123
1124   void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX, int x,
1125           int y, int iconOffset, int startRes, int column, boolean validRes,
1126           boolean validEnd)
1127   {
1128     g.setColor(GLYPHLINE_COLOR);
1129     g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
1130   }
1131
1132   void drawSheetAnnot(Graphics g, Annotation[] row,
1133
1134           int lastSSX, int x, int y, int iconOffset, int startRes,
1135           int column, boolean validRes, boolean validEnd)
1136   {
1137     g.setColor(SHEET_COLOUR);
1138
1139     if (!validEnd || !validRes || row == null || row[column] == null
1140             || row[column].secondaryStructure != 'E')
1141     {
1142       g.fillRect(lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX - 4,
1143               7);
1144       g.fillPolygon(
1145               new int[]
1146               { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) },
1147               new int[]
1148               { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
1149               3);
1150     }
1151     else
1152     {
1153       g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth - lastSSX,
1154               7);
1155     }
1156
1157   }
1158
1159   void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX, int x,
1160           int y, int iconOffset, int startRes, int column, boolean validRes,
1161           boolean validEnd)
1162   {
1163     g.setColor(HELIX_COLOUR);
1164
1165     int sCol = (lastSSX / charWidth)
1166             + hiddenColumns.visibleToAbsoluteColumn(startRes);
1167     int x1 = lastSSX;
1168     int x2 = (x * charWidth);
1169
1170     if (MAC)
1171     {
1172       int ofs = charWidth / 2;
1173       // Off by 1 offset when drawing rects and ovals
1174       // to offscreen image on the MAC
1175       g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
1176       if (sCol == 0 || row[sCol - 1] == null
1177               || row[sCol - 1].secondaryStructure != 'H')
1178       {
1179       }
1180       else
1181       {
1182         // g.setColor(Color.orange);
1183         g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
1184                 0, 0);
1185       }
1186       if (!validRes || row[column] == null
1187               || row[column].secondaryStructure != 'H')
1188       {
1189
1190       }
1191       else
1192       {
1193         // g.setColor(Color.magenta);
1194         g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset,
1195                 x2 - x1 - ofs + 1, 8, 0, 0);
1196
1197       }
1198
1199       return;
1200     }
1201
1202     if (sCol == 0 || row[sCol - 1] == null
1203             || row[sCol - 1].secondaryStructure != 'H')
1204     {
1205       g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
1206       x1 += charWidth / 2;
1207     }
1208
1209     if (!validRes || row[column] == null
1210             || row[column].secondaryStructure != 'H')
1211     {
1212       g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset, charWidth,
1213               8, 270, 180);
1214       x2 -= charWidth / 2;
1215     }
1216
1217     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
1218   }
1219
1220   void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
1221           Annotation[] aa_annotations, int sRes, int eRes, int y, float min,
1222           float max, int graphHeight)
1223   {
1224     if (sRes > aa_annotations.length)
1225     {
1226       return;
1227     }
1228
1229     int x = 0;
1230
1231     // Adjustment for fastpaint to left
1232     if (eRes < endRes)
1233     {
1234       eRes++;
1235     }
1236
1237     eRes = Math.min(eRes, aa_annotations.length);
1238
1239     if (sRes == 0)
1240     {
1241       x++;
1242     }
1243
1244     int y1 = y, y2 = y;
1245     float range = max - min;
1246
1247     // //Draw origin
1248     if (min < 0)
1249     {
1250       y2 = y - (int) ((0 - min / range) * graphHeight);
1251     }
1252
1253     g.setColor(Color.gray);
1254     g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
1255
1256     eRes = Math.min(eRes, aa_annotations.length);
1257
1258     int column;
1259     int aaMax = aa_annotations.length - 1;
1260
1261     while (x < eRes - sRes)
1262     {
1263       column = sRes + x;
1264       if (hasHiddenColumns)
1265       {
1266         column = hiddenColumns.visibleToAbsoluteColumn(column);
1267       }
1268
1269       if (column > aaMax)
1270       {
1271         break;
1272       }
1273
1274       if (aa_annotations[column] == null
1275               || aa_annotations[column - 1] == null)
1276       {
1277         x++;
1278         continue;
1279       }
1280
1281       if (aa_annotations[column].colour == null)
1282       {
1283         g.setColor(Color.black);
1284       }
1285       else
1286       {
1287         g.setColor(aa_annotations[column].colour);
1288       }
1289
1290       y1 = y - (int) (((aa_annotations[column - 1].value - min) / range)
1291               * graphHeight);
1292       y2 = y - (int) (((aa_annotations[column].value - min) / range)
1293               * graphHeight);
1294
1295       g.drawLine(x * charWidth - charWidth / 2, y1,
1296               x * charWidth + charWidth / 2, y2);
1297       x++;
1298     }
1299
1300     if (_aa.threshold != null)
1301     {
1302       g.setColor(_aa.threshold.colour);
1303       Graphics2D g2 = (Graphics2D) g;
1304       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
1305               BasicStroke.JOIN_ROUND, 3f, new float[]
1306               { 5f, 3f }, 0f));
1307
1308       y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
1309       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
1310       g2.setStroke(new BasicStroke());
1311     }
1312   }
1313
1314   void drawBarGraph(Graphics g, AlignmentAnnotation _aa,
1315           Annotation[] aa_annotations, int sRes, int eRes, float min,
1316           float max, int y, boolean renderHistogram, boolean renderProfile,
1317           boolean normaliseProfile)
1318   {
1319     if (sRes > aa_annotations.length)
1320     {
1321       return;
1322     }
1323     Font ofont = g.getFont();
1324     eRes = Math.min(eRes, aa_annotations.length);
1325
1326     int x = 0, y1 = y, y2 = y;
1327
1328     float range = max - min;
1329
1330     if (min < 0)
1331     {
1332       y2 = y - (int) ((0 - min / (range)) * _aa.graphHeight);
1333     }
1334
1335     g.setColor(Color.gray);
1336
1337     g.drawLine(x, y2, (eRes - sRes) * charWidth, y2);
1338
1339     int column;
1340     int aaMax = aa_annotations.length - 1;
1341     while (x < eRes - sRes)
1342     {
1343       column = sRes + x;
1344       if (hasHiddenColumns)
1345       {
1346         column = hiddenColumns.visibleToAbsoluteColumn(column);
1347       }
1348
1349       if (column > aaMax)
1350       {
1351         break;
1352       }
1353
1354       if (aa_annotations[column] == null)
1355       {
1356         x++;
1357         continue;
1358       }
1359       if (aa_annotations[column].colour == null)
1360       {
1361         g.setColor(Color.black);
1362       }
1363       else
1364       {
1365         g.setColor(aa_annotations[column].colour);
1366       }
1367
1368       y1 = y - (int) (((aa_annotations[column].value - min) / (range))
1369               * _aa.graphHeight);
1370
1371       if (renderHistogram)
1372       {
1373         if (y1 - y2 > 0)
1374         {
1375           g.fillRect(x * charWidth, y2, charWidth, y1 - y2);
1376         }
1377         else
1378         {
1379           g.fillRect(x * charWidth, y1, charWidth, y2 - y1);
1380         }
1381       }
1382       // draw profile if available
1383       if (renderProfile)
1384       {
1385
1386         /*
1387          * {profile type, #values, total count, char1, pct1, char2, pct2...}
1388          */
1389         int profl[] = getProfileFor(_aa, column);
1390
1391         // just try to draw the logo if profl is not null
1392         if (profl != null && profl[2] != 0)
1393         {
1394           boolean isStructureProfile = profl[0] == AlignmentAnnotation.STRUCTURE_PROFILE;
1395           boolean isCdnaProfile = profl[0] == AlignmentAnnotation.CDNA_PROFILE;
1396           float ht = normaliseProfile ? y - _aa.graphHeight : y1;
1397           double htn = normaliseProfile ? _aa.graphHeight : (y2 - y1);// aa.graphHeight;
1398           double hght;
1399           float wdth;
1400           double ht2 = 0;
1401           char[] dc;
1402
1403           /**
1404            * Render a single base for a sequence profile, a base pair for
1405            * structure profile, and a triplet for a cdna profile
1406            */
1407           dc = new char[isStructureProfile ? 2 : (isCdnaProfile ? 3 : 1)];
1408
1409           LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g);
1410           double scale = 1f / (normaliseProfile ? profl[2] : 100f);
1411           float ofontHeight = 1f / lm.getAscent();// magnify to fill box
1412           double scl = 0.0;
1413
1414           /*
1415            * Traverse the character(s)/percentage data in the array
1416            */
1417           int c = 3;
1418           int valuesProcessed = 0;
1419           // profl[1] is the number of values in the profile
1420           while (valuesProcessed < profl[1])
1421           {
1422             if (isStructureProfile)
1423             {
1424               // todo can we encode a structure pair as an int, like codons?
1425               dc[0] = (char) profl[c++];
1426               dc[1] = (char) profl[c++];
1427             }
1428             else if (isCdnaProfile)
1429             {
1430               dc = CodingUtils.decodeCodon(profl[c++]);
1431             }
1432             else
1433             {
1434               dc[0] = (char) profl[c++];
1435             }
1436
1437             wdth = charWidth;
1438             wdth /= fm.charsWidth(dc, 0, dc.length);
1439
1440             ht += scl;
1441             // next profl[] position is profile % for the character(s)
1442             scl = htn * scale * profl[c++];
1443             lm = ofont.getLineMetrics(dc, 0, 1,
1444                     g.getFontMetrics().getFontRenderContext());
1445             Font font = ofont.deriveFont(AffineTransform
1446                     .getScaleInstance(wdth, scl / lm.getAscent()));
1447             g.setFont(font);
1448             lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g);
1449
1450             // Debug - render boxes around characters
1451             // g.setColor(Color.red);
1452             // g.drawRect(x*av.charWidth, (int)ht, av.charWidth,
1453             // (int)(scl));
1454             // g.setColor(profcolour.findColour(dc[0]).darker());
1455
1456             /*
1457              * Set character colour as per alignment colour scheme; use the
1458              * codon translation if a cDNA profile
1459              */
1460             Color colour = null;
1461             if (isCdnaProfile)
1462             {
1463               final String codonTranslation = ResidueProperties
1464                       .codonTranslate(new String(dc));
1465               colour = profcolour.findColour(codonTranslation.charAt(0),
1466                       column, null);
1467             }
1468             else
1469             {
1470               colour = profcolour.findColour(dc[0], column, null);
1471             }
1472             g.setColor(colour == Color.white ? Color.lightGray : colour);
1473
1474             hght = (ht + (scl - lm.getDescent()
1475                     - lm.getBaselineOffsets()[lm.getBaselineIndex()]));
1476
1477             g.drawChars(dc, 0, dc.length, x * charWidth, (int) hght);
1478             valuesProcessed++;
1479           }
1480           g.setFont(ofont);
1481         }
1482       }
1483       x++;
1484     }
1485     if (_aa.threshold != null)
1486     {
1487       g.setColor(_aa.threshold.colour);
1488       Graphics2D g2 = (Graphics2D) g;
1489       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
1490               BasicStroke.JOIN_ROUND, 3f, new float[]
1491               { 5f, 3f }, 0f));
1492
1493       y2 = (int) (y
1494               - ((_aa.threshold.value - min) / range) * _aa.graphHeight);
1495       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
1496       g2.setStroke(new BasicStroke());
1497     }
1498   }
1499
1500   // used by overview window
1501   public void drawGraph(Graphics g, AlignmentAnnotation _aa,
1502           Annotation[] aa_annotations, int width, int y, int sRes, int eRes)
1503   {
1504     eRes = Math.min(eRes, aa_annotations.length);
1505     g.setColor(Color.white);
1506     g.fillRect(0, 0, width, y);
1507     g.setColor(new Color(0, 0, 180));
1508
1509     int x = 0, height;
1510
1511     for (int j = sRes; j < eRes; j++)
1512     {
1513       if (aa_annotations[j] != null)
1514       {
1515         if (aa_annotations[j].colour == null)
1516         {
1517           g.setColor(Color.black);
1518         }
1519         else
1520         {
1521           g.setColor(aa_annotations[j].colour);
1522         }
1523
1524         height = (int) ((aa_annotations[j].value / _aa.graphMax) * y);
1525         if (height > y)
1526         {
1527           height = y;
1528         }
1529
1530         g.fillRect(x, y - height, charWidth, height);
1531       }
1532       x += charWidth;
1533     }
1534   }
1535
1536   Color getNotCanonicalColor(char lastss)
1537   {
1538     switch (lastss)
1539     {
1540     case '{':
1541     case '}':
1542       return new Color(255, 125, 5);
1543
1544     case '[':
1545     case ']':
1546       return new Color(245, 115, 10);
1547
1548     case '>':
1549     case '<':
1550       return new Color(235, 135, 15);
1551
1552     case 'A':
1553     case 'a':
1554       return new Color(225, 105, 20);
1555
1556     case 'B':
1557     case 'b':
1558       return new Color(215, 145, 30);
1559
1560     case 'C':
1561     case 'c':
1562       return new Color(205, 95, 35);
1563
1564     case 'D':
1565     case 'd':
1566       return new Color(195, 155, 45);
1567
1568     case 'E':
1569     case 'e':
1570       return new Color(185, 85, 55);
1571
1572     case 'F':
1573     case 'f':
1574       return new Color(175, 165, 65);
1575
1576     case 'G':
1577     case 'g':
1578       return new Color(170, 75, 75);
1579
1580     case 'H':
1581     case 'h':
1582       return new Color(160, 175, 85);
1583
1584     case 'I':
1585     case 'i':
1586       return new Color(150, 65, 95);
1587
1588     case 'J':
1589     case 'j':
1590       return new Color(140, 185, 105);
1591
1592     case 'K':
1593     case 'k':
1594       return new Color(130, 55, 110);
1595
1596     case 'L':
1597     case 'l':
1598       return new Color(120, 195, 120);
1599
1600     case 'M':
1601     case 'm':
1602       return new Color(110, 45, 130);
1603
1604     case 'N':
1605     case 'n':
1606       return new Color(100, 205, 140);
1607
1608     case 'O':
1609     case 'o':
1610       return new Color(90, 35, 150);
1611
1612     case 'P':
1613     case 'p':
1614       return new Color(85, 215, 160);
1615
1616     case 'Q':
1617     case 'q':
1618       return new Color(75, 25, 170);
1619
1620     case 'R':
1621     case 'r':
1622       return new Color(65, 225, 180);
1623
1624     case 'S':
1625     case 's':
1626       return new Color(55, 15, 185);
1627
1628     case 'T':
1629     case 't':
1630       return new Color(45, 235, 195);
1631
1632     case 'U':
1633     case 'u':
1634       return new Color(35, 5, 205);
1635
1636     case 'V':
1637     case 'v':
1638       return new Color(25, 245, 215);
1639
1640     case 'W':
1641     case 'w':
1642       return new Color(15, 0, 225);
1643
1644     case 'X':
1645     case 'x':
1646       return new Color(10, 255, 235);
1647
1648     case 'Y':
1649     case 'y':
1650       return new Color(5, 150, 245);
1651
1652     case 'Z':
1653     case 'z':
1654       return new Color(0, 80, 255);
1655
1656     default:
1657       System.out.println("This is not a interaction : " + lastss);
1658       return null;
1659
1660     }
1661   }
1662 }