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 java.awt.BasicStroke;
  24 import java.awt.Color;
  25 import java.awt.Font;
  26 import java.awt.FontMetrics;
  27 import java.awt.Graphics;
  28 import java.awt.Graphics2D;
  29 import java.awt.Image;
  30 import java.awt.RenderingHints;
  31 import java.awt.Stroke;
  32 import java.awt.geom.AffineTransform;
  33 import java.awt.image.ImageObserver;
  34 import java.util.BitSet;
  35 import java.util.HashMap;
  36 import java.util.Hashtable;
  37 import java.util.Map;
  38
  39 import org.jfree.graphics2d.svg.SVGGraphics2D;
  40 import org.jibble.epsgraphics.EpsGraphics2D;
  41
  42 import jalview.analysis.AAFrequency;
  43 import jalview.analysis.CodingUtils;
  44 import jalview.analysis.Rna;
  45 import jalview.analysis.StructureFrequency;
  46 import jalview.api.AlignViewportI;
  47 import jalview.bin.Cache;
  48 import jalview.bin.Console;
  49 import jalview.datamodel.AlignmentAnnotation;
  50 import jalview.datamodel.Annotation;
  51 import jalview.datamodel.ColumnSelection;
  52 import jalview.datamodel.HiddenColumns;
  53 import jalview.datamodel.ProfilesI;
  54 import jalview.renderer.api.AnnotationRendererFactoryI;
  55 import jalview.renderer.api.AnnotationRowRendererI;
  56 import jalview.schemes.ColourSchemeI;
  57 import jalview.schemes.NucleotideColourScheme;
  58 import jalview.schemes.ResidueProperties;
  59 import jalview.schemes.ZappoColourScheme;
  60 import jalview.util.Platform;
  61
  62 public class AnnotationRenderer
  63 {
  64   private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32
  65
  66   private static final int CHAR_A = 'A'; // 65
  67
  68   private static final int CHAR_Z = 'Z'; // 90
  69
  70   /**
  71    * flag indicating if timing and redraw parameter info should be output
  72    */
  73   private final boolean debugRedraw;
  74
  75   private int charWidth, endRes, charHeight;
  76
  77   private boolean validCharWidth, hasHiddenColumns;
  78
  79   private FontMetrics fm;
  80
  81   private final boolean USE_FILL_ROUND_RECT = Platform.isAMacAndNotJS();
  82
  83   boolean av_renderHistogram = true, av_renderProfile = true,
  84           av_normaliseProfile = false;
  85
  86   ResidueShaderI profcolour = null;
  87
  88   private ColumnSelection columnSelection;
  89
  90   private HiddenColumns hiddenColumns;
  91
  92   private ProfilesI hconsensus;
  93
  94   private Hashtable<String, Object>[] complementConsensus;
  95
  96   private Hashtable<String, Object>[] hStrucConsensus;
  97
  98   private boolean av_ignoreGapsConsensus;
  99
 100   private boolean renderingVectors = false;
 101
 102   private boolean glyphLineDrawn = false;
 103
 104   /**
 105    * attributes set from AwtRenderPanelI
 106    */
 107   /**
 108    * old image used when data is currently being calculated and cannot be
 109    * rendered
 110    */
 111   private Image fadedImage;
 112
 113   /**
 114    * panel being rendered into
 115    */
 116   private ImageObserver annotationPanel;
 117
 118   /**
 119    * width of image to render in panel
 120    */
 121   private int imgWidth;
 122
 123   /**
 124    * offset to beginning of visible area
 125    */
 126   private int sOffset;
 127
 128   /**
 129    * offset to end of visible area
 130    */
 131   private int visHeight;
 132
 133   /**
 134    * indicate if the renderer should only render the visible portion of the
 135    * annotation given the current view settings
 136    */
 137   private boolean useClip = true;
 138
 139   /**
 140    * master flag indicating if renderer should ever try to clip. not enabled for
 141    * jalview 2.8.1
 142    */
 143   private boolean canClip = false;
 144
 145   /**
 146    * Property to set text antialiasing method
 147    */
 148   private static final String TEXT_ANTIALIAS_METHOD = "TEXT_ANTIALIAS_METHOD";
 149
 150   private static final Object textAntialiasMethod;
 151
 152   static
 153   {
 154     final String textAntialiasMethodPref = Cache
 155             .getDefault(TEXT_ANTIALIAS_METHOD, "GASP");
 156     switch (textAntialiasMethodPref)
 157     {
 158     case "ON":
 159       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_ON;
 160       break;
 161     case "GASP":
 162       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
 163       break;
 164     case "LCD_HBGR":
 165       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR;
 166       break;
 167     case "LCD_HRGB":
 168       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB;
 169       break;
 170     case "LCD_VBGR":
 171       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR;
 172       break;
 173     case "LCD_VRGB":
 174       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB;
 175       break;
 176     case "OFF":
 177       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
 178       break;
 179     case "DEFAULT":
 180       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT;
 181       break;
 182     default:
 183       jalview.bin.Console.warn(TEXT_ANTIALIAS_METHOD + " value '"
 184               + textAntialiasMethodPref
 185               + "' not recognised, defaulting to 'GASP'. See https://docs.oracle.com/javase/8/docs/api/java/awt/RenderingHints.html#KEY_TEXT_ANTIALIASING");
 186       textAntialiasMethod = RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
 187     }
 188   }
 189
 190   public AnnotationRenderer()
 191   {
 192     this(false);
 193   }
 194
 195   /**
 196    * Create a new annotation Renderer
 197    *
 198    * @param debugRedraw
 199    *          flag indicating if timing and redraw parameter info should be
 200    *          output
 201    */
 202   public AnnotationRenderer(boolean debugRedraw)
 203   {
 204     this.debugRedraw = debugRedraw;
 205   }
 206
 207   /**
 208    * Remove any references and resources when this object is no longer required
 209    */
 210   public void dispose()
 211   {
 212     hiddenColumns = null;
 213     hconsensus = null;
 214     complementConsensus = null;
 215     hStrucConsensus = null;
 216     fadedImage = null;
 217     annotationPanel = null;
 218     rendererFactoryI = null;
 219   }
 220
 221   void drawStemAnnot(Graphics g, Annotation[] row_annotations, int lastSSX,
 222           int x, int y, int iconOffset, int startRes, int column,
 223           boolean validRes, boolean validEnd)
 224   {
 225     int sCol = (lastSSX / charWidth)
 226             + hiddenColumns.visibleToAbsoluteColumn(startRes);
 227     int x1 = lastSSX;
 228     int x2 = (x * charWidth);
 229
 230     char dc = (column == 0 || row_annotations[column - 1] == null) ? ' '
 231             : row_annotations[column - 1].secondaryStructure;
 232
 233     boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
 234             || dc != row_annotations[sCol - 1].secondaryStructure
 235             || !validEnd;
 236     boolean diffdownstream = !validRes || !validEnd
 237             || row_annotations[column] == null
 238             || dc != row_annotations[column].secondaryStructure;
 239
 240     if (diffupstream || diffdownstream)
 241     {
 242       // draw glyphline under arrow
 243       drawGlyphLine(g, lastSSX, x, y, iconOffset);
 244     }
 245     g.setColor(STEM_COLOUR);
 246
 247     if (column > 0 && Rna.isClosingParenthesis(dc))
 248     {
 249       if (diffupstream)
 250       // if (validRes && column>1 && row_annotations[column-2]!=null &&
 251       // dc.equals(row_annotations[column-2].displayCharacter))
 252       {
 253         /*
 254          * if new annotation with a closing base pair half of the stem,
 255          * display a backward arrow
 256          */
 257         fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
 258                 new int[]
 259                 { y + iconOffset + 1, y + 13 + iconOffset,
 260                     y + 7 + iconOffset },
 261                 3);
 262         x1 += 5;
 263       }
 264       if (diffdownstream)
 265       {
 266         x2 -= 1;
 267       }
 268     }
 269     else
 270     {
 271       // display a forward arrow
 272       if (diffdownstream)
 273       {
 274         /*
 275          * if annotation ending with an opeing base pair half of the stem,
 276          * display a forward arrow
 277          */
 278         fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 },
 279                 new int[]
 280                 { y + iconOffset + 1, y + 13 + iconOffset,
 281                     y + 7 + iconOffset },
 282                 3);
 283         x2 -= 5;
 284       }
 285       if (diffupstream)
 286       {
 287         x1 += 1;
 288       }
 289     }
 290     // draw arrow body
 291     unsetAntialias(g);
 292     fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
 293   }
 294
 295   void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
 296           Annotation[] row_annotations, int lastSSX, int x, int y,
 297           int iconOffset, int startRes, int column, boolean validRes,
 298           boolean validEnd)
 299   {
 300     // Console.info(nonCanColor);
 301
 302     int sCol = (lastSSX / charWidth)
 303             + hiddenColumns.visibleToAbsoluteColumn(startRes);
 304     int x1 = lastSSX;
 305     int x2 = (x * charWidth);
 306
 307     String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
 308             : row_annotations[column - 1].displayCharacter;
 309
 310     boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
 311             || !dc.equals(row_annotations[sCol - 1].displayCharacter)
 312             || !validEnd;
 313     boolean diffdownstream = !validRes || !validEnd
 314             || row_annotations[column] == null
 315             || !dc.equals(row_annotations[column].displayCharacter);
 316     // Console.info("Column "+column+" diff up:
 317     // "+diffupstream+"
 318     // down:"+diffdownstream);
 319     // If a closing base pair half of the stem, display a backward arrow
 320     if (diffupstream || diffdownstream)
 321     {
 322       // draw glyphline under arrow
 323       drawGlyphLine(g, lastSSX, x, y, iconOffset);
 324     }
 325     g.setColor(nonCanColor);
 326     if (column > 0 && Rna.isClosingParenthesis(dc))
 327     {
 328
 329       if (diffupstream)
 330       // if (validRes && column>1 && row_annotations[column-2]!=null &&
 331       // dc.equals(row_annotations[column-2].displayCharacter))
 332       {
 333         fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
 334                 new int[]
 335                 { y + iconOffset + 1, y + 13 + iconOffset,
 336                     y + 7 + iconOffset },
 337                 3);
 338         x1 += 5;
 339       }
 340       if (diffdownstream)
 341       {
 342         x2 -= 1;
 343       }
 344     }
 345     else
 346     {
 347
 348       // display a forward arrow
 349       if (diffdownstream)
 350       {
 351         fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 },
 352                 new int[]
 353                 { y + iconOffset + 1, y + 13 + iconOffset,
 354                     y + 7 + iconOffset },
 355                 3);
 356         x2 -= 5;
 357       }
 358       if (diffupstream)
 359       {
 360         x1 += 1;
 361       }
 362     }
 363     // draw arrow body
 364     unsetAntialias(g);
 365     fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
 366   }
 367
 368   // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
 369   // av)
 370   public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel,
 371           AlignViewportI av)
 372   {
 373     fm = annotPanel.getFontMetrics();
 374     annotationPanel = annotPanel;
 375     fadedImage = annotPanel.getFadedImage();
 376     imgWidth = annotPanel.getFadedImageWidth();
 377     // visible area for rendering
 378     int[] bounds = annotPanel.getVisibleVRange();
 379     if (bounds != null)
 380     {
 381       sOffset = bounds[0];
 382       visHeight = bounds[1];
 383       if (visHeight == 0)
 384       {
 385         useClip = false;
 386       }
 387       else
 388       {
 389         useClip = canClip;
 390       }
 391     }
 392     else
 393     {
 394       useClip = false;
 395     }
 396
 397     rendererFactoryI = AnnotationRendererFactory.getRendererFactory();
 398     updateFromAlignViewport(av);
 399   }
 400
 401   public void updateFromAlignViewport(AlignViewportI av)
 402   {
 403     charWidth = av.getCharWidth();
 404     endRes = av.getRanges().getEndRes();
 405     charHeight = av.getCharHeight();
 406     hasHiddenColumns = av.hasHiddenColumns();
 407     validCharWidth = av.isValidCharWidth();
 408     av_renderHistogram = av.isShowConsensusHistogram();
 409     av_renderProfile = av.isShowSequenceLogo();
 410     av_normaliseProfile = av.isNormaliseSequenceLogo();
 411     profcolour = av.getResidueShading();
 412     if (profcolour == null || profcolour.getColourScheme() == null)
 413     {
 414       /*
 415        * Use default colour for sequence logo if
 416        * the alignment has no colourscheme set
 417        * (would like to use user preference but n/a for applet)
 418        */
 419       ColourSchemeI col = av.getAlignment().isNucleotide()
 420               ? new NucleotideColourScheme()
 421               : new ZappoColourScheme();
 422       profcolour = new ResidueShader(col);
 423     }
 424     columnSelection = av.getColumnSelection();
 425     hiddenColumns = av.getAlignment().getHiddenColumns();
 426     hconsensus = av.getSequenceConsensusHash();
 427     complementConsensus = av.getComplementConsensusHash();
 428     hStrucConsensus = av.getRnaStructureConsensusHash();
 429     av_ignoreGapsConsensus = av.isIgnoreGapsConsensus();
 430   }
 431
 432   /**
 433    * Returns profile data; the first element is the profile type, the second is
 434    * the number of distinct values, the third the total count, and the remainder
 435    * depend on the profile type.
 436    *
 437    * @param aa
 438    * @param column
 439    * @return
 440    */
 441   int[] getProfileFor(AlignmentAnnotation aa, int column)
 442   {
 443     // TODO : consider refactoring the global alignment calculation
 444     // properties/rendering attributes as a global 'alignment group' which holds
 445     // all vis settings for the alignment as a whole rather than a subset
 446     //
 447     if (aa.autoCalculated && (aa.label.startsWith("Consensus")
 448             || aa.label.startsWith("cDNA Consensus")))
 449     {
 450       boolean forComplement = aa.label.startsWith("cDNA Consensus");
 451       if (aa.groupRef != null && aa.groupRef.consensusData != null
 452               && aa.groupRef.isShowSequenceLogo())
 453       {
 454         // TODO? group consensus for cDNA complement
 455         return AAFrequency.extractProfile(
 456                 aa.groupRef.consensusData.get(column),
 457                 aa.groupRef.getIgnoreGapsConsensus());
 458       }
 459       // TODO extend annotation row to enable dynamic and static profile data to
 460       // be stored
 461       if (aa.groupRef == null && aa.sequenceRef == null)
 462       {
 463         if (forComplement)
 464         {
 465           return AAFrequency.extractCdnaProfile(complementConsensus[column],
 466                   av_ignoreGapsConsensus);
 467         }
 468         else
 469         {
 470           return AAFrequency.extractProfile(hconsensus.get(column),
 471                   av_ignoreGapsConsensus);
 472         }
 473       }
 474     }
 475     else
 476     {
 477       if (aa.autoCalculated && aa.label.startsWith("StrucConsensus"))
 478       {
 479         // TODO implement group structure consensus
 480         /*
 481          * if (aa.groupRef != null && aa.groupRef.consensusData != null &&
 482          * aa.groupRef.isShowSequenceLogo()) { //TODO check what happens for
 483          * group selections return StructureFrequency.extractProfile(
 484          * aa.groupRef.consensusData[column], aa.groupRef
 485          * .getIgnoreGapsConsensus()); }
 486          */
 487         // TODO extend annotation row to enable dynamic and static profile data
 488         // to
 489         // be stored
 490         if (aa.groupRef == null && aa.sequenceRef == null
 491                 && hStrucConsensus != null
 492                 && hStrucConsensus.length > column)
 493         {
 494           return StructureFrequency.extractProfile(hStrucConsensus[column],
 495                   av_ignoreGapsConsensus);
 496         }
 497       }
 498     }
 499     return null;
 500   }
 501
 502   boolean rna = false;
 503
 504   private AnnotationRendererFactoryI rendererFactoryI;
 505
 506   /**
 507    * Render the annotation rows associated with an alignment.
 508    *
 509    * @param annotPanel
 510    *          container frame
 511    * @param av
 512    *          data and view settings to render
 513    * @param g
 514    *          destination for graphics
 515    * @param activeRow
 516    *          row where a mouse event occured (or -1)
 517    * @param startRes
 518    *          first column that will be drawn
 519    * @param endRes
 520    *          last column that will be drawn
 521    * @return true if the fadedImage was used for any alignment annotation rows
 522    *         currently being calculated
 523    */
 524   public boolean drawComponent(AwtRenderPanelI annotPanel,
 525           AlignViewportI av, Graphics g, int activeRow, int startRes,
 526           int endRes)
 527   {
 528     if (g instanceof EpsGraphics2D || g instanceof SVGGraphics2D)
 529     {
 530       this.setVectorRendering(true);
 531     }
 532     Graphics2D g2d = (Graphics2D) g;
 533
 534     long stime = System.currentTimeMillis();
 535     boolean usedFaded = false;
 536     // NOTES:
 537     // AnnotationPanel needs to implement: ImageObserver, access to
 538     // AlignViewport
 539     updateFromAwtRenderPanel(annotPanel, av);
 540     fm = g.getFontMetrics();
 541     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 542     // int temp = 0;
 543     if (aa == null)
 544     {
 545       return false;
 546     }
 547     int x = 0, y = 0;
 548     int column = 0;
 549     char lastSS;
 550     int lastSSX;
 551     int iconOffset = 0;
 552     boolean validRes = false;
 553     boolean validEnd = false;
 554     boolean labelAllCols = false;
 555     // boolean centreColLabels;
 556     // boolean centreColLabelsDef = av.isCentreColumnLabels();
 557     boolean scaleColLabel = false;
 558     final AlignmentAnnotation consensusAnnot = av
 559             .getAlignmentConsensusAnnotation();
 560     final AlignmentAnnotation structConsensusAnnot = av
 561             .getAlignmentStrucConsensusAnnotation();
 562     final AlignmentAnnotation complementConsensusAnnot = av
 563             .getComplementConsensusAnnotation();
 564
 565     BitSet graphGroupDrawn = new BitSet();
 566     // \u03B2 \u03B1
 567     // debug ints
 568     int yfrom = 0, f_i = 0, yto = 0, f_to = 0;
 569     boolean clipst = false, clipend = false;
 570     for (int i = 0; i < aa.length; i++)
 571     {
 572       AlignmentAnnotation row = aa[i];
 573       boolean renderHistogram = true;
 574       boolean renderProfile = false;
 575       boolean normaliseProfile = false;
 576       boolean isRNA = row.isRNA();
 577
 578       // check if this is a consensus annotation row and set the display
 579       // settings appropriately
 580       // TODO: generalise this to have render styles for consensus/profile
 581       // data
 582       if (row.groupRef != null && row == row.groupRef.getConsensus())
 583       {
 584         renderHistogram = row.groupRef.isShowConsensusHistogram();
 585         renderProfile = row.groupRef.isShowSequenceLogo();
 586         normaliseProfile = row.groupRef.isNormaliseSequenceLogo();
 587       }
 588       else if (row == consensusAnnot || row == structConsensusAnnot
 589               || row == complementConsensusAnnot)
 590       {
 591         renderHistogram = av_renderHistogram;
 592         renderProfile = av_renderProfile;
 593         normaliseProfile = av_normaliseProfile;
 594       }
 595
 596       Annotation[] row_annotations = row.annotations;
 597       if (!row.visible)
 598       {
 599         continue;
 600       }
 601       // centreColLabels = row.centreColLabels || centreColLabelsDef;
 602       labelAllCols = row.showAllColLabels;
 603       scaleColLabel = row.scaleColLabel;
 604       lastSS = ' ';
 605       lastSSX = 0;
 606
 607       if (!useClip || ((y - charHeight) < visHeight
 608               && (y + row.height + charHeight * 2) >= sOffset))
 609       {// if_in_visible_region
 610         if (!clipst)
 611         {
 612           clipst = true;
 613           yfrom = y;
 614           f_i = i;
 615         }
 616         yto = y;
 617         f_to = i;
 618         if (row.graph > 0)
 619         {
 620           if (row.graphGroup > -1 && graphGroupDrawn.get(row.graphGroup))
 621           {
 622             continue;
 623           }
 624
 625           // this is so that we draw the characters below the graph
 626           y += row.height;
 627
 628           if (row.hasText)
 629           {
 630             iconOffset = charHeight - fm.getDescent();
 631             y -= charHeight;
 632           }
 633         }
 634         else if (row.hasText)
 635         {
 636           iconOffset = charHeight - fm.getDescent();
 637
 638         }
 639         else
 640         {
 641           iconOffset = 0;
 642         }
 643
 644         if (row.autoCalculated && av.isCalculationInProgress(row))
 645         {
 646           y += charHeight;
 647           usedFaded = true;
 648           g.drawImage(fadedImage, 0, y - row.height, imgWidth, y, 0,
 649                   y - row.height, imgWidth, y, annotationPanel);
 650           g.setColor(Color.black);
 651           // g.drawString("Calculating "+aa[i].label+"....",20, y-row.height/2);
 652
 653           continue;
 654         }
 655
 656         /*
 657          * else if (annotationPanel.av.updatingConservation &&
 658          * aa[i].label.equals("Conservation")) {
 659          *
 660          * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y -
 661          * row.height, annotationPanel.imgWidth, y, 0, y - row.height,
 662          * annotationPanel.imgWidth, y, annotationPanel);
 663          *
 664          * g.setColor(Color.black); //
 665          * g.drawString("Calculating Conservation.....",20, y-row.height/2);
 666          *
 667          * continue; } else if (annotationPanel.av.updatingConservation &&
 668          * aa[i].label.equals("Quality")) {
 669          *
 670          * y += charHeight; g.drawImage(annotationPanel.fadedImage, 0, y -
 671          * row.height, annotationPanel.imgWidth, y, 0, y - row.height,
 672          * annotationPanel.imgWidth, y, annotationPanel);
 673          * g.setColor(Color.black); // /
 674          * g.drawString("Calculating Quality....",20, y-row.height/2);
 675          *
 676          * continue; }
 677          */
 678
 679         // first pass sets up state for drawing continuation from left-hand
 680         // column
 681         // of startRes
 682
 683         // flag used for vector rendition
 684         this.glyphLineDrawn = false;
 685         x = (startRes == 0) ? 0 : -1;
 686
 687         while (x < endRes - startRes)
 688         {
 689           if (hasHiddenColumns)
 690           {
 691             column = hiddenColumns.visibleToAbsoluteColumn(startRes + x);
 692             if (column > row_annotations.length - 1)
 693             {
 694               break;
 695             }
 696           }
 697           else
 698           {
 699             column = startRes + x;
 700           }
 701
 702           if ((row_annotations == null)
 703                   || (row_annotations.length <= column)
 704                   || (row_annotations[column] == null))
 705           {
 706             validRes = false;
 707           }
 708           else
 709           {
 710             validRes = true;
 711           }
 712           final String displayChar = validRes
 713                   ? row_annotations[column].displayCharacter
 714                   : null;
 715           if (x > -1)
 716           {
 717             unsetAntialias(g);
 718             if (activeRow == i)
 719             {
 720               g.setColor(Color.red);
 721
 722               if (columnSelection != null)
 723               {
 724                 if (columnSelection.contains(column))
 725                 {
 726                   fillRect(g, x * charWidth, y, charWidth, charHeight);
 727                 }
 728               }
 729             }
 730             if (row.getInvalidStrucPos() > x)
 731             {
 732               g.setColor(Color.orange);
 733               fillRect(g, x * charWidth, y, charWidth, charHeight);
 734             }
 735             else if (row.getInvalidStrucPos() == x)
 736             {
 737               g.setColor(Color.orange.darker());
 738               fillRect(g, x * charWidth, y, charWidth, charHeight);
 739             }
 740             if (validCharWidth && validRes && displayChar != null
 741                     && (displayChar.length() > 0))
 742             {
 743               float fmWidth = fm.stringWidth(displayChar);
 744
 745               /*
 746                * shrink label width to fit in column, if that is
 747                * both configured and necessary
 748                */
 749               boolean scaledToFit = false;
 750               float fmScaling = 1f;
 751               if (scaleColLabel && fmWidth > charWidth)
 752               {
 753                 scaledToFit = true;
 754                 fmScaling = (float) charWidth / fmWidth;
 755                 // and update the label's width to reflect the scaling.
 756                 fmWidth = charWidth;
 757               }
 758
 759               float charOffset = (charWidth - fmWidth) / 2f;
 760
 761               if (row_annotations[column].colour == null)
 762               {
 763                 g2d.setColor(Color.black);
 764               }
 765               else
 766               {
 767                 g2d.setColor(row_annotations[column].colour);
 768               }
 769
 770               /*
 771                * draw the label, unless it is the same secondary structure
 772                * symbol (excluding RNA Helix) as the previous column
 773                */
 774               final float xPos = (x * charWidth) + charOffset;
 775               final float yPos = y + iconOffset;
 776
 777               // Act on a copy of the Graphics2d object
 778               Graphics2D g2dCopy = (Graphics2D) g2d.create();
 779               // Clip to this annotation line (particularly width).
 780               // This removes artifacts from text when side scrolling
 781               // (particularly in wrap format), but can result in clipped
 782               // characters until a full paint is drawn.
 783               g2dCopy.setClip(0, (int) yPos - charHeight, imgWidth - 1,
 784                       charHeight);
 785               /*
 786                * translate to drawing position _before_ applying any scaling
 787                */
 788               g2dCopy.translate(xPos, yPos);
 789               if (scaledToFit)
 790               {
 791                 /*
 792                  * use a scaling transform to make the label narrower
 793                  * (JalviewJS doesn't have Font.deriveFont(AffineTransform))
 794                  */
 795                 g2dCopy.transform(
 796                         AffineTransform.getScaleInstance(fmScaling, 1.0));
 797               }
 798               setAntialias(g2dCopy, true);
 799               if (column == 0 || row.graph > 0)
 800               {
 801                 g2dCopy.drawString(displayChar, 0, 0);
 802               }
 803               else if (row_annotations[column - 1] == null || (labelAllCols
 804                       || !displayChar.equals(
 805                               row_annotations[column - 1].displayCharacter)
 806                       || (displayChar.length() < 2
 807                               && row_annotations[column].secondaryStructure == ' ')))
 808               {
 809                 g2dCopy.drawString(displayChar, 0, 0);
 810               }
 811               g2dCopy.dispose();
 812             }
 813           }
 814           if (row.hasIcons)
 815           {
 816             char ss = validRes ? row_annotations[column].secondaryStructure
 817                     : '-';
 818
 819             if (ss == '(')
 820             {
 821               // distinguish between forward/backward base-pairing
 822               if (displayChar.indexOf(')') > -1)
 823               {
 824
 825                 ss = ')';
 826
 827               }
 828             }
 829             if (ss == '[')
 830             {
 831               if ((displayChar.indexOf(']') > -1))
 832               {
 833                 ss = ']';
 834
 835               }
 836             }
 837             if (ss == '{')
 838             {
 839               // distinguish between forward/backward base-pairing
 840               if (displayChar.indexOf('}') > -1)
 841               {
 842                 ss = '}';
 843
 844               }
 845             }
 846             if (ss == '<')
 847             {
 848               // distinguish between forward/backward base-pairing
 849               if (displayChar.indexOf('<') > -1)
 850               {
 851                 ss = '>';
 852
 853               }
 854             }
 855             if (isRNA && (ss >= CHAR_A) && (ss <= CHAR_Z))
 856             {
 857               // distinguish between forward/backward base-pairing
 858               int ssLowerCase = ss + UPPER_TO_LOWER;
 859               // TODO would .equals() be safer here? or charAt(0)?
 860               if (displayChar.indexOf(ssLowerCase) > -1)
 861               {
 862                 ss = (char) ssLowerCase;
 863               }
 864             }
 865
 866             if (!validRes || (ss != lastSS))
 867             {
 868
 869               if (x > 0)
 870               {
 871
 872                 // int nb_annot = x - temp;
 873                 // Console.info("\t type :"+lastSS+"\t x
 874                 // :"+x+"\t nbre
 875                 // annot :"+nb_annot);
 876                 switch (lastSS)
 877                 {
 878                 case '(': // Stem case for RNA secondary structure
 879                 case ')': // and opposite direction
 880                   drawStemAnnot(g, row_annotations, lastSSX, x, y,
 881                           iconOffset, startRes, column, validRes, validEnd);
 882                   // temp = x;
 883                   break;
 884
 885                 case 'H':
 886                   if (!isRNA)
 887                   {
 888                     drawHelixAnnot(g, row_annotations, lastSSX, x, y,
 889                             iconOffset, startRes, column, validRes,
 890                             validEnd);
 891                     break;
 892                   }
 893                   // no break if isRNA - falls through to drawNotCanonicalAnnot!
 894                 case 'E':
 895                   if (!isRNA)
 896                   {
 897                     drawSheetAnnot(g, row_annotations, lastSSX, x, y,
 898                             iconOffset, startRes, column, validRes,
 899                             validEnd);
 900                     break;
 901                   }
 902                   // no break if isRNA - fall through to drawNotCanonicalAnnot!
 903
 904                 case '{':
 905                 case '}':
 906                 case '[':
 907                 case ']':
 908                 case '>':
 909                 case '<':
 910                 case 'A':
 911                 case 'a':
 912                 case 'B':
 913                 case 'b':
 914                 case 'C':
 915                 case 'c':
 916                 case 'D':
 917                 case 'd':
 918                 case 'e':
 919                 case 'F':
 920                 case 'f':
 921                 case 'G':
 922                 case 'g':
 923                 case 'h':
 924                 case 'I':
 925                 case 'i':
 926                 case 'J':
 927                 case 'j':
 928                 case 'K':
 929                 case 'k':
 930                 case 'L':
 931                 case 'l':
 932                 case 'M':
 933                 case 'm':
 934                 case 'N':
 935                 case 'n':
 936                 case 'O':
 937                 case 'o':
 938                 case 'P':
 939                 case 'p':
 940                 case 'Q':
 941                 case 'q':
 942                 case 'R':
 943                 case 'r':
 944                 case 'S':
 945                 case 's':
 946                 case 'T':
 947                 case 't':
 948                 case 'U':
 949                 case 'u':
 950                 case 'V':
 951                 case 'v':
 952                 case 'W':
 953                 case 'w':
 954                 case 'X':
 955                 case 'x':
 956                 case 'Y':
 957                 case 'y':
 958                 case 'Z':
 959                 case 'z':
 960
 961                   Color nonCanColor = getNotCanonicalColor(lastSS);
 962                   drawNotCanonicalAnnot(g, nonCanColor, row_annotations,
 963                           lastSSX, x, y, iconOffset, startRes, column,
 964                           validRes, validEnd);
 965                   // temp = x;
 966                   break;
 967                 default:
 968                   if (isVectorRendering())
 969                   {
 970                     // draw single full width glyphline
 971                     drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
 972                     // disable more glyph lines
 973                     this.glyphLineDrawn = true;
 974                   }
 975                   else
 976                   {
 977                     drawGlyphLine(g, lastSSX, x, y, iconOffset);
 978                   }
 979                   break;
 980                 }
 981               }
 982               if (validRes)
 983               {
 984                 lastSS = ss;
 985               }
 986               else
 987               {
 988                 lastSS = ' ';
 989               }
 990               if (x > -1)
 991               {
 992                 lastSSX = (x * charWidth);
 993               }
 994             }
 995           }
 996           column++;
 997           x++;
 998         }
 999         if (column >= row_annotations.length)
1000         {
1001           column = row_annotations.length - 1;
1002           validEnd = false;
1003         }
1004         else
1005         {
1006           validEnd = true;
1007         }
1008         if ((row_annotations == null) || (row_annotations.length <= column)
1009                 || (row_annotations[column] == null))
1010         {
1011           validRes = false;
1012         }
1013         else
1014         {
1015           validRes = true;
1016         }
1017         // x ++;
1018
1019         if (row.hasIcons)
1020         {
1021           switch (lastSS)
1022           {
1023
1024           case 'H':
1025             if (!isRNA)
1026             {
1027               drawHelixAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
1028                       startRes, column, validRes, validEnd);
1029               break;
1030             }
1031             // no break if isRNA - fall through to drawNotCanonicalAnnot!
1032
1033           case 'E':
1034             if (!isRNA)
1035             {
1036               drawSheetAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
1037                       startRes, column, validRes, validEnd);
1038               break;
1039             }
1040             // no break if isRNA - fall through to drawNotCanonicalAnnot!
1041
1042           case '(':
1043           case ')': // Stem case for RNA secondary structure
1044
1045             drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
1046                     startRes, column, validRes, validEnd);
1047
1048             break;
1049           case '{':
1050           case '}':
1051           case '[':
1052           case ']':
1053           case '>':
1054           case '<':
1055           case 'A':
1056           case 'a':
1057           case 'B':
1058           case 'b':
1059           case 'C':
1060           case 'c':
1061           case 'D':
1062           case 'd':
1063           case 'e':
1064           case 'F':
1065           case 'f':
1066           case 'G':
1067           case 'g':
1068           case 'h':
1069           case 'I':
1070           case 'i':
1071           case 'J':
1072           case 'j':
1073           case 'K':
1074           case 'k':
1075           case 'L':
1076           case 'l':
1077           case 'M':
1078           case 'm':
1079           case 'N':
1080           case 'n':
1081           case 'O':
1082           case 'o':
1083           case 'P':
1084           case 'p':
1085           case 'Q':
1086           case 'q':
1087           case 'R':
1088           case 'r':
1089           case 'T':
1090           case 't':
1091           case 'U':
1092           case 'u':
1093           case 'V':
1094           case 'v':
1095           case 'W':
1096           case 'w':
1097           case 'X':
1098           case 'x':
1099           case 'Y':
1100           case 'y':
1101           case 'Z':
1102           case 'z':
1103             // Console.info(lastSS);
1104             Color nonCanColor = getNotCanonicalColor(lastSS);
1105             drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX,
1106                     x, y, iconOffset, startRes, column, validRes, validEnd);
1107             break;
1108           default:
1109             if (isVectorRendering())
1110             {
1111               // draw single full width glyphline
1112               drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
1113               // disable more glyph lines
1114               this.glyphLineDrawn = true;
1115             }
1116             else
1117             {
1118               drawGlyphLine(g, lastSSX, x, y, iconOffset);
1119             }
1120             break;
1121           }
1122         }
1123
1124         if (row.graph > 0 && row.graphHeight > 0)
1125         {
1126           if (row.graph == AlignmentAnnotation.LINE_GRAPH)
1127           {
1128             if (row.graphGroup > -1 && !graphGroupDrawn.get(row.graphGroup))
1129             {
1130               // TODO: JAL-1291 revise rendering model so the graphGroup map is
1131               // computed efficiently for all visible labels
1132               float groupmax = -999999, groupmin = 9999999;
1133               for (int gg = 0; gg < aa.length; gg++)
1134               {
1135                 if (aa[gg].graphGroup != row.graphGroup)
1136                 {
1137                   continue;
1138                 }
1139
1140                 if (aa[gg] != row)
1141                 {
1142                   aa[gg].visible = false;
1143                 }
1144                 if (aa[gg].graphMax > groupmax)
1145                 {
1146                   groupmax = aa[gg].graphMax;
1147                 }
1148                 if (aa[gg].graphMin < groupmin)
1149                 {
1150                   groupmin = aa[gg].graphMin;
1151                 }
1152               }
1153
1154               for (int gg = 0; gg < aa.length; gg++)
1155               {
1156                 if (aa[gg].graphGroup == row.graphGroup)
1157                 {
1158                   drawLineGraph(g, aa[gg], aa[gg].annotations, startRes,
1159                           endRes, y, groupmin, groupmax, row.graphHeight);
1160                 }
1161               }
1162
1163               graphGroupDrawn.set(row.graphGroup);
1164             }
1165             else
1166             {
1167               drawLineGraph(g, row, row_annotations, startRes, endRes, y,
1168                       row.graphMin, row.graphMax, row.graphHeight);
1169             }
1170           }
1171           else if (row.graph == AlignmentAnnotation.BAR_GRAPH)
1172           {
1173             drawBarGraph(g, row, row_annotations, startRes, endRes,
1174                     row.graphMin, row.graphMax, y, renderHistogram,
1175                     renderProfile, normaliseProfile);
1176           }
1177           else
1178           {
1179             AnnotationRowRendererI renderer = rendererFactoryI
1180                     .getRendererFor(row);
1181             if (renderer != null)
1182             {
1183               renderer.renderRow(g, charWidth, charHeight, hasHiddenColumns,
1184                       av, hiddenColumns, columnSelection, row,
1185                       row_annotations, startRes, endRes, row.graphMin,
1186                       row.graphMax, y, isVectorRendering());
1187             }
1188             if (debugRedraw)
1189             {
1190               if (renderer == null)
1191               {
1192                 System.err
1193                         .println("No renderer found for " + row.toString());
1194               }
1195               else
1196               {
1197                 Console.warn(
1198                         "rendered with " + renderer.getClass().toString());
1199               }
1200             }
1201
1202           }
1203         }
1204       }
1205       else
1206       {
1207         if (clipst && !clipend)
1208         {
1209           clipend = true;
1210         }
1211       } // end if_in_visible_region
1212       if (row.graph > 0 && row.hasText)
1213       {
1214         y += charHeight;
1215       }
1216
1217       if (row.graph == 0)
1218       {
1219         y += aa[i].height;
1220       }
1221     }
1222     if (debugRedraw)
1223     {
1224       if (canClip)
1225       {
1226         if (clipst)
1227         {
1228           Console.warn("Start clip at : " + yfrom + " (index " + f_i + ")");
1229         }
1230         if (clipend)
1231         {
1232           Console.warn("End clip at : " + yto + " (index " + f_to + ")");
1233         }
1234       }
1235       ;
1236       Console.warn("Annotation Rendering time:"
1237               + (System.currentTimeMillis() - stime));
1238     }
1239     ;
1240
1241     return !usedFaded;
1242   }
1243
1244   public static final Color GLYPHLINE_COLOR = Color.gray;
1245
1246   public static final Color SHEET_COLOUR = Color.green;
1247
1248   public static final Color HELIX_COLOUR = Color.red;
1249
1250   public static final Color STEM_COLOUR = Color.blue;
1251
1252   // private Color sdNOTCANONICAL_COLOUR;
1253
1254   void drawGlyphLine(Graphics g, int lastSSX, int x, int y, int iconOffset)
1255   {
1256     if (glyphLineDrawn)
1257     {
1258       // if we've drawn a single long glyphline for an export, don't draw the
1259       // bits
1260       return;
1261     }
1262     unsetAntialias(g);
1263     g.setColor(GLYPHLINE_COLOR);
1264     g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
1265   }
1266
1267   void drawSheetAnnot(Graphics g, Annotation[] row,
1268
1269           int lastSSX, int x, int y, int iconOffset, int startRes,
1270           int column, boolean validRes, boolean validEnd)
1271   {
1272     if (!validEnd || !validRes || row == null || row[column] == null
1273             || row[column].secondaryStructure != 'E')
1274     {
1275       // draw the glyphline underneath
1276       drawGlyphLine(g, lastSSX, x, y, iconOffset);
1277
1278       g.setColor(SHEET_COLOUR);
1279       fillRect(g, lastSSX, y + 4 + iconOffset,
1280               (x * charWidth) - lastSSX - 4, 6);
1281       fillPolygon(g,
1282               new int[]
1283               { (x * charWidth) - 6, (x * charWidth) - 6,
1284                   (x * charWidth - 1) },
1285               new int[]
1286               { y + iconOffset + 1, y + 13 + iconOffset,
1287                   y + 7 + iconOffset },
1288               3);
1289     }
1290     else
1291     {
1292       g.setColor(SHEET_COLOUR);
1293       fillRect(g, lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX,
1294               6);
1295     }
1296   }
1297
1298   void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX, int x,
1299           int y, int iconOffset, int startRes, int column, boolean validRes,
1300           boolean validEnd)
1301   {
1302     int sCol = (lastSSX / charWidth)
1303             + hiddenColumns.visibleToAbsoluteColumn(startRes);
1304     int x1 = lastSSX;
1305     int x2 = (x * charWidth);
1306
1307     if (USE_FILL_ROUND_RECT || isVectorRendering())
1308     {
1309       // draw glyph line behind helix (visible in EPS or SVG output)
1310       drawGlyphLine(g, lastSSX, x, y, iconOffset);
1311
1312       g.setColor(HELIX_COLOUR);
1313       setAntialias(g);
1314       int ofs = charWidth / 2;
1315       // Off by 1 offset when drawing rects and ovals
1316       // to offscreen image on the MAC
1317       fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - 1, 8, 8, 8);
1318       if (sCol == 0 || row[sCol - 1] == null
1319               || row[sCol - 1].secondaryStructure != 'H')
1320       {
1321       }
1322       else
1323       {
1324         fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - ofs, 8, 0,
1325                 0);
1326       }
1327       if (!validRes || row[column] == null
1328               || row[column].secondaryStructure != 'H')
1329       {
1330
1331       }
1332       else
1333       {
1334         fillRoundRect(g, lastSSX + ofs, y + 3 + iconOffset, x2 - x1 - ofs,
1335                 8, 0, 0);
1336       }
1337
1338       return;
1339     }
1340
1341     boolean leftEnd = sCol == 0 || row[sCol - 1] == null
1342             || row[sCol - 1].secondaryStructure != 'H';
1343     boolean rightEnd = !validRes || row[column] == null
1344             || row[column].secondaryStructure != 'H';
1345
1346     if (leftEnd || rightEnd)
1347     {
1348       drawGlyphLine(g, lastSSX, x, y, iconOffset);
1349     }
1350     g.setColor(HELIX_COLOUR);
1351
1352     if (leftEnd)
1353     {
1354       fillArc(g, lastSSX, y + 3 + iconOffset, charWidth, 8, 90, 180);
1355       x1 += charWidth / 2;
1356     }
1357
1358     if (rightEnd)
1359     {
1360       fillArc(g, ((x - 1) * charWidth), y + 3 + iconOffset, charWidth, 8,
1361               270, 180);
1362       x2 -= charWidth / 2;
1363     }
1364
1365     fillRect(g, x1, y + 3 + iconOffset, x2 - x1, 8);
1366   }
1367
1368   void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
1369           Annotation[] aa_annotations, int sRes, int eRes, int y, float min,
1370           float max, int graphHeight)
1371   {
1372     if (sRes > aa_annotations.length)
1373     {
1374       return;
1375     }
1376     Stroke roundStroke = new BasicStroke(1, BasicStroke.CAP_ROUND,
1377             BasicStroke.JOIN_ROUND);
1378     Stroke squareStroke = new BasicStroke(1, BasicStroke.CAP_SQUARE,
1379             BasicStroke.JOIN_MITER);
1380     Graphics2D g2d = (Graphics2D) g;
1381     Stroke prevStroke = g2d.getStroke();
1382     g2d.setStroke(roundStroke);
1383
1384     int x = 0;
1385
1386     // Adjustment for fastpaint to left
1387     if (eRes < endRes)
1388     {
1389       eRes++;
1390     }
1391
1392     eRes = Math.min(eRes, aa_annotations.length);
1393
1394     int y1 = y, y2 = y;
1395     float range = max - min;
1396
1397     // //Draw origin
1398     if (min < 0)
1399     {
1400       y2 = y - (int) ((0 - min / range) * graphHeight);
1401     }
1402
1403     g.setColor(Color.gray);
1404     drawLine(g, squareStroke, x * charWidth, y2, (eRes - sRes) * charWidth,
1405             y2);
1406
1407     if (sRes == 0)
1408     {
1409       x++;
1410     }
1411
1412     eRes = Math.min(eRes, aa_annotations.length);
1413
1414     int column;
1415     int aaMax = aa_annotations.length - 1;
1416
1417     while (x <= eRes - sRes)
1418     {
1419       column = sRes + x;
1420       if (hasHiddenColumns)
1421       {
1422         column = hiddenColumns.visibleToAbsoluteColumn(column);
1423       }
1424
1425       if (column > aaMax)
1426       {
1427         break;
1428       }
1429
1430       if (aa_annotations[column] == null)
1431       {
1432         x++;
1433         continue;
1434       }
1435
1436       if (aa_annotations[column].colour == null)
1437       {
1438         g.setColor(Color.black);
1439       }
1440       else
1441       {
1442         g.setColor(aa_annotations[column].colour);
1443       }
1444
1445       boolean previousValueExists = column > 0
1446               && aa_annotations[column - 1] != null;
1447       float previousValue = previousValueExists
1448               ? aa_annotations[column - 1].value
1449               : 0;
1450       float thisValue = aa_annotations[column].value;
1451       boolean nextValueExists = aa_annotations.length > column + 1
1452               && aa_annotations[column + 1] != null;
1453       float nextValue = nextValueExists ? aa_annotations[column + 1].value
1454               : 0;
1455
1456       // check for standalone value
1457       if (!previousValueExists && !nextValueExists)
1458       {
1459         y2 = y - yValueToPixelHeight(thisValue, min, range, graphHeight);
1460         drawLine(g, x * charWidth + charWidth / 4, y2,
1461                 x * charWidth + 3 * charWidth / 4, y2);
1462         x++;
1463         continue;
1464       }
1465
1466       if (!previousValueExists)
1467       {
1468         x++;
1469         continue;
1470       }
1471
1472       y1 = y - yValueToPixelHeight(previousValue, min, range, graphHeight);
1473       y2 = y - yValueToPixelHeight(thisValue, min, range, graphHeight);
1474
1475       if (x == 0)
1476       {
1477         // only draw an initial half-line
1478         drawLine(g, x * charWidth, y1 + (y2 - y1) / 2,
1479                 x * charWidth + charWidth / 2, y2);
1480
1481       }
1482       else if (x == eRes - sRes)
1483       {
1484         // this is one past the end to draw -- only draw a half line
1485         drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
1486                 x * charWidth - 1, y1 + (y2 - y1) / 2);
1487
1488       }
1489       else
1490       {
1491         drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
1492                 x * charWidth + charWidth / 2, y2);
1493       }
1494       x++;
1495     }
1496
1497     if (_aa.threshold != null)
1498     {
1499       g.setColor(_aa.threshold.colour);
1500       Graphics2D g2 = (Graphics2D) g;
1501       y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
1502       drawLine(g, dashedLine(charWidth), 0, y2, (eRes - sRes) * charWidth,
1503               y2);
1504     }
1505     g2d.setStroke(prevStroke);
1506   }
1507
1508   private static double log2 = Math.log(2);
1509
1510   // Cached dashed line Strokes
1511   private static Map<Integer, Stroke> dashedLineLookup = new HashMap<>();
1512
1513   /**
1514    * Returns a dashed line stroke as close to 6-4 pixels as fits within the
1515    * charWidth. This allows translations of multiples of charWidth without
1516    * disrupting the dashed line. The exact values are 0.6-0.4 proportions of
1517    * charWidth for charWidth under 16. For charWidth 16 or over, the number of
1518    * dashes doubles as charWidth doubles.
1519    *
1520    * @param charWidth
1521    * @return Stroke with appropriate dashed line fitting exactly within the
1522    *         charWidth
1523    */
1524   private static Stroke dashedLine(int charWidth)
1525   {
1526     if (!dashedLineLookup.containsKey(charWidth))
1527     {
1528       int power2 = charWidth >= 8 ? (int) (Math.log(charWidth) / log2) : 2;
1529       float width = ((float) charWidth) / ((float) Math.pow(2, power2 - 3));
1530       float segment1 = width * 0.6f;
1531       float segment2 = width - segment1;
1532       dashedLineLookup.put(charWidth, new BasicStroke(1,
1533               BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 3f, new float[]
1534               { segment1, segment2 }, 0f));
1535     }
1536     return dashedLineLookup.get(charWidth);
1537   }
1538
1539   private static int yValueToPixelHeight(float value, float min,
1540           float range, int graphHeight)
1541   {
1542     return (int) (((value - min) / range) * graphHeight);
1543   }
1544
1545   @SuppressWarnings("unused")
1546   void drawBarGraph(Graphics g, AlignmentAnnotation _aa,
1547           Annotation[] aa_annotations, int sRes, int eRes, float min,
1548           float max, int y, boolean renderHistogram, boolean renderProfile,
1549           boolean normaliseProfile)
1550   {
1551     if (sRes > aa_annotations.length)
1552     {
1553       return;
1554     }
1555     Font ofont = g.getFont();
1556     eRes = Math.min(eRes, aa_annotations.length);
1557
1558     int x = 0, y1 = y, y2 = y;
1559
1560     float range = max - min;
1561
1562     if (min < 0)
1563     {
1564       y2 = y - (int) ((0 - min / (range)) * _aa.graphHeight);
1565     }
1566
1567     g.setColor(Color.gray);
1568
1569     drawLine(g, x, y2, (eRes - sRes) * charWidth, y2);
1570
1571     int column;
1572     int aaMax = aa_annotations.length - 1;
1573     while (x < eRes - sRes)
1574     {
1575       column = sRes + x;
1576       if (hasHiddenColumns)
1577       {
1578         column = hiddenColumns.visibleToAbsoluteColumn(column);
1579       }
1580
1581       if (column > aaMax)
1582       {
1583         break;
1584       }
1585
1586       if (aa_annotations[column] == null)
1587       {
1588         x++;
1589         continue;
1590       }
1591       if (aa_annotations[column].colour == null)
1592       {
1593         g.setColor(Color.black);
1594       }
1595       else
1596       {
1597         g.setColor(aa_annotations[column].colour);
1598       }
1599
1600       y1 = y - (int) (((aa_annotations[column].value - min) / (range))
1601               * _aa.graphHeight);
1602
1603       if (renderHistogram)
1604       {
1605         if (y1 - y2 > 0)
1606         {
1607           fillRect(g, x * charWidth, y2, charWidth, y1 - y2);
1608         }
1609         else
1610         {
1611           fillRect(g, x * charWidth, y1, charWidth, y2 - y1);
1612         }
1613       }
1614       // draw profile if available
1615       if (renderProfile)
1616       {
1617
1618         /*
1619          * {profile type, #values, total count, char1, pct1, char2, pct2...}
1620          */
1621         int profl[] = getProfileFor(_aa, column);
1622
1623         // just try to draw the logo if profl is not null
1624         if (profl != null && profl[2] != 0)
1625         {
1626           boolean isStructureProfile = profl[0] == AlignmentAnnotation.STRUCTURE_PROFILE;
1627           boolean isCdnaProfile = profl[0] == AlignmentAnnotation.CDNA_PROFILE;
1628           float ht = normaliseProfile ? y - _aa.graphHeight : y1;
1629           final double normaliseFactor = normaliseProfile ? _aa.graphHeight
1630                   : (y2 - y1);
1631
1632           /**
1633            * Render a single base for a sequence profile, a base pair for
1634            * structure profile, and a triplet for a cdna profile
1635            */
1636           char[] dc = new char[isStructureProfile ? 2
1637                   : (isCdnaProfile ? 3 : 1)];
1638
1639           // lm is not necessary - we can just use fm - could be off by no more
1640           // than 0.5 px
1641           // LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g);
1642           // Console.info(asc + " " + dec + " " + (asc -
1643           // lm.getAscent())
1644           // + " " + (dec - lm.getDescent()));
1645
1646           double asc = fm.getAscent();
1647           double dec = fm.getDescent();
1648           double fht = fm.getHeight();
1649
1650           double scale = 1f / (normaliseProfile ? profl[2] : 100f);
1651           // float ofontHeight = 1f / fm.getAscent();// magnify to fill box
1652
1653           /*
1654            * Traverse the character(s)/percentage data in the array
1655            */
1656
1657           float ht2 = ht;
1658
1659           // profl[1] is the number of values in the profile
1660           for (int i = 0, c = 3, last = profl[1]; i < last; i++)
1661           {
1662
1663             String s;
1664             if (isStructureProfile)
1665             {
1666               // todo can we encode a structure pair as an int, like codons?
1667               dc[0] = (char) profl[c++];
1668               dc[1] = (char) profl[c++];
1669               s = new String(dc);
1670             }
1671             else if (isCdnaProfile)
1672             {
1673               CodingUtils.decodeCodon2(profl[c++], dc);
1674               s = new String(dc);
1675             }
1676             else
1677             {
1678               dc[0] = (char) profl[c++];
1679               s = new String(dc);
1680             }
1681             // next profl[] position is profile % for the character(s)
1682
1683             int percent = profl[c++];
1684             if (percent == 0)
1685             {
1686               // failsafe in case a count rounds down to 0%
1687               continue;
1688             }
1689             double newHeight = normaliseFactor * scale * percent;
1690
1691             /*
1692              * Set character colour as per alignment colour scheme; use the
1693              * codon translation if a cDNA profile
1694              */
1695             Color colour = null;
1696             if (isCdnaProfile)
1697             {
1698               final String codonTranslation = ResidueProperties
1699                       .codonTranslate(s);
1700               colour = profcolour.findColour(codonTranslation.charAt(0),
1701                       column, null);
1702             }
1703             else
1704             {
1705               colour = profcolour.findColour(dc[0], column, null);
1706             }
1707             g.setColor(colour == Color.white ? Color.lightGray : colour);
1708
1709             double sx = 1f * charWidth / fm.charsWidth(dc, 0, dc.length);
1710             double sy = newHeight / asc;
1711             double newAsc = asc * sy;
1712             double newDec = dec * sy;
1713             // it is not necessary to recalculate lm for the new font.
1714             // note: lm.getBaselineOffsets()[lm.getBaselineIndex()]) must be 0
1715             // by definition. Was:
1716             // int hght = (int) (ht + (newAsc - newDec);
1717             // - lm.getBaselineOffsets()[lm.getBaselineIndex()]));
1718
1719             if (Platform.isJS())
1720             {
1721               /*
1722                * SwingJS does not implement font.deriveFont()
1723                * so use a scaling transform to draw instead,
1724                * this is off by a very small amount
1725                */
1726               final int hght = (int) (ht2 + (newAsc - newDec));
1727               Graphics2D gg = (Graphics2D) g;
1728               int xShift = (int) Math.round(x * charWidth / sx);
1729               int yShift = (int) Math.round(hght / sy);
1730               gg.transform(AffineTransform.getScaleInstance(sx, sy));
1731               gg.drawString(s, xShift, yShift);
1732               gg.transform(
1733                       AffineTransform.getScaleInstance(1D / sx, 1D / sy));
1734               ht2 += newHeight;
1735             }
1736             else
1737             /**
1738              * Java only
1739              *
1740              * @j2sIgnore
1741              */
1742             {
1743               // Java ('normal') method is to scale the font to fit
1744
1745               final int hght = (int) (ht + (newAsc - newDec));
1746               Font font = ofont
1747                       .deriveFont(AffineTransform.getScaleInstance(sx, sy));
1748               g.setFont(font);
1749               g.drawChars(dc, 0, dc.length, x * charWidth, hght);
1750               g.setFont(ofont);
1751
1752               ht += newHeight;
1753             }
1754           }
1755         }
1756       }
1757       x++;
1758     }
1759     if (_aa.threshold != null)
1760     {
1761       g.setColor(_aa.threshold.colour);
1762       Stroke s = new BasicStroke(1, BasicStroke.CAP_SQUARE,
1763               BasicStroke.JOIN_ROUND, 3f, new float[]
1764               { 5f, 3f }, 0f);
1765
1766       y2 = (int) (y
1767               - ((_aa.threshold.value - min) / range) * _aa.graphHeight);
1768       drawLine(g, s, 0, y2, (eRes - sRes) * charWidth, y2);
1769     }
1770   }
1771
1772   // used by overview window
1773   public void drawGraph(Graphics g, AlignmentAnnotation _aa,
1774           Annotation[] aa_annotations, int width, int y, int sRes, int eRes)
1775   {
1776     eRes = Math.min(eRes, aa_annotations.length);
1777     g.setColor(Color.white);
1778     fillRect(g, 0, 0, width, y);
1779     g.setColor(new Color(0, 0, 180));
1780
1781     int x = 0, height;
1782
1783     for (int j = sRes; j < eRes; j++)
1784     {
1785       if (aa_annotations[j] != null)
1786       {
1787         if (aa_annotations[j].colour == null)
1788         {
1789           g.setColor(Color.black);
1790         }
1791         else
1792         {
1793           g.setColor(aa_annotations[j].colour);
1794         }
1795
1796         height = (int) ((aa_annotations[j].value / _aa.graphMax) * y);
1797         if (height > y)
1798         {
1799           height = y;
1800         }
1801
1802         fillRect(g, x, y - height, charWidth, height);
1803       }
1804       x += charWidth;
1805     }
1806   }
1807
1808   Color getNotCanonicalColor(char lastss)
1809   {
1810     switch (lastss)
1811     {
1812     case '{':
1813     case '}':
1814       return new Color(255, 125, 5);
1815
1816     case '[':
1817     case ']':
1818       return new Color(245, 115, 10);
1819
1820     case '>':
1821     case '<':
1822       return new Color(235, 135, 15);
1823
1824     case 'A':
1825     case 'a':
1826       return new Color(225, 105, 20);
1827
1828     case 'B':
1829     case 'b':
1830       return new Color(215, 145, 30);
1831
1832     case 'C':
1833     case 'c':
1834       return new Color(205, 95, 35);
1835
1836     case 'D':
1837     case 'd':
1838       return new Color(195, 155, 45);
1839
1840     case 'E':
1841     case 'e':
1842       return new Color(185, 85, 55);
1843
1844     case 'F':
1845     case 'f':
1846       return new Color(175, 165, 65);
1847
1848     case 'G':
1849     case 'g':
1850       return new Color(170, 75, 75);
1851
1852     case 'H':
1853     case 'h':
1854       return new Color(160, 175, 85);
1855
1856     case 'I':
1857     case 'i':
1858       return new Color(150, 65, 95);
1859
1860     case 'J':
1861     case 'j':
1862       return new Color(140, 185, 105);
1863
1864     case 'K':
1865     case 'k':
1866       return new Color(130, 55, 110);
1867
1868     case 'L':
1869     case 'l':
1870       return new Color(120, 195, 120);
1871
1872     case 'M':
1873     case 'm':
1874       return new Color(110, 45, 130);
1875
1876     case 'N':
1877     case 'n':
1878       return new Color(100, 205, 140);
1879
1880     case 'O':
1881     case 'o':
1882       return new Color(90, 35, 150);
1883
1884     case 'P':
1885     case 'p':
1886       return new Color(85, 215, 160);
1887
1888     case 'Q':
1889     case 'q':
1890       return new Color(75, 25, 170);
1891
1892     case 'R':
1893     case 'r':
1894       return new Color(65, 225, 180);
1895
1896     case 'S':
1897     case 's':
1898       return new Color(55, 15, 185);
1899
1900     case 'T':
1901     case 't':
1902       return new Color(45, 235, 195);
1903
1904     case 'U':
1905     case 'u':
1906       return new Color(35, 5, 205);
1907
1908     case 'V':
1909     case 'v':
1910       return new Color(25, 245, 215);
1911
1912     case 'W':
1913     case 'w':
1914       return new Color(15, 0, 225);
1915
1916     case 'X':
1917     case 'x':
1918       return new Color(10, 255, 235);
1919
1920     case 'Y':
1921     case 'y':
1922       return new Color(5, 150, 245);
1923
1924     case 'Z':
1925     case 'z':
1926       return new Color(0, 80, 255);
1927
1928     default:
1929       Console.info("This is not a interaction : " + lastss);
1930       return null;
1931
1932     }
1933   }
1934
1935   private void fillPolygon(Graphics g, int[] xpoints, int[] ypoints, int n)
1936   {
1937     setAntialias(g);
1938     g.fillPolygon(xpoints, ypoints, n);
1939   }
1940
1941   /*
1942   private void fillRect(Graphics g, int a, int b, int c, int d)
1943   {
1944     fillRect(g, false, a, b, c, d);
1945   }*/
1946
1947   private void fillRect(Graphics g, int a, int b, int c, int d)
1948   {
1949     unsetAntialias(g);
1950     g.fillRect(a, b, c, d);
1951   }
1952
1953   private void fillRoundRect(Graphics g, int a, int b, int c, int d, int e,
1954           int f)
1955   {
1956     setAntialias(g);
1957     g.fillRoundRect(a, b, c, d, e, f);
1958   }
1959
1960   private void fillArc(Graphics g, int a, int b, int c, int d, int e, int f)
1961   {
1962     setAntialias(g);
1963     g.fillArc(a, b, c, d, e, f);
1964   }
1965
1966   private void drawLine(Graphics g, Stroke s, int a, int b, int c, int d)
1967   {
1968     Graphics2D g2d = (Graphics2D) g;
1969     Stroke p = g2d.getStroke();
1970     g2d.setStroke(s);
1971     drawLine(g, a, b, c, d);
1972     g2d.setStroke(p);
1973   }
1974
1975   private void drawLine(Graphics g, int a, int b, int c, int d)
1976   {
1977     setAntialias(g);
1978     g.drawLine(a, b, c, d);
1979   }
1980
1981   private void setAntialias(Graphics g)
1982   {
1983     setAntialias(g, false);
1984   }
1985
1986   private void setAntialias(Graphics g, boolean text)
1987   {
1988     if (isVectorRendering())
1989     {
1990       // no need to antialias vector drawings
1991       return;
1992     }
1993     if (Cache.getDefault("ANTI_ALIAS", true))
1994     {
1995       Graphics2D g2d = (Graphics2D) g;
1996       if (text)
1997       {
1998         g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
1999                 this.textAntialiasMethod);
2000       }
2001       else
2002       {
2003         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
2004                 RenderingHints.VALUE_ANTIALIAS_ON);
2005       }
2006     }
2007   }
2008
2009   private void unsetAntialias(Graphics g)
2010   {
2011     if (isVectorRendering())
2012     {
2013       // no need to antialias vector drawings
2014       return;
2015     }
2016     Graphics2D g2d = (Graphics2D) g;
2017     g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
2018             RenderingHints.VALUE_ANTIALIAS_OFF);
2019   }
2020
2021   public void setVectorRendering(boolean b)
2022   {
2023     renderingVectors = b;
2024   }
2025
2026   public boolean isVectorRendering()
2027   {
2028     return renderingVectors;
2029   }
2030 }