Merge branch 'releases/Release_2_11_4_Branch'
[jalview.git] / 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.FeatureRenderer;
24 import jalview.datamodel.SequenceGroup;
25 import jalview.datamodel.SequenceI;
26 import jalview.schemes.ColourSchemeI;
27
28 import java.awt.Color;
29 import java.awt.FontMetrics;
30 import java.awt.Graphics;
31
32 public class SequenceRenderer implements jalview.api.SequenceRenderer
33 {
34   final static int CHAR_TO_UPPER = 'A' - 'a';
35
36   AlignViewport av;
37
38   FontMetrics fm;
39
40   boolean renderGaps = true;
41
42   SequenceGroup currentSequenceGroup = null;
43
44   SequenceGroup[] allGroups = null;
45
46   Color resBoxColour;
47
48   Graphics graphics;
49
50   boolean monospacedFont;
51
52   boolean forOverview = false;
53
54   /**
55    * Creates a new SequenceRenderer object.
56    * 
57    * @param av
58    *          DOCUMENT ME!
59    */
60   public SequenceRenderer(AlignViewport av)
61   {
62     this.av = av;
63   }
64
65   /**
66    * DOCUMENT ME!
67    * 
68    * @param b
69    *          DOCUMENT ME!
70    */
71   public void prepare(Graphics g, boolean renderGaps)
72   {
73     graphics = g;
74     fm = g.getFontMetrics();
75
76     // If EPS graphics, stringWidth will be a double, not an int
77     double dwidth = fm.getStringBounds("M", g).getWidth();
78
79     monospacedFont = (dwidth == fm.getStringBounds("|", g).getWidth() && av
80             .getCharWidth() == dwidth);
81
82     this.renderGaps = renderGaps;
83   }
84
85   @Override
86   public Color getResidueBoxColour(SequenceI seq, int i)
87   {
88     allGroups = av.getAlignment().findAllGroups(seq);
89
90     if (inCurrentSequenceGroup(i))
91     {
92       if (currentSequenceGroup.getDisplayBoxes())
93       {
94         getBoxColour(currentSequenceGroup.cs, seq, i);
95       }
96     }
97     else if (av.getShowBoxes())
98     {
99       getBoxColour(av.getGlobalColourScheme(), seq, i);
100     }
101
102     return resBoxColour;
103   }
104
105   /**
106    * Get the residue colour at the given sequence position - as determined by
107    * the sequence group colour (if any), else the colour scheme, possibly
108    * overridden by a feature colour.
109    * 
110    * @param seq
111    * @param position
112    * @param fr
113    * @return
114    */
115   @Override
116   public Color getResidueColour(final SequenceI seq, int position,
117           FeatureRenderer fr)
118   {
119     // TODO replace 8 or so code duplications with calls to this method
120     // (refactored as needed)
121     Color col = getResidueBoxColour(seq, position);
122
123     if (fr != null)
124     {
125       col = fr.findFeatureColour(col, seq, position);
126     }
127     return col;
128   }
129
130   /**
131    * DOCUMENT ME!
132    * 
133    * @param cs
134    *          DOCUMENT ME!
135    * @param seq
136    *          DOCUMENT ME!
137    * @param i
138    *          DOCUMENT ME!
139    */
140   void getBoxColour(ColourSchemeI cs, SequenceI seq, int i)
141   {
142     if (cs != null)
143     {
144       resBoxColour = cs.findColour(seq.getCharAt(i), i, seq);
145     }
146     else if (forOverview
147             && !jalview.util.Comparison.isGap(seq.getCharAt(i)))
148     {
149       resBoxColour = Color.lightGray;
150     }
151     else
152     {
153       resBoxColour = Color.white;
154     }
155   }
156
157   /**
158    * DOCUMENT ME!
159    * 
160    * @param g
161    *          DOCUMENT ME!
162    * @param seq
163    *          DOCUMENT ME!
164    * @param sg
165    *          DOCUMENT ME!
166    * @param start
167    *          DOCUMENT ME!
168    * @param end
169    *          DOCUMENT ME!
170    * @param x1
171    *          DOCUMENT ME!
172    * @param y1
173    *          DOCUMENT ME!
174    * @param width
175    *          DOCUMENT ME!
176    * @param height
177    *          DOCUMENT ME!
178    */
179   public void drawSequence(SequenceI seq, SequenceGroup[] sg, int start,
180           int end, int y1)
181   {
182     allGroups = sg;
183
184     drawBoxes(seq, start, end, y1);
185
186     if (av.validCharWidth)
187     {
188       drawText(seq, start, end, y1);
189     }
190   }
191
192   /**
193    * DOCUMENT ME!
194    * 
195    * @param seq
196    *          DOCUMENT ME!
197    * @param start
198    *          DOCUMENT ME!
199    * @param end
200    *          DOCUMENT ME!
201    * @param x1
202    *          DOCUMENT ME!
203    * @param y1
204    *          DOCUMENT ME!
205    * @param width
206    *          DOCUMENT ME!
207    * @param height
208    *          DOCUMENT ME!
209    */
210   public synchronized void drawBoxes(SequenceI seq, int start, int end,
211           int y1)
212   {
213     if (seq == null)
214     {
215       return; // fix for racecondition
216     }
217     int i = start;
218     int length = seq.getLength();
219
220     int curStart = -1;
221     int curWidth = av.getCharWidth(), avWidth = av.getCharWidth(), avHeight = av
222             .getCharHeight();
223
224     Color tempColour = null;
225
226     while (i <= end)
227     {
228       resBoxColour = Color.white;
229
230       if (i < length)
231       {
232         if (inCurrentSequenceGroup(i))
233         {
234           if (currentSequenceGroup.getDisplayBoxes())
235           {
236             getBoxColour(currentSequenceGroup.cs, seq, i);
237           }
238         }
239         else if (av.getShowBoxes())
240         {
241           getBoxColour(av.getGlobalColourScheme(), seq, i);
242         }
243
244       }
245
246       if (resBoxColour != tempColour)
247       {
248         if (tempColour != null)
249         {
250           graphics.fillRect(avWidth * (curStart - start), y1, curWidth,
251                   avHeight);
252         }
253
254         graphics.setColor(resBoxColour);
255
256         curStart = i;
257         curWidth = avWidth;
258         tempColour = resBoxColour;
259       }
260       else
261       {
262         curWidth += avWidth;
263       }
264
265       i++;
266     }
267
268     graphics.fillRect(avWidth * (curStart - start), y1, curWidth, avHeight);
269
270   }
271
272   /**
273    * DOCUMENT ME!
274    * 
275    * @param seq
276    *          DOCUMENT ME!
277    * @param start
278    *          DOCUMENT ME!
279    * @param end
280    *          DOCUMENT ME!
281    * @param x1
282    *          DOCUMENT ME!
283    * @param y1
284    *          DOCUMENT ME!
285    * @param width
286    *          DOCUMENT ME!
287    * @param height
288    *          DOCUMENT ME!
289    */
290   public void drawText(SequenceI seq, int start, int end, int y1)
291   {
292     y1 += av.getCharHeight() - av.getCharHeight() / 5; // height/5 replaces pady
293     int charOffset = 0;
294     char s;
295
296     if (end + 1 >= seq.getLength())
297     {
298       end = seq.getLength() - 1;
299     }
300     graphics.setColor(av.getTextColour());
301
302     if (monospacedFont && av.getShowText() && allGroups.length == 0
303             && !av.getColourText() && av.getThresholdTextColour() == 0)
304     {
305       if (av.isRenderGaps())
306       {
307         graphics.drawString(seq.getSequenceAsString(start, end + 1), 0, y1);
308       }
309       else
310       {
311         char gap = av.getGapCharacter();
312         graphics.drawString(seq.getSequenceAsString(start, end + 1)
313                 .replace(gap, ' '), 0, y1);
314       }
315     }
316     else
317     {
318       boolean srep = av.isDisplayReferenceSeq();
319       boolean getboxColour = false;
320       boolean isarep = av.getAlignment().getSeqrep() == seq;
321       boolean isgrep = currentSequenceGroup != null ? currentSequenceGroup
322               .getSeqrep() == seq : false;
323       char sr_c;
324       for (int i = start; i <= end; i++)
325       {
326
327         graphics.setColor(av.getTextColour());
328         getboxColour = false;
329         s = seq.getCharAt(i);
330
331         if (!renderGaps && jalview.util.Comparison.isGap(s))
332         {
333           continue;
334         }
335
336         if (inCurrentSequenceGroup(i))
337         {
338           if (!currentSequenceGroup.getDisplayText())
339           {
340             continue;
341           }
342
343           if (currentSequenceGroup.thresholdTextColour > 0
344                   || currentSequenceGroup.getColourText())
345           {
346             getboxColour = true;
347             getBoxColour(currentSequenceGroup.cs, seq, 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.getGlobalColourScheme(), 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.getGlobalColourScheme(), 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 }