JAL-2909 Tidy up bam file cigar code
[jalview.git] / src / jalview / appletgui / IdCanvas.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.SequenceI;
24 import jalview.viewmodel.ViewportListenerI;
25 import jalview.viewmodel.ViewportRanges;
26
27 import java.awt.Color;
28 import java.awt.Font;
29 import java.awt.Graphics;
30 import java.awt.Image;
31 import java.awt.Panel;
32 import java.beans.PropertyChangeEvent;
33 import java.util.List;
34
35 public class IdCanvas extends Panel implements ViewportListenerI
36 {
37   protected AlignViewport av;
38
39   protected boolean showScores = true;
40
41   protected int maxIdLength = -1;
42
43   protected String maxIdStr = null;
44
45   Image image;
46
47   Graphics gg;
48
49   int imgHeight = 0;
50
51   boolean fastPaint = false;
52
53   List<SequenceI> searchResults;
54
55   public IdCanvas(AlignViewport av)
56   {
57     setLayout(null);
58     this.av = av;
59     PaintRefresher.Register(this, av.getSequenceSetId());
60     av.getRanges().addPropertyChangeListener(this);
61   }
62
63   public void drawIdString(Graphics gg, boolean hiddenRows, SequenceI s,
64           int i, int starty, int ypos)
65   {
66     int charHeight = av.getCharHeight();
67
68     if (searchResults != null && searchResults.contains(s))
69     {
70       gg.setColor(Color.black);
71       gg.fillRect(0, ((i - starty) * charHeight) + ypos, getSize().width,
72               charHeight);
73       gg.setColor(Color.white);
74     }
75     else if (av.getSelectionGroup() != null
76             && av.getSelectionGroup().getSequences(null).contains(s))
77     {
78       gg.setColor(Color.lightGray);
79       gg.fillRect(0, ((i - starty) * charHeight) + ypos, getSize().width,
80               charHeight);
81       gg.setColor(Color.white);
82     }
83     else
84     {
85       gg.setColor(av.getSequenceColour(s));
86       gg.fillRect(0, ((i - starty) * charHeight) + ypos, getSize().width,
87               charHeight);
88       gg.setColor(Color.black);
89     }
90
91     gg.drawString(s.getDisplayId(av.getShowJVSuffix()), 0,
92             ((i - starty) * charHeight) + ypos + charHeight
93                     - (charHeight / 5));
94
95     if (hiddenRows)
96     {
97       drawMarker(i, starty, ypos);
98     }
99
100   }
101
102   public void fastPaint(int vertical)
103   {
104     if (gg == null || av.getWrapAlignment())
105     {
106       repaint();
107       return;
108     }
109
110     ViewportRanges ranges = av.getRanges();
111
112     gg.copyArea(0, 0, getSize().width, imgHeight, 0,
113             -vertical * av.getCharHeight());
114
115     int ss = ranges.getStartSeq(), es = ranges.getEndSeq(), transY = 0;
116     if (vertical > 0) // scroll down
117     {
118       ss = es - vertical;
119       if (ss < ranges.getStartSeq()) // ie scrolling too fast, more than a page
120                                      // at a
121       // time
122       {
123         ss = ranges.getStartSeq();
124       }
125       else
126       {
127         transY = imgHeight - ((vertical + 1) * av.getCharHeight());
128       }
129     }
130     else if (vertical < 0)
131     {
132       es = ss - vertical;
133       if (es > ranges.getEndSeq())
134       {
135         es = ranges.getEndSeq();
136       }
137     }
138
139     gg.translate(0, transY);
140
141     drawIds(ss, es);
142
143     gg.translate(0, -transY);
144
145     fastPaint = true;
146     repaint();
147   }
148
149   @Override
150   public void update(Graphics g)
151   {
152     paint(g);
153   }
154
155   @Override
156   public void paint(Graphics g)
157   {
158     if (getSize().height < 0 || getSize().width < 0)
159     {
160       return;
161     }
162     if (fastPaint)
163     {
164       fastPaint = false;
165       g.drawImage(image, 0, 0, this);
166       return;
167     }
168
169     imgHeight = getSize().height;
170     imgHeight -= imgHeight % av.getCharHeight();
171
172     if (imgHeight < 1)
173     {
174       return;
175     }
176
177     if (image == null || imgHeight != image.getHeight(this))
178     {
179       image = createImage(getSize().width, imgHeight);
180       gg = image.getGraphics();
181       gg.setFont(av.getFont());
182     }
183
184     // Fill in the background
185     gg.setColor(Color.white);
186     Font italic = new Font(av.getFont().getName(), Font.ITALIC,
187             av.getFont().getSize());
188     gg.setFont(italic);
189
190     gg.fillRect(0, 0, getSize().width, getSize().height);
191     drawIds(av.getRanges().getStartSeq(), av.getRanges().getEndSeq());
192     g.drawImage(image, 0, 0, this);
193   }
194
195   /**
196    * local copy of av.getCharHeight set at top of drawIds
197    */
198   private int avcharHeight;
199
200   void drawIds(int starty, int endy)
201   {
202     avcharHeight = av.getCharHeight();
203
204     Color currentColor = Color.white;
205     Color currentTextColor = Color.black;
206
207     final boolean doHiddenCheck = av.isDisplayReferenceSeq()
208             || av.hasHiddenRows();
209     boolean hiddenRows = av.hasHiddenRows() && av.getShowHiddenMarkers();
210
211     if (av.getWrapAlignment())
212     {
213       drawIdsWrapped(starty, doHiddenCheck, hiddenRows);
214       return;
215     }
216
217     // Now draw the id strings
218     SequenceI seq;
219     for (int i = starty; i <= endy; i++)
220     {
221       seq = av.getAlignment().getSequenceAt(i);
222       if (seq == null)
223       {
224         continue;
225       }
226       // hardwired italic IDs in applet currently
227       Font italic = new Font(av.getFont().getName(), Font.ITALIC,
228               av.getFont().getSize());
229       gg.setFont(italic);
230       // boolean isrep=false;
231       if (doHiddenCheck)
232       {
233         // isrep =
234         setHiddenFont(seq);
235       }
236
237       // Selected sequence colours
238       if ((searchResults != null) && searchResults.contains(seq))
239       {
240         currentColor = Color.black;
241         currentTextColor = Color.white;
242       }
243       else if ((av.getSelectionGroup() != null)
244               && av.getSelectionGroup().getSequences(null).contains(seq))
245       {
246         currentColor = Color.lightGray;
247         currentTextColor = Color.black;
248       }
249       else
250       {
251         currentColor = av.getSequenceColour(seq);
252         currentTextColor = Color.black;
253       }
254
255       gg.setColor(currentColor);
256       // TODO: isrep could be used to highlight the representative in a
257       // different way
258       gg.fillRect(0, (i - starty) * avcharHeight, getSize().width,
259               avcharHeight);
260       gg.setColor(currentTextColor);
261
262       gg.drawString(seq.getDisplayId(av.getShowJVSuffix()), 0,
263               (((i - starty) * avcharHeight) + avcharHeight)
264                       - (avcharHeight / 5));
265
266       if (hiddenRows)
267       {
268         drawMarker(i, starty, 0);
269       }
270     }
271   }
272
273   /**
274    * Draws sequence ids in wrapped mode
275    * 
276    * @param starty
277    * @param doHiddenCheck
278    * @param hiddenRows
279    */
280   protected void drawIdsWrapped(int starty, final boolean doHiddenCheck,
281           boolean hiddenRows)
282   {
283     int maxwidth = av.getAlignment().getWidth();
284     int alheight = av.getAlignment().getHeight();
285
286     if (av.hasHiddenColumns())
287     {
288       maxwidth = av.getAlignment().getHiddenColumns()
289               .findColumnPosition(maxwidth) - 1;
290     }
291
292     int annotationHeight = 0;
293     AnnotationLabels labels = null;
294
295     if (av.isShowAnnotation())
296     {
297       AnnotationPanel ap = new AnnotationPanel(av);
298       annotationHeight = ap.adjustPanelHeight();
299       labels = new AnnotationLabels(av);
300     }
301     int hgap = avcharHeight;
302     if (av.getScaleAboveWrapped())
303     {
304       hgap += avcharHeight;
305     }
306
307     int cHeight = alheight * avcharHeight + hgap + annotationHeight;
308
309     int rowSize = av.getRanges().getViewportWidth();
310
311     // hardwired italic IDs in applet currently
312     Font italic = new Font(av.getFont().getName(), Font.ITALIC,
313             av.getFont().getSize());
314     gg.setFont(italic);
315
316     /*
317      * draw repeating sequence ids until out of sequence data or
318      * out of visible space, whichever comes first
319      */
320     int ypos = hgap;
321     int row = av.getRanges().getStartRes();
322     while ((ypos <= getHeight()) && (row < maxwidth))
323     {
324       for (int i = starty; i < alheight; i++)
325       {
326
327         SequenceI s = av.getAlignment().getSequenceAt(i);
328         // gg.setFont(italic);
329         if (doHiddenCheck)
330         {
331           setHiddenFont(s);
332         }
333         drawIdString(gg, hiddenRows, s, i, 0, ypos);
334       }
335
336       if (labels != null)
337       {
338         gg.translate(0, ypos + (alheight * avcharHeight));
339         labels.drawComponent(gg, getSize().width);
340         gg.translate(0, -ypos - (alheight * avcharHeight));
341       }
342       ypos += cHeight;
343       row += rowSize;
344     }
345   }
346
347   public void setHighlighted(List<SequenceI> list)
348   {
349     searchResults = list;
350     repaint();
351   }
352
353   void drawMarker(int i, int starty, int yoffset)
354   {
355     SequenceI[] hseqs = av.getAlignment()
356             .getHiddenSequences().hiddenSequences;
357     // Use this method here instead of calling hiddenSeq adjust
358     // 3 times.
359     int hSize = hseqs.length;
360
361     int hiddenIndex = i;
362     int lastIndex = i - 1;
363     int nextIndex = i + 1;
364
365     for (int j = 0; j < hSize; j++)
366     {
367       if (hseqs[j] != null)
368       {
369         if (j - 1 < hiddenIndex)
370         {
371           hiddenIndex++;
372         }
373         if (j - 1 < lastIndex)
374         {
375           lastIndex++;
376         }
377         if (j - 1 < nextIndex)
378         {
379           nextIndex++;
380         }
381       }
382     }
383
384     boolean below = (hiddenIndex > lastIndex + 1);
385     boolean above = (nextIndex > hiddenIndex + 1);
386
387     gg.setColor(Color.blue);
388     if (below)
389     {
390       gg.fillPolygon(
391               new int[]
392               { getSize().width - avcharHeight,
393                   getSize().width - avcharHeight, getSize().width },
394               new int[]
395               { (i - starty) * avcharHeight + yoffset,
396                   (i - starty) * avcharHeight + yoffset + avcharHeight / 4,
397                   (i - starty) * avcharHeight + yoffset },
398               3);
399     }
400     if (above)
401     {
402       gg.fillPolygon(
403               new int[]
404               { getSize().width - avcharHeight,
405                   getSize().width - avcharHeight, getSize().width },
406               new int[]
407               { (i - starty + 1) * avcharHeight + yoffset,
408                   (i - starty + 1) * avcharHeight + yoffset
409                           - avcharHeight / 4,
410                   (i - starty + 1) * avcharHeight + yoffset },
411               3);
412
413     }
414   }
415
416   boolean setHiddenFont(SequenceI seq)
417   {
418     Font bold = new Font(av.getFont().getName(), Font.BOLD,
419             av.getFont().getSize());
420
421     if (av.isReferenceSeq(seq) || av.isHiddenRepSequence(seq))
422     {
423       gg.setFont(bold);
424       return true;
425     }
426     return false;
427   }
428
429   /**
430    * Respond to viewport range changes (e.g. alignment panel was scrolled). Both
431    * scrolling and resizing change viewport ranges. Scrolling changes both start
432    * and end points, but resize only changes end values. Here we only want to
433    * fastpaint on a scroll, with resize using a normal paint, so scroll events
434    * are identified as changes to the horizontal or vertical start value.
435    * <p>
436    * In unwrapped mode, only responds to a vertical scroll, as horizontal scroll
437    * leaves sequence ids unchanged. In wrapped mode, only vertical scroll is
438    * provided, but it generates a change of "startres" which does require an
439    * update here.
440    */
441   @Override
442   public void propertyChange(PropertyChangeEvent evt)
443   {
444     String propertyName = evt.getPropertyName();
445     if (propertyName.equals(ViewportRanges.STARTSEQ)
446             || (av.getWrapAlignment()
447                     && propertyName.equals(ViewportRanges.STARTRES)))
448     {
449       fastPaint((int) evt.getNewValue() - (int) evt.getOldValue());
450     }
451     else if (propertyName.equals(ViewportRanges.STARTRESANDSEQ))
452     {
453       fastPaint(((int[]) evt.getNewValue())[1]
454               - ((int[]) evt.getOldValue())[1]);
455     }
456     else if (propertyName.equals(ViewportRanges.MOVE_VIEWPORT))
457     {
458       repaint();
459     }
460   }
461 }