src/jalview/appletgui/SequenceRenderer.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.appletgui;
  22
  23 import jalview.datamodel.SequenceGroup;
  24 import jalview.datamodel.SequenceI;
  25 import jalview.renderer.ResidueColourFinder;
  26 import jalview.renderer.seqfeatures.FeatureColourFinder;
  27
  28 import java.awt.Color;
  29 import java.awt.Font;
  30 import java.awt.FontMetrics;
  31 import java.awt.Graphics;
  32
  33 public class SequenceRenderer implements jalview.api.SequenceRenderer
  34 {
  35   final static int CHAR_TO_UPPER = 'A' - 'a';
  36
  37   AlignViewport av;
  38
  39   FontMetrics fm;
  40
  41   boolean renderGaps = true;
  42
  43   SequenceGroup[] allGroups = null;
  44
  45   Color resBoxColour;
  46
  47   Graphics graphics;
  48
  49   ResidueColourFinder resColourFinder;
  50
  51   public SequenceRenderer(AlignViewport av)
  52   {
  53     this.av = av;
  54     resColourFinder = new ResidueColourFinder();
  55   }
  56
  57   /**
  58    * DOCUMENT ME!
  59    *
  60    * @param b
  61    *          DOCUMENT ME!
  62    */
  63   public void prepare(Graphics g, boolean renderGaps)
  64   {
  65     graphics = g;
  66     fm = g.getFontMetrics();
  67
  68     this.renderGaps = renderGaps;
  69   }
  70
  71   /**
  72    * Get the residue colour at the given sequence position - as determined by
  73    * the sequence group colour (if any), else the colour scheme, possibly
  74    * overridden by a feature colour.
  75    *
  76    * @param seq
  77    * @param position
  78    * @param finder
  79    * @return
  80    */
  81   @Override
  82   public Color getResidueColour(final SequenceI seq, int position,
  83           FeatureColourFinder finder)
  84   {
  85     // TODO replace 8 or so code duplications with calls to this method
  86     // (refactored as needed)
  87     return resColourFinder.getResidueColour(av.getShowBoxes(),
  88             av.getResidueShading(),
  89             allGroups, seq, position, finder);
  90   }
  91
  92   public Color findSequenceColour(SequenceI seq, int i)
  93   {
  94     allGroups = av.getAlignment().findAllGroups(seq);
  95     drawBoxes(seq, i, i, 0);
  96     return resBoxColour;
  97   }
  98
  99   public void drawSequence(SequenceI seq, SequenceGroup[] sg, int start,
 100           int end, int y1)
 101   {
 102     if (seq == null)
 103     {
 104       return;
 105     }
 106
 107     allGroups = sg;
 108
 109     drawBoxes(seq, start, end, y1);
 110
 111     if (av.validCharWidth)
 112     {
 113       drawText(seq, start, end, y1);
 114     }
 115   }
 116
 117   public void drawBoxes(SequenceI seq, int start, int end, int y1)
 118   {
 119     int i = start;
 120     int length = seq.getLength();
 121
 122     int curStart = -1;
 123     int curWidth = av.getCharWidth(), avCharWidth = av.getCharWidth(),
 124             avCharHeight = av.getCharHeight();
 125
 126     Color resBoxColour = Color.white;
 127     Color tempColour = null;
 128     while (i <= end)
 129     {
 130       resBoxColour = Color.white;
 131       if (i < length)
 132       {
 133         SequenceGroup currentSequenceGroup = resColourFinder
 134                 .getCurrentSequenceGroup(allGroups, i);
 135         if (currentSequenceGroup != null)
 136         {
 137           if (currentSequenceGroup.getDisplayBoxes())
 138           {
 139             resBoxColour = resColourFinder.getBoxColour(
 140                     currentSequenceGroup.getGroupColourScheme(), seq,
 141                     i);
 142           }
 143         }
 144         else if (av.getShowBoxes())
 145         {
 146           resBoxColour = resColourFinder
 147                   .getBoxColour(av.getResidueShading(), seq, i);
 148         }
 149       }
 150
 151       if (resBoxColour != tempColour)
 152       {
 153         if (tempColour != null)
 154         {
 155           graphics.fillRect(avCharWidth * (curStart - start), y1, curWidth,
 156                   avCharHeight);
 157         }
 158         graphics.setColor(resBoxColour);
 159
 160         curStart = i;
 161         curWidth = avCharWidth;
 162         tempColour = resBoxColour;
 163
 164       }
 165       else
 166       {
 167         curWidth += avCharWidth;
 168       }
 169
 170       i++;
 171     }
 172
 173     graphics.fillRect(avCharWidth * (curStart - start), y1, curWidth,
 174             avCharHeight);
 175   }
 176
 177   public void drawText(SequenceI seq, int start, int end, int y1)
 178   {
 179     int avCharWidth = av.getCharWidth(), avCharHeight = av.getCharHeight();
 180     Font boldFont = null;
 181     boolean bold = false;
 182     if (av.isUpperCasebold())
 183     {
 184       boldFont = new Font(av.getFont().getName(), Font.BOLD, avCharHeight);
 185
 186       graphics.setFont(av.getFont());
 187     }
 188
 189     y1 += avCharHeight - avCharHeight / 5; // height/5 replaces pady
 190
 191     int charOffset = 0;
 192
 193     // Need to find the sequence position here.
 194     if (end + 1 >= seq.getLength())
 195     {
 196       end = seq.getLength() - 1;
 197     }
 198
 199     char s = ' ';
 200     boolean srep = av.isDisplayReferenceSeq();
 201     for (int i = start; i <= end; i++)
 202     {
 203       graphics.setColor(Color.black);
 204
 205       s = seq.getCharAt(i);
 206       if (!renderGaps && jalview.util.Comparison.isGap(s))
 207       {
 208         continue;
 209       }
 210
 211       SequenceGroup currentSequenceGroup = resColourFinder
 212               .getCurrentSequenceGroup(allGroups, i);
 213       if (currentSequenceGroup != null)
 214       {
 215         if (!currentSequenceGroup.getDisplayText())
 216         {
 217           continue;
 218         }
 219
 220         if (currentSequenceGroup.getColourText())
 221         {
 222           resBoxColour = resColourFinder.getBoxColour(
 223                   currentSequenceGroup.getGroupColourScheme(), seq, i);
 224           graphics.setColor(resBoxColour.darker());
 225         }
 226         if (currentSequenceGroup.getShowNonconserved())
 227         {
 228           s = getDisplayChar(srep, i, s, '.', currentSequenceGroup);
 229         }
 230       }
 231       else
 232       {
 233         if (!av.getShowText())
 234         {
 235           continue;
 236         }
 237
 238         if (av.getColourText())
 239         {
 240           resBoxColour = resColourFinder
 241                   .getBoxColour(av.getResidueShading(), seq, i);
 242           if (av.getShowBoxes())
 243           {
 244             graphics.setColor(resBoxColour.darker());
 245           }
 246           else
 247           {
 248             graphics.setColor(resBoxColour);
 249           }
 250         }
 251         if (av.getShowUnconserved())
 252         {
 253           s = getDisplayChar(srep, i, s, '.', null);
 254
 255         }
 256       }
 257
 258       if (av.isUpperCasebold())
 259       {
 260         fm = graphics.getFontMetrics();
 261         if ('A' <= s && s <= 'Z')
 262         {
 263           if (!bold)
 264           {
 265
 266             graphics.setFont(boldFont);
 267           }
 268           bold = true;
 269         }
 270         else if (bold)
 271         {
 272           graphics.setFont(av.font);
 273           bold = false;
 274         }
 275
 276       }
 277
 278       charOffset = (avCharWidth - fm.charWidth(s)) / 2;
 279       graphics.drawString(String.valueOf(s),
 280               charOffset + avCharWidth * (i - start), y1);
 281     }
 282
 283   }
 284
 285   /**
 286    * Returns 'conservedChar' to represent the given position if the sequence
 287    * character at that position is equal to the consensus (ignoring case), else
 288    * returns the sequence character
 289    *
 290    * @param usesrep
 291    * @param position
 292    * @param sequenceChar
 293    * @param conservedChar
 294    * @return
 295    */
 296   private char getDisplayChar(final boolean usesrep, int position,
 297           char sequenceChar, char conservedChar, SequenceGroup currentGroup)
 298   {
 299     // TODO - use currentSequenceGroup rather than alignment
 300     // currentSequenceGroup.getConsensus()
 301     char conschar = (usesrep) ? (currentGroup == null
 302             || position < currentGroup.getStartRes()
 303             || position > currentGroup.getEndRes()
 304                     ? av.getAlignment().getSeqrep().getCharAt(position)
 305                     : (currentGroup.getSeqrep() != null
 306                             ? currentGroup.getSeqrep().getCharAt(position)
 307                             : av.getAlignment().getSeqrep()
 308                                     .getCharAt(position)))
 309             : (currentGroup != null && currentGroup.getConsensus() != null
 310                     && position >= currentGroup.getStartRes()
 311                     && position <= currentGroup.getEndRes()
 312                     && currentGroup
 313                             .getConsensus().annotations.length > position)
 314                                     ? currentGroup
 315                                             .getConsensus().annotations[position].displayCharacter
 316                                                     .charAt(0)
 317                                     : av.getAlignmentConsensusAnnotation().annotations[position].displayCharacter
 318                                             .charAt(0);
 319     if (!jalview.util.Comparison.isGap(conschar)
 320             && (sequenceChar == conschar
 321                     || sequenceChar + CHAR_TO_UPPER == conschar))
 322     {
 323       sequenceChar = conservedChar;
 324     }
 325     return sequenceChar;
 326   }
 327
 328   public void drawHighlightedText(SequenceI seq, int start, int end,
 329           int x1, int y1)
 330   {
 331     int avCharWidth = av.getCharWidth(), avCharHeight = av.getCharHeight();
 332     int pady = avCharHeight / 5;
 333     int charOffset = 0;
 334     graphics.setColor(Color.black);
 335     graphics.fillRect(x1, y1, avCharWidth * (end - start + 1),
 336             avCharHeight);
 337     graphics.setColor(Color.white);
 338
 339     char s = '~';
 340     // Need to find the sequence position here.
 341     if (av.validCharWidth)
 342     {
 343       for (int i = start; i <= end; i++)
 344       {
 345         if (i < seq.getLength())
 346         {
 347           s = seq.getCharAt(i);
 348         }
 349
 350         charOffset = (avCharWidth - fm.charWidth(s)) / 2;
 351         graphics.drawString(String.valueOf(s),
 352                 charOffset + x1 + avCharWidth * (i - start),
 353                 y1 + avCharHeight - pady);
 354       }
 355     }
 356   }
 357
 358   public void drawCursor(SequenceI seq, int res, int x1, int y1)
 359   {
 360     int pady = av.getCharHeight() / 5;
 361     int charOffset = 0;
 362     graphics.setColor(Color.black);
 363     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
 364     graphics.setColor(Color.white);
 365
 366     graphics.setColor(Color.white);
 367
 368     char s = seq.getCharAt(res);
 369     if (av.validCharWidth)
 370     {
 371
 372       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
 373       graphics.drawString(String.valueOf(s), charOffset + x1,
 374               (y1 + av.getCharHeight()) - pady);
 375     }
 376   }
 377
 378 }