JAL-3161 limit tooltip and status updates to visible columns
[jalview.git] / src / jalview / renderer / seqfeatures / FeatureRenderer.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.seqfeatures;
22
23 import jalview.api.AlignViewportI;
24 import jalview.api.FeatureColourI;
25 import jalview.datamodel.Range;
26 import jalview.datamodel.SequenceFeature;
27 import jalview.datamodel.SequenceI;
28 import jalview.util.Comparison;
29 import jalview.viewmodel.seqfeatures.FeatureRendererModel;
30
31 import java.awt.AlphaComposite;
32 import java.awt.Color;
33 import java.awt.FontMetrics;
34 import java.awt.Graphics;
35 import java.awt.Graphics2D;
36 import java.util.List;
37
38 public class FeatureRenderer extends FeatureRendererModel
39 {
40   private static final AlphaComposite NO_TRANSPARENCY = AlphaComposite
41           .getInstance(AlphaComposite.SRC_OVER, 1.0f);
42
43   /**
44    * Constructor given a viewport
45    * 
46    * @param viewport
47    */
48   public FeatureRenderer(AlignViewportI viewport)
49   {
50     this.av = viewport;
51   }
52
53   /**
54    * Renders the sequence using the given feature colour between the given start
55    * and end columns. Returns true if at least one column is drawn, else false
56    * (the feature range does not overlap the start and end positions).
57    * 
58    * @param g
59    * @param seq
60    * @param featureStart
61    * @param featureEnd
62    * @param featureColour
63    * @param start
64    * @param end
65    * @param y1
66    * @param colourOnly
67    * @return
68    */
69   boolean renderFeature(Graphics g, SequenceI seq, int featureStart,
70           int featureEnd, Color featureColour, int start, int end, int y1,
71           boolean colourOnly)
72   {
73     int charHeight = av.getCharHeight();
74     int charWidth = av.getCharWidth();
75     boolean validCharWidth = av.isValidCharWidth();
76
77     if (featureStart > end || featureEnd < start)
78     {
79       return false;
80     }
81
82     if (featureStart < start)
83     {
84       featureStart = start;
85     }
86     if (featureEnd >= end)
87     {
88       featureEnd = end;
89     }
90     int pady = (y1 + charHeight) - charHeight / 5;
91
92     FontMetrics fm = g.getFontMetrics();
93     for (int i = featureStart; i <= featureEnd; i++)
94     {
95       char s = seq.getCharAt(i);
96
97       if (Comparison.isGap(s))
98       {
99         continue;
100       }
101
102       g.setColor(featureColour);
103
104       g.fillRect((i - start) * charWidth, y1, charWidth, charHeight);
105
106       if (colourOnly || !validCharWidth)
107       {
108         continue;
109       }
110
111       g.setColor(Color.white);
112       int charOffset = (charWidth - fm.charWidth(s)) / 2;
113       g.drawString(String.valueOf(s),
114               charOffset + (charWidth * (i - start)), pady);
115     }
116     return true;
117   }
118
119   /**
120    * Renders the sequence using the given SCORE feature colour between the given
121    * start and end columns. Returns true if at least one column is drawn, else
122    * false (the feature range does not overlap the start and end positions).
123    * 
124    * @param g
125    * @param seq
126    * @param fstart
127    * @param fend
128    * @param featureColour
129    * @param start
130    * @param end
131    * @param y1
132    * @param bs
133    * @param colourOnly
134    * @return
135    */
136   boolean renderScoreFeature(Graphics g, SequenceI seq, int fstart,
137           int fend, Color featureColour, int start, int end, int y1,
138           byte[] bs, boolean colourOnly)
139   {
140     if (fstart > end || fend < start)
141     {
142       return false;
143     }
144
145     if (fstart < start)
146     { // fix for if the feature we have starts before the sequence start,
147       fstart = start; // but the feature end is still valid!!
148     }
149
150     if (fend >= end)
151     {
152       fend = end;
153     }
154     int charHeight = av.getCharHeight();
155     int pady = (y1 + charHeight) - charHeight / 5;
156     int ystrt = 0, yend = charHeight;
157     if (bs[0] != 0)
158     {
159       // signed - zero is always middle of residue line.
160       if (bs[1] < 128)
161       {
162         yend = charHeight * (128 - bs[1]) / 512;
163         ystrt = charHeight - yend / 2;
164       }
165       else
166       {
167         ystrt = charHeight / 2;
168         yend = charHeight * (bs[1] - 128) / 512;
169       }
170     }
171     else
172     {
173       yend = charHeight * bs[1] / 255;
174       ystrt = charHeight - yend;
175
176     }
177
178     FontMetrics fm = g.getFontMetrics();
179     int charWidth = av.getCharWidth();
180
181     for (int i = fstart; i <= fend; i++)
182     {
183       char s = seq.getCharAt(i);
184
185       if (Comparison.isGap(s))
186       {
187         continue;
188       }
189
190       g.setColor(featureColour);
191       int x = (i - start) * charWidth;
192       g.drawRect(x, y1, charWidth, charHeight);
193       g.fillRect(x, y1 + ystrt, charWidth, yend);
194
195       if (colourOnly || !av.isValidCharWidth())
196       {
197         continue;
198       }
199
200       g.setColor(Color.black);
201       int charOffset = (charWidth - fm.charWidth(s)) / 2;
202       g.drawString(String.valueOf(s),
203               charOffset + (charWidth * (i - start)), pady);
204     }
205     return true;
206   }
207
208   /**
209    * {@inheritDoc}
210    */
211   @Override
212   public Color findFeatureColour(SequenceI seq, int column, Graphics g)
213   {
214     if (!av.isShowSequenceFeatures())
215     {
216       return null;
217     }
218
219     // column is 'base 1' but getCharAt is an array index (ie from 0)
220     if (Comparison.isGap(seq.getCharAt(column - 1)))
221     {
222       /*
223        * returning null allows the colour scheme to provide gap colour
224        * - normally white, but can be customised
225        */
226       return null;
227     }
228
229     Color renderedColour = null;
230     if (transparency == 1.0f)
231     {
232       /*
233        * simple case - just find the topmost rendered visible feature colour
234        */
235       renderedColour = findFeatureColour(seq, column);
236     }
237     else
238     {
239       /*
240        * transparency case - draw all visible features in render order to
241        * build up a composite colour on the graphics context
242        */
243       renderedColour = drawSequence(g, seq, column, column, 0, true);
244     }
245     return renderedColour;
246   }
247
248   /**
249    * Draws the sequence features on the graphics context, or just determines the
250    * colour that would be drawn (if flag colourOnly is true). Returns the last
251    * colour drawn (which may not be the effective colour if transparency
252    * applies), or null if no feature is drawn in the range given.
253    * 
254    * @param g
255    *          the graphics context to draw on (may be null if colourOnly==true)
256    * @param seq
257    * @param start
258    *          start column
259    * @param end
260    *          end column
261    * @param y1
262    *          vertical offset at which to draw on the graphics
263    * @param colourOnly
264    *          if true, only do enough to determine the colour for the position,
265    *          do not draw the character
266    * @return
267    */
268   public synchronized Color drawSequence(final Graphics g,
269           final SequenceI seq, int start, int end, int y1,
270           boolean colourOnly)
271   {
272     /*
273      * if columns are all gapped, or sequence has no features, nothing to do
274      */
275     Range visiblePositions = seq.findPositions(start+1, end+1);
276     if (visiblePositions == null || !seq.getFeatures().hasFeatures())
277     {
278       return null;
279     }
280
281     updateFeatures();
282
283     if (transparency != 1f && g != null)
284     {
285       Graphics2D g2 = (Graphics2D) g;
286       g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
287               transparency));
288     }
289
290     Color drawnColour = null;
291
292     /*
293      * iterate over features in ordering of their rendering (last is on top)
294      */
295     for (int renderIndex = 0; renderIndex < renderOrder.length; renderIndex++)
296     {
297       String type = renderOrder[renderIndex];
298       if (!showFeatureOfType(type))
299       {
300         continue;
301       }
302
303       FeatureColourI fc = getFeatureStyle(type);
304       List<SequenceFeature> overlaps = seq.getFeatures().findFeatures(
305               visiblePositions.getBegin(), visiblePositions.getEnd(), type);
306
307       if (fc.isSimpleColour())
308       {
309         filterFeaturesForDisplay(overlaps);
310       }
311
312       for (SequenceFeature sf : overlaps)
313       {
314         Color featureColour = getColor(sf, fc);
315         if (featureColour == null)
316         {
317           /*
318            * feature excluded by visibility settings, filters, or colour threshold
319            */
320           continue;
321         }
322
323         /*
324          * if feature starts/ends outside the visible range,
325          * restrict to visible positions (or if a contact feature,
326          * to a single position)
327          */
328         int visibleStart = sf.getBegin();
329         if (visibleStart < visiblePositions.getBegin())
330         {
331           visibleStart = sf.isContactFeature() ? sf.getEnd()
332                   : visiblePositions.getBegin();
333         }
334         int visibleEnd = sf.getEnd();
335         if (visibleEnd > visiblePositions.getEnd())
336         {
337           visibleEnd = sf.isContactFeature() ? sf.getBegin()
338                   : visiblePositions.getEnd();
339         }
340
341         int featureStartCol = seq.findIndex(visibleStart);
342         int featureEndCol = sf.begin == sf.end ? featureStartCol : seq
343                 .findIndex(visibleEnd);
344
345         // Color featureColour = getColour(sequenceFeature);
346
347         boolean isContactFeature = sf.isContactFeature();
348
349         if (isContactFeature)
350         {
351           boolean drawn = renderFeature(g, seq, featureStartCol - 1,
352                   featureStartCol - 1, featureColour, start, end, y1,
353                   colourOnly);
354           drawn |= renderFeature(g, seq, featureEndCol - 1,
355                   featureEndCol - 1, featureColour, start, end, y1,
356                   colourOnly);
357           if (drawn)
358           {
359             drawnColour = featureColour;
360           }
361         }
362         else
363         {
364           /*
365            * showing feature score by height of colour
366            * is not implemented as a selectable option 
367            *
368           if (av.isShowSequenceFeaturesHeight()
369                   && !Float.isNaN(sequenceFeature.score))
370           {
371             boolean drawn = renderScoreFeature(g, seq,
372                     seq.findIndex(sequenceFeature.begin) - 1,
373                     seq.findIndex(sequenceFeature.end) - 1, featureColour,
374                     start, end, y1, normaliseScore(sequenceFeature),
375                     colourOnly);
376             if (drawn)
377             {
378               drawnColour = featureColour;
379             }
380           }
381           else
382           {
383           */
384             boolean drawn = renderFeature(g, seq,
385                     featureStartCol - 1,
386                     featureEndCol - 1, featureColour,
387                     start, end, y1, colourOnly);
388             if (drawn)
389             {
390               drawnColour = featureColour;
391             }
392           /*}*/
393         }
394       }
395     }
396
397     if (transparency != 1.0f && g != null)
398     {
399       /*
400        * reset transparency
401        */
402       Graphics2D g2 = (Graphics2D) g;
403       g2.setComposite(NO_TRANSPARENCY);
404     }
405
406     return drawnColour;
407   }
408
409   /**
410    * Called when alignment in associated view has new/modified features to
411    * discover and display.
412    * 
413    */
414   @Override
415   public void featuresAdded()
416   {
417     findAllFeatures();
418   }
419
420   /**
421    * Returns the sequence feature colour rendered at the given column position,
422    * or null if none found. The feature of highest render order (i.e. on top) is
423    * found, subject to both feature type and feature group being visible, and
424    * its colour returned. This method is suitable when no feature transparency
425    * applied (only the topmost visible feature colour is rendered).
426    * <p>
427    * Note this method does not check for a gap in the column so would return the
428    * colour for features enclosing a gapped column. Check for gap before calling
429    * if different behaviour is wanted.
430    * 
431    * @param seq
432    * @param column
433    *          (1..)
434    * @return
435    */
436   Color findFeatureColour(SequenceI seq, int column)
437   {
438     /*
439      * check for new feature added while processing
440      */
441     updateFeatures();
442
443     /*
444      * inspect features in reverse renderOrder (the last in the array is 
445      * displayed on top) until we find one that is rendered at the position
446      */
447     for (int renderIndex = renderOrder.length
448             - 1; renderIndex >= 0; renderIndex--)
449     {
450       String type = renderOrder[renderIndex];
451       if (!showFeatureOfType(type))
452       {
453         continue;
454       }
455
456       List<SequenceFeature> overlaps = seq.findFeatures(column, column,
457               type);
458       for (SequenceFeature sequenceFeature : overlaps)
459       {
460         if (!featureGroupNotShown(sequenceFeature))
461         {
462           Color col = getColour(sequenceFeature);
463           if (col != null)
464           {
465             return col;
466           }
467         }
468       }
469     }
470
471     /*
472      * no displayed feature found at position
473      */
474     return null;
475   }
476 }