JAL-972 workaround for working out source URL for pre DAS 1.6 sources.
[jalview.git] / src / jalview / renderer / AnnotationRenderer.java
1 package jalview.renderer;
2
3 import jalview.analysis.AAFrequency;
4 import jalview.analysis.StructureFrequency;
5 import jalview.api.AlignViewportI;
6 import jalview.datamodel.AlignmentAnnotation;
7 import jalview.datamodel.ColumnSelection;
8 import jalview.schemes.ColourSchemeI;
9
10 import java.awt.BasicStroke;
11 import java.awt.Color;
12 import java.awt.Font;
13 import java.awt.FontMetrics;
14 import java.awt.Graphics;
15 import java.awt.Graphics2D;
16 import java.awt.Image;
17 import java.awt.font.LineMetrics;
18 import java.awt.geom.AffineTransform;
19 import java.awt.image.ImageObserver;
20 import java.util.Hashtable;
21
22 import com.stevesoft.pat.Regex;
23
24 public class AnnotationRenderer
25 {
26
27   public AnnotationRenderer()
28   {
29     // TODO Auto-generated constructor stub
30   }
31
32   public void drawStemAnnot(Graphics g, AlignmentAnnotation row, int lastSSX, int x, int y, int iconOffset, int startRes, int column, boolean validRes, boolean validEnd)
33   {
34     g.setColor(STEM_COLOUR);
35     int sCol = (lastSSX / charWidth) + startRes;
36     int x1 = lastSSX;
37     int x2 = (x * charWidth);
38     Regex closeparen = new Regex("(\\))");
39   
40     String dc = (column == 0 || row.annotations[column-1]==null) ? ""
41             : row.annotations[column - 1].displayCharacter;
42   
43     boolean diffupstream = sCol == 0 || row.annotations[sCol - 1] == null
44             || !dc.equals(row.annotations[sCol - 1].displayCharacter);
45     boolean diffdownstream = !validRes || !validEnd
46             || row.annotations[column] == null
47             || !dc.equals(row.annotations[column].displayCharacter);
48     // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
49     // If a closing base pair half of the stem, display a backward arrow
50     if (column > 0 && closeparen.search(dc))
51     {
52       if (diffupstream)
53       // if (validRes && column>1 && row.annotations[column-2]!=null &&
54       // dc.equals(row.annotations[column-2].displayCharacter))
55       {
56         g.fillPolygon(new int[]
57         { lastSSX + 5, lastSSX + 5, lastSSX }, new int[]
58         { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
59         x1 += 5;
60       }
61       if (diffdownstream)
62       {
63         x2 -= 1;
64       }
65     }
66     else
67     {
68       // display a forward arrow
69       if (diffdownstream)
70       {
71         g.fillPolygon(new int[]
72         { x2 - 5, x2 - 5, x2 }, new int[]
73         { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
74         x2 -= 5;
75       }
76       if (diffupstream)
77       {
78         x1 += 1;
79       }
80     }
81     // draw arrow body
82     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
83   }
84   private int charWidth,endRes,charHeight;
85   private boolean validCharWidth, hasHiddenColumns;
86   private FontMetrics fm;
87   private boolean MAC=new jalview.util.Platform().isAMac();
88   boolean av_renderHistogram = true, av_renderProfile = true, av_normaliseProfile=false;
89   ColourSchemeI profcolour=null;
90   private ColumnSelection columnSelection;
91   private Hashtable[] hconsensus;
92   private Hashtable[] hStrucConsensus;
93   private boolean av_ignoreGapsConsensus;
94   
95   /**
96    * attributes set from AwtRenderPanelI
97    */
98   /**
99    * old image used when data is currently being calculated and cannot be rendered
100    */
101   private Image fadedImage;
102   /**
103    * panel being rendered into
104    */
105   private ImageObserver annotationPanel;
106   /**
107    * width of image to render in panel
108    */
109   private int imgWidth; 
110   
111   //  public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI av)
112   public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel, AlignViewportI av)
113   {
114     fm = annotPanel.getFontMetrics();
115     annotationPanel = annotPanel;
116     fadedImage=annotPanel.getFadedImage();
117     imgWidth=annotPanel.getFadedImageWidth();
118     updateFromAlignViewport(av);
119   }
120   public void updateFromAlignViewport(AlignViewportI av)
121   {
122     charWidth = av.getCharWidth();
123     endRes = av.getEndRes();
124     charHeight = av.getCharHeight();
125     hasHiddenColumns = av.hasHiddenColumns();
126     validCharWidth = av.isValidCharWidth();
127     av_renderHistogram = av.isShowConsensusHistogram();
128     av_renderProfile = av.isShowSequenceLogo();
129     av_normaliseProfile= av.isNormaliseSequenceLogo();
130     profcolour = av.getGlobalColourScheme();
131     if (profcolour == null)
132     {
133       // Set the default colour for sequence logo if the alignnent has no colourscheme set
134       profcolour = av.getAlignment().isNucleotide() ? new jalview.schemes.NucleotideColourScheme() : new jalview.schemes.ZappoColourScheme();
135     }
136     columnSelection = av.getColumnSelection();
137     hconsensus = av.getSequenceConsensusHash();//hconsensus;
138     hStrucConsensus = av.getRnaStructureConsensusHash(); //hStrucConsensus;
139     av_ignoreGapsConsensus=av.getIgnoreGapsConsensus();
140   }
141   public int[] getProfileFor(AlignmentAnnotation aa, int column)
142   {
143     // TODO : consider refactoring the global alignment calculation properties/rendering attributes as a global 'alignment group' which holds all vis settings for the alignment as a whole rather than a subset 
144     // 
145     if (aa.autoCalculated && aa.label.startsWith("Consensus"))
146     {
147       if (aa.groupRef != null && aa.groupRef.consensusData != null
148               && aa.groupRef.isShowSequenceLogo())
149       {
150         return AAFrequency.extractProfile(
151                 aa.groupRef.consensusData[column], aa.groupRef
152                         .getIgnoreGapsConsensus());
153       }
154       // TODO extend annotation row to enable dynamic and static profile data to
155       // be stored
156       if (aa.groupRef == null && aa.sequenceRef == null
157               && av_renderProfile)
158       {
159         return AAFrequency.extractProfile(hconsensus[column], av_ignoreGapsConsensus);
160       }
161     }
162     else
163     {
164       if (aa.autoCalculated && aa.label.startsWith("StrucConsensus"))
165       {
166         // TODO implement group structure consensus
167         /* if (aa.groupRef != null && aa.groupRef.consensusData != null
168                 && aa.groupRef.isShowSequenceLogo())
169         {
170           //TODO check what happens for group selections
171           return StructureFrequency.extractProfile(
172                   aa.groupRef.consensusData[column], aa.groupRef
173                           .getIgnoreGapsConsensus());
174         }
175         */
176         // TODO extend annotation row to enable dynamic and static profile data
177         // to
178         // be stored
179         if (aa.groupRef == null && aa.sequenceRef == null
180                 && av_renderProfile && hStrucConsensus!=null && hStrucConsensus.length>column)
181         {
182           return StructureFrequency.extractProfile(hStrucConsensus[column],
183                   av_ignoreGapsConsensus);
184         }
185       }
186     }
187     return null;
188   }
189   
190   /**
191    * DOCUMENT ME!
192    * 
193    * @param annotationPanel TODO
194    * @param g
195    *          DOCUMENT ME!
196    * @param startRes
197    *          DOCUMENT ME!
198    * @param endRes
199    *          DOCUMENT ME!
200    */
201   public void drawComponent(AwtRenderPanelI annotPanel, AlignViewportI av, Graphics g, int activeRow, int startRes, int endRes)
202   {
203     // NOTES:
204     // AnnotationPanel needs to implement: ImageObserver, access to AlignViewport
205     updateFromAwtRenderPanel(annotPanel, av);
206     fm = g.getFontMetrics();  
207     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
208   
209     int x = 0, y = 0;
210     int column = 0;
211     char lastSS;
212     int lastSSX;
213     int iconOffset = 0;
214     boolean validRes = false;
215     boolean validEnd = false;
216     boolean labelAllCols = false;
217     boolean centreColLabels, centreColLabelsDef = av
218             .getCentreColumnLabels();
219     boolean scaleColLabel = false;
220     boolean[] graphGroupDrawn = new boolean[aa.length];
221     int charOffset = 0; // offset for a label
222     float fmWidth, fmScaling = 1f; // scaling for a label to fit it into a
223     // column.
224     Font ofont = g.getFont();
225     // \u03B2 \u03B1
226     for (int i = 0; i < aa.length; i++)
227     {
228       AlignmentAnnotation row = aa[i];
229   
230       if (!row.visible)
231       {
232         continue;
233       }
234       centreColLabels = row.centreColLabels || centreColLabelsDef;
235       labelAllCols = row.showAllColLabels;
236       scaleColLabel = row.scaleColLabel;
237       lastSS = ' ';
238       lastSSX = 0;
239       if (row.graph > 0)
240       {
241         if (row.graphGroup > -1 && graphGroupDrawn[row.graphGroup])
242         {
243           continue;
244         }
245   
246         // this is so that we draw the characters below the graph
247         y += row.height;
248   
249         if (row.hasText)
250         {
251           iconOffset = charHeight - fm.getDescent();
252           y -= charHeight;
253         }
254       }
255       else if (row.hasText)
256       {
257         iconOffset = charHeight - fm.getDescent();
258   
259       }
260       else
261       {
262         iconOffset = 0;
263       }
264   
265       if (aa[i].autoCalculated && av.isCalculationInProgress(aa[i]))
266       {
267         y += charHeight;
268   
269         g.drawImage(fadedImage, 0, y - row.height, imgWidth, y, 0, y
270                 - row.height, imgWidth, y, annotationPanel);
271         g.setColor(Color.black);
272         // g.drawString("Calculating "+aa[i].label+"....",20, y-row.height/2);
273   
274         continue;
275       }
276       
277 /*      else if (annotationPanel.av.updatingConservation
278               && aa[i].label.equals("Conservation"))
279       {
280   
281         y += charHeight;
282         g.drawImage(annotationPanel.fadedImage, 0, y - row.height, annotationPanel.imgWidth, y, 0, y
283                 - row.height, annotationPanel.imgWidth, y, annotationPanel);
284   
285         g.setColor(Color.black);
286         // g.drawString("Calculating Conservation.....",20, y-row.height/2);
287   
288         continue;
289       }
290       else if (annotationPanel.av.updatingConservation && aa[i].label.equals("Quality"))
291       {
292   
293         y += charHeight;
294         g.drawImage(annotationPanel.fadedImage, 0, y - row.height, annotationPanel.imgWidth, y, 0, y
295                 - row.height, annotationPanel.imgWidth, y, annotationPanel);
296         g.setColor(Color.black);
297         // / g.drawString("Calculating Quality....",20, y-row.height/2);
298   
299         continue;
300       }
301   */
302       // first pass sets up state for drawing continuation from left-hand column
303       // of startRes
304       x = (startRes == 0) ? 0 : -1;
305       while (x < endRes - startRes)
306       {
307         if (hasHiddenColumns)
308         {
309           column = columnSelection.adjustForHiddenColumns(
310                   startRes + x);
311           if (column > row.annotations.length - 1)
312           {
313             break;
314           }
315         }
316         else
317         {
318           column = startRes + x;
319         }
320   
321         if ((row.annotations == null) || (row.annotations.length <= column)
322                 || (row.annotations[column] == null))
323         {
324           validRes = false;
325         }
326         else
327         {
328           validRes = true;
329         }
330         if (x > -1)
331         {
332           if (activeRow == i)
333           {
334             g.setColor(Color.red);
335   
336             if (columnSelection != null)
337             {
338               for (int n = 0; n < columnSelection.size(); n++)
339               {
340                 int v = columnSelection.columnAt(n);
341   
342                 if (v == column)
343                 {
344                   g.fillRect(x * charWidth, y, charWidth,
345                           charHeight);
346                 }
347               }
348             }
349           }
350           if (!row.isValidStruc())
351           {
352             g.setColor(Color.orange);
353             g.fillRect((int)row.getInvalidStrucPos()*charWidth, y, charWidth, charHeight);
354           }
355           if (validCharWidth
356                   && validRes
357                   && row.annotations[column].displayCharacter != null
358                   && (row.annotations[column].displayCharacter.length() > 0))
359           {
360   
361             if (centreColLabels || scaleColLabel)
362             {
363               fmWidth = (float) fm.charsWidth(
364                       row.annotations[column].displayCharacter
365                               .toCharArray(), 0,
366                       row.annotations[column].displayCharacter.length());
367   
368               if (scaleColLabel)
369               {
370                 // justify the label and scale to fit in column
371                 if (fmWidth > charWidth)
372                 {
373                   // scale only if the current font isn't already small enough
374                   fmScaling = charWidth;
375                   fmScaling /= fmWidth;
376                   g.setFont(ofont.deriveFont(AffineTransform
377                           .getScaleInstance(fmScaling, 1.0)));
378                   // and update the label's width to reflect the scaling.
379                   fmWidth = charWidth;
380                 }
381               }
382             }
383             else
384             {
385               fmWidth = (float) fm
386                       .charWidth(row.annotations[column].displayCharacter
387                               .charAt(0));
388             }
389             charOffset = (int) ((charWidth - fmWidth) / 2f);
390   
391             if (row.annotations[column].colour == null)
392               g.setColor(Color.black);
393             else
394               g.setColor(row.annotations[column].colour);
395   
396             if (column == 0 || row.graph > 0)
397             {
398               g.drawString(row.annotations[column].displayCharacter,
399                       (x * charWidth) + charOffset, y + iconOffset);
400             }
401             else if (row.annotations[column - 1] == null
402                     || (labelAllCols
403                             || !row.annotations[column].displayCharacter
404                                     .equals(row.annotations[column - 1].displayCharacter) || (row.annotations[column].displayCharacter
405                             .length() < 2 && row.annotations[column].secondaryStructure == ' ')))
406             {
407               g.drawString(row.annotations[column].displayCharacter, x
408                       * charWidth + charOffset, y + iconOffset);
409             }
410             g.setFont(ofont);
411           }
412         }
413         if (row.hasIcons)
414         {
415           char ss = validRes ? row.annotations[column].secondaryStructure
416                   : ' ';
417           if (ss == 'S')
418           {
419             // distinguish between forward/backward base-pairing
420             if (row.annotations[column].displayCharacter.indexOf(')') > -1)
421             {
422               ss = 's';
423             }
424           }
425           if (!validRes || (ss != lastSS))
426           {
427             if (x > -1)
428             {
429               switch (lastSS)
430               {
431               case 'H':
432                 drawHelixAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
433                         column, validRes, validEnd);
434                 break;
435   
436               case 'E':
437                 drawSheetAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
438                         column, validRes, validEnd);
439                 break;
440   
441               case 'S': // Stem case for RNA secondary structure
442               case 's': // and opposite direction
443                 drawStemAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
444                         column, validRes, validEnd);
445                 break;
446   
447               default:
448                 g.setColor(Color.gray);
449                 g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth)
450                         - lastSSX, 2);
451   
452                 break;
453               }
454             }
455             if (validRes)
456             {
457               lastSS = ss;
458             }
459             else
460             {
461               lastSS = ' ';
462             }
463             if (x > -1)
464             {
465               lastSSX = (x * charWidth);
466             }
467           }
468         }
469         column++;
470         x++;
471       }
472       if (column >= row.annotations.length)
473       {
474         column = row.annotations.length - 1;
475         validEnd = false;
476       }
477       else
478       {
479         validEnd = true;
480       }
481       if ((row.annotations == null) || (row.annotations.length <= column)
482               || (row.annotations[column] == null))
483       {
484         validRes = false;
485       }
486       else
487       {
488         validRes = true;
489       }
490   
491       // x ++;
492   
493       if (row.hasIcons)
494       {
495         switch (lastSS)
496         {
497         case 'H':
498           drawHelixAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
499                   column, validRes, validEnd);
500           break;
501   
502         case 'E':
503           drawSheetAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
504                   column, validRes, validEnd);
505           break;
506         case 's':
507         case 'S': // Stem case for RNA secondary structure
508           drawStemAnnot(g, row, lastSSX, x, y, iconOffset, startRes,
509                   column, validRes, validEnd);
510           break;
511         default:
512           drawGlyphLine(g, row, lastSSX, x, y, iconOffset, startRes,
513                   column, validRes, validEnd);
514           break;
515         }
516       }
517   
518       if (row.graph > 0 && row.graphHeight > 0)
519       {
520         if (row.graph == AlignmentAnnotation.LINE_GRAPH)
521         {
522           if (row.graphGroup > -1 && !graphGroupDrawn[row.graphGroup])
523           {
524             float groupmax = -999999, groupmin = 9999999;
525             for (int gg = 0; gg < aa.length; gg++)
526             {
527               if (aa[gg].graphGroup != row.graphGroup)
528               {
529                 continue;
530               }
531   
532               if (aa[gg] != row)
533               {
534                 aa[gg].visible = false;
535               }
536   
537               if (aa[gg].graphMax > groupmax)
538               {
539                 groupmax = aa[gg].graphMax;
540               }
541               if (aa[gg].graphMin < groupmin)
542               {
543                 groupmin = aa[gg].graphMin;
544               }
545             }
546   
547             for (int gg = 0; gg < aa.length; gg++)
548             {
549               if (aa[gg].graphGroup == row.graphGroup)
550               {
551                 drawLineGraph(g, aa[gg], startRes, endRes, y, groupmin,
552                         groupmax, row.graphHeight);
553               }
554             }
555   
556             graphGroupDrawn[row.graphGroup] = true;
557           }
558           else
559           {
560             drawLineGraph( g, row, startRes, endRes, y, row.graphMin,
561                     row.graphMax, row.graphHeight);
562           }
563         }
564         else if (row.graph == AlignmentAnnotation.BAR_GRAPH)
565         {
566           drawBarGraph(g, row, startRes, endRes, row.graphMin,
567                   row.graphMax, y);
568         }
569       }
570   
571       if (row.graph > 0 && row.hasText)
572       {
573         y += charHeight;
574       }
575   
576       if (row.graph == 0)
577       {
578         y += aa[i].height;
579       }
580     }
581   }
582
583   private Color GLYPHLINE_COLOR=Color.gray;
584   private Color SHEET_COLOUR=Color.green;
585   private Color HELIX_COLOUR=Color.red;
586   private Color STEM_COLOUR=Color.blue;
587   
588   
589   public void drawGlyphLine(Graphics g, AlignmentAnnotation row, int lastSSX, int x, int y, int iconOffset, int startRes, int column, boolean validRes, boolean validEnd)
590   {
591     g.setColor(GLYPHLINE_COLOR);
592     g
593             .fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth)
594                     - lastSSX, 2);
595   }
596
597   public void drawSheetAnnot(Graphics g, AlignmentAnnotation row, int lastSSX, int x, int y, int iconOffset, int startRes, int column, boolean validRes, boolean validEnd)
598   {
599     g.setColor(SHEET_COLOUR);
600   
601     if (!validEnd || !validRes || row.annotations[column] == null
602             || row.annotations[column].secondaryStructure != 'E')
603     {
604       g.fillRect(lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX
605               - 4, 7);
606       g.fillPolygon(
607               new int[]
608               { (x * charWidth) - 4, (x * charWidth) - 4,
609                   (x * charWidth) }, new int[]
610               { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
611               3);
612     }
613     else
614     {
615       g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth
616               - lastSSX, 7);
617     }
618   
619   }
620
621   public void drawHelixAnnot(Graphics g, AlignmentAnnotation row, int lastSSX, int x, int y, int iconOffset, int startRes, int column, boolean validRes, boolean validEnd)
622   {
623     g.setColor(HELIX_COLOUR);
624   
625     int sCol = (lastSSX / charWidth) + startRes;
626     int x1 = lastSSX;
627     int x2 = (x * charWidth);
628   
629     if (MAC)
630     {
631       int ofs = charWidth / 2;
632       // Off by 1 offset when drawing rects and ovals
633       // to offscreen image on the MAC
634       g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
635       if (sCol == 0 || row.annotations[sCol - 1] == null
636               || row.annotations[sCol - 1].secondaryStructure != 'H')
637       {
638       }
639       else
640       {
641         // g.setColor(Color.orange);
642         g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
643                 0, 0);
644       }
645       if (!validRes || row.annotations[column] == null
646               || row.annotations[column].secondaryStructure != 'H')
647       {
648   
649       }
650       else
651       {
652         // g.setColor(Color.magenta);
653         g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset, x2 - x1 - ofs
654                 + 1, 8, 0, 0);
655   
656       }
657   
658       return;
659     }
660   
661     if (sCol == 0 || row.annotations[sCol - 1] == null
662             || row.annotations[sCol - 1].secondaryStructure != 'H')
663     {
664       g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
665       x1 += charWidth / 2;
666     }
667   
668     if (!validRes || row.annotations[column] == null
669             || row.annotations[column].secondaryStructure != 'H')
670     {
671       g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset,
672               charWidth, 8, 270, 180);
673       x2 -= charWidth / 2;
674     }
675   
676     g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
677   }
678
679   public void drawLineGraph(Graphics g, AlignmentAnnotation aa, int sRes, int eRes, int y, float min, float max, int graphHeight)
680   {
681     if (sRes > aa.annotations.length)
682     {
683       return;
684     }
685   
686     int x = 0;
687   
688     // Adjustment for fastpaint to left
689     if (eRes < endRes)
690     {
691       eRes++;
692     }
693   
694     eRes = Math.min(eRes, aa.annotations.length);
695   
696     if (sRes == 0)
697     {
698       x++;
699     }
700   
701     int y1 = y, y2 = y;
702     float range = max - min;
703   
704     // //Draw origin
705     if (min < 0)
706     {
707       y2 = y - (int) ((0 - min / range) * graphHeight);
708     }
709   
710     g.setColor(Color.gray);
711     g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
712   
713     eRes = Math.min(eRes, aa.annotations.length);
714   
715     int column;
716     int aaMax = aa.annotations.length - 1;
717   
718     while (x < eRes - sRes)
719     {
720       column = sRes + x;
721       if (hasHiddenColumns)
722       {
723         column = columnSelection.adjustForHiddenColumns(column);
724       }
725   
726       if (column > aaMax)
727       {
728         break;
729       }
730   
731       if (aa.annotations[column] == null
732               || aa.annotations[column - 1] == null)
733       {
734         x++;
735         continue;
736       }
737   
738       if (aa.annotations[column].colour == null)
739         g.setColor(Color.black);
740       else
741         g.setColor(aa.annotations[column].colour);
742   
743       y1 = y
744               - (int) (((aa.annotations[column - 1].value - min) / range) * graphHeight);
745       y2 = y
746               - (int) (((aa.annotations[column].value - min) / range) * graphHeight);
747   
748       g.drawLine(x * charWidth - charWidth / 2, y1, x * charWidth
749               + charWidth / 2, y2);
750       x++;
751     }
752   
753     if (aa.threshold != null)
754     {
755       g.setColor(aa.threshold.colour);
756       Graphics2D g2 = (Graphics2D) g;
757       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
758               BasicStroke.JOIN_ROUND, 3f, new float[]
759               { 5f, 3f }, 0f));
760   
761       y2 = (int) (y - ((aa.threshold.value - min) / range) * graphHeight);
762       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
763       g2.setStroke(new BasicStroke());
764     }
765   }
766
767   public void drawBarGraph(Graphics g, AlignmentAnnotation aa, int sRes, int eRes, float min, float max, int y)
768   {
769     if (sRes > aa.annotations.length)
770     {
771       return;
772     }
773     Font ofont = g.getFont();
774     eRes = Math.min(eRes, aa.annotations.length);
775   
776     int x = 0, y1 = y, y2 = y;
777   
778     float range = max - min;
779   
780     if (min < 0)
781     {
782       y2 = y - (int) ((0 - min / (range)) * aa.graphHeight);
783     }
784   
785     g.setColor(Color.gray);
786   
787     g.drawLine(x, y2, (eRes - sRes) * charWidth, y2);
788   
789     int column;
790     int aaMax = aa.annotations.length - 1;
791     boolean renderHistogram = true, renderProfile = true, normaliseProfile=false;
792   //    if (aa.autoCalculated && aa.label.startsWith("Consensus"))
793     {
794       // TODO: generalise this to have render styles for consensus/profile data
795       if (aa.groupRef != null)
796       {
797         renderHistogram = aa.groupRef.isShowConsensusHistogram();
798         renderProfile = aa.groupRef.isShowSequenceLogo();
799         normaliseProfile= aa.groupRef.isNormaliseSequenceLogo();
800       }
801       else
802       {
803         renderHistogram = av_renderHistogram;
804         renderProfile = av_renderProfile;
805         normaliseProfile= av_normaliseProfile;
806       }
807     }
808     while (x < eRes - sRes)
809     {
810       column = sRes + x;
811       if (hasHiddenColumns)
812       {
813         column = columnSelection.adjustForHiddenColumns(column);
814       }
815   
816       if (column > aaMax)
817       {
818         break;
819       }
820   
821       if (aa.annotations[column] == null)
822       {
823         x++;
824         continue;
825       }
826       if (aa.annotations[column].colour == null)
827         g.setColor(Color.black);
828       else
829         g.setColor(aa.annotations[column].colour);
830   
831       y1 = y
832               - (int) (((aa.annotations[column].value - min) / (range)) * aa.graphHeight);
833   
834       if (renderHistogram)
835       {
836         if (y1 - y2 > 0)
837         {
838           g.fillRect(x * charWidth, y2, charWidth, y1 - y2);
839         }
840         else
841         {
842           g.fillRect(x * charWidth, y1, charWidth, y2 - y1);
843         }
844       }
845       // draw profile if available
846       if (renderProfile && aa.annotations[column].value != 0)
847       {
848   
849         int profl[] = getProfileFor(aa, column);
850         // just try to draw the logo if profl is not null
851         if (profl != null)
852         {
853   
854           float ht = normaliseProfile ? y-aa.graphHeight : y1;
855           double htn = normaliseProfile ? aa.graphHeight : (y2 - y1);// aa.graphHeight;
856           float wdth;
857           double ht2 = 0;
858           char[] dc;
859   
860           /**
861            * profl.length == 52 indicates that the profile of a secondary
862            * structure conservation row was accesed.
863            * Therefore dc gets length 2, to have space for a basepair instead of
864            * just a single nucleotide
865            */
866           if (profl.length == 74)
867           {
868             dc = new char[2];
869           }
870           else
871           {
872             dc = new char[1];
873           }
874           LineMetrics lm=g.getFontMetrics(ofont).getLineMetrics("Q", g);
875           double scale = 1f/(normaliseProfile ? profl[1] : 100f);
876           float ofontHeight = 1f/lm.getAscent();// magnify to fill box
877           double scl=0.0;
878           for (int c = 2; profl != null && c < profl[0];)
879           {
880             dc[0] = (char) profl[c++];
881   
882             if (aa.label.startsWith("StrucConsensus"))
883             {
884               dc[1] = (char) profl[c++];
885             }
886             
887             wdth = charWidth;
888             wdth /= (float) fm.charsWidth(dc, 0, dc.length);
889             
890             ht +=  scl;
891             {
892               // if (aa.annotations[column].value==0) {
893               // g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance(wdth,
894               // (ht2=(aa.graphHeight*0.1/av.charHeight)))));
895               // ht = y2-(int)ht2;
896               // } else {
897               scl=((double)htn)*scale* ((double) profl[c++]);
898               lm = ofont.getLineMetrics(dc, 0, 1, g.getFontMetrics().getFontRenderContext());
899               g.setFont(ofont.deriveFont(AffineTransform.getScaleInstance(
900                       wdth, scl/lm.getAscent())));
901               lm = g.getFontMetrics().getLineMetrics(dc, 0, 1, g);
902               
903               // htn -=ht2;
904               // }
905               // ? );// try to get a
906               // colourscheme for the
907               // group(aa.groupRef.cs==null)
908               // ? av.textColour2 :
909               // cs.findColour(dc));
910               // System.out.println(dc[0]);
911               // Debug - render boxes around characters
912               // g.setColor(Color.red);
913               // g.drawRect(x*av.charWidth, (int)ht, av.charWidth, (int)(scl));
914               // g.setColor(profcolour.findColour(dc[0]).darker());
915               g.setColor(profcolour.findColour(dc[0]));
916               // (av.globalColourScheme!=null)
917               g.drawChars(dc, 0, dc.length, x * charWidth,
918                       (int) (ht + (scl-lm.getDescent()-lm.getBaselineOffsets()[lm.getBaselineIndex()])));
919               // ht+=g.getFontMetrics().getAscent()-g.getFontMetrics().getDescent();
920             }
921           }
922           g.setFont(ofont);
923         }
924       }
925       x++;
926     }
927     if (aa.threshold != null)
928     {
929       g.setColor(aa.threshold.colour);
930       Graphics2D g2 = (Graphics2D) g;
931       g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
932               BasicStroke.JOIN_ROUND, 3f, new float[]
933               { 5f, 3f }, 0f));
934   
935       y2 = (int) (y - ((aa.threshold.value - min) / range) * aa.graphHeight);
936       g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
937       g2.setStroke(new BasicStroke());
938     }
939   }
940   // used by overview window
941   public void drawGraph(Graphics g, AlignmentAnnotation aa, int width,
942           int y, int sRes, int eRes)
943   {
944     eRes = Math.min(eRes, aa.annotations.length);
945     g.setColor(Color.white);
946     g.fillRect(0, 0, width, y);
947     g.setColor(new Color(0, 0, 180));
948
949     int x = 0, height;
950
951     for (int j = sRes; j < eRes; j++)
952     {
953       if (aa.annotations[j] != null)
954       {
955         if (aa.annotations[j].colour == null)
956           g.setColor(Color.black);
957         else
958           g.setColor(aa.annotations[j].colour);
959
960         height = (int) ((aa.annotations[j].value / aa.graphMax) * y);
961         if (height > y)
962         {
963           height = y;
964         }
965
966         g.fillRect(x, y - height, charWidth, height);
967       }
968       x += charWidth;
969     }
970   }
971 }