JAL-3161 limit tooltip and status updates to visible columns
[jalview.git] / 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 }