Merge branch 'releases/Release_2_11_4_Branch'
[jalview.git] / jalview / gui / 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.gui;
22
23 import jalview.api.AlignViewportI;
24 import jalview.datamodel.SequenceGroup;
25 import jalview.datamodel.SequenceI;
26 import jalview.renderer.ResidueShaderI;
27 import jalview.renderer.seqfeatures.FeatureColourFinder;
28 import jalview.util.Comparison;
29
30 import java.awt.Color;
31 import java.awt.FontMetrics;
32 import java.awt.Graphics;
33
34 public class SequenceRenderer implements jalview.api.SequenceRenderer
35 {
36   final static int CHAR_TO_UPPER = 'A' - 'a';
37
38   AlignViewportI av;
39
40   FontMetrics fm;
41
42   boolean renderGaps = true;
43
44   SequenceGroup currentSequenceGroup = null;
45
46   SequenceGroup[] allGroups = null;
47
48   Color resBoxColour;
49
50   Graphics graphics;
51
52   boolean monospacedFont;
53
54   boolean forOverview = false;
55
56   /**
57    * Creates a new SequenceRenderer object
58    * 
59    * @param viewport
60    */
61   public SequenceRenderer(AlignViewportI viewport)
62   {
63     this.av = viewport;
64   }
65
66   /**
67    * DOCUMENT ME!
68    * 
69    * @param b
70    *          DOCUMENT ME!
71    */
72   public void prepare(Graphics g, boolean renderGaps)
73   {
74     graphics = g;
75     fm = g.getFontMetrics();
76
77     // If EPS graphics, stringWidth will be a double, not an int
78     double dwidth = fm.getStringBounds("M", g).getWidth();
79
80     monospacedFont = (dwidth == fm.getStringBounds("|", g).getWidth() && av
81             .getCharWidth() == dwidth);
82
83     this.renderGaps = renderGaps;
84   }
85
86   protected Color getResidueBoxColour(SequenceI seq, int i)
87   {
88     // rate limiting step when rendering overview for lots of groups
89     allGroups = av.getAlignment().findAllGroups(seq);
90
91     if (inCurrentSequenceGroup(i))
92     {
93       if (currentSequenceGroup.getDisplayBoxes())
94       {
95         getBoxColour(currentSequenceGroup.getGroupColourScheme(), seq, i);
96       }
97     }
98     else if (av.getShowBoxes())
99     {
100       getBoxColour(av.getResidueShading(), seq, i);
101     }
102
103     return resBoxColour;
104   }
105
106   /**
107    * Get the residue colour at the given sequence position - as determined by
108    * the sequence group colour (if any), else the colour scheme, possibly
109    * overridden by a feature colour.
110    * 
111    * @param seq
112    * @param position
113    * @param finder
114    * @return
115    */
116   @Override
117   public Color getResidueColour(final SequenceI seq, int position,
118           FeatureColourFinder finder)
119   {
120     Color col = getResidueBoxColour(seq, position);
121
122     if (finder != null)
123     {
124       col = finder.findFeatureColour(col, seq, position);
125     }
126     return col;
127   }
128
129   /**
130    * DOCUMENT ME!
131    * 
132    * @param shader
133    *          DOCUMENT ME!
134    * @param seq
135    *          DOCUMENT ME!
136    * @param i
137    *          DOCUMENT ME!
138    */
139   void getBoxColour(ResidueShaderI shader, SequenceI seq, int i)
140   {
141     if (shader.getColourScheme() != null)
142     {
143       resBoxColour = shader.findColour(seq.getCharAt(i),
144               i, seq);
145     }
146     else if (forOverview && !Comparison.isGap(seq.getCharAt(i)))
147     {
148       resBoxColour = Color.lightGray;
149     }
150     else
151     {
152       resBoxColour = Color.white;
153     }
154   }
155
156   /**
157    * DOCUMENT ME!
158    * 
159    * @param g
160    *          DOCUMENT ME!
161    * @param seq
162    *          DOCUMENT ME!
163    * @param sg
164    *          DOCUMENT ME!
165    * @param start
166    *          DOCUMENT ME!
167    * @param end
168    *          DOCUMENT ME!
169    * @param x1
170    *          DOCUMENT ME!
171    * @param y1
172    *          DOCUMENT ME!
173    * @param width
174    *          DOCUMENT ME!
175    * @param height
176    *          DOCUMENT ME!
177    */
178   public void drawSequence(SequenceI seq, SequenceGroup[] sg, int start,
179           int end, int y1)
180   {
181     allGroups = sg;
182
183     drawBoxes(seq, start, end, y1);
184
185     if (av.isValidCharWidth())
186     {
187       drawText(seq, start, end, y1);
188     }
189   }
190
191   /**
192    * DOCUMENT ME!
193    * 
194    * @param seq
195    *          DOCUMENT ME!
196    * @param start
197    *          DOCUMENT ME!
198    * @param end
199    *          DOCUMENT ME!
200    * @param x1
201    *          DOCUMENT ME!
202    * @param y1
203    *          DOCUMENT ME!
204    * @param width
205    *          DOCUMENT ME!
206    * @param height
207    *          DOCUMENT ME!
208    */
209   public synchronized void drawBoxes(SequenceI seq, int start, int end,
210           int y1)
211   {
212     if (seq == null)
213     {
214       return; // fix for racecondition
215     }
216     int i = start;
217     int length = seq.getLength();
218
219     int curStart = -1;
220     int curWidth = av.getCharWidth(), avWidth = av.getCharWidth(), avHeight = av
221             .getCharHeight();
222
223     Color tempColour = null;
224
225     while (i <= end)
226     {
227       resBoxColour = Color.white;
228
229       if (i < length)
230       {
231         if (inCurrentSequenceGroup(i))
232         {
233           if (currentSequenceGroup.getDisplayBoxes())
234           {
235             getBoxColour(currentSequenceGroup.getGroupColourScheme(), seq,
236                     i);
237           }
238         }
239         else if (av.getShowBoxes())
240         {
241           getBoxColour(av.getResidueShading(), seq, i);
242         }
243       }
244
245       if (resBoxColour != tempColour)
246       {
247         if (tempColour != null)
248         {
249           graphics.fillRect(avWidth * (curStart - start), y1, curWidth,
250                   avHeight);
251         }
252
253         graphics.setColor(resBoxColour);
254
255         curStart = i;
256         curWidth = avWidth;
257         tempColour = resBoxColour;
258       }
259       else
260       {
261         curWidth += avWidth;
262       }
263
264       i++;
265     }
266
267     graphics.fillRect(avWidth * (curStart - start), y1, curWidth, avHeight);
268
269   }
270
271   /**
272    * DOCUMENT ME!
273    * 
274    * @param seq
275    *          DOCUMENT ME!
276    * @param start
277    *          DOCUMENT ME!
278    * @param end
279    *          DOCUMENT ME!
280    * @param x1
281    *          DOCUMENT ME!
282    * @param y1
283    *          DOCUMENT ME!
284    * @param width
285    *          DOCUMENT ME!
286    * @param height
287    *          DOCUMENT ME!
288    */
289   public void drawText(SequenceI seq, int start, int end, int y1)
290   {
291     y1 += av.getCharHeight() - av.getCharHeight() / 5; // height/5 replaces pady
292     int charOffset = 0;
293     char s;
294
295     if (end + 1 >= seq.getLength())
296     {
297       end = seq.getLength() - 1;
298     }
299     graphics.setColor(av.getTextColour());
300
301     if (monospacedFont && av.getShowText() && allGroups.length == 0
302             && !av.getColourText() && av.getThresholdTextColour() == 0)
303     {
304       if (av.isRenderGaps())
305       {
306         graphics.drawString(seq.getSequenceAsString(start, end + 1), 0, y1);
307       }
308       else
309       {
310         char gap = av.getGapCharacter();
311         graphics.drawString(seq.getSequenceAsString(start, end + 1)
312                 .replace(gap, ' '), 0, y1);
313       }
314     }
315     else
316     {
317       boolean srep = av.isDisplayReferenceSeq();
318       boolean getboxColour = false;
319       boolean isarep = av.getAlignment().getSeqrep() == seq;
320       boolean isgrep = currentSequenceGroup != null ? currentSequenceGroup
321               .getSeqrep() == seq : false;
322       char sr_c;
323       for (int i = start; i <= end; i++)
324       {
325
326         graphics.setColor(av.getTextColour());
327         getboxColour = false;
328         s = seq.getCharAt(i);
329
330         if (!renderGaps && jalview.util.Comparison.isGap(s))
331         {
332           continue;
333         }
334
335         if (inCurrentSequenceGroup(i))
336         {
337           if (!currentSequenceGroup.getDisplayText())
338           {
339             continue;
340           }
341
342           if (currentSequenceGroup.thresholdTextColour > 0
343                   || currentSequenceGroup.getColourText())
344           {
345             getboxColour = true;
346             getBoxColour(currentSequenceGroup.getGroupColourScheme(), seq,
347                     i);
348
349             if (currentSequenceGroup.getColourText())
350             {
351               graphics.setColor(resBoxColour.darker());
352             }
353
354             if (currentSequenceGroup.thresholdTextColour > 0)
355             {
356               if (resBoxColour.getRed() + resBoxColour.getBlue()
357                       + resBoxColour.getGreen() < currentSequenceGroup.thresholdTextColour)
358               {
359                 graphics.setColor(currentSequenceGroup.textColour2);
360               }
361             }
362           }
363           else
364           {
365             graphics.setColor(currentSequenceGroup.textColour);
366           }
367           if (!isarep && !isgrep
368                   && currentSequenceGroup.getShowNonconserved()) // todo
369                                                                  // optimize
370           {
371             // todo - use sequence group consensus
372             s = getDisplayChar(srep, i, s, '.', currentSequenceGroup);
373
374           }
375
376         }
377         else
378         {
379           if (!av.getShowText())
380           {
381             continue;
382           }
383
384           if (av.getColourText())
385           {
386             getboxColour = true;
387             getBoxColour(av.getResidueShading(), seq, i);
388
389             if (av.getShowBoxes())
390             {
391               graphics.setColor(resBoxColour.darker());
392             }
393             else
394             {
395               graphics.setColor(resBoxColour);
396             }
397           }
398
399           if (av.getThresholdTextColour() > 0)
400           {
401             if (!getboxColour)
402             {
403               getBoxColour(av.getResidueShading(), seq, i);
404             }
405
406             if (resBoxColour.getRed() + resBoxColour.getBlue()
407                     + resBoxColour.getGreen() < av.getThresholdTextColour())
408             {
409               graphics.setColor(av.getTextColour2());
410             }
411           }
412           if (!isarep && av.getShowUnconserved())
413           {
414             s = getDisplayChar(srep, i, s, '.', null);
415
416           }
417
418         }
419
420         charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
421         graphics.drawString(String.valueOf(s),
422                 charOffset + av.getCharWidth() * (i - start), y1);
423
424       }
425     }
426   }
427
428   /**
429    * Returns 'conservedChar' to represent the given position if the sequence
430    * character at that position is equal to the consensus (ignoring case), else
431    * returns the sequence character
432    * 
433    * @param usesrep
434    * @param position
435    * @param sequenceChar
436    * @param conservedChar
437    * @return
438    */
439   private char getDisplayChar(final boolean usesrep, int position,
440           char sequenceChar, char conservedChar, SequenceGroup currentGroup)
441   {
442     // TODO - use currentSequenceGroup rather than alignment
443     // currentSequenceGroup.getConsensus()
444     char conschar = (usesrep) ? (currentGroup == null
445             || position < currentGroup.getStartRes()
446             || position > currentGroup.getEndRes() ? av.getAlignment()
447             .getSeqrep().getCharAt(position)
448             : (currentGroup.getSeqrep() != null ? currentGroup.getSeqrep()
449                     .getCharAt(position) : av.getAlignment().getSeqrep()
450                     .getCharAt(position)))
451             : (currentGroup != null && currentGroup.getConsensus() != null
452                     && position >= currentGroup.getStartRes()
453                     && position <= currentGroup.getEndRes() && currentGroup
454                     .getConsensus().annotations.length > position) ? currentGroup
455                     .getConsensus().annotations[position].displayCharacter
456                     .charAt(0)
457                     : av.getAlignmentConsensusAnnotation().annotations[position].displayCharacter
458                             .charAt(0);
459     if (!jalview.util.Comparison.isGap(conschar)
460             && (sequenceChar == conschar || sequenceChar + CHAR_TO_UPPER == conschar))
461     {
462       sequenceChar = conservedChar;
463     }
464     return sequenceChar;
465   }
466
467   /**
468    * DOCUMENT ME!
469    * 
470    * @param res
471    *          DOCUMENT ME!
472    * 
473    * @return DOCUMENT ME!
474    */
475   boolean inCurrentSequenceGroup(int res)
476   {
477     if (allGroups == null)
478     {
479       return false;
480     }
481
482     for (int i = 0; i < allGroups.length; i++)
483     {
484       if ((allGroups[i].getStartRes() <= res)
485               && (allGroups[i].getEndRes() >= res))
486       {
487         currentSequenceGroup = allGroups[i];
488
489         return true;
490       }
491     }
492
493     return false;
494   }
495
496   /**
497    * DOCUMENT ME!
498    * 
499    * @param seq
500    *          DOCUMENT ME!
501    * @param start
502    *          DOCUMENT ME!
503    * @param end
504    *          DOCUMENT ME!
505    * @param x1
506    *          DOCUMENT ME!
507    * @param y1
508    *          DOCUMENT ME!
509    * @param width
510    *          DOCUMENT ME!
511    * @param height
512    *          DOCUMENT ME!
513    */
514   public void drawHighlightedText(SequenceI seq, int start, int end,
515           int x1, int y1)
516   {
517     int pady = av.getCharHeight() / 5;
518     int charOffset = 0;
519     graphics.setColor(Color.BLACK);
520     graphics.fillRect(x1, y1, av.getCharWidth() * (end - start + 1),
521             av.getCharHeight());
522     graphics.setColor(Color.white);
523
524     char s = '~';
525
526     // Need to find the sequence position here.
527     if (av.isValidCharWidth())
528     {
529       for (int i = start; i <= end; i++)
530       {
531         if (i < seq.getLength())
532         {
533           s = seq.getCharAt(i);
534         }
535
536         charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
537         graphics.drawString(String.valueOf(s),
538                 charOffset + x1 + (av.getCharWidth() * (i - start)),
539                 (y1 + av.getCharHeight()) - pady);
540       }
541     }
542   }
543
544   public void drawCursor(SequenceI seq, int res, int x1, int y1)
545   {
546     int pady = av.getCharHeight() / 5;
547     int charOffset = 0;
548     graphics.setColor(Color.black);
549     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
550
551     if (av.isValidCharWidth())
552     {
553       graphics.setColor(Color.white);
554
555       char s = seq.getCharAt(res);
556
557       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
558       graphics.drawString(String.valueOf(s), charOffset + x1,
559               (y1 + av.getCharHeight()) - pady);
560     }
561
562   }
563 }